Java设计模式—代理模式

代理模式（Proxy Pattern）也叫做委托模式，是一个使用率非常高的模式。

 

定义如下：
     为其他对象提供一种代理以控制对这个对象的访问。

 

个人理解：

       代理模式将原类进行封装，客户端不能直接找到原类，必须通过代理角色。即代理是原类的一个替身，客户端要找原类，统统找代理就可以搞定。明星和经纪人就是一种代理模式。

 

通用类图如下：

 

 

角色定义：

 

● Subject 抽象主题角色
     抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。

● Real Subject 具体主题角色

    也叫做被委托角色、被代理角色。它才是冤大头，是业务逻辑的具体执行者。

● Proxy代理主题角色
    也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。

 

通用源代码：

[java]  view plain  copy

 

1. //抽象主题类  
2. public interface Subject {  
3.      //定义一个方法  
4.      public void request();  
5. }  

在接口中我们定义了一个方法request来作为方法的代表，RealSubject对它进行实现。

[java]  view plain  copy

 

1. //真实主题类  
2. public class Real Subject implements Subject {  
3.      //实现方法  
4.      public void request() {  
5.              //业务逻辑处理  
6.      }  
7. }  

Real Subject是一个正常的业务实现类，代理模式的核心就在代理类上。

代理类如下：

[java]  view plain  copy

 

1. public class Proxy implements Subject {  
2.      //要代理哪个实现类  
3.      private Subject subject = null;      
4.      //默认被代理者  
5.      public Proxy(){  
6.              this.subject = new Proxy();  
7.      }  
8.      //通过构造函数传递代理者  
9.      public Proxy(Object...objects )    {    
10.    }  
11.      //实现接口中定义的方法  
12.      public void request() {  
13.              this.before();  
14.              this.subject.request();  
15.              this.after();  
16.      }  
17.      //预处理  
18.      private void before(){  
19.              //do something  
20.      }  
21.      //善后处理  
22.      private void after(){  
23.              //do something  
24.      }  
25. }  

代理模式的优点：

职责清晰、高扩展性、智能化

 

案例分析：追星族想要明星签名，必须找其经纪人搞定。

类图如下：

 

 

 

 

通用源代码如下：

[java]  view plain  copy

 

1. //明星接口  
2. public interface IStar {  
3.      //明星都会签名  
4.      public void sign();  
5. }  
6. //明星只有一个行为：签字。我们来看明星的实现，如代码清单3  
7.   
8. //明星  
9. public class Singer implements IStar {  
10.      public void sign() {  
11.              System.out.println("明星签字：我是XXX大明星");  
12.      }  
13. }  
14.   
15.   
16. //经纪人与明星应该有相同的行为，比如说签名，虽然经纪人不签名，但是他把你要签名的笔记本、衣服、CD等传递过去让真正的明星签字，  
17.   
18. //经纪人  
19. public class Agent implements IStar {  
20.      //定义是谁的经纪人  
21.      private IStar star;  
22.      //构造函数传递明星  
23.      public Agent(IStar _star){  
24.              this.star = _star;  
25.      }  
26.      //经纪人是不会签字的，签字了歌迷也不认  
27.      public void sign() {  
28.              star.sign();  
29.      }  
30. }  

[java]  view plain  copy

 

1. //追星族  
2. public class Idolater {  
3.      public static void main(String[] args) {  
4.              //崇拜的明星是谁  
5.              IStar star = new Singer();  
6.              //找到明星的经纪人  
7.              IStar agent = new Agent(star);  
8.              System.out.println("追星族：我是你的崇拜者，请签名！");  
9.              //签字  
10.              agent.sign();  
11.      }  
12. }  

很简单，找到明星的代理，然后明星就签字了。运行结果如下所示：

追星族：我是你的崇拜者，请签名！
明星签字：我是XXX大明星

看看我们的程序逻辑，我们是找明星的经纪人签字，真实签字的是明星，经纪人只是把这个请求传递给明星处理而已，这是普通的代理模式的典型应用。

 

 *********************************************************************************************************************************************************************

 代理模式的扩展：

 普通代理、强制代理、动态代理

 

