JDK Proxy 代理是可以根据我们的 接口 Interface 生成类的字节码,从而可以在 Java 中为所欲为的一种技术,包括对象增强(修改成员变量),函数增强(在函数前后执行别的代码),根据接口名执行不同逻辑 等。在 Mybatis 中有典型应用。它的本质是 由 Proxy 生成一个 代理对象,实现我们的接口。这个对象中有我们的回调函数。当调用 代理对象的接口方法时,这个对象再调用我们的回调函数,我们的回调函数再调用原对象的对应方法。从而实现代理。为了实现代理模式,Proxy 用了另外一种设计模式:命令模式。

不过,如果我们没有接口,直接是个类,那么 Proxy 将不能用,我们可能需要用 CGLIB 等 ASM 框架进行对类的字节码进行修改。

用法简介

定义一个接口和一个实现的对象

1
2
3
4
5
6
7
8
9
10
11
12
// 规定一个接口
public interface IHello {
void sayHello();
}

// 新建一个对象
IHello hello = new Hello(){
@Override
public void sayHello() {
System.out.println("Hello!");
}
};

不增强时,我们平时调用的话是这样:

1
2
3
4
hello.sayHello()

// 输出:
// Hello!

使用反射调用,可以达到同样的效果:

1
2
3
4
// 从类的字节码获取到方法
Method method = hello.getClass().getMethod("sayHello");
// 指定一个对象执行
method.invoke(hello);

我们使用 JDK 的 Proxy 对对象进行增强:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 对这个对象进行增强,三个参数
IHello iHello = (IHello) Proxy.newProxyInstance(
    IHello.class.getClassLoader(), // 类加载器
new Class[]{IHello.class}, // 所有接口
    new InvocationHandler() { // 回调函数 handler 打包成对象,可以用 lambda
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("前置通知");
Object rs = method.invoke(hello, args); // 这里指定由我们的 hello 对象执行
System.out.println("后置通知");
return rs;
}
});
// 调用
iHello.sayHello();

// 输出:
// 前置通知
// Hello!
// 后置通知

我们看到,我们给 Proxy.newProxyInstance 传入了一个类加载器、一个接口的数组、一个 Handler返回的是一个 动态生成的 Proxy 对象,实现了 IHello 接口

我们在调用 这个Proxy 对象的 sayHello() 的时候,实际上调用的是我们 handler 的 invoke 方法,然后将我们的 method(类比上面的 hello.getClass().getMethod(“sayHello”)) 传入,然后我们在 invoke 方法里面已经指定了由原来的对象执行这个方法,method.invoke(hello, args),所以整个代理就完成了。

用法解析

方法增强/对象增强

Proxy 本质上是根据我们的接口生成了一个 Proxy 对象,然后这个对象再调用我们指定的逻辑来实现动态代理的。而在我们的逻辑中,要用 反射的方法 回调真正对象的方法来实现对象增强。在反射调用的前后,我们还执行别的一些额外的逻辑。
为什么要这么增强呢?这其实是一种AOP的编程方法。 在 SpringMVC 的一些逻辑操作中,我们可以用到它,比如每个方法统一鉴权,日志处理等等,我们可以在一个地方写一次代码,就可以应用到全部方法中。当然 Proxy 还不灵活,默认会对接口的所有方法都执行同一个逻辑,所以我们还有 AspectJ 等包来灵活管理。

根据接口名执行不同方法

当然,我们也可以不做对象增强,而是直接读取我们的接口中的方法名,做一些别的逻辑,比如 在 Mybatis 中,我们只要定义接口,然后经过工厂返回一个 Proxy 对象,我们就可以调用到真正的逻辑代码,读取 map 和 数据库。

原理解析

眼见为实,我们来把经过代理后的对象的类文件导出来,再确认下我们的结论:

1
2
3
4
5
6
7
try(FileOutputStream fos = new FileOutputStream(path)) {
fos.write(classFile);
fos.flush();
System.out.println("代理类class文件写入成功");
} catch (Exception e) {
System.out.println("写文件错误");
}

为了简洁起见,这里删掉了对 Object代理 的 一些方法

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
public final class $Proxy0 extends Proxy implements IHello { // 实现原接口,是代理模式的核心

private static Method m3;

static {
try {
m3 = Class.forName("test.ProxyTest$IHello").getMethod("sayHello"); // 调用了 getMethod 方法
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}

public $Proxy0(InvocationHandler var1) throws {
super(var1); // 把我们的 Handler 传进来了
}

// super(var1) 方法的代码,非本文件
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h;
}

public final void sayHello() throws {
try {
// 这里回调我们传入的 handler 类
super.h.invoke(this, m3, (Object[])null); // 因为我们的接口没有参数,所以这里传null
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
// super.h.invoke 方法就是我们自己定义的 Handler 的 invoke 方法
// 如果有其他方法,就直接由生成器复制即可

}

这其实是命令模式的设计模式,我们先传入一个回调函数,Proxy 被调用时,调用我们的的回调函数(对象)

参考资料

https://www.cnblogs.com/gonjan-blog/p/6685611.html