Java-基础-JDK动态代理

1. 简介

代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

比如：我们在调用底层框架方法时候，需要在调用方法的前后打印日志，或者做一些逻辑判断。此时我们无法去修改底层框架方法，那我们可以通过封装一个代理类，在代理类中实现对方法的处理，然后所有的客户端通过代理类去调用目标方法。

其中这里有几个对象：

抽象角色：通过接口或者抽象类声明真实角色实现的业务方法，尽可能的保证代理对象的内部结构和目标对象一致，这样我们对代理对象的操作最终都可以转移到目标对象上。
代理角色/代理对象：实现抽象角色，是真实角色的代理，实现对目标方法的增强。
真实角色/目标对象：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
调用角色/客户端：调用代理对象。

2. 静态代理

2.1 业务场景

假设现在有这么个场景：王淑芬打算相亲，但是自己嘴笨，于是找到媒婆，希望媒婆帮自己找个帅哥，于是找到了张铁牛。

角色分析：

王淑芬：目标对象（被代理的人）。
媒婆：代理对象（代理了王淑芬，实现对目标方法的增强）。
张铁牛：客户端（访问代理对象，即找媒婆）。
抽象角色（相亲）：媒婆和王淑芬的共同目标-相亲成功。

2.2 代码实现

相亲接口

/**

 * 相亲抽象类

 *

 * @author ludangxin

 * @date 2021/9/25

 */

public interface BlindDateService {

   /**

    * 聊天

    */

   void chat();

}

目标对象

/**

 * 王淑芬 - 目标对象

 *

 * @author ludangxin

 * @date 2021/9/25

 */

@Slf4j

public class WangShuFen implements BlindDateService {

   @Override

   public void chat() {

      log.info("美女：王淑芬～");

   }

}

代理对象

/**

 * 媒婆 - 代理对象

 *

 * @author ludangxin

 * @date 2021/9/25

 */

@Slf4j

public class WomanMatchmaker implements BlindDateService {

   private BlindDateService bs;

   public WomanMatchmaker() {

      this.bs = new WangShuFen();

   }

   @Override

   public void chat() {

      this.introduce();

      bs.chat();

      this.praise();

   }

   /**

    * 介绍

    */

   private void introduce() {

      log.info("媒婆：她的工作是web前端～");

   }

   /**

    * 夸人

    */

   private void praise() {

      log.info("媒婆：她就是有点害羞～");

      log.info("媒婆：你看她人长的漂亮，而且温柔贤惠，上的厅堂下的厨房～");

      log.info("媒婆：而且写bug超厉害～");

   }

}

客户端

/**

 * 张铁牛 - client

 *

 * @author ludangxin

 * @date 2021/9/25

 */

public class ZhangTieNiu {

   public static void main(String[] args) {

      WomanMatchmaker wm  = new WomanMatchmaker();

      wm.chat();

   }

}

执行方法输出内容如下：

22:44:51.184 [main] INFO proxy.staticp.WomanMatchmaker - 媒婆：她的工作是web前端～

22:44:51.191 [main] INFO proxy.staticp.WangShuFen - 美女：你好，我叫王淑芬～

22:44:51.191 [main] INFO proxy.staticp.WomanMatchmaker - 媒婆：她就是有点害羞～

22:44:51.191 [main] INFO proxy.staticp.WomanMatchmaker - 媒婆：你看她人长的漂亮，而且温柔贤惠，上的厅堂下的厨房～

22:44:51.191 [main] INFO proxy.staticp.WomanMatchmaker - 媒婆：而且写bug超厉害～

2.3 小节

好处：

耦合性降低。因为加入了代理类，调用者只用关心代理类即可，降低了调用者与目标类的耦合度。
指责清晰，目标对象只关心真实的业务逻辑。代理对象只负责对目标对象的增强。调用者只关心代理对象的执行结果。
代理对象实现了对目标方法的增强。也就是说：代理对象 = 增强代码 + 目标对象。

缺陷：

每一个目标类都需要写对应的代理类。如果当前系统已经有成百上千个类，工作量大太。所以，能不能不用写那么多代理类，就能实现对目标方法的增强呢？

3. 动态代理

我们常见的动态代理一般有两种：JDK动态代理和CGLib动态代理，本章只讲JDK动态代理。

在了解JDK动态代理之前，先了解两个重要的类。

3.1 Proxy

从JDK的帮助文档中可知：

Proxy提供了创建动态代理和实例的静态方法。即：

Proxy::newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

参数：

loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序

前两个参数没啥好说的，主要还需要了解下InvocationHandler。

3.2 InvocationHandler

从JDK的帮助文档中可知：

InvocationHandler是一个接口，并且是调用处理逻辑实现的接口。在调用代理对象方法时，实际上是调用实现接口的invoke方法。

Object InvocationHandler::invoke(Object proxy, Method method, Object[] args)

参数：

proxy - 调用方法的代理实例。
method - 对应于在代理实例上调用的接口方法的 Method 实例。 Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。
args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。

返回值：

从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。

3.3 代码实现

创建动态代理类

import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Arrays;

