文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

面试官提问：什么是动态代理？

2024-12-02 14:45

关注

一、介绍

何谓代理?

据史料记载，代理这个词最早出现在代理商这个行业，所谓代理商，简而言之，其实就是帮助企业或者老板打理生意，自己本身不做生产任何商品。

举个例子，我们去火车站买票的时候，人少老板一个人还忙的过来，但是人一多的话，就会非常拥挤，于是就有了各种代售点，我们可以从代售点买车票，从而加快老板的卖票速度。

代售点的出现，可以说，很直观的帮助老板提升了用户购票体验。

站在软件设计的角度，其实效果也是一样的，采用代理模式的编程，能显著的增强原有的功能和简化方法调用方式。

在介绍动态代理之前，我们先来聊解静态代理。

二、静态代理

下面，我们以两数相加为例，实现过程如下!

接口类

  1. public interface Calculator { 
  2.  
  3.      
  4.     Integer add(Integer num1, Integer num2); 
  5. } 

目标对象

  1. public class CalculatorImpl implements Calculator { 
  2.  
  3.  
  4.     @Override 
  5.     public Integer add(Integer num1, Integer num2) { 
  6.         Integer result = num1 + num2; 
  7.         return result; 
  8.     } 
  9. } 

代理对象

  1. public class CalculatorProxyImpl implements Calculator { 
  2.  
  3.  
  4.     private Calculator calculator; 
  5.  
  6.  
  7.     @Override 
  8.     public Integer add(Integer num1, Integer num2) { 
  9.         //方法调用前，可以添加其他功能.... 
  10.         Integer result = calculator.add(num1, num2); 
  11.         //方法调用后，可以添加其他功能.... 
  12.         return result; 
  13.     } 
  14.  
  15.  
  16.     public CalculatorProxyImpl(Calculator calculator) { 
  17.         this.calculator = calculator; 
  18.     } 
  19. } 

测试类

  1. public class CalculatorProxyClient { 
  2.  
  3.     public static void main(String[] args) { 
  4.         //目标对象 
  5.         Calculator target = new CalculatorImpl(); 
  6.         //代理对象 
  7.         Calculator proxy = new CalculatorProxyImpl(target); 
  8.         Integer result = proxy.add(1,2); 
  9.         System.out.println("相加结果：" + result); 
  10.     } 
  11. } 

输出结果

  1. 相加结果：3 

通过这种代理方式，最大的优点就是：可以在不修改目标对象的前提下，扩展目标对象的功能。

但也有缺点：需要代理对象和目标对象实现一样的接口，因此，当目标对象扩展新的功能时，代理对象也要跟着一起扩展，不易维护!

三、动态代理

动态代理，其实本质也是为了解决上面当目标对象扩展新功能时，代理对象也需要跟着一起扩展的痛点问题而生。

那它是怎么解决的呢?

以 JDK 为例，当需要给某个目标对象添加代理处理的时候，JDK 会在内存中动态的构建代理对象，从而实现对目标对象的代理功能。

下面，我们还是以两数相加为例，介绍具体的玩法!

3.1、JDK 中生成代理对象的玩法

创建接口

  1. public interface JdkCalculator { 
  2.  
  3.      
  4.     Integer add(Integer num1, Integer num2); 
  5. } 

目标对象

  1. public class JdkCalculatorImpl implements JdkCalculator { 
  2.  
  3.     @Override 
  4.     public Integer add(Integer num1, Integer num2) { 
  5.         Integer result = num1 + num2; 
  6.         return result; 
  7.     } 
  8. } 

动态代理对象

  1. public class JdkProxyFactory { 
  2.  
  3.      
  4.     private Object target; 
  5.  
  6.     public JdkProxyFactory(Object target) { 
  7.         this.target = target; 
  8.     } 
  9.  
  10.     public Object getProxyInstance(){ 
  11.         Object proxyClassObj = Proxy.newProxyInstance(target.getClass().getClassLoader(), 
  12.                 target.getClass().getInterfaces(), 
  13.                 new InvocationHandler(){ 
  14.  
  15.                     @Override 
  16.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  17.                         System.out.println("方法调用前，可以添加其他功能...."); 
  18.  
  19.                         // 执行目标对象方法 
  20.                         Object returnValue = method.invoke(target, args); 
  21.                         System.out.println("方法调用后，可以添加其他功能...."); 
  22.                         return returnValue; 
  23.                     } 
  24.                 }); 
  25.         return proxyClassObj; 
  26.     } 
  27. } 

