1 从动态代理到动静代理
举个例子，有些人到了适婚年龄，会被父母催婚。而当初在各种压力之下，很多人都抉择晚婚晚育。于是焦急的父母就开始到处为子女相亲，比子女本人还焦急。上面来看代码实现。创立顶层接口 IPerson 的代码如下。
public interface IPerson {void findLove();
}
儿子张三要找对象，实现 ZhangSan 类。
public class ZhangSan implements IPerson {public void findLove() {System.out.println("儿子张三提出要求");
}
}
父亲张老三要帮儿子张三相亲，实现 ZhangLaosan 类。
public class ZhangLaosan implements IPerson {
private ZhangSan zhangsan;
public ZhangLaosan(ZhangSan zhangsan) {this.zhangsan = zhangsan;}
public void findLove() {System.out.println("张老三开始物色");
zhangsan.findLove();
System.out.println("开始来往");
}
}
来看客户端测试代码。
public class Test {public static void main(String[] args) {ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
zhangLaosan.findLove();}
}
运行后果如下图所示。
然而，下面的场景有个弊病，就是本人的父亲只会帮本人的子女去物色对象，他人家的孩子是不会管的。但社会上这项业务倒退成了一个产业，呈现了媒婆、婚介所等，还有各种各样的定制套餐。如果还应用动态代理老本就太高了，须要一个更加通用的解决方案，满足任何独身人士找对象的需要。这就由动态代理降级到了动静代理。采纳动静代理基本上只有是人（IPerson）就能够提供相亲服务。动静代理的底层实现个别不必咱们亲自去实现，曾经有很多现成的 API。在 Java 生态中，目前广泛应用的是 JDK 自带的代理和 CGLib 提供的类库。首先基于 JDK 的动静代理反对来降级一下代码。
首先创立媒婆（婚介所）类 JdkMeipo。
public class JdkMeipo implements InvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target;
Class<?> clazz = target.getClass();
return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {System.out.println("双方同意，开始来往");
}
private void before() {System.out.println("我是媒婆，曾经收集到你的需要，开始物色");
}
}
而后创立一个类 ZhaoLiu。
public class ZhaoLiu implements IPerson {public void findLove() {System.out.println("合乎赵六的要求");
}
public void buyInsure() {}
}
最初客户端测试代码如下。
public static void main(String[] args) {JdkMeipo jdkMeipo = new JdkMeipo();
IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
zhaoliu.findLove();}
运行后果如下图所示。
2 三层架构中的动态代理
小伙伴们可能会感觉还是不晓得如何将代理模式利用到业务场景中，咱们来看一个理论的业务场景。在分布式业务场景中，通常会对数据库进行分库分表，分库分表之后应用 Java 操作时就可能须要配置多个数据源，咱们通过设置数据源路由来动静切换数据源。首先创立 Order 订单类。
public class Order {
private Object orderInfo;
private Long createTime;
private String id;
public Object getOrderInfo() {return orderInfo;}
public void setOrderInfo(Object orderInfo) {this.orderInfo = orderInfo;}
public Long getCreateTime() {return createTime;}
public void setCreateTime(Long createTime) {this.createTime = createTime;}
public String getId() {return id;}
public void setId(String id) {this.id = id;}
}
创立 OrderDao 长久层操作类。
public class OrderDao {public int insert(Order order){System.out.println("OrderDao 创立 Order 胜利!");
return 1;
}
}
创立 IOrderService 接口。
public interface IOrderService {int createOrder(Order order);
}
创立 OrderService 实现类。
public class OrderService implements IOrderService {
private OrderDao orderDao;
public OrderService(){
// 如果应用 Spring，则应该是主动注入的
// 为了使用方便，咱们在构造方法中间接将 orderDao 初始化
orderDao = new OrderDao();}
@Override
public int createOrder(Order order) {System.out.println("OrderService 调用 orderDao 创立订单");
return orderDao.insert(order);
}
}
而后应用动态代理，次要实现的性能是：依据订单创立工夫主动按年进行分库。依据开闭准则，咱们批改原来写好的代码逻辑，通过代理对象来实现。创立数据源路由对象，应用 ThreadLocal 的单例实现 DynamicDataSourceEntry 类。
// 动静切换数据源
public class DynamicDataSourceEntry {
// 默认数据源
public final static String DEFAULT_SOURCE = null;
private final static ThreadLocal<String> local = new ThreadLocal<String>();
private DynamicDataSourceEntry(){}
// 清空数据源
public static void clear() {local.remove();
}
// 获取以后正在应用的数据源名字
public static String get() {return local.get();
}
// 还原以后切换的数据源
public static void restore() {local.set(DEFAULT_SOURCE);
}
// 设置已知名字的数据源
public static void set(String source) {local.set(source);
}
// 依据年份动静设置数据源
public static void set(int year) {local.set("DB_" + year);
}
}
创立切换数据源的代理类 OrderServiceSaticProxy。
public class OrderServiceStaticProxy implements IOrderService {private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
private IOrderService orderService;
public OrderServiceStaticProxy(IOrderService orderService){this.orderService = orderService;}
public int createOrder(Order order) {before();
Long time = order.getCreateTime();
Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("动态代理类主动调配到【DB_" + dbRouter + "】数据源解决数据");
DynamicDataSourceEntry.set(dbRouter);
orderService.createOrder(order);
after();
return 0;
}
private void before(){System.out.println("Proxy before method.");
}
private void after(){System.out.println("Proxy after method.");
}
}
来看客户端测试代码。
public static void main(String[] args) {
try {Order order = new Order();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
Date date = sdf.parse("2017/02/01");
order.setCreateTime(date.getTime());
IOrderService orderService = new OrderServiceStaticProxy(new OrderService());
orderService.createOrder(order);
}catch (Exception e){e.printStackTrace();;
}
}
运行后果如下图所示。
由上图可知，后果合乎预期。再来回顾一下类图，看是否与咱们最先画的统一，如下图所示。
动静代理和动态代理的基本思路是统一的，只不过动静代理的性能更弱小，随着业务的扩大，适应性更强。
3 应用动静代理实现无感知切换数据源
在了解了下面的案例后，再来看数据源动静路由业务，帮忙小伙伴们加深对动静代理的印象。创立动静代理的类 OrderServiceDynamicProxy，代码如下。
public class OrderServiceDynamicProxy implements InvocationHandler {private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
private Object target;
public Object getInstance(Object target){
this.target = target;
Class<?> clazz = target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {before(args[0]);
Object object = method.invoke(target,args);
after();
return object;
}
private void before(Object target){
try {System.out.println("Proxy before method.");
Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("动态代理类主动调配到【DB_" + dbRouter + "】数据源解决数据");
DynamicDataSourceEntry.set(dbRouter);
}catch (Exception e){e.printStackTrace();
}
}
private void after(){System.out.println("Proxy after method.");
}
}
编写客户端测试代码如下。
public static void main(String[] args) {
try {Order order = new Order();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
Date date = sdf.parse("2018/02/01");
order.setCreateTime(date.getTime());
IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().
getInstance(new OrderService());
orderService.createOrder(order);
}catch (Exception e){e.printStackTrace();
}
}
由下面代码能够看出，仍然可能达到雷同的运行成果。然而，应用动静代理实现之后，不仅能实现 Order 的数据源动静路由，还能够实现其余任何类的数据源路由。当然，有一个比拟重要的约定，必须实现 getCreateTime() 办法，因为路由规定是依据工夫来运算的。能够通过接口标准达到束缚的目标，在此不再举例。
4 手写 JDK 动静代理外围原理
不仅知其然，还得知其所以然。既然 JDK 动静代理的性能如此弱小，那么它是如何实现的呢？当初来探索一下原理，并模拟 JDK 动静代理手写一个属于本人的动静代理。
咱们都晓得 JDK 动静代理采纳字节重组，从新生成对象来代替原始对象，以达到动静代理的目标。JDK 动静代理生成对象的步骤如下。
（1）获取被代理对象的援用，并且获取它的所有接口，反射获取。
（2）JDK 动静代理类从新生成一个新的类，同时新的类要实现被代理类实现的所有接口。
（3）动静生成 Java 代码，新加的业务逻辑办法由肯定的逻辑代码调用（在代码中体现）。
（4）编译新生成的 Java 代码.class 文件。
（5）从新加载到 JVM 中运行。
以上过程就叫作字节码重组。JDK 中有一个标准，在 ClassPath 下只有是 $ 结尾的.class 文件，个别都是主动生成的。那么有没有方法看到代替后的对象的“真容”呢？做一个这样的测试，将内存中的对象字节码通过文件流输入到一个新的.class 文件，而后应用反编译工具查看源码。
public static void main(String[] args) {
try {IPerson obj = (IPerson)new JdkMeipo().getInstance(new Zhangsan());
obj.findLove();
// 通过反编译工具查看源代码
byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{IPerson.class});
FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
os.write(bytes);
os.close();} catch (Exception e) {e.printStackTrace();
}
}
运行以上代码，能够在 E 盘找到一个 $Proxy0.class 文件。应用 Jad 反编译，失去 $Proxy0.jad 文件，关上文件看到如下内容。
import com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson;
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 IPerson {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m4;
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})).booleanValue();} catch (RuntimeException | Error var3) {throw var3;} catch (Throwable var4) {throw new UndeclaredThrowableException(var4);
}
}
public final void findLove() throws {
try {super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException(var3);
}
}
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 void buyInsure() throws {
try {super.h.invoke(this, m4, (Object[])null);
} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException(var3);
}
}
static {
try {m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[]{Class.forName("java.lang.Object")});
m3 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
.getMethod("findLove", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m4 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
.getMethod("buyInsure", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {throw new NoClassDefFoundError(var3.getMessage());
}
}
}
咱们发现，$Proxy0 继承了 Proxy 类，同时实现了 Person 接口，而且重写了 findLove() 等办法。在动态代码块中用反射查找到了指标对象的所有办法，而且保留了所有办法的援用，重写的办法用反射调用指标对象的办法。小伙伴们此时肯定会好奇：这些代码是从哪里来的？其实是 JDK 主动生成的。当初咱们不依赖 JDK，本人来动静生成源码、动静实现编译，而后代替指标对象并执行。
创立 GPInvocationHandler 接口。
public interface GPInvocationHandler {public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
创立 GPProxy 类。
/**
* 用来生成源码的工具类
* Created by Tom.
*/
public class GPProxy {
public static final String ln = "\r\n";
public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces,
GPInvocationHandler h){
try {
//1. 动静生成源码.java 文件
String src = generateSrc(interfaces);
//2.Java 文件输入磁盘
String filePath = GPProxy.class.getResource("").getPath();
File f = new File(filePath + "$Proxy0.java");
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//3. 把生成的.java 文件编译成.class 文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
Iterable iterable = manage.getJavaFileObjects(f);
JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
task.call();
manage.close();
//4. 编译生成的.class 文件加载到 JVM 中
Class proxyClass = classLoader.findClass("$Proxy0");
Constructor c = proxyClass.getConstructor(GPInvocationHandler.class);
f.delete();
//5. 返回字节码重组当前的新的代理对象
return c.newInstance(h);
}catch (Exception e){e.printStackTrace();
}
return null;
}
private static String generateSrc(Class<?>[] interfaces){StringBuffer sb = new StringBuffer();
sb.append(GPProxy.class.getPackage() + ";" + ln);
sb.append("import" + interfaces[0].getName() + ";" + ln);
sb.append("import java.lang.reflect.*;" + ln);
sb.append("public class $Proxy0 implements" + interfaces[0].getName() + "{" + ln);
sb.append("GPInvocationHandler h;" + ln);
sb.append("public $Proxy0(GPInvocationHandler h) {" + ln);
sb.append("this.h = h;");
sb.append("}" + ln);
for (Method m : interfaces[0].getMethods()){Class<?>[] params = m.getParameterTypes();
StringBuffer paramNames = new StringBuffer();
StringBuffer paramValues = new StringBuffer();
StringBuffer paramClasses = new StringBuffer();
for (int i = 0; i < params.length; i++) {Class clazz = params[i];
String type = clazz.getName();
String paramName = toLowerFirstCase(clazz.getSimpleName());
paramNames.append(type + " " + paramName);
paramValues.append(paramName);
paramClasses.append(clazz.getName() + ".class");
if(i > 0 && i < params.length-1){paramNames.append(",");
paramClasses.append(",");
paramValues.append(",");
}
}
sb.append("public" + m.getReturnType().getName() + "" + m.getName() +"("+ paramNames.toString() +") {" + ln);
sb.append("try{" + ln);
sb.append("Method m =" + interfaces[0].getName() + ".class. getMethod(\"" + m.getName() + "\",new Class[]{"+ paramClasses.toString() +"});" + ln);
sb.append((hasReturnValue(m.getReturnType()) ? "return" : "") + getCaseCode("this.h.invoke(this,m,new Object[]{"+ paramValues +"})",m.getReturnType()) +";" + ln);
sb.append("}catch(Error _ex) {}");
sb.append("catch(Throwable e){" + ln);
sb.append("throw new UndeclaredThrowableException(e);" + ln);
sb.append("}");
sb.append(getReturnEmptyCode(m.getReturnType()));
sb.append("}");
}
sb.append("}" + ln);
return sb.toString();}
private static Map<Class,Class> mappings = new HashMap<Class, Class>();
static {mappings.put(int.class,Integer.class);
}
private static String getReturnEmptyCode(Class<?> returnClass){if(mappings.containsKey(returnClass)){return "return 0;";}else if(returnClass == void.class){return "";}else {return "return null;";}
}
private static String getCaseCode(String code,Class<?> returnClass){if(mappings.containsKey(returnClass)){return "((" + mappings.get(returnClass).getName() + ")" + code + ")." + returnClass.getSimpleName() + "Value()";
}
return code;
}
private static boolean hasReturnValue(Class<?> clazz){return clazz != void.class;}
private static String toLowerFirstCase(String src){char [] chars = src.toCharArray();
chars[0] += 32;
return String.valueOf(chars);
}
}
创立 GPClassLoader 类。
public class GPClassLoader extends ClassLoader {
private File classPathFile;
public GPClassLoader(){String classPath = GPClassLoader.class.getResource("").getPath();
this.classPathFile = new File(classPath);
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {String className = GPClassLoader.class.getPackage().getName() + "." + name;
if(classPathFile != null){File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
if(classFile.exists()){
FileInputStream in = null;
ByteArrayOutputStream out = null;
try{in = new FileInputStream(classFile);
out = new ByteArrayOutputStream();
byte [] buff = new byte[1024];
int len;
while ((len = in.read(buff)) != -1){out.write(buff,0,len);
}
return defineClass(className,out.toByteArray(),0,out.size());
}catch (Exception e){e.printStackTrace();
}
}
}
return null;
}
}
创立 GPMeipo 类。
public class GpMeipo implements GPInvocationHandler {
private IPerson target;
public IPerson getInstance(IPerson target){
this.target = target;
Class<?> clazz = target.getClass();
return (IPerson) GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {before();
Object result = method.invoke(this.target,args);
after();
return result;
}
private void after() {System.out.println("双方同意，开始来往");
}
private void before() {System.out.println("我是媒婆，曾经收集到你的需要，开始物色");
}
}
客户端测试代码如下。
public static void main(String[] args) {GpMeipo gpMeipo = new GpMeipo();
IPerson zhangsan = gpMeipo.getInstance(new Zhangsan());
zhangsan.findLove();}
至此，手写 JDK 动静代理就实现了。小伙伴们是不是又多了一个面试用的“撒手锏”呢？
5 CGLib 动静代理 API 原理剖析
简略看一下 CGLib 动静代理的应用，还是以媒婆为例，创立 CglibMeipo 类。
public class CGlibMeipo implements MethodInterceptor {public Object getInstance(Class<?> clazz) throws Exception{
// 相当于 JDK 中的 Proxy 类，是实现代理的工具类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {before();
Object obj = methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void before(){System.out.println("我是媒婆，我要给你找对象，当初曾经确认你的需要");
System.out.println("开始物色");
}
private void after(){System.out.println("双方同意，筹备办婚事");
}
}
创立独身客户类 Customer。
public class Customer {public void findLove(){System.out.println("符合要求");
}
}
这里有一个小细节，CGLib 动静代理的指标对象不须要实现任何接口，它是通过动静继承指标对象实现动静代理的，客户端测试代码如下。
public static void main(String[] args) {
try {
//JDK 采纳读取接口的信息
//CGLib 笼罩父类办法
// 目标都是生成一个新的类，去实现加强代码逻辑的性能
//JDK Proxy 对于用户而言，必须要有一个接口实现，指标类相对来说简单
//CGLib 能够代理任意一个一般的类，没有任何要求
//CGLib 生成代理的逻辑更简单，调用效率更高，生成一个蕴含了所有逻辑的 FastClass，不再需 要反射调用
//JDK Proxy 生成代理的逻辑简略，执行效率绝对要低，每次都要反射动静调用
//CGLib 有一个毛病，CGLib 不能代理 final 的办法
Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
System.out.println(obj);
obj.findLove();} catch (Exception e) {e.printStackTrace();
}
}
CGLib 动静代理的实现原理又是怎么的呢？咱们能够在客户端测试代码中加上一句代码，将 CGLib 动静代理后的.class 文件写入磁盘，而后反编译来一探到底，代码如下。
public static void main(String[] args) {
try {
// 应用 CGLib 的代理类能够将内存中的.class 文件写入本地磁盘
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E://cglib_proxy_class/");
Customer obj = (Customer)new CglibMeipo().getInstance(Customer.class);
obj.findLove();} catch (Exception e) {e.printStackTrace();
}
}
从新执行代码，咱们会发现在 E://cglib_proxy_class 目录下多了三个.class 文件，如下图所示。
通过调试跟踪发现，Customer$$EnhancerByCGLIB$$3feeb52a.class 就是 CGLib 动静代理生成的代理类，继承了 Customer 类。
package com.tom.pattern.proxy.dynamicproxy.cglibproxy;
import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.*;
public class Customer$$EnhancerByCGLIB$$3feeb52a extends Customer
implements Factory
{
...
final void CGLIB$findLove$0()
{super.findLove();
}
public final void findLove()
{
CGLIB$CALLBACK_0;
if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
JVM INSTR pop ;
CGLIB$BIND_CALLBACKS(this);
CGLIB$CALLBACK_0;
_L2:
JVM INSTR dup ;
JVM INSTR ifnull 37;
goto _L3 _L4
_L3:
break MISSING_BLOCK_LABEL_21;
_L4:
break MISSING_BLOCK_LABEL_37;
this;
CGLIB$findLove$0$Method;
CGLIB$emptyArgs;
CGLIB$findLove$0$Proxy;
intercept();
return;
super.findLove();
return;
}
...
}
咱们重写了 Customer 类的所有办法，通过代理类的源码能够看到，代理类会取得所有从父类继承来的办法，并且会有 MethodProxy 与之对应，比方 Method CGLIB$findLove$0$Method、MethodProxy CGLIB$findLove$0$Proxy 等办法在代理类的 findLove() 办法中都有调用。
// 代理办法（methodProxy.invokeSuper() 办法会调用）final void CGLIB$findLove$0()
{super.findLove();
}
// 被代理办法（methodProxy.invoke() 办法会调用
// 这就是为什么在拦截器中调用 methodProxy.invoke 会产生死循环，始终在调用拦截器）public final void findLove()
{
...
// 调用拦截器
intercept();
return;
super.findLove();
return;
}
调用过程为：代理对象调用 this.findLove() 办法→调用拦截器→methodProxy.invokeSuper()→ CGLIB$findLove$0→被代理对象 findLove() 办法。
此时，咱们发现 MethodInterceptor 拦截器就是由 MethodProxy 的 invokeSuper() 办法调用代理办法的，因而，MethodProxy 类中的代码十分要害，咱们剖析它具体做了什么。
package net.sf.cglib.proxy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import net.sf.cglib.core.AbstractClassGenerator;
import net.sf.cglib.core.CodeGenerationException;
import net.sf.cglib.core.GeneratorStrategy;
import net.sf.cglib.core.NamingPolicy;
import net.sf.cglib.core.Signature;
import net.sf.cglib.reflect.FastClass;
import net.sf.cglib.reflect.FastClass.Generator;
public class MethodProxy {
private Signature sig1;
private Signature sig2;
private MethodProxy.CreateInfo createInfo;
private final Object initLock = new Object();
private volatile MethodProxy.FastClassInfo fastClassInfo;
public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {MethodProxy proxy = new MethodProxy();
proxy.sig1 = new Signature(name1, desc);
proxy.sig2 = new Signature(name2, desc);
proxy.createInfo = new MethodProxy.CreateInfo(c1, c2);
return proxy;
}
...
private static class CreateInfo {
Class c1;
Class c2;
NamingPolicy namingPolicy;
GeneratorStrategy strategy;
boolean attemptLoad;
public CreateInfo(Class c1, Class c2) {
this.c1 = c1;
this.c2 = c2;
AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent();
if(fromEnhancer != null) {this.namingPolicy = fromEnhancer.getNamingPolicy();
this.strategy = fromEnhancer.getStrategy();
this.attemptLoad = fromEnhancer.getAttemptLoad();}
}
}
...
}
持续看 invokeSuper() 办法。
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {this.init();
MethodProxy.FastClassInfo fci = this.fastClassInfo;
return fci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetException var4) {throw var4.getTargetException();
}
}
...
private static class FastClassInfo {
FastClass f1;
FastClass f2;
int i1;
int i2;
private FastClassInfo() {}
}
下面代码调用获取代理类对应的 FastClass，并执行代理办法。还记得之前生成的三个.class 文件吗？Customer$$EnhancerByCGLIB$$3feeb52a$$FastClassByCGLIB$$6aad62f1.class 就是代理类的 FastClass，Customer$$FastClassByCGLIB$$2669574a.class 就是被代理类的 FastClass。
CGLib 动静代理执行代理办法的效率之所以比 JDK 高，是因为 CGlib 采纳了 FastClass 机制，它的原理简略来说就是：为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的办法调配一个 index（int 类型）；这个 index 被当作一个入参，FastClass 能够间接定位要调用的办法并间接进行调用，省去了反射调用，因而调用效率比 JDK 代理通过反射调用高。上面咱们来反编译一个 FastClass。
public int getIndex(Signature signature)
{String s = signature.toString();
s;
s.hashCode();
JVM INSTR lookupswitch 11: default 223
…
JVM INSTR pop ;
return -1;
}
// 局部代码省略
// 依据 index 间接定位执行办法
public Object invoke(int i, Object obj, Object aobj[])
throws InvocationTargetException
{(Customer)obj;
i;
JVM INSTR tableswitch 0 10: default 161
goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12
_L2:
eat();
return null;
_L3:
findLove();
return null;
…
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
FastClass 并不是跟代理类一起生成的，而是在第一次执行 MethodProxy 的 invoke() 或 invokeSuper() 办法时生成的，并被放在了缓存中。
//MethodProxy 的 invoke() 或 invokeSuper() 办法都调用了 init() 办法
private void init() {if(this.fastClassInfo == null) {
Object var1 = this.initLock;
synchronized(this.initLock) {if(this.fastClassInfo == null) {
MethodProxy.CreateInfo ci = this.createInfo;
MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
// 如果在缓存中，则取出；如果没在缓存中，则生成新的 FastClass
fci.f1 = helper(ci, ci.c1);
fci.f2 = helper(ci, ci.c2);
fci.i1 = fci.f1.getIndex(this.sig1);// 获取办法的 index
fci.i2 = fci.f2.getIndex(this.sig2);
this.fastClassInfo = fci;
}
}
}
}
至此，咱们根本分明了 CGLib 动静代理的原理，对代码细节感兴趣的小伙伴们能够自行深入研究。
6 CGLib 和 JDK Proxy 比照剖析
（1）JDK 动静代理实现了被代理对象的接口，CGLib 动静代理继承了被代理对象。
（2）JDK 动静代理和 CGLib 动静代理都在运行期生成字节码，JDK 动静代理间接写 Class 字节码，CGLib 动静代理应用 ASM 框架写 Class 字节码。CGLib 动静代理实现更简单，生成代理类比 JDK 动静代理效率低。
（3）JDK 动静代理调用代理办法是通过反射机制调用的，CGLib 动静代理是通过 FastClass 机制间接调用办法的，CGLib 动静代理的执行效率更高。
本文为“Tom 弹架构”原创，转载请注明出处。技术在于分享，我分享我高兴！
如果本文对您有帮忙，欢送关注和点赞；如果您有任何倡议也可留言评论或私信，您的反对是我保持创作的能源。关注微信公众号『Tom 弹架构』可获取更多技术干货！