【源码】动态代理整理

2019-03-28

动态代理

在程序运行时创建实现了给定的接口的新类。

动态代理实现是通过字节码增强方式实现的，字节码增强又有两种方式实现

生成新类并实现被代理类的所有接口（spring aop是这种方式）
直接篡改class类文件后重新加载到java虚拟机

主要用来做方法的增强，可以在不修改源码的情况下，增强一些方法，在方法执行前后做任何想做的事情，因为在InvocationHandler的invoke方法中会通过反射机制执行委托类的方法。

应用在很多场景里比如：方法调用时想要记录日志，权限查看，事务管理之中，这些都不需要改动原来方法，而只需要在代理类中添加，具体下面的例子说明。

例子

程序中实现动态代理关键是使用Proxy类和实现InvocationHandler接口的invoke()方法（方法里是具体的方法执行）

ProxyFacade1.java和ProxyFacade2.java

package com.example.facade;
public interface ProxyFacade1 {
	String a(int a);
}

package com.example.facade;
public interface ProxyFacade2 {
	String b(int b);
}

ProxyFacadeImpl.java实现两个接口

package com.example.facade.impl;
import com.example.facade.ProxyFacade1;
import com.example.facade.ProxyFacade2;
public class ProxyFacadeImpl implements ProxyFacade1, ProxyFacade2 {
	@Override
	public String b(int b) {
		return b+":b";
	}
	@Override
	public String a(int a) {
		return a+":a";
	}
}

AOPHandler.java

package com.example.facade.impl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class AOPHandler implements InvocationHandler {
	//实际对象
	private Object obj;
	public AOPHandler(Object obj){
		this.obj=obj;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("aop handler invoke");
		//通过反射机制调用实际对象方法
		return method.invoke(obj, args);
	}
}

ProxyTest.java测试类

package com.example.facade.impl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import com.example.facade.ProxyFacade1;
import com.example.facade.ProxyFacade2;
public class ProxyTest {
	public static void main(String[] args) {
		ProxyFacadeImpl cc=new ProxyFacadeImpl();
		InvocationHandler handler=new AOPHandler(cc);
		//生成代理类
		Object proxyObj=Proxy.newProxyInstance(cc.getClass().getClassLoader(),
				cc.getClass().getInterfaces(), handler);
		
		ProxyFacade1 o=((ProxyFacade1)proxyObj);
		ProxyFacade2 o2=((ProxyFacade2)proxyObj);
		
		System.out.println(o.a(1));
		System.out.println(o2.b(2));
	}
}

打印输出一下内容，因为真正的执行方法是AOPHandler的invoke方法代理执行的

aop handler invoke
1:a
aop handler invoke
2:b

动态代理源码简单分析

Proxy.newProxyInstance重点代码在WeakCache.java 主要获取代理类的工厂类
Proxy$ProxyClassFactory.java生成字节码文件并加载到jvm

//成员变量 map结构key=ClassLoader类,value=Map(key=生成的代理类,value=classLoader工厂类)
private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map = new ConcurrentHashMap<>();
public V get(K key, P parameter) {
...
	//从弱引用中获取被代理类加载器的缓存key
	//（弱引用是垃圾回收时就一定会回收的引用关系）
	Object cacheKey = CacheKey.valueOf(key, refQueue);
	//从全局变量map中获取该代理类，如果没有就新建map等待下一步的设值
	ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
	if (valuesMap == null) {
		ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey,valuesMap = new ConcurrentHashMap<>());
		if (oldValuesMap != null) {
			valuesMap = oldValuesMap;
		}
	}
	//生成代理类
	Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
	Supplier<V> supplier = valuesMap.get(subKey);
	
	//放入到valuesMap中
	Factory factory = null;
	while (true) {
		if (supplier != null) {
			// supplier might be a Factory or a CacheValue<V> instance
			V value = supplier.get();
			if (value != null) {
				return value;
			}
		}
		// else no supplier in cache
		// or a supplier that returned null (could be a cleared CacheValue
		// or a Factory that wasn't successful in installing the CacheValue)
		// lazily construct a Factory
		if (factory == null) {
			factory = new Factory(key, parameter, subKey, valuesMap);
		}
		if (supplier == null) {
			supplier = valuesMap.putIfAbsent(subKey, factory);
			if (supplier == null) {
				// successfully installed Factory
				supplier = factory;
			}
			// else retry with winning supplier
		} else {
			if (valuesMap.replace(subKey, supplier, factory)) {
				// successfully replaced
				// cleared CacheEntry / unsuccessful Factory
				// with our Factory
				supplier = factory;
			} else {
				// retry with current supplier
				supplier = valuesMap.get(subKey);
			}
		}
	}
}

Proxy$ProxyClassFactory.java

/*
* 因为同一个类加载器中只加载一次同一个类
* 为了给代理类区分，所以使用原子性操作AtomicLong++1获取唯一数字加到代理类名称中以便区分类
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* 利用字节码增强技术，生成了一个新的类并实现了所有被代理类实现的接口方法
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
try {
	//通过类加载机制把proxy的字节码文件加载到jvm
	return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
	throw new IllegalArgumentException(e.toString());
}

最终会生成$ProxyClass文件这里省略equals和toString和hashCode方法

package com.sun.proxy.$Proxy;
import com.example.facade.ProxyFacade1;
import com.example.facade.ProxyFacade2;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class Proxy1 extends Proxy implements ProxyFacade1, ProxyFacade2 {
   private static Method m1;
   private static Method m2;
   private static Method m3;
   private static Method m4;
   private static Method m0;
	static {
      try {
	  	//省略显示equals和toString
		m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
		
		m3 = Class.forName("com.example.facade.ProxyFacade1").getMethod("a", new Class[]{Integer.TYPE});
		m4 = Class.forName("com.example.facade.ProxyFacade2").getMethod("b", new Class[]{Integer.TYPE});
      } catch (NoSuchMethodException var2) {
         throw new NoSuchMethodError(var2.getMessage());
      } catch (ClassNotFoundException var3) {
         throw new NoClassDefFoundError(var3.getMessage());
      }
   }
   public Proxy1(InvocationHandler var1) throws  {
      super(var1);
   }
   public final String a(int var1) throws  {
      try {
         return (String)super.h.invoke(this, m3, new Object[]{Integer.valueOf(var1)});
      } catch (RuntimeException | Error var3) {
         throw var3;
      } catch (Throwable var4) {
         throw new UndeclaredThrowableException(var4);
      }
   }
   public final String b(int var1) throws  {
      try {
         return (String)super.h.invoke(this, m4, new Object[]{Integer.valueOf(var1)});
      } catch (RuntimeException | Error var3) {
         throw var3;
      } catch (Throwable var4) {
         throw new UndeclaredThrowableException(var4);
      }
   }
   public final int hashCode() throws  {
      ...
   }
   
   public final boolean equals(Object var1) throws  {
      ...
   }
   public final String toString() throws  {
      ...
   }
}

最后看下uml关系图

uml-proxy