学习笔记-Java动态代理的简单使用

代理模式

• 一种设计模式
  
• 简单地说，在代理模式中存在三个角色
  
  
  
  • 用户
    
  • 代理
    
  • 被代理的对象
    
  
  
• 用户调用代理，代理去调用被代理的对象
  
• 以此来实现功能的增强
  
• 动态代理在java中有两种实现方法
  
  
  
  • JDK中的Proxy类
    
  • CGLIB
    
  
  

JDK中的Proxy类

步骤

• 实现InvocationHandler接口，创建自己的调用处理器
  
• 通过为Proxy类指定ClassLoader和一组Interface来创建动态代理类
  
  
  
  • 被代理对象的ClassLoader和Interface
    
  
  
• 通过反射机制获取动态代理类的构造函数
  
  
  
  • 其需要的唯一参数类型是InvocationHandler
    
  
  
• 通过构造函数创建动态代理实例
  
  
  
  • 构造时将之前实现的InvocationHandler对象作为参数传入
    
  
  

这四步之后，我们就可以用使用被代理对象的方式，来使用动态代理实例了
另外

• 后三步可以自己手动调用Proxy类的方法来分别实现
  
• 也可以直接调用Proxy封装好的方法来一步实现
  
  
  
  • Proxy.newProxyInstance(ClassLoader, Interface[], InvocationHandler)
    
  
  

Demo

1. package cn.andl;
3. import cn.andl.util.Computer;
4. import cn.andl.util.impl.ComputerImpl;
6. import java.lang.reflect.InvocationHandler;
7. import java.lang.reflect.Method;
8. import java.lang.reflect.Proxy;
10. /**
11. * 测试JDK动态代理方式
12. * @author Andl
13. * @since 2023/5/29 11:17
14. */
15. public class TestProxy {
17.     public static void main(String[] args) {
19.         // 创建被代理对象实例
20.         ComputerImpl computer = new ComputerImpl();
22.         // 实现一个调用处理器
23.         InvocationHandler invocationHandler = new InvocationHandler() {
25.             /**
26.              * 在之后的代理类调用方法时，会实际调用这个方法
27.              *
28.              * @param proxy 代理
29.              *
30.              * @param method 要被代理的方法
31.              *
32.              * @param args 方法里的参数列表
33.              *
34.              * @return 方法的返回值
35.              * @throws Throwable
36.              */
37.             @Override
38.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
39.                 System.out.format("[%s] 执行 %s 方法, 参数1：%d, 参数2：%d\n",
40.                         this.getClass().getName(), method.getName(), (Integer)args[0], (Integer)args[1]);
42.                 // 调用被代理对象的方法，并获取返回值
43.                 Object result = method.invoke(computer, args);
45.                 System.out.format("[%s] 执行 %s 方法完毕, 结果：%d\n",
46.                         this.getClass().getName(), method.getName(), (Integer)result);
48.                 return result;
49.             }
50.         };
52.         //获取代理对象
53.         Computer computerProxy = (Computer) Proxy.newProxyInstance(
54.                 // 被代理对象的类加载器
55.                 computer.getClass().getClassLoader(),
56.                 // 被代理对象实现的接口
57.                 computer.getClass().getInterfaces(),
58.                 // 调用处理器
59.                 invocationHandler);
61.         // 执行方法
62.         computerProxy.add(1, 2);
63.     }
65. }

复制代码

Computer接口

1. package cn.andl.util;
3. /**
4. * 计算接口
5. * @author Andl
6. * @create 2023/5/29 11:18
7. */
8. public interface Computer {
10.     /**
11.      * 计算a和b的和
12.      * @param a 加数1
13.      * @param b 加数2
14.      * @return 和
15.      */
16.     int add(int a, int b);
18. }

复制代码

ComputerImpl类

1. package cn.andl.util.impl;
3. import cn.andl.util.Computer;
5. /**
6. * 计算接口实现类
7. * @author Andl
8. * @since 2023/5/29 11:23
9. */
10. public class ComputerImpl implements Computer {
11.     @Override
12.     public int add(int a, int b) {
13.         System.out.format("[%s] 方法执行中\n", this.getClass().getName());
14.         return a + b;
15.     }
16. }

复制代码

输出结果

1. [cn.andl.TestProxy$1] 执行 add 方法, 参数1：1, 参数2：2
2. [cn.andl.util.impl.ComputerImpl] 方法执行中
3. [cn.andl.TestProxy$1] 执行 add 方法完毕, 结果：3：3

复制代码

Demo2

简单封装一下

1. package cn.andl;
3. import cn.andl.util.Computer;
4. import cn.andl.util.impl.ComputerImpl;
6. import java.lang.reflect.InvocationHandler;
7. import java.lang.reflect.Method;
8. import java.lang.reflect.Proxy;
10. /**
11. * 测试JDK动态代理2
12. * @author Andl
13. * @since 2023/5/29 13:19
14. */
15. public class TestProxy2 {
17.     static class InvocationHandlerImpl implements InvocationHandler {
19.         Object originalObject;
21.         public Object bind(Object originalObject) {
22.             this.originalObject = originalObject;
24.             return Proxy.newProxyInstance(
25.                     originalObject.getClass().getClassLoader(),
26.                     originalObject.getClass().getInterfaces(),
27.                     this);
28.         }
30.         @Override
31.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
32.             System.out.format("[%s] 执行 %s 方法, 参数1：%d, 参数2：%d\n",
33.                     this.getClass().getName(), method.getName(), (Integer)args[0], (Integer)args[1]);
35.             Object result = method.invoke(originalObject, args);
37.             System.out.format("[%s] 执行 %s 方法完毕, 结果：%d\n",
38.                     this.getClass().getName(), method.getName(), (Integer)result);
40.             return result;
41.         }
42.     }
44.     public static void main(String[] args) {
45.         // 获取代理
46.         Computer computer = (Computer) new InvocationHandlerImpl().bind(new ComputerImpl());
48.         // 执行方法
49.         computer.add(1, 2);
50.     }
52. }

