作者：京東零售 秦浩然
引子
舉個例子，眾所周知，我們是可以在京東上購買機票的。 但機票是航司提供的，我們本質上是代理銷售而已。
那為什麼航司要讓我們代理銷售呢？
我們又是如幫他做代理的呢？
別急，本文將展開說說他們之間的關係。。。
一個有夢想的航司
從前有個航司打算開展線上銷售機票業務，於是設計瞭如下系統。系統完成後，業務正常開展了。。。
航司銷售機票的介面：
public interface SellAirTicket {
/**
* 銷售機票
* @param price
*/
void sellAirTicket(int price);
}
航司銷售機票的介面實現類：
public class SellAirTicketImpl implements SellAirTicket {
@Override
public 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 {
@Override
public 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 {
@Override
public void sellAirTicket(int price) {
System.out.println("航司銷售機票，價格：" + price);
}
}
JD平臺代理航司銷售機票實現類：
public class SellAirTicketProxy implements SellAirTicket {
/**
* 航司售票介面
*/
private SellAirTicket sellAirTicket;
@Override
public 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售前風控。。。
航司銷售機票，價格：666
JD售後統計。。。
樸素的一對一合作方式，靜態代理
以上流程對與航司而言，由JD幫助自己關注風控、統計，自已可以專心的賣票，看著很好的樣子。
但是JD平臺只能給航司賣票，其餘的也幹不了，航司與JD的關係屬於靜態繫結的關係，即：被代理類與代理類屬於靜態繫結的關係，稱之為“靜態代理”。
據此，我們可以給代理模式下個定義：
【代理模式】 就是在不改變原有類（被代理類）的情況下，為原有類建立代理物件，對原有類的功能做增強的一種模式
代理模式的優點：
1. 滿足單一原則，業務類可以只關心自己的核心邏輯，非核心邏輯由代理類完成；
2. 易於維護，核心邏輯、非核心邏輯的修改不會互相影響；
3. 對於使用者（呼叫者）而言，使用的方式沒有區別，有和可以做到低成本替換；
代理模式的缺點：
1. 每個被代理類都要有一個代理類，大大增加了程式碼量；
保險出現，代理公司高瞻遠矚
某天，保險公司也被風控、統計邏輯搞的焦頭爛額，聽說航司找了個代理，於是也找到了JD，讓JD給他們做代理。
JD想：總不能誰來找我，我就給誰做一套代理系統吧，那我得做多少套，反正他們都是找我做風控、統計的，那我能不能做一套系統，給他們所有的人用呢，說幹就幹。。。
保險公司銷售保險的介面：
public interface SellInsurance {
/**
* 銷售保險
* @param price
*/
void sellInsurance(int price);
}
保險公司銷售保險的介面實現類：
public class SellInsuranceImpl implements SellInsurance {
@Override
public 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;
@Override
public 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售前風控。。。
航司銷售機票，價格：600
JD售後統計。。。
JD售前風控。。。
保險公司銷售保險，價格：30
JD售後統計。。。
進階的一對多合作方式，動態代理
到這裡航司、保險公司都找到了自己的代理，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<Void>() {
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 ProxyClassFactory
return 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 cacheKey
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); //這裡建立字解碼物件
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
V 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 Factory
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
} else {
if (valuesMap.replace(subKey, supplier, factory)) {
// successfully replaced
// cleared CacheEntry / unsuccessful Factory
// with our Factory
supplier = factory;
} else {
// retry with current supplier
supplier = 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 ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";
// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, 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 in
int 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 package
proxyPkg = 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 { //代理類的構造器，將事件處理器傳入，交給父類Proxy
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 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();
}
@Override
public 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售前風控。。。
酒店銷售房間，價格：300
cglib售後統計。。。
原理分析：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.<init>();
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就是依賴於動態代理模式實現的，那我們在日常的開發中有哪些地方能用到代理呢？
•事物
•日誌
•監控
•統計
•鑑權
•限流
•快取
•環境隔離