首先实例一个简单的jdk动态代理实例，为下文分析方便，所以实例拆分得比较厉害，可能和常看到的动态代理模板所不同。
接口类
1
2
3
4
5
6
7
| public interface Function {
public void sayHello();
public String getBay();
}
|
接口实现类【被代理对象】
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
|
public void createProxyClass() throws Exception {
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代理原理图
可见，我们测试中的被代理对象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方法，绕过了代理，因此代理增强并没有执行。
