最近看了马士兵老师的设计模式视频，感觉其中最难也最感兴趣的就是代理模式了。马士兵老师从静态代理的两种基本方式出发，到初步实现指定接口的动态代理，最后到模仿 JDK 的动态代理，讲的都很详细。现在我来给大家梳理一下整个思路，希望对大家有所帮助。

1. 想要看懂动态代理所需要具备的知识：

   • 需要对 java 语法有基本的了解
   • 需要初步具备对面向对象编程思想的设计思想
   • 了解多态的概念。

2. 什么是代理模式？
   代理模式 (Proxy Pattern) ：给某一个对象提供一个代 理，并由代理对象控制对原对象的引用。代理模式的英 文叫 做Proxy 或 Surrogate，它是一种对象结构型模式。

   这里给出一个例子：假设现在有 Tank 这个类,其继承了 Moveable 接口，里面有一个 move() 方法，现在需要统计这个方法的运行时间，要求不能改变这个类的源代码，问有几种实现方式？

   moveable 接口 ：

   package proxy;
   
   public interface Moveable  {
       void move() ;
   }
   

   Tank 类:

   package proxy;
   
   public class Tank implements Moveable {
       @Override
       public void move() throws InterruptedException {
       System.out.println("Tank moving ...");
       Thread.sleep(10000);
       }
   }
   

   答： 聚合 and 继承

   • 继承：新建一个类 Tank1 继承 Tank,重写其 move() 方法：

   package proxy;
   
   public class Tank1 extends Tank {
       @Override
       public void move() throws InterruptedException {
           long startTime = System.currentTimeMillis() ;
           super.move();
           long endTime = System.currentTimeMillis() ;
           System.out.println("time : " + (endTime - startTime));
       }
   }
   

   • 聚合：新建一个类 Tank2,也实现 Moveable 接口,定义一个 Moveable 的实例变量，调用其 move() 方法，并添加代码

   package proxy;
   
   public class Tank2 implements Moveable{
       public Tank2(Moveable m) {
           this.m = m;
       }
   
       private Moveable m;
   
       @Override
       public void move() throws InterruptedException {
           long startTime = System.currentTimeMillis() ;
           m.move();
           long endTime = System.currentTimeMillis() ;
           System.out.println("time : " + (endTime - startTime));
       }
   }
   
   

   以上的代码就是初步的代理模式。即在不改变被代理对象的前提下，对其里面的方法或字段进行加工处理。

3. 那么问题来了，两种代理模式哪种比较好？
   现在再给出一个需求，我们需要在统计 Tank 对象方法运行时间的基础上，再加一个记录方法运行的日志代理,而后再改变两个代理的前后顺序。

   • 继承实现：

     • 添加一个记录日志代理：再新建一个 Tank3 类，继承 Tank1 类，再重写其 move() 方法
     • 改变两个代理的前后顺序：再新建一个 Tank4 类，继承 Tank 类，先重写 move() 方法添加日志代理，再新建一个 Tank5 类，继承 Tank3 类，再重写 move() 方法添加时间代理。以此类推。

   • 聚合实现：

     • 再添加一个日志代理：新建一个 Tank3 类，实现 Moveable 接口，定义一个 Moveable 类型变量，把代理过的 Tank1 对象传进来，调用其 move() 方法。

     public class Tank6 implements Moveable {
         public Tank6(Moveable m) {
             this.m = m;
         }
     
         private Moveable m ;
     
         @Override
         public void move() throws InterruptedException {
             System.out.println("Log start...");
             m.move();
             System.out.println("Log end ...");
         }
     }
     

     这里给一下客户端 Client 的代码及运行结果：

     
     
     运行结果
     • 改变两个代理的顺序：先把被代理的 tank 对象传给 Tank6 实现日志代理，得到 tankLogProxy 对象，再将其传给 Tank2 实现时间代理。

     这里给一下客户端 Client 的代码及运行结果：

     
     
     运行结果

   到了这里，相信各位已经能看出来了。代理模式的实现，还是聚合的方法比较好，特别是在改变代理顺序的需求下，只需要改变客户端的代理顺序即可，可以避免类的无限扩增。

   ---

代理模式中很重要的一点是多态的应用，我们可以看出来，在 Tank2 和 Tank6 中，我们都是实现的 Moveable 接口，即我们要实现代理的必须是同一类对象，这里也正是我们到目前为止所说的不足之处，即只能实现静态代理，在下一篇，我们实现初步的动态代理。