代理模式和装饰者模式

简介

代理模式和装饰者模式是两种常见的设计模式。代理模式是为其它对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰者来包裹真实的对象。

因为这两种模式比较相似，所以把它们放在一起做个比较与总结。

代理模式

代理模式包含代理对象和被代理对象，类图如下：

代理对象 Proxy 和被代理对象 RealSubject 都继承了 Subject 接口。客户端调用 Proxy 的方法，而 Proxy 则把具体操作委托给 RealSubject 执行。下面是代码实现：

interface Subject {
    void doAction();
}

class RealSubject implements Subject {

    @Override
    public void doAction() {
        System.out.println("RealSubject#doAction");
    }
}

class Proxy implements Subject {
    private Subject subject;

    public Proxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void doAction() {
        subject.doAction();
    }
}

public class Client {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxy = new Proxy(realSubject);
        proxy.doAction();
    }
}

输出：RealSubject#doAction

在 Client 中，首先创建了一个 realSubject 对象，然后创建一个代理对象 proxy 并且把 realSubject
对象通过构造器传入进去。最后调用代理对象的 doAction，实际执行的是 realSubject 的对应方法。这里通过构造函数的参数将被代理对象传入到代理中，也可以通过其它方式，如提供一个 setSubject 方法。

上面的代理模式，代理对象和被代理对象需要实现相同的接口，所以如果要代理其它接口的对象需要写一个新的代理类。Java 提供了动态代理的功能，可以简化我们的代码。

动态代理

动态代理可以在运行期生成所需要的代理对象，看下面的代码：

class DynamicProxy implements InvocationHandler {
    // 被代理对象的引用
    private Object obj;

    public DynamicProxy(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(obj, args);
        return result;
    }
}

类 DynamicProxy 实现了 InvocationHandler 接口，这个接口中有一个 invoke 方法，被代理的对象的任何方法都是在 invoke 中调用。下面是 Client 的代码：

public class TestDelegate {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();

        DynamicProxy dynamicProxy = new DynamicProxy(realSubject);
        ClassLoader loader = realSubject.getClass().getClassLoader();
        Subject proxy = (Subject) Proxy.newProxyInstance(loader, new Class[]{Subject.class}, dynamicProxy);

        proxy.doAction();
    }
}

输出：RealSubject#doAction

首先依然是先创建一个需要被代理的对象 realSubject，然后把它传入到 DynamicProxy 的构造函数中。这个 dynamicProxy 还不是我们需要的代理，毕竟它没有实现 Subject 接口。下面通过 Proxy.newProxyInstance 创建了一个 Subject 对象，也就是最终的代理对象。

通过动态代理，创建一个实现了 InvocationHandler 接口的 DynamicProxy 类，通过这个类可以在运行期为各种对象创建对应的代理，比静态代理方便了很多。

装饰者模式

装饰者模式是为了给已有的对象增加一些逻辑，但是不改变已有对象的代码，下面是类图：

从上图可以看出，装饰者 Decorator与需要被装饰的对象 ContcreteComponent 实现了相同的接口。具体怎么装饰则由 Decorator 的子类 ConcreteDecorator 决定。

Java 中使用装饰者模式的一个典型的例子是 I/O 对象的创建，比如创建一个 BufferedInputStream 时：

InputStream in = ...
InputStream input = new BufferedInputStream(in);

BufferedInputStream 继承于 FilterInputStream，这个 FilterInputStream 相当于装饰者模式中的 Decorator，它继承了 InputStream 接口。BufferedInputStream 则是一个具体的装饰类，其它还有 DataInputStream 以及 ByteArrayInputStream 等。而传给 BufferedInputstream 的对象 in 则是需要被装饰者。装饰者对被装饰者进行了功能的扩展，但是又不需要修改被装饰者的相应代码，符合“开闭原则”，即对于修改是封闭的，对于扩展则是开放的。

如果是为了给某个类提供更多的功能，继承是一种方案。但是，如果我们的功能有很多种组合，那么为每种组合编写一个继承的类可能需要创建太多的子类。而装饰者模式则可以解决这个问题，只需要为每个功能编写一个装饰类，在运行时组合不同的对象即可实现所需的功能组合。

总结

代理模式和装饰者模式有着很多的应用，这两者具有一定的相似性，都是通过一个新的对象封装原有的对象。二者之间的差异在于代理模式是为了实现对象的控制，可能被代理的对象难以直接获得或者是不想暴露给客户端，而装饰者模式是继承的一种替代方案，在避免创建过多子类的情况下为被装饰者提供更多的功能。

如果我的文章对您有帮助，不妨点个赞支持一下(^_^)