深度剖析JDK动态代理机制

摘要

相比于静态代理，动态代理避免了开发人员编写各个繁锁的静态代理类，只需简单地指定一组接口及目标类对象就能动态的获得代理对象。

代理模式

使用代理模式必须要让代理类和目标类实现相同的接口，客户端通过代理类来调用目标方法，代理类会将所有的方法调用分派到目标对象上反射执行，还可以在分派过程中添加"前置通知"和后置处理（如在调用目标方法前校验权限，在调用完目标方法后打印日志等）等功能。

 

使用动态代理的五大步骤

1.通过实现InvocationHandler接口来自定义自己的InvocationHandler;

 

2.通过Proxy.getProxyClass获得动态代理类

 

3.通过反射机制获得代理类的构造方法，方法签名为getConstructor(InvocationHandler.class)

 

4.通过构造函数获得代理对象并将自定义的InvocationHandler实例对象传为参数传入

 

5.通过代理对象调用目标方法

 

动态代理的使用

例1(方式一)

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

public class MyProxy {      public interface IHello{          void sayHello();      }      static class Hello implements IHello{          public void sayHello() {              System.out.println( "Hello world!!" );          }      }      //自定义InvocationHandler      static  class HWInvocationHandler implements InvocationHandler{          //目标对象          private Object target;          public HWInvocationHandler(Object target){              this .target = target;          }          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {              System.out.println( "------插入前置通知代码-------------" );              //执行相应的目标方法              Object rs = method.invoke(target,args);              System.out.println( "------插入后置处理代码-------------" );              return rs;          }      }      public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetExc    eption, InstantiationException {          //生成$Proxy0的class文件          System.getProperties().put( "sun.misc.ProxyGenerator.saveGeneratedFiles" , "true" );          //获取动态代理类          Class proxyClazz = Proxy.getProxyClass(IHello. class .getClassLoader(),IHello. class );          //获得代理类的构造函数，并传入参数类型InvocationHandler.class          Constructor constructor = proxyClazz.getConstructor(InvocationHandler. class );          //通过构造函数来创建动态代理对象，将自定义的InvocationHandler实例传入          IHello iHello = (IHello) constructor.newInstance( new HWInvocationHandler( new Hello()));          //通过代理对象调用目标方法          iHello.sayHello();      } }




输出：

------插入前置通知代码-------------
Hello world!!
------插入后置处理代码-------------

Proxy类中还有个将2~4步骤封装好的简便方法来创建动态代理对象，其方法签名为：newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h)，如下例：

(方式二)

?