复制代码

输出结果

1. [cn.andl.TestProxy2$InvocationHandlerImpl] 执行 add 方法, 参数1：1, 参数2：2
2. [cn.andl.util.impl.ComputerImpl] 方法执行中
3. [cn.andl.TestProxy2$InvocationHandlerImpl] 执行 add 方法完毕, 结果：3

复制代码

原理简述

通过在main方法中最开始时加入一句代码，我们可以保留动态代理对象的字节码文件

• System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
  
• 可以在和src同级的com文件夹下的sun/proxy/中找到
  

类名

public final class $Proxy0 extends Proxy implements Computer {
观察类名可以发现，动态代理类继承了Proxy方法，实现了Computer接口
静态代码块

1.     static {
2.         try {
3.             m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
4.             m2 = Class.forName("java.lang.Object").getMethod("toString");
5.             m3 = Class.forName("cn.andl.util.Computer").getMethod("add", Integer.TYPE, Integer.TYPE);
6.             m0 = Class.forName("java.lang.Object").getMethod("hashCode");
7.         } catch (NoSuchMethodException var2) {
8.             throw new NoSuchMethodError(var2.getMessage());
9.         } catch (ClassNotFoundException var3) {
10.             throw new NoClassDefFoundError(var3.getMessage());
11.         }
12.     }

复制代码

观察静态代码块可以发现，被代理对象的方法被赋值到了变量中
add方法

1.     public final int add(int var1, int var2) throws  {
2.         try {
3.             return (Integer)super.h.invoke(this, m3, new Object[]{var1, var2});
4.         } catch (RuntimeException | Error var4) {
5.             throw var4;
6.         } catch (Throwable var5) {
7.             throw new UndeclaredThrowableException(var5);
8.         }
9.     }

复制代码

观察动态代理类中的add方法可以发现

• 是通过调用父类中变量h的invoke方法来实现功能的
  
• 而这个h,就是我们在之前创建动态代理类时，向构造器传入的InvocationHandler
  

CGLIB

• cglib是一个功能强大、高性能、高质量的字节码操作库
  
• 主要用于在运行时拓展Java类或者根据接口生成对象
  
• 本身的实现基于asm库
  
• 要使用cglib主要会用到Enhancer和回调类
  

Enhancer

• Enhancer是cglib中使用最多的类
  
• Enhancer可以生成被代理类的子类，并且会拦截所有方法的调用
  
  
  
  • 称之为增强
    
  
  
• Enhancer可以基于接口来生成动态代理类，也可以直接基于类生成动态代理类
  
• Enhancer不能增强构造函数，也不能增强被final修饰的类，或者被static和final修饰的方法
  
  
  
  • 因为Enhancer是通过继承被代理的目标类来是实现增强的
    
  
  
• Enhancer的使用分成两步
  
  
  
  • 传入目标类型
    
  • 设置回调
    
  
  

MethodInterceptor

cglib中回调类型有很多，这里主要介绍方法拦截器MethodInterceptor

• 方法拦截器会对被代理的目标类中所有可以增强的方法进行增强
  
  
  
  • 不包括构造方法、final方法和static方法
    
  
  
• 方法拦截器的核心方法public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  
  
  
  • o
    
    
    
    • 被代理的目标对象
      
    
    
  • method
    
    
    
    • 被代理的目标方法
      
    
    
  • objects
    
    
    
    • 参数列表
      
    
    
  • methodProxy
    
    
    
    • 代理类的方法引用
      
    
    
  
  

Demo

1. public class TestCGLIB {
3.     public static void main(String[] args) {
4.         // 初始化enhancer对象
5.         Enhancer enhancer = new Enhancer();
6.         // 传入目标类型
7.         enhancer.setSuperclass(ComputerImpl.class);
8.         // 也可以传入接口
9. //        enhancer.setInterfaces(ComputerImpl.class.getInterfaces());
10.         // 设置回调类型
11.         enhancer.setCallback(new MethodInterceptor() {
12.             /**
13.              * 拦截方法
14.              * @param o 目标对象
15.              * @param method 目标方法
16.              * @param objects 参数列表
17.              * @param methodProxy 代理方法
18.              */
19.             @Override
20.             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
22.                 System.out.format("[%s] 执行方法 [%s] 参数：[%d][%d]\n",
23.                         this.getClass().getName(), method.getName(), (Integer)objects[0], (Integer)objects[1]);
24.                 Object result = methodProxy.invokeSuper(o, objects);
25.                 System.out.format("[%s] 执行方法 [%s] 结果：[%d]\n",
26.                         this.getClass().getName(), method.getName(), (Integer)result);
28.                 return result;
29.             }
30.         });
31.         // 创建代理对象
32.         ComputerImpl computer = (ComputerImpl)enhancer.create();
33.         // 执行方法
34.         computer.add(1, 2);
35.     }
37. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！