/**

 * 媒婆 - 代理对象

 *

 * @author ludangxin

 * @date 2021/9/25

 */

@Slf4j

public class ProxyTest {

   public static Object getProxy(final Object target) {

      return Proxy.newProxyInstance(

         //类加载器

         target.getClass().getClassLoader(),

         //让代理对象和目标对象实现相同接口

         target.getClass().getInterfaces(),

         //代理对象的方法最终都会被JVM导向它的invoke方法

         new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

               log.info("proxy ===》{}", proxy.getClass().toGenericString());

               log.info("method ===》{}", method.toGenericString());

               log.info("args ===》{}", Arrays.toString(args));

               introduce();

               // 调用目标方法

               Object result = method.invoke(target, args);

               praise();

               return result;

            }

         });

   }

   /**

    * 介绍

    */

   private static void introduce() {

      log.info("媒婆：她的工作是web前端～");

   }

   /**

    * 夸人

    */

   private static void praise() {

      log.info("媒婆：她就是有点害羞～");

      log.info("媒婆：你看她人长的漂亮，而且温柔贤惠，上的厅堂下的厨房～");

      log.info("媒婆：而且写bug超厉害～");

   }

}

客户端

/**

 * 张铁牛 - client

 *

 * @author ludangxin

 * @date 2021/9/25

 */

public class ZhangTieNiu {

   public static void main(String[] args) {

      BlindDateService proxy = (BlindDateService)ProxyTest.getProxy(new WangShuFen());

      proxy.chat();

   }

}

执行方法输出内容如下：

21:29:22.222 [main] INFO proxy.dynamic.ProxyTest - proxy ===》public final class com.sun.proxy.$Proxy0

21:29:22.229 [main] INFO proxy.dynamic.ProxyTest - method ===》public abstract void proxy.dynamic.BlindDateService.chat()

21:29:22.229 [main] INFO proxy.dynamic.ProxyTest - args ===》null

21:29:22.229 [main] INFO proxy.dynamic.ProxyTest - 媒婆：她的工作是web前端～

21:29:22.229 [main] INFO proxy.dynamic.WangShuFen - 美女：你好，我叫王淑芬～

21:29:22.230 [main] INFO proxy.dynamic.ProxyTest - 媒婆：她就是有点害羞～

21:29:22.230 [main] INFO proxy.dynamic.ProxyTest - 媒婆：你看她人长的漂亮，而且温柔贤惠，上的厅堂下的厨房～

21:29:22.230 [main] INFO proxy.dynamic.ProxyTest - 媒婆：而且写bug超厉害～

3.4 小节

其实代码很简单，只需要通过jdk提供的代理类创建一个代理类，再通过代理类去调用目标方法，并实现对方法的增强即可。

从打印的日志中可以看出JDK生成真实的代理对象为com.sun.proxy.$Proxy0，那我们能不能查看下生成的代理对象的源码呢？答案肯定是可以的。我们可以借助JDK默认提供的ProxyGenerator::generateProxyClass()来输出动态生成的代理对象。

改造下动态代理类如下：

添加输出动态代理类的方法。

package proxy.dynamic;

import lombok.extern.slf4j.Slf4j;

import sun.misc.ProxyGenerator;

import java.io.File;

import java.io.FileOutputStream;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.Arrays;

/**

 * 媒婆 - 代理对象

 *

 * @author ludangxin

 * @date 2021/9/25

 */

@Slf4j

public class ProxyTest {

   public static Object getProxy(final Object target) {

      return Proxy.newProxyInstance(

            //类加载器

            target.getClass().getClassLoader(),

            //让代理对象和目标对象实现相同接口

            target.getClass().getInterfaces(),

            //代理对象的方法最终都会被JVM导向它的invoke方法

            new InvocationHandler() {

               @Override

               public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                  generateProxyClass(proxy);

                  log.info("proxy ===》{}", proxy.getClass().toGenericString());

                  log.info("method ===》{}", method.toGenericString());

                  log.info("args ===》{}", Arrays.toString(args));

                  introduce();

                  Object result = method.invoke(target, args);

                  praise();

                  return result;

               }

            });

   }

   /**

    * 输出动态生成的代理类

    * @param proxy 代理实例

    */

   private static void generateProxyClass(Object proxy) {

      byte[] bytes = ProxyGenerator.generateProxyClass(proxy.getClass().getName(), proxy.getClass().getInterfaces());

      File file = new File("/Users/ludangxin/workspace/idea/test/target/classes/proxy/dynamic/proxy.class");

      try {

         FileOutputStream fileOutputStream = new FileOutputStream(file);

         fileOutputStream.write(bytes);

      } catch(Exception e) {

         e.printStackTrace();

      }

   }

   ...

}

再次执行调用方法，输出类如下：

类信息如下：

看完代理类的方法是不是恍然大悟，我们再整理下调用过程：

动态代理：动态的生成代理对象。

4. 总结

其实无论是静态代理还是动态代理本质都是最终生成代理对象，区别在于静态代理对象需要人手动生成，而动态代理对象是运行时，JDK通过反射动态生成的代理类最终构造的对象，JDK生成的类在加载到内存之后就删除了，所以看不到类文件。