java动态代理，能干什么呢。假设有一种场景，我们调用某个类的所有方法，然后我们想记录下我们调用每个方法的调用时间，这个我们该怎么去实现它。比较笨的办法是我们每调用一个方法，都在方法的开始和返回之前，去计算一下时间。但是这样的话，我们写了很多重复的代码。通过动态代理，我们就能实现这样的功能，spring也是同样方式，去实现类似的功能。
首先我们定义一个接口
1
2
3
4
public interface Person {
public void run();
public void jump();
}
有两个方法，现在我们想统计调用这两个方法，占用的时长统计。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Jack implements Person {
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("我是jack，我正在跑");
}
public void jump() {
System.out.println("我是jack，我正在跳");
}
}
让jack来实现这个接口，现在我们来统计jack的运行时间。
1
2
3
4
5
6
7
8
9
10
11
12
final Person jack = new Jack();
Person jackPrxoxy = (Person) Proxy.newProxyInstance(Jack.class.getClassLoader(), new Class<?>[]{Person.class}, new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long time = System.currentTimeMillis();
method.invoke(jack, args);
System.out.println("调用" + method.getName() + "方法，耗时：" + (System.currentTimeMillis() - time));
return null;
}
});
jackPrxoxy.run();
jackPrxoxy.jump();
最终得到的结果是
1
2
3
4
我是jack，我正在跑
调用run方法，耗时：101
我是jack，我正在跳
调用jump方法，耗时：0
通过上面简单的代码，我们已经实现了我们最初的需求，那么我们来分析，分析背后的原理。
通过查看源码可知，Proxy.newProxyInstance这个类会动态生成一个java的class类，然后动态生成的这个class类，将被实例化，供我们调用。
1
2
3
4
5
6
7
8
9
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0",new Class<?>[]{Person.class});
String path = "./StuProxy.class";
try(FileOutputStream fos = new FileOutputStream(path)) {
fos.write(classFile);
fos.flush();
System.out.println("代理类class文件写入成功");
} catch (Exception e) {
System.out.println("写文件错误");
}
可通过这个代码，去保存生成的类。
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
public final class $Proxy0 extends Proxy implements Person {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m4;
private static Method m0;
public $Proxy0(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 run() 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 void jump() throws {
try {
super.h.invoke(this, m4, (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("proxy.Person").getMethod("run");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m4 = Class.forName("proxy.Person").getMethod("jump");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
从上面的代码可以清晰的看出来，我们调用的方法最终都被代理给了InvocationHandler，我们在InvocationHandler又反射调用被代理的对象，最终实现整个代理过程。