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弹架构 』可获取更多技术干货！