引子

举个栗子，众所周知，我们是可以在京东上购买机票的。 但机票是航司提供的，我们本质上是代理销售而已。

那为什么航司要让我们代理销售呢？

我们又是如帮他做代理的呢？

别急，本文将展开说说他们之间的关系。。。

一个有梦想的航司

从前有个航司打算开展线上销售机票业务，于是设计了如下系统。系统完成后，业务正常开展了。。。

航司销售机票的接口：

public interface SellAirTicket {/** * 销售机票 * @param price */void sellAirTicket(int price);}

航司销售机票的接口实现类：

public class SellAirTicketImpl implements SellAirTicket {@Overridepublic void sellAirTicket(int price) {System.out.println("航司销售机票，价格：" + price);}}

测试：

public class MainClass {public static void main(String[] args) {SellAirTicket sellAirTicket = new SellAirTicketImpl();sellAirTicket.sellAirTicket(666);}}

测试结果：

航司销售机票，价格：666

业务蒸蒸日上，问题接踵而至

随着业务发展的越来越好，新的问题出现了。

黄牛天天爬接口，系统风险出现了；卖完票没有统计结果，卖成啥样也不知道。

于是航司想增加售前风控、售后统计。加上这些功能后，业务又继续稳步发展了。。。

航司销售机票的接口：

public interface SellAirTicket {/** * 销售机票 * @param price */void sellAirTicket(int price);}

航司销售机票的接口实现类：

public class SellAirTicketImpl implements SellAirTicket {@Overridepublic void sellAirTicket(int price) {System.out.println("航司售前风控。。。");System.out.println("航司销售机票，价格：" + price);System.out.println("航司售后统计。。。");}}

测试：

public class MainClass {public static void main(String[] args) {SellAirTicket sellAirTicket = new SellAirTicketImpl();sellAirTicket.sellAirTicket(666);}}

测试结果：

航司售前风控。。。航司销售机票，价格：666航司售后统计。。。

人员捉襟见肘，业务被迫拆分

后来航司发现，就这么点人，又想做风控，又想卖机票，又想做统计，根本忙不过来。

那怎么解决呢？ 航司只想专心卖票，不想做这些跟卖票无关的工作，那只能找个代理公司了。

于是，航司找到了JD代替自己做这些工作，自己就负责专心卖票。。。

航司销售机票的接口：

public interface SellAirTicket {/** * 销售机票 * @param price */void sellAirTicket(int price);}

航司销售机票的接口实现类：

public class SellAirTicketImpl implements SellAirTicket {@Overridepublic void sellAirTicket(int price) {System.out.println("航司销售机票，价格：" + price);}}

JD平台代理航司销售机票实现类：

public class SellAirTicketProxy implements SellAirTicket {/** * 航司售票接口 */private SellAirTicket sellAirTicket;@Overridepublic void sellAirTicket(int price) {System.out.println("JD售前风控。。。");sellAirTicket.sellAirTicket(price);System.out.println("JD售后统计。。。");}public SellAirTicketProxy(SellAirTicket sellAirTicket) {this.sellAirTicket = sellAirTicket;}}

测试：

public class MainClass {public static void main(String[] args) {SellAirTicket sellAirTicket = new SellAirTicketImpl();SellAirTicket sellAirTicketProxy = new SellAirTicketProxy(sellAirTicket);sellAirTicketProxy.sellAirTicket(666);}}

测试结果：

JD售前风控。。。航司销售机票，价格：666JD售后统计。。。

朴素的一对一合作方式，静态代理

以上流程对与航司而言，由JD帮助自己关注风控、统计，自已可以专心的卖票，看着很好的样子。

但是JD平台只能给航司卖票，其余的也干不了，航司与JD的关系属于静态绑定的关系，即：被代理类与代理类属于静态绑定的关系，称之为“静态代理”。

据此，我们可以给代理模式下个定义：

【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式 代理模式的优点：1. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；2. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；3. 对于用户（调用者）而言，使用的方式没有区别，有和可以做到低成本替换；代理模式的缺点：1. 每个被代理类都要有一个代理类，大大增加了代码量；

