代理模式

为其他对象提供一个代理以控制对某个对象的访问。代理类主要负责为委托了（真实对象）预处理消息、过滤消息、传递消息给委托类，代理类不现实具体服务，而是利用委托类来完成服务，并将执行结果封装处理。
其实就是代理类为被代理类预处理消息、过滤消息并在此之后将消息转发给被代理类，之后还能进行消息的后置处理。代理类和被代理类通常会存在关联关系(即上面提到的持有的被带离对象的引用)，代理类本身不实现服务，而是通过调用被代理类中的方法来提供服务。

静态代理

创建一个接口，然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类，同时使其也实现这个接口。在代理类中持有一个被代理对象的引用，而后在代理类方法中调用该对象的方法。
接口：

  1. public interface HelloInterface {
  2.     void sayHello();
  3. }

被代理类：

  1. public class Hello implements HelloInterface{
  2.     @Override
  3.     public void sayHello() {
  4.         System.out.println("Hello zhanghao!");
  5.     }
  6. }

代理类：

  1. public class HelloProxy implements HelloInterface{
  2.     private HelloInterface helloInterface = new Hello();
  3.     @Override
  4.     public void sayHello() {
  5.         System.out.println("Before invoke sayHello" );
  6.         helloInterface.sayHello();
  7.         System.out.println("After invoke sayHello");
  8.     }
  9. }

代理类调用：
被代理类被传递给了代理类HelloProxy，代理类在执行具体方法时通过所持用的被代理类完成调用。

  1. public static void main(String[] args) {
  2.         HelloProxy helloProxy = new HelloProxy();
  3.         helloProxy.sayHello();
  4.     }
  6. 输出：
  7. Before invoke sayHello
  8. Hello zhanghao!
  9. After invoke sayHello

使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。

动态代理

利用反射机制在运行时创建代理类。
接口、被代理类不变，我们构建一个handler类来实现InvocationHandler接口。

  1. public class ProxyHandler implements InvocationHandler{
  2.     private Object object;
  3.     public ProxyHandler(Object object){
  4.         this.object = object;
  5.     }
  6.     @Override
  7.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  8.         System.out.println("Before invoke "  + method.getName());
  9.         method.invoke(object, args);
  10.         System.out.println("After invoke " + method.getName());
  11.         return null;
  12.     }
  13. }

执行动态代理：

  1. public static void main(String[] args) {
  2.         System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
  3.         HelloInterface hello = new Hello();
  5.         InvocationHandler handler = new ProxyHandler(hello);
  6.         HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
  7.         proxyHello.sayHello();
  8.     }
  9.     输出：
  10.     Before invoke sayHello
  11.     Hello zhanghao!
  12.     After invoke sayHello

通过Proxy类的静态方法newProxyInstance返回一个接口的代理实例。针对不同的代理类，传入相应的代理程序控制器InvocationHandler。
如果新来一个被代理类Bye，如：

  1. public interface ByeInterface {
  2.     void sayBye();
  3. }
  4. public class Bye implements ByeInterface {
  5.     @Override
  6.     public void sayBye() {
  7.         System.out.println("Bye zhanghao!");
  8.     }
  9. }

那么执行过程：

  1. public static void main(String[] args) {
  2.         System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
  3.         HelloInterface hello = new Hello();
  4.         ByeInterface bye = new Bye();
  5.         InvocationHandler handler = new ProxyHandler(hello);
  6.         InvocationHandler handler1 = new ProxyHandler(bye);
  7.         HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
  8.         ByeInterface proxyBye = (ByeInterface) Proxy.newProxyInstance(bye.getClass().getClassLoader(), bye.getClass().getInterfaces(), handler1);
  9.         proxyHello.sayHello();
  10.         proxyBye.sayBye();
  11.     }
  12.     输出：
  13.     Before invoke sayHello
  14.     Hello zhanghao!
  15.     After invoke sayHello
  16.     Before invoke sayBye
  17.     Bye zhanghao!
  18.     After invoke sayBye

动态代理底层实现

动态代理具体步骤：

  1. 通过实现 InvocationHandler 接口创建自己的调用处理器；
  2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
  3. 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
  4. 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

