1. 什么是代理模式？

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

2. 代理模式有什么好处？

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

3. 代理模式一般涉及到的角色有：

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

代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。

              同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。  

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

4. 应用场景举例：

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

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

我们看看具体代码。

先定义一种女人

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

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

  1. package com.yangguangfu.proxy;  
  2. /** 
  3.  *定义一个潘金莲是什么样的人 
  4.  */  
  5. public class PanJinLian  implements KindWoman{  
  6.   
  7.     @Override  
  8.     public void happyWithMan() {  
  9.         System.out.println("潘金莲和男人在做那个...");     
  10.     }  
  11.   
  12.     @Override  
  13.     public void makeEyesWithMan() {  
  14.         System.out.println("潘金莲抛媚眼...");   
  15.     }  
  16. }  

再定义个丑陋的王婆

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

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

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

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

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

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

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

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

说完这个故事，那我总结一下，代理模式主要使用了java的多态，干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？

同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口.