JAVA设计模式(8) —<结构型>代理模式(Proxy)

1 定义：

代理模式(Proxy)

provide a surrogate or placeholder for another object to control access to it.(为其他对象提供一种代理以控制对这个对象的访问)。

1.1 通用类图：

           代理模式也叫做委托模式，它是一项基本设计技巧。许多其它的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式，而且在日常的应用中，代理模式可以提供非常好的访问控制。下面看一下类图中三个角色的定义：

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

具体主题角色(RealSubject)：也叫做被委托角色、被代理角色。它才是业务逻辑的具体执行者；

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

1.2 通用代码：

[java] view plaincopy

1. public interface Subject {  
2.          //定义一个方法  
3.          public void request();  
4. }  
5.    
6. public class RealSubject implements Subject{          
7.          //实现方法  
8.          public void request() {  
9.                 System.out.println("doing request-----"); 
10.          }  
11. }  
12.    
13. public class Proxy implements Subject {  
14.          //要代理哪个实现类  
15.          private Subject subject = null;  
16.           
17.          //默认被代理者  
18.          public Proxy(){  
19.          }  
20.           
21.          public Proxy(Subject _subject){  
22.                    this.subject= _subject;  
23.          }  
24.           
25.          //通过构造函数传递代理者  
26.          public Proxy(Object...objects ){  
27.    
28.          }  
29.           
30.          //实现接口中定义的方法  
31.          public void request() {  
32.                    this.before();  
33.                    this.subject.request();  
34.                    this.after();  
35.          }  
36.           
37.          //预处理  
38.          private void before(){  
39.                 System.out.println("doing before-----"); 
40.          }  
41.           
42.          //善后处理  
43.          private void after(){  
44.                 System.out.println("doing after-----"); 
45.          }  
46. }  
47.    
48. public class Client {   
49.          public static void main(String[] args) {  
50.                    Subject proxy = new Proxy(new RealSubject()) ;  
51.                    proxy.request();  
52.          }  
53. }  

输出：

doing before-----
doing request-----
doing after-----

2 优点

2.1 职责清晰：

     真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件事务，附带的结果就是编程简洁；

2.2 高扩展性：

     具体主题角色是随时都会发生变化的，只要它实现了接口，不用管它如何变化，都逃不了接口，那我们的代理类完全可以在不做任何修改的情况下使用。

2.3 智能化：

     这在我们以上讲解中还没有体现出来，不过在我们以下的动态代理章节中你就会看到代理的智能化，读者有兴趣也可以看看Struts是如何把表单元素映射到对象上的。

3 缺点

3.1 由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。       

3.2  实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

4 应用场景

在需要用比较通用和复杂的对象指针代替简单的指针的时候，使用 Proxy模式。下面是一些可以使用Proxy模式常见情况：

1. 远程（Remote）代理：为一个位于不同的地址空间的对象提供一个局域代表对象。这个不同的地址空间可以是在本机器中，也可是在另一台机器中。远程代理又叫做大使（Ambassador）。好处是系统可以将网络的细节隐藏起来，使得客户端不必考虑网络的存在。客户完全可以认为被代理的对象是局域的而不是远程的，而代理对象承担了大部份的网络通讯工作。由于客户可能没有意识到会启动一个耗费时间的远程调用，因此客户没有必要的思想准备。
2. 虚拟（Virtual）代理（图片延迟加载的例子）：根据需要创建一个资源消耗较大的对象，使得此对象只在需要时才会被真正创建。使用虚拟代理模式的好处就是代理对象可以在必要的时候才将被代理的对象加载；代理可以对加载的过程加以必要的优化。当一个模块的加载十分耗费资源的情况下，虚拟代理的好处就非常明显。
3. 保护代理（Protection Proxy）：控制对原始对象的访问。保护代理用于对象应该有不同的访问权限的时候。
4. Copy-on-Write代理：虚拟代理的一种。把复制（克隆）拖延到只有在客户端需要时，才真正采取行动。
5. 智能引用（Smart Reference）代理：当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。