测试类

  1. public class TestJdkProxy { 
  2.  
  3.     public static void main(String[] args) { 
  4.         //目标对象 
  5.         JdkCalculator target = new JdkCalculatorImpl(); 
  6.         System.out.println(target.getClass()); 
  7.         //代理对象 
  8.         JdkCalculator proxyClassObj = (JdkCalculator) new JdkProxyFactory(target).getProxyInstance(); 
  9.         System.out.println(proxyClassObj.getClass()); 
  10.         //执行代理方法 
  11.         Integer result = proxyClassObj.add(1,2); 
  12.         System.out.println("相加结果：" + result); 
  13.     } 
  14. } 

输出结果

  1. class com.example.java.proxy.jdk1.JdkCalculatorImpl 
  2. class com.sun.proxy.$Proxy0 
  3. 方法调用前，可以添加其他功能.... 
  4. 方法调用后，可以添加其他功能.... 
  5. 相加结果：3 

采用 JDK 技术动态创建interface实例的步骤如下：

  1. 1. 首先定义一个 InvocationHandler 实例，它负责实现接口的方法调用 
  2. 2. 通过 Proxy.newProxyInstance() 创建 interface 实例，它需要 3 个参数: 
  3.    （1）使用的 ClassLoader，通常就是接口类的 ClassLoader 
  4.    （2）需要实现的接口数组，至少需要传入一个接口进去； 
  5.    （3）用来处理接口方法调用的 InvocationHandler 实例。 
  6. 3. 将返回的 Object 强制转型为接口 

动态代理实际上是 JVM 在运行期动态创建class字节码并加载的过程，它并没有什么黑魔法技术，把上面的动态代理改写为静态实现类大概长这样：

  1. public class JdkCalculatorDynamicProxy implements JdkCalculator { 
  2.  
  3.     private InvocationHandler handler; 
  4.  
  5.     public JdkCalculatorDynamicProxy(InvocationHandler handler) { 
  6.         this.handler = handler; 
  7.     } 
  8.  
  9.     public void add(Integer num1, Integer num2) { 
  10.         handler.invoke( 
  11.            this, 
  12.            JdkCalculator.class.getMethod("add", Integer.class, Integer.class), 
  13.            new Object[] { num1, num2 }); 
  14.     } 
  15. } 

本质就是 JVM 帮我们自动编写了一个上述类(不需要源码，可以直接生成字节码)。

3.2、cglib 生成代理对象的玩法

除了 jdk 能实现动态的创建代理对象以外，还有一个非常有名的第三方框架：cglib，它也可以做到运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib 特点如下：

cglib 不仅可以代理接口还可以代理类，而 JDK 的动态代理只能代理接口

cglib 是一个强大的高性能的代码生成包，它广泛的被许多 AOP 的框架使用，例如我们所熟知的 Spring AOP，cglib 为他们提供方法的 interception(拦截)。

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

在使用 cglib 之前，我们需要添加依赖包，如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

  1.  
  2.     cglib 
  3.     cglib 
  4.     3.2.5 
  5.  

 

下面，我们还是以两数相加为例，介绍具体的玩法!

  1. public interface CglibCalculator { 
  2.  
  3.      
  4.     Integer add(Integer num1, Integer num2); 
  5. } 

目标对象

  1. public class CglibCalculatorImpl implements CglibCalculator { 
  2.  
  3.  
  4.     @Override 
  5.     public Integer add(Integer num1, Integer num2) { 
  6.         Integer result = num1 + num2; 
  7.         return result; 
  8.     } 
  9. } 

动态代理对象

  1. public class CglibProxyFactory implements MethodInterceptor { 
  2.  
  3.      
  4.     private Object target; 
  5.  
  6.     public CglibProxyFactory(Object target) { 
  7.         this.target = target; 
  8.     } 
  9.  
  10.      
  11.     public Object getProxyInstance() { 
  12.         //工具类 
  13.         Enhancer en = new Enhancer(); 
  14.         //设置父类 
  15.         en.setSuperclass(target.getClass()); 
  16.         //设置回调函数 
  17.         en.setCallback(this); 
  18.         //创建子类对象代理 
  19.         return en.create(); 
  20.     } 
  21.  
  22.     @Override 
  23.     public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { 
  24.         System.out.println("方法调用前，可以添加其他功能...."); 
  25.  
  26.         // 执行目标对象方法 
  27.         Object returnValue = method.invoke(target, args); 
  28.         System.out.println("方法调用后，可以添加其他功能...."); 
  29.         return returnValue; 
  30.     } 
  31. } 

测试类

  1. public class TestCglibProxy { 
  2.  
  3.     public static void main(String[] args) { 
  4.         //目标对象 
  5.         CglibCalculator target = new CglibCalculatorImpl(); 
  6.         System.out.println(target.getClass()); 
  7.         //代理对象 
  8.         CglibCalculator proxyClassObj = (CglibCalculator) new CglibProxyFactory(target).getProxyInstance(); 
  9.         System.out.println(proxyClassObj.getClass()); 
  10.         //执行代理方法 
  11.         Integer result = proxyClassObj.add(1,2); 
  12.         System.out.println("相加结果：" + result); 
  13.     } 
  14. } 

