接著學習設計模式系列，今天講解的是代理模式。 定義 什麼是代理模式？ 代理模式，也叫委托模式，其定義是給某一個對象提供一個代理對象，並由代理對象控制對原對象的引用。它包含了三個角色： Subject：抽象主題角色。可以是抽象類也可以是介面，是一個最普通的業務類型定義。 RealSubject：具體主 ...
接著學習設計模式系列，今天講解的是代理模式。
定義
什麼是代理模式？
代理模式，也叫委托模式，其定義是給某一個對象提供一個代理對象，並由代理對象控制對原對象的引用。它包含了三個角色：
Subject：抽象主題角色。可以是抽象類也可以是介面，是一個最普通的業務類型定義。
RealSubject：具體主題角色，也就是被代理的對象，是業務邏輯的具體執行者。
Proxy：代理主題角色。負責讀具體主題角色的引用，通過真實角色的業務邏輯方法來實現抽象方法，併在前後可以附加自己的操作。
用類圖來表示的話大概如下：
我們可以用舉一個電影演員拍戲的例子，一般來說，演員最主要的工作就是演戲，其他的事可以交給他的經紀人去做，例如談合同，安排檔期等等，而負責這些場外工作的經紀人就相當於Proxy，而負責核心業務的演員就是 RealSubject 。
這就是代理模式的設計思路，除此之外，代理模式分為靜態代理和動態代理，靜態代理是我們自己創建一個代理類，而動態代理是程式自動幫我們生成一個代理類，可以在程式運行時再生成對象，下麵分別對它們做介紹。
靜態代理
靜態代理在程式運行之前，代理類.class文件就已經被創建了。還是用上面演員演戲的例子，在靜態代理模式中，我們要先創建一個抽象主題角色 Star ，
public interface Star {
// 演戲
void act();
}接下來就是創建具體的主題角色和代理主題角色，分別實現這個介面，先創建一個具體的主題角色 Actor ，
/**
* 演員，也就是具體的主題角色
*
* @author Tao
* @since 2019/7/9 18:34
*/
public class Actor implements Star {
public void act() {
System.out.println("演員演戲~~~");
}
}然後就是創建代理主題角色，也就是代理類，代理類本身並不負責核心業務的執行流程，演戲這事還得明星自己來。所以在代理類中需要將真實對象引入，下麵是具體的代碼實現：
/**
* 代理對象
* @author Tao
* @since 2019/7/9 18:43
*/
public class Agent implements Star {
/**
* 接收真實的明星對象
*/
private Star star;
/**
* 通過構造方法傳進來真實的明星對象
*
* @param star star
*/
public Agent(Star star) {
this.star = star;
}
public void act() {
System.out.println("簽合同");
star.act();
System.out.println("演完戲就收錢了");
}
}代碼的邏輯還是比較清晰的，通過維護一個Star對象，可以在act里調用具體主題角色的業務邏輯，並且在核心邏輯前後可以做一些輔助操作，比如簽合同，收錢等，這樣代理模式的角色就都分工完成了，最後用一個場景類來驗證下：
public class Client {
public static void main(String[] args) {
Star actor = new Actor();
Agent agent = new Agent(actor);
agent.act();
}
}運行的結果如下：
簽合同
演員演戲~~~
演完戲就收錢了
動態代理
動態代理分為兩種，分別是JDK動態代理和 CGLIB 動態代理，怎麼又分了，代理模式分類真多，不過來都來了，就都學習一下吧。
JDK動態代理
前面說了，在動態代理中我們不再需要再手動的創建代理類，我們只需要編寫一個動態處理器就可以了。真正的代理對象由JDK再運行時幫我們動態的來創建。
/**
* 動態代理處理類
*
* @author Tao
* @since 2019/7/9 19:04
*/
public class JdkProxyHandler {
/**
* 用來接收真實明星對象
*/
private Object star;
/**
* 通過構造方法傳進來真實的明星對象
*
* @param star star
*/
public JdkProxyHandler(Star star) {
super();
this.star = star;
}
/**
* 給真實對象生成一個代理對象實例
*
* @return Object
*/
public Object getProxyInstance() {
return Proxy.newProxyInstance(star.getClass().getClassLoader(),
star.getClass().getInterfaces(), (proxy, method, args) -> {
System.out.println("簽合同");
// 執行具體的業務邏輯
Object object = method.invoke(star, args);
System.out.println("演出完經紀人去收錢……");
return object;
});
}
}這裡說一下Proxy.newProxyInstance 這個方法，該方法包含了三個參數，
- ClassLoader loader：指定當前目標對象使用的類載入器，獲取載入器的方法是固定的；
- Class<?>[] interfaces：指定目標對象實現的介面的類型，使用泛型方式確認類型；
- InvocationHandler：
指定動態處理器，執行目標對象的方法時會觸發事件處理器的方法。
寫完了動態代理實現類，我們寫個場景類測試下，
public class Client {
public static void main(String[] args) {
Star actor = new Actor();
// 創建動態代理對象實例
Star jdkProxy = (Star) new JdkProxyHandler(actor).getProxyInstance();
jdkProxy.act();
}
}執行結果正常輸出：
簽合同
演員演戲~~~
演出完代理去收錢……
由此可見，JDK 動態代理確實發揮了代理的功能，相對於靜態代理，JDK 動態代理大大減少了我們的開發任務，同時減少了對業務介面的依賴，降低了耦合度。但它同樣有缺陷，就是動態代理的實現類需要類實現介面來完成代理的業務，也就是說它始終無法擺脫僅支持interface代理的桎梏，這是設計上的缺陷。而這時CGLIB 動態代理就派上用場了。
CGLIB 動態代理
CGLib採用了非常底層的位元組碼技術，其原理是通過位元組碼技術為一個類創建子類，併在子類中採用方法攔截的技術攔截所有父類方法的調用，順勢織入橫切邏輯。但因為採用的是繼承，所以不能對final修飾的類進行代理。下麵我們寫一個關於CGLib的動態代理類，值得說下的是，CGLib所在的依賴包不是JDK本身就有的，所以我們需要額外引入，如果是用maven來管理的話，就可以直接引入如下的依賴：
<dependencies>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.3</version>
</dependency>
</dependencies>使用 CGLIB 需要實現 MethodInterceptor 介面，並重寫intercept 方法，在該方法中對原始要執行的方法前後做增強處理。該類的代理對象可以使用代碼中的位元組碼增強器來獲取。具體的代碼如下：
public class CglibProxy implements MethodInterceptor {
/**
* 維護目標對象
*/
private Object target;
public Object getProxyInstance(final Object target) {
this.target = target;
// Enhancer類是CGLIB中的一個位元組碼增強器，它可以方便的對你想要處理的類進行擴展
Enhancer enhancer = new Enhancer();
// 將被代理的對象設置成父類
enhancer.setSuperclass(this.target.getClass());
// 回調方法，設置攔截器
enhancer.setCallback(this);
// 動態創建一個代理類
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("簽合同");
// 執行具體的業務邏輯
Object result = methodProxy.invoke(o, objects);
System.out.println("演出完經紀人去收錢……");
return result;
}
}
場景測試類：public class Client {
public static void main(String[] args) {
Star actor = new Actor();
// 創建動態代理對象實例
Star proxy = (Star) new CglibProxy().getProxyInstance(actor);
proxy.act();
}
}可以看出，測試類的邏輯和JDK動態代理差不多，其實套路都是一樣的，其實技術實現不同。
總結一下CGLIB代理模式： CGLIB創建的動態代理對象比JDK創建的動態代理對象的性能更高，但是CGLIB創建代理對象時所花費的時間卻比JDK多得多。所以對於單例的對象，因為無需頻繁創建對象，用CGLIB合適，反之使用JDK方式要更為合適一些。同時由於CGLib由於是採用動態創建子類的方法，對於final修飾的方法無法進行代理。
擴展知識
這裡擴展一個知識點，那就是Spring AOP的底層實現，為什麼在這裡提及呢？因為Spring AOP的底層實現就是基於代理模式，而JDK 動態代理和 CGLIB 動態代理均是實現 Spring AOP 的基礎。我們可以看下AOP的部分底層源碼：
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
// 判斷目標類是否是介面或者目標類是否Proxy類型，若是則使用JDK動態代理
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
// 使用CGLIB的方式創建代理對象
return new ObjenesisCglibAopProxy(config);
}
else {
// 上麵條件都不滿足就使用JDK的提供的代理方式生成代理對象
return new JdkDynamicAopProxy(config);
}
}
}
源碼的判斷邏輯並不難，主要是根據目標類是否是介面或者Proxy類型來判斷使用哪種代理模式創建代理對象，使用的代理模式正是JDK動態代理和CGLIB 動態代理技術。由此可見，瞭解代理模式還是很重要的，起碼以後面試官問AOP的底層實現時，我們還能吹一波呢，哈哈~~~
