你必须会的 JDK 动态代理和 CGLIB 动态代理

我们在阅读一些 Java 框架的源码时,基本上常会看到使用动态代理机制,它可以无感的对既有代码进行方法的增强,使得代码拥有更好的拓展性。
通过从静态代理、JDK 动态代理、CGLIB 动态代理来进行本文的分析。

静态代理

静态代理就是在程序运行之前,代理类字节码.class就已编译好,通常一个静态代理类也只代理一个目标类,代理类和目标类都实现相同的接口。
接下来就先通过 demo 进行分析什么是静态代理,当前创建一个 Animal 接口,里面包含call函数。

1
2
3
4
5
6
7
8
9
10
package top.ytao.demo.proxy;

/**
* Created by YangTao
*/
public interface Animal {

void call();

}

创建目标类 Cat,同时实现 Animal 接口,下面是 Cat 发出叫声的实现。

1
2
3
4
5
6
7
8
9
10
11
12
package top.ytao.demo.proxy;

/**
* Created by YangTao
*/
public class Cat implements Animal {

@Override
public void call() {
System.out.println("喵喵喵 ~");
}
}

由于 Cat 叫之前是因为肚子饿了,所以我们需要在目标对象方法Cat#call之前说明是饥饿,这是使用静态代理实现猫饥饿然后发出叫声。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package top.ytao.demo.proxy.jdk;

import top.ytao.demo.proxy.Animal;

/**
* Created by YangTao
*/
public class StaticProxyAnimal implements Animal {

private Animal impl;

public StaticProxyAnimal(Animal impl) {
this.impl = impl;
}

@Override
public void call() {
System.out.println("猫饥饿");
impl.call();
}
}

通过调用静态代理实现猫饥饿和叫行为。

1
2
3
4
5
6
7
8
public class Main {

@Test
public void staticProxy(){
Animal staticProxy = new StaticProxyAnimal(new Cat());
staticProxy.call();
}
}

执行结果

代理类、目标类、接口之间关系如图:

以上内容可以看到代理类中通过持有目标类对象,然后通过调用目标类的方法,实现静态代理。
静态代理虽然实现了代理,但在一些情况下存在比较明显不足之处:

  1. 当我们在 Animal 接口中增加方法,这时不仅实现类 Cat 需要新增该方法的实现,同时,由于代理类实现了 Animal 接口,所以代理类也必须实现 Animal 新增的方法,这对项目规模较大时,在维护上就不太友好了。
  2. 代理类实现Animal#call是针对 Cat 目标类的对象进行设置的,如果再需要添加 Dog 目标类的代理,那就必须再针对 Dog 类实现一个对应的代理类,这样就使得代理类的重用型不友好,并且过多的代理类对维护上也是比较繁琐。

上面问题,在 JDk 动态代理中就得到了较友好的解决。

JDK 动态代理

动态代理类与静态代理类最主要不同的是,代理类的字节码不是在程序运行前生成的,而是在程序运行时再虚拟机中程序自动创建的。
继续用上面 Cat 类和 Animal 接口实现 JDK 动态代理。

实现 InvocationHandler 接口

JDK 动态代理类必须实现反射包中的 java.lang.reflect.InvocationHandler 接口,在此接口中只有一个 invoker 方法:

InvocationHandler#invoker中必须调用目标类被代理的方法,否则无法做到代理的实现。下面为实现 InvocationHandler 的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
* Created by YangTao
*/
public class TargetInvoker implements InvocationHandler {
// 代理中持有的目标类
private Object target;

public TargetInvoker(Object target) {
this.target = target;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("jdk 代理执行前");
Object result = method.invoke(target, args);
System.out.println("jdk 代理执行后");
return result;
}
}

在实现InvocationHandler#invoker时,该方法里有三个参数:

  • proxy 代理目标对象的代理对象,它是真实的代理对象。
  • method 执行目标类的方法
  • args 执行目标类的方法的参数

创建 JDK 动态代理类

创建 JDK 动态代理类实例同样也是使用反射包中的 java.lang.reflect.Proxy 类进行创建。通过调用Proxy#newProxyInstance静态方法进行创建。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
*
* Created by YangTao
*/
public class DynamicProxyAnimal {

public static Object getProxy(Object target) throws Exception {
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 指定目标类的类加载
target.getClass().getInterfaces(), // 代理需要实现的接口,可指定多个,这是一个数组
new TargetInvoker(target) // 代理对象处理器
);
return proxy;
}

}

Proxy#newProxyInstance中的三个参数(ClassLoader loader、Class<?>[] interfaces、InvocationHandler h):

  • loader 加载代理对象的类加载器
  • interfaces 代理对象实现的接口,与目标对象实现同样的接口
  • h 处理代理对象逻辑的处理器,即上面的 InvocationHandler 实现类。