输出结果

  1. class com.example.java.proxy.cglib1.CglibCalculatorImpl 
  2. class com.example.java.proxy.cglib1.CglibCalculatorImpl$$EnhancerByCGLIB$$3ceadfe4 
  3. 方法调用前，可以添加其他功能.... 
  4. 方法调用后，可以添加其他功能.... 
  5. 相加结果：3 

将 cglib 生成的代理类改写为静态实现类大概长这样：

  1. public class CglibCalculatorImplByCGLIB extends CglibCalculatorImpl implements Factory { 
  2.      
  3.  
  4.     private static final MethodInterceptor methodInterceptor; 
  5.  
  6.     private static final Method method; 
  7.          
  8.  
  9.     public final Integer add(Integer var1, Integer var2) { 
  10.         return methodInterceptor.intercept(this, method, new Object[]{var1, var2}, methodProxy); 
  11.     } 
  12.  
  13.     //.... 
  14. } 

其中，拦截思路与 JDK 类似，都是通过一个接口方法进行拦截处理!

在上文中咱们还介绍到了，cglib 不仅可以代理接口还可以代理类，下面我们试试代理类。

  1. public class CglibCalculatorClass { 
  2.  
  3.      
  4.     public Integer add(Integer num1, Integer num2) { 
  5.         Integer result = num1 + num2; 
  6.         return result; 
  7.     } 
  8. } 

测试类

  1. public class TestCglibProxyClass { 
  2.  
  3.     public static void main(String[] args) { 
  4.         //目标对象 
  5.         CglibCalculatorClass target = new CglibCalculatorClass(); 
  6.         System.out.println(target.getClass()); 
  7.         //代理对象 
  8.         CglibCalculatorClass proxyClassObj = (CglibCalculatorClass) new CglibProxyFactory(target).getProxyInstance(); 
  9.         System.out.println(proxyClassObj.getClass()); 
  10.         //执行代理方法 
  11.         Integer result = proxyClassObj.add(1,2); 
  12.         System.out.println("相加结果：" + result); 
  13.     } 
  14. } 

输出结果

  1. class com.example.java.proxy.cglib1.CglibCalculatorClass 
  2. class com.example.java.proxy.cglib1.CglibCalculatorClass$$EnhancerByCGLIB$$e68ff36c 
  3. 方法调用前，可以添加其他功能.... 
  4. 方法调用后，可以添加其他功能.... 
  5. 相加结果：3 

四、静态织入

在上文中，我们介绍的代理方案都是在代码运行时动态的生成class文件达到动态代理的目的。

回到问题的本质，其实动态代理的技术目的，主要为了解决静态代理模式中当目标接口发生了扩展，代理类也要跟着一遍变动的问题，避免造成了工作伤的繁琐和复杂。

在 Java 生态里面，还有一个非常有名的第三方代理框架，那就是AspectJ，AspectJ通过特定的编译器可以将目标类编译成class字节码的时候，在方法周围加上业务逻辑，从而达到静态代理的效果。

采用AspectJ进行方法植入，主要有四种：

使用起来也非常简单，首先是在项目中添加AspectJ编译器插件。

  1.  
  2.     org.codehaus.mojo 
  3.     aspectj-maven-plugin 
  4.     1.5 
  5.      
  6.          
  7.              
  8.                 compile 
  9.                 test-compile 
  10.              
  11.          
  12.      
  13.      
  14.         1.6 
  15.         1.6 
  16.         UTF-8 
  17.         1.6 
  18.         true 
  19.         true 
  20.      
  21.  

 

 

然后，编写一个方法，准备进行代理。

  1. @RequestMapping({"/hello"}) 
  2. public String hello(String name) { 
  3.     String result = "Hello World"; 
  4.     System.out.println(result); 
  5.     return result; 
  6. } 

编写代理配置类

  1. @Aspect 
  2. public class ControllerAspect { 
  3.  
  4.      
  5.     @Pointcut("execution(* com.example.demo.web..*.*(..))") 
  6.     public void methodAspect(){} 
  7.  
  8.      
  9.     @Before("methodAspect()") 
  10.     public void before(){ 
  11.         System.out.println("代理 -> 调用方法执行之前......"); 
  12.     } 
  13.  
  14.      
  15.     @After("methodAspect()") 
  16.     public void after(){ 
  17.         System.out.println("代理 -> 调用方法执行之后......"); 
  18.     } 
  19.  
  20.      
  21.     @AfterReturning("methodAspect()") 
  22.     public void afterReturning(){ 
  23.         System.out.println("代理 -> 调用方法结束之后......"); 
  24.     } 
  25.  
  26.      
  27.     @AfterThrowing("methodAspect()") 
  28.     public void afterThrowing() { 
  29.         System.out.println("代理 -> 调用方法异常......"); 
  30.     } 
  31. } 

