Java的代理有两种：静态代理和动态代理，动态代理又分为 基于jdk的动态代理 和 基于cglib的动态代理 ，两者都是通过动态生成代理类的方法实现的，但是基于jdk的动态代理需要委托类实现接口，基于cglib的动态代理不要求委托类实现接口。
接下来主要分析一下基于jdk的动态代理的实现原理。
一 动态代理例子
首先来看一个动态代理的例子：
# 测试类，主要功能是生成代理类并调用代理方法 TargetFactory.java
public class TargetFactory {
public static void main(String[] args) {
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
TargetFactory tf = new TargetFactory();
Target tt = new Target();
Display dy = (Display) tf.getInstance(tt, new InvokerHandler(tt));
try {
dy.f();
} catch (Exception e) {
e.printStackTrace();
}
}
public Object getInstance(Object target, InvocationHandler handler){
return Proxy.newProxyInstance(target.getClass().getClassLoader(), new Class<?>[]{Display.class},handler);
}
}
# 接口 Display.java
interface Display {
public void f();
public void g();
}
# 实现了接口的目标类 Target.java
public class Target implements Display{
@Override
public void f() {
System.out.println("Targer f() method");
}
@Override
public void g() {
System.out.println("Targer g() method");;
}
}
# 实现了InvocationHandler接口的代理类的调用处理类 InvokerHandler.java
public class InvokerHandler implements InvocationHandler {
private Object target;
public InvokerHandler(Object t){
target = t;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("beforem invoke method");
method.invoke(target, args);
System.out.println("after invoke method");
return null;
}
}
运行上面的例子，结果为：
beforem invoke method
Targer f() method
after invoke method
二 代理类分析
我们从生成的代理类入手来进行分析，代理类默认是只存在于内存中的，我们可以通过添加如下代码来将代理类存储在磁盘上：
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
FAQ1：添加此代码后程序有时会抛出 java.lang.InternalError: I/O exception saving generated file: java.io.FileNotFoundException : test\java\dynamicProxy\$Proxy0.class (系统找不到指定的路径。)。这个问题不得不说一下代理类的生成路径。系统是根据接口的描述符来选择生成路径的，如果有一个接口的描述符都为public的，那么代理类就被放置在用户目录下面，可以通过System.getProperty("user.dir")来获取到。接口中只要有一个是非public的，那么代理类的放置路径就为System.getProperty("user.dir")+File.separator+该接口的包路径。谈到这里，我们可以想象一下如果有两个接口是非public的，而它们属于不同的包，那么将会抛出IllegalArgumentException的异常。
代理类的命名是 “$Proxy”（由Proxy类中的proxyClassNamePrefix字段指定的）+代理类的序号（Proxy类中的nextUniqueNumber字段，从0开始），考虑到多线程的问题在操作nextUniqueNumber时先要获取到nextUniqueNumberLock的对象锁。
获得了代理类的class文件后我们使用jd-gui（free for no commercial）来进行反编译获取到源码，本文的$Proxy0.class 反编译的结果如下
//代理类都继承 Proxy 类 并且实现代理接口Display
public final class $Proxy0 extends Proxy implements Display
{
//构造函数的入参为 例子中InvokerHandler的实例
//也就是 Proxy.newProxyInstance(target.getClass().getClassLoader(), new Class<?>[]{Display.class},handler); 的入参 handler
public $Proxy0(InvocationHandler paramInvocationHandler) throws
{
/*接着调用Proxy的构造函数，把handler赋值给Proxy类的h字段，下面注释为Proxy的构造函数
*protected Proxy(InvocationHandler h) {
* this.h = h;
*}
*/ super(paramInvocationHandler); } private static Method m1;
private static Method m3;
private static Method m4;
private static Method m0;
private static Method m2; static
{
try
{
//通过反射获取接口中的方法f() 和 g()，这就决定了委托类必须实现接口，不然的话没有办法通过反射来调用委托类中的方法
m3 = Class.forName("test.java.dynamicProxy.Display").getMethod("g", new Class[0]);
m4 = Class.forName("test.java.dynamicProxy.Display").getMethod("f", 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]);
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
//在调用代理类中的接口方法时，代理类会将此方法和方法的参数作为入参来调用paramInvocationHandler的invoke函数，在invoke函数中调用委托类中对应的函数
public final void g() throws
{
try
{
//m3代表的是g方法，null是g的入参，因为g没有入参所以为null
this.h.invoke(this, m3, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw newpublic final void f() throws
{
try
{
this.h.invoke(this, m4, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
} 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 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);
}
} 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);
}
}
}
基于jdk动态代理所生成的代理类和静态代理类一样都要实现接口，动态代理类需要继承Proxy（不知道为何要继承此类）。动态代理invoke函数中的对于委托类的方法调用是反射调用，效率上比这静态代理要差一些。
在编码时，静态代理类需要用户实现每一个接口方法，而动态代理只需要实现 InvocationHandler 中的invoke函数，因此动态代理使得代码比较简洁，所有对method的预处理都在invoke函数中完成。
三 代理类的产生
上面使用反编译的手段来分析了代理类的源码，下面要介绍一下代理类到底是怎么生成的
1. Proxy.newProxyInstance方法
newProxyInstance 是 Proxy类中的静态方法，它的作用就是根据入参来返回一个代理类的实例，下面来介绍一下入参：
Proxy.newProxyInstance(target.getClass().getClassLoader(), new Class<?>[]{Display.class},handler);
target.getClass().getClassLoader()：是用来加载代理类的class loader
new Class<?>[]{Display.class}：是需要代理的接口，一个代理类可以代理多个接口，所以这里是个数组
handler： 传递委托类方法调用的调用处理类，在例子一种对应的是InvokerHandler的实例
我们来看一下 newProxyInstance的源码：
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}
//生成代理类
Class cl = getProxyClass(loader, interfaces); try {
//获取构造函数，生成并返回代理类的实例
//根据第二节中对生成代理类的分析，构造函数的参数类型为 { InvocationHandler.class }
Constructor cons = cl.getConstructor(constructorParams);
return (Object) cons.newInstance(new Object[] { h });
} 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());
}
}
2. getProxyClass
这个函数主要实现了下列的功能：
- 对需要代理的接口进行合法性验证（接口对传入newProxyInstance的Class loader是否可见，是否是接口类型，接口去重）
在此只关注一下接口的去重。此函数中采用HashSet的方法来简单进行去重，代码如下：
Set interfaceSet = new HashSet();
if (interfaceSet.contains(interfaceClass)) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
- 使用本地缓存loaderToCache来缓存已经产生的代理类
先来看一下本地缓存的初始化，它采用WeakHashMap这个特殊的Map类型，关于WeakHashMap在此不再赘述
private static Map loaderToCache = new WeakHashMap();
loaderToCache 的类型是<ClassLoader,<Object,Class>>，涉及到缓存操作的代码如下，代码比较简单，又有完整的注释，这里不予过多分析，以免画蛇添足之嫌。
Map cache;
synchronized (loaderToCache) {
cache = (Map) loaderToCache.get(loader);
if (cache == null) {
cache = new HashMap();
loaderToCache.put(loader, cache);
}
/*
* This mapping will remain valid for the duration of this
* method, without further synchronization, because the mapping
* will only be removed if the class loader becomes unreachable.
*/
} /*
* Look up the list of interfaces in the proxy class cache using
* the key. This lookup will result in one of three possible
* kinds of values:
* null, if there is currently no proxy class for the list of
* interfaces in the class loader,
* the pendingGenerationMarker object, if a proxy class for the
* list of interfaces is currently being generated,
* or a weak reference to a Class object, if a proxy class for
* the list of interfaces has already been generated.
*/
synchronized (cache) {
/*
* Note that we need not worry about reaping the cache for
* entries with cleared weak references because if a proxy class
* has been garbage collected, its class loader will have been
* garbage collected as well, so the entire cache will be reaped
* from the loaderToCache map.
*/
do {
Object value = cache.get(key);
if (value instanceof Reference) {
proxyClass = (Class) ((Reference) value).get();
}
if (proxyClass != null) {
// proxy class already generated: return it
return proxyClass;
} else if (value == pendingGenerationMarker) {
// proxy class being generated: wait for it
try {
cache.wait();
} catch (InterruptedException e) {
/*
* The class generation that we are waiting for should
* take a small, bounded time, so we can safely ignore
* thread interrupts here.
*/
}
continue;
} else {
/*
* No proxy class for this list of interfaces has been
* generated or is being generated, so we will go and
* generate it now. Mark it as pending generation.
*/
cache.put(key, pendingGenerationMarker);
break;
}
} while (true);
}
- 产生缓存中没有的代理类，并将该类存入缓存
如果缓存中没有所需的代理类，则由下面的这个函数来根据需要代理的接口产生。
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
3. ProxyGenerator
这个类是jdk动态代理的核心类，class文件的生成就是在这个类中完成的，在分析这个类之前，首先来看一下class file的 格式，这里只简要的提一下，可以在jvm规范中找到详细的解释。
ClassFile {
u4 magic; //此处必须为0xCAFEBABE
u2 minor_version;
u2 major_version;
u2 constant_pool_count;
cp_info constant_pool[constant_pool_count-1];
u2 access_flags;
u2 this_class;
u2 super_class;
u2 interfaces_count;
u2 interfaces[interfaces_count];
u2 fields_count; //代理类中的field info没有属性
field_info fields[fields_count];
u2 methods_count;
method_info methods[methods_count];//代理类中的method info只有Code属性和Exceptions属性
u2 attributes_count; // 代理类没有属性，所以attributes_count=0
attribute_info attributes[attributes_count];
}
java class file中最复杂的就是各种各样的attribute，而在代理类中只存在两种属性"Code" 和 "Exceptions"，由此可以看出，该类也是比较简单的。
constant_pool[constant_pool_count-1] 是class file中不可缺少的元素，这里需要提一下，在class file中引用constant_pool中的元素时下标是从1 开始的，比如constant_pool_count是39 那么只能使用constant_pool[1] --> constant_pool[38]的
元素。
在ProxyGenerator 中使用静态内部类ConstantPool来管理constant pool，在ConstantPool中使用private List<Entry> pool = new ArrayList<Entry>(32) 来存储constant pool entries，用private Map<Object,Short> map = new HashMap<Object,Short>(16) 来存储entries 与下标之间的对应关系，这样的设计避免了需要轮询pool来查找需要存入的条目是否已经存在了。
4. ProxyGenerator.generateClassFile
在ProxyGenerator中generateClassFile 是入口函数，该函数可以对照class file的结构来阅读。
private byte[] generateClassFile() {
/* ============================================================
* Step 1: Assemble ProxyMethod objects for all methods to
* generate proxy dispatching code for.
*/
/*
* Record that proxy methods are needed for the hashCode, equals,
* and toString methods of java.lang.Object. This is done before
* the methods from the proxy interfaces so that the methods from
* java.lang.Object take precedence over duplicate methods in the
* proxy interfaces.
*/
/* hashCodeMethod equalsMethod toStringMethod 存在于每个生成的代理类中
* addProxyMethod 中会扫描每个接口中的方法，对于函数签名一致的方法则判断
* 抛出的异常类型是否一致，如果不一致且没有继承关系，则不抛出异常。如果不
* 一致但异常有继承关系的，则抛出子类的异常
* 例如 接口1中 void f() throws Exception
* 接口2中 void f() throws IOException
* 代理类中 void f() throws IOException
*/
addProxyMethod(hashCodeMethod, Object.class);
addProxyMethod(equalsMethod, Object.class);
addProxyMethod(toStringMethod, Object.class);
/*
* Now record all of the methods from the proxy interfaces, giving
* earlier interfaces precedence over later ones with duplicate
* methods.
*/
for (int i = 0; i < interfaces.length; i++) {
Method[] methods = interfaces[i].getMethods();
for (int j = 0; j < methods.length; j++) {
addProxyMethod(methods[j], interfaces[i]);
}
}
/*
* For each set of proxy methods with the same signature,
* verify that the methods' return types are compatible.
*/
/*这里需要强调一下，签名一致的函数返回值类型不一样且没有继承关系，则是不兼容的
* 如果返回值类型不一致而返回值存在继承关系的，在代理类中返回值类型为子类
* 例如： 接口1 superclass f();
* 接口2 subclass f();
* 代理类中 subclass f(); 其中 subclass extends superclass
*/
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
checkReturnTypes(sigmethods);
}
/* ============================================================
* Step 2: Assemble FieldInfo and MethodInfo structs for all of
* fields and methods in the class we are generating.
*/
try {
methods.add(generateConstructor());//生成构造函数的字节码
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
for (ProxyMethod pm : sigmethods) {
// add static field for method's Method object
fields.add(new FieldInfo(pm.methodFieldName,
"Ljava/lang/reflect/Method;",
ACC_PRIVATE | ACC_STATIC));
// generate code for proxy method and add it
//生成equals，toString，hashCode 和 接口方法的字节码
methods.add(pm.generateMethod());
}
}
//生成静态代码块的字节码
methods.add(generateStaticInitializer());
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception");
}
if (methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
}
if (fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
}
/* ============================================================
* Step 3: Write the final class file.
*/
/*
* Make sure that constant pool indexes are reserved for the
* following items before starting to write the final class file.
*/
cp.getClass(dotToSlash(className));
cp.getClass(superclassName);
for (int i = 0; i < interfaces.length; i++) {
cp.getClass(dotToSlash(interfaces[i].getName()));
}
/*
* Disallow new constant pool additions beyond this point, since
* we are about to write the final constant pool table.
*/
cp.setReadOnly();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
try {
/*
* Write all the items of the "ClassFile" structure.
* See JVMS section 4.1.
*/
// u4 magic;
dout.writeInt(0xCAFEBABE);
// u2 minor_version;
dout.writeShort(CLASSFILE_MINOR_VERSION);
// u2 major_version;
dout.writeShort(CLASSFILE_MAJOR_VERSION);
cp.write(dout); // (write constant pool)
// u2 access_flags;
dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);
// u2 this_class;
dout.writeShort(cp.getClass(dotToSlash(className)));
// u2 super_class;
dout.writeShort(cp.getClass(superclassName));
// u2 interfaces_count;
dout.writeShort(interfaces.length);
// u2 interfaces[interfaces_count];
for (int i = 0; i < interfaces.length; i++) {
dout.writeShort(cp.getClass(
dotToSlash(interfaces[i].getName())));
}
// u2 fields_count;
dout.writeShort(fields.size());
// field_info fields[fields_count];
for (FieldInfo f : fields) {
f.write(dout);
}
// u2 methods_count;
dout.writeShort(methods.size());
// method_info methods[methods_count];
for (MethodInfo m : methods) {
m.write(dout);
}
// u2 attributes_count;
dout.writeShort(0); // (no ClassFile attributes for proxy classes)
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception");
}
return bout.toByteArray();
}