什么是动态代理?(转载) | 字数总计: 2.9k | 阅读时长: 10分钟 | 阅读量:
个人博客 转载自:https://mp.weixin.qq.com/s/GT1-yrxJ5KF0xeMydbJDCQ#
1、代理模式 代理模式是一种设计模式,提供了对目标对象额外的访问方式,即通过代理对象访问目标对象,这样可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能。
一个比方:在租房的时候,有的人会通过房东直租,有的人会通过中介租房。
这两种情况哪种比较方便呢?当然是通过中介更加方便。
这里的中介就相当于代理,用户通过中介完成租房的一系列操作(看房、交押金、租房、清扫卫生)代理模式可以有效的将具体的实现与调用方进行解耦,通过面向接口进行编码完全将具体的实现隐藏在内部。
分类:
静态代理: 在编译时就已经实现,编译完成后代理类是一个实际的class文件。
动态代理: 在运行时动态生成的,即编译完成后没有实际的class文件,而是在运行时动态生成类字节码,并加载到JVM中 。
2、静态代理 使用方式
创建一个接口,然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类,同时使其也实现这个接口。在代理类中持有一个被代理对象的引用,而后在代理类方法中调用该对象的方法。
1 2 3 public interface UserDao { void save () ; }
1 2 3 4 5 6 public class UserDaoImpl implements UserDao { @Override public void save () { System.out.println("正在保存用户..." ); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class TransactionHandler implements UserDao { private UserDao target; public TransactionHandler (UserDao target) { this .target = target; } @Override public void save () { System.out.println("开启事务控制..." ); target.save(); System.out.println("关闭事务控制..." ); } }
1 2 3 4 5 6 7 8 9 10 public class Main { public static void main (String[] args) { UserDaoImpl target = new UserDaoImpl(); UserDao userDao = new TransactionHandler(target); userDao.save(); } }
使用JDK静态代理很容易就完成了对一个类的代理操作。但是JDK
静态代理的缺点也暴露了出来:由于代理只能为一个类服务,如果需要 代理的类很多,那么就需要编写大量的代理类,比较繁琐。
3、JDK动态代理 使用JDK动态代理的五大步骤:
通过实现InvocationHandler接口来自定义自己的InvocationHandler; 通过Proxy.getProxyClass
获得动态代理类; 通过反射机制获得代理类的构造方法,方法签名为getConstructor(InvocationHandler.class)
; 通过构造函数获得代理对象并将自定义的InvocationHandler
实例对象传为参数传入; 通过代理对象调用目标方法; 1 2 3 public interface IHello { void sayHello () ; }
1 2 3 4 5 6 public class HelloImpl implements IHello { @Override public void sayHello () { System.out.println("Hello world!" ); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method; public class MyInvocationHandler implements InvocationHandler { private Object target; public MyInvocationHandler (Object target) { this .target = target; } @Override public Object invoke (Object proxy, Method method, Object[] args) throws Throwable { System.out.println("------插入前置通知代码-------------" ); Object rs = method.invoke(target,args); System.out.println("------插入后置处理代码-------------" ); return rs; } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 import java.lang.reflect.Constructor;import java.lang.reflect.InvocationHandler;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Proxy;public class MyProxyTest { public static void main (String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException { System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles" , "true" ); Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class); Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class); IHello iHello1 = (IHello) constructor.newInstance(new MyInvocationHandler(new HelloImpl())); iHello1.sayHello(); IHello iHello2 = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), new Class[]{IHello.class}, new MyInvocationHandler(new HelloImpl())); iHello2.sayHello(); } }
JDK静态代理与JDK动态代理之间有些许相似,比如说都要创建代理类,以及代理类都要实现接口等。
不同之处: 在静态代理中我们需要对哪个接口和哪个被代理类创建代理类,所以我们在编译前就需要代理类实现与被代理类相同的接口,并且直接在实现的方法中调用被代理类相应的方法;但是动态代理则不同,我们不知道要针对哪个接口、哪个被代理类创建代理类,因为它是在运行时被创建的。
一句话来总结一下JDK静态代理和JDK动态代理的区别:
JDK静态代理是通过直接编码创建的,而JDK
动态代理是利用反射机制在运行时创建代理类的。
其实在动态代理中,核心是InvocationHandler
。每一个代理的实例都会有一个关联的调用处理程序(InvocationHandler)。对待代理实例进行调用时,将对方法的调用进行编码并指派到它的调用处理器(InvocationHandler)的invoke
方法。
对代理对象实例方法的调用都是通过InvocationHandler中的invoke方法来完成的,而invoke方法会根据传入的代理对象、方法名称以及参数决定调用代理的哪个方法。
4、CGLIB CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM
,来转换字节码并生成新的类。
CGLIB代理实现如下:
首先实现一个MethodInterceptor,方法调用会被转发到该类的intercept()方法。 然后在需要使用的时候,通过CGLIB动态代理获取代理对象。 使用案例
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class HelloService { public HelloService () { System.out.println("HelloService构造" ); } final public String sayOthers (String name) { System.out.println("HelloService:sayOthers>>" +name); return null ; } public void sayHello () { System.out.println("HelloService:sayHello" ); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class MyMethodInterceptor implements MethodInterceptor { @Override public Object intercept (Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { System.out.println("======插入前置通知======" ); Object object = methodProxy.invokeSuper(sub, objects); System.out.println("======插入后者通知======" ); return object; } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 import net.sf.cglib.core.DebuggingClassWriter;import net.sf.cglib.proxy.Enhancer; public class Client { public static void main (String[] args) { System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code" ); Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(HelloService.class); enhancer.setCallback(new MyMethodInterceptor()); HelloService proxy= (HelloService)enhancer.create(); proxy.sayHello(); } }
JDK代理要求被代理的类必须实现接口,有很强的局限性。
而CGLIB动态代理则没有此类强制性要求。简单的说,CGLIB
会让生成的代理类继承被代理类,并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。
总结一下CGLIB在进行代理的时候都进行了哪些工作
生成的代理类继承被代理类。在这里我们需要注意一点:如果委托类被final修饰,那么它不可被继承,即不可被代理;同样,如果委托类中存在final修饰的方法,那么该方法也不可被代理。 代理类会为委托方法生成两个方法,一个是与委托方法签名相同的方法,它在方法中会通过super
调用委托方法;另一个是代理类独有的方法。 当执行代理对象的方法时,会首先判断一下是否存在实现了MethodInterceptor
接口的CGLIB$CALLBACK_0
;,如果存在,则将调用MethodInterceptor
中的intercept
方法。 在intercept
方法中,我们除了会调用委托方法,还会进行一些增强操作。在Spring AOP中,典型的应用场景就是在某些敏感方法执行前后进行操作日志记录。
在CGLIB中,方法的调用并不是通过反射来完成的,而是直接对方法进行调用:通过FastClass机制 对Class对象进行特别的处理,比如将会用数组保存method的引用,每次调用方法的时候都是通过一个index下标来保持对方法的引用。
5、Fastclass机制 CGLIB采用了FastClass的机制来实现对被拦截方法的调用。
FastClass机制就是对一个类的方法建立索引,通过索引来直接调用相应的方法。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 public class test10 { public static void main (String[] args) { Test tt = new Test(); Test2 fc = new Test2(); int index = fc.getIndex("f()V" ); fc.invoke(index, tt, null ); } } class Test { public void f () { System.out.println("f method" ); } public void g () { System.out.println("g method" ); } } class Test2 { public Object invoke (int index, Object o, Object[] ol) { Test t = (Test) o; switch (index){ case 1 : t.f(); return null ; case 2 : t.g(); return null ; } return null ; } public int getIndex (String signature) { switch (signature.hashCode()){ case 3078479 : return 1 ; case 3108270 : return 2 ; } return -1 ; } }
上例中,Test2是Test的Fastclass,在Test2中有两个方法getIndex和invoke。
在getIndex方法中对Test的每个方法建立索引,并根据入参(方法名+方法的描述符)来返回相应的索引。
Invoke根据指定的索引,以ol为入参调用对象O的方法。这样就避免了反射调用,提高了效率。
三种代理方式之间对比
6、问题 CGlib比JDK快?
使用CGLiB实现动态代理,CGLib底层采用ASM字节码生成框架,使用字节码技术生成代理类, 在jdk6之前比使用Java反射效率要高。唯一需要注意的是,CGLib不能对声明为final的方法进行代理, 因为CGLib原理是动态生成被代理类的子类。 在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后,在调用次数较少的情况下,JDK代理效率高于CGLIB代理效率。只有当进行大量调用的时候,jdk6和jdk7比CGLIB代理效率低一点,但是到jdk8的时候,jdk代理效率高于CGLIB代理,总之,每一次jdk版本升级,jdk代理效率都得到提升,而CGLIB代理消息确有点跟不上步伐。 Spring如何选择用JDK还是CGLIB?
当Bean实现接口时,Spring就会用JDK的动态代理。 当Bean没有实现接口时,Spring使用CGlib实现。 可以强制使用CGlib。