最后实现执行 DynamicProxyAnimal 动态代理:

1
2
3
4
5
6
7
8
9
public class Main {

@Test
public void dynamicProxy() throws Exception {
Cat cat = new Cat();
Animal proxy = (Animal) DynamicProxyAnimal.getProxy(cat);
proxy.call();
}
}

执行结果:

通过上面的代码,有两个问题:代理类是怎么创建的和代理类怎么调用方法的?

分析

Proxy#newProxyInstance入口进行源码分析:

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
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<?> cl = getProxyClass0(loader, intfs);

try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}

// 获取代理的构造器
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
// 处理代理类修饰符,使得能被访问
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
// 创建代理类实例化
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);
}
}

newProxyInstance 方法里面获取到代理类,如果类的作用不能访问,使其能被访问到,最后实例化代理类。这段代码中最为核心的是获取代理类的getProxyClass0方法。

1
2
3
4
5
6
7
8
9
10
11
12
private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
// 实现类的接口不能超过 65535 个
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}

// 获取代理类
return proxyClassCache.get(loader, interfaces);
}

如果 proxyClassCache 缓存中存在指定的代理类,则从缓存直接获取;如果不存在,则通过 ProxyClassFactory 创建代理类。
至于为什么接口最大为 65535,这个是由字节码文件结构和 Java 虚拟机规定的,具体可以通过研究字节码文件了解。

进入到proxyClassCache#get,获取代理类:

继续进入Factory#get查看,

最后到ProxyClassFactory#apply,这里实现了代理类的创建。

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
77
78
79
80
81
private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>>{
// 所有代理类名称都已此前缀命名
private static final String proxyClassNamePrefix = "$Proxy";

// 代理类名的编号
private static final AtomicLong nextUniqueNumber = new AtomicLong();

@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {

// 校验代理和目标对象是否实现同一接口
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");
}

// 校验 interfaceClass 是否为接口
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}

// 判断当前 interfaceClass 是否被重复
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}

// 代理类的包名
String proxyPkg = null;
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

// 记录非 public 修饰符代理接口的包,使生成的代理类与它在同一个包下
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) {
// 如果接口类是 public 修饰,则用 com.sun.proxy 包名
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}

// 创建代理类名称
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;

// 生成代理类字节码文件
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
// 加载字节码,生成指定代理对象
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}

以上就是创建字节码流程,通过检查接口的属性,决定代理类字节码文件生成的包名及名称规则,然后加载字节码获取代理实例。操作生成字节码文件在ProxyGenerator#generateProxyClass中生成具体的字节码文件,字节码操作这里不做详细讲解。
生成的字节码文件,我们可以通过保存本地进行反编译查看类信息,保存生成的字节码文件可以通过两种方式:设置jvm参数或将生成 byte[] 写入文件。

上图的ProxyGenerator#generateProxyClass方法可知,是通过 saveGeneratedFiles 属性值控制,该属性的值来源:

1
private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();

所以通过设置将生成的代理类字节码保存到本地。

1
-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true

反编译查看生成的代理类:

生成的代理类继承了 Proxy 和实现了 Animal 接口,调用call方法,是通过调用 Proxy 持有的 InvocationHandler 实现TargetInvoker#invoker的执行。

CGLIB 动态代理

CGLIB 动态代理的实现机制是生成目标类的子类,通过调用父类(目标类)的方法实现,在调用父类方法时再代理中进行增强。

实现 MethodInterceptor 接口

相比于 JDK 动态代理的实现,CGLIB 动态代理不需要实现与目标类一样的接口,而是通过方法拦截的方式实现代理,代码实现如下,首先方法拦截接口 net.sf.cglib.proxy.MethodInterceptor。

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* Created by YangTao
*/
public class TargetInterceptor implements MethodInterceptor {

@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("CGLIB 调用前");
Object result = proxy.invokeSuper(obj, args);
System.out.println("CGLIB 调用后");
return result;
}
}

通过方法拦截接口调用目标类的方法,然后在该被拦截的方法进行增强处理,实现方法拦截器接口的 intercept 方法里面有四个参数:

  • obj 代理类对象
  • method 当前被代理拦截的方法
  • args 拦截方法的参数
  • proxy 代理类对应目标类的代理方法

创建 CGLIB 动态代理类

创建 CGLIB 动态代理类使用 net.sf.cglib.proxy.Enhancer 类进行创建,它是 CGLIB 动态代理中的核心类,首先创建个简单的代理类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* Created by YangTao
*/
public class CglibProxy {

public static Object getProxy(Class<?> clazz){
Enhancer enhancer = new Enhancer();
// 设置类加载
enhancer.setClassLoader(clazz.getClassLoader());
// 设置被代理类
enhancer.setSuperclass(clazz);
// 设置方法拦截器
enhancer.setCallback(new TargetInterceptor());
// 创建代理类
return enhancer.create();
}

}

