ip-1000

少说、多听、多做、多思考!

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
代理模式:给某一对象提供代理对象,并由代理对象控制具体对象的引用。

 

代理模式涉及的角色: 
1:抽象主题角色.声明了代理主题和真实主题的公共接口,使任何需要真实主题的地方都能用代理主题代替. 

2:代理主题角色.含有真实主题的引用,从而可以在任何时候操作真实主题,代理主题功过提供和真实主题相同的接口,使它可以随时代替真实主题.代理主题通过持有真实主题的引用,不但可以控制真实主题的创建或删除,可以在真实主题被调用前进行拦截,或在调用后进行某些操作. 

3:真实代理对象.定义了代理角色所代表的具体对象.  


我们可以用客户买红酒来模拟代理模式的实现 

 红酒代理商和红酒厂商都有销售红酒的ke能,我们可以为他们定义一个共同的抽象主题角色, 

2 *抽象主题角色,定义了真实角色和代理角色的公共接口 
3 */  
4 public interface SellInterface{  
5      public Object sell();  
6 }  

接着,我们定义真实主题角色(这里就是红酒工厂),它必须实现了SellInterface接口的.  

2 *真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口 
3 */  
4 public class RedWineFactory implements SellInterface{  
5      public Object sell(){  
6          System.out.println("真实主题角色RedWineFactory 被调用了");  
7          return new Object();  
8      }  
9 }  

接着,我们定义真实主题角色(这里就是红酒工厂),它必须实现了SellInterface接口的.  

  1. /** 
  2. *真实主题角色,这里指红酒工厂角色,它实现了SellInterface接口 
  3. */  
  4. public class RedWineFactory implements SellInterface{  
  5.      public Object sell(){  
  6.          System.out.println("真实主题角色RedWineFactory 被调用了");  
  7.          return new Object();  
  8.      }  
  9. }  
  

下面是代理主题角色(这里指红酒代理商),同样,代理主题也必须实现SellInterface接口. 

 

  1. /** 
  2. *代理主题角色,这里指红酒代理商.它除了也要实现了sellInterface接口外,还持有红酒 
  3. *厂商RedWineFactory 对象的引用,从而使它能在调用真实主题前后做一些必要处理. 
  4. */  
  5. public class RedWineProxy implements SellInterface{  
  6.      //持有一个RedWineFactory对象的引用  
  7.       private RedWineFactory redWineFactory;  
  8.   
  9.      //销售总量  
  10.       private static int sell_count = 0;  
  11.   
  12.      public Object sell(){  
  13.          if(checkUser()){//在通过代理主题角色,我们可以在真实主题角色被调用前做一些诸如权限判断的事情  
  14.              Object obj = redWineFactory.sell();  
  15.              count ++;//同样,在调用后我们也可以执行一些额外的动作.  
  16.              return obj ;  
  17.          }else{  
  18.              throw new RuntimeException();  
  19.          }  
  20.      }  
  21.   
  22.      protected boolean checkUser(){  
  23.             //do something  
  24.             return true;  
  25.      }  
  26. }  


接下来看看调用代理对象的代码  

 

  1. public static void main(String agr[])  
  2. {  
  3.      SellInterface sell = new RedWineProxy();  
  4.      sell.sell();  
  5. }  
从上面的例子可以看出代理模式的工作方式,首先,因为代理主题和真实主题都实现了共同的接口,这使我们可以在不改变原来接口的情况下,只要用真实主题对象的地方,都可以用代理主题来代替.其次,代理主题在客户和真实主题之间起了一个中介作用,利用这个中介平台,我们可以在把客户请求传递给真实主题之前,做一些必要的预处理. 

java对代理模式的支持 ---动态代理 
上面的代理,我们强迫代理类RedWineProxy实现了抽象接口SellInterface.这导致我们的代理类无法通用于其他接口,所以不得不为每一个接口实现一个代理类.幸好,java为代理模式提供了支持. 
java主要是通过Proxy类和InvocationHandler接口来给实现对代理模式的支持的. 
下面用java的代理机制来实现
 
 1 import java.lang.reflect.InvocationHandler;
 2  import java.lang.reflect.Proxy;
 3  import java.lang.reflect.Method;
 4  //抽象角色:java动态代理的实现目前只支持接口,不支持抽象类
 5  interface BusinessFoo
 6  {
 7      void foo();
 8  }
 9  interface BusinessBar
