代理的目标对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class TestServiceImpl implements TestService {
@Override
public void testA() {
testB();
//解决方案1：从Aop上下文获取当前的代理对象
TestService testService = (TestService) AopContext.currentProxy();
System.out.println("aaaa");
}
@Override
public void testB() {
System.out.println("bbbbb");
}
}
service接口
1
2
3
4
5
6
7
public interface TestService {
void testA();
void testB();
}
之前一直有一个疑问，为什么jdk动态代理是基于接口来实现的呢， 查看jdk底层源码可以发现生成字节码的方法如下，那么我们就将生成出来的字节码存储到文件中， 然后反编译查看生成的代码是怎样。 代码如下：
1
2
3
4
5
6
Class[] classes = new Class[]{Dao.class};
byte[] bytes = ProxyGenerator.generateProxyClass("Dao.class", classes);
File file = new File("/Users/xuguangwu/Dao.class");
FileOutputStream fileOutputStream = new FileOutputStream(file);
fileOutputStream.write(bytes);
反编译后的代码如下：
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
package Dao;
import com.clear.spring.aop.Dao;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class class extends Proxy implements Dao {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public class(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void hello() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("com.clear.spring.aop.Dao").getMethod("hello");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
那么很显然，代理类已经集成了Proxy类，因为java是单继承的特性，所以jdk的动态代理只能由接口类来实现了。
以下为jdk动态代理的应用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//TODO 额外的处理
System.out.println("代理中的方法");
return method.invoke(target, args);//实际上调用目标对象的方法
}
public static void main(String[] args) {
MyInvocationHandler myInvocationHandler = new MyInvocationHandler(new TestServiceImpl());
TestService proxy = (TestService) Proxy.newProxyInstance(MyInvocationHandler.class.getClassLoader(), new Class[]{TestService.class}, myInvocationHandler);
proxy.testA();
// proxy.testB();
}
}