设置被代理类的信息和代理类拦截的方法的回调执行逻辑,就可以实现一个代理类。
实现 CGLIB 动态代理调用:

1
2
3
4
5
6
7
8
public class Main {

@Test
public void dynamicProxy() throws Exception {
Animal cat = (Animal) CglibProxy.getProxy(Cat.class);
cat.call();
}
}

执行结果:

CGLIB 动态代理简单应用就这样实现,但是 Enhancer 在使用过程中,常用且有特色功能还有回调过滤器 CallbackFilter 的使用,它在拦截目标对象的方法时,可以有选择性的执行方法拦截,也就是选择被代理方法的增强处理。使用该功能需要实现 net.sf.cglib.proxy.CallbackFilter 接口。
现在增加一个方法拦截的实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* Created by YangTao
*/
public class TargetInterceptor2 implements MethodInterceptor {

@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("CGLIB 调用前 TargetInterceptor2");
Object result = proxy.invokeSuper(obj, args);
System.out.println("CGLIB 调用后 TargetInterceptor2");
return result;
}
}

然后在 Cat 中增加 hobby 方法,因为 CGLIB 代理无需实现接口,可以直接代理普通类,所以不需再 Animal 接口中增加方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package top.ytao.demo.proxy;

/**
* Created by YangTao
*/
public class Cat implements Animal {

@Override
public void call() {
System.out.println("喵喵喵 ~");
}

public void hobby(){
System.out.println("fish ~");
}
}

实现回调过滤器 CallbackFilter

1
2
3
4
5
6
7
8
9
10
11
12
/**
* Created by YangTao
*/
public class TargetCallbackFilter implements CallbackFilter {
@Override
public int accept(Method method) {
if ("hobby".equals(method.getName()))
return 1;
else
return 0;
}
}

为演示调用不同的方法拦截器,在 Enhancer 设置中,使用Enhancer#setCallbacks设置多个方法拦截器,参数是一个数组,TargetCallbackFilter#accept返回的数字即为该数组的索引,决定调用的回调选择器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* Created by YangTao
*/
public class CglibProxy {

public static Object getProxy(Class<?> clazz){
Enhancer enhancer = new Enhancer();
enhancer.setClassLoader(clazz.getClassLoader());
enhancer.setSuperclass(clazz);
enhancer.setCallbacks(new Callback[]{new TargetInterceptor(), new TargetInterceptor2()});
enhancer.setCallbackFilter(new TargetCallbackFilter());
return enhancer.create();
}

}

按代码实现逻辑,call 方法会调用 TargetInterceptor 类,hobby 类会调用 TargetInterceptor2 类,执行结果:

CGLIB 的实现原理是通过设置被代理的类信息到 Enhancer 中,然后利用配置信息在Enhancer#create生成代理类对象。生成类是使用 ASM 进行生成,本文不做重点分析。如果不关注 ASM 的操作原理,只看 CGLIB 的处理原理还是比较容易读懂。这里主要看生成后的代理类字节码文件,通过设置

1
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "F:\\xxx");

可保存生成的字节到 F:\xxx 文件夹中

通过反编译可看到

代理类继承了目标类 Cat,同时将两个方法拦截器加载到了代理类中,通过 Callbacks 下标作为变量名后缀进行区分,最后调用指定的方法拦截器中的 intercept 实现代理的最终的执行结果。
这里需要注意的是 CGLIB 动态代理不能代理 final 修饰的类和方法。

最后

通过反编译生成的 JDK 代理类和 CGLIB 代理类,我们可以看到它们两种不同机制的实现:
JDK 动态代理是通过实现目标类的接口,然后将目标类在构造动态代理时作为参数传入,使代理对象持有目标对象,再通过代理对象的 InvocationHandler 实现动态代理的操作。
CGLIB 动态代理是通过配置目标类信息,然后利用 ASM 字节码框架进行生成目标类的子类。当调用代理方法时,通过拦截方法的方式实现代理的操作。
总的来说,JDK 动态代理利用接口实现代理,CGLIB 动态代理利用继承的方式实现代理。

动态代理在 Java 开发中是非常常见的,在日志,监控,事务中都有着广泛的应用,同时在大多主流框架中的核心组件中也是少不了使用的,掌握其要点,不管是开发还是阅读其他框架源码时,都是必须的。

Yang Tao wechat
我的公众号
原创技术分享,感谢您的鼓励!
0%