Dynamic Proxy、 Proxy Pattern and Decorator Pattern

動態代理：

在目前的Java開發包中包含了對動態代理的支持，但是其實現只支持對接口的的實現。其實現主要通過是java.lang.reflect.Proxy類和java.lang.reflect.InvocationHandler接口。Proxy類主要用來獲取動態代理對象，InvocationHandler接口用來約束調用者實現，

如下，IHelloWorld接口定義的業務方法，HelloWorld是IHelloWorld接口的實現，HelloWorldProxy是 InvocationHandler接口實現。

package aop.dynamicProxy; public interface IHelloWorld { public void sayHello(); } package aop.dynamicProxy; public class HelloWorld implements IHelloWorld { public void sayHello() { System.out.println("say hello!"); } } package aop.dynamicProxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class HelloWorldProxy implements InvocationHandler { private Object origanalObj; public HelloWorldProxy(Object orignalObject){ this.origanalObj = orignalObject; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; beforeAction(); result = method.invoke(origanalObj, args); afterAction(); return result; } private void beforeAction(){ System.out.println("invoke before method!"); } private void afterAction(){ System.out.println("invoke after method!"); } } package aop; import java.lang.reflect.Proxy; import aop.dynamicProxy.HelloWorld; import aop.dynamicProxy.HelloWorldProxy; import aop.dynamicProxy.IHelloWorld; public class Main { /** * @param args */ public static void main(String[] args) { IHelloWorld hello = new HelloWorld(); HelloWorldProxy handler = new HelloWorldProxy(hello); IHelloWorld proxy = (IHelloWorld) Proxy.newProxyInstance(hello.getClass().getClassLoader() , hello.getClass().getInterfaces(), handler); proxy.sayHello(); } }

運行結果：

 

invoke before method!

say hello!

invoke after method!

 

1. 首先獲取一個業務接口的實現對象；
2. 獲取一個InvocationHandler實現，此處是HelloWorldProxy對象；
3. 創建動態代理對象；(只支持對接口的的實現)
4. 通過動態代理對象調用sayHello()方法，此時會在原始對象HelloWorld. sayHello()方法前後輸出兩句字符串。

 

Proxy模式：

代理是一種常用的設計模式，其目的就是爲其他對象提供一個代理以控制對某個對象的訪問。代理類負責爲委託類預處理消息，過濾消息並轉發消息，以及消息被委託類執行後的後續處理。

爲了保持行爲的一致性，代理類和委託類通常會實現相同的接口，所以在訪問者看來兩者沒有絲毫的區別。通過代理類這中間一層，能有效控制對委託類對象的直接訪問，也可以很好地隱藏和保護委託類對象，同時也爲實施不同控制策略預留了空間，從而在設計上獲得了更大的靈活性。

代理模式常用的兩個目的：

1. 授權機制 不同級別的用戶對同一對象擁有不同的訪問權利,代理來控制這兩種用戶對資源的訪問權限.
2. 某個客戶端不能直接操作到某個對象,但又必須和那個對象有所互動（如果那個對象是一個是很大的圖片,需要花費很長時間才能顯示出來,那麼當這個圖片包含在文檔中時,使用編輯器或瀏覽器打開這個文檔,打開文檔必須很迅速,不能等待大圖片處理完成,這時需要做個圖片Proxy來代替真正的圖片）.

package aop.proxyPattern; public interface IUserService { public void deleteUser(); } package aop.proxyPattern; public class UserServiceImpl implements IUserService { public void deleteUser() { System.out.println("delete user."); } } package aop.proxyPattern; public class UserServiceProxy implements IUserService { private IUserService userService; public UserServiceProxy(IUserService userService){ this.userService = userService; } public void deleteUser() { if (checkPermission()) { userService.deleteUser(); } } private boolean checkPermission(){ System.out.println("check permission before delete user!"); return true; } public IUserService getUserService() { return userService; } public void setUserService(IUserService userService) { this.userService = userService; } } package aop; import aop.proxyPattern.IUserService; import aop.proxyPattern.UserServiceImpl; import aop.proxyPattern.UserServiceProxy; public class Main { /** * @param args */ public static void main(String[] args) { IUserService service = new UserServiceImpl(); IUserService proxy = new UserServiceProxy(service); proxy.deleteUser(); } } 運行結果： invoke before delete user! delete user. invoke after delete user! package aop.proxyPattern; public interface IRenderImg { public void renderMiddleImg(); } package aop.proxyPattern; public class RenderImgImpl implements IRenderImg { public void renderMiddleImg() { System.out.println("render middle img."); } } package aop.proxyPattern; public class RenderImgProxy implements IRenderImg { private IRenderImg render; public RenderImgProxy(IRenderImg render){ this.render = render; } public void renderMiddleImg() { new Thread(new RenderImg(render)).start(); } class RenderImg implements Runnable { IRenderImg img; RenderImg(IRenderImg img){ this.img = img; } public void run() { System.out.println("start a new thread to down load and render middle img."); img.renderMiddleImg(); } } } package aop.proxyPattern; public class ImgProxyTest { public static void main(String[] args) { ImgProxyTest main = new ImgProxyTest(); main.renderContent(); } public void renderContent() { renderTopContent(); renderMiddleImg(); renderBottomContent(); } public void renderTopContent() { System.out.println("render top content."); } public void renderMiddleImg() { IRenderImg img = new RenderImgImpl(); IRenderImg imgProxy = new RenderImgProxy(img); imgProxy.renderMiddleImg(); } public void renderBottomContent() { System.out.println("render bottom content."); } } 運行結果： render top content. render bottom content. start a new thread to down load and render middle img. render middle img. 

 

Decorator Pattern：

 

動態給一個對象添加一些額外的職責,就象在牆上刷油漆.使用Decorator模式相比用生成子類方式達到功能的擴充顯得更爲靈活.我們通常可以使用繼承來實現功能的拓展,如果這些需要拓展的功能的種類很繁多,那麼勢必生成很多子類,增加系統的複雜性。

使用Decorator的理由是:這些功能需要由用戶動態決定加入的方式和時機.Decorator提供了"即插即用"的方法,在運行期間決定何時增加何種功能.

 

 

 

 

 

package aop.decoratorPattern; public interface IFly { public void fly(); } package aop.decoratorPattern; public class FlyImpl implements IFly { public void fly() { System.out.println("begin to fly"); } } package aop.decoratorPattern; public class FlyDecorator implements IFly { private IFly fly; public FlyDecorator(IFly fly) { this.fly = fly; } public void fly() { beforeFly(); fly.fly(); afterFly(); } private void beforeFly(){ System.out.println("before fly, prepare for flying"); } private void afterFly(){ System.out.println("after fly, do something after flying"); } } 運行結果： before fly, prepare for flying begin to fly after fly, do something after flying 

總結：

Proxy模式和Decorator模式本質上沒什麼大的區別，只是他們的使用目的不一樣而已：proxy只是對現在功能作了代理，而decorator不是對現在功能代理，是添加新的功能。而Java自己的動態代理則是更靈活一點的代理模式的實現，代理類被動態生成。 他們都是java編程思想中對“繼承”“多態”“面向接口編程”原則的較好實踐而已。