java动态代理 cglib之间的关系
什么是aop?
aop(Aspect Oriented Programming)面向切面编程。是oop面向对象思想的一种补充和延续。也是Spring框架的一种重要的组件!
Spring中Aop代理是由SpringIOC容器负责生成、管理,其依赖关系也是由IOC容器负责处理的。
在Spring中,默认情况下是使用java动态代理技术来实现
当需要代理的类不是接口类型的时候,Spring会自动切换为CGLIB来进行代理,也可以强制的选择使用CGLIB来进行代理
可以看一下SpringAOP的源代码
package org.springframework.aop.framework; import java.io.Serializable; import java.lang.reflect.Proxy; import org.springframework.aop.SpringProxy; @SuppressWarnings("serial") public class DefaultAopProxyFactory implements AopProxyFactory, Serializable { @Override
//创建Aop代理 public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
//判断配置是否有效,配置中有代理类信息,判断有没有用户自己定义的解析接口 if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) { Class<?> targetClass = config.getTargetClass(); if (targetClass == null) { throw new AopConfigException("TargetSource cannot determine target class: " + "Either an interface or a target is required for proxy creation."); }
//如果是接口,或者Proxy的类,返回默认的JDK动态代理对象 if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) { return new JdkDynamicAopProxy(config); }
//配置中有用户自己指定的代理信息,则使用cglib进行代理 return new ObjenesisCglibAopProxy(config); } else { return new JdkDynamicAopProxy(config); } } private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) { Class<?>[] ifcs = config.getProxiedInterfaces(); return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]))); } }
首先从通过配置信息解析有没有指定的解析方法。
如果配置信息中没有的话,就使用默认的JdkDynamicAopProxy()来进行代理
好了,现在知道了Spring在什么情况下使用什么代理。下面开始深入了解一下jdk代理和cglib代理吧
动态代理是jdk1.5引进的新的技术。动态代理的类位于Java.lang.reflect包下
先举个栗子!
BookStore.java
public interface BookStore { public void addBook(); public void deleteBook(); }
还有一个实现该接口的实现类
BookStoreImpl.java
package test; public class BookStoreImpl implements BookStore { public void addBook() { System.out.println("增加图书方法。。。"); } public void deleteBook() { System.out.println("我現在要刪除一個書"); } }
BookStoreProxy.java
package test; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class BookStoreProxy implements InvocationHandler { private Object target; public Object bind(Object target) { this.target = target; return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; System.out.println("代理事务开始啦"); result = method.invoke(target, args); System.out.println("代理事务结束啦"); return result; } }
测试一下
package test; public class TestProxy { public static void main(String[] args) { BookStoreProxy proxy = new BookStoreProxy(); BookStore bs = (BookStore) proxy.bind(new BookStoreImpl()); bs.addBook(); System.out.println("-------------------"); bs.deleteBook(); } }
输出结果
代理事务开始啦 增加图书方法。。。 代理事务结束啦 ------------------- 代理事务开始啦 我現在要刪除一個書 代理事务结束啦
从测试的过程中可以看到,我们没有改变原来的那个BookStore接口和BookStoreImpl实现类。
但是实现了方法的注入
这就是动态代理了,它的作用有以下几点
1.Proxy类的代码量可以降下来,不会因为业务的增大而庞大起来
2.可以实现aop编程,虽然静态代理也可以实现
3.降低耦合性,通过参数就可以判断真实的类,不需要事先实例化,比较灵活
jdk代理很好啊,但是仔细想一下还是有缺陷啊,Proxy类只能代理接口类
所以cglib(Code generation Library)就出现了,完美的拓展了proxy的性能,它可以代理接口的和类。碉堡了
再举个栗子!
action.java
package cglib.test; public class Action { public void playGame(){ System.out.println("上班玩游戏..."); } public void smoke(){ System.out.println("上班抽烟..."); } }
ActionFactory.java
package cglib.test; public class ActionFactory { public static Action action = new Action(); public static Action getActionInstance(){ return action; } }
ActionTest.java
package cglib.test; import org.junit.Before; import org.junit.Test; public class ActionTest { @Before public void setUp() throws Exception { } @Test public void test() { Action action = ActionFactory.getActionInstance(); action.playGame(); action.smoke(); } }
好了,运行没有问题。playGame和smoke两个动作可以完成,但是新的需求来了
老板说,只有他能在上班的时候玩游戏!之前的类不能动!
用jdk中的动态代理当然可以实现,但是我们这没有Action的接口。要是使用jdk动态代理的话,我们还需要创建新的接口!老板说了不能动原来的类。
所以我们选用cglib
再搞一个
ActionCglibProxy.java
package cglib.test; import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; public class ActionCglibProxy implements MethodInterceptor { private String name; private Enhancer enhancer = new Enhancer(); public ActionCglibProxy(String name) { super(); this.name = name; } public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { if ("zhyonk".equals(name)) { Object result = proxy.invokeSuper(obj, args); return result; } System.out.println(name + "你不可以抽烟哦"); return null; } public Action getAction(){ enhancer.setSuperclass(Action.class); enhancer.setCallback(this); return (Action) enhancer.create(); } }
测试一下
@Test public void TestCglibAction() { ActionCglibProxy proxy = new ActionCglibProxy("老板"); Action action = proxy.getAction(); action.playGame(); action.smoke(); }
成功代理了,这个过程中没有用到接口。
通过Enhancer进行对类的注入。
getAction()返回的是原有的被代理类Action的子类
暂时就是这样啦!