1 2 3 4 5 6 7 8

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {         //生成$Proxy0的class文件         System.getProperties().put( "sun.misc.ProxyGenerator.saveGeneratedFiles" , "true" );         IHello  ihello = (IHello) Proxy.newProxyInstance(IHello. class .getClassLoader(),  //加载接口的类加载器                 new Class[]{IHello. class },      //一组接口                 new HWInvocationHandler( new Hello())); //自定义的InvocationHandler         ihello.sayHello();     }

输出结果一样.

 

下面以newProxyInstance方法为切入点来剖析代理类的生成及代理方法的调用

（为了篇幅整洁去掉了次要的代码）

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

public static Object newProxyInstance(ClassLoader loader,                                            Class<!--?-->[] interfaces,                                            InvocationHandler h)              throws IllegalArgumentException      {          if (h == null ) {   //如果h为空直接抛出异常，所以InvocationHandler实例对象是必须的              throw new NullPointerException();          }          //对象的拷贝,暂不知道这里拷贝下的意义是啥？          final Class<!--?-->[] intfs = interfaces.clone();          //一些安全的权限检查          final SecurityManager sm = System.getSecurityManager();          if (sm != null ) {              checkProxyAccess(Reflection.getCallerClass(), loader, intfs);          }          //产生代理类          Class<!--?--> cl = getProxyClass0(loader, intfs);            //获取代理类的构造函数对象          //参数constructorParames为常量值：private static final Class<!--?-->[] constructorParams = { InvocationHandler.class };          final Constructor<!--?--> cons = cl.getConstructor(constructorParames);          final InvocationHandler ih = h;          //根据代理类的构造函数对象来创建代理类对象          return newInstance(cons, ih);                     }

这段代码就是对代理类对象的创建，就是对例1中34~38行封装，其中getProxyClass0就是生成代理类的方法

getProxyClass0方法剖析

?

1 2 3 4 5 6 7 8 9

private static Class<!--?--> getProxyClass0(ClassLoader loader,                                             Class<!--?-->... interfaces) { //接口数不得超过65535个          if (interfaces.length > 65535 ) {              throw new IllegalArgumentException( "interface limit exceeded" );          } //代理类缓存，如果缓存中有代理类了直接返回，否则将由ProxyClassFactory创建代理类          return proxyClassCache.get(loader, interfaces);      }




看看ProxyClassFactory是怎样生成代理类的?

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

private static final class ProxyClassFactory          implements BiFunction<classloader, class <?= "" >[], Class<!--?-->>      {          //统一代理类的前缀名都以$Proxy开关          private static final String proxyClassNamePrefix = "$Proxy" ;          //使用唯一的编号给作为代理类名的一部分，如$Proxy0,$Proxy1等          private static final AtomicLong nextUniqueNumber = new AtomicLong();          @Override          public Class<!--?--> apply(ClassLoader loader, Class<!--?-->[] interfaces) {              Map< class <?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);              for (Class<!--?--> intf : interfaces) {                  //验证指定的类加载器(loader)加载接口所得到的Class对象(interfaceClass)是否与intf对象相同                  Class<!--?--> interfaceClass = null ;                  try {                      interfaceClass = Class.forName(intf.getName(), false , loader);                  } catch (ClassNotFoundException e) {                  }                  if (interfaceClass != intf) {                      throw new IllegalArgumentException(                          intf + " is not visible from class loader" );                  }                  //验证该Class对象是不是接口                  if (!interfaceClass.isInterface()) {                      throw new IllegalArgumentException(                          interfaceClass.getName() + " is not an interface" );                  }                  // 验证该接口是否重复了                  if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null ) {                      throw new IllegalArgumentException(                          "repeated interface: " + interfaceClass.getName());                  }              }                    //声明代理类所在包              String proxyPkg = null ;                /*验证你传入的接口中是否有非public接口，只要有一个接口是非public的，那么这些接口都必须在同一包中              这里的接口修饰符直接影响到System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")所生成              的代理类的路径，往下看！！*/              for (Class<!--?--> intf : interfaces) {                  int flags = intf.getModifiers();                  if (!Modifier.isPublic(flags)) {                      String name = intf.getName();                      int n = name.lastIndexOf( '.' );                      //截取完整包名                      String pkg = ((n == - 1 ) ? "" : name.substring( 0 , n + 1 ));                      if (proxyPkg == null ) {                          proxyPkg = pkg;                      } else if (!pkg.equals(proxyPkg)) {                          throw new IllegalArgumentException(                              "non-public interfaces from different packages" );                      }                  }              }                            if (proxyPkg == null ) {                  /*如果都是public接口，那么生成的代理类就在com.sun.proxy包下如果报java.io.FileNotFoundException: com\sun\proxy\$Proxy0.c                  lass (系统找不到指定的路径。)的错误，就先在你项目中创建com.sun.proxy路径*/                              proxyPkg = ReflectUtil.PROXY_PACKAGE + "." ;              }                 //将当前nextUniqueNumber的值以原子的方式的加1，所以第一次生成代理类的名字为$Proxy0.class              long num = nextUniqueNumber.getAndIncrement();              //代理类的完全限定名，如com.sun.proxy.$Proxy0.calss,              String proxyName = proxyPkg + proxyClassNamePrefix + num;              //生成代理类字节码文件                          byte [] proxyClassFile = ProxyGenerator.generateProxyClass(                  proxyName, interfaces);              try {                  return defineClass0(loader, proxyName,                                      proxyClassFile, 0 , proxyClassFile.length);              } catch (ClassFormatError e) {                  throw new IllegalArgumentException(e.toString());              }          }      }</ class <?></classloader,>

 

而生成代理类字节码文件又主要通过ProxyGenerate的generateProxyClass(proxyName，interfaces)

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public static byte [] generateProxyClass( final String var0, Class[] var1) {          ProxyGenerator var2 = new ProxyGenerator(var0, var1);         //生成代理类字节码文件的真正方法          final byte [] var3 = var2.generateClassFile();          //保存文件          if (saveGeneratedFiles) {              AccessController.doPrivileged( new PrivilegedAction() {                  public Void run() {                      try {                          FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class" );                          var1.write(var3);                          var1.close();                          return null ;                      } catch (IOException var2) {                          throw new InternalError( "I/O exception saving generated file: " + var2);                      }                  }              });          }          return var3;      }

 

层层调用后，最终generateClassFile才是真正生成代理类字节码文件的方法， 注意开头的三个addProxyMethod方法是只将Object的hashcode,equals,toString方法添加到代理方法容器中，代理类除此之外并没有重写其他Object的方法，所以除这三个方法外，代理类调用其他方法的行为与Object调用这些方法的行为一样不通过Invoke

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93

private byte [] generateClassFile() {          /addProxyMethod系列方法就是将接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods),           其中方法签名作为key,proxyMethod作为value*/          /*hashCodeMethod方法位于静态代码块中通过Object对象获得，hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),           相当于从Object中继承过来了这三个方法equalsMethod,toStringMethod*/              this .addProxyMethod(hashCodeMethod, Object. class );   -->          this .addProxyMethod(equalsMethod, Object. class );          this .addProxyMethod(toStringMethod, Object. class );          int var1;          int var3;           //获得所有接口中的所有方法，并将方法添加到代理方法中          for (var1 = 0 ; var1 < this .interfaces.length; ++var1) {              Method[] var2 = this .interfaces[var1].getMethods();                         for (var3 = 0 ; var3 < var2.length; ++var3) {                  this .addProxyMethod(var2[var3], this .interfaces[var1]);              }          }                     Iterator var7 = this .proxyMethods.values().iterator();          List var8;          while (var7.hasNext()) {              var8 = (List)var7.next();              checkReturnTypes(var8);    //验证具有相同方法签名的的方法的返回值类型是否一致，因为不可能有两个方法名相同,参数相同，而返回值却不同的方法          };      //接下来就是写代理类文件的步骤了          Iterator var11          try {               //生成代理类的构造函数              this .methods.add( this .generateConstructor());              var7 = this .proxyMethods.values().iterator();              while (var7.hasNext()) {                  var8 = (List)var7.next();                  var11 = var8.iterator();                  while (var11.hasNext()) {                      ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next();                      /将代理字段声明为Method， 10 为ACC_PRIVATE和ACC_STATAIC的与运算，表示该字段的修饰符为 private static                       所以代理类的字段都是 private static Method XXX*/                      this .fields.add( new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;" , 10 ));                      //生成代理类的代理方法                      this .methods.add(var4.generateMethod());                  }              }              //为代理类生成静态代码块，对一些字段进行初始化              this .methods.add( this .generateStaticInitializer());          } catch (IOException var6) {              throw new InternalError( "unexpected I/O Exception" );          }                  if ( this .methods.size() > '\uffff' ) {  //代理方法超过65535将抛出异常              throw new IllegalArgumentException( "method limit exceeded" );          } else if ( this .fields.size() > '\uffff' ) {   //代理类的字段超过65535将抛出异常              throw new IllegalArgumentException( "field limit exceeded" );          } else {           //这里开始就是一些代理类文件的过程，此过程略过              this .cp.getClass(dotToSlash( this .className));              this .cp.getClass( "java/lang/reflect/Proxy" );              for (var1 = 0 ; var1 < this .interfaces.length; ++var1) {                  this .cp.getClass(dotToSlash( this .interfaces[var1].getName()));              }              this .cp.setReadOnly();              ByteArrayOutputStream var9 = new ByteArrayOutputStream();              DataOutputStream var10 = new DataOutputStream(var9);              try {                  var10.writeInt(- 889275714 );                  var10.writeShort( 0 );                  var10.writeShort( 49 );                  this .cp.write(var10);                  var10.writeShort( 49 );                  var10.writeShort( this .cp.getClass(dotToSlash( this .className)));                  var10.writeShort( this .cp.getClass( "java/lang/reflect/Proxy" ));                  var10.writeShort( this .interfaces.length);                  for (var3 = 0 ; var3 < this .interfaces.length; ++var3) {                      var10.writeShort( this .cp.getClass(dotToSlash( this .interfaces[var3].getName())));                  }                  var10.writeShort( this .fields.size());                  var11 = this .fields.iterator();                  while (var11.hasNext()) {                      ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next();                      var12.write(var10);                  }                  var10.writeShort( this .methods.size());                  var11 = this .methods.iterator();                  while (var11.hasNext()) {                      ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next();                      var13.write(var10);                  }                  var10.writeShort( 0 );                  return var9.toByteArray();              } catch (IOException var5) {                  throw new InternalError( "unexpected I/O Exception" );              }          }      }

 

addProxyMethod方法剖析

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

private void addProxyMethod(Method var1, Class var2) {          String var3 = var1.getName();  //方法名          Class[] var4 = var1.getParameterTypes();   //方法参数类型数组          Class var5 = var1.getReturnType();    //返回值类型          Class[] var6 = var1.getExceptionTypes();   //异常类型          String var7 = var3 + getParameterDescriptors(var4);   //方法签名          Object var8 = (List) this .proxyMethods.get(var7);   //根据方法签名却获得proxyMethods的Value          if (var8 != null ) {    //处理多个代理接口中重复的方法的情况              Iterator var9 = ((List)var8).iterator();              while (var9.hasNext()) {                  ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();                  if (var5 == var10.returnType) {                      /*归约异常类型以至于让重写的方法抛出合适的异常类型，我认为这里可能是多个接口中有相同的方法，而这些相同的方法抛出的异常类                      型又不同，所以对这些相同方法抛出的异常进行了归约*/                      ArrayList var11 = new ArrayList();                      collectCompatibleTypes(var6, var10.exceptionTypes, var11);                      collectCompatibleTypes(var10.exceptionTypes, var6, var11);                      var10.exceptionTypes = new Class[var11.size()];                      //将ArrayList转换为Class对象数组                      var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);                      return ;                  }              }          } else {              var8 = new ArrayList( 3 );              this .proxyMethods.put(var7, var8);          }              ((List)var8).add( new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null ));         /*24~27行的意思就是如果var8为空，就创建一个数组，并以方法签名为key,proxymethod对象数组为value添加到proxyMethods*/      }

InvocationHandler的作用

在动态代理中InvocationHandler是核心，每个代理实例都具有一个关联的调用处理程序(InvocationHandler)。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序(InvocationHandler)的 invoke 方法。所以对代理方法的调用都是通InvocationHadler的invoke来实现中，而invoke方法根据传入的代理对象，方法和参数来决定调用代理的哪个方法

invoke方法签名：invoke（Object Proxy，Method method，Object[] args）

 

$Proxy0.class

来看看例1(MyProxy)的代理类是怎样的？

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

public final class $Proxy0 extends Proxy implements IHello {   //继承了Proxy类和实现IHello接口      //变量，都是private static Method  XXX      private static Method m3;        private static Method m1;      private static Method m0;      private static Method m2;      //代理类的构造函数，其参数正是是InvocationHandler实例，Proxy.newInstance方法就是通过通过这个构造函数来创建代理实例的      public $Proxy0(InvocationHandler var1) throws  {          super (var1);      }      //接口代理方法      public final void sayHello() throws  {          try {              super .h.invoke( this , m3, (Object[]) null );          } catch (RuntimeException | Error var2) {              throw var2;          } catch (Throwable var3) {              throw new UndeclaredThrowableException(var3);          }      }      //以下Object中的三个方法      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 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);          }      }      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);          }      }      //对变量进行一些初始化工作      static {          try {              m3 = Class.forName( "com.mobin.proxy.IHello" ).getMethod( "sayHello" , new Class[ 0 ]);              m1 = Class.forName( "java.lang.Object" ).getMethod( "equals" , new Class[]{Class.forName( "java.lang.Object" )});              m0 = Class.forName( "java.lang.Object" ).getMethod( "hashCode" , new Class[ 0 ]);              m2 = Class.forName( "java.lang.Object" ).getMethod( "toString" , new Class[ 0 ]);          } catch (NoSuchMethodException var2) {              throw new NoSuchMethodError(var2.getMessage());          } catch (ClassNotFoundException var3) {              throw new NoClassDefFoundError(var3.getMessage());          }      } }

 

以上就是对代理类如何生成，代理类方法如何被调用的分析！在很多框架都使用了动态代理如Spring,HDFS的RPC调用等等，分析过程中收获很多，如果想深入的了解JDK动态代理机制一定要深入到源码去剖析！！

原文地址：http://www.cnblogs.com/MOBIN/p/5597215.html