學習 Spring 的過程中，不可避免要掌握代理模式。這篇文章總結一下代理模式。顧名思義，代理，就是你委託別人幫你辦事，所以代理模式也有人稱作委託模式的。比如領導要做什麼事，可以委託他的祕書去幫忙做，這時就可以把祕書看做領導的代理。下面將以這個例子來講解。
代理模式又分為靜態代理和動態代理。
一、靜態代理
靜態代理的使用
靜態代理，代理類和被代理的類實現了同樣的介面，代理類同時持有被代理類的引用，這樣，當我們需要呼叫被代理類的方法時，可以通過呼叫代理類的方法來做到。舉例如下：
假設領導的工作是開會和給員工考評。
先定義一個介面：
package com.sharpcj;
public interface IWork {
void meeting();
int evaluate(String name);
}然後定義領導類：
package com.sharpcj;
import java.util.Random;
public class Leader implements IWork {
@Override
public void meeting() {
System.out.println("領導早上要組織會議");
}
@Override
public int evaluate(String name) {
int score = new Random(System.currentTimeMillis()).nextInt(20) + 80;
System.out.println(String.format("領導給%s的考評為%s分", name, score));
return score;
}
}祕書類：
package com.sharpcj;
public class Secretary implements IWork {
private Leader mLeader;
public Secretary(Leader mLeader) {
this.mLeader = mLeader;
}
@Override
public void meeting() {
System.out.println("祕書先給老闆準備材料");
mLeader.metting();
}
@Override
public int evaluate(String name) {
return mLeader.evaluate(name);
}
}測試類：
package com.sharpcj;
public class TestApp {
public static void main(String[] args) {
Leader leader = new Leader();
Secretary secretary = new Secretary(leader);
secretary.meeting();
secretary.evaluate("Joy");
}
}執行結果：
這個程式碼很簡單，注意在呼叫Secretary類的 meeting 方法時，我們呼叫了Leader類的 meeting 的方法，在此之前，我們還擴充了該方法。這時有的人可能有疑惑了，這看起來有點是裝飾者模式了。這到底怎麼回事？
與裝飾者模式的區別
實際上，在裝飾器模式和代理模式之間還是有很多差別的。裝飾器模式關注於在一個物件上動態的新增方法，然而代理模式關注於控制對物件的訪問。換句話說，用代理模式，代理類（proxy class）可以對它的客戶隱藏一個物件的具體資訊。因此，當使用代理模式的時候，我們常常在一個代理類中建立一個物件的例項。並且，當我們使用裝飾器模式的時候，我們通常的做法是將原始物件作為一個引數傳給裝飾者的構造器。
我們可以用另外一句話來總結這些差別：使用代理模式，代理和真實物件之間的的關係通常在編譯時就已經確定了，而裝飾者能夠在執行時遞迴地被構造。
先看看兩者的 UML 類圖區別：
代理模式
裝飾者模式
兩者虛擬碼：
代理模式:
Interface Subject {
void doAction()
}
public class RealSubject implements Subject{
@Override
public void doAction() {};
}
public class Proxy implements Subject{
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
//關係在編譯時確定
this.realSubject = realSubject;
}
@Override
public void doAction() {
….
realSubject.doAction();
….
}
}// 裝飾者模式
Interface Component {
void doAction()
}
public class ConcreteComponent implement Component {
@Override
public void doAction() {};
}
public class Decorator implements Component {
private Component component;
public Decorator(Component component) {
//關係在編譯時確定
this.component = new component;
}
public void doAction() {
….
component.doAction();
….
}
}其實代理模式和裝飾者模式側重點不一樣，代理模式重點在於明確了被代理的類。如上例中，祕書很明確要代理的是的領導。而裝飾者模式側重於擴充類的方法，裝飾類持有的實現Component介面的類的物件不是固定的，也就是說，裝飾類可以根據在呼叫時傳入的引數，裝飾任意一個實現了 Component 介面的類。
二、動態代理
動態代理的根據實現方式的不同可以分為 JDK 動態代理和 CGlib 動態代理。
JDK 動態代理：利用反射機制生成一個實現代理介面的類，在呼叫具體方法前呼叫InvokeHandler來處理。
CGlib 動態代理：利用ASM（開源的Java位元組碼編輯庫，操作位元組碼）開源包，將代理物件類的class檔案載入進來，通過修改其位元組碼生成子類來處理。
區別：JDK代理只能對實現介面的類生成代理；CGlib是針對類實現代理，對指定的類生成一個子類，並覆蓋其中的方法，這種通過繼承類的實現方式，不能代理final修飾的類。
JDK 動態代理
還是以上面的例子為例：
首先，定一個類實現 InvocationHandler 介面，並實現 invoke 方法：
package com.sharpcj;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class WorkInvocationHandler implements InvocationHandler {
private Object object;
public WorkInvocationHandler(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("object: " + object.getClass().getSimpleName());
System.out.println("proxy: " + proxy.getClass().getSimpleName());
if ("meeting".equals(method.getName())) {
System.out.println("代理先準備會議材料...");
return method.invoke(object, args);
} else if ("evaluate".equals(method.getName())) {
if(args[0] instanceof String) {
if ("James".equals(args[0])) {
System.out.println("James 犯過錯誤，所以考評分數較低...");
return 70;
}
}
return method.invoke(object, args);
}
return null;
}
}然後通過 Proxy.newProxyInstance() 方法建立代理物件：
package com.sharpcj;
import java.lang.reflect.Proxy;
public class TestApp {
public static void main(String[] args) {
/*Leader leader = new Leader();
Secretary secretary = new Secretary(leader);
secretary.meeting();
secretary.evaluate("Joy");*/
Leader leader = new Leader();
IWork proxy = (IWork) Proxy.newProxyInstance(Leader.class.getClassLoader(),
new Class[]{IWork.class}, new WorkInvocationHandler(leader));
proxy.meeting();
proxy.evaluate("Joy");
proxy.evaluate("James");
}
}輸出結果：
我們看到，通過 WorkInvocationHandler 類，我們同樣可以代理 Leader 類的方法的實現，實際上我們實現的是任意的方法的實現，只是我們在建立代理物件的時候傳入的是 Iwork 介面以及 Leader 類物件。
這裡需要注意的是：在 InvocationHandler 介面的 invoke 方法中第一個引數 proxy, 並不是我們呼叫方法的物件，那這個引數是什麼呢？程式碼中，我特別增加相應列印，列印出了 proxy 的類名，實際上 proxy 是代理物件本身，它的意義在於，我們可以在 invoke 方法中，返回該代理物件，然後進行連續呼叫。
看如下例子：
package com.sharpcj.proxytest;
public interface IWork {
IWork work(String subject);
}package com.sharpcj.proxytest;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class WorkInvocationHandler implements InvocationHandler {
private Object object;
public WorkInvocationHandler(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("work".equals(method.getName())){
System.out.println("--- work: " + args[0]);
return proxy;
}
return null;
}
}package com.sharpcj.proxytest;
import java.lang.reflect.Proxy;
public class TestApp {
public static void main(String[] args) {
IWork worker = (IWork) Proxy.newProxyInstance(IWork.class.getClassLoader(), new Class[]{IWork.class},
new WorkInvocationHandler(new IWork() {
@Override
public IWork work(String subject) {
return null;
}
}));
worker.work("AAA").work("BBB").work("CCC");
}
}結果如下：
CGlib 動態代理實現
首先新增 cglib 依賴
build.gradle 檔案：
...
dependencies {
// 引入 cglib 庫
compile 'cglib:cglib:3.1'
testCompile group: 'junit', name: 'junit', version: '4.12'
}
...前面說了，cglib 針對類進行代理，我們以上面的 Leader 類為例，先建立一個類實現 MethodInterceptor介面：
package com.sharpcj;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class LeaderMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
if ("meeting".equals(method.getName())) {
System.out.println("代理先準備會議材料...");
return methodProxy.invokeSuper(o, objects);
} else if ("evaluate".equals(method.getName())) {
if(objects[0] instanceof String) {
if ("James".equals(objects[0])) {
System.out.println("James 犯過錯誤，所以考評分數較低...");
return 70;
}
}
return methodProxy.invokeSuper(o, objects);
}
return null;
}
}測試程式碼：
package com.sharpcj;
import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;
import java.lang.reflect.Proxy;
public class TestApp {
public static void main(String[] args) {
// System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\temp\\code"); //儲存生成的 class 檔案
Enhancer enhancer = new Enhancer(); // 通過CGLIB動態代理獲取代理物件的過程
enhancer.setSuperclass(Leader.class); // 設定enhancer物件的父類
enhancer.setCallback(new LeaderMethodInterceptor()); // 設定enhancer的回撥物件
Leader proxy= (Leader)enhancer.create(); // 建立代理物件
// 通過代理物件呼叫目標方法
proxy.meeting();
proxy.evaluate("Joy");
proxy.evaluate("James");
}
}
結果如下：
MethodInterceptor 介面只有一個 intercept 方法，這個方法有4個引數：
1）obj表示增強的物件，即實現這個介面類的一個物件；
2）method表示要被攔截的方法；
3）args表示要被攔截方法的引數；
4）proxy表示要觸發父類的方法物件；
需要注意的是，實際呼叫是 methodProxy.invokeSuper(), 如果使用 invoke() 方法，則需要傳入被代理的類物件，否則出現死迴圈，造成 stackOverflow 。
詳情參考： 聊聊cglib動態代理遇到的坑: https://blog.csdn.net/kingmax54212008/article/details/83902535