静态代理+JDK/CGLIB 动态代理实战

1. 代理模式

代理模式是一种比较好的理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

举个例子：你的找了一小红来帮你问话，小红就看作是代理我的代理对象，代理的行为（方法）是问话。
06 静态代理 JDK/CGLIB 动态代理实战 - 图1
https://medium.com/@mithunsasidharan/understanding-the-proxy-design-pattern-5e63fe38052a
代理模式有静态代理和动态代理两种实现方式，我们 先来看一下静态代理模式的实现。

2.动态代理

JDK 动态代理机制

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

  1. public static Object newProxyInstance(ClassLoader loader,
  2.                                           Class<?>[] interfaces,
  3.                                           InvocationHandler h)
  4.         throws IllegalArgumentException
  5.     {
  6.         ......
  7.     }

这个方法一共有 3 个参数：

1loader :类加载器，用于加载代理对象。
2interfaces : 被代理类实现的一些接口；
3h : 实现了 InvocationHandler 接口的对象；

要实现动态代理的话，还必须需要实现InvocationHandler 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

  1. public interface InvocationHandler {
  3.     /**
  4.      * 当你使用代理对象调用方法的时候实际会调用到这个方法
  5.      */
  6.     public Object invoke(Object proxy, Method method, Object[] args)
  7.         throws Throwable;
  8. }

invoke() 方法有下面三个参数：

proxy :动态生成的代理类
method : 与代理类对象调用的方法相对应
args : 当前 method 方法的参数

也就是说：你通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

JDK 动态代理类使用步骤

定义一个接口及其实现类；
自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

代码示例

定义发送短信的接口

  1. public interface SmsService {
  2.     String send(String message);
  3. }

实现发送短信的接口

  1. public class SmsServiceImpl implements SmsService {
  2.     public String send(String message) {
  3.         System.out.println("send message:" + message);
  4.         return message;
  5.     }
  6. }

定义一个 JDK 动态代理类

  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.InvocationTargetException;
  3. import java.lang.reflect.Method;
  5. public class DebugInvocationHandler implements InvocationHandler {
  6.     /**
  7.      * 代理类中的真实对象
  8.      */
  9.     private final Object target;
  11.     public DebugInvocationHandler(Object target) {
  12.         this.target = target;
  13.     }
  15.     public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
  16.         //调用方法之前，我们可以添加自己的操作
  17.         System.out.println("before method " + method.getName());
  18.         Object result = method.invoke(target, args);
  19.         //调用方法之后，我们同样可以添加自己的操作
  20.         System.out.println("after method " + method.getName());
  21.         return result;
  22.     }
  23. }

invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。

获取代理对象的工厂类

  1. public class JdkProxyFactory {
  2.     public static Object getProxy(Object target) {
  3.         return Proxy.newProxyInstance(
  4.                 target.getClass().getClassLoader(), // 目标类的类加载
  5.                 target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
  6.                 new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
  7.         );
  8.     }
  9. }

getProxy() ：主要通过Proxy.newProxyInstance（）方法获取某个类的代理对象

实际使用

  1. SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
  2. smsService.send("java");

运行上述代码之后，控制台打印出：

  1. before method send
  2. send message:java
  3. after method send

JDK 动态代理和 CGLIB 动态代理对比

JDK 动态代理只能只能代理实现了接口的类，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。

就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。