5 注意事项

暂无

6 扩展

      在网络上代理服务器设置分为透明代理和普通代理，是什么意思呢？透明代理就是用户不用设置代理服务器地址，就可以直接访问，也就是说代理服务器对用户来说透明的，看不到，不用知道它存在的；普通代理则是需要用户自己设置代理服务器的IP地址，用户必须知道代理的存在。我们设计模式中的普通代理和强制代理也是类似的一种结构，普通代理就是我们要知道代理的存在，也就是类似的GamePlayerProxy这个类的存在，然后才能访问；强制代理则是调用者直接调用真实角色，而不用关心代理是否存在，其代理的产生是由真实角色决定的，这样解释还是比较复杂，我们还是用实例来讲解。

6.1普通代理例子：（游戏代理升级）

类图如下：

首先说普通代理，它的要求就是客户端只能访问代理角色，而不能访问真实角色，这是比较简单的，我们以上面的例子作为扩展，我自己作为一个游戏玩家，我肯定自己不练级了，也就是场景类不能再直接new一个GamePlayer对象了，它必须由GampePlayerProxy来进行模拟场景，类图修改如图12-4所示。

图12-4 普通代理类图

      改动很小，仅仅修改了两个实现类的构造函数，GamePlayer的构造函数增加了_gamePlayer参数，而代理角色则只要传入代理者名字即可，而不需要说是替哪个对象做代理。GamePlayer类如代码清单12-10所示。

代码清单12-10 普通代理的游戏者

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

public class GamePlayer implements IGamePlayer {   private String name = "";   //构造函数限制谁能创建对象，并同时传递姓名   public GamePlayer(IGamePlayer _gamePlayer,String _name) throws Exception{   if(_gamePlayer == null ){   throw new Exception("不能创建真是角色！");   }else{   this.name = _name;   }   }   //打怪，最期望的就是杀老怪   public void killBoss() {   System.out.println(this.name + "在打怪！");   }   //进游戏之前你肯定要登录吧，这是一个必要条件   public void login(String user, String password) {   System.out.println("登录名为"+user + " 的用户 " +this.name + "登录成功！");   }   //升级，升级有很多方法，花钱买是一种，做任务也是一种   public void upgrade() {   System.out.println(this.name + " 又升了一级！");   }   }

      在构造函数中，传递进来一个IGamePlayer对象，检查谁能创建真实的角色，当然还可以有其他的限制，比如类名必须为Proxy类等等，读者可以根据实际情况进行扩展。GamePlayerProxy如代码清单12-11所示。

代码清单12-11 普通代理的代理者

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

public class GamePlayerProxy implements IGamePlayer {   private IGamePlayer gamePlayer = null;   //通过构造函数传递要对谁进行代练   public GamePlayerProxy(String name){   try {   gamePlayer = new GamePlayer(this,name);   }catch (Exception e) {   // TODO 异常处理   }   }   //代练杀怪   public void killBoss() {   this.gamePlayer.killBoss();   }   //代练登录   public void login(String user, String password) {   this.gamePlayer.login(user, password);   }   //代练升级   public void upgrade() {   this.gamePlayer.upgrade();   }   }

      仅仅修改了构造函数，传递进来一个代理者名称，即可进行代理，在这种改造下，系统更加简洁了，调用者只知道代理存在就可以，不用知道代理了谁。同时场景类也稍作改动，如代码清单12-12所示。

代码清单12-12 普通代理的场景类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

public class GamePlayerProxy implements IGamePlayer {   private IGamePlayer gamePlayer = null;   //通过构造函数传递要对谁进行代练   public GamePlayerProxy(String name){   try {   gamePlayer = new GamePlayer(this,name);   }catch (Exception e) {   // TODO 异常处理   }   }   //代练杀怪   public void killBoss() {   this.gamePlayer.killBoss();   }   //代练登录   public void login(String user, String password) {   this.gamePlayer.login(user, password);   }   //代练升级   public void upgrade() {   this.gamePlayer.upgrade();   }   }

