引子

舉個栗子，眾所周知，我們是可以在京東上購買機票的。 但機票是航司提供的，我們本質(zhì)上是代理銷售而已。

那為什么航司要讓我們代理銷售呢？

我們又是如幫他做代理的呢？

別急，本文將展開說說他們之間的關(guān)系。。。

一個有夢想的航司

從前有個航司打算開展線上銷售機票業(yè)務(wù)，于是設(shè)計了如下系統(tǒng)。系統(tǒng)完成后，業(yè)務(wù)正常開展了。。。

航司銷售機票的接口：

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

航司銷售機票的接口實現(xiàn)類：

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);}}

測試結(jié)果：

航司銷售機票，價格：666

業(yè)務(wù)蒸蒸日上，問題接踵而至

隨著業(yè)務(wù)發(fā)展的越來越好，新的問題出現(xiàn)了。

黃牛天天爬接口，系統(tǒng)風險出現(xiàn)了；賣完票沒有統(tǒng)計結(jié)果，賣成啥樣也不知道。

于是航司想增加售前風控、售后統(tǒng)計。加上這些功能后，業(yè)務(wù)又繼續(xù)穩(wěn)步發(fā)展了。。。

航司銷售機票的接口：

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

航司銷售機票的接口實現(xiàn)類：

public class SellAirTicketImpl implements SellAirTicket {@Overridepublic void sellAirTicket(int price) {System.out.println("航司售前風控。。。");System.out.println("航司銷售機票，價格：" + price);System.out.println("航司售后統(tǒng)計。。。");}}

測試：

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

測試結(jié)果：

航司售前風控。。。航司銷售機票，價格：666航司售后統(tǒng)計。。。

人員捉襟見肘，業(yè)務(wù)被迫拆分

后來航司發(fā)現(xiàn)，就這么點人，又想做風控，又想賣機票，又想做統(tǒng)計，根本忙不過來。

那怎么解決呢？ 航司只想專心賣票，不想做這些跟賣票無關(guān)的工作，那只能找個代理公司了。

于是，航司找到了JD代替自己做這些工作，自己就負責專心賣票。。。

航司銷售機票的接口：

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

航司銷售機票的接口實現(xiàn)類：

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

JD平臺代理航司銷售機票實現(xiàn)類：

public class SellAirTicketProxy implements SellAirTicket {/** * 航司售票接口 */private SellAirTicket sellAirTicket;@Overridepublic void sellAirTicket(int price) {System.out.println("JD售前風控。。。");sellAirTicket.sellAirTicket(price);System.out.println("JD售后統(tǒng)計。。。");}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);}}

測試結(jié)果：

JD售前風控。。。航司銷售機票，價格：666JD售后統(tǒng)計。。。

樸素的一對一合作方式，靜態(tài)代理

以上流程對與航司而言，由JD幫助自己關(guān)注風控、統(tǒng)計，自已可以專心的賣票，看著很好的樣子。

但是JD平臺只能給航司賣票，其余的也干不了，航司與JD的關(guān)系屬于靜態(tài)綁定的關(guān)系，即：被代理類與代理類屬于靜態(tài)綁定的關(guān)系，稱之為“靜態(tài)代理”。

據(jù)此，我們可以給代理模式下個定義：

【代理模式】 就是在不改變原有類（被代理類）的情況下，為原有類創(chuàng)建代理對象，對原有類的功能做增強的一種模式 代理模式的優(yōu)點：1. 滿足單一原則，業(yè)務(wù)類可以只關(guān)心自己的核心邏輯，非核心邏輯由代理類完成；2. 易于維護，核心邏輯、非核心邏輯的修改不會互相影響；3. 對于用戶（調(diào)用者）而言，使用的方式?jīng)]有區(qū)別，有和可以做到低成本替換；代理模式的缺點：1. 每個被代理類都要有一個代理類，大大增加了代碼量；

保險出現(xiàn)，代理公司高瞻遠矚

某天，保險公司也被風控、統(tǒng)計邏輯搞的焦頭爛額，聽說航司找了個代理，于是也找到了JD，讓JD給他們做代理。

JD想：總不能誰來找我，我就給誰做一套代理系統(tǒng)吧，那我得做多少套，反正他們都是找我做風控、統(tǒng)計的，那我能不能做一套系統(tǒng)，給他們所有的人用呢，說干就干。。。

保險公司銷售保險的接口：

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

保險公司銷售保險的接口實現(xiàn)類：

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

JD平臺代理的風控、統(tǒng)計實現(xiàn)類：

