代理模式（Proxy Pattern）的定义也非常简单，是指为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介作用，代理模式属于结构型设计模式。使用代理模式主要有两个目的：一保护目标对象，二增强目标对象。下面我们来看一下代理模式的类结构图，如下图所示。

一个典型的代理模式通常有三个角色，这里称之为代理三要素：

  • 共同接口
  • 真实对象
  • 代理对象

image.png

Subject 是顶层接口，RealSubject 是真实对象（被代理对象），Proxy 是代理对象，代理对象持有被代理对象的引用，客户端调用代理对象的方法，同时也调用被代理对象的方法，但是会在代理对象前后增加一些处理代码。在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知。代理模式属于结构型模式，分为静态代理和动态代理。

代理模式分为静态代理和动态代理。动态代理的实现方式有 JDK 动态代理、CGLIB 动态代理、Javassist 动态代理。

静态代理

由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口，被代理类，代理类等确定下来。在程序运行之前，代理类的 .class 文件就已经生成。

举个例子，有些人到了适婚年龄，父母为自己的子女相亲，这个相亲的过程就是一种代理模式。下面来看代码实现。

顶层接口 Person 的代码如下：

  1. /**
  2.  * 顶层接口
  3.  */
  4. public interface Person {
  5.     public void findLove();
  6. }

儿子要找对象，实现 Son 类：

  1. public class Son implements Person {
  2.     @Override
  3.     public void findLove() {
  4.         System.out.println("儿子要求：肤白貌美大长腿");
  5.     }
  6. }

父亲要帮儿子相亲，实现 Father 类：

  1. public class Father implements Person {
  3.     private Person person;
  5.     public Father(Person person){
  6.         this.person = person;
  7.     }
  9.     @Override
  10.     public void findLove() {
  11.         System.out.println("父亲物色对象");
  12.         person.findLove();
  13.         System.out.println("双方同意交往，确立关系");
  14.     }
  15. }

来看测试代码：

  1. public static void main(String[] args) {
  2.     Father father = new Father(new Son());
  3.     father.findLove();
  4. }

运行结果如下图所示。

image.png

静态代理的优缺点：

  • 优点：扩展原功能，不侵入原代码；
  • 缺点：不同的代理类、代理方法，需要提供不同的代理对象；

动态代理

动态代理的目的就是为了解决静态代理的缺点。通过使用动态代理，我们可以通过在运行时，动态生成一个持有真实对象并实现代理接口的代理对象，同时注入扩展逻辑。

如果还以找对象为例，那么使用动态代理相当于能够适应复杂的业务场景，不仅包括父亲给儿子找对象，如果找对象这项业务发展成了一个产业，出现了媒婆、婚介所等，那么用静态代理成本太高了，需要一个更加通用的解决方案，满足任何单身人士找对象的需求，下面我们升级一下代码。

JDK 实现方式

创建媒婆类 JDKMeipo：

  1. public class JDKMeipo implements InvocationHandler {
  3.     private Person person;
  5.     public JDKMeipo(Person person) {
  6.         this.person = person;
  7.     }
  9.     public Person getInstance() {
  10.         return (Person) Proxy.newProxyInstance(Person.class.getClassLoader(),
  11.                 person.getClass().getInterfaces(), this);
  12.     }
  14.     @Override
  15.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  16.         before();
  17.         Object object = method.invoke(person, args);
  18.         after();
  19.         return object;
  20.     }
  22.     private void before() {
  23.         System.out.println("我是媒婆：我要给你找对象，现在已经确认你的需求");
  24.         System.out.println("开始物色");
  25.     }
  27.     private void after() {
  28.         System.out.println("如果合适的话，就准备办事");
  29.     }
  30. }

创建单身客户类：

  1. public class Customer implements Person {
  3.     @Override
  4.     public void findLove() {
  5.         System.out.println("高富帅，身高180，有6块腹肌");
  6.     }
  7. }


测试代码如下：

  1. public static void main(String[] args) {
  2.     Person person = new JDKMeipo(new Customer()).getInstance();
  3.     person.findLove();
  4. }

