java动态代理的内部实现

hadoop中的RPC是个很重要的机制，datanode与namenode之间的通信通过RPC方式在实现，其中java的动态代理与反射等相关机制在里面扮演了重要的角色。下午花了点时间，弄了个简单的代理实例，按照个人的理解来粗讲下的proxy的内部实现。

 

一.相关类及其方法:

java.lang.reflect.Proxy：  Proxy 提供用于创建动态代理类和实例的静态方法.
newProxyInstance()：   返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序


java.lang.reflect.InvocationHandler：   InvocationHandler 是代理实例的调用处理程序 实现的接口，主要是帮助proxy来完成调用转发，实现目标类的接口调用。 
 

 invoke() ：  在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

以上的相关说明 可以直接查看jdk下面的相关类，比较清楚。

 

二.测试的源代码:

目标类 及需要调用的接口

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

package test; public interface Server {     public void setName(String name);   public String getName();    }   public class NameServer implements Server {   private String name = null;     public void setName(String name){    this.name = name;   }      public String getName(){    return this.name;   }   }

 

实现调用转发的InvocationHandler类：

 

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

package test; import java.lang.reflect.InvocationHandler; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Proxy; import java.lang.reflect.Method; import java.lang.reflect.Field; import java.lang.reflect.Constructor; import java.lang.Class; import java.lang.ClassLoader; import java.lang.ClassCastException; import org.apache.ojb.jdo.jdoql.ThisExpression; import org.jmock.core.matcher.InvokeAtLeastOnceMatcher; public class MyInvocationHandler implements InvocationHandler {   Object target = null;     public void setTarget(Object object){    this.target = object;   }      public MyInvocationHandler(Object object){    this.target = object;   }   public MyInvocationHandler(){       }      public Object invoke(Object proxy, Method method, Object[] args){    Object result = null;      try {     System.out.println("begin to call method: " + method.getName());      result = method.invoke(this.target, args);   //转发调用目标类的接口     System.out.println("method: " + method.getName() + " has been called!");    } catch (InvocationTargetException e) {     // TODO: handle exception     e.printStackTrace();    }catch (IllegalAccessException e) {     // TODO: handle exception     e.printStackTrace();    }   return result;   } }

 

客户端：

 

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import test.MyInvocationHandler;
import test.NameServer;

public class MyProxyTest {

  public static void main(String[] args)
   throws ClassCastException, ClassNotFoundException,
   IllegalAccessException,InstantiationException{
   
   Class<?> nameServerClass = (Class<NameServer>)Class.forName("test.NameServer");
   NameServer nameServerImpl = (NameServer)nameServerClass.newInstance();  //目标接口实例
   
   //创建一个InvocationHandler实例给proxy，用来转发调用
   Class<MyInvocationHandler> invocationHandlerClass =
        (Class<MyInvocationHandler>)Class.forName("test.MyInvocationHandler");
   MyInvocationHandler invocationHandler = (MyInvocationHandler)invocationHandlerClass.newInstance();
   invocationHandler.setTarget(nameServerImpl);
   //MyInvocationHandler invocationHandler = new MyInvocationHandler(nameServerImpl);
   
   //创建nameserver的代理类
   Server serverProxy = (Server)Proxy.newProxyInstance(
       nameServerClass.getClassLoader(),
      // new Class[]{Server.class},
       nameServerImpl.getClass().getInterfaces(),
       invocationHandler
       );
   serverProxy.setName("Michael");
   
   String name = serverProxy.getName();
   System.out.println("name: " + name);
  }
 
}

 

三.执行结果:

begin to call method: setName
method: setName has been called!
begin to call method: getName
method: getName has been called!
name: Michael

 

四.机制分析:

Proxy.(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下几件事.
(1)根据参数loader和interfaces调用方法 getProxyClass(loader, interfaces)创建代理类$Proxy.
$Proxy0类实现了interfaces的接口,并继承了Proxy类.
(2)实例化$Proxy0并在构造方法中把BusinessHandler传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下:

1 2 3 4 5 6 7

class  Proxy{      InvocationHandler h= null ;      protected  Proxy(InvocationHandler h) {       this .h = h;      }      ... public static Object newProxyInstance(ClassLoader loader,        Class<?>[] interfaces,        InvocationHandler h)  throws IllegalArgumentException{        } }

 

关键在于$Proxy0它的内部实现机制，下面是本测试实例中$Proxy0的内部代码，通过观察$Proxy0，代理实现的机制一目了然：

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 Server  { 

       

private  static  Method m1; 

private  static  Method m0; 

private  static  Method m3; 

private  static  Method m2; 

private static Method m5;

       

static  { 

    try  { 

     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 ]); 

     m3 = Class.forName( "test.Server" ).getMethod( "setName" , 

       new  Class[ 0 ]); 

     m2 = Class.forName( "java.lang.Object" ).getMethod( "toString" , 

       new  Class[ 0 ]); 

    m5 = Class.forName("test.Server").getMethod("getName",

      new Class[0]);

    }  catch  (NoSuchMethodException nosuchmethodexception) { 

     throw  new  NoSuchMethodError(nosuchmethodexception.getMessage()); 

    }  catch  (ClassNotFoundException classnotfoundexception) { 

     throw  new  NoClassDefFoundError(classnotfoundexception.getMessage()); 

    } 

} 

       

public  $Proxy0(InvocationHandler invocationhandler) { 

    super (invocationhandler); 

} 

       

@Override

public  final  boolean  equals(Object obj) { 

    try  { 

     return  ((Boolean)  super .h.invoke( this , m1,  new  Object[] { obj })) 

       .booleanValue(); 

    }  catch  (Throwable throwable) { 

     throw  new  UndeclaredThrowableException(throwable); 

    } 

} 

       

@Override

public  final  int  hashCode() { 

    try  { 

     return  ((Integer)  super .h.invoke( this , m0,  null )).intValue(); 

    }  catch  (Throwable throwable) { 

     throw  new  UndeclaredThrowableException(throwable); 

    } 

} 

       

public  final  void setName (String arg) { 

    try  { 

     super .h.invoke( this , m3, arg ); 

     return ; 

    }  catch  (Error e) { 

    }  catch  (Throwable throwable) { 

     throw  new  UndeclaredThrowableException(throwable); 

    } 

} 

       

@Override

public  final  String toString() { 

    try  { 

     return  (String)  super .h.invoke( this , m2,  null ); 

    }  catch  (Throwable throwable) { 

     throw  new  UndeclaredThrowableException(throwable); 

    } 

} 

 

public final String getName() {

 

   try{

    retrun (String) super.h.invoke(this, m5, null);

   } catch(Throwable throwable) {

    throw new UndeclaredThrowableException(throwable);

   }

} 

}

 

接着把得到的$Proxy0实例强制转换成Server.
当执行serverProxy.setName()方法时,就调用了$Proxy0类中的setName()方法.

public $Proxy0(InvocationHandler invocationhandler) {

   super(invocationhandler);

}

在setName方法中,调用父类Proxy中的h（$Proxy0的构造器初始化为我们定义的invocationhanddler）的invoke()方法.
即InvocationHandler.invoke(); Proxy.newProxyInstance(..)方法执行时生成了$Proxy0的内存字节码文件并return出来赋给了

serverProxy，强制转化成了server接口，同时$Proxy0也实现了server接口中的所有方法.

 

下面是Proxy类中的关于$Proxy0的生成：

public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)
 throws IllegalArgumentException
{

     ..........

  long num;
  synchronized (nextUniqueNumberLock) {
      num = nextUniqueNumber++;
  }
  String proxyName = proxyPkg + proxyClassNamePrefix + num;
  /*
   * Verify that the class loader hasn't already
   * defined a class with the chosen name.
   */

  /*
   * Generate the specified proxy class.
   */
  byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
      proxyName, interfaces);
  try {
      proxyClass = defineClass0(loader, proxyName,   //这里就得到了$Proxy0的实现，从Proxy继承，并实现了用户目标接口Server
   proxyClassFile, 0, proxyClassFile.length);

}......

 

return proxyClass;

}

 

 

 

所以JAVA的动态代理的关键就在Proxy.newProxyInstance(..)方法执行时生成了$Proxy0的内存字节码以及JDK的反射机制！

1.产生代理类$Proxy0类

执行了Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

将产生$Proxy0类，它继承Proxy对象，并根据第二个参数，实现了被代理类的所有接口，自然就可以生成接口要实现的所有方法了（这时候会重写hashcode，toString和equals三个方法），但是还没有具体的实现体；

2.    将代理类$Proxy0类加载到JVM中

这时候是根据Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第一个参数----就是被代理类的类加载器，把当前的代理类加载到JVM中

3.    创建代理类$Proxy0类的对象

调用的$Proxy0类的$Proxy0（InvocationHandler）构造函数，生成$Proxy0类的对象

参数就是Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)它的第三个参数

这个参数就是我们自己实现的InvocationHandler对象，我们知道InvocationHandler对象中组合加入了代理类代理的接口类的实现类；所以，$Proxy0对象调用所有要实现的接口的方法，都会调用InvocationHandler对象的invoke（）方法实现；

4.    生成代理类的class byte

动态代理生成的都是二进制class字节码