public class SellDynamicProxy {/** * 獲取傳入目標對象的代理對象 * @param target * @return */public Object createProxy(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(), //目標對象使用類加載器target.getClass().getInterfaces(),//目標對象實現(xiàn)的接口的類型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售后統(tǒng)計。。。");return null;}public DynamicProxyHandler(Object object) {this.target = object;}}}

測試：

public class MainClass {public static void main(String[] args) {//創(chuàng)建動態(tài)代理平臺SellDynamicProxy dynamicProxy = new SellDynamicProxy();//代理銷售機票SellAirTicket airTicketProxy = (SellAirTicket) dynamicProxy.createProxy(new SellAirTicketImpl());airTicketProxy.sellAirTicket(600);//代理銷售保險SellInsurance insuranceProxy = (SellInsurance) dynamicProxy.createProxy(new SellInsuranceImpl());insuranceProxy.sellInsurance(30);}}

測試結(jié)果：

JD售前風控。。。航司銷售機票，價格：600JD售后統(tǒng)計。。。JD售前風控。。。保險公司銷售保險，價格：30JD售后統(tǒng)計。。。

進階的一對多合作方式，動態(tài)代理

到這里航司、保險公司都找到了自己的代理，JD平臺也完成了風控、統(tǒng)計代理平臺的搭建。再有人來找自己，JD平臺都可以滿足代理需求，現(xiàn)在看來，已經(jīng)很完美了。

被代理的商家與JD屬于動態(tài)綁定的關(guān)系，即：被代理類與代理類屬于動態(tài)綁定的關(guān)系，稱之為“動態(tài)代理”，由于此代理功能依賴JDK提供的Proxy、InvocationHandler類，也成為“JDK動態(tài)代理”。

據(jù)此，我們可以補充代理模式的定義：

【代理模式】 就是在不改變原有類（被代理類）的情況下，為原有類創(chuàng)建代理對象，對原有類的功能做增強的一種模式 代理模式的優(yōu)點：1. 滿足單一原則，業(yè)務(wù)類可以只關(guān)心自己的核心邏輯，非核心邏輯由代理類完成；2. 易于維護，核心邏輯、非核心邏輯的修改不會互相影響；3. 對于用戶（調(diào)用者）而言，使用的方式?jīng)]有區(qū)別，可以做到低成本替換；4. JDK動態(tài)代理可以動態(tài)的綁定目標類，可以減少代碼量，提高代碼的復用；代理模式的缺點：1. 靜態(tài)代理每個被代理類都要有一個代理類，大大增加了代碼量；2. JDK動態(tài)代理基于JDK的反射原理實現(xiàn)，降低了執(zhí)行效率；

酒店出現(xiàn)，代理公司意外降臨

平靜的日子沒過多久，一天某酒店找來了，要求給他們做代理，做就做唄。輕車又熟路。。。

酒店銷售房間：

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

測試：

public class MainClass {public static void main(String[] args) {//創(chuàng)建動態(tài)代理平臺SellDynamicProxy dynamicProxy = new SellDynamicProxy();//代理銷售酒店SellHotel sellHotel = (SellHotel) dynamicProxy.createProxy(new SellHotel());sellHotel.sellHotel(300);}}

測試結(jié)果：

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)

怎么回事，平臺不好用了！代理公司閉關(guān)修煉，查一下問題。。。

優(yōu)秀代理公司的自我修養(yǎng)

以前給別人代理都好使，這次給酒店代理為何就不行了呢？ 一個優(yōu)秀的代理，有問題就要解決問題。。。

先看異常，代理類不能被強轉(zhuǎn)為目標類型，但是為何之前的都好使？

思考：只有生成的代理類屬于目標類型，才能強轉(zhuǎn)，那就需要代理類實現(xiàn)目標類的接口，那問題就可能是這樣了，驗證一下。

原理分析：JDK代理對象是如何實現(xiàn)的？

讓我們先看下源碼：

/** * 獲取傳入目標對象的代理對象 * @param target * @return */public Object createProxy(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(), //目標對象使用類加載器target.getClass().getInterfaces(),//目標對象實現(xiàn)的接口的類型new DynamicProxyHandler(target));//目標對象事件處理器}/** * 創(chuàng)建代理類源碼 */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);//生成代理類的字節(jié)碼對象/* * Invoke its constructor with the designated invocation handler. */try {if (sm != null) {checkNewProxyPermission(Reflection.getCallerClass(), cl);}final Constructor cons = cl.getConstructor(constructorParams);//獲取參數(shù)為事件處理器的構(gòu)造器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});//用詞構(gòu)造器，傳入的事件處理器，構(gòu)造代理類} 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. * 生成代理類的字節(jié)碼對象 */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); //這里獲取字節(jié)碼對象}/** * 這里獲取字節(jié)碼對象 */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));//這里創(chuàng)建字解碼對象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類的內(nèi)部類，就是為了創(chuàng)建代理對象的字節(jié)碼對象 */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(//這里生成需要的字節(jié)碼對象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());}}}

上面分析一堆，那我們來了看看得到的代理類到底是啥，為啥他就能執(zhí)行那個我們的目標類的方法。同時，還得目標類實現(xiàn)接口？

/** * 我們自己生成一份目標類字節(jié)碼文件 * @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();}

將我們的字節(jié)碼文件在此反編譯：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{ //代理類的構(gòu)造器，將事件處理器傳入，交給父類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)}); //執(zhí)行目標方法時，調(diào)用父類的事件處理器} 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父類，同時實現(xiàn)了目標類的接口，這就將我們的目標方法與定義的事件處理器聯(lián)系起來了。

同時，由于java的單繼承模式，導致了代理類只能繼承Proxy類，那這樣的話，就只好通過目標類的接口來關(guān)聯(lián)目標類了。

小結(jié)：JDK動態(tài)代理

據(jù)此，我們可以再次補充代理模式的定義：

【代理模式】 就是在不改變原有類（被代理類）的情況下，為原有類創(chuàng)建代理對象，對原有類的功能做增強的一種模式 代理模式的優(yōu)點：1. 滿足單一原則，業(yè)務(wù)類可以只關(guān)心自己的核心邏輯，非核心邏輯由代理類完成；2. 易于維護，核心邏輯、非核心邏輯的修改不會互相影響；3. 對于用戶（調(diào)用者）而言，使用的方式?jīng)]有區(qū)別，可以做到低成本替換；4. JDK動態(tài)代理可以動態(tài)的綁定目標類，可以減少代碼量，提高代碼的復用；代理模式的缺點：1. 靜態(tài)代理每個被代理類都要有一個代理類，大大增加了代碼量；2. JDK動態(tài)代理基于JDK的反射原理實現(xiàn)，降低了執(zhí)行效率；3. JDK動態(tài)代理是基于接口的代理，要求目標類必須實現(xiàn)目標接口；

好的合作伙伴就是不拋棄不放棄

到這里，問題是搞明白了，就是酒店的問題，但是好的合作伙伴就是應該不拋棄，不放棄。

酒店跟我們合作，我們就要幫助他們解決困難。那怎么辦呢？酒店沒接口，JDK代理又非要接口，那我們就不用JDK代理了！

這時，基于類的代理方式就應運而生了—— cglib為我們提供了基于類的動態(tài)代理模式。

導Jar包：cglib-3.2.5.jar（cglib核心包）、asm-3.3.1.jar（字節(jié)碼處理框架）

public class CglibDynamicProxy implements MethodInterceptor {//目標對象private Object target;/** *給目標對象創(chuàng)建一個代理對象 */public Object getProxyInstance(){//工具類Enhancer en = new Enhancer();//設(shè)置父類en.setSuperclass(target.getClass());//設(shè)置回調(diào)函數(shù)en.setCallback(this);//創(chuàng)建子類代理對象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售后統(tǒng)計。。。");return invoke;}public CglibDynamicProxy(Object target) {this.target = target;}}

測試

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

測試結(jié)果

cglib售前風控。。。酒店銷售房間，價格：300cglib售后統(tǒng)計。。。

原理分析：cglib代理對象是如何實現(xiàn)的？

那為啥cglib就不用目標類實現(xiàn)接口了呢？讓我們看看代理類。

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

反編譯結(jié)果

/** * 代理類反編譯結(jié)果 */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) {//執(zhí)行方法攔截器 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代理是幫我們新建了一個代理類，此代理類繼承自目標類獲取目標方法，同時重寫了目標方法。

再通過我們定義的攔截器調(diào)用我們的目標方法，以此來達到代理目標方法的目的。

總結(jié)：JDK、cglib動態(tài)代理

據(jù)此，我們可以總結(jié)代理模式的定義：

【代理模式】 就是在不改變原有類（被代理類）的情況下，為原有類創(chuàng)建代理對象，對原有類的功能做增強的一種模式。 代理模式的優(yōu)點：1. 滿足單一原則，業(yè)務(wù)類可以只關(guān)心自己的核心邏輯，非核心邏輯由代理類完成；2. 易于維護，核心邏輯、非核心邏輯的修改不會互相影響；3. 對于用戶（調(diào)用者）而言，使用的方式?jīng)]有區(qū)別，可以做到低成本替換；4. JDK動態(tài)代理可以動態(tài)的綁定目標類，可以減少代碼量，提高代碼的復用；5. cglib動態(tài)代理可基于實現(xiàn)類做代理，可以解決JDK代理依賴接口的問題；代理模式的缺點：1. 靜態(tài)代理每個被代理類都要有一個代理類，大大增加了代碼量；2. JDK動態(tài)代理基于JDK的反射原理實現(xiàn)，降低了執(zhí)行效率；3. JDK動態(tài)代理是基于接口的代理，要求目標類必須實現(xiàn)目標接口；代理模式分類：1. 靜態(tài)代理；2. JDK動態(tài)代理（基于目標類的接口生成代理類做代理）；3. cglib動態(tài)代理（基于目標類生成子類做代理，同時也支持基于接口的代理）；

代理模式的使用場景

我們知道，Spring的AOP就是依賴于動態(tài)代理模式實現(xiàn)的，那我們在日常的開發(fā)中有哪些地方能用到代理呢？

?事物

?日志

?監(jiān)控

?統(tǒng)計

?鑒權(quán)

?限流

?緩存

?環(huán)境隔離