运行效果如下图所示。

image.png

手写实现 JDK 动态代理

我们来探究一下 JDK 动态代理的原理，并模仿 JDK 动态代理手动实现一个动态代理。

JDK 动态代理采用字节码重组，重新生成对象来替代原始对象，以达到动态代理的目的。JDK 动态代理生成对象的步骤如下：

  1. 获取被代理对象的引用，并且获取它的所有接口，反射获取；
  2. JDK 动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口；
  3. 动态生成 Java 代码，新加的业务逻辑方法由一定的逻辑代码调用（在代码中体现）；
  4. 编译新生成的 Java 代码.class 文件；
  5. 重新加载到 JVM 中运行。

以上过程就叫字节码重组。JDK 中有一个规范，在 ClassPath 下只要是 $ 开头的 .class 文件，一般都是自动生成的。那么我们有没有办法看到代替后的对象的“真容”呢？做一个这样测试，我们将内存中的对象字节码通过文件输出到一个新的 .class 文件，然后利用反编译工具查看其源码。

修改刚才的测试类代码：

  1. package com.yjw.demo.pattern.proxy2.jdk;
  3. import com.yjw.demo.pattern.proxy2.staticed.Person;
  4. import sun.misc.ProxyGenerator;
  6. import java.io.FileOutputStream;
  8. public class JDKProxyTest {
  9.     public static void main(String[] args) throws Exception {
  10.         Person person = new JDKMeipo(new Customer()).getInstance();
  11.         person.findLove();
  13.         // 通过反编译工具可以查看源代码
  14.         byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Person.class});
  15.         FileOutputStream os = new FileOutputStream("/Users/yinjianwei/Downloads/$Proxy0.class");
  16.         os.write(bytes);
  17.         os.close();
  18.     }
  19. }

运行以上代码，找到目录中的 $Proxy0.class 文件。使用反编译工具打开，看到如下内容：

  1. package com.yjw.demo.pattern.proxy2.jdk;
  3. import com.yjw.demo.pattern.proxy2.staticed.Person;
  5. import java.lang.reflect.InvocationHandler;
  6. import java.lang.reflect.Method;
  7. import java.lang.reflect.Proxy;
  8. import java.lang.reflect.UndeclaredThrowableException;
  10. /* renamed from: $Proxy0  reason: invalid class name and default package */
  11. public final class C$Proxy0 extends Proxy implements Person {
  12.     private static Method m0;
  13.     private static Method m1;
  14.     private static Method m2;
  15.     private static Method m3;
  17.     static {
  18.         try {
  19.             m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
  20.             m3 = Class.forName("com.yjw.demo.pattern.proxy2.staticed.Person").getMethod("findLove", new Class[0]);
  21.             m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
  22.             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
  23.         } catch (NoSuchMethodException e) {
  24.             throw new NoSuchMethodError(e.getMessage());
  25.         } catch (ClassNotFoundException e2) {
  26.             throw new NoClassDefFoundError(e2.getMessage());
  27.         }
  28.     }
  30.     /**
  31.      * 代理类的构造方法，方法参数为InvocationHandler类型，调用父类的构造方法，父类构造方法代码如下所示
  32.      * <p>
  33.      * protected Proxy(InvocationHandler h) {
  34.      *     Objects.requireNonNull(h);
  35.      *     this.h = h;
  36.      * }
  37.      * </p>
  38.      *
  39.      * @param invocationHandler
  40.      */
  41.     public C$Proxy0(InvocationHandler invocationHandler) {
  42.         super(invocationHandler);
  43.     }
  45.     public final boolean equals(Object obj) {
  46.         try {
  47.             return ((Boolean) this.h.invoke(this, m1, new Object[]{obj})).booleanValue();
  48.         } catch (Error | RuntimeException e) {
  49.             throw e;
  50.         } catch (Throwable th) {
  51.             throw new UndeclaredThrowableException(th);
  52.         }
  53.     }
  55.     /**
  56.      * 调用InvocationHandler中的invoke方法，并把m3传进去
  57.      */
  58.     public final void findLove() {
  59.         try {
  60.             this.h.invoke(this, m3, (Object[]) null);
  61.         } catch (Error | RuntimeException e) {
  62.             throw e;
  63.         } catch (Throwable th) {
  64.             throw new UndeclaredThrowableException(th);
  65.         }
  66.     }
  68.     public final int hashCode() {
  69.         try {
  70.             return ((Integer) this.h.invoke(this, m0, (Object[]) null)).intValue();
  71.         } catch (Error | RuntimeException e) {
  72.             throw e;
  73.         } catch (Throwable th) {
  74.             throw new UndeclaredThrowableException(th);
  75.         }
  76.     }
  78.     public final String toString() {
  79.         try {
  80.             return (String) this.h.invoke(this, m2, (Object[]) null);
  81.         } catch (Error | RuntimeException e) {
  82.             throw e;
  83.         } catch (Throwable th) {
  84.             throw new UndeclaredThrowableException(th);
  85.         }
  86.     }
  87. }