既然生成代理对象是用的Proxy类的静态方newProxyInstance，那么我们就去它的源码里看一下它到底都做了些什么？

  1. public static Object newProxyInstance(ClassLoader loader,
  2.                                           Class<?>[] interfaces,
  3.                                           InvocationHandler h)
  4.         throws IllegalArgumentException
  5.     {
  6.         Objects.requireNonNull(h);
  7.         final Class<?>[] intfs = interfaces.clone();
  8.         final SecurityManager sm = System.getSecurityManager();
  9.         if (sm != null) {
  10.             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  11.         }
  12.          //生成代理类对象
  13.         Class<?> cl = getProxyClass0(loader, intfs);
  14.         //使用指定的调用处理程序获取代理类的构造函数对象
  15.         try {
  16.             if (sm != null) {
  17.                 checkNewProxyPermission(Reflection.getCallerClass(), cl);
  18.             }
  19.             final Constructor<?> cons = cl.getConstructor(constructorParams);
  20.             final InvocationHandler ih = h;
  21.             //如果Class作用域为私有，通过 setAccessible 支持访问
  22.             if (!Modifier.isPublic(cl.getModifiers())) {
  23.                 AccessController.doPrivileged(new PrivilegedAction<Void>() {
  24.                     public Void run() {
  25.                         cons.setAccessible(true);
  26.                         return null;
  27.                     }
  28.                 });
  29.             }
  30.             //获取Proxy Class构造函数，创建Proxy代理实例。
  31.             return cons.newInstance(new Object[]{h});
  32.         } catch (IllegalAccessException|InstantiationException e) {
  33.             throw new InternalError(e.toString(), e);
  34.         } catch (InvocationTargetException e) {
  35.             Throwable t = e.getCause();
  36.             if (t instanceof RuntimeException) {
  37.                 throw (RuntimeException) t;
  38.             } else {
  39.                 throw new InternalError(t.toString(), t);
  40.             }
  41.         } catch (NoSuchMethodException e) {
  42.             throw new InternalError(e.toString(), e);
  43.         }
  44.     }

利用getProxyClass0(loader, intfs)生成代理类Proxy的Class对象。

  1. private static Class<?> getProxyClass0(ClassLoader loader,
  2.                                            Class<?>... interfaces) {
  3.         //如果接口数量大于65535，抛出非法参数错误
  4.         if (interfaces.length > 65535) {
  5.             throw new IllegalArgumentException("interface limit exceeded");
  6.         }
  8.         //如果指定接口的代理类已经存在与缓存中，则不用新创建，直接从缓存中取即可；
  9.         //如果缓存中没有指定代理对象，则通过ProxyClassFactory来创建一个代理对象。
  10.         return proxyClassCache.get(loader, interfaces);
  11.     }

