反射机制在代理中的应用(三) 动态代理中的反射机制

上一章中我们讲述了利用Proxy类来动态生成代理对象。接下来我们先认识一下ProxyGenerator类。这个类是在sun.misc包里，并不是Java的标准API。通过链接sun.misc.ProxyGenerator可以看一下这个类的功能以及实现。

public class ProxyGenerator {
    /** name of the superclass of proxy classes */
    private final static String superclassName = "java/lang/reflect/Proxy";

    /** name of field for storing a proxy instance's invocation handler */
    private final static String handlerFieldName = "h";
    /**
     * Generate a public proxy class given a name and a list of proxy interfaces.
     */
    public static byte[] generateProxyClass(final String name,
                                            Class<?>[] interfaces) {
        return generateProxyClass(name, interfaces, (ACC_PUBLIC | ACC_FINAL | ACC_SUPER));
    }
	/**
     * Generate a proxy class given a name and a list of proxy interfaces.
     *
     * @param name        the class name of the proxy class
     * @param interfaces  proxy interfaces
     * @param accessFlags access flags of the proxy class
    */
    public static byte[] generateProxyClass(final String name,
                                            Class<?>[] interfaces,
                                            int accessFlags){……}
	……
}

通过上面的代码我们可以大体了解到，这个类提供了两个静态方法，可以借助Class<?>[] interfaces参数来生成基于Proxy的子类并实现interfaces的接口，下面我们来测试一下第一个静态方法：

import java.io.FileOutputStream;
import sun.misc.ProxyGenerator;

public class TestBrowser {
	public static void main(String[] args) {
		IBrowser realBrowser = new IBrowserImpl();
		IBrowser proxyBrowser = (IBrowser)new MyInvocationHandler().bind(realBrowser);
		proxyBrowser.browserURL("www.google.com.hk");
		testProxyGenerator(realBrowser);
	}
	public static void testProxyGenerator(IBrowser browser){
		byte[] classFile = ProxyGenerator.generateProxyClass("com.sun.proxy.$Proxy.1", 
				browser.getClass().getInterfaces());
		FileOutputStream out;
		try {
			out = new FileOutputStream("com.sun.proxy.$Proxy.1.class");
			out.write(classFile);
			out.flush();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Eclipse中引入sun.misc.ProxyGenerator会导致报错,可在Project=>Properties=>Java compile=>Error/warnings中修改，将Forbidden reference修改为warning即可。

运行后会在工程根目录下生成com.sun.proxy.$Proxy.1.class文件，我们利用反编译工具JD-GUI来看看这个生成的代理类：

public final class 1
  extends Proxy
  implements IBrowser
{
  private static Method m1;
  private static Method m2;
  private static Method m3;
  private static Method m0;
  
  public 1(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
  
  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final void browserURL(String paramString)
    throws 
  {
    try
    {
      this.h.invoke(this, m3, new Object[] { paramString });
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m3 = Class.forName("reflection.IBrowser").getMethod("browserURL", new Class[] { Class.forName("java.lang.String") });
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
}

新生成的代理类继承自Proxy，并且实现了IBrowser接口，其中两处代码比较关键

1.先是获取IBrowser的Class对象，并利用getMethod获得Method对象，对应的方法为browserURL，并需传入一个String类型参数

m3 = Class.forName("reflection.IBrowser").getMethod("browserURL", new Class[] { Class.forName("java.lang.String") });

2.代理类的对象调用browserURL的时候，实际调用的是传入Proxy构造方法的InvocationHandler对象的invoke方法，并将Proxy对象(测试代码中并未用到这个对象)、刚刚获取的Method对象，以及参数传递。

public final void browserURL(String paramString)
    throws 
  {
   ……
      this.h.invoke(this, m3, new Object[] { paramString });
      return;
    }

Proxy类中正是调用了ProxyGenerator的generateProxyClass方法，来生成代理类的字节码。我们回过头来再看一下MyInvocationHandler中的invoke方法：

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//		在此添加翻墙操作*******
		System.out.println("已成功翻墙");
		Object ret = method.invoke(this.obj, args);
//		在此解除翻墙操作*******
		System.out.println("已成功解除翻墙");
		return ret;
	}

代理对象将自己以及 browserURL的Method对象、method参数传递过来，invoke中变可以采用method的反射调用方法： method.invoke(this.obj,args);熟悉反射调用的到这里应该能看出下面会调用 realBrowser的 browserURL方法，网址参数也是我们传递到代理对象，代理对象再传递到invoke，最后传递到realBrowser的 browserURL。

至此静态代理和动态代理已经讲述完了。文中大部分是我个人的理解，难免有错误之处，欢迎各位指正。