动态代理总结,面试你要知道的都在这里,无废话!

开发 前端
代理模式是一种设计模式,提供了对目标对象额外的访问方式,即通过代理对象访问目标对象,这样可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能。

[[399678]]

本文转载自微信公众号「月伴飞鱼」,作者日常加油站。转载本文请联系月伴飞鱼公众号。

代理模式

代理模式是一种设计模式,提供了对目标对象额外的访问方式,即通过代理对象访问目标对象,这样可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能

一个比方:在租房的时候,有的人会通过房东直租,有的人会通过中介租房。

这两种情况哪种比较方便呢?当然是通过中介更加方便。

这里的中介就相当于代理,用户通过中介完成租房的一系列操作(看房、交押金、租房、清扫卫生)代理模式可以有效的将具体的实现与调用方进行解耦,通过面向接口进行编码完全将具体的实现隐藏在内部。

分类:

静态代理: 在编译时就已经实现,编译完成后代理类是一个实际的class文件

动态代理: 在运行时动态生成的,即编译完成后没有实际的class文件,而是在运行时动态生成类字节码,并加载到JVM中

静态代理

使用方式

创建一个接口,然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类,同时使其也实现这个接口。在代理类中持有一个被代理对象的引用,而后在代理类方法中调用该对象的方法。

  1. public interface UserDao {     
  2.   void save();      
  1. public class UserDaoImpl implements UserDao { 
  2.     @Override 
  3.     public void save() { 
  4.         System.out.println("正在保存用户..."); 
  5.     } 
  1. public class TransactionHandler implements UserDao { 
  2.     //目标代理对象 
  3.     private UserDao target; 
  4.     //构造代理对象时传入目标对象 
  5.     public TransactionHandler(UserDao target) { 
  6.         this.target = target; 
  7.     } 
  8.     @Override 
  9.     public void save() { 
  10.         //调用目标方法前的处理 
  11.         System.out.println("开启事务控制..."); 
  12.         //调用目标对象的方法 
  13.         target.save(); 
  14.         //调用目标方法后的处理 
  15.         System.out.println("关闭事务控制..."); 
  16.     } 
  1. public class Main { 
  2.     public static void main(String[] args) { 
  3.         //新建目标对象 
  4.         UserDaoImpl target = new UserDaoImpl(); 
  5.         //创建代理对象, 并使用接口对其进行引用 
  6.         UserDao userDao = new TransactionHandler(target); 
  7.         //针对接口进行调用 
  8.         userDao.save(); 
  9.     } 

使用JDK静态代理很容易就完成了对一个类的代理操作。但是JDK静态代理的缺点也暴露了出来:由于代理只能为一个类服务,如果需要代理的类很多,那么就需要编写大量的代理类,比较繁琐

JDK动态代理

使用JDK动态代理的五大步骤:

  1. 通过实现InvocationHandler接口来自定义自己的InvocationHandler;
  2. 通过Proxy.getProxyClass获得动态代理类;
  3. 通过反射机制获得代理类的构造方法,方法签名为getConstructor(InvocationHandler.class);
  4. 通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入;
  5. 通过代理对象调用目标方法;
  1. public interface IHello { 
  2.     void sayHello(); 
  1. public class HelloImpl implements IHello { 
  2.    @Override 
  3.    public void sayHello() { 
  4.        System.out.println("Hello world!"); 
  5.    } 
  1. import java.lang.reflect.InvocationHandler; 
  2. import java.lang.reflect.Method; 
  3.   
  4. public class MyInvocationHandler implements InvocationHandler { 
  5.   
  6.     /** 目标对象 */ 
  7.     private Object target; 
  8.   
  9.     public MyInvocationHandler(Object target){ 
  10.         this.target = target; 
  11.     } 
  12.   
  13.     @Override 
  14.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  15.         System.out.println("------插入前置通知代码-------------"); 
  16.         // 执行相应的目标方法 
  17.         Object rs = method.invoke(target,args); 
  18.         System.out.println("------插入后置处理代码-------------"); 
  19.         return rs; 
  20.     } 
  1. import java.lang.reflect.Constructor; 
  2. import java.lang.reflect.InvocationHandler; 
  3. import java.lang.reflect.InvocationTargetException; 
  4. import java.lang.reflect.Proxy; 
  5.  
  6. public class MyProxyTest { 
  7.     public static void main(String[] args) 
  8.             throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException { 
  9.         // =========================第一种========================== 
  10.         // 1、生成$Proxy0的class文件 
  11.         System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles""true"); 
  12.         // 2、获取动态代理类 
  13.         Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class); 
  14.         // 3、获得代理类的构造函数,并传入参数类型InvocationHandler.class 
  15.         Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class); 
  16.         // 4、通过构造函数来创建动态代理对象,将自定义的InvocationHandler实例传入 
  17.         IHello iHello1 = (IHello) constructor.newInstance(new MyInvocationHandler(new HelloImpl())); 
  18.         // 5、通过代理对象调用目标方法 
  19.         iHello1.sayHello(); 
  20.   
  21.         // ==========================第二种============================= 
  22.         /** 
  23.          * Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象, 
  24.          *其方法签名为:newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h) 
  25.          */ 
  26.         IHello  iHello2 = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), // 加载接口的类加载器 
  27.                 new Class[]{IHello.class}, // 一组接口 
  28.                 new MyInvocationHandler(new HelloImpl())); // 自定义的InvocationHandler 
  29.         iHello2.sayHello(); 
  30.     } 

JDK静态代理与JDK动态代理之间有些许相似,比如说都要创建代理类,以及代理类都要实现接口等。

不同之处: 在静态代理中我们需要对哪个接口和哪个被代理类创建代理类,所以我们在编译前就需要代理类实现与被代理类相同的接口,并且直接在实现的方法中调用被代理类相应的方法;但是动态代理则不同,我们不知道要针对哪个接口、哪个被代理类创建代理类,因为它是在运行时被创建的。

一句话来总结一下JDK静态代理和JDK动态代理的区别:

JDK静态代理是通过直接编码创建的,而JDK动态代理是利用反射机制在运行时创建代理类的。

其实在动态代理中,核心是InvocationHandler。每一个代理的实例都会有一个关联的调用处理程序(InvocationHandler)。对待代理实例进行调用时,将对方法的调用进行编码并指派到它的调用处理器(InvocationHandler)的invoke方法

对代理对象实例方法的调用都是通过InvocationHandler中的invoke方法来完成的,而invoke方法会根据传入的代理对象、方法名称以及参数决定调用代理的哪个方法。

CGLIB

CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM,来转换字节码并生成新的类

CGLIB代理实现如下:

首先实现一个MethodInterceptor,方法调用会被转发到该类的intercept()方法。

然后在需要使用的时候,通过CGLIB动态代理获取代理对象。

使用案例

  1.  public class HelloService { 
  2.   
  3.     public HelloService() { 
  4.         System.out.println("HelloService构造"); 
  5.     } 
  6.   
  7.     /** 
  8.      * 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的 
  9.      */ 
  10.     final public String sayOthers(String name) { 
  11.         System.out.println("HelloService:sayOthers>>"+name); 
  12.         return null
  13.     } 
  14.   
  15.     public void sayHello() { 
  16.         System.out.println("HelloService:sayHello"); 
  17.     } 
  1. import net.sf.cglib.proxy.MethodInterceptor; 
  2. import net.sf.cglib.proxy.MethodProxy; 
  3.   
  4. import java.lang.reflect.Method; 
  5.   
  6. /** 
  7.  * 自定义MethodInterceptor 
  8.  */ 
  9. public class MyMethodInterceptor implements MethodInterceptor{ 
  10.   
  11.     /** 
  12.      * sub:cglib生成的代理对象 
  13.      * method:被代理对象方法 
  14.      * objects:方法入参 
  15.      * methodProxy: 代理方法 
  16.      */ 
  17.     @Override 
  18.     public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
  19.         System.out.println("======插入前置通知======"); 
  20.         Object object = methodProxy.invokeSuper(sub, objects); 
  21.         System.out.println("======插入后者通知======"); 
  22.         return object; 
  23.     } 
  1. import net.sf.cglib.core.DebuggingClassWriter; 
  2. import net.sf.cglib.proxy.Enhancer; 
  3.   
  4. public class Client { 
  5.     public static void main(String[] args) { 
  6.         // 代理类class文件存入本地磁盘方便我们反编译查看源码 
  7.         System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code"); 
  8.         // 通过CGLIB动态代理获取代理对象的过程 
  9.         Enhancer enhancer = new Enhancer(); 
  10.         // 设置enhancer对象的父类 
  11.         enhancer.setSuperclass(HelloService.class); 
  12.         // 设置enhancer的回调对象 
  13.         enhancer.setCallback(new MyMethodInterceptor()); 
  14.         // 创建代理对象 
  15.         HelloService proxy= (HelloService)enhancer.create(); 
  16.         // 通过代理对象调用目标方法 
  17.         proxy.sayHello(); 
  18.     } 

JDK代理要求被代理的类必须实现接口,有很强的局限性。

而CGLIB动态代理则没有此类强制性要求。简单的说,CGLIB会让生成的代理类继承被代理类,并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。

总结一下CGLIB在进行代理的时候都进行了哪些工作

  • 生成的代理类继承被代理类。在这里我们需要注意一点:如果委托类被final修饰,那么它不可被继承,即不可被代理;同样,如果委托类中存在final修饰的方法,那么该方法也不可被代理
  • 代理类会为委托方法生成两个方法,一个是与委托方法签名相同的方法,它在方法中会通过super调用委托方法;另一个是代理类独有的方法
  • 当执行代理对象的方法时,会首先判断一下是否存在实现了MethodInterceptor接口的CGLIB$CALLBACK_0;,如果存在,则将调用MethodInterceptor中的intercept方法

在intercept方法中,我们除了会调用委托方法,还会进行一些增强操作。在Spring AOP中,典型的应用场景就是在某些敏感方法执行前后进行操作日志记录

在CGLIB中,方法的调用并不是通过反射来完成的,而是直接对方法进行调用:通过FastClass机制对Class对象进行特别的处理,比如将会用数组保存method的引用,每次调用方法的时候都是通过一个index下标来保持对方法的引用

Fastclass机制

CGLIB采用了FastClass的机制来实现对被拦截方法的调用。

FastClass机制就是对一个类的方法建立索引,通过索引来直接调用相应的方法

  1. public class test10 { 
  2.   //这里,tt可以看作目标对象,fc可以看作是代理对象;首先根据代理对象的getIndex方法获取目标方法的索引, 
  3.   //然后再调用代理对象的invoke方法就可以直接调用目标类的方法,避免了反射 
  4.     public static void main(String[] args){ 
  5.         Test tt = new Test(); 
  6.         Test2 fc = new Test2(); 
  7.         int index = fc.getIndex("f()V"); 
  8.         fc.invoke(index, tt, null); 
  9.     } 
  10.  
  11. class Test{ 
  12.     public void f(){ 
  13.         System.out.println("f method"); 
  14.     } 
  15.      
  16.     public void g(){ 
  17.         System.out.println("g method"); 
  18.     } 
  19. class Test2{ 
  20.     public Object invoke(int index, Object o, Object[] ol){ 
  21.         Test t = (Test) o; 
  22.         switch(index){ 
  23.         case 1: 
  24.             t.f(); 
  25.             return null
  26.         case 2: 
  27.             t.g(); 
  28.             return null
  29.         } 
  30.         return null
  31.     } 
  32.     //这个方法对Test类中的方法建立索引 
  33.     public int getIndex(String signature){ 
  34.         switch(signature.hashCode()){ 
  35.         case 3078479: 
  36.             return 1; 
  37.         case 3108270: 
  38.             return 2; 
  39.         } 
  40.         return -1; 
  41.     } 

上例中,Test2是Test的Fastclass,在Test2中有两个方法getIndex和invoke。

在getIndex方法中对Test的每个方法建立索引,并根据入参(方法名+方法的描述符)来返回相应的索引。

Invoke根据指定的索引,以ol为入参调用对象O的方法。这样就避免了反射调用,提高了效率

三种代理方式之间对比

 

 

代理方式 实现 优点 缺点 特点
JDK静态代理 代理类与委托类实现同一接口,并且在代理类中需要硬编码接口 实现简单,容易理解 代理类需要硬编码接口,在实际应用中可能会导致重复编码,浪费存储空间并且效率很低 好像没啥特点
JDK动态代理 代理类与委托类实现同一接口,主要是通过代理类实现InvocationHandler并重写invoke方法来进行动态代理的,在invoke方法中将对方法进行增强处理 不需要硬编码接口,代码复用率高 只能够代理实现了接口的委托类 底层使用反射机制进行方法的调用
CGLIB动态代理 代理类将委托类作为自己的父类并为其中的非final委托方法创建两个方法,一个是与委托方法签名相同的方法,它在方法中会通过super调用委托方法;另一个是代理类独有的方法。在代理方法中,它会判断是否存在实现了MethodInterceptor接口的对象,若存在则将调用intercept方法对委托方法进行代理 可以在运行时对类或者是接口进行增强操作,且委托类无需实现接口 不能对final类以及final方法进行代理 底层将方法全部存入一个数组中,通过数组索引直接进行方法调用

 

问题

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

 

责任编辑:武晓燕 来源: 月伴飞鱼
相关推荐

2021-12-09 08:16:40

JVM参数系统

2020-06-02 07:00:00

会话安全黑客攻击

2017-08-29 11:21:03

微软

2021-12-27 08:00:00

Kubernetes容器安全

2020-12-23 09:00:00

开发Web工具

2022-09-22 08:00:00

API开发数据

2021-02-01 08:39:26

JTAG接口Jlink

2020-08-12 09:32:31

小米MIUI

2021-07-01 09:00:00

安全数字化转型渗透

2019-11-04 09:07:48

DevOps互联网IT

2023-09-11 08:51:23

LinkedList双向链表线程

2021-06-17 13:40:47

区块链比特币公有链

2020-12-08 11:08:55

时间复杂度软件

2021-07-19 08:33:56

时间复杂度大O

2020-03-18 18:20:19

区块链数字货币比特币

2019-04-24 08:31:43

分布式限流kafka

2019-12-25 14:00:26

数据科学人工智能科学家

2019-07-21 08:10:21

技术研发优化

2016-03-01 16:14:32

问问应用商店Android Wea

2019-01-24 08:19:17

云服务多云云计算
点赞
收藏

51CTO技术栈公众号