ProxyClassFactory内部类创建、定义代理类，返回给定ClassLoader 和interfaces的代理类。

  1. private static final class ProxyClassFactory
  2.         implements BiFunction<ClassLoader, Class<?>[], Class<?>>{
  3.         // 代理类的名字的前缀统一为“$Proxy”
  4.         private static final String proxyClassNamePrefix = "$Proxy";
  5.         // 每个代理类前缀后面都会跟着一个唯一的编号，如$Proxy0、$Proxy1、$Proxy2
  6.         private static final AtomicLong nextUniqueNumber = new AtomicLong();
  7.         @Override
  8.         public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
  9.             Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
  10.             for (Class<?> intf : interfaces) {
  11.                 //验证类加载器加载接口得到对象是否与由apply函数参数传入的对象相同
  12.                 Class<?> interfaceClass = null;
  13.                 try {
  14.                     interfaceClass = Class.forName(intf.getName(), false, loader);
  15.                 } catch (ClassNotFoundException e) {
  16.                 }
  17.                 if (interfaceClass != intf) {
  18.                     throw new IllegalArgumentException(
  19.                         intf + " is not visible from class loader");
  20.                 }
  21.                 //验证这个Class对象是不是接口
  22.                 if (!interfaceClass.isInterface()) {
  23.                     throw new IllegalArgumentException(
  24.                         interfaceClass.getName() + " is not an interface");
  25.                 }
  26.                 if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
  27.                     throw new IllegalArgumentException(
  28.                         "repeated interface: " + interfaceClass.getName());
  29.                 }
  30.             }
  31.             String proxyPkg = null;     // package to define proxy class in
  32.             int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
  33.             /*
  34.              * Record the package of a non-public proxy interface so that the
  35.              * proxy class will be defined in the same package.  Verify that
  36.              * all non-public proxy interfaces are in the same package.
  37.              */
  38.             for (Class<?> intf : interfaces) {
  39.                 int flags = intf.getModifiers();
  40.                 if (!Modifier.isPublic(flags)) {
  41.                     accessFlags = Modifier.FINAL;
  42.                     String name = intf.getName();
  43.                     int n = name.lastIndexOf('.');
  44.                     String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
  45.                     if (proxyPkg == null) {
  46.                         proxyPkg = pkg;
  47.                     } else if (!pkg.equals(proxyPkg)) {
  48.                         throw new IllegalArgumentException(
  49.                             "non-public interfaces from different packages");
  50.                     }
  51.                 }
  52.             }
  53.             if (proxyPkg == null) {
  54.                 // if no non-public proxy interfaces, use com.sun.proxy package
  55.                 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
  56.             }
  57.             /*
  58.              * Choose a name for the proxy class to generate.
  59.              */
  60.             long num = nextUniqueNumber.getAndIncrement();
  61.             String proxyName = proxyPkg + proxyClassNamePrefix + num;
  62.             /*
  63.              * 
  64.              * 生成指定代理类的字节码文件
  65.              */
  66.             byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
  67.                 proxyName, interfaces, accessFlags);
  68.             try {
  69.                 return defineClass0(loader, proxyName,
  70.                                     proxyClassFile, 0, proxyClassFile.length);
  71.             } catch (ClassFormatError e) {
  72.                 /*
  73.                  * A ClassFormatError here means that (barring bugs in the
  74.                  * proxy class generation code) there was some other
  75.                  * invalid aspect of the arguments supplied to the proxy
  76.                  * class creation (such as virtual machine limitations
  77.                  * exceeded).
  78.                  */
  79.                 throw new IllegalArgumentException(e.toString());
  80.             }
  81.         }
  82.     }

一系列检查后，调用ProxyGenerator.generateProxyClass来生成字节码文件。

  1. public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
  2.         ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
  3.         // 真正用来生成代理类字节码文件的方法在这里
  4.         final byte[] var4 = var3.generateClassFile();
  5.         // 保存代理类的字节码文件
  6.         if(saveGeneratedFiles) {
  7.             AccessController.doPrivileged(new PrivilegedAction<Void>() {
  8.                 public Void run() {
  9.                     try {
  10.                         int var1 = var0.lastIndexOf(46);
  11.                         Path var2;
  12.                         if(var1 > 0) {
  13.                             Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), new String[0]);
  14.                             Files.createDirectories(var3, new FileAttribute[0]);
  15.                             var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
  16.                         } else {
  17.                             var2 = Paths.get(var0 + ".class", new String[0]);
  18.                         }
  19.                         Files.write(var2, var4, new OpenOption[0]);
  20.                         return null;
  21.                     } catch (IOException var4x) {
  22.                         throw new InternalError("I/O exception saving generated file: " + var4x);
  23.                     }
  24.                 }
  25.             });
  26.         }
  27.         return var4;
  28.     }

