关于 Java 的代理技术，我写了一个开源库，推荐对具体实现有兴趣的同学去看看：
https://github.com/Spongecaptain/ProxyPatternInJava
1. 为类的方法添加第三方功能-朴素方式
这里提到的第三方功能类似于软件的插件，主要用于添加第三方功能，比如：日志、拦截。
那么我们该如何为类的方法添加第三方功能呢？
-
首先，我们可以修改原来的类，在原来类的方法上直接嵌入第三方功能方法的调用；
主要缺陷：修改原来的类是非常危险的事情，因为此类可能已经被其他类依赖，一旦修改可能出现各种错误。另一方面，第三方功能的侵入性太强了。
-
其次，我们可以为原来的类添加新方法，在新方法中调用原方法以及第三方功能方法。
优点：这样原本依赖的此类的类并不会调用新写的方法，因此不会出现依赖错误。
主要缺陷：很多第三方架包我们并不能直接拿到源码，或者并不想编译，总之，一旦没有源码我们就难以为类写新方法；
-
或者，我们可以继承原来的类，重写其被代理方法，重写方法中既调用父类的被代理方法又调用第三方功能的方法。
优点：不再需要第三方类库的源代码；
主要缺陷：仅仅为了代理方法就设计一个子类，面向对象的继承关系混乱。
-
最后，我们可以采用静态代理的手段，只要原来的类需要被代理的方法来自接口，那么我们通过实现此接口，并在接口方法中调用第三方代码以及原来的方法就能实现代理。
优点：不再需要第三方类库的源代码；
主要缺陷：每次想添加一个新的代理功能，那么必须要实现一个新代理类，代理类会随着被代理的方法而增多。
次要缺陷：对于不是实现于接口的方法无法进行代理。
注意事项：下面的方式拥有的缺陷对于上面的方式来说，可能也具备，比如继承和静态代理都有随着新第三方功能的加入需要成正比地添加类数量。
下面是上述逻辑的代码案例。
方式一，直接改写原类的方法：
1
2
3
4
5
6
7
|
class Proxyee implements Foo{
public void bar(){
Log.log();
System.out.println("foo");
Log.log();
}
}
|
方式二，写一个新方法：
1
2
3
4
5
6
7
8
9
10
11
|
class Proxyee implements Foo{
public void bar(){
System.out.println("foo");
}
//下面是新方法，和 bar() 方法的区别仅仅在于额外添加了日志系统
public void barProxy(){
Log.log();
System.out.println("foo");
Log.log();
}
}
|
方式三，继承：
1
2
3
4
5
6
7
8
9
|
class Proxyer extends Proxyee{
//重写父类方法，区别仅仅在于额外调用了第三方功能：日志系统
@Override
public void bar(){
Log.log();
super.bar();
Log.log();
}
}
|
方式四，静态代理：
代码最长，不过也算是这四个臭皮匠中最好的一个。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
//和代理类实现一样的接口（实现哪个接口取决于要代理哪一个类）
class Proxyer implements Foo{
Proxyee proxyee;
public Proxyer(Proxyee proxyee){
this.proxyee = proxyee;
}
//实现接口的方法，借此代理
public void bar(){
Log.log();
proxyee.bar();
Log.log();
}
}
|
2. 为类添加第三方功能-奇思妙想
2.1 JDK 动态代理
JDK 动态代理是静态代理的升级版，其还是需要被代理方法一定源于接口的，但是避免了静态代理可能会产生过多代理类的问题。
理解 JDK 动态代理最好的方式就是举一个使用 JDK 动态代理的案例。不过对 Foo 接口进行了简单的修改，为了避免只用无参方法。
1
2
3
4
5
6
7
8
9
10
11
12
|
//被代理方法所在接口
public interface Foo {
String bar(String str,int i);
}
//被代理类
public class Proxyee implements Foo {
@Override
public String bar(String str,int i) {
System.out.println(str+i);
return str+i;
}
}
|
利用 JDK 的动态代理机制我们需使用 2 个类：
- java.lang.reflect.Proxy
- java.lang.reflect.InvocationHandler
以及其他反射类库中的类。
这里我们先看如何使用它们，后面会附上原代码。
InvocationHandler 类只有一个方法 invoke() 方法，如上所示，其入口参数有：
-
Object proxy：指向最终执行代理方法的实例；
为什么是 Object？这是因为代理类一次可以代理多个接口的方法，这里并不能事先确定具体代理哪几个接口的方法。
-
Method method：指向需要被代理的方法。
给 Proxy.newProxyInstance() 方法传递的接口数组代表 JDK 代理机制负责帮助实现这些接口相关方法的代理，如果不想被代理，可以选择将 interfaces 数据中移除该接口对应的 Class 实例。
Method 方法代表 interfaces 中每一个接口的每一个方法，因此这个 Method 在 Proxy.newProxyInstance() 方法返回值被声明为不同多态的条件下指向不同的方法，这里指的是 Proxyee.bar() 方法。
-
Object[] args：被代理方法的入口参数列表；
-
invoke() 方法返回值：此方法的返回值实际上也就是代理类实例(这里就是 proxyer 实例)的任何方法的返回值。如果我们需要链式调用，那么可以使 invoke() 方法返回入口参数 Proxy 类型实例；
下面是 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
25
26
27
28
29
30
31
32
33
34
|
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @author SpongeCaptain
* @date 2020/7/16 22:08
*/
public class Proxyer {
public static void main(String[] args) {
final Proxyee proxyee = new Proxyee();
final ClassLoader classLoader = Proxyee.class.getClassLoader();
final Class<?>[] interfaces = Proxyee.class.getInterfaces();
InvocationHandler myInvocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("--------Log.log()---------");
method.invoke(proxyee, args[0], args[1]);
System.out.println("--------Log.log()---------");
return "From Proxyer";
}
};
Foo proxyer = (Foo) Proxy.newProxyInstance(
classLoader, interfaces, myInvocationHandler);
String result = proxyer.bar("hello", 2020);
System.out.println(result);
}
}
|
控制台输出：
——–Log.log()———
hello2020
——–Log.log()———
From Proxyer
那么 JDK 动态代理的原理是什么？
我们从 Proxy.newProxyInstance(classLoader, interfaces, myInvocationHandler); 方法调用出发，这个方法入口参数依次为：
-
ClassLoader 实例：用于动态代理类实例的加载；
-
Class<?>[] interfaces 实例：被代理类的所有接口；
正是因为 JDK 动态代理 API 需要接收接口，因此如果被代理类的某个方法不属于某一个接口，那么该方法就无法被 JDK 动态代理机制处理。
另一方面，如果不希望被代理类的某个接口方法被代理，可以选择将此接口不作为 interfaces 的一员。
-
InvocationHandler 实例：通常在 Java 中命令为 Handler 的类是被作为回调函数的封装而存在，而这里就是封装了动态代理方法，回调时机是代理类的代理方法被调用。
首先所有代理类，也就是 Proxy.newProxyInstance(classLoader, interfaces, myInvocationHandler); 方法返回的实例都是 java.lang.reflect.Proxy 类的匿名内部类（也就是继承关系），比如会表示成 com.sun.proxy.$Proxy0。
当然我使用的是 Sun 的虚拟机，如果是其他虚拟机，那么此类的完全限定名会有所区别。
其次，代理类又实现了所有被代理类的接口。这句话有点绕口，具体来说就是如果被代理类实现了 A、B、C 三个接口，且将这三个接口实例注入到方法的 interfaces 实例中，那么 Proxy.newProxyInstance(classLoader, interfaces, myInvocationHandler); 方法返回的实例会将上述三个接口都实现。
对于这个说法，可以通过如下的语句来证实：
1
2
3
4
5
6
7
|
//superclass 为 java.lang.reflect.Proxy
System.out.println(proxyer.getClass().getSuperclass());
//interfaces 为 Proxyee 所实现的所有接口
Class<?>[] interfaces1 = proxyer.getClass().getInterfaces();
for (int i = 0; i < interfaces1.length; i++) {
System.out.println(interfaces1[i].getName());
}
|
那么 JDK 动态代理具体来说是如何实现的呢？
先说结论：
- 步骤 1：利用我们在刚才输入的类加载器实例、interfaces、InvocationHandler 实例进行动态生成 com.sun.proxy.Proxy 类的字节码；
- 步骤 2：通过 com.sun.proxy.Proxy 类的字节码生成 com.sun.proxy.Proxy 类对应的 Class 类实例；
- 步骤 3：通过上述 Class 实例得到入口参数类型为 InvocationHandler 实例的构造器 Constructor 实例；
- 步骤 4：通过 Constructor 实例的
newInstance() 方法，输入我们自己写的 InvocationHandler 实例，利用反射机制最终构造出 com.sun.proxy.Proxy 类实例，因为没有在磁盘上的 class 文件，即作为匿名内部类存在，因此通常类型命名为：com.sun.proxy.$Proxy0，末尾的是序号，随着匿名内部类的增多序号自增；
上述过程发生的方法栈如下：
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
|
//java.lang.reflect.Proxy#newProxyInstance
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);//非空检查
final Class<?>[] intfs = interfaces.clone();//克隆数组
final SecurityManager sm = System.getSecurityManager();//安全检查
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//这里生成代理类对应的 Class 类实例，这是最关键的一步，内部实现了步骤 1、2
Class<?> cl = getProxyClass0(loader, intfs);
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
// 步骤 3
final Constructor<?> cons = cl.getConstructor(constructorParams);
// 生成代理类的实例并把 InvocationHandler 实例传给它的构造方法
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//步骤 4
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
|
步骤 1、2 发生于如下方法：
1
2
3
4
5
6
7
8
9
10
11
|
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//检查传入的接口数是否大于 65535，接口数过多则直接抛出异常
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//根据给定的 interfaces 来生成 Proxy 类，这个方法首先去缓存中查找是否已经构造了 Proxy 实例
//如果还没有构造，那么就通过 ProxyClassFactory 来构造实例
return proxyClassCache.get(loader, interfaces);
}
|
在 proxyClassCache.get(loader, interfaces); 方法执行过程中分为如下几步：
- 通过注入类加载器、接口 interfaces 初始化 WeakCache.Factory 工厂实例；
- 利用工厂实例类动态生成一个类型为 com.sun.proxy.$Proxy 的字节码
byte[]；
- 利用字节码构造 com.sun.proxy.$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
|
//java.lang.reflect.Proxy.ProxyClassFactory#apply
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
//遍历我们输入的 interfaces 接口数组
for (Class<?> intf : interfaces) {
//这里在检查每一个 interface 通过输入的类加载器加载后和原来的接口是否是同一个类
//因为 Java 的类加载机制有命名空间 NameSpace 机制
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
//因为 interfaces 的元素类型是 Class，这里需要检查 Class 是否真的是指向接口而不是一般类
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
//利用 Set 来确保 interfaces 内没有放置重复的接口类型实例
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
//检查 Proxy 类的 package 管理的相关机制（不是重点）
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
// 如果没有公开的代理接口，使用com.sun.proxy包
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//生成 Proxy 类的类名称
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//这里开始是重点
//输入值依次为：生成的代理类的类名、接口、public final 修饰标记，用于生成代理类的字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//利用字节码 byte[] 数组直接生成 Proxy 类实例
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
|
如果你觉得代码太长，不妨先看一下这张执行流程图：
这里有几个小问题需要解决：
-
为什么构造 Proxy 匿名内部类的字节码输入不需要 Proxy 类呢？
这是因为无论是 Proxy.ProxyClassFactory 还是 Proxy.defineClass0() 方法它们都知道你要构造 Proxy 的匿名内部类，这是写死的，因此我们并不需要再输入 Proxy 的 Class 对象；
-
为什么 JDK 的动态代理仅仅支持接口而不支持继承呢？
虽然继承和接口在利用多态实现动态代理没有太大的区别，但是 Java 是一门仅仅支持单一继承的语言，而所有 Proxy 匿名内部类都是 Proxy 类的子类（这是匿名内部类的定义要求之一），即动态代理类默认继承 com.sun.Proxy 类，因此无法基于继承实现动态代理。
-
为什么动态代理的方法体不能进行 Debug？
动态代理类都是匿名内部类，没有 .java 文件，也没有 Class 文件，而 IDE 的 Debug 模式依赖于行号，连文件都没有哪来行号，因此不能 Debug。当然你能对 InvocationHandler 的 invoke() 方法进行 debug，我指的是你无法利用 debug 来测试 invoke() 方法是如何被调用的。
那么作为 Proxy 子类的（匿名内部类）的代理类是如何调用 InvocationHandler 的 invoke() 方法的呢？
我们无法通过 debug 来观察 InvocationHandler 如何被调用，但是可以通过将匿名内部类的 Class 文件保存于硬盘，然后利用反编译软件来查看其实现机理。
如何将 Class 文件保存于硬盘于见此章节末尾的 GitHub 项目地址，本节的所有代码也都放在此目录下。
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
|
//反编译文件
package com.sun.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Foo;
public final class $Proxy0 extends Proxy implements Foo {
//静态的 Method 实例，初始化写于类的最后
private static Method m1;
private static Method m2;
private static Method m3;
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 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 String bar(String var1, int var2) throws {
try {
return (String)super.h.invoke(this, m3, new Object[]{var1, var2});
} catch (RuntimeException | Error var4) {
throw var4;
} catch (Throwable var5) {
throw new UndeclaredThrowableException(var5);
}
}
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"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("proxy.Foo").getMethod("bar", Class.forName("java.lang.String"), Integer.TYPE);
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
|
通过上述反编译的匿名内部类代码，我们可以看出：
-
匿名内部类对于方法 equals()、toString()、hashCode() 方法首先映射为 Object 的方法对应的 Method 实例，然后转发给 InvocationHandler 实例的 invoke() 方法。注意：其他方法（包括代理方法）都将代理类作为方法接受者，而不是 InvocationHandler 实例；
比如说，即使你为 InvocationHandler 实例创建了多个代理类实例，但是它们的 equals() 方法返回 true，因为比较的是 InvocationHandler 实例，而不是代理类实例。这要求我们对 InvocationHandler.invoke() 进行此方法逻辑代码的处理。
-
从匿名内部类的 bar() 方法可以看出，其除了捕获异常代码块，实际上就是直接简单地调用 InvocationHandler 实例的 invoke() 方法。
而 invoke() 方法的逻辑通常是根据传入的 Method method 实例的类型来执行不同的逻辑，但是不需要每次调用都重新创建 Mehthod 实例（它们是静态字段，仅仅初始化一次），因此和普通方法调用相比，在执行效率上区别不大。
因此我们可以看到代理类的继承、实现、依赖关系如下图所示：
- Proxyee 为被代理类；
- Proxyer 为代理类，负责代理逻辑的组织以及对外暴露 interfaces 接口方法；
- InvocationHandler 为回调函数的方法，这里的回调函数即代理方法；
最后总结一下，JDK 的动态代理简单明了，可以将其视作动态生成的匿名内部类版本的静态代理，但是在代理逻辑上和静态代理没有任何区别。其核心思想是基于接口 interfaces 以及 com.sun.proxy.Proxy 类动态新生成一个全新的代理类的字节码，然后基于字节码生成 Proxy 的匿名内部类。
接下来会看到 CGLIB 动态代理和 JDK 动态代理的主要区别就在于：
- JDK 是基于 com.sun.proxy.Proxy 类以及 interfaces 生成全新的字节码；
- CGLIB 直接在原字节码上修改，因此无需依赖于接口；
补充：
- 本文基于 JDK8 进行讲述；
- 具体的 JDK 动态代理源码分析，可见：https://www.iteye.com/blog/rejoy-1627405
2.2 CGLIB 动态代理
限于篇幅，CGLIB 动态代理不妨看我的另一篇文章：CGLIB 动态代理的实际演练
2.3 AspectJ 动态代理
限于篇幅，CGLIB 动态代理不妨看我的另一篇文章：AspectJ 动态代理的实际演练