【设计模式】—-（12）代理模式（结构型）

这篇文章挺有意思的，是男人应该都能理解吧。（捂嘴：））

代理模式理解应该很简单，就是现实中的中介，相信大家都租过房子，撸主上学那会其实就很鄙视中介，看其他同学都找中介很快搞定房子，而露珠呢，宁可自己去走街串巷一个一个联系，也不愿意出中介费。现在想想真好笑哈。

好了言归正转

1，什么是代理模式？代理模式有什么好处？

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。

在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

 补充：

和装饰者模式一样，代理模式中也实现了相同的接口。然而不同的是，代理模式强调的重点是使用代替实际对象工作，减少对实际对象的操作（干实事儿的还是实际对象啊）；装饰者模式则是，给被装饰者添加附加功能才是重点（修饰被装饰者）。

静态代理

代理模式有几种，虚拟代理，计数代理，远程代理，动态代理。主要分为两类，静态代理和动态代理。

静态代理比较简单，是由程序员编写的代理类，并在程序运行前就编译好的，而不是由程序动态产生代理类，这就是所谓的静态。

考虑这样的场景，管理员在网站上执行操作，在生成操作结果的同时需要记录操作日志，这是很常见的。

此时就可以使用代理模式，代理模式可以通过聚合和继承两种方式实现：

[java] view plain copy

 print?

1. /**方式一：聚合式静态代理 
2.  * @author Singit (mailto:[e-mail]) 
3.  * @Since 2017年01月7日 
4.  */  
5. //1.抽象主题接口  
6. public interface Manager {  
7.     void doSomething();  
8. }  
9. //2.真实主题类  
10. public class Admin implements Manager {  
11.     public void doSomething() {  
12.         System.out.println("Admin do something.");  
13.     }  
14. }  
15. //3.以聚合方式实现的代理主题  
16. public class AdminPoly implements Manager{  
17.     private Admin admin;  
18.      
19.     public AdminPoly(Admin admin) {  
20.         super();  
21.         this.admin = admin;  
22.     }  
23.    
24.     public void doSomething() {  
25.         System.out.println("Log:admin操作开始");  
26.         admin.doSomething();  
27.         System.out.println("Log:admin操作结束");  
28.     }  
29. }  
30. //4.测试代码  
31.         Admin admin = new Admin();  
32.         Manager m = new AdminPoly(admin);  
33.         m.doSomething();  
34. //方式二：继承式静态代理  
35. //与上面的方式仅代理类和测试代码不同  
36. //1.代理类  
37. public class AdminProxy extends Admin {  
38.     @Override  
39.     public void doSomething() {  
40.         System.out.println("Log:admin操作开始");  
41.         super.doSomething();  
42.         System.out.println("Log:admin操作开始");  
43.     }  
44. }  
45. //2.测试代码  
46.         AdminProxy proxy = new AdminProxy();  
47.         proxy.doSomething();  

聚合实现方式中代理类聚合了被代理类，且代理类及被代理类都实现了同一个接口，可实现灵活多变。继承式的实现方式则不够灵活。

比如，在管理员操作的同时需要进行权限的处理，操作内容的日志记录，操作后数据的变化三个功能。三个功能的排列组合有6种，也就是说使用继承要编写6个继承了Admin的代理类，而使用聚合，仅需要针对权限的处理、日志记录和数据变化三个功能编写代理类，在业务逻辑中根据具体需求改变代码顺序即可。

动态代理

一般来说，对代理模式而言，一个主题类与一个代理类一一对应，这也是静态代理模式的特点。

但是，也存在这样的情况，有n各主题类，但是代理类中的“前处理、后处理”都是一样的，仅调用主题不同。也就是说，多个主题类对应一个代理类，共享“前处理，后处理”功能，动态调用所需主题，大大减小了程序规模，这就是动态代理模式的特点。

小结

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理。在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样对每一个方法或方法组合进行处理。Proxy 很美很强大，但是仅支持 interface 代理。Java 的单继承机制注定了这些动态代理类们无法实现对 class 的动态代理。好在有cglib为Proxy提供了弥补。class与interface的区别本来就模糊，在java8中更是增加了一些新特性，使得interface越来越接近class，当有一日，java突破了单继承的限制，动态代理将会更加强大。

2，UML：

    

 

3，代理模式涉及到的角色：

 

ISubject:抽象角色：声明真实对象和代理对象的共同接口； 

Proxy:代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。 

RealObject:真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

 

 

4，应用场景举例：

 

比如西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理，表现在程序上时是这样的体现的

先说说这个场景中的要素：一种类型的女人，潘金莲，王婆，西门庆，后来扩展的贾氏也和西门庆勾上了，我们是假设的，然后西门庆找潘金莲happy,但潘金莲不好意思直接，就找个王婆代理呗。我们看看具体代码。

 