我们发现，$Proxy0 继承了 Proxy 类，同时还实现了 Person 接口，而且重写了 findLove() 等方法，在静态块中用反射查找到了目标对象的所有方法，而且保存了所有方法的引用，重写的方法用反射调用目标对象的方法。

注意代理类中的构造方法和 findLove() 方法，执行 $Proxy0 中的 findLove() 方法会调用 JDKMeipo 中的 invoke() 方法。

上面的 $Proxy0 是 JDK 帮我们自动生成的，现在我们不依赖 JDK，自己来动态生成源代码、动态完成编译，然后替代目标对象并执行。

创建 GPInvocationHandler 接口：

  1. package com.yjw.demo.pattern.proxy2.manual;
  3. import java.lang.reflect.Method;
  5. public interface GPInvocationHandler {
  6.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
  7. }

创建 GPClassLoader 类：

  1. package com.yjw.demo.pattern.proxy2.manual;
  3. import java.io.*;
  4. import java.net.URLDecoder;
  6. public class GPClassLoader extends ClassLoader {
  8.     private File classPathFile;
  10.     public GPClassLoader() {
  11.         String classPath = null;
  12.         try {
  13.             classPath = URLDecoder.decode(GPClassLoader.class.getResource("").getPath(), "UTF-8");
  14.         } catch (UnsupportedEncodingException e) {
  15.             e.printStackTrace();
  16.         }
  17.         this.classPathFile = new File(classPath);
  18.     }
  20.     @Override
  21.     protected Class<?> findClass(String name) throws ClassNotFoundException {
  22.         String className = GPClassLoader.class.getPackage().getName() + "." + name;
  23.         if (classPathFile != null) {
  24.             File classFile = new File(classPathFile, name.replaceAll("\\.", "/") + ".class");
  25.             if (classFile.exists()) {
  26.                 FileInputStream in = null;
  27.                 ByteArrayOutputStream out = null;
  28.                 try {
  29.                     in = new FileInputStream(classFile);
  30.                     out = new ByteArrayOutputStream();
  31.                     byte[] buff = new byte[1024];
  32.                     int len;
  33.                     while ((len = in.read(buff)) != -1) {
  34.                         out.write(buff, 0, len);
  35.                     }
  36.                     return defineClass(className, out.toByteArray(), 0, out.size());
  37.                 } catch (Exception e) {
  38.                     e.printStackTrace();
  39.                 } finally {
  40.                     if (null != in) {
  41.                         try {
  42.                             in.close();
  43.                         } catch (IOException e) {
  44.                             e.printStackTrace();
  45.                         }
  46.                     }
  47.                     if (out != null) {
  48.                         try {
  49.                             out.close();
  50.                         } catch (IOException e) {
  51.                             e.printStackTrace();
  52.                         }
  53.                     }
  54.                 }
  55.             }
  56.         }
  57.         return null;
  58.     }
  59. }