      运行结果完全相同。在该模式下，调用者只知代理而不用知道真实的角色是谁，屏蔽了真实角色的变更对高层模块的影响，真实的主题角色爱怎么修改就怎么修改，对高层次的模块没有任何的影响，只要你实现了接口所对应的方法，该模式非常适合对扩展性要求较高的场合。当然，在实际的项目中，一般都是通过约定来禁止new一个真实的角色，也是一个非常好的方案。

      注意 普通代理模式的约束问题，尽量通过团队内的编程规范类约束，因为每一个主题类是可被重用的和可维护的，使用技术约束的方式对系统维护是一种非常不利的因素。

6.2 强制代理

 强制代理在设计模式中比较另类，为什么这么说呢？一般的思维都是通过代理找到真实的角色，但是强制代理却是要“强制”，你必须通过真实角色查找到代理角色，否则你不能访问，甭管你是通过代理类还是通过直接new一个主题角色类，都不能访问，只有通过真实角色指定的代理类才可以访问，也就是说由真实角色管理代理角色，这么说吧，高层模块new了一个真实角色的对象，返回的却是代理角色，这就好比是你和一个明星比较熟，相互认识，有件事情你需要向她确认一下，于是你就直接拨通了明星的电话：

      “喂，沙比呀，我要见一下XXX导演，你帮下忙了！”

      “不行呀衰哥，我这几天很忙呀，你找我的经纪人吧…”

