本文转发自技术世界,原文链接
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快