解析Spring中的靜態代理和動態代理
一、靜態代理
1.1、靜態代理的使用
靜態代理,代理類和被代理的類實現瞭同樣的接口,代理類同時持有被代理類的引用,這樣,當我們需要調用被代理類的方法時,可以通過調用代理類的方法來做到。舉例如下:
假設領導的工作是開會和給員工考評。
先定義一個接口:
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 的方法,在此之前,我們還擴充瞭該方法。這時有的人可能有疑惑瞭,這看起來有點是裝飾者模式瞭。這到底怎麼回事?
1.2、與裝飾者模式的區別
實際上,在裝飾器模式和代理模式之間還是有很多差別的。裝飾器模式關註於在一個對象上動態的添加方法,然而代理模式關註於控制對對象的訪問。換句話說,用代理模式,代理類(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修飾的類。
2.1、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"); } }
結果如下:
2.2、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 。
以上就是解析Spring中的靜態代理和動態代理的詳細內容,更多關於Spring靜態代理和動態代理的資料請關註WalkonNet其它相關文章!
推薦閱讀:
- Spring AOP的底層實現方式-代理模式
- 解析動態代理jdk的Proxy與spring的CGlib(包括區別介紹)
- 解析Spring中面向切面編程
- Spring中AOP概念與兩種動態代理模式原理詳解
- Java基礎之動態代理Cglib詳解