设计模式感触之代理模式应用

设计模式感触之代理模式应用

 转自：http://jiangshuiy.iteye.com/blog/1333558

如果说看完设计模式之后，哪个模式最让我印象深刻和半醉半醒，那一定就是代理模式（Proxy）。代理模式看似非常简单，很直接，应用的也很广泛，然而，放下书，去使用的时候，可能是由于动态代理和远程代理实现的细节还没弄清，忽然发现，代理模式究竟为哪般还是模糊的。此处记录和总结下我所理解的代理模式，本部分主要是基础部分。

 

1 面向对象设计之路---使用面向对象设计原则

1.1 初始设计

学习程序设计，还是以程序的语言来说吧：

我们有一个接口Callable：

 

Java代码  

1. public interface Callable {  
2.     public void call();  
3. }  

  

现在我们有一个实现类Phone：

 

Java代码  

1. public class Phone implements Callable {  
2.     @Override  
3.     public void call() {  
4.         System.out.println("Phone is calling ...");  
5.     }  
6.     //Other Phone methods  
7. }  

 

OK，现在工作的很好，能完成要求的所有功能。

 

1.2 需求扩展

这时候，出现了一个新的需求，就是需要对Phone的所有动作进行计时，以对最终的收费提供依据，这时候有三种解决方案：

A 如果有源码，直接修改Phone类：一种可能的实现可能是如下形式：

 

Java代码  

1. public class Phone implements Callable {  
2.     @Override  
3.     public void call() {  
4.         long startTime = System.currentTimeMillis();  
5.         System.out.println("Phone is calling ...");  
6.         long endTime = System.currentTimeMillis();  
7.         System.out.println("Call duration = " + (endTime - startTime));  
8.     }  
9.     //Other Phone methods  
10. }  

 

B不幸的是，我们没有源代码可以修改，可以采用继承的方式来解决：可能的实现如下：

 

Java代码  

1. public class Phone2 extends Phone {  
2.     @Override  
3.     public void call() {  
4.         long startTime = System.currentTimeMillis();  
5.         super.call();  
6.         long endTime = System.currentTimeMillis();  
7.         System.out.println("Call duration = " + (endTime - startTime));  
8.     }  
9. }  

 

C 除开A、B之外，我们还有一种方式来达到目的，那就是使用聚合来完成：示例如下

 

Java代码  

1. public class Phone3 implements Callable {  
2.     private Callable phone;  
3.    
4.     public Phone3(Callable phone) {  
5.         this.phone = phone;  
6.     }  
7.    
8.     @Override  
9.     public void call() {  
10.         long startTime = System.currentTimeMillis();  
11.         phone.call();  
12.         long endTime = System.currentTimeMillis();  
13.         System.out.println("Call duration = " + (endTime - startTime));  
14.     }  
15. }  

 

A、B、C三种方法对比，很容易发现：

A的做法最是糟糕，完全破坏了伟大程序员缔造伟大程序的美感，破坏了面向对象设计的第一大原则：开闭原则：软件实体应该对扩展开放，对修改关闭。OK，类似于A的做法以后不再出现了。

 

B的做法使用了面向对象语言里面的继承，相对于A来说，那是大大的进化了，也没有破坏开闭原则，但有一点，如果我们需要对Phone的call职责再加强一下，需要记录日志，那么采用继承的话，在Java中由于只支持单继承，因此需要再次从Phone2继承，容易造成类的爆炸，如此下去，会造成很多很多类和很长很长的继承链。

 

C的做法采用了对象聚合，在解决上述的新问题时，只需要再次聚合下Phone3就可以解决了，聚合比继承更好的优势主要体现在扩展性上，继承不够灵活，能更好的提高类的复用性。这也是面向对象设计的一大原则之一：合成/聚合复用原则：尽量使用合成/聚合，尽量不要使用继承。

 

仔细观察，聚合为什么会具有更强的能力呢，这里主要是在Phone3里面传入的是Callable接口，因此非常灵活，其实这是另外一个面向对象设计原则：依赖反转原则：要依赖于抽象，不要依赖与具体。另外一种说法是：要针对接口编程，不要针对实现编程。

 

2 代理模式的基本形式

代理，按其字面意义来说，就是指代替其他人做他们该做的事情，广泛的来讲，上述的继承和聚合方式实现都是代理的形式，继承中，子类将call的行为交给父类处理，聚合中，将具体的call行为交给引用的类处理。

在GoF提出的设计模式中，代理模式是这样定义的：

对其他对象提供一种代理以控制对这个对象的访问。

它的UML模型如下：

由此可见，代理与真实对象实现了同一个接口，对真实对象的请求事实上是通过代理来处理的。也可以说明前面所述的继承与聚合事实上也是一种代理。

 

3 代理模式的应用形式

远程代理：可以为一个不同的地址空间的对象提供一个局域代表对象；

虚拟代理：根据需要创建一个资源消耗较大的对象，使得此对象只在需要时才会被真正创建；

保护代理：基于访问权限可以控制对一个对象的访问；

…

 

4 代理模式的动态代理

上面所述的都属于静态代理，但代理模式的一大犀利之处就是其也能实现动态代理，即在运行时动态决定真实的被代理对象。

Java自身提供了实现动态代理的结构，自定义动态代理类，只需要使用java.lang.reflect包下面的InvocationHandler, Proxy和Method三个类就可以了，下面看一个简单的例子：

 

Java代码  

1. public class FirstInvocationHandler implements InvocationHandler {  
2.     private Object o;  
3.    
4.     public FirstInvocationHandler(Object phone) {  
5.         this.o = phone;  
6.     }  
7.    
8.     @Override  
9.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
10.         System.out.println("Invoke start!");  
11.         method.invoke(o, args);  
12.         System.out.println("Invoke completed!");  
13.         return null;  
14.     }  
15. }  

 

 

下面只需要调用就可以了，给个测试例子：

 

Java代码  

1. public class TestJavaProxy {  
2.    
3.     public static void main(String[] args) {  
4.         Phone phone = new Phone();  
5.         Callable proxyPhone = (Callable) Proxy.newProxyInstance(phone.getClass().getClassLoader(), phone.getClass().getInterfaces(), new FirstInvocationHandler(phone));  
6.         proxyPhone.call();  
7.          
8.         Date date = new Date();  
9.         Serializable proxyDate = (Serializable)Proxy.newProxyInstance(date.getClass().getClassLoader(), date.getClass().getInterfaces(), new FirstInvocationHandler(date));  
10.         proxyDate.toString();  
11.     }  
12. }  

 

通过例子，将可以发现，我们可以自由实现我们需要的代理，只需要能传递正确的classLoader、interfaces和args，就能被代理到，这对于具有通用增强功能方法的尤其有意义，比如在典型的日志记录、事务管理、权限等控制上非常灵活。

 

5 代理模式的其他

本节主要论述代理模式中的一些应用，对JDK的动态代理也做了一些例子，关于更深层次的代理感触请查看下一节。