【Java】深入理解动态代理：JDK、CGLIB
代理模式
日常生活中代理司空见惯的，比如某地区总代理，直白点就是中间商。在代码的世界里也有这种“中间商”，不过这个“中间商”不收差价，有时候甚至给你点额外的“小惊喜”。
代理模式有3个要素：接口、目标类(委托人)、代理类(中间商)。目标类、代理类都实现同一个接口，代理类有一个目标类的属性。客户所有的请求都是到代理类对象，代理对象转发到目标对象。
那么前面说的“小惊喜”是什么呢？ 代理对象在找目标对象之前，可以自己做一些扩展。
- 代理商可以提前备一些货，直接给到你，无需找厂家 ---- 缓存
- 如果某个品牌货厂家不生产了，可直接告诉你，无需你去厂家确认 ---- 扩展限制条件
所以代理模式有以下好处：
- 屏蔽底层的实现；
- 遵守设计模式的开闭原则，欢迎扩展、拒绝修改。
动态代理
一般情况要实现代理模式，开发者需要显示创建代理类，然后编译打包运行，我们称为静态代理。不过，由于jvm类加载的机制，允许开发者主动加载某个类，开发者可以在程序运行时动态创建代理类，然后通过类加载器加载到jvm，实例化代理对象，这就是动态代理。动态代理的核心是如何生成代理类。目前，有两种方式生成动态代理：JDK动态代理、CGLIB动态代理。
JDK动态代理
jdk动态代理是jdk自带的动态代理方式，核心组件有java.lang.reflect.Proxy、java.lang.reflect.InvocationHandler(接口)。jdk动态代理稍微修改了代理模式模型-引入了InvocationHandler。jdk动态代理生成代理类之后的类图模型如下：
jdk生成的代理类ProxyClass继承java.lang.reflect.Proxy，后者有个成员变量h(java.lang.reflect.InvocationHandler)，开发者可以在InvocationHandler实现类中关联目标对象(TargetClass)。创建代理对象的实现需要传入InvocationHandler的实现类。引入InvocationHandler有两点作用：
- 创建代理类更简单，直接把所有的请求转发到InvocationHandler#invoke即可，由InvocationHandler#invoke完成分发调用目标对象的方法；
- 让开发者可以非常方便实现扩展功能，InvocationHandler#invoke在分发请求之前、之后、异常等位置扩展功能。
jdk动态代理使用起来很简单，直接拿例子说吧。如下图，假设有LocalWriterPrinter实现3个接口Priter、Writer、WriterPrinter，我们对目标对象(LocalWriterPrinter)做动态代理，在方法前后加上额外的信息。
目标类LocalWriterPrinter实现3个接口：
public class LocalWriterPrinter implements Writer, Printer, WriterPrinter {
public String print(String text) {
System.out.println(this.getClass().getSimpleName() + " print:" + text);
return text;
}
public String write(String text) {
System.out.println(this.getClass().getSimpleName() + " write:" + text);
return text;
}
}Jdk动态代理是通过InvocationHandler#invoke分发代理请求，所以需要一个InvocationHandler实现类WriterPrinterInvocationHandler，目标类对象printer是其成员变量。我们在调用目标类对象之前、之后还有finlly都做一个额外的事情(例子只打个日志)
public class WriterPrinterInvocationHandler implements InvocationHandler {
private Object printer;
public WriterPrinterInvocationHandler(Object writerPrinter) {
this.printer = writerPrinter;
};
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
System.out.println("before advice:" + method.getDeclaringClass().getSimpleName() + "." + method.getName());
Object ret = method.invoke(printer, args);
System.out.println("after advice:" + method.getDeclaringClass().getSimpleName() + "." + method.getName());
return ret;
} finally {
System.out.println("finally advice:" + method.getDeclaringClass().getSimpleName() + "." + method.getName());
}
}
}public class JdkDynamicDemo {
public static void main(String... args) {
//创建目标类对象
LocalWriterPrinter target= new LocalWriterPrinter();
//创建InvocationHander，并将目标类对象作为属性
WriterPrinterInvocationHandler handler = new WriterPrinterInvocationHandler(target);
Class[] infs = {Printer.class, WriterPrinter.class, Writer.class};
//调用Proxy.newProxyInstance创建代理类对象
Object writerPrinter = Proxy.newProxyInstance(JdkDynamicDemo.class.getClassLoader(), infs, handler);
//执行代理类对象的print方法
Printer printer = (Printer)writerPrinter;
printer.print("jdk dynamic");
//执行代理类对象的write方法
Writer writer = (Writer) writerPrinter;
writer.write("jdk dynamic");
}
}运行结果如下：
我们看以下生成的代理类是什么样的（用jdk的HSDB工具导出代理类）
package com.sun.proxy;
import com.focuse.dynamicdemo.jdkproxy.Printer;
import com.focuse.dynamicdemo.jdkproxy.Writer;
import com.focuse.dynamicdemo.jdkproxy.WriterPrinter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Printer, WriterPrinter, Writer {
private static Method m1;
private static Method m2;
private static Method m0;
private static Method m3;
private static Method m4;
public $Proxy0(InvocationHandler var1) {
super(var1);
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
m3 = Class.forName("com.focuse.dynamicdemo.jdkproxy.Printer").getMethod("print", Class.forName("java.lang.String"));
//笔者注：write方法来源于WritePrinter，因为传入的接口数组中WritePrinter接口在前,Writer接口在后
m4 = Class.forName("com.focuse.dynamicdemo.jdkproxy.WriterPrinter").getMethod("write", Class.forName("java.lang.String"));
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
public final boolean equals(Object var1) {
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() {
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 int hashCode() {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final String write(String var1) {
try {
return (String)super.h.invoke(this, m4, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String print(String var1) {
try {
return (String)super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
}h就是创建代理对象时传入的InvocationHandler实例，看到代理类的代码一切都清晰了，所的请求的都转到InvocationHandler实例h处理。InvocationHandler#invoke第一个参数是代理对象，第二个参数是被代理接口的method，第三个参数请求的实际参数。显而易见，jdk动态代理有以下特点：
- JDK动态代理支持对Interface生成代理类，不支持对Class生成代理类；
- 所有的代理请求都是通过InvocationHandler#invoke转发，开发者可以在这里干任何想干的事情；
- 如果多个接口类中有相同签名的方法(名称、参数个数、参数类型)，代理类传给InvocationHandler#invoke的method参数来源于第一个接口类，例如本例中write方法就是来源于WritePrinter接口。
CGLIB动态代理
不同于JDK动态代理，CGLIB是通过生成目标类的子类实现的。核心组件是net.sf.cglib.proxy.Enhancer和net.sf.cglib.proxy.Callback。Callback相当于JDK动态代理中的InvocationHandler。其实，CGLIB的功能只是增强父类的逻辑，要用它实现代理模式，需要在Callback里关联目标对象。子类的逻辑是如果Callback不为空执行Callback，否则执行父类方法。
CGLIB提供四种Callback子类型，一般做动态代理的是net.sf.cglib.proxy.MethodInterceptor：
咋一看这个类图看不出是代理模式，我们转换一下画一个对象图就看得明白了。我们用黑心圆点表示实例关系，如下图，代理对象和目标对象都是目标类的实例，代理对象实际是目标类子类(代理类)的实例。
同样，我们举个小栗子，对Printer类做动态代理，并在print方法之前、之后、finally位置做一些扩展(本例仅仅打个日志)。首先看一下原来的Printer类
public class Printer {
public String print(String text) {
System.out.println("Local Printer:" + text);
return text;
}
protected String print22(String text) {
System.out.println("Local Printer:" + text);
return text;
}
private String print33(String text) {
System.out.println("Local Printer:" + text);
return text;
}
}其次，实现一个MethodInterceptor，目标对象作为其成员变量，并在调用目标对象方法之前、之后、finally位置加上相应日志。
public class LocalPrinterCallback implements MethodInterceptor {
Object target;
public LocalPrinterCallback(Object target) {
this.target = target;
}
//代理
public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
MethodProxy proxy) throws Throwable{
try {
System.out.println("before advice");
//请求目标对象方法
Object ret = method.invoke(target, args);
System.out.println("after advice");
return ret;
}finally {
System.out.println("finally advice");
}
}
}接下来就是开始用CGLIB进行动态代理
public class CglibDynamicDemo {
public static void main(String... args) {
//目标对象
Printer target = new Printer();
//callback 目标对象作为其成员变量
LocalPrinterCallback localCallback = new LocalPrinterCallback(target);
//创建enhancer类
Enhancer enhancer = new Enhancer();
//设置需要增强的类Printer
enhancer.setSuperclass(Printer.class);
//设置callback 相当于jdk动态代理的InvocationHandler
enhancer.setCallback(localCallback);
//创建代理类并返回代理对象
Object object = enhancer.create();
Printer proxy = (Printer)object;
//执行print方法
proxy.print("cglib demo");
}
}运行结果如下，期望在增强的位置打出相应的信息：
我们看一下CGLIB生成的代理类是什么样的(也是用jdk的HSDB工具导出代理类) 。cglib生成的代理类比jdk动态代理生成的代理类相对复杂一些。不过，我们主要看一下print方法的实现，不难看出，print方法的逻辑是当callback不为空null时就去调用callback的net.sf.cglib.proxy.MethodInterceptor#intercept方法(本例中callback是MethodInterceptor类型)。同时，我们也看到cglib只对public和protected修饰的方法做代理，private方法则不做。
package com.focuse.dynamicdemo.cglibproxy;
import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class Printer$$EnhancerByCGLIB$$9402db17 extends Printer implements Factory {
private boolean CGLIB$BOUND;
public static Object CGLIB$FACTORY_DATA;
private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
private static final Callback[] CGLIB$STATIC_CALLBACKS;
private MethodInterceptor CGLIB$CALLBACK_0;
private static Object CGLIB$CALLBACK_FILTER;
private static final Method CGLIB$print$0$Method;
private static final MethodProxy CGLIB$print$0$Proxy;
private static final Object[] CGLIB$emptyArgs;
private static final Method CGLIB$print22$1$Method;
private static final MethodProxy CGLIB$print22$1$Proxy;
private static final Method CGLIB$equals$2$Method;
private static final MethodProxy CGLIB$equals$2$Proxy;
private static final Method CGLIB$toString$3$Method;
private static final MethodProxy CGLIB$toString$3$Proxy;
private static final Method CGLIB$hashCode$4$Method;
private static final MethodProxy CGLIB$hashCode$4$Proxy;
private static final Method CGLIB$clone$5$Method;
private static final MethodProxy CGLIB$clone$5$Proxy;
public Printer$$EnhancerByCGLIB$$9402db17() {
CGLIB$BIND_CALLBACKS(this);
}
static {
CGLIB$STATICHOOK1();
}
......(略)
public final String print(String var1) {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (this.CGLIB$CALLBACK_0 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
return var10000 != null ? (String)var10000.intercept(this, CGLIB$print$0$Method, new Object[]{var1}, CGLIB$print$0$Proxy) : super.print(var1);
}
protected final String print22(String var1) {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (this.CGLIB$CALLBACK_0 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
return var10000 != null ? (String)var10000.intercept(this, CGLIB$print22$1$Method, new Object[]{var1}, CGLIB$print22$1$Proxy) : super.print22(var1);
}
......（略）
static void CGLIB$STATICHOOK1() {
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$emptyArgs = new Object[0];
Class var0 = Class.forName("com.focuse.dynamicdemo.cglibproxy.Printer$$EnhancerByCGLIB$$9402db17");
Class var1;
Method[] var10000 = ReflectUtils.findMethods(new String[]{"print", "(Ljava/lang/String;)Ljava/lang/String;", "print22", "(Ljava/lang/String;)Ljava/lang/String;"}, (var1 = Class.forName("com.focuse.dynamicdemo.cglibproxy.Printer")).getDeclaredMethods());
CGLIB$print$0$Method = var10000[0];
CGLIB$print$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "print", "CGLIB$print$0");
CGLIB$print22$1$Method = var10000[1];
CGLIB$print22$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "print22", "CGLIB$print22$1");
var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
CGLIB$equals$2$Method = var10000[0];
CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
CGLIB$toString$3$Method = var10000[1];
CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
CGLIB$hashCode$4$Method = var10000[2];
CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
CGLIB$clone$5$Method = var10000[3];
CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
}
final String CGLIB$print$0(String var1) {
return super.print(var1);
}
private static final void CGLIB$BIND_CALLBACKS(Object var0) {
Printer$$EnhancerByCGLIB$$9402db17 var1 = (Printer$$EnhancerByCGLIB$$9402db17)var0;
if (!var1.CGLIB$BOUND) {
var1.CGLIB$BOUND = true;
Object var10000 = CGLIB$THREAD_CALLBACKS.get();
if (var10000 == null) {
var10000 = CGLIB$STATIC_CALLBACKS;
if (CGLIB$STATIC_CALLBACKS == null) {
return;
}
}
var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
}
}
final String CGLIB$print22$1(String var1) {
return super.print22(var1);
}
}总结
这里介绍代理模式、动态代理以及动态代理的两种方式：JDK自带方式动态代理、CGLIB创建动态代理，总结一下
- 代理模式三要素：代理类(代理对象)、目标类(目标对象)、二者共同的接口
- JDK动态代理引入了InvocationHandler接管并分发所有的请求
- JDK动态代理只能对Interface做动态代理，不能对Class做代理
- CGLIB对Class做代理，其实现方式是生成目标类的子类
- CGLIB实现请求转发到目标对象是通过Callback接口，CGLIB提供了6中Callback子类型，常用做动态代理的是net.sf.cglib.proxy.MethodInterceptor