普通代理：要求客户端只能访问代理角色，而不能访问真实角色。

          在该模式下，调用者只知道代理而不知道真是的角色是谁，屏蔽了真是角色的变更对高层模块的影响，真实的主

题角色想怎么修改都可以。在实际项目中，一般通过约定来禁止new一个真实的角色。

 

强制代理：客户端必须通过真实角色查找到代理角色，否则你不能访问。

            就好比是你和一个明星比较熟，相互认识，有件事情你需要向她确认一下，于是你就直接拨通了明星的电话：
                  “喂，沙比呀，我要见一下×××导演，你帮下忙了！”
                 “不行呀衰哥，我这几天很忙呀，你找我的经纪人吧……”

                 郁闷了吧，你是想直接绕过她的代理，谁知道返回的还是她的代理，这就是强制代理，你可以不用知道代理存在，但是你的所作所为还是需要代理为你提供。

 动态代理：

     在实现阶段不用关心代理谁，而在运行阶段才指定代理哪一个对象。相对来说，自己写代理类的方式就是静态

代理。

 

首先我们需要学习JDK提供的动态代理接口InvocationHandler，该接口对被代理类的方法进行代理。

JDK如图所示：

其次还有一个类叫Proxy，来看JDK描述,我们主要使用了newProxyInstance( )的静态方法。

 

动态代理Demo如下：

[java]  view plain  copy

 

1. package com.package1;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7. public class DynamicProxy {  
8.       
9.     public static void main(String[] args){  
10.         //定义一个people作为被代理的实例  
11.         IPeople ple=new People();  
12.         //定义一个handler  
13.         InvocationHandler handle=new MyHandle(ple);  
14.           
15.         //获得类加载器  
16.         ClassLoader cl=ple.getClass().getClassLoader();  
17.           
18.         //动态产生一个代理，下边两种方法均可  
19. //      IPeople p=(IPeople) Proxy.newProxyInstance(cl, new Class[]{IPeople.class}, handle);  
20.         IPeople p=(IPeople) Proxy.newProxyInstance(cl, ple.getClass().getInterfaces(), handle);  
21.           
22.         //执行被代理者的方法。  
23.         p.func();  
24.     }  
25.       
26.       
27.       
28. }  
29.   
30. class MyHandle implements InvocationHandler{  
31.       
32.   
33.     //被代理的实例  
34.     Object obj=null;  
35.       
36.     //我要代理谁  
37.     public MyHandle(Object obj){  
38.         this.obj=obj;  
39.           
40.     }  
41.   
42.     @Override  
43.     public Object invoke(Object proxy, Method method, Object[] args)  
44.             throws Throwable {  
45.         Object result=method.invoke(this.obj, args);  
46.         return result;  
47.     }  
48.       
49. }  
50.   
51. interface IPeople{  
52.       
53.     public void fun();  
54.       
55.     public void func();  
56. }  
57.   
58. //实际被代理的类  
59. class People implements IPeople{  
60.   
61.     @Override  
62.     public void fun() {  
63.         System.out.println("这是fun方法");  
64.           
65.     }  
66.   
67.     @Override  
68.     public void func() {  
69.         System.out.println("这是func方法");  
70.           
71.     }  
72.       
73. }  

       其中invoke方法是接口Invocation Handler定义必须实现的，它完成对真实方法的调用。我们来详细讲解一下Invocation Handler

接口，动态代理是根据被代理的接口生成所有的方法，也就是说给定一个接口，动态代理会宣称“我已经实现该接口下的所有方法

了”，那各位读者想想看，动态代理怎么才能实现被代理接口中的方法呢？默认情况下所有的方法返回值都是空的，是的，代理已经

实现它了，但是没有任何的逻辑含义，那怎么办？好办，通过Invocation Handler接口，所有方法都由该Handler来进行处理，即所

有被代理的方法都由Invocation Handler接管实际的处理任务。