代理模式VS装饰模式

本文转发自技术世界，原文链接
http://www.jasongj.com/design_pattern/proxy_decorator/
模式介绍

• 代理模式（Proxy Pattern），为其它对象提供一种代理以控制对这个对象的访问。
• 装饰模式（Decorator Pattern），动态地给一个对象添加一些额外的职责。

从语意上讲，代理模式的目标是控制对被代理对象的访问，而装饰模式是给原对象增加额外功能。

类图

代理模式类图如下

装饰模式类图如下

相同部分

代理模式和装饰模式都包含ISubject和ConcreteSubject，并且这两种模式中这两个Component的实现没有任何区别。

ISubject代码如下

public interface ISubject {
  void action();
}

ConcreteSubject代码如下

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ConcreteSubject implements ISubject {
  private static final Logger LOG = LoggerFactory.getLogger(ConcreteSubject.class);
  @Override
  public void action() {
    LOG.info("ConcreteSubject action()");
  }
}

代理类和使用方式

代理类实现方式如下

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Random;
public class ProxySubject implements ISubject {
  private static final Logger LOG = LoggerFactory.getLogger(ProxySubject.class);
  private ISubject subject;
  public ProxySubject() {
    subject = new ConcreteSubject();
  }
  @Override
  public void action() {
    preAction();
    if((new Random()).nextBoolean()){
      subject.action();
    } else {
      LOG.info("Permission denied");
    }
    postAction();
  }
  private void preAction() {
    LOG.info("ProxySubject.preAction()");
  }
  private void postAction() {
    LOG.info("ProxySubject.postAction()");
  }
}

从上述代码中可以看到，被代理对象由代理对象在编译时确定，并且代理对象可能限制对被代理对象的访问。

代理模式使用方式如下

public class StaticProxyClient {
  public static void main(String[] args) {
    ISubject subject = new ProxySubject();
    subject.action();
  }
}

装饰类和使用方式