编译后，hello方法会变成这样。

  1. @RequestMapping({"/hello"}) 
  2. public String hello(Integer name) throws SQLException { 
  3.     JoinPoint var2 = Factory.makeJP(ajc$tjp_0, this, this, name); 
  4.  
  5.     Object var7; 
  6.     try { 
  7.         Object var5; 
  8.         try { 
  9.             //调用before 
  10.             Aspectj.aspectOf().doBeforeTask2(var2); 
  11.             String result = "Hello World"; 
  12.             System.out.println(result); 
  13.             var5 = result; 
  14.         } catch (Throwable var8) { 
  15.             Aspectj.aspectOf().after(var2); 
  16.             throw var8; 
  17.         } 
  18.         //调用after 
  19.         Aspectj.aspectOf().after(var2); 
  20.         var7 = var5; 
  21.     } catch (Throwable var9) { 
  22.         //调用抛出异常 
  23.         Aspectj.aspectOf().afterthrowing(var2); 
  24.         throw var9; 
  25.     } 
  26.     //调用return 
  27.     Aspectj.aspectOf().afterRutuen(var2); 
  28.     return (String)var7; 
  29. } 

很显然，代码被AspectJ编译器修改了，AspectJ并不是动态的在运行时生成代理类，而是在编译的时候就植入代码到class文件。

由于是静态织入的，所以性能相对来说比较好!

五、小结

看到上面的介绍静态织入方案，跟我们现在使用Spring AOP的方法极其相似，可能有的同学会发出疑问，我们现在使用的Spring AOP动态代理，到底是动态生成的还是静态织入的呢?

实际上，Spring AOP代理是对JDK代理和CGLIB代理做了一层封装，同时引入了AspectJ中的一些注解@pointCut、@after，@before等等，本质是使用的动态代理技术。

总结起来就三点：

如果目标是接口的话，默认使用 JDK 的动态代理技术;

如果目标是类的话，使用 cglib 的动态代理技术;

引入了AspectJ中的一些注解@pointCut、@after，@before，主要是为了简化使用，跟AspectJ的关系并不大;

那为什么Spring AOP不使用AspectJ这种静态织入方案呢?

虽然AspectJ编译器非常强，性能非常高，但是只要目标类发生了修改就需要重新编译，主要原因可能还是AspectJ的编译器太过于复杂，还不如动态代理来的省心!

六、参考

Java三种代理模式：静态代理、动态代理和cglib代理

 

Java 动态代理作用是什么?

 

来源： Java极客技术内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

面试官提问：什么是动态代理？

后端开发面试动态2024-12-02

面试官：为什么JDK动态代理只能代理接口？

后端开发JDK动态代理2024-11-30

面试官提问：什么是前缀索引？

后端开发数据库索引2024-12-01

面试官问 async、await 函数原理是在问什么？

后端开发asynawait2024-12-02

被面试官问住了，MySQL两阶段提交是什么鬼？

后端开发MySQL数据库2024-12-13

动态ip代理是什么

后端开发2023-06-25

面试官问我：分布式事务是什么？

后端开发分布式事务2024-12-03

面试官问：synchronized为什么是重量级锁？

后端开发重量级锁2024-11-30

什么是动态代理模式

后端开发2024-04-02

java动态代理的原理是什么

后端开发2023-06-15

Java中的动态代理是什么

后端开发2023-06-02

Java动态代理是什么意思

后端开发2023-06-20

Java动态代理机制是什么

后端开发2023-06-17

Java 中的动态代理机制究竟是什么？(Java的动态代理机制是什么)

Java 中的动态代理机制究竟是什么？(Java的动态代理机制是什么)
后端开发Java2024-12-19

Java 动态代理实现的原理究竟是什么？(java动态代理实现的原理是什么)

Java 动态代理实现的原理究竟是什么？(java动态代理实现的原理是什么)
后端开发Java2024-12-14

面试官问：ThreadLocal中的键为什么是弱引用？

后端开发弱引用线程2024-11-30

Java 索引缓存是什么？面试官为什么要问这个问题？

Java 索引缓存是什么？面试官为什么要问这个问题？
后端开发2023-10-29

代理ip的动态、静态线路是什么

后端开发2023-06-25

面试官追问的STW，到底什么是STW？有什么影响？

后端开发STWJava2024-11-29

面试官：MyBatis中ResultMap的实现原理是什么？

后端开发MyBatisresultMap2024-11-29
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