      郁闷了吧，你是想直接绕过她的代理，谁知道返回的还是她的代理，这就是强制代理，你可以不用知道代理存在，但是你的所作所为还是需要代理为你提供。我们把上面的例子稍作修改就可以完成，如图12-5所示。

图12-5 强制代理类图

在接口上增加了一个getProxy方法，真实角色GamePlayer可以指定一个自己的代理，除了代理外谁都不能访问。我们来看代码，先看IGamePlayer接口，如代码清单12-13所示。

代码清单12-13 强制代理的接口类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public interface IGamePlayer {   //登录游戏   public void login(String user,String password);   //杀怪，这是网络游戏的主要特色   public void killBoss();   //升级   public void upgrade();   //每个人都可以找一下自己的代理   public IGamePlayer getProxy();   }

      仅仅增加了一个getProxy方法，指定要访问自己必须通过哪个代理，实现类也要做适当的修改，先看真实角色GamePlayer，如代码清单12-14所示。

代码清单12-14 强制代理的真实角色

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

public class GamePlayer implements IGamePlayer {   private String name = "";   //我的代理是谁   private IGamePlayer proxy = null;   public GamePlayer(String _name){   this.name = _name;   }   //找到自己的代理   public IGamePlayer getProxy(){   this.proxy = new GamePlayerProxy(this.name);   return this.proxy;   }   //打怪，最期望的就是杀老怪   public void killBoss() {   if(this.isProxy()){   System.out.println(this.name + "在打怪！");   }else{   System.out.println("请使用指定的代理访问");   }   }   //进游戏之前你肯定要登录吧，这是一个必要条件   public void login(String user, String password) {   if(this.isProxy()){   System.out.println("登录名为"+user + " 的用户 " +this.name + "登录成功！");   }else{   System.out.println("请使用指定的代理访问");;   }   }   //升级，升级有很多方法，花钱买是一种，做任务也是一种   public void upgrade() {   if(this.isProxy()){   System.out.println(this.name + " 又升了一级！");   }else{   System.out.println("请使用指定的代理访问");   }   }   //校验是否是代理访问   private boolean isProxy(){   if(this.proxy == null){   return false;   }else{   return true;   }   }   }

      增加了一个私有方法，检查是否是自己指定的代理，是指定的代理则允许访问，否则不允许访问。我们再来看代理角色，如代码清单12-15所示。

代码清单12-15 强制代理的代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

public class GamePlayerProxy implements IGamePlayer {   private IGamePlayer gamePlayer = null;   //构造函数传递用户名   public GamePlayerProxy(IGamePlayer _gamePlayer){   this.gamePlayer = _gamePlayer;   }   //代练杀怪   public void killBoss() {   this.gamePlayer.killBoss();   }   //代练登录   public void login(String user, String password) {   this.gamePlayer.login(user, password);   }   //代练升级   public void upgrade() {   this.gamePlayer.upgrade();   }   //代理的代理暂时还没有,就是自己   public IGamePlayer getProxy(){   return this;   }   }

      代理角色也可以再次被代理，这里我们就没有继续延伸下去了，查找代理的方法就返回自己的实例。代码都写完毕了，我们先按照常规的思路来运行一下，直接new一个真实角色，如代码清单12-16所示。

代码清单12-16 直接访问真实角色

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

public class Client {   public static void main(String[] args) {   //定义个游戏的角色   IGamePlayer player = new GamePlayer("张三");   //开始打游戏，记下时间戳   System.out.println("开始时间是：2009-8-25 10:45");   player.login("zhangSan","password");   //开始杀怪   player.killBoss();   //升级   player.upgrade();   //记录结束游戏时间   System.out.println("结束时间是：2009-8-26 03:40");   }   }

      想想看能运行吗？运行结果如下所示：

开始时间是：2009-8-25 10:45

请使用指定的代理访问

请使用指定的代理访问

请使用指定的代理访问

结束时间是：2009-8-26 03:40

      它要求你必须通过代理来访问，你想要直接访问它，门儿都没有，好，你要我通过代理来访问，那就生产一个代理，如代码清单12-17所示。

代码清单12-17 直接访问代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

public class Client {   public static void main(String[] args) {   //定义个游戏的角色   IGamePlayer player = new GamePlayer("张三");   //然后再定义一个代练者   IGamePlayer proxy = new GamePlayerProxy(player);   //开始打游戏，记下时间戳   System.out.println("开始时间是：2009-8-25 10:45");   proxy.login("zhangSan","password");   //开始杀怪   proxy.killBoss();   //升级   proxy.upgrade();   //记录结束游戏时间   System.out.println("结束时间是：2009-8-26 03:40");   }   }

      这次能访问吗？还是不行，结果如下所示：

开始时间是：2009-8-25 10:45

请使用指定的代理访问

请使用指定的代理访问

请使用指定的代理访问

结束时间是：2009-8-26 03:40

      同样是不能访问，为什么呢？它不是真实角色指定的对象，这个代理对象是你自己new出来的，当然真实对象不认了，这就好比是那个明星，人家已经告诉你去找她的代理人了，你随便找个代理人能成吗？你必须去找她指定的代理才成！我们修改一下场景类，如代码清单12-18所示。

代码清单12-18 强制代理的场景类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

public class Client {   public static void main(String[] args) {   //定义个游戏的角色   IGamePlayer player = new GamePlayer("张三");   //获得指定的代理   IGamePlayer proxy = player.getProxy();   //开始打游戏，记下时间戳   System.out.println("开始时间是：2009-8-25 10:45");   proxy.login("zhangSan","password");   //开始杀怪   proxy.killBoss();   //升级   proxy.upgrade();   //记录结束游戏时间   System.out.println("结束时间是：2009-8-26 03:40");   }   }

      运行结果如下：

开始时间是：2009-8-25 10:45

登录名为zhangSan 的用户 张三登录成功！

张三在打怪！

张三 又升了一级！

结束时间是：2009-8-26 03:40

      OK，可以正常访问代理了。强制代理的概念就是要从真实角色查找到代理角色，不允许直接访问真实角色，高层模块只要调用getProxy就可以访问真实角色的所有方法，它根本就不需要产生一个代理出来，代理的管理已经由真实角色自己完成。

6.3 代理是有个性的

一个类可以实现多个接口，完成不同任务的整合，那也就是说代理类不仅仅可以实现主题接口，也可以实现其他接口完成不同的任务，而且代理的目的是在目标对象方法的基础上作增强，这种增强的本质通常就是对目标对象的方法进行拦截和过滤，例如游戏代理是需要收费的，升一级需要5元钱，这个计算功能就是代理类的个性，它应该在代理的接口中定义，如图12-6所示。

图12-6 代理类的个性

      增加了一个IProxy接口，其作用是计算代理的费用，否则代理公司不是亏死了，我们先来看IProxy接口，如代码清单12-19所示。

代码清单12-19 代理类的接口

1 2 3 4 5 6 7

public interface IProxy {   //计算费用   public void count();   }

      仅仅一个方法，非常简单，看GamePlayerProxy来的变化，如代码清单12-20所示。

代码清单12-20 代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

public class GamePlayerProxy implements IGamePlayer,IProxy {   private IGamePlayer gamePlayer = null;   //通过构造函数传递要对谁进行代练   public GamePlayerProxy(IGamePlayer _gamePlayer){   this.gamePlayer = _gamePlayer;   }   //代练杀怪   public void killBoss() {   this.gamePlayer.killBoss();   }   //代练登录   public void login(String user, String password) {   this.gamePlayer.login(user, password);   }   //代练升级   public void upgrade() {   this.gamePlayer.upgrade();   this.count();   }   //计算费用   public void count(){   System.out.println("升级总费用是：150元");   }   }

      实现了IProxy接口，同时在upgrade方法中调用该方法，完成费用结算，其他的类都没有任何改动，运行结果如下：

开始时间是：2009-8-25 10:45

登录名为zhangSan 的用户 张三登录成功！

张三在打怪！

张三 又升了一级！

升级总费用是：150元

结束时间是：2009-8-26 03:40

      好了，代理公司也赚钱了，我的游戏也升级了，皆大欢喜。代理类不仅仅是都可以有自己的运算方法，通常的情况下代理的职责并不一定单一，它可以组合其他的真实角色，也可以实现自己的职责，比如计算费用。代理类可以为真实角色预处理消息、过滤消息、消息转发、事后处理消息等功能，当然一个代理类，可以代理多个真实角色，并且真实角色之间可以有耦合关系，读者可以自行扩展一下。

6.4 虚拟代理

虚拟代理(Virual Proxy)：在需要时候才初始化主题对象，可以避免被代理对象较多而引起的初始化缓慢的问题，其缺点是需要在每个方法中判断主题对象是否被创建。

虚拟代理(Virual Proxy)听着很复杂，其实非常简单，我们只要把代理模式的通用代码稍微修改一下就成为虚拟代理，修改后的代理类如代码清单12-21所示。

代码清单12-21 虚拟代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public  class  Proxy implements Subject {   //要代理哪个实现类   private  Subject subject;   //实现接口中定义的方法   public  void  request() {   //判断一下真实主题是否初始化   if (subject == null ){   subject = new  RealSubject();   }   subject.request();   }   }

6.5 动态代理

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

面向横切面编程，也就是AOP（AspectOriented Programming），其核心就是采用了动态代理机制。

还是以打游戏为例，类图修改一下以实现动态代理，如图12-7所示。

图12-7 动态代理

      在类图中增加了一个InvocationHanlder接口和GamePlayIH类，作用就是产生一个对象的代理对象，其中InvocationHanlder是JDK提供的动态代理接口，对被代理类的方法进行代理。我们来看程序，接口保持不变，实现类也没有变化，请参考代码清单12-1、12-2所示。我们来看DynamicProxy类，如代码清单12-22所示。

代码清单12-22 动态代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

public class GamePlayIH implements InvocationHandler {   //被代理者   Class cls =null;   //被代理的实例   Object obj = null;   //我要代理谁   public GamePlayIH(Object _obj){   this.obj = _obj;   }   //调用被代理的方法   public Object invoke(Object proxy, Method method, Object[] args)   throws Throwable {   Object result = method.invoke(this.obj, args);   return result;   }   }

      其中invoke方法是接口InvocationHandler定义必须实现的，它完成对真实方法的调用。我们来详细讲解一下InvocationHanlder接口，动态代理是根据被代理的接口生成所有的方法，也就是说给定一个接口，动态代理会宣称“我已经实现该接口下的所有方法了”，那各位读者想想看，动态代理怎么才能实现被代理接口中的方法呢？默认情况下所有的方法返回值都是空的，是的，代理已经实现它了，但是没有任何的逻辑含义，那怎么办？好办，通过InvocationHandler接口，所有方法都由该Handler来进行处理，即所有被代理的方法都由InvocationHandler接管实际的处理任务。

      我们接下来看看场景类，如代码清单12-23所示。

代码清单12-23 动态代理的场景类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

public class Client {   public static void main(String[] args) throws Throwable {   //定义一个痴迷的玩家   IGamePlayer player = new GamePlayer("张三");   //定义一个handler   InvocationHandler handler = new GamePlayIH(player);   //开始打游戏，记下时间戳   System.out.println("开始时间是：2009-8-25 10:45");   //获得类的class loader   ClassLoader cl = player.getClass().getClassLoader();   //动态产生一个代理者   IGamePlayer proxy = (IGamePlayer)Proxy.newProxyInstance(cl,new Class[]{IGamePlayer.class},handler);   //登录   proxy.login("zhangSan","password");   //开始杀怪   proxy.killBoss();   //升级   proxy.upgrade();   //记录结束游戏时间   System.out.println("结束时间是：2009-8-26 03:40");   }   }

      很奇怪是吗？不要着急，学习是一个循序渐进的过程，继续看下去，我知道你的疑惑了。其运行结果如下：

开始时间是：2009-8-25 10:45

登录名为zhangSan 的用户 张三登录成功！

张三在打怪！

张三 又升了一级！

结束时间是：2009-8-26 03:40

      我们还是让代练者帮我们打游戏，但是我们既没有创建代理类，也没有实现IGamePlayer接口，这就是动态代理。别急，动态代理可不仅仅就这么多内容，还有更重要的，如果我们想在游戏登陆后发一个信息给我，防止账号被人盗用嘛，该怎么处理？直接修改被代理类GamePlayer？这不是一个好办法，好办法如代码清单12-24所示。

代码清单12-24 修正后的动态代理

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

public class GamePlayIH implements InvocationHandler {   //被代理者   Class cls =null;   //被代理的实例   Object obj = null;   //我要代理谁   public GamePlayIH(Object _obj){   this.obj = _obj;   }   //调用被代理的方法   public Object invoke(Object proxy, Method method, Object[] args)   throws Throwable {   Object result = method.invoke(this.obj, args);   //如果是登录方法，则发送信息   if(method.getName().equalsIgnoreCase("login")){   System.out.println("有人在用我的账号登陆！");   }   return result;   }   }

      看黑体部分，只要在代理中增加一个判断就可以决定是否要发送信息，运行结果如下：

开始时间是：2009-8-25 10:45

登录名为zhangSan 的用户 张三登录成功！

有人在用我的账号登陆！

张三在打怪！

张三 又升了一级！

结束时间是：2009-8-26 03:40

      That’s very nice。 有人用我的账号就发送一个信息，然后看看自己的账号是不是被人盗了，非常好的方法，这就是AOP编程，AOP编程没有使用什么新的技术，但是它对我们的设计、编码有非常大的影响，对于日志、事务、权限等都可以在系统设计阶段不用考虑，而在设计后通过AOP的方式切过去。既然动态代理是如此的诱人，我们来看看通用动态代理模型，类图如图12-7所示。

图12-8 动态代理通用类图

      很简单，两条独立发展的线路，动态代理实现代理的职责，业务逻辑Subject实现相关的逻辑功能，两者之间没有必然的相互耦合的关系，通知Advice从另一个切面切入，最终在高层模块也就是Client进行耦合，完成逻辑的封装任务，我们先来看Subject接口，如代码清单12-25所示。

代码清单12-25 抽象主题

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public interface Subject {   //业务操作   public void doSomething(String str);   }   其中的doSomething是一个标示方法，可以有多个逻辑处理方法，实现类如代码清单12-25所示。   代码清单12-26 真实主题   public class RealSubject implements Subject {   //业务操作   public void doSomething(String str) {   System.out.println("do something!---->" + str);   }   }

      重点是我们的MyInvocationHandler，如代码清单12-27所示。

代码清单12-27 动态代理的Handler类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public class MyInvocationHandler implements InvocationHandler {   //被代理的对象   private Object target = null;   //通过构造函数传递一个对象   public MyInvocationHandler(Object _obj){   this.target = _obj;   }   //代理方法   public Object invoke(Object proxy, Method method, Object[] args)   throws Throwable {   //执行被代理的方法   return method.invoke(this.target, args);   }   }

      非常简单，所有通过动态代理实现的方法全部通过invokve方法调用。DynamicProxy代码如代码清单12-28所示。

代码清单12-28 动态代理类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public class DynamicProxy<T> {   public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){   //寻找JoinPoint连接点，AOP框架使用元数据定义   if(true){   //执行一个前置通知   (new BeforeAdvice()).exec();   }   //执行目标，并返回结果   return (T)Proxy.newProxyInstance(loader,interfaces, h);   }   }

      在这里插入了较多的AOP术语，在什么地方（连接点）执行什么行为（通知），我们在这里实现了一个简单的横切面编程，读者有经验的话可以看看AOP的配置文件就会明白这段代码的意义了。我们来看通知Advice，也就是我们要切入的类，比较简单，接口和实现如代码清单12-29所示。

代码清单12-29 通知接口及实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public interface IAdvice {   //通知只有一个方法，执行即可   public void exec();   }   public class BeforeAdvice implements IAdvice{   public void exec(){   System.out.println("我是前置通知，我被执行了！");   }   }

      最后就是看我们怎么调用了，如代码清单12-30所示。

代码清单12-30 动态代理的场景类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public class Client {   public static void main(String[] args) {   //定义一个主题   Subject subject = new RealSubject();   //定义一个Handler   InvocationHandler handler = new MyInvocationHandler(subject);   //定义主题的代理   Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(),handler);   //代理的行为   proxy.doSomething("Finish");   }   }

      运行结果如下所示：

我是前置通知，我被执行了！

do something!---->Finish

      好，所有的程序都看完了，我们回过头来看看程序是怎么实现的。在DynamicProxy类中，我们有这样的方法：

      this.obj = Proxy.newProxyInstance(c.getClassLoader(), c.getInterfaces(), new MyInvocationHandler(_obj));

      该方法是重新生成了一个对象，为什么要重新生成？你要使用代理呀，注意c.getInterfaces()这句话，这是非常有意思的一句话，是说查找到该类的所有接口，然后实现接口的所有方法，当然了，方法都是空的，由谁具体负责接管呢？是new MyInvocationHandler(_Obj)这个对象，于是清楚了：一个类的动态代理类是这样的一个类，由InvocationHandler的实现类实现所有的方法，由其invoke方法接管所有方法的实现，其动态调用过程如图12-9所示。

图12-9 动态代理调用过程示意图

      读者可能注意到我们以上的代码还有更进一步的扩展余地，那当然了，注意看DynamicProxy类，它是一个通用类，不具有业务意义，如果我们再产生一个实现类是不是就很有意义了呢？如代码清单12-31所示。

代码清单12-31 具体业务的动态代理

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public class SubjectDynamicProxy extends DynamicProxy{   public static <T> T newProxyInstance(Subject subject){   //获得ClassLoader   ClassLoader loader = subject.getClass().getClassLoader();   //获得接口数组   Class<?>[] classes = subject.getClass().getInterfaces();   //获得handler   InvocationHandler handler = new MyInvocationHandler(subject);   return newProxyInstance(loader, classes, handler);   }   }

      如此扩展以后，高层模块对代理的访问会更加简单，如代码清单12-32所示。

代码清单12-32 场景类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class Client {   public static void main(String[] args) {   //定义一个主题   Subject subject = new RealSubject();   //定义主题的代理   Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);   //代理的行为   proxy.doSomething("Finish");   }   }

      是不是更加简单了？可能读者就要提问了，这样与静态代理还有什么区别？都是需要实现一个代理类，有区别，注意看父类，动态代理的主要意图就是解决我们常说的“审计”问题，也就横切面编程，在不改变我们已有代码结构的情况下增强或控制对象的行为。

      注意 要实现动态代理的首要条件是：被代理类必须实现一个接口，回想一下刚刚的分析吧。当然了，现在也有很多技术如CGLIB可以实现不需要接口也可以实现动态代理的方式。

      再次说明，以上的动态代理是一个通用代理框架，如果你想设计自己的AOP框架，完全可以在此基础上扩展，我们设计的是一个通用代理，只要有一个接口，一个实现类，就可以使用该代理，完成代理的所有功效。

7 范例

读大学的时候都追过女生吧！某天你看到一位美女，一见钟情，心里发誓要她做你女朋友。但是你想这样直接上去可能会唐突了。于是你采用迂回政策，先和她室友搞好关系，然后通过她室友给她礼物，然后……。

       首先出现的就是美女一枚：BeautifulGirl.java

[java] view plaincopyprint?

1. public class BeautifulGirl {  
2.     String name;  
3.       
4.     public BeautifulGirl(String name){  
5.         this.name = name;  
6.     }  
7.   
8.     public String getName() {  
9.         return name;  
10.     }  
11.   
12.     public void setName(String name) {  
13.         this.name = name;  
14.     }  
15.       
16. }  

       然后是抽象主题，送礼物接口：GiveGift.java

[java] view plaincopyprint?

1. public interface GiveGift {  
2.     /** 
3.      * 送花 
4.      */  
5.     void giveFlowers();  
6.       
7.     /** 
8.      * 送巧克力 
9.      */  
10.     void giveChocolate();  
11.       
12.     /** 
13.      * 送书 
14.      */  
15.     void giveBook();  
16. }  

       你小子：You.java

[java] view plaincopyprint?

1. public class You implements GiveGift {  
2.     BeautifulGirl mm ;     //美女  
3.       
4.     public You(BeautifulGirl mm){  
5.         this.mm = mm;  
6.     }  
7.       
8.   
9.     public void giveBook() {  
10.         System.out.println(mm.getName() +",送你一本书....");  
11.     }  
12.   
13.     public void giveChocolate() {  
14.         System.out.println(mm.getName() + ",送你一盒巧克力....");  
15.     }  
16.   
17.     public void giveFlowers() {  
18.         System.out.println(mm.getName() + ",送你一束花....");  
19.     }  
20.   
21. }  

       她闺蜜室友：HerChum.java

[java] view plaincopyprint?

1. public class HerChum implements GiveGift{  
2.   
3.     You you;  
4.       
5.     public HerChum(BeautifulGirl mm){  
6.         you = new You(mm);  
7.     }  
8.       
9.     public void giveBook() {  
10.         you.giveBook();  
11.     }  
12.   
13.     public void giveChocolate() {  
14.         you.giveChocolate();  
15.     }  
16.   
17.     public void giveFlowers() {  
18.         you.giveFlowers();  
19.     }  
20.   
21. }  

       客户端：Client.java

[java] view plaincopyprint?

1. public class Client {  
2.     public static void main(String[] args) {  
3.         BeautifulGirl mm = new BeautifulGirl("小屁孩...");  
4.           
5.         HerChum chum = new HerChum(mm);  
6.           
7.         chum.giveBook();  
8.         chum.giveChocolate();  
9.         chum.giveFlowers();  
10.     }  
11. }  

       运行结果

       小屁孩...,送你一本书....

       小屁孩...,送你一盒巧克力....

       小屁孩...,送你一束花....

       好了礼物已经送出去了，能不能搞定就看你的魅力了！！！！