先定义一种女人

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福([e-mail])<br> 
5.  *定义一种类型的女人，王婆和潘金莲都属于这个类型的女人 
6.  */  
7. public interface KindWoman {  
8.       
9.     //这种女人能做什么事情呢？  
10.     public void makeEyesWithMan();//抛媚眼  
11.       
12.     public void happyWithMan();//和男人那个....  
13.   
14. }  

 

一种类型嘛，那肯定是接口，定义个潘金莲

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福([e-mail])<br> 
5.  *定义一个潘金莲是什么样的人 
6.  */  
7. public class PanJinLian  implements KindWoman{  
8.   
9.     @Override  
10.     public void happyWithMan() {  
11.         System.out.println("潘金莲和男人在做那个...");  
12.           
13.     }  
14.   
15.     @Override  
16.     public void makeEyesWithMan() {  
17.         System.out.println("潘金莲抛媚眼...");  
18.           
19.     }  
20.   
21. }  

 

再定义个丑陋的王婆

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福([e-mail])<br> 
5.  *王婆这个人老聪明了，她太老了，是个男人都看不上她， 
6.  *但是她有智慧经验呀，他作为一类女人的代理！ 
7.  */  
8. public class WangPo implements KindWoman {  
9.       
10.     private KindWoman kindWoman;  
11.       
12.     public WangPo(){  
13.         //默认的话是潘金莲的代理  
14.         this.kindWoman = new PanJinLian();  
15.     }  
16.     //她可以是KindWomam的任何一个女人的代理，只要你是这一类型  
17.     public WangPo(KindWoman kindWoman){  
18.         this.kindWoman = kindWoman;  
19.     }  
20.   
21.     @Override  
22.     public void happyWithMan() {  
23.         //自己老了，干不了了，但可以叫年轻的代替。  
24.         this.kindWoman.happyWithMan();  
25.           
26.     }  
27.   
28.     @Override  
29.     public void makeEyesWithMan() {  
30.         //王婆年纪大了，谁看她抛媚眼啊  
31.         this.kindWoman.makeEyesWithMan();  
32.           
33.     }  
34.   
35. }  

 

两个女主角都上场了，该男主角了，定义个西门庆

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福([e-mail])<br> 
5.  *水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下： 
6.  *如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！ 
7.  */  
8. public class XiMenQiang {  
9.   
10.     /** 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         WangPo wangPo;  
15.         //把王婆叫出来  
16.          wangPo = new WangPo();  
17.         //然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：  
18.         wangPo.makeEyesWithMan();  
19.         //看到没有表面是王婆在做，其实爽的是潘金莲  
20.         wangPo.happyWithMan();  
21.           
22.           
23.   
24.     }  
25.   
26. }  

 

那这就是活生生的一个例子，通过代理人实现了某种目的，如果真去了王婆这个中间环节，直接西门庆和潘金莲勾搭，估计很难成就武松杀嫂事件。

     那我们再考虑一下，水浒里面还有没有这类型的女人？有，卢俊义的老婆贾氏（就是和那个管家苟合的那个），这个名字起的：“贾氏”，那我们也让王婆做她的代理：

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福([e-mail])<br> 
5.  *定义一个贾氏是什么样的人 
6.  */  
7. public class JiaShi implements KindWoman {  
8.   
9.     @Override  
10.     public void happyWithMan() {  
11.         System.out.println("贾氏和男人在做那个...");  
12.           
13.     }  
14.   
15.     @Override  
16.     public void makeEyesWithMan() {  
17.         System.out.println("贾氏抛媚眼...");  
18.           
19.     }  
20.   
21.   
22. }  

 

西门庆勾潘金莲又勾引贾氏

Java代码  

1. package com.yangguangfu.proxy;  
2. /** 
3.  *  
4.  * @author 阿福([e-mail])<br> 
5.  *水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下： 
6.  *如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！ 
7.  */  
8. public class XiMenQiang {  
9.   
10.     /** 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         WangPo wangPo;  
15.         //把王婆叫出来  
16.          wangPo = new WangPo();  
17.         //然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：  
18.         wangPo.makeEyesWithMan();  
19.         //看到没有表面是王婆在做，其实爽的是潘金莲  
20.         wangPo.happyWithMan();  
21.           
22.           
23.           
24.         //西门庆勾引贾氏  
25.         JiaShi jiaShi = new JiaShi();  
26.         wangPo = new WangPo(jiaShi);  
27.         wangPo.makeEyesWithMan();  
28.         wangPo.happyWithMan();  
29.   
30.     }  
31.   
32. }  

 说完这个故事，那我总结一下，代理模式主要使用了java的多态，干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口呗。好了不多说了，慢慢体会吧。