java代理及动态代理

代理在java技术中起着很重要的作用,Spring的aop及各种开源框架都使用了代理的技术。

代理一般分为：静态代理与动态代理。

一、 静态代理,一般分为 类继承代理与对象组合代理。 类继承就是继承超类获得超类的功能。

在应用中，一般用组合代理。

如下图：

 

 二、在java应用中，动态代理应用更广泛，可以说这是java语言的特性。

public class SetProxyFactory {
	@SuppressWarnings("unchecked")
	public static <T> T getProxy(final T obj) {
		// 类加载器、类的接口、一个InvocationHandler实现
		return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
				.getClass().getInterfaces(), new InvocationHandler() {
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				System.out.println("Start....");
				return method.invoke(obj, args);
			}
		});
	}
	public static void main(String[] agrs) throws ClassNotFoundException {
		Set<String> set = new HashSet<String>();// 创建一个类
		Set<String> proxySet = SetProxyFactory.getProxy(set);// 有类生成一个代理对象
		System.out.println(Proxy.getInvocationHandler(proxySet));
		System.out.println(proxySet.size());
	}
}

1. 动态代理主要涉及到 Proxy类与InvocationHandler类。
   1. Proxy有一个 public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)返回值是一个由JVM动态生成的类所实例化的对象，可以认为InvocationHandler 是这个类的变量属性。
      1. loader是类加载器
      2. interfaces 是接口列表
         
      3. InvocationHandler 是一个InvocationHandler 的实例。
   2. InvocationHandler有一个接口： public Object invoke(Object proxy, Method method, Object[] args)  throws Throwable;此接口可以认为是回调函数，也就是代理的类的对象 被访问时候，就会触发它所绑定的 InvocationHandler 的invoke方法。传来的差数有代理类，方法，差数列表。在invoke方法一般有method.invoke(obj, args)调用，obj真正的实例。
2. 动态关键类还是Proxy类的newProxyInstance方法，我们可以进入源码一看究竟。

3.  public static Object newProxyInstance(ClassLoader loader,
   					  Class<?>[] interfaces,
   					  InvocationHandler h)
   	throws IllegalArgumentException
       {
   	if (h == null) {
   	    throw new NullPointerException();
   	}
   
   	/*
   	 * Look up or generate the designated proxy class.
   	 */
   	Class cl = getProxyClass(loader, interfaces);//关键是创建代理类
   
   	/*
   	 * Invoke its constructor with the designated invocation handler.
   	 */
   	try {
   	    Constructor cons = cl.getConstructor(constructorParams);
   	    return (Object) cons.newInstance(new Object[] { h });//InvocationHandler是作为一个实例变量传入代理类中。
   	} catch (NoSuchMethodException e) {
   	    throw new InternalError(e.toString());
   	} catch (IllegalAccessException e) {
   	    throw new InternalError(e.toString());
   	} catch (InstantiationException e) {
   	    throw new InternalError(e.toString());
   	} catch (InvocationTargetException e) {
   	    throw new InternalError(e.toString());
   	}
       }

4. 关键还是 Class cl = getProxyClass(loader, interfaces); getProxyClass方法，该方法的差数是 ClassLoader 与 Classinterfaces。此方法中主要分为：
   1. 检查 ，一般有：接口数目不能大于65535，禁止非接口，禁止有重复的接口等。
   2. 缓存并复用。
   3. 定义名称 

   4. long num;
      		synchronized (nextUniqueNumberLock) {
      		    num = nextUniqueNumber++;
      		}
      		String proxyName = proxyPkg + proxyClassNamePrefix + num;

   5. 创建代理类。代码如下

   6. /*
      		 * Generate the specified proxy class.
      		 */
      		byte[] proxyClassFile =	ProxyGenerator.generateProxyClass(
      		    proxyName, interfaces); 主要是此方法，生成了 字节码。 如果要看，建议使用openjdk及看看jvm字节码
      		try {
      		    proxyClass = defineClass0(loader, proxyName,
      			proxyClassFile, 0, proxyClassFile.length);

   7. 最后调用 defineClass0 根据字节码生成代理类。
5. 我们可以看下动态代理的类图
6. 
   
7. 在上图中$ProxyN是代理类。继承Proxy类。在实现了接口。$ProxyN其实跟User是没有关系的。调用是通过AInvocationHandler来实现的。

三、其它

1. 为什么使用代理：主要的目的是为了对目标类，进行精确的控制。打打日志。
2. 为什么用动态代理不用静态代理：用静态代理,如果目标方法改变则需要修改代理类，很不方便。动态代理能避免这个。
3. 我们要注意什么？针对接口代理，不能针对类进行动态代理这个也有点遗憾。许多的框架都使用动态代理，debug程序的时候一定要注意。

四、参考资料

• Java 动态代理机制分析及扩展：http://www.ibm.com/developerworks/cn/java/j-lo-proxy1
• ProxyAPI:http://dlc.sun.com.edgesuite.net/jdk/jdk-api-localizations/jdk-api-zh-cn/publish/1.6.0/html/zh_CN/api/java/lang/reflect/Proxy.html

五、版权声明

• 此文可以自由转载，请保留 著作者相关信息。
• 原文地址：http://blog.csdn.net/bxyz1203/article/details/6071310
• 作者：就职于 阿里巴巴 封神