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

 

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

 

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

 

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

1.1 初始设计

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

我们有一个接口Callable：

 

public interface Callable {
    public void call();
}

  

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

 

public class Phone implements Callable {
    @Override
    public void call() {
        System.out.println("Phone is calling ...");
    }
    //Other Phone methods
}

 

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

 

1.2 需求扩展

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

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

 

public class Phone implements Callable {
    @Override
    public void call() {
        long startTime = System.currentTimeMillis();
        System.out.println("Phone is calling ...");
        long endTime = System.currentTimeMillis();
        System.out.println("Call duration = " + (endTime - startTime));
    }
    //Other Phone methods
}

 

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

 

public class Phone2 extends Phone {
    @Override
    public void call() {
        long startTime = System.currentTimeMillis();
        super.call();
        long endTime = System.currentTimeMillis();
        System.out.println("Call duration = " + (endTime - startTime));
    }
}

 

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

 

public class Phone3 implements Callable {
    private Callable phone;
 
    public Phone3(Callable phone) {
        this.phone = phone;
    }
 
    @Override
    public void call() {
        long startTime = System.currentTimeMillis();
        phone.call();
        long endTime = System.currentTimeMillis();
        System.out.println("Call duration = " + (endTime - startTime));
    }
}

 

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三个类就可以了，下面看一个简单的例子：

 

public class FirstInvocationHandler implements InvocationHandler {
    private Object o;
 
    public FirstInvocationHandler(Object phone) {
        this.o = phone;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Invoke start!");
        method.invoke(o, args);
        System.out.println("Invoke completed!");
        return null;
    }
}

 

 

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

 

public class TestJavaProxy {
 
    public static void main(String[] args) {
        Phone phone = new Phone();
        Callable proxyPhone = (Callable) Proxy.newProxyInstance(phone.getClass().getClassLoader(), phone.getClass().getInterfaces(), new FirstInvocationHandler(phone));
        proxyPhone.call();
       
        Date date = new Date();
        Serializable proxyDate = (Serializable)Proxy.newProxyInstance(date.getClass().getClassLoader(), date.getClass().getInterfaces(), new FirstInvocationHandler(date));
        proxyDate.toString();
    }
}

 

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

 

5 代理模式的其他

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

评论

2 楼 RainWu 2015-06-16  

1 楼 ch_dj 2014-06-24  

面向对象涉及原则：
1.开闭原则
2.少用继承，多用聚合
3.针对接口编程，不用实现类 编程