10 {
11     String bar(String message);
12 }
13 //真实角色:真正实现业务逻辑方法
14 class BusinessFooImpl implements BusinessFoo
15 {
16     public void foo()
17     {
18         System.out.println("BusinessFooImpl.foo()");
19     }
20 }
21 class BusinessBarImpl implements BusinessBar
22 {
23     public String bar(String message)
24     {
25         System.out.println("BusinessBarImpl.bar()");
26         return message;
27     }
28 }
29 //动态角色:动态生成代理类
30 class BusinessImplProxy implements InvocationHandler
31 {
32     private Object obj;
33     BusinessImplProxy() {
34     }
35     BusinessImplProxy(Object obj) {
36         this.obj = obj;
37     }
38     public Object invoke(Object proxy,Method method,Object[] args) throws Throwable
39     {
40         Object result = null;
41         doBefore();
42         result = method.invoke(obj,args);
43         doAfter();
44         return result;
45     }
46     public void doBefore(){
47         System.out.println("do something before Business Logic");
48     }
49     public void doAfter(){
50         System.out.println("do something after Business Logic");
51     }
52     public static Object factory(Object obj)
53     {
54         Class cls = obj.getClass();
55         return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj));
56     }
57 }
58 //测试类
59 public class DynamicProxy
60 {    
61     public static void main(String[] args) throws Throwable
62     {
63         BusinessFooImpl bfoo = new BusinessFooImpl();
64         BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo);
65         bf.foo();
66         System.out.println();
67         
68         BusinessBarImpl bbar = new BusinessBarImpl();
69         BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar);
70         String message = bb.bar("Hello,World");
71         System.out.println(message);
72     }
73 }
通过上面的代码可以看出,代理主题BusinessImplProxy类并没有实现我们定义的两个接口, 
而是实现了java的InvocationHandler接口,这样就把代理主题角色和我们的业务代码分离开来,使代理对象能通用于其他接口. 
其实InvocationHandler接口就是一种拦截机制,当系统中有了代理对象以后,对原对象(真实主题)方法的调用,都会转由InvocationHandler接口来处理,并把方法信息以参数的形式传递给invoke方法,这样,我们就可以在invoke方法中拦截原对象的调用,并通过反射机制来动态调用原对象的方法.这好象也是spring aop编程的基础吧 

接着,用代理模式实现一个超级简单的aop拦截机制 
这个例子可以拦截我们指定的函数,并在拦截前后根据需要进行处理 
Java代码  收藏代码
  1. /** 
  2. *切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理 
  3. */  
  4. public interface AopInterface {  
  5.    public void before(Object obj);//调用的处理  
  6.    public void end(Object obj);//调用后的处理  
  7. }  


这个是实现了AopInterface 接口,在这里我们实现了我们的处理逻辑 
Java代码  收藏代码
  1. public class AopInterfaceImp implements AopInterface{  
  2.   
  3.     public void before(Object obj) {  
  4.         System.out.println("调用前拦截");  
  5.     }  
  6.   
  7.     public void end(Object obj) {  
  8.         System.out.println("调用调用后处理");  
  9.     }  
  10.   
  11. }  


接着是代理类 
Java代码  收藏代码
  1. public class PeoxyObject implements InvocationHandler {  
  2.     private AopInterface aop;//定义了切入时调用的方法  
  3.     private Object proxy_obj;  
  4.     private String methodName;//指定要切入的方法名  
  5.   
  6.     PeoxyObject(){}  
  7.   
  8.     public Object factory(Object obj){  
  9.         proxy_obj = obj;  
  10.         Class cls = obj.getClass();  
  11.         return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);  
  12.     }  
  13.   
  14.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  15.         if(this.aop == null)throw new NullPointerException("aop is null");  
  16.         if(method == null)throw new NullPointerException("method is null");  
  17.   
  18.         Object o;  
  19. //如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理  
  20. //否则当正常方法处理  
  21.         if(methodName != null && method.toString().indexOf(methodName) != -1){  
  22.             aop.before(proxy_obj);//指定方法调用前的处理  
  23.             o = method.invoke(proxy_obj, args);  
  24.             aop.end(proxy_obj);//指定方法调用后的处理  
  25.         }else{  
  26.             //没有指定的方法,以正常方法调用  
  27.             o = method.invoke(proxy_obj, args);  
  28.         }  
  29.         return o;  
  30.     }  
  31.   
  32.     public AopInterface getAop() {  
  33.         return aop;  
  34.     }  
  35.   
  36.     public void setAop(AopInterface aop) {  
  37.         this.aop = aop;  
  38.     }  
  39.   
  40.     public String getMethodName() {  
  41.         return methodName;  
  42.     }  
  43.   
  44.     public void setMethodName(String methodName) {  
  45.         this.methodName = methodName;  
  46.     }  
  47. }  


这里定义一个用来测试用的类 
Java代码  收藏代码
  1. public interface SubInterface {  
  2.     public void add(String value1,String value2);  
  3.     public void acc(String value1);  
  4. }  
  5.   
  6. public class ImpObject implements SubInterface{  
  7.   
  8.     public void add(String value1,String value2) {  
  9.         System.out.println("ImpObject add(String value1,String value2)");  
  10.     }  
  11.   
  12.     public void acc(String value1){  
  13.         System.out.println("ImpObject acc(String value1)");  
  14.     }  
  15.   
  16. }  


这里是测试代码 
Java代码  收藏代码
  1. public static void main(String agr[]){  
  2.      PeoxyObject po = new PeoxyObject();  
  3.   
  4.      po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象  
  5.       po.setMethodName("acc");//指定要拦截的函数  
  6.        
  7.       SubInterface si = (SubInterface)po.factory(new ImpObject());  
  8.    //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行  
  9.       si.add("tt","dd");     
  10.   
  11.    //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp  
  12.     //对象的两个方法  
  13.       si.acc("tt");  
  14.  }  


通过上面可以看出,拦截机制是代理模式的重要使用方式之一, 
除了拦截,代理模式还常用于资源加载,当我们要加载的资源很大时,我们可以让真实主题角色在后台加载资源,让代理主题角色负责处理前台的等待提示信息. 

还有就是授权机制,通过代理能拦截真实主题的能力,来控制真实主题的访问权限. 

 

参考地址:http://www.iteye.com/topic/517835 

 

posted on 2012-04-09 22:04  ip-10000  阅读(1654)  评论(0编辑  收藏  举报