设计模式-代理模式
为另一个对象提供代表,以便控制客户对对象的访问。其定义为:为另一个对象提供替身或占位符以访问这个对象。具体地吗可以浏览 https://github.com/UniqueDong/zero-design-patterns
什么是代理
官话上讲是一种设计模式,目的是希望代码重用。跟我们以往访问对象的方式不同,代理模式不是直接通过目标对象,而是通过代理访问我们的目标对象以及方法。因为有的时候我们无法直接与目标对象建立联系或者,我们要控制客户端访问。所以便通过代理来访问我们的真实对象。
就好比「客户」-> 「明星经纪人」-> 「明星」。我们不是直接与明星联系,明星很忙的,要唱歌跳舞烫头拍电影,给的价格足够好,经纪人才告知明星接下这个任务。
主要角色
代理模式
● Subject:被代理类与代理类都要实现的主题接口。
● ConcreteSubject:被代理类,也叫委托类,也就是真实对象,真正干活的。
● Proxy:代理类,扮演者中介的角色,控制客户端对真实对象的访问、生成代理对象让客户端透明调用,通过代理我们可以屏蔽或者加工针对真实对象。
使用场景
● 通常更多出现在我们常用的开源框架里面,比如 Mybatis 中我们 通过Mapper 接口就能调用到真正执行 SQL 的逻辑,其本质就是利用了动态代理,定位到真实的Statement执行。
● Spring AOP 也是利用了动态代理,比如 Spring 事务,当调用的方法是被 Spring 事务管理的时候,其实他会生成一个代理类,封装我们的事务处理逻辑从而实现了事务增强,代码复用。解放我们开启事务、执行逻辑 、提交事务或者回滚事务的模板代码,我们只要安心的编写路基代码即可。在这里一共用到了 「模版方法模式」、动态代理模式。关于「模版方法」模式可以参考历史文章。
● 还有 Dubbo RPC 框架,也是有使用动态代理。对于消费者我们只是通过接口就能调用提供者所实现的功能,就像本地调用一样。它为我们封装了网络传输、序列化、解码编码的繁琐细节。就是生成了一个代理类为屏蔽了底层细节。使得我们可以透明调用。
我们根据加载被代理类的时机不同,将代理分为静态代理和动态代理。如果我们在代码编译时就确定了被代理的类是哪一个,那么就可以直接使用静态代理;如果不能确定,那么可以使用类的动态加载机制,在代码运行期间加载被代理的类这就是动态代理,比如RPC框架和Spring AOP机制。
静态代理代码示例
我们按照 UML 类图来实现一个简单的静态代理模式,首先先创建一个 Subject 接口。
我们按照 UML 类图来实现一个简单的静态代理模式,首先先创建一个 Subject 接口。
publicinterface Subject {
public void request();
}
创建一个真实对象去实现该接口
publicclass RealSubjbect implements Subject {
@Override
public void request() {
System.out.println("this is RealSubjbect.request()");
}
}
创建我们的代理类,持有真实对象的引用,同时实现了 Subject 接口。
publicclass ProxySubject implements Subject {
private Subject realSubjbect = null;
/**
* 除了代理真实角色做该做的事,代理角色提供附加操作
* 如
*/
@Override
public void request() {
preRequest(); //真实角色操作前的附加操作
if (realSubjbect == null) {
realSubjbect = new RealSubjbect();
}
realSubjbect.request();
postRequest();//真实角色操作后的附加操作
}
/**
* 真实角色操作前的附加操作
*/
private void postRequest() {
System.out.println("真实角色操作后的附加操作");
}
/**
* 真实角色操作后的附加操作
*/
private void preRequest() {
System.out.println("真实角色操作前的附加操作");
}
}
编写我们的客户端接口,通过代理类调用。
publicclass Client {
public static void main(String[] args) {
Subject subject = new ProxySubject();
subject.request(); //代理者代替真实者做事情
}
}
打印的结果如下所示,我们实现了对真实对象的控制,并且新增一些操作。就像Spring的AOP实现的功能一样。
真实角色操作前的附加操作
this is RealSubjbect.request()
真实角色操作后的附加操作
缺点
- 代理对象的一个接口只服务于一种类型的对象,如果要代理的方法很多,势必要为每一种方法都进行代理,静态代理在程序规模稍大时就无法胜任了。
- 如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。
另外,如果要按照上述的方法使用代理模式,那么真实角色(委托类)必须是事先已经存在的,并将其作为代理对象的内部属性。但是实际使用时,一个真实角色必须对应一个代理角色,如果大量使用会导致类的急剧膨胀;此外,如果事先并不知道真实角色(委托类),该如何使用代理呢?这个问题可以通过Java的动态代理类来解决。
动态代理
概念
动态代理类的源码是在程序运行期间 JVM 根据反射机制动态生成的,所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。
实现方式
主要有两种实现方式:
- 使用 JDK 实现。委托类逆序有接口。
- 使用 CGLIB 实现。不能是final修饰的类,只能修饰 public 方法。
JDK 动态代理
UML 类图如下所示
JDK动态代理
● 创建一个自己Handler 实现 InvocationHandler,同时持有真实对象的引用,会依赖我们的业务类。
● 代理对象通过 Proxy.newProxyInstance()生成,而该方法以来于 Handler对象和 真实对象 。
通过类图其实我们也可以知道,当通过动态代理生成的代理字节码调用的时候就会委托到 Handler 的 invoke 方法。同时 Handler 又持有真正的业务对象。所以能在执行调用真实的对象之前控制其行为以及访问。主要优点:
● 隐藏委托类的实现,调用者只需要和代理类进行交互。
● 解耦合,在不改变委托类代码情况下做额外处理。比如添加 Dubbo 客户端调用时的序列化、网络传输细节。
代码实现
通过类图,创建 JDK 动态代理我们可以分为三步。
- 定义被代理的业务接口以及实现类。
- 新建自定义的 InvocationHandler 实现 InvocationHandler接口,并依赖被代理类(真实对象的引用)。
- 通过 Proxy.newProxyInstance() 方法创建具体代理对象。
现在我们有一个需求,为我们的业务逻辑统一记录调用日志,或者事务控制,在这里我们那就编写一个日志记录为我们的被代理类记录日志。模拟类似 Spring AOP功能,一个简化版的例子让大家明白其使用场景以及原理。
第一步:我们定义自己的业务接口 OrderService 跟 ProductService
publicinterface OrderService {
String createOder(String no);
}
publicinterface ProductService {
String getProduct(String no);
}
业务逻辑的实现类
publicclass OrderServiceImpl implements OrderService {
@Override
public String createOder(String no) {
return"生成订单" + no + "成功";
}
}
publicclass ProductServiceImpl implements ProductService {
@Override
public String getProduct(String no) {
return"获取商品" + no + "成功";
}
}
第二步:定义我们的 Handler 实现 JDK 的 Invocationhandler,将持有的委托引用定义 Object 类型,这样可以代理所有需要日志记录的委托类,同时我们有一个 bind()方法,用于设置 target 同时返回 对应的代理类让客户端调用。第三步的 Proxy.newProxyInstance() 我们放在 bind 方法里。代码更加简洁。
publicclass LoggerInterceptor implements InvocationHandler {
/**
* 持有委托类的引用
*/
private Object target;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.currentTimeMillis();
System.out.println(proxy.getClass().getInterfaces()[0]);
//通过反射调用
System.out.println("Entered " + target.getClass().getName() + "-" + method.getName() + ",with arguments{" + args[0] + "}");
//调用目标对象的方法
Object result = method.invoke(target, args);
long end = System.currentTimeMillis();
System.out.println("执行结果:" + result.toString());
System.out.println("共耗时:" + (end - start));
return result;
}
/**
* 获取代理类:并将 target 委托类绑定到 我们定义的Targe中
* @param target 真实的委托类
* @return
*/
public synchronized Object bind(Object target) {
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
}
最后我们新建启动类看效果,分别有两个业务逻辑类需要日志记录。具体可看代码注释
publicclass BootStrap {
public static void main(String[] args) {
// 新建业务逻辑
OrderService orderService = new OrderServiceImpl();
ProductService productService = new ProductServiceImpl();
// 新建我们的 日志 Handler
LoggerInterceptor loggerInterceptor = new LoggerInterceptor();
//绑定 委托类同时生产代理类调用 。
OrderService orderServiceProxy = (OrderService) loggerInterceptor.bind(orderService);
orderServiceProxy.createOder("12927381");
ProductService productServiceProxy = (ProductService) loggerInterceptor.bind(productService);
productServiceProxy.getProduct("34010234");
}
}
结果打印如下所示:我们可以看到,每个我们所代理的接口执行方法前后都打印了日志以及返回结果。其实 Spring AOP 就是通过动态代理实现。
nterface com.zero.headfirst.proxy.service.OrderService
Entered com.zero.headfirst.proxy.service.OrderServiceImpl-createOder,with arguments{12927381}
执行结果:生成订单12927381成功
共耗时:2
interface com.zero.headfirst.proxy.service.ProductService
Entered com.zero.headfirst.proxy.service.ProductServiceImpl-getProduct,with arguments{34010234}
执行结果:获取商品34010234成功
共耗时:1
CGLIB 动态代理
CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用,例如Spring AOP为他们提供方法的interception(拦截)。CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM,来转换字节码并生成新的类。
不能是 final 修饰的类,以及final方法,可以不定义接口。
使用方式很简单:我们要先添加cglib 依赖 ,新建一个类实现 MethodInterceptor 。
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
publicclass LoggerProxy implements MethodInterceptor {
/**
* 创建代理类
* @param targetClass 委托类
* @return
*/
public Object bind(Class targetClass) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(targetClass);
//设置回调方,当客户端通过代理调用方法的时候会会调用我们重写的 intercept() 方法
enhancer.setCallback(this);
//创建代理类
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
long start = System.currentTimeMillis();
//通过反射调用
System.out.println("Entered " + o.getClass().getName() + "-" + method.getName() + ",with arguments{" + args[0] + "}");
Object result = methodProxy.invokeSuper(o, args);
long end = System.currentTimeMillis();
System.out.println("执行结果:" + result.toString());
System.out.println("共耗时:" + (end - start));
return result;
}
}
是不是很简单?新建 Enhancer ,只要设置好 委托类以及回调类。在这里我们可以利用工厂模式 创建不同的代理类对应的回调。这里简单实例就不写了。
接下来看我们的测试类以及结果
publicclass CglibBootStrap {
public static void main(String[] args) {
LoggerProxy loggerProxy = new LoggerProxy();
OrderService orderService = (OrderService) loggerProxy.bind(OrderServiceImpl.class);
orderService.createOder("12873051209g");
ProductService productProxy = (ProductService) loggerProxy.bind(ProductServiceImpl.class);
productProxy.getProduct("2780935782309");
}
}
打印结果如下所示
Entered com.zero.headfirst.proxy.service.OrderServiceImpl$$EnhancerByCGLIB$$54d983a1-createOder,with arguments{12873051209g}
执行结果:生成订单12873051209g成功
共耗时:14
Entered com.zero.headfirst.proxy.service.ProductServiceImpl$$EnhancerByCGLIB$$4e2c7c36-getProduct,with arguments{2780935782309}
执行结果:获取商品2780935782309成功
共耗时:5
文章转载自公众号:码哥字节