深入浅出动态代理

  • 2019 年 11 月 6 日
  • 筆記

代理模式是为了提供额外或者不同的操作，而插入代替”实际对象”的对象，即代理类，针对代理类的调用操作，都会涉及到与”实际对象”的通信，代理类起到中间人的作用。Java动态代理比代理的思想更进一步，它可以动态的创建代理类并处理对”实际对象”的调用，Java动态代理底层基于Proxy/InvocationHandler相关类和反射技术。

Java动态代理

Java动态代理底层基于Proxy/InvocationHandler相关类和反射技术，注意，Java动态代理只能做接口的动态代理。下面是一个Java动态代理的示例： 

public interface Hello {      String hello(String msg);  }  public static class HelloImpl implements Hello {      @Override      public String hello(String msg) {          return "hello " + msg;      }  }    public static class HelloProxy implements InvocationHandler {      private Object target = null;        public Object build(Object target) {          this.target = target;          return Proxy.newProxyInstance(                  target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);      }        @Override      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {          return method.invoke(target, args);      }  }    public static void main(String[] args) throws Exception {      // 设置此属性，让JVM自动生成的proxy类写入文件      System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");        HelloImpl helloImpl = new HelloImpl();      Hello hello = (Hello) new HelloProxy().build(helloImpl);        System.out.println(hello.hello("world"));  }

Java动态代理为什么只能做接口的动态代理呢，这与JDK动态生成代理类机制有关，JDK动态生成代理类逻辑如下： 

/**   * var0：代理类名称，比如com.sun.proxy.$Proxy0   * var1：代理接口   * var2：代理类访问标识   */  public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {      ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);      final byte[] var4 = var3.generateClassFile();      if (saveGeneratedFiles) {  		// 如果开启了保存proxy文件，则进行保存          AccessController.doPrivileged(new PrivilegedAction<Void>() {              public Void run() {                  try {                      int var1 = var0.lastIndexOf(46);                      Path var2;                      if (var1 > 0) {                          Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));                          Files.createDirectories(var3);                          var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");                      } else {                          var2 = Paths.get(var0 + ".class");                      }                        Files.write(var2, var4, new OpenOption[0]);                      return null;                  } catch (IOException var4x) {                      throw new InternalError("I/O exception saving generated file: " + var4x);                  }              }          });      }        return var4;  }

Java动态代理自动生成代理类的逻辑是生成一个代理接口的实现类（这也是只能做接口动态代理的原因），对该类中方法调用都指向到了我们自己定义的xxxInvocationHandler，在xxxInvocationHandler中再通过反射调用真正类的方法，这样就完成了一次动态代理的方法调用。比如，示例中自动生成类com.sun.proxy.$Proxy0文件如下所示： 

package com.sun.proxy;    import com.luo.demo.boot.dyn.DynMain.Hello;  import java.lang.reflect.InvocationHandler;  import java.lang.reflect.Method;  import java.lang.reflect.Proxy;  import java.lang.reflect.UndeclaredThrowableException;    public final class $Proxy0 extends Proxy implements Hello {      private static Method m1;      private static Method m2;      private static Method m3;      private static Method m0;        public $Proxy0(InvocationHandler var1) throws  {          super(var1);      }        public final boolean equals(Object var1) throws  {          try {              return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();          } catch (RuntimeException | Error var3) {              throw var3;          } catch (Throwable var4) {              throw new UndeclaredThrowableException(var4);          }      }        public final String toString() throws  {          try {              return (String)super.h.invoke(this, m2, (Object[])null);          } catch (RuntimeException | Error var2) {              throw var2;          } catch (Throwable var3) {              throw new UndeclaredThrowableException(var3);          }      }        public final String hello(String var1) throws  {          try {              return (String)super.h.invoke(this, m3, new Object[]{var1});          } catch (RuntimeException | Error var3) {              throw var3;          } catch (Throwable var4) {              throw new UndeclaredThrowableException(var4);          }      }        public final int hashCode() throws  {          try {              return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();          } catch (RuntimeException | Error var2) {              throw var2;          } catch (Throwable var3) {              throw new UndeclaredThrowableException(var3);          }      }        static {          try {              m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));              m2 = Class.forName("java.lang.Object").getMethod("toString");              m3 = Class.forName("com.luo.demo.boot.dyn.DynMain$Hello").getMethod("hello", Class.forName("java.lang.String"));              m0 = Class.forName("java.lang.Object").getMethod("hashCode");          } catch (NoSuchMethodException var2) {              throw new NoSuchMethodError(var2.getMessage());          } catch (ClassNotFoundException var3) {              throw new NoClassDefFoundError(var3.getMessage());          }      }  }

