代理模式
设计模式详解之代理模式
简介
代理模式是我们使用率比较高的一个模式。它的定义是为其他对象提供一种代理以控制对这个对象的访问。
如果只是从定义上来看,可能无法理解。为什么要用代理来对这个对象来访问,我直接访问不行吗?行,当然行了。但是我们使用代理自然是有代理的优势,我们举个简单例子来说明一下。
有一个房东,他有一座房子要出售。但是房子买卖呢,我们知道,需要让买房的人来看房,有意向之后还需要和顾客签订一系列的合同,实在复杂。我们的房东比较懒,他不想做那么多事情,他只想单纯卖房子。于是他找了一个中介,由中介来代替房东做这些事情。这个中介就可以说是我们的代理。如果觉得还是觉得抽象的话,下面我们会用实际开发代码来演示代理模式,深入理解。
代理模式的三个重要角色:
![](https://upload-images.jianshu.io/upload_images/22691891-2ef9afa29149c18e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
Subject抽象主题角色
- 抽象主题类可以是抽象类也可以是接口,是一个最普通的业务类型定义,无特殊要求。
RealSubject具体主题角色
- 被委托角色,被代理角色。也就是我们的房东
Proxy代理主题角色
- 也叫做委托类、代理类。它负责对真实角色的应用,把所有抽象主题类定义的方法限制委托给真实主题角色实现,并且在真实主题角色处理完毕前后做预处理和善后处理工作。(我们的中介)
关于我们的代理模式大致可以分成两种,静态代理模式和动态代理模式。下面我们会用代码来分别演示一下两种代理的区别。
静态代理
静态代理呢,就是我们的每一个具体主题角色都有自己专门的代理角色。我们用代码来说吧,我们开发业务的时候,需要抽象service接口和具体实现。我们模拟一个增删改查。
package proxydemo;
public interface Service {
//比如我们的业务有这四个方法
void add();
void delete();
void update();
void query();
}
然后就是我们去实现这个接口
package proxydemo;
public class ServiceImpl implements Service {
@Override
public void add() {
System.out.println("增加操作");
}
@Override
public void delete() {
System.out.println("删除操作");
}
@Override
public void update() {
System.out.println("更新操作");
}
@Override
public void query() {
System.out.println("查询操作");
}
}
这个service接口就可以看作是我们的抽象主题角色,具体实现类就是我们的具体主题角色。我们可以在客户端使用
package proxydemo;
public class Client {
public static void main(String[] args) {
ServiceImpl service = new ServiceImpl();
service.add();
service.delete();
service.update();
service.query();
}
}
|----------控制台输出--------|
增加操作
删除操作
更新操作
查询操作
Process finished with exit code 0
但是如果这个时候来了一个需求,说要在我们使用方法后,日志能够记录下来是进行了什么操作。那我们容易想到的就是在我们的实现类去修改,在使用后方法后用日志记录下来。但是我们在开发中最忌讳就是修改原有的代码,因为我们是要符合开闭原则的。所有我们就可以用代理模式来
package proxydemo;
//我们的代理角色,在不修改原来的代码情况下,扩展了日志的功能
public class ProxyServiceImpl implements Service{
//使用组合模式代替继承
private ServiceImpl service;
public void setService(ServiceImpl service) {
this.service = service;
}
@Override
public void add() {
System.out.println("日志输出:使用add方法");
service.add();
}
@Override
public void delete() {
System.out.println("日志输出:使用delete方法");
service.delete();
}
@Override
public void update() {
System.out.println("日志输出:使用update方法");
service.update();
}
@Override
public void query() {
System.out.println("日志输出:使用query方法");
service.query();
}
}
然后在我们的客户端使用的时候,只需要给代理角色设置需要被代理的角色就行
package proxydemo;
public class Client {
public static void main(String[] args) {
//实例化我们原来的功能
ServiceImpl service = new ServiceImpl();
//实例我们的代理角色
ProxyServiceImpl proxyService = new ProxyServiceImpl();
//设置需要被代理的角色
proxyService.setService(service);
//使用有日志功能的代理方法
proxyService.add();
proxyService.delete();
proxyService.update();
proxyService.query();
}
}
|----------控制台输出--------|
日志输出:使用add方法
增加操作
日志输出:使用delete方法
删除操作
日志输出:使用update方法
更新操作
日志输出:使用query方法
查询操作
Process finished with exit code 0
静态代理总结
好处:
- 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
- 一些非核心的功能交给了代理角色,实现了业务的分工
- 公共业务扩展的时候,方便集中管理
缺点:
- 上面也说了,每一个真实角色就会产生一个代理角色,代码量翻倍
动态代理
动态代理就是为了解决我们上面那个代码量大的解决问题,也是我们真正在开发中会去使用的代理模式。我们的动态代理有两种方式去实现,一个是JDK动态代理(面向接口),一个是CGlib动态代理(面向类)。我们这里主要是介绍概念,所以就用JDK动态代理来实现我们上面的例子,另一种的使用可以看这里(动态代理的两种方式以及区别)
(补充:现在也出了Javassit去实现了)
关于JDK的动态代理,我们在java.lang.reflect
包下,有这么一个接口
Interface InvocationHandler :
InvocationHandler
是由代理实例的调用处理程序实现的接口 。
每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时,方法调用将被编码并分派到其调用处理程序的
invoke
方法。
还有一个Proxy
类,它提供了创建动态代理类和实例的静态方法,它也是由这些方法创建的所有动态代理类的超类。
可以通过反射来创建代理
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
new Class<?>[] { Foo.class },
handler);
话不多说,我们用代码了实现一下更容易明白这些抽象的解释。
例子还是调用我们的上面的例子,只不过这个时候,我们的代理类不需要去实现了,我们实现InvocationHandler接口写调用程序就行了。
package proxydemo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
public Object target;
public void setTarget(Object object) {
this.target = object;
}
//通过反射生成得到代理类
public Object getProxy(){
//三个参数,当前的类加载器,被代理的接口,以及一个InvocationHandler,当前即可
return Proxy.newProxyInstance
(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
//处理代理实例,返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//通过反射来调用方法
Object result = method.invoke(target,args);
return result;
}
}
我们在我们的客户端使用的时候,需要去实例化一个InvocationHandler就行了。
package proxydemo;
public class Client {
public static void main(String[] args) {
//实例一个我们的需要被代理的角色
ServiceImpl service = new ServiceImpl();
//实例我们的代理调用处理
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//设计被代理的角色
pih.setTarget(service);
//通过反射了来实例我们的代理类
Service proxyService = (Service) pih.getProxy();
proxyService.add();
proxyService.delete();
proxyService.update();
proxyService.query();
}
}
|----------控制台输出--------|
增加操作
删除操作
更新操作
查询操作
Process finished with exit code 0
具体的调用过程就是
![](https://upload-images.jianshu.io/upload_images/22691891-029aeccd0c7bb1e6.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
这个时候如果我们要增加一个日志输出功能的话,只需要在我们的ProxyInvocationHandler里面增加就行。
package proxydemo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Object target;
//设计被代理的接口
public void setTarget(Object object) {
this.target = object;
}
//通过反射生成得到代理类
public Object getProxy(){
//三个参数,当前的类加载器,被代理的接口,以及一个InvocationHandler,当前即可
return Proxy.newProxyInstance
(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
//处理代理实例,返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//通过反射来调用方法
log(method.getName()); //将方法名传给我们的输出方法
Object result = method.invoke(target,args);
return result;
}
//新增加的日志输出功能
public void log(String msg){
System.out.println("日志输出,调用了"+msg+"方法");
}
}
客户端输出:
日志输出,调用了add方法
增加操作
日志输出,调用了delete方法
删除操作
日志输出,调用了update方法
更新操作
日志输出,调用了query方法
查询操作
Process finished with exit code 0
看到这里可能还是会有小伙伴不是很懂, 上面我们的静态代理实现了一个代理类,这里不也是实现了一个调用处理吗?注意,这里我们的调用处理可是一个可以复用的,只要你是实现了基于接口实现的业务就可以调用。比如我们一个庞大的业务的层,有很多的servcie接口,都可以统一使用这个动态代理模板。我们不需要在实现阶段去关心代理谁,在使用的时候才指定代理谁!!!
总结
关于代理我们也了解,它主要的优点也很明显
- 职责清晰。真实的角色就是实现实际的业务逻辑,不用关心其他非本职责的事务,通过后期的代理完成一件事务,附带的结果就是编程简洁清晰。
- 高扩展性。具体主题角色是随时都会发生变化的,只要它实现了接口,甭管它如何变化,都逃不脱如来佛的手掌(接口),那我们的代理类完全就可以在不做任何修改的情况下使用。
- 智能化。都不用自己实现代理,只需要在使用的时候去指定就行了。
使用场景
关于代理模式应用的场景,一个比较典型的动态代理就是Spring AOP了,我们用AOP来面向切面编程。在我们完成核心业务之后,然后可以横向扩展我们的周边业务,比如日志输出,监控等。具体的可以去了解AOP,了解之后对其他的场景,下次一见到就能看出来这用到了代理模式了。
参考资料
遇见狂神说:通俗易懂的23中设计模式教学(视频)
设计模式之禅(第二版)
本文作者:CryFace
本文链接:https://www.cnblogs.com/CryFace/p/13432501.html
版权声明:本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。
不改了 退出 订阅评论 我的博客
[Ctrl+Enter快捷键提交]