创建 GPProxy 类：

  1. package com.yjw.demo.pattern.proxy2.manual;
  3. import javax.tools.JavaCompiler;
  4. import javax.tools.StandardJavaFileManager;
  5. import javax.tools.ToolProvider;
  6. import java.io.File;
  7. import java.io.FileWriter;
  8. import java.lang.reflect.Constructor;
  9. import java.lang.reflect.Method;
  10. import java.net.URLDecoder;
  11. import java.util.HashMap;
  12. import java.util.Map;
  14. public class GPProxy {
  16.     public static final String ln = "\r\n";
  18.     public static Object newProxyInstance(GPClassLoader classLoader, Class<?>[] interfaces, GPInvocationHandler h) {
  20.         try {
  21.             //1、动态生成源代码.java文件
  22.             String src = generateSrc(interfaces);
  24.             //2、Java文件输出磁盘
  25.             String filePath = URLDecoder.decode(GPProxy.class.getResource("").getPath(), "UTF-8");
  26.             System.out.println(filePath);
  27.             File f = new File(filePath + "$Proxy0.java");
  28.             FileWriter fw = new FileWriter(f);
  29.             fw.write(src);
  30.             fw.flush();
  31.             fw.close();
  33.             //3、把生成的.java文件编译成.class文件
  34.             JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  35.             StandardJavaFileManager manage = compiler.getStandardFileManager(null, null, null);
  36.             Iterable iterable = manage.getJavaFileObjects(f);
  38.             JavaCompiler.CompilationTask task = compiler.getTask(null, manage, null, null, null, iterable);
  39.             task.call();
  40.             manage.close();
  42.             //4、编译生成的.class文件加载到JVM中来
  43.             Class proxyClass = classLoader.findClass("$Proxy0");
  44.             Constructor c = proxyClass.getConstructor(GPInvocationHandler.class);
  45.             f.delete();
  47.             //5、返回字节码重组以后的新的代理对象
  48.             return c.newInstance(h);
  49.         } catch (Exception e) {
  50.             e.printStackTrace();
  51.         }
  52.         return null;
  53.     }
  55.     private static String generateSrc(Class<?>[] interfaces) {
  56.         StringBuffer sb = new StringBuffer();
  57.         sb.append("package com.yjw.demo.pattern.proxy2.manual;" + ln);
  58.         sb.append("import com.yjw.demo.pattern.proxy2.staticed.Person;" + ln);
  59.         sb.append("import java.lang.reflect.*;" + ln);
  60.         sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
  61.         sb.append("GPInvocationHandler h;" + ln);
  62.         sb.append("public $Proxy0(GPInvocationHandler h) { " + ln);
  63.         sb.append("this.h = h;");
  64.         sb.append("}" + ln);
  66.         for (Method m : interfaces[0].getMethods()) {
  67.             Class<?>[] params = m.getParameterTypes();
  69.             StringBuffer paramNames = new StringBuffer();
  70.             StringBuffer paramValues = new StringBuffer();
  71.             StringBuffer paramClasses = new StringBuffer();
  73.             for (int i = 0; i < params.length; i++) {
  74.                 Class clazz = params[i];
  75.                 String type = clazz.getName();
  76.                 String paramName = toLowerFirstCase(clazz.getSimpleName());
  77.                 paramNames.append(type + " " + paramName);
  78.                 paramValues.append(paramName);
  79.                 paramClasses.append(clazz.getName() + ".class");
  80.                 if (i > 0 && i < params.length - 1) {
  81.                     paramNames.append(",");
  82.                     paramValues.append(",");
  83.                     paramClasses.append(",");
  84.                 }
  85.             }
  87.             sb.append("public " + m.getReturnType().getName() + " " + m.getName()
  88.                     + "(" + paramNames.toString() + ") {" + ln);
  89.             sb.append("try{" + ln);
  90.             sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\""
  91.                     + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
  92.             sb.append((hasReturnValue(m.getReturnType()) ? "return " : "")
  93.                     + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})", m.getReturnType())
  94.                     + ";" + ln);
  95.             sb.append("}catch(Error _ex) { }");
  96.             sb.append("catch(Throwable e){" + ln);
  97.             sb.append("throw new UndeclaredThrowableException(e);" + ln);
  98.             sb.append("}");
  99.             sb.append(getReturnEmptyCode(m.getReturnType()));
  100.             sb.append("}");
  101.         }
  102.         sb.append("}" + ln);
  103.         return sb.toString();
  104.     }
  106.     private static Map<Class, Class> mappings = new HashMap<>();
  108.     static {
  109.         mappings.put(int.class, Integer.class);
  110.     }
  112.     private static String getReturnEmptyCode(Class<?> returnClass) {
  113.         if (mappings.containsKey(returnClass)) {
  114.             return "return 0;";
  115.         } else if (returnClass == void.class) {
  116.             return "";
  117.         } else {
  118.             return "return null;";
  119.         }
  120.     }
  122.     private static String getCaseCode(String code, Class<?> returnClass) {
  123.         if (mappings.containsKey(returnClass)) {
  124.             return "((" + mappings.get(returnClass).getName() + ")" + code + ")."
  125.                     + returnClass.getSimpleName() + "Values()";
  126.         }
  127.         return code;
  128.     }
  130.     private static boolean hasReturnValue(Class<?> clazz) {
  131.         return clazz != void.class;
  132.     }
  134.     private static String toLowerFirstCase(String src) {
  135.         char[] chars = src.toCharArray();
  136.         chars[0] += 32;
  137.         return String.valueOf(chars);
  138.     }
  139. }