装饰类实现方式如下

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SubjectPreDecorator implements ISubject {
  private static final Logger LOG = LoggerFactory.getLogger(SubjectPreDecorator.class);
  private ISubject subject;
  public SubjectPreDecorator(ISubject subject) {
    this.subject = subject;
  }
  @Override
  public void action() {
    preAction();
    subject.action();
  }
  private void preAction() {
    LOG.info("SubjectPreDecorator.preAction()");
  }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SubjectPostDecorator implements ISubject {
  private static final Logger LOG = LoggerFactory.getLogger(SubjectPostDecorator.class);
  private ISubject subject;
  public SubjectPostDecorator(ISubject subject) {
    this.subject = subject;
  }
  @Override
  public void action() {
    subject.action();
    postAction();
  }
  private void postAction() {
    LOG.info("SubjectPostDecorator.preAction()");
  }
}

装饰模式使用方法如下

public class DecoratorClient {
  public static void main(String[] args) {
    ISubject subject = new ConcreteSubject();
    ISubject preDecorator = new SubjectPreDecorator(subject);
    ISubject postDecorator = new SubjectPostDecorator(preDecorator);
    postDecorator.action();
  }
}

从上述代码中可以看出，装饰类可装饰的类并不固定，并且被装饰对象是在使用时通过组合确定。如本例中SubjectPreDecorator装饰ConcreteSubject，而SubjectPostDecorator装饰SubjectPreDecorator。并且被装饰对象由调用方实例化后通过构造方法（或者setter）指定。

装饰模式的本质是动态组合。动态是手段，组合是目的。每个装饰类可以只负责添加一项额外功能，然后通过组合为被装饰类添加复杂功能。由于每个装饰类的职责比较简单单一，增加了这些装饰类的可重用性，同时也更符合单一职责原则。

小结

• 从语意上讲，代理模式是为控制对被代理对象的访问，而装饰模式是为了增加被装饰对象的功能
• 代理类所能代理的类完全由代理类确定，装饰类装饰的对象需要根据实际使用时客户端的组合来确定
• 被代理对象由代理对象创建，客户端甚至不需要知道被代理类的存在；被装饰对象由客户端创建并传给装饰对象

上文讲到的代理方式是静态代理。所谓静态代理，是指程序运行前就已经存在了代理类的字节码文件，代理类和被代理类的关系在运行前就已经确定。

动态代理类的字节码是在程序运行期间动态生成，所以不存在代理类的字节码文件。代理类和被代理类的关系是在程序运行时确定的。

JDK动态代理
使用JDK动态代理，需要创建一个实现java.lang.reflect.InvocationHandler接口的类，并在该类中定义代理行为。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SubjectProxyHandler implements InvocationHandler {
  private static final Logger LOG = LoggerFactory.getLogger(SubjectProxyHandler.class);
  private Object target;

  @SuppressWarnings("rawtypes")
  public SubjectProxyHandler(Class clazz) {
    try {
      this.target = clazz.newInstance();
    } catch (InstantiationException | IllegalAccessException ex) {
      LOG.error("Create proxy for {} failed", clazz.getName());
    }
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    preAction();
    Object result = method.invoke(target, args);
    postAction();
    LOG.info("Proxy class name {}", proxy.getClass().getName());
    return result;
  }
  private void preAction() {
    LOG.info("SubjectProxyHandler.preAction()");
  }
  private void postAction() {
    LOG.info("SubjectProxyHandler.postAction()");
  }
}

从上述代码中可以看到，被代理对象的类对象作为参数传给了构造方法。
注意，SubjectProxyHandler定义的是代理行为而非代理类本身。实际上代理类及其实例是在运行时通过反射动态创建出来的。

JDK动态代理使用方式

代理行为定义好后，先实例化SubjectProxyHandler（在构造方法中指明被代理类），然后通过Proxy.newProxyInstance动态创建代理类的实例。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class JDKDynamicProxyClient {
  public static void main(String[] args) {
    InvocationHandler handler = new SubjectProxyHandler(ConcreteSubject.class);
    ISubject proxy =
        (ISubject) Proxy.newProxyInstance(JDKDynamicProxyClient.class.getClassLoader(),
            new Class[] {ISubject.class}, handler);
    proxy.action();
  }
}

从上述代码中也可以看到，Proxy.newProxyInstance的第二个参数是类对象数组，也就意味着被代理对象可以实现多个接口。

运行结果如下：

SubjectProxyHandler.preAction()
ConcreteSubject action()
SubjectProxyHandler.postAction()
Proxy class name com.sun.proxy.$Proxy18

从上述结果可以看到，定义的代理行为顺利的加入到了执行逻辑中。同时，最后一行日志说明了代理类的类名是com.sun.proxy.$Proxy18，验证了上文的论点——SubjectProxyHandler定义的是代理行为而非代理类本身，代理类及其实例是在运行时通过反射动态创建出来的。

所有生成的动态代理类都是Proxy类的子类。JDK动态代理只能代理实现了接口的类——Java不支持多继承，代理类已经继承了Proxy类，无法再继承其它类。

cglib

cglib介绍

cglib是一个强大的高性能代码生成库，它的底层是通过使用一个小而快的字节码处理框架ASM（Java字节码操控框架，它能被用来动态生成类或者增强既有类的功能。ASM可以直接产生二进制class文件，也可以在类被加载入Java虚拟机之前动态改变类行为）来转换字节码并生成新的类。

使用cglib实现动态代理，需要在MethodInterceptor实现类中定义代理行为。

import java.lang.reflect.Method;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class SubjectInterceptor implements MethodInterceptor {
  private static final Logger LOG = LoggerFactory.getLogger(SubjectInterceptor.class);
  @Override
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
      throws Throwable {
    preAction();
    Object result = proxy.invokeSuper(obj, args);
    postAction();
    return result;
  }
  private void preAction() {
    LOG.info("SubjectProxyHandler.preAction()");
  }
  private void postAction() {
    LOG.info("SubjectProxyHandler.postAction()");
  }
}

代理行为在intercept方法中定义，同时通过getInstance方法（该方法名可以自定义）获取动态代理的实例，并且可以通过向该方法传入类对象指定被代理对象的类型。

cglib使用方式

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
public class CgLibProxyClient {
  public static void main(String[] args) {
    MethodInterceptor methodInterceptor = new SubjectInterceptor();
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(ConcreteSubject.class);
    enhancer.setCallback(methodInterceptor);
    ISubject subject = (ISubject)enhancer.create();
    subject.action();
  }
}

JDK动态代理与cglib对比

• 字节码创建方式：JDK动态代理通过JVM实现代理类字节码的创建，cglib通过ASM创建字节码
• 对被代理对象的要求：JDK动态代理要求被代理对象实现接口，cglib要求被代理对象未被final修饰
• 代理对象创建速度：JDK动态代理创建代理对象速度比cglib快
• 代理对象执行速度：JDK动态代理代理对象执行速度比cglib快