动态代理在 Java 中有着广泛的应用,比如 Spring AOP,Hibernate 数据查询、测试框架的后端 mock、RPC,Java 注解对象获取等。静态代理的代理关系在编译时就确定了,而动态代理的代理关系是在编译期确定的。静态代理实现简单,适合于代理类较少且确定的情况,而动态代理则给我们提供了更大的灵活性。今天我们来探讨 Java 中两种常见的动态代理方式:JDK 原生动态代理和 CGLIB 动态代理。
先从直观的示例说起,假设我们有一个接口 Hello 和一个简单实现 HelloImp:
- // 接口
- interface Hello{
- String sayHello(String str);
- }
- // 实现
- class HelloImp implements Hello{
- @Override
- public String sayHello(String str) {
- return "HelloImp: " + str;
- }
- }
这是 Java 种再常见不过的场景,使用接口制定协议,然后用不同的实现来实现具体行为。假设你已经拿到上述类库,如果我们想通过日志记录对 sayHello() 的调用,使用静态代理可以这样做:
- // 静态代理方式
- class StaticProxiedHello implements Hello{
- ...
- private Hello hello = new HelloImp();
- @Override
- public String sayHello(String str) {
- logger.info("You said: " + str);
- return hello.sayHello(str);
- }
- }
上例中静态代理类 StaticProxiedHello 作为 HelloImp 的代理,实现了相同的 Hello 接口。用 Java 动态代理可以这样做:
- // Java Proxy
- // 1. 首先实现一个InvocationHandler,方法调用会被转发到该类的invoke()方法。
- class LogInvocationHandler implements InvocationHandler{
- ...
- private Hello hello;
- public LogInvocationHandler(Hello hello) {
- this.hello = hello;
- }
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- if("sayHello".equals(method.getName())) {
- logger.info("You said: " + Arrays.toString(args));
- }
- return method.invoke(hello, args);
- }
- }
- // 2. 然后在需要使用Hello的时候,通过JDK动态代理获取Hello的代理对象。
- Hello hello = (Hello)Proxy.newProxyInstance(
- getClass().getClassLoader(), // 1. 类加载器
- new Class<?>[] {Hello.class}, // 2. 代理需要实现的接口,可以有多个
- new LogInvocationHandler(new HelloImp()));// 3. 方法调用的实际处理者
- System.out.println(hello.sayHello("I love you!"));
运行上述代码输出结果:
- 日志信息: You said: [I love you!]
- HelloImp: I love you!
上述代码的关键是
方法,该方法会根据指定的参数动态创建代理对象。三个参数的意义如下:
- Proxy.newProxyInstance(ClassLoader loader, Class < ?>[] interfaces, InvocationHandler handler)
newProxyInstance() 会返回一个实现了指定接口的代理对象,对该对象的所有方法调用都会转发给
方法。理解上述代码需要对 Java 反射机制有一定了解。动态代理神奇的地方就是:
- InvocationHandler.invoke()
方法,在 invoke() 方法里我们可以加入任何逻辑,比如修改方法参数,加入日志功能、安全检查功能等;之后我们通过某种方式执行真正的方法体,示例中通过反射调用了 Hello 对象的相应方法,还可以通过 RPC 调用远程方法。
- InvocationHandler.invoke()
注意 1:对于从 Object 中继承的方法,JDK Proxy 会把 hashCode()、equals()、toString() 这三个非接口方法转发给 InvocationHandler,其余的 Object 方法则不会转发。详见 JDK Proxy 官方文档 。
如果对 JDK 代理后的对象类型进行深挖,可以看到如下信息:
- # Hello代理对象的类型信息
- class=class jdkproxy.$Proxy0
- superClass=class java.lang.reflect.Proxy
- interfaces:
- interface jdkproxy.Hello
- invocationHandler=jdkproxy.LogInvocationHandler@a09ee92
代理对象的类型是 jdkproxy.$Proxy0,这是个动态生成的类型,类名是形如 $ProxyN 的形式;父类是
,所有的 JDK 动态代理都会继承这个类;同时实现了 Hello 接口,也就是我们接口列表中指定的那些接口。
- java.lang.reflect.Proxy
如果你还对 jdkproxy.$Proxy0 具体实现感兴趣,它大致长这个样子:
- // JDK代理类具体实现
- public final class $Proxy0 extends Proxy implements Hello
- {
- ...
- public $Proxy0(InvocationHandler invocationhandler)
- {
- super(invocationhandler);
- }
- ...
- @Override
- public final String sayHello(String str){
- ...
- return super.h.invoke(this, m3, new Object[] {str});// 将方法调用转发给invocationhandler
- ...
- }
- ...
- }
这些逻辑没什么复杂之处,但是他们是在运行时动态产生的,无需我们手动编写。更多详情,可参考 BrightLoong 的 Java 静态代理 & 动态代理笔记
Java 动态代理为我们提供了非常灵活的代理机制,但 Java 动态代理是基于接口的,如果对象没有实现接口我们该如何代理呢?CGLIB 登场。
CGLIB (Code Generation Library) 是一个基于 ASM 的字节码生成库,它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。
来看示例,假设我们有一个没有实现任何接口的类 HelloConcrete:
- public class HelloConcrete {
- public String sayHello(String str) {
- return "HelloConcrete: " + str;
- }
- }
因为没有实现接口该类无法使用 JDK 代理,通过 CGLIB 代理实现如下:
- // CGLIB动态代理
- // 1. 首先实现一个MethodInterceptor,方法调用会被转发到该类的intercept()方法。
- class MyMethodInterceptor implements MethodInterceptor{
- ...
- @Override
- public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
- logger.info("You said: " + Arrays.toString(args));
- return proxy.invokeSuper(obj, args);
- }
- }
- // 2. 然后在需要使用HelloConcrete的时候,通过CGLIB动态代理获取代理对象。
- Enhancer enhancer = new Enhancer();
- enhancer.setSuperclass(HelloConcrete.class);
- enhancer.setCallback(new MyMethodInterceptor());
- HelloConcrete hello = (HelloConcrete)enhancer.create();
- System.out.println(hello.sayHello("I love you!"));
运行上述代码输出结果:
- 日志信息: You said: [I love you!]
- HelloConcrete: I love you!
上述代码中,我们通过 CGLIB 的 Enhancer 来指定要代理的目标对象、实际处理代理逻辑的对象,最终通过调用 create() 方法得到代理对象,对这个对象所有非 final 方法的调用都会转发给
方法,在 intercept() 方法里我们可以加入任何逻辑,比如修改方法参数,加入日志功能、安全检查功能等;通过调用
- MethodInterceptor.intercept()
方法,我们将调用转发给原始对象,具体到本例,就是 HelloConcrete 的具体方法。CGLIG 中 MethodInterceptor 的作用跟 JDK 代理中的 InvocationHandler 很类似,都是方法调用的中转站。
- MethodProxy.invokeSuper()
注意:对于从 Object 中继承的方法,CGLIB 代理也会进行代理,如 hashCode()、equals()、toString() 等,但是 getClass()、wait() 等方法不会,因为它是 final 方法,CGLIB 无法代理。
如果对 CGLIB 代理之后的对象类型进行深挖,可以看到如下信息:
- # HelloConcrete代理对象的类型信息
- class=class cglib.HelloConcrete$EnhancerByCGLIB$e3734e52
- superClass=class lh.HelloConcrete
- interfaces:
- interface net.sf.cglib.proxy.Factory
- invocationHandler=not java proxy class
我们看到使用 CGLIB 代理之后的对象类型是
,这是 CGLIB 动态生成的类型;父类是 HelloConcrete,印证了 CGLIB 是通过继承实现代理;同时实现了
- cglib.HelloConcrete$EnhancerByCGLIB$e3734e52
接口,这个接口是 CGLIB 自己加入的,包含一些工具方法。
- net.sf.cglib.proxy.Factory
注意,既然是继承就不得不考虑 final 的问题。我们知道 final 类型不能有子类,所以 CGLIB 不能代理 final 类型,遇到这种情况会抛出类似如下异常:
- java.lang.IllegalArgumentException: Cannot subclass final class cglib.HelloConcrete
同样的,final 方法是不能重载的,所以也不能通过 CGLIB 代理,遇到这种情况不会抛异常,而是会跳过 final 方法只代理其他方法。
如果你还对代理类
具体实现感兴趣,它大致长这个样子:
- cglib.HelloConcrete$EnhancerByCGLIB$e3734e52
- // CGLIB代理类具体实现
- public class HelloConcrete$EnhancerByCGLIB$e3734e52
- extends HelloConcrete
- implements Factory
- {
- ...
- private MethodInterceptor CGLIB$CALLBACK_0; // ~~
- ...
- public final String sayHello(String paramString)
- {
- ...
- MethodInterceptor tmp17_14 = CGLIB$CALLBACK_0;
- if (tmp17_14 != null) {
- // 将请求转发给MethodInterceptor.intercept()方法。
- return (String)tmp17_14.intercept(this,
- CGLIB$sayHello$0$Method,
- new Object[] { paramString },
- CGLIB$sayHello$0$Proxy);
- }
- return super.sayHello(paramString);
- }
- ...
- }
上述代码我们看到,当调用代理对象的 sayHello() 方法时,首先会尝试转发给
方法,如果没有 MethodInterceptor 就执行父类的 sayHello()。这些逻辑没什么复杂之处,但是他们是在运行时动态产生的,无需我们手动编写。如何获取 CGLIB 代理类字节码可参考 Access the generated byte[] array directly 。
- MethodInterceptor.intercept()
更多关于 CGLIB 的介绍可以参考 Rafael Winterhalter 的 cglib: The missing manual ,一篇很深入的文章。
本文介绍了 Java 两种常见动态代理机制的用法和原理,JDK 原生动态代理是 Java 原生支持的,不需要任何外部依赖,但是它只能基于接口进行代理;CGLIB 通过继承的方式进行代理,无论目标对象有没有实现接口都可以代理,但是无法处理 final 的情况。
动态代理是 Spring AOP (Aspect Orient Programming, 面向切面编程) 的实现方式,了解动态代理原理,对理解 Spring AOP 大有帮助。