生成代理类字节码文件的generateClassFile方法:

  1. private byte[] generateClassFile() {
  2.         //下面一系列的addProxyMethod方法是将接口中的方法和Object中的方法添加到代理方法中(proxyMethod)
  3.         this.addProxyMethod(hashCodeMethod, Object.class);
  4.         this.addProxyMethod(equalsMethod, Object.class);
  5.         this.addProxyMethod(toStringMethod, Object.class);
  6.         Class[] var1 = this.interfaces;
  7.         int var2 = var1.length;
  8.         int var3;
  9.         Class var4;
  10.         //获得接口中所有方法并添加到代理方法中
  11.         for(var3 = 0; var3 < var2; ++var3) {
  12.             var4 = var1[var3];
  13.             Method[] var5 = var4.getMethods();
  14.             int var6 = var5.length;
  15.             for(int var7 = 0; var7 < var6; ++var7) {
  16.                 Method var8 = var5[var7];
  17.                 this.addProxyMethod(var8, var4);
  18.             }
  19.         }
  20.         Iterator var11 = this.proxyMethods.values().iterator();
  21.         List var12;
  22.         while(var11.hasNext()) {
  23.             var12 = (List)var11.next();
  24.             checkReturnTypes(var12);
  25.         }
  26.         Iterator var15;
  27.         try {
  28.             //生成代理类的构造函数
  29.             this.methods.add(this.generateConstructor());
  30.             var11 = this.proxyMethods.values().iterator();
  31.             while(var11.hasNext()) {
  32.                 var12 = (List)var11.next();
  33.                 var15 = var12.iterator();
  35.                 while(var15.hasNext()) {
  36.                     ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
  37.                     this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
  38.                     this.methods.add(var16.generateMethod());
  39.                 }
  40.             }
  41.             this.methods.add(this.generateStaticInitializer());
  42.         } catch (IOException var10) {
  43.             throw new InternalError("unexpected I/O Exception", var10);
  44.         }
  45.         if(this.methods.size() > '\uffff') {
  46.             throw new IllegalArgumentException("method limit exceeded");
  47.         } else if(this.fields.size() > '\uffff') {
  48.             throw new IllegalArgumentException("field limit exceeded");
  49.         } else {
  50.             this.cp.getClass(dotToSlash(this.className));
  51.             this.cp.getClass("java/lang/reflect/Proxy");
  52.             var1 = this.interfaces;
  53.             var2 = var1.length;
  54.             for(var3 = 0; var3 < var2; ++var3) {
  55.                 var4 = var1[var3];
  56.                 this.cp.getClass(dotToSlash(var4.getName()));
  57.             }
  58.             this.cp.setReadOnly();
  59.             ByteArrayOutputStream var13 = new ByteArrayOutputStream();
  60.             DataOutputStream var14 = new DataOutputStream(var13);
  61.             try {
  62.                 var14.writeInt(-889275714);
  63.                 var14.writeShort(0);
  64.                 var14.writeShort(49);
  65.                 this.cp.write(var14);
  66.                 var14.writeShort(this.accessFlags);
  67.                 var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
  68.                 var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
  69.                 var14.writeShort(this.interfaces.length);
  70.                 Class[] var17 = this.interfaces;
  71.                 int var18 = var17.length;
  72.                 for(int var19 = 0; var19 < var18; ++var19) {
  73.                     Class var22 = var17[var19];
  74.                     var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
  75.                 }
  76.                 var14.writeShort(this.fields.size());
  77.                 var15 = this.fields.iterator();
  78.                 while(var15.hasNext()) {
  79.                     ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
  80.                     var20.write(var14);
  81.                 }
  82.                 var14.writeShort(this.methods.size());
  83.                 var15 = this.methods.iterator();
  84.                 while(var15.hasNext()) {
  85.                     ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
  86.                     var21.write(var14);
  87.                 }
  88.                 var14.writeShort(0);
  89.                 return var13.toByteArray();
  90.             } catch (IOException var9) {
  91.                 throw new InternalError("unexpected I/O Exception", var9);
  92.             }
  93.         }
  94.     }

字节码生成后，调用defineClass0来解析字节码，生成了Proxy的Class对象。在了解完代理类动态生成过程后，生产的代理类是怎样的，谁来执行这个代理类。
其中，在ProxyGenerator.generateProxyClass函数中 saveGeneratedFiles定义如下，其指代是否保存生成的代理类class文件，默认false不保存。
在前面的示例中，我们修改了此系统变量：

  1. System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

java动态代理 - 图1
image.png
如图，生成了两个名为 java动态代理 - 图2Proxy1.class的class文件。
动态代理流程图：

java动态代理 - 图3

作者：只是肿态度 链接：https://www.jianshu.com/p/9bcac608c714 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。