保险出现，代理公司高瞻远瞩

某天，保险公司也被风控、统计逻辑搞的焦头烂额，听说航司找了个代理，于是也找到了JD，让JD给他们做代理。

JD想：总不能谁来找我，我就给谁做一套代理系统吧，那我得做多少套，反正他们都是找我做风控、统计的，那我能不能做一套系统，给他们所有的人用呢，说干就干。。。

保险公司销售保险的接口：

public interface SellInsurance {/** * 销售保险 * @param price */void sellInsurance(int price);}

保险公司销售保险的接口实现类：

public class SellInsuranceImpl implements SellInsurance {@Overridepublic void sellInsurance(int price) {System.out.println("保险公司销售保险，价格：" + price);}}

JD平台代理的风控、统计实现类：

public class SellDynamicProxy {/** * 获取传入目标对象的代理对象 * @param target * @return */public Object createProxy(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(), //目标对象使用类加载器target.getClass().getInterfaces(),//目标对象实现的接口的类型new DynamicProxyHandler(target));//目标对象事件处理器}/** * 目标对象的事件处理器 */private class DynamicProxyHandler implements InvocationHandler {//被代理对象private Object target;@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("JD售前风控。。。");method.invoke(target, args);System.out.println("JD售后统计。。。");return null;}public DynamicProxyHandler(Object object) {this.target = object;}}}

测试：

public class MainClass {public static void main(String[] args) {//创建动态代理平台SellDynamicProxy dynamicProxy = new SellDynamicProxy();//代理销售机票SellAirTicket airTicketProxy = (SellAirTicket) dynamicProxy.createProxy(new SellAirTicketImpl());airTicketProxy.sellAirTicket(600);//代理销售保险SellInsurance insuranceProxy = (SellInsurance) dynamicProxy.createProxy(new SellInsuranceImpl());insuranceProxy.sellInsurance(30);}}

测试结果：

JD售前风控。。。航司销售机票，价格：600JD售后统计。。。JD售前风控。。。保险公司销售保险，价格：30JD售后统计。。。

进阶的一对多合作方式，动态代理

到这里航司、保险公司都找到了自己的代理，JD平台也完成了风控、统计代理平台的搭建。再有人来找自己，JD平台都可以满足代理需求，现在看来，已经很完美了。

被代理的商家与JD属于动态绑定的关系，即：被代理类与代理类属于动态绑定的关系，称之为“动态代理”，由于此代理功能依赖JDK提供的Proxy、InvocationHandler类，也成为“JDK动态代理”。

据此，我们可以补充代理模式的定义：

【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式 代理模式的优点：1. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；2. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；3. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；4. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；代理模式的缺点：1. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；2. JDK动态代理基于JDK的反射原理实现，降低了执行效率；

酒店出现，代理公司意外降临

平静的日子没过多久，一天某酒店找来了，要求给他们做代理，做就做呗。轻车又熟路。。。

酒店销售房间：

public class SellHotel {/** * 销售酒店 * @param price */public void sellHotel(int price) {System.out.println("酒店销售房间，价格：" + price);}}

测试：

public class MainClass {public static void main(String[] args) {//创建动态代理平台SellDynamicProxy dynamicProxy = new SellDynamicProxy();//代理销售酒店SellHotel sellHotel = (SellHotel) dynamicProxy.createProxy(new SellHotel());sellHotel.sellHotel(300);}}

测试结果：

Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to demo.pattern.proxy.SellHotel at demo.pattern.proxy.MainClass.main(MainClass.java:14)

怎么回事，平台不好用了！代理公司闭关修炼，查一下问题。。。

优秀代理公司的自我修养

以前给别人代理都好使，这次给酒店代理为何就不行了呢？ 一个优秀的代理，有问题就要解决问题。。。

先看异常，代理类不能被强转为目标类型，但是为何之前的都好使？

思考：只有生成的代理类属于目标类型，才能强转，那就需要代理类实现目标类的接口，那问题就可能是这样了，验证一下。

原理分析：JDK代理对象是如何实现的？

让我们先看下源码：

/** * 获取传入目标对象的代理对象 * @param target * @return */public Object createProxy(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(), //目标对象使用类加载器target.getClass().getInterfaces(),//目标对象实现的接口的类型new DynamicProxyHandler(target));//目标对象事件处理器}/** * 创建代理类源码 */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);}/* * Look up or generate the designated proxy class. */Class cl = getProxyClass0(loader, intfs);//生成代理类的字节码对象/* * Invoke its constructor with the designated invocation handler. */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() {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);}}/** * Generate a proxy class.Must call the checkProxyAccess method * to perform permission checks before calling this. * 生成代理类的字节码对象 */private static Class getProxyClass0(ClassLoader loader,Class... interfaces) {if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}// If the proxy class defined by the given loader implementing// the given interfaces exists, this will simply return the cached copy;// otherwise, it will create the proxy class via the ProxyClassFactoryreturn proxyClassCache.get(loader, interfaces); //这里获取字节码对象}/** * 这里获取字节码对象 */public V get(K key, P parameter) {Objects.requireNonNull(parameter);expungeStaleEntries();Object cacheKey = CacheKey.valueOf(key, refQueue);// lazily install the 2nd level valuesMap for the particular cacheKeyConcurrentMap> valuesMap = map.get(cacheKey);if (valuesMap == null) {ConcurrentMap> oldValuesMap= map.putIfAbsent(cacheKey,valuesMap = new ConcurrentHashMap<>());if (oldValuesMap != null) {valuesMap = oldValuesMap;}}// create subKey and retrieve the possible Supplier stored by that// subKey from valuesMapObject subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));//这里创建字解码对象Supplier supplier = valuesMap.get(subKey);Factory factory = null;while (true) {if (supplier != null) {// supplier might be a Factory or a CacheValue instanceV value = supplier.get();if (value != null) {return value;}}// else no supplier in cache// or a supplier that returned null (could be a cleared CacheValue// or a Factory that wasn't successful in installing the CacheValue)// lazily construct a Factoryif (factory == null) {factory = new Factory(key, parameter, subKey, valuesMap);}if (supplier == null) {supplier = valuesMap.putIfAbsent(subKey, factory);if (supplier == null) {// successfully installed Factorysupplier = factory;}// else retry with winning supplier} else {if (valuesMap.ｒｅｐｌａｃｅ(subKey, supplier, factory)) {// successfully replaced// cleared CacheEntry / unsuccessful Factory// with our Factorysupplier = factory;} else {// retry with current suppliersupplier = valuesMap.get(subKey);}}}}/** * A factory function that generates, defines and returns the proxy class given * the ClassLoader and array of interfaces. *  * Proxy类的内部类，就是为了创建代理对象的字节码对象 */private static final class ProxyClassFactoryimplements BiFunction[], Class>{// prefix for all proxy class namesprivate static final String proxyClassNamePrefix = "$Proxy";// next number to use for generation of unique proxy class namesprivate static final AtomicLong nextUniqueNumber = new AtomicLong();@Overridepublic Class apply(ClassLoader loader, Class[] interfaces) {Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);for (Class intf : interfaces) {/* * Verify that the class loader resolves the name of this * interface to the same Class object. */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");}/* * Verify that the Class object actually represents an * interface. */if (!interfaceClass.isInterface()) {throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");}/* * Verify that this interface is not a duplicate. */if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());}}String proxyPkg = null; // package to define proxy class inint accessFlags = Modifier.PUBLIC | Modifier.FINAL;/* * Record the package of a non-public proxy interface so that the * proxy class will be defined in the same package.Verify that * all non-public proxy interfaces are in the same package. */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) {// if no non-public proxy interfaces, use com.sun.proxy packageproxyPkg = ReflectUtil.PROXY_PACKAGE + ".";}/* * Choose a name for the proxy class to generate. */long num = nextUniqueNumber.getAndIncrement();String proxyName = proxyPkg + proxyClassNamePrefix + num;/* * Generate the specified proxy class. */byte[] proxyClassFile = ProxyGenerator.generateProxyClass(//这里生成需要的字节码对象proxyName, interfaces, accessFlags);try {return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);} catch (ClassFormatError e) {/* * A ClassFormatError here means that (barring bugs in the * proxy class generation code) there was some other * invalid aspect of the arguments supplied to the proxy * class creation (such as virtual machine limitations * exceeded). */throw new IllegalArgumentException(e.toString());}}}

上面分析一堆，那我们来了看看得到的代理类到底是啥，为啥他就能执行那个我们的目标类的方法。同时，还得目标类实现接口？

/** * 我们自己生成一份目标类字节码文件 * @throws IOException */public static void transClass() throws IOException {SellAirTicketImpl sellAirTicket = new SellAirTicketImpl();byte[] bts = ProxyGenerator.generateProxyClass("$Proxy0", sellAirTicket.getClass().getInterfaces());File file = new File("E:\\test","$Proxy0.class");if (!file.exists()){file.createNewFile();}FileOutputStream fos = new FileOutputStream(file);fos.write(bts);fos.flush();fos.close();}

将我们的字节码文件在此反编译：http://javare.cn，得到我们的代理类：

import demo.pattern.proxy.SellAirTicket;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 SellAirTicket {private static Method m1;private static Method m2;private static Method m3;private static Method m0;public $Proxy0(InvocationHandler var1) throws{ //代理类的构造器，将事件处理器传入，交给父类Proxysuper(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 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 sellAirTicket(int var1) throws{try { super.h.invoke(this, m3, new Object[]{Integer.valueOf(var1)}); //执行目标方法时，调用父类的事件处理器} catch (RuntimeException | Error var3) { throw var3;} catch (Throwable var4) { throw new UndeclaredThrowableException(var4);}}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")}); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m3 = Class.forName("demo.pattern.proxy.SellAirTicket").getMethod("sellAirTicket", new Class[]{Integer.TYPE});//获取接口类型的目标方法 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());}}}

到此为止真相大白了，原来代理类继承了Proxy父类，同时实现了目标类的接口，这就将我们的目标方法与定义的事件处理器联系起来了。

同时，由于java的单继承模式，导致了代理类只能继承Proxy类，那这样的话，就只好通过目标类的接口来关联目标类了。

小结：JDK动态代理

据此，我们可以再次补充代理模式的定义：

【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式 代理模式的优点：1. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；2. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；3. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；4. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；代理模式的缺点：1. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；2. JDK动态代理基于JDK的反射原理实现，降低了执行效率；3. JDK动态代理是基于接口的代理，要求目标类必须实现目标接口；

好的合作伙伴就是不抛弃不放弃

到这里，问题是搞明白了，就是酒店的问题，但是好的合作伙伴就是应该不抛弃，不放弃。

酒店跟我们合作，我们就要帮助他们解决困难。那怎么办呢？酒店没接口，JDK代理又非要接口，那我们就不用JDK代理了！

这时，基于类的代理方式就应运而生了—— cglib为我们提供了基于类的动态代理模式。

导Jar包：cglib-3.2.5.jar（cglib核心包）、asm-3.3.1.jar（字节码处理框架）

public class CglibDynamicProxy implements MethodInterceptor {//目标对象private Object target;/** *给目标对象创建一个代理对象 */public Object getProxyInstance(){//工具类Enhancer en = new Enhancer();//设置父类en.setSuperclass(target.getClass());//设置回调函数en.setCallback(this);//创建子类代理对象return en.create();}@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("cglib售前风控。。。");final Object invoke = method.invoke(target, objects);System.out.println("cglib售后统计。。。");return invoke;}public CglibDynamicProxy(Object target) {this.target = target;}}

测试

public static void main(String[] args) {//创建销售酒店代理CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy(new SellHotel());SellHotel sellHotel = (SellHotel) cglibDynamicProxy.getProxyInstance();sellHotel.sellHotel(300);}

测试结果

cglib售前风控。。。酒店销售房间，价格：300cglib售后统计。。。

原理分析：cglib代理对象是如何实现的？

那为啥cglib就不用目标类实现接口了呢？让我们看看代理类。

public static void main(String[] args) {//代理类class文件存入本地磁盘System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E:\\testCglib");//创建销售酒店代理CglibDynamicProxy cglibDynamicProxy = new CglibDynamicProxy(new SellHotel());SellHotel sellHotel = (SellHotel) cglibDynamicProxy.getProxyInstance();sellHotel.sellHotel(300);}

反编译结果

/** * 代理类反编译结果 */public class SellHotel$EnhancerByCGLIB$2624d6e3 extends SellHotel 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 final Method CGLIB$sellHotel$0$Method;//被代理方法private static final MethodProxy CGLIB$sellHotel$0$Proxy;//代理方法private static final Object[] CGLIB$emptyArgs;private static final Method CGLIB$equals$1$Method;private static final MethodProxy CGLIB$equals$1$Proxy;private static final Method CGLIB$toString$2$Method;private static final MethodProxy CGLIB$toString$2$Proxy;private static final Method CGLIB$hashCode$3$Method;private static final MethodProxy CGLIB$hashCode$3$Proxy;private static final Method CGLIB$clone$4$Method;private static final MethodProxy CGLIB$clone$4$Proxy;static void CGLIB$STATICHOOK1() {CGLIB$THREAD_CALLBACKS = new ThreadLocal();CGLIB$emptyArgs = new Object[0];Class var0 = Class.forName("demo.pattern.proxy.SellHotel$EnhancerByCGLIB$2624d6e3");//代理类Class var1;//被代理类CGLIB$sellHotel$0$Method = ReflectUtils.findMethods(new String[]{"sellHotel", "(I)V"}, (var1 = Class.forName("demo.pattern.proxy.SellHotel")).getDeclaredMethods())[0];CGLIB$sellHotel$0$Proxy = MethodProxy.create(var1, var0, "(I)V", "sellHotel", "CGLIB$sellHotel$0");Method[] 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$1$Method = var10000[0];CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");CGLIB$toString$2$Method = var10000[1];CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");CGLIB$hashCode$3$Method = var10000[2];CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");CGLIB$clone$4$Method = var10000[3];CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");}final void CGLIB$sellHotel$0(int var1) {super.sellHotel(var1);}public final void sellHotel(int var1) {//代理类重写的方法MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;//方法拦截器if(this.CGLIB$CALLBACK_0 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0;}if(var10000 != null) {//执行方法拦截器 var10000.intercept(this, CGLIB$sellHotel$0$Method, new Object[]{new Integer(var1)}, CGLIB$sellHotel$0$Proxy);} else { super.sellHotel(var1);}}final boolean CGLIB$equals$1(Object var1) {return super.equals(var1);}public final boolean equals(Object var1) {MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;if(this.CGLIB$CALLBACK_0 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0;}if(var10000 != null) { Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy); return var2 == null?false:((Boolean)var2).booleanValue();} else { return super.equals(var1);}}final String CGLIB$toString$2() {return super.toString();}public final String toString() {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$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy):super.toString();}final int CGLIB$hashCode$3() {return super.hashCode();}public final int hashCode() {MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;if(this.CGLIB$CALLBACK_0 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0;}if(var10000 != null) { Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy); return var1 == null?0:((Number)var1).intValue();} else { return super.hashCode();}}final Object CGLIB$clone$4() throws CloneNotSupportedException {return super.clone();}protected final Object clone() throws CloneNotSupportedException {MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;if(this.CGLIB$CALLBACK_0 == null) { CGLIB$BIND_CALLBACKS(this); var10000 = this.CGLIB$CALLBACK_0;}return var10000 != null?var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy):super.clone();}public static MethodProxy CGLIB$findMethodProxy(Signature var0) {String var10000 = var0.toString();switch(var10000.hashCode()) {case -508378822: if(var10000.equals("clone()Ljava/lang/Object;")) {return CGLIB$clone$4$Proxy; } break;case 1826985398: if(var10000.equals("equals(Ljava/lang/Object;)Z")) {return CGLIB$equals$1$Proxy; } break;case 1913648695: if(var10000.equals("toString()Ljava/lang/String;")) {return CGLIB$toString$2$Proxy; } break;case 1979480752: if(var10000.equals("sellHotel(I)V")) {return CGLIB$sellHotel$0$Proxy; } break;case 1984935277: if(var10000.equals("hashCode()I")) {return CGLIB$hashCode$3$Proxy; }}return null;}public SellHotel$EnhancerByCGLIB$2624d6e3() {CGLIB$BIND_CALLBACKS(this);}public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {CGLIB$THREAD_CALLBACKS.set(var0);}public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {CGLIB$STATIC_CALLBACKS = var0;}private static final void CGLIB$BIND_CALLBACKS(Object var0) {SellHotel$EnhancerByCGLIB$2624d6e3 var1 = (SellHotel$EnhancerByCGLIB$2624d6e3)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];}}public Object newInstance(Callback[] var1) {CGLIB$SET_THREAD_CALLBACKS(var1);SellHotel$EnhancerByCGLIB$2624d6e3 var10000 = new SellHotel$EnhancerByCGLIB$2624d6e3();CGLIB$SET_THREAD_CALLBACKS((Callback[])null);return var10000;}public Object newInstance(Callback var1) {CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});SellHotel$EnhancerByCGLIB$2624d6e3 var10000 = new SellHotel$EnhancerByCGLIB$2624d6e3();CGLIB$SET_THREAD_CALLBACKS((Callback[])null);return var10000;}public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {CGLIB$SET_THREAD_CALLBACKS(var3);SellHotel$EnhancerByCGLIB$2624d6e3 var10000 = new SellHotel$EnhancerByCGLIB$2624d6e3;switch(var1.length) {case 0: var10000.(); CGLIB$SET_THREAD_CALLBACKS((Callback[])null); return var10000;default: throw new IllegalArgumentException("Constructor not found");}}public Callback getCallback(int var1) {CGLIB$BIND_CALLBACKS(this);MethodInterceptor var10000;switch(var1) {case 0: var10000 = this.CGLIB$CALLBACK_0; break;default: var10000 = null;}return var10000;}public void setCallback(int var1, Callback var2) {switch(var1) {case 0: this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;default:}}public Callback[] getCallbacks() {CGLIB$BIND_CALLBACKS(this);return new Callback[]{this.CGLIB$CALLBACK_0};}public void setCallbacks(Callback[] var1) {this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];}static {CGLIB$STATICHOOK1();}}

到此，我们知道cglib代理是帮我们新建了一个代理类，此代理类继承自目标类获取目标方法，同时重写了目标方法。

再通过我们定义的拦截器调用我们的目标方法，以此来达到代理目标方法的目的。

总结：JDK、cglib动态代理

据此，我们可以总结代理模式的定义：

【代理模式】 就是在不改变原有类（被代理类）的情况下，为原有类创建代理对象，对原有类的功能做增强的一种模式。 代理模式的优点：1. 满足单一原则，业务类可以只关心自己的核心逻辑，非核心逻辑由代理类完成；2. 易于维护，核心逻辑、非核心逻辑的修改不会互相影响；3. 对于用户（调用者）而言，使用的方式没有区别，可以做到低成本替换；4. JDK动态代理可以动态的绑定目标类，可以减少代码量，提高代码的复用；5. cglib动态代理可基于实现类做代理，可以解决JDK代理依赖接口的问题；代理模式的缺点：1. 静态代理每个被代理类都要有一个代理类，大大增加了代码量；2. JDK动态代理基于JDK的反射原理实现，降低了执行效率；3. JDK动态代理是基于接口的代理，要求目标类必须实现目标接口；代理模式分类：1. 静态代理；2. JDK动态代理（基于目标类的接口生成代理类做代理）；3. cglib动态代理（基于目标类生成子类做代理，同时也支持基于接口的代理）；

代理模式的使用场景

我们知道，Spring的AOP就是依赖于动态代理模式实现的，那我们在日常的开发中有哪些地方能用到代理呢？

•事物

•日志

•监控

•统计

•鉴权

•限流

•缓存

•环境隔离