Java动态代理能满足针对接口的场景，如果对没有实现接口的动态代理该如何做呢？这个时候就该cglib上场了~

cglib动态代理

cglib是一个强大的高性能代码生成包，被广泛的用于AOP框架中，比如Spring AOP就用到了cglib（Spring中如果代理类实现了接口，就使用jdk动态代理，否则使用cglib）。

CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。除了CGLIB包，脚本语言例如Groovy和BeanShell，也是使用ASM来生成java的字节码。当然不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

cglib示例代码如下： 

public static class HelloServiceImpl {      public String hello(String msg) {          return "hello " + msg;      }  }    // 利用Enhancer类生成代理类  public static class MyMethodInterceptor implements MethodInterceptor {      @Override      public Object intercept(Object obj, Method method, Object[] arg, MethodProxy methodProxy)              throws Throwable {          return methodProxy.invokeSuper(obj, arg);      }  }    public static void main(String[] args) {      // 设置将cglib生成的代理类字节码生成到指定位置      System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\ideas2\cglib");        Enhancer enhancer = new Enhancer();      enhancer.setSuperclass(HelloServiceImpl.class);      enhancer.setCallback(new MyMethodInterceptor());        HelloServiceImpl helloService = (HelloServiceImpl) enhancer.create();      System.out.println(helloService.hello("world"));  }

cglib生成的代理类实际上是指定类的子类，比如上面例子cglib自动生成的代理类如下所示： 

public class CglibMain$HelloServiceImpl$$EnhancerByCGLIB$$15d87b9c extends HelloServiceImpl implements Factory {  	final String CGLIB$hello$0(String var1) {          return super.hello(var1);      }        public final String hello(String var1) {          MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;          if (this.CGLIB$CALLBACK_0 == null) {              CGLIB$BIND_CALLBACKS(this);              var10000 = this.CGLIB$CALLBACK_0;          }            return var10000 != null ? (String)var10000.intercept(this, CGLIB$hello$0$Method, new Object[]{var1}, CGLIB$hello$0$Proxy) : super.hello(var1);      }        // 其他方法，比如equals、toString、hashCode、clone等  }

如果cglib要代理的指定类是final类型的，也就是上例中HelloServiceImpl如果是final的，则cglib在创建子类时报异常；如果指定类中方法是final的，则创建子类是OK的，但是针对该final方法的调用不会产生动态代理的效果。

小结

Java动态代理底层基于Proxy/InvocationHandler相关类和反射技术，其自动生成代理类的逻辑是生成一个代理接口的实现类（这也是只能做接口动态代理的原因），对该类中方法调用都指向到了我们自己定义的xxxInvocationHandler，在xxxInvocationHandler中再通过反射调用真正类的方法。

cglib的动态代理底层通过asm生成要代理类的子类，在该子类中调用我们自定义的xxxMethodInterceptor,在xxxMethodInterceptor中调用子类中对应方法，对应方法内部直接通过supper.xxx()调用对应要代理类的方法。

参考资料：

1、深入浅出Java反射(https://topcoder.site/2018/08/%E6%B7%B1%E5%85%A5%E6%B5%85%E5%87%BAJava%E5%8F%8D%E5%B0%84/)

VirMach 便宜 VPS

QNews

QNews