Java动态代理--jdk代理原理深究

java

首先实例一个简单的jdk动态代理实例，为下文分析方便，所以实例拆分得比较厉害，可能和常看到的动态代理模板所不同。

接口类

1
2
3
4
5
6
7
public interface Function {

	public void sayHello();
	public String getBay();
	//jdk动态代理基于接口代理，所以该方法在代理类中不存在
//	public void doNothing();
}

接口实现类【被代理对象】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class FunctionImpl implements Function {

	public void sayHello() {
		System.out.println("hello,world");
	}

	public final String getBay() {
		System.out.println("bay");
		return "bay";
	}

	public void doNothing() {

	}
}

InvocationHandler实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MyHandler implements InvocationHandler {

	Object delegate=null;
	
	public MyHandler(Object delegate) {
		this.delegate=delegate;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if (!method.getName().equals("getBay")) {
			return method.invoke(delegate, args);
		} else {
			System.out.println("this is a proxy");
			return "再见";	//方法返回值
		}
	}

}

动态代理入口

1
2
3
4
5
6
7
8
public class DynamicProxy {

	public static Object getInstance(Object obj) {
		Class<?> cls = obj.getClass();
		return Proxy.newProxyInstance(
				cls.getClassLoader(), cls.getInterfaces(), new MyHandler(obj));
	}
}

测试

1
2
3
4
Function f = new FunctionImpl();
Function function = (Function) DynamicProxy.getInstance(f);
function.sayHello();
function.getBay();

最终测试结果为f实例被动态代理，并且在执行getBay()方法时被拦截，而执行自定义的方法。
那么，问题来了，jdk动态代理是如何做到拦截指定方法并执行自定义方法的呢？
我在一次学习中无意发现了一段代码，用于从内存中输出动态代理类的class文件。此方法要在动态代理对象在内存存活期间运行。

1
2
3
4
5
6
7
8
9
// 把动态代理对象类生成class文件输出
public void createProxyClass() throws Exception {
	//$Proxy0为代理对象的名字，可通过proxy.getClass().getName()获得：com.sun.proxy.$Proxy0
	byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", FunctionImpl.class.getInterfaces());
	FileOutputStream out = new FileOutputStream(new File("D:/proxy.class"));
	out.write(data);
	out.close();

}

输出得到class文件后，通过反编译得到代理对象$Proxy源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
public final class $Proxy0 extends Proxy implements Function {
 	private static Method m4;
 	private static Method m1;
 	private static Method m0;
 	private static Method m3;
 	private static Method m2;
  
 	public $Proxy0(InvocationHandler paramInvocationHandler)  {
  		super(paramInvocationHandler);
 	}
  
 	public final void sayHello()  {
  		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)  {
  		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()  {
		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 getBay()  {
		try {
			return (String)this.h.invoke(this, m3, null);
		} catch (Error|RuntimeException localError) {
			throw localError;
		} catch (Throwable localThrowable) {
			throw new UndeclaredThrowableException(localThrowable);
		}
	}
  
	public final String toString()  {
 		try {
			return (String)this.h.invoke(this, m2, null);
		} catch (Error|RuntimeException localError) {
			throw localError;
		} catch (Throwable localThrowable) {
			throw new UndeclaredThrowableException(localThrowable);
		}
	}
  
	static {
		try {
			m4 = Class.forName("proxy.Function").getMethod("sayHello", new Class[0]);
			m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
			m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
			m3 = Class.forName("proxy.Function").getMethod("getBay", new Class[0]);
			m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
		} catch (NoSuchMethodException localNoSuchMethodException) {
			throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
		} catch (ClassNotFoundException localClassNotFoundException) {
			throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
		}
	}
}

从而我制作出这张jdk代理原理图

img

可见，我们测试中的被代理对象f 就是图中的实体对象，代理对象function 就是$Proxy，jdk动态代理对象实现了被代理对象的接口，并继承了Proxy类，而我们的InvocationHandler的实现类就是Proxy的成员变量。

所以代理对象f 执行sayHello()方法时，实际上是通过反射获取被代理对象接口的sayHello()方法，然后执行代理对象父类Proxy中的InvocationHandler实现类的invoke()方法，在invoke()方法中默认执行被代理对象的原方法method.invoke(delegate, args)，我们的代理增强也就是在这里执行的。其中delegate则就是我们最开始的被代理对象了。

所以此处也就能解释为何Spring在A方法中直接调用本类的B方法时会出现事务失效、日志失效之类的问题，原因就是使用代理增强必须调用代理对象才行，A中直接调用本类的B方法实际上是在被代理对象中调用B方法，绕过了代理，因此代理增强并没有执行。

>