创建 GPMeipo 类：

  1. package com.yjw.demo.pattern.proxy2.manual;
  3. import com.yjw.demo.pattern.proxy2.staticed.Person;
  5. import java.lang.reflect.Method;
  7. public class GPMeipo implements GPInvocationHandler {
  8.     // 被代理的对象，把引用保存下来
  9.     private Person person;
  11.     public GPMeipo(Person person) {
  12.         this.person = person;
  13.     }
  15.     public Person getInstance() {
  16.         Class<?> clazz = person.getClass();
  17.         return (Person) GPProxy.newProxyInstance(new GPClassLoader(), clazz.getInterfaces(), this);
  18.     }
  20.     @Override
  21.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  22.         before();
  23.         method.invoke(person, args);
  24.         after();
  25.         return null;
  26.     }
  28.     private void before() {
  29.         System.out.println("我是媒婆：我要给你找对象，现在已经确认你的需求");
  30.         System.out.println("开始物色");
  31.     }
  33.     private void after() {
  34.         System.out.println("如果合适的话，就准备办事");
  35.     }
  36. }

客户端测试代码如下：

  1. public static void main(String[] args) {
  2.     Person person = new GPMeipo(new Customer()).getInstance();
  3.     person.findLove();
  4. }

运行效果如下图所示。

image.png

静态代理和动态代理的本质区别

  1. 静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，代理类需要同步增加，违背开闭原则；
  2. 动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则；
  3. 若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码。

代理模式的优缺点

代理模式具有以下优点：

  1. 代理模式能将代理对象与真实被调用目标对象分离；
  2. 在一定程度上降低了系统的耦合度，扩展性好；
  3. 可以起到保护目标对象的作用；
  4. 可以增强目标对象的功能。

代理模式的缺点：

  1. 代理模式会造成系统设计中类的数量增加；
  2. 在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢；
  3. 增加了系统的复杂度。

摘录：《Spring 5 核心原理与30个类手写实战》来自文艺界的Tom老师的书籍。

推荐文章

代理模式详解（包含原理详解）：另外一种方式解读
java动态代理实现与原理详细分析：动态代理原理分析
深入理解［代理模式］原理与技术：手写JDK动态代理源码

作者：殷建卫 链接：https://www.yuque.com/yinjianwei/vyrvkf/dtdhxw 来源：殷建卫 - 架构笔记 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。