设计模式

代理模式的作用是控制和管理访问

先看一段代码：

1. package com.test;  
2. /** 
3.  * 抽象角色 
4.  * @author Administrator 
5.  * 
6.  */  
7. abstract public class Subject {  
8.     abstract public void request();  
9. }  

1. package com.test;  
2. /** 
3.  * 真实角色 
4.  * @author 阳光小强 
5.  * 
6.  */  
7. public class RealSubject extends Subject{  
8.     public RealSubject(){  
9.           
10.     }  
11.       
12.     public void request(){  
13.         System.out.println("From real subject");  
14.     }  
15. }  

1. package com.test;  
2. /** 
3.  * 客户端调用 
4.  * @author 阳光小强 
5.  * 
6.  */  
7. public class Main {  
8.     public static void main(String[] args) {  
9.         Subject sub = new RealSubject();  
10.         sub.request();  
11.     }  
12. }  

上面代码应该很容易看懂，下面我们使用代理模式（新增一个ProxySubject类）

1. package com.test;  
2.   
3. /** 
4.  *  
5.  * @author 阳光小强 
6.  * 
7.  */  
8. public class ProxySubject extends Subject{  
9.     private RealSubject realSubject; //以真实角色作为代理角色的属性  
10.       
11.     public ProxySubject(){  
12.           
13.     }  
14.   
15.     @Override  
16.     public void request() {  
17.         preRequest();  
18.           
19.         if(realSubject == null){  
20.             realSubject = new RealSubject();  
21.         }  
22.         realSubject.request();  
23.           
24.         postRequest();  
25.     }  
26.       
27.     private void preRequest(){  
28.         //something you want to do before requesting   
29.     }  
30.       
31.     private void postRequest(){  
32.         //something you want to do after requesting   
33.     }  
34.   
35. }  

客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理RealSubject类，同样达到目的，同时还封装了其他方法(preRequest(),postRequest())，可以处理一些其他问题。 

有时候我们需要代理的对象不确定，所以就需要动态代理，Java中的动态代理模式实现如下：

1. package com.test;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5.   
6. public class DynamicSubject implements InvocationHandler {    
7.         
8.     private Object dele;    
9.         
10.     public DynamicSubject(Object obj) {    
11.         this.dele = obj;    
12.     }    
13.         
14.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
15.         doBefore();    
16.         //在这里完全可以把下面这句注释掉，而做一些其它的事情    
17.         Object result = method.invoke(dele, args);    
18.         after();    
19.         return result;    
20.     }    
21.         
22.     private void doBefore() {    
23.         System.out.println("before....");    
24.     }    
25.         
26.     private void after() {    
27.         System.out.println("after....");    
28.     }    
29. }    

1. package com.test;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Proxy;  
5.   
6. /** 
7.  * 客户端调用 
8.  * @author 阳光小强 
9.  * 
10.  */  
11. public class Main {  
12.     public static void main(String[] args) throws Exception {  
13.         RealSubject rs = new RealSubject(); //被代理的类  
14.         InvocationHandler ds = new DynamicSubject(rs); //初始化代理类  
15.           
16.         Subject subject = (Subject) Proxy.newProxyInstance(rs.getClass().getClassLoader(), rs.getClass().getInterfaces(), ds);  
17.         subject.request();  
18.   
19.     }