java-动态代理-从源码分析

现在有一个接口UserService

public interface UserService {  /**  * 目标方法   */  public abstract void add();  }  

有一个实现类

public class UserServiceImpl implements UserService {  /* (non-Javadoc)  * @see dynamic.proxy.UserService#add()  */  public void add() {      System.out.println("--------------------add---------------");  }  }  

有一个InvocationHandler类

public class MyInvocationHandler implements InvocationHandler {  // 目标对象   private Object target;  /**  * 构造方法  * @param target 目标对象   */  public MyInvocationHandler(Object target) {      super();      this.target = target;  }  /**  * 执行目标对象的方法  */  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {      // 在目标对象的方法执行之前简单的打印一下      System.out.println("------------------before------------------");      // 执行目标对象的方法      Object result = method.invoke(target, args);      // 在目标对象的方法执行之后简单的打印一下      System.out.println("-------------------after------------------");      return result;  }  }  

现在就可以实现动态代理啦

public class ProxyTest {  @Test  public void testProxy() throws Throwable {      // 实例化目标对象      UserService userService = new UserServiceImpl();      // 实例化InvocationHandler      MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);      // 根据目标对象生成代理对象,参数为：一个classloader，一个接口数组，一个invocationHandler     UserService proxy = (UserService)Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),userService.getClass().getInterfaces(), invocationHandler );    // 调用代理对象的方法      proxy.add();  }  }  

解析

当你刚看到动态代理时，会感到非常疑惑与混乱。但最终的结果告诉我们，最后执行的代码是invocationHandler.invoke方法：

System.out.println("------------------before------------------");      // 执行目标对象的方法      Object result = method.invoke(target, args);      // 在目标对象的方法执行之后简单的打印一下      System.out.println("-------------------after------------------");  

通过查看Proxy.newProxyInstance方法的源码，我发现，有用的就两句话，大概意思是：

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
Class proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
Constructor cons = proxyClass.getConstructor(InvocationHandler.class);
return (Object) cons.newInstance(new Object[] { invocationHandler });

java用Proxy.newInstance的第二个参数：接口数组，构造了一个新的class，并且返回了一个用该class构造的一个新的对象，通过反编译工具，来将该class文件反编译为一个java文件，来看看究竟：

public final class $Proxy11 extends Proxy  implements UserService  {   public $Proxy11(InvocationHandler invocationhandler)  {      super(invocationhandler);  }  public final boolean equals(Object obj)  {      try      {          return ((Boolean)super.h.invoke(this, m1, new Object[] {              obj          })).booleanValue();      }      catch(Error _ex) { }      catch(Throwable throwable)      {          throw new UndeclaredThrowableException(throwable);      }  }  @这个方法是关键部分@ public final void add()  {      try      {            super.h.invoke(this, m3, null);          return;      }      catch(Error _ex) { }      catch(Throwable throwable)      {          throw new UndeclaredThrowableException(throwable);      }  }  public final int hashCode()  {      try      {          return ((Integer)super.h.invoke(this, m0, null)).intValue();      }      catch(Error _ex) { }      catch(Throwable throwable)      {          throw new UndeclaredThrowableException(throwable);      }  }  public final String toString()  {      try      {          return (String)super.h.invoke(this, m2, null);      }      catch(Error _ex) { }      catch(Throwable throwable)      {          throw new UndeclaredThrowableException(throwable);      }  }  private static Method m1;  private static Method m3;  private static Method m0;  private static Method m2;  static   {      try      {          m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {              Class.forName("java.lang.Object")          });          m3 = Class.forName("dynamic.proxy.UserService").getMethod("add", new Class[0]);          m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);          m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);      }      catch(NoSuchMethodException nosuchmethodexception)      {          throw new NoSuchMethodError(nosuchmethodexception.getMessage());      }      catch(ClassNotFoundException classnotfoundexception)      {          throw new NoClassDefFoundError(classnotfoundexception.getMessage());      }  }  }  

也就是说当我们调用proxy.add()方法时，add方法的代码为：
super.h.invoke(this, m3, null);
super.h：
h也就是我们我们构造这个类时传入的参数，上面提到过，具体代码如下：
return (Object) cons.newInstance(new Object[] { invocationHandler });
一个我们定义过的类的实例。
m3：
m3 = Class.forName(“dynamic.proxy.UserService”).getMethod(“add”, new Class[0]);
现在一切就很清晰明了了吧，知其然知其所以然，现在就可以灵活运用java动态代理了。

参考文章：http://rejoy.iteye.com/blog/1627405