qileilove

          blog已經(jīng)轉(zhuǎn)移至github,大家請訪問 http://qaseven.github.io/

          跟屌絲大哥學習設(shè)計模式---代理模式之動態(tài)代理

          動態(tài)代理

          java中動態(tài)代理機制的引入使得代理模式的思想更加完善與進步,它允許動態(tài)的創(chuàng)建代理并支持對動態(tài)的對所代理的方法進行調(diào)用。Java動態(tài)代理類位于Java.lang.reflect包下,一般主要涉及到以下兩個類: 

          (1). Interface InvocationHandler:該接口中僅定義了一個方法Object:invoke(Object obj,Method method, Object[] args)。在實際使用時,第一個參數(shù)obj一般是指代理類,method是被代理的方法,如上例中的request(),args為該方法的參數(shù)數(shù)組。這個抽象方法在代理類中動態(tài)實現(xiàn)。 

          (2).Proxy:該類即為動態(tài)代理類,作用類似于上例中的ProxySubject,其中主要包含以下內(nèi)容: 

          Protected Proxy(InvocationHandler h):構(gòu)造函數(shù),估計用于給內(nèi)部的h賦值。 

          Static Class getProxyClass (ClassLoader loader, Class[] interfaces):獲得一個代理類,其中l(wèi)oader是類裝載器,interfaces是真實類所擁有的全部接口的數(shù)組。 

          Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):返回代理類的一個實例,返回后的代理類可以當作被代理類使用(可使用被代理類的在Subject接口中聲明過的方法)。 

           

          所謂Dynamic Proxy是這樣一種class:它是在運行時生成的class,在生成它時你必須提供一組interface給它,然后該class就宣稱它實現(xiàn)了這些interface。你當然可以把該class的實例當作這些interface中的任何一個來用。當然啦,這個Dynamic Proxy其實就是一個Proxy,它不會替你作實質(zhì)性的工作,在生成它的實例時你必須提供一個handler,由它接管實際的工作。 下面我們通過動態(tài)代理來重新實現(xiàn)上面發(fā)送信息的例子!


           

          在上面的例子基礎(chǔ)上,我們先添加一個通過短信來發(fā)送消息的處理類:

          public class SmsMessage implements MessageHandler {
          @Override
          public void sendMessage(String msg) {
          // TODO Auto-generated method stub
          System.out.println("SMS Message :" + msg+" sent !");
          }
          }
          //動態(tài)代理類
          import java.lang.reflect.InvocationHandler;
          import java.lang.reflect.Method;
          public class DynamicMessageProxy implements InvocationHandler {
          private static int count;
          private MessageHandler msgHandler;
          public DynamicMessageProxy(MessageHandler handler) {
          msgHandler = handler;
          }
          @Override
          public Object invoke(Object proxy, Method method, Object[] args)
          throws Throwable {
          // TODO Auto-generated method stub
          System.out.println("++++++++=============+++++++++");
          System.out.println("proxy:" + proxy.getClass());
          System.out.println("method:" + method);
          System.out.println("++++++++=============+++++++++");
          if (args != null && args.length == 1 && checkMessage((String) args[0])) {
          count++;
          System.out.println("Message sent:" + count);
          return method.invoke(msgHandler, args);
          }
          return null;
          }
          private boolean checkMessage(String msg) {
          return msg != null && msg.length() > 10;
          }
          }
          //下面是調(diào)用
          import java.lang.reflect.Proxy;
          public class MainClass {
          private static void runProxy(MessageHandler handler) {
          handler.sendMessage("message for test");
          }
          /**
           * @param args
           */
          public static void main(String[] args) {
          // TODO Auto-generated method stub
          // runProxy(new EmailMessage());
          // System.out.println("++++++++++++++++Proxy++++++++++++++++++");
          // runProxy(new MessageProxy());
          MessageHandler handler = new EmailMessage();
          runProxy(handler);
          MessageHandler proxy = (MessageHandler) Proxy.newProxyInstance(
          MessageHandler.class.getClassLoader(),
          new Class[] { MessageHandler.class }, new DynamicMessageProxy(
          handler));
          runProxy(proxy);
          System.out.println("++++++++++++++++++++++++++++++++++");
          // 短信方式
          handler = new SmsMessage();
          runProxy(handler);
          proxy = (MessageHandler) Proxy.newProxyInstance(MessageHandler.class
          .getClassLoader(), new Class[] { MessageHandler.class },
          new DynamicMessageProxy(handler));
          runProxy(proxy);
          }
          }
          下面為以上方法的輸出:
          message for test send!!
          ++++++++=============+++++++++
          proxy:class $Proxy0
          method:public abstract void MessageHandler.sendMessage(java.lang.String)
          ++++++++=============+++++++++
          Message sent:1
          message for test send!!
          ++++++++++++++++++++++++++++++++++
          SMS Message :message for test sent !
          ++++++++=============+++++++++
          proxy:class $Proxy0
          method:public abstract void MessageHandler.sendMessage(java.lang.String)
          ++++++++=============+++++++++
          Message sent:2
          SMS Message :message for test sent !

          以上例子中,通過調(diào)用Proxy.newProxyInstance方法創(chuàng)建動態(tài)代理對象,該方法需要傳入一個 類加載器、一組希望代理實現(xiàn)的接口列表、InvocationHandler 接口的一個具體實現(xiàn)。動態(tài)代理可以將所有調(diào)用重定向到調(diào)用處理器,通常我們會向該處理器傳遞一個時間對象的引用。invoke()方法中傳遞進來了代理對象,當你需要區(qū)分請求來源時這是非常有用的,例如你可以通過判斷傳入的方法名屏蔽掉某些方法的執(zhí)行!動態(tài)代理機制并不是會很頻繁使用的方法,它通常用來解決一些特定情況下的問題,因此不要盲目的為了使用而使用,要根據(jù)自己的實際需求來決定!

          動態(tài)代理的應(yīng)用十分廣泛,在struts2的攔截器中就用到了動態(tài)代理機制。還是以買車票為例子,現(xiàn)在用動態(tài)代理來實現(xiàn),其中不懂的接口方法查查Java api就會明白了,在此不多做解釋,代碼如下(注意PassengerProxy類):

          import java.lang.reflect.*;

          public interface Passenger {
          public void buyTicket();
          }

          public class RealPassenger implements Passenger {

          @Override
          public void buyTicket() {
             // TODO Auto-generated method stub
             System.out.println("購買了車票");
          }
          }

          // 用動態(tài)代理實現(xiàn)

          //InvocationHandler 是代理實例的調(diào)用處理程序 實現(xiàn)的接口。 每個代理實例都具有一個關(guān)聯(lián)的調(diào)用處理程序。對代理實例調(diào)用方法時,將對方法調(diào)用進行編碼并將其指派到//它的調(diào)用處理程序的 invoke 方法。
          public class PassengerProxy implements InvocationHandler {
          public Object obj;

          // 把obj交給代理類
          public Object obj(Object obj) {
             this.obj = obj;
             return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
               .getClass().getInterfaces(), this);
          }

          @Override
          public Object invoke(Object proxy, Method method, Object[] args)
              throws Throwable {
             // TODO Auto-generated method stub
             System.out.println("通過代理");
             method.invoke(obj, args);
             return null;
          }
          }

          public class Client {
          public static void main(String[] args) {
             PassengerProxy proxy = new PassengerProxy();
             Passenger passenger = (Passenger) proxy.obj(new RealPassenger());
             passenger.buyTicket();
          }
          }

          再來一個更牛的例子

          1. /** 
          2.  * 相親接口 
          3.  *  
          4.  * @author zhengt 
          5.  * @time Jun 3, 2095 3:13:03 PM 
          6.  */  
          7. public interface XiangQinInterface {  
          8.     /** 
          9.      * 相親方法 
          10.      */  
          11.     public void xiangQin();  
          12. }  
          13. /** 
          14.  * 張三相親實現(xiàn)類 
          15.  *  
          16.  * @author zhengt 
          17.  * @time Jun 3, 2095 3:14:48 PM 
          18.  */  
          19. public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {  
          20.     public void xiangQin() {  
          21.         System.out.println("張三去相親,娶個漂亮老婆。");  
          22.     }  
          23. }  
          24. import java.lang.reflect.InvocationHandler;  
          25. import java.lang.reflect.Method;  
          26.   
          27. /** 
          28.  * 相親可是一輩子的大事,相親前要準備一下,打扮得帥氣些。 
          29.  *  
          30.  * @author zhengt 
          31.  * @time Jun 3, 2095 3:15:48 PM 
          32.  */  
          33. public class ReadyInvocationHandler implements InvocationHandler {  
          34.     //相親接口的實現(xiàn)類,也就是張三相親類  
          35.     private Object zhangSan = null;  
          36.   
          37.     public ReadyInvocationHandler(Object realSubject) {  
          38.         this.zhangSan = realSubject;  
          39.     }  
          40.   
          41.     public Object invoke(Object proxy, Method m, Object[] args) {  
          42.         Object result = null;  
          43.         try {  
          44.             /** 
          45.              * 動態(tài)代理類$Proxy0調(diào)用xiangQin方法時會調(diào)用它自己的xiangQin方法, 
          46.              * 而它自己的xiangQin方法里面調(diào)用的是super.h.invoke(this, , ),也就是父類Proxy的h的invoke方法, 
          47.              * 也就是ReadyInvocationHandler類的invoke方法。 
          48.              * 所以,invoke(Object proxy, Method m, Object[] args)種的proxy實際上就是動態(tài)代理類$Proxy0, 
          49.              * 如果你將其強轉(zhuǎn)成XiangQinInterface然后調(diào)用它的xiangQin方法,然后它就會調(diào)用super.h.invoke(this, , ),這樣就會死循環(huán)。 
          50.              */  
          51.             /** 
          52.              * 網(wǎng)上關(guān)于這里最多問題就是Object proxy放在這里用來做什么呢?這個我也不知道, 
          53.              * 不過至少我們知道它到底是個什么東西,具體做什么用嘛就不得而知了 
          54.              */  
          55.             System.out.println(proxy.getClass().getSimpleName());  
          56.             System.out.println("張三相親前,代理人給他打扮了打扮。");  
          57.             result = m.invoke(zhangSan, args);  
          58.         } catch (Exception ex) {  
          59.             System.exit(1);  
          60.         }  
          61.         return result;  
          62.     }  
          63. }  
          64. import java.lang.reflect.InvocationHandler;  
          65. import java.lang.reflect.Method;  
          66. import java.lang.reflect.Proxy;  
          67.   
          68. /** 
          69.  * 張三來到了婚介所(相親現(xiàn)場),開始相親。 
          70.  *  
          71.  * @author zhengt 
          72.  * @time Jun 3, 2095 3:17:16 PM 
          73.  */  
          74. public class HunJieSuo {  
          75.     public static void main(String args[]) {  
          76.         //先將張三相親這個相親的實現(xiàn)類實例化,也就是得到XiangQinInterface接口的一個實例對象  
          77.         XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();  
          78.         /** 
          79.          * 得到ZhangSanXiangQinInterfaceImpl這個類的一個代理類,同時為代理類綁定了一個處理類ReadyInvocationHandler。 
          80.          * 聽著很繞口,其實就是每次調(diào)用ZhangSanXiangQinInterfaceImpl這個子類的xiangQin方法時, 
          81.          * 不是zhangSan這個ZhangSanXiangQinInterfaceImpl類的實例去調(diào)用, 
          82.          * 而是這個ZhangSanXiangQinInterfaceImpl的代理類ReadyInvocationHandler去調(diào)用它自己的invoke方法, 
          83.          * 這個invoke方法里呢可以調(diào)用zhangSan這個實例的xiangQin方法 
          84.          */  
          85.         /** 
          86.          * 在java種怎樣實現(xiàn)動態(tài)代理呢 
          87.          * 第一步,我們要有一個接口,還要有一個接口的實現(xiàn)類,而這個實現(xiàn)類呢就是我們要代理的對象, 
          88.          * 所謂代理呢也就是在調(diào)用實現(xiàn)類的方法時,可以在方法執(zhí)行前后做額外的工作,這個就是代理。 
          89.          * 第二步,我們要自己寫一個在要代理類的方法執(zhí)行時,能夠做額外工作的類,而這個類必須繼承InvocationHandler接口, 
          90.          * 為什么要繼承它呢?因為代理類的實例在調(diào)用實現(xiàn)類的方法的時候,不會調(diào)真正的實現(xiàn)類的這個方法, 
          91.          * 而是轉(zhuǎn)而調(diào)用這個類的invoke方法(繼承時必須實現(xiàn)的方法),在這個方法中你可以調(diào)用真正的實現(xiàn)類的這個方法。 
          92.          * 第三步,在要用代理類的實例去調(diào)用實現(xiàn)類的方法的時候,寫出下面兩段代碼。 
          93.          */  
          94.         XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(  
          95.                 zhangSan.getClass().getClassLoader(),  
          96.                 zhangSan.getClass().getInterfaces(),  
          97.                 new ReadyInvocationHandler(zhangSan));  
          98.         proxy.xiangQin();  
          99.         /** 
          100.          * 這里要解釋下中部那段長長的代碼的意思,以及具體做了哪些工作? 
          101.          * 第一,根據(jù)zhangSan.getClass().getClassLoader()這個要代理類的類加載器和 
          102.          * zhangSan.getClass().getInterfaces()要代理類所實現(xiàn)的所有的接口 
          103.          * 作為參數(shù)調(diào)用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces) 
          104.          * 的方法返回代理類的java.lang.Class對象,也就是得到了java動態(tài)生成的代理類$Proxy0的Class對象。 
          105.          * 同時,java還讓這個動態(tài)生成的$Proxy0類實現(xiàn)了要代理類的實現(xiàn)的所有接口,并繼承了Proxy接口。 
          106.          * 第二,實例化這個動態(tài)生成的$Proxy0類的一個實例,實例化代理類的構(gòu)造函數(shù)為Proxy(InvocationHandler h), 
          107.          * 也就是說要實例化這個動態(tài)生成的$Proxy0類,必須給它一個InvocationHandler參數(shù),也就是我們自己實現(xiàn)的用來在代理類 
          108.          * 方法執(zhí)行前后做額外工作的類ReadyInvocationHandler。 
          109.          * 這 段代碼 Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan)) 
          110.          * 得到的其實是一個類名叫$Proxy0 extends Proxy implements XiangQinInterface的類。 
          111.          * 第三,將這個$Proxy0類強制轉(zhuǎn)型成XiangQinInterface類型,調(diào)用xiangQin方法。 
          112.          */  
          113.     }  

          網(wǎng)上看到一個牛人讀過這個動態(tài)代理的源代碼,現(xiàn)把網(wǎng)址留在這里,希望對網(wǎng)友們有幫助。
          http://hi.baidu.com/malecu/blog/item/45d4952b31bc0e27d52af17a.html
          在目前的Java開發(fā)包中包含了對動態(tài)代理的支持,但是其實現(xiàn)只支持對接口的的實現(xiàn)。

            其實現(xiàn)主要通過是java.lang.reflect.Proxy類和java.lang.reflect.InvocationHandler接口。

            Proxy類主要用來獲取動態(tài)代理對象,InvocationHandler接口用來約束調(diào)用者實現(xiàn),如下,DiaoSi接口定義的 業(yè)務(wù)方法,DiaoSiNanImpl是DiaoSi接口的實現(xiàn),
          DiaoSiNanHandler是 InvocationHandler接口實現(xiàn)。代碼如下:
          業(yè)務(wù)接口:
          package proxy;

          public interface DiaoSi {
          void luGuan();
          }
           業(yè)務(wù)接口實現(xiàn):
          public class DiaoSiNan implements DiaoSi {

              @Override
              public void luGuan() {
                  // TODO Auto-generated method stub
                  System.out.println("我是擼管王");
              }

          }
           InvocationHandler實現(xiàn),需要在接口方法調(diào)用前后加入一部份處理工作,這里僅僅在方法調(diào)用前后向后臺輸出兩句字符串,其代碼如下:
          package proxy;

          import java.lang.reflect.InvocationHandler;
          import java.lang.reflect.Method;

          public class DiaoSiNanHander implements InvocationHandler{
              //要代理的原始對象
              
          private Object diaosinan;
          /**

          * 構(gòu)造函數(shù)。

          * @param obj 要代理的原始對象。

          */
          public DiaoSiNanHander(Object diaosinan) {

              this.diaosinan = diaosinan;
          }
              @Override
              
              public Object invoke(Object proxy, Method method, Object[] args)
                      throws Throwable {
                  // TODO Auto-generated method stub
                  Object result ;
                  doBefore();
                  //調(diào)用原始對象的方法
                  result = method.invoke(this.diaosinan ,args);
                  //方法調(diào)用之后
                  doafter();
                  return result;

                  
              }
              private void doafter() {
                  // TODO Auto-generated method stub
          System.out.println("after method invoke!");
              }
              private void doBefore() {
                  // TODO Auto-generated method stub
                  System.out.println("before method invoke!");
              }


          }
          測試代碼:
          package proxy;

          import java.lang.reflect.InvocationHandler;
          import java.lang.reflect.Proxy;

          public class Test {
          public static void main(String[] args) {
          DiaoSi ds = new DiaoSiNan();

          DiaoSiNanHander handler = new DiaoSiNanHander(ds);

          DiaoSi proxy = (DiaoSi) Proxy.newProxyInstance(

          ds.getClass().getClassLoader(),

          ds.getClass().getInterfaces(),

          handler);
          /*public static Object newProxyInstance(ClassLoader loader,
                  Class<?>[] interfaces,
                  InvocationHandler h)
          throws IllegalArgumentException
          {
          if (h == null) {
          throw new NullPointerException();
          }*/
          proxy.luGuan();

                  

          }
          }
          Ø 首先獲取一個業(yè)務(wù)接口的實現(xiàn)對象;

            Ø 獲取一個InvocationHandler實現(xiàn),此處是
          DiaoSiNanHanderHandler對象;

            Ø 創(chuàng)建動態(tài)代理對象;

            Ø 通過動態(tài)代理對象調(diào)用luGuan()方法,此時會在原始對象DiaoSiNan.luGuan()方法前后輸出兩句字符串。

            運行測試類輸出如下:

            
          before method invoke!
          我試擼管王
          after method invoke!


            此處Test類中的方法調(diào)用代碼比較多,在我們的實際應(yīng)用中可以通過配置文件來來簡化客戶端的調(diào)用實現(xiàn)。另外也可以通過動態(tài)代理來實現(xiàn)簡單的AOP。




           

          posted on 2012-12-13 11:53 順其自然EVO 閱讀(501) 評論(0)  編輯  收藏 所屬分類: 設(shè)計模式學習

          <2012年12月>
          2526272829301
          2345678
          9101112131415
          16171819202122
          23242526272829
          303112345

          導航

          統(tǒng)計

          常用鏈接

          留言簿(55)

          隨筆分類

          隨筆檔案

          文章分類

          文章檔案

          搜索

          最新評論

          閱讀排行榜

          評論排行榜

          主站蜘蛛池模板: 开原市| 扎赉特旗| 峨眉山市| 洪泽县| 大石桥市| 温泉县| 鄂温| 巴彦淖尔市| 通化县| 湘乡市| 安仁县| 石泉县| 府谷县| 太白县| 盐池县| 泰来县| 曲沃县| 交城县| 台东县| 遵化市| 潞城市| 民勤县| 阳山县| 吉安市| 南投市| 湖北省| 纳雍县| 扶余县| 天气| 日土县| 句容市| 镇坪县| 宁城县| 祁连县| 巫山县| 塘沽区| 西乌珠穆沁旗| 府谷县| 五家渠市| 安图县| 郓城县|