Proxy Design Pattern(代理设计模式)

代理模式：给某一对象提供代理对象,并由代理对象控制具体对象的引用。

 

代理模式涉及的角色: 
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