设计模式—静态代理模式（聚合与继承方式比较）

代理模式：

为某个对象提供一个代理，以控制对这个对象的访问。 代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

静态代理模式：

由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

一、概述

1.目标：要在Tank的move()方法做时间代理及日志代理(可以设想以后还要增加很多代理处理)，且代理间的顺序可活更换

2.思路：

(1)聚合：代理类聚合了被代理类，且代理类及被代理类都实现了movable接口，则可实现灵活多变，具体看代码

(2)继承：继承不够灵活，随着功能需求增多，继承体系会非常臃肿。具体看代码

二、代码

1.Movable.java

2.Tank.java

3.TankTimeProxy.java

4.TankLogProxy.java

5.Tank2Time.java

6.Tank3Log.java

7.Client.java

1.Movable.java

1 public interface Movable {
2     public void move();
3 }

2.Tank.java

 1 import java.util.Random;
 2 
 3 public class Tank implements Movable {
 4 
 5     @Override
 6     public void move() {
 7         System.out.println("Tank moving.......");
 8         try {
 9             Thread.sleep(new Random().nextInt(5000));
10         } catch (InterruptedException e) {
11             e.printStackTrace();
12         }
13     }
14 
15 }

3.TankTimeProxy.java

 1 public class TankTimeProxy implements Movable {
 2 
 3     Movable m;
 4     
 5     public TankTimeProxy(Movable m) {
 6         this.m = m;
 7     }
 8 
 9     @Override
10     public void move() {
11         System.out.println("Time Proxy start...........");
12         long start = System.currentTimeMillis();
13         m.move();
14         long end = System.currentTimeMillis();
15         System.out.println("花费时间："+(end - start));
16         System.out.println("Time Proxy end...........");
17     }
18 
19 }

4.TankLogProxy.java

 1 public class TankLogProxy implements Movable {
 2 
 3     Movable m;
 4     
 5     public TankLogProxy(Movable m) {
 6         this.m = m;
 7     }
 8 
 9     @Override
10     public void move() {
11         System.out.println("Log Proxy start...........");
12         m.move();
13         System.out.println("Log Proxy end...........");
14     }
15 
16 }

5.Tank2Time.java

 1 public class Tank2Time extends Tank {
 2 
 3     public void move(){
 4         System.out.println("Tank2 time  start...........");
 5         long start = System.currentTimeMillis();
 6         super.move();
 7         long end = System.currentTimeMillis();
 8         System.out.println("花费时间："+(end - start));
 9         System.out.println("Tank2 time end...........");
10     }
11 }

6.Tank3Log.java

1 public class Tank3Log extends Tank2Time {
2 
3     public void move(){
4         System.out.println("Tank3Log  start...........");
5         super.move();
6         System.out.println("Tank3Log  end...........");
7     }
8 }

7.Client.java

 1 public class Client {
 2 
 3     @Test
 4     public void testProxy(){
 5         
 6         Tank t = new Tank();
 7         Movable m;
 8         
 9         //一、聚合的方式(较灵活，因为实现了接口)
10         //1.1聚合方式的代理,先日志代理，后时间代理
11         TankTimeProxy ttp1 = new TankTimeProxy(t);
12         TankLogProxy tlp1 = new TankLogProxy(ttp1);
13         
14         m = tlp1;
15         m.move();
16         
17         System.out.println("
==============================分隔线==========================
");
18         
19         //1.2聚合方式的代理,先时间代理，后日志代理(可以灵活切换顺序)
20         TankLogProxy tlp2 = new TankLogProxy(t);
21         TankTimeProxy ttp2 = new TankTimeProxy(tlp2);
22         
23         m = ttp2;
24         m.move();
25         
26         System.out.println("
==============================分隔线==========================
");
27         
28         //二、继承的方式
29         //2.1代理时间
30         Tank2Time t2 = new Tank2Time();
31         t2.move();
32         
33         System.out.println("
==============================分隔线==========================
");
34         
35         //2.2先代理日志，后时间，不能灵活切换
36         Tank3Log t3 = new Tank3Log();
37         t3.move(); 
41     }
42 }

三、运行结果

因为每个代理都实现了同一movable接口，代理和被代理对象之间都可以相互灵活转换，以实现代理功能之间的灵活叠加组合。

 静态代理类优缺点
优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。
缺点：
1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

另外，如果要按照上述的方法使用代理模式，那么真实角色(委托类)必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色（委托类），该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。