Provide a surrogate or placeholder for another object to control access to it.
本篇博客属于《Java设计模式》系列之一,内容主要借鉴于 秦小波的著作《设计模式之禅》,在理解过程中可能还参考其他博主的知识,最后整理成自己的学习笔记,在此分享给大家。由于本人知识和能力有限,博客中有错误或者理解偏差的地方,还望大佬们多多指点,感谢不尽。(目前处于实习阶段,设计模式配合个人的实际经验更下饭,暂时更新最常见设计模式9+1篇。立个flag,将来一定会补齐)–2020.11.22
定义
为其他对象提供一种代理以控制对这个对象的访问。
代理模式的通用类图:
- Subject抽象主题角色,可以是抽象类也可以是接口,一个普通业务类型定义
- RealSubject具体主题角色,是业务逻辑的具体执行者
- Proxy代理主题角色。对具体主题角色的应用,把所有抽象主题类定义的方法委托给RealSubject实现,并在RealSubject处理完毕前做预处理和善后处理。
抽象主题类:
public interface Subject {
// 定义一个方法
public void doSomething();
}
真实主题类:
public class realSubject implements Subject{
@Override
public void doSomething() {
// 业务逻辑处理
}
}
代理类:
public class Proxy implements Subject{
// 要实现的代理类
private Subject sub = null;
// 默认被代理的对象
public Proxy(){
this.sub = new Proxy();
}
// 通过构造函数传递被代理对象
public Proxy(Subject _sub){
this.sub = _sub;
}
// 实现接口方法
@Override
public void doSomething() {
this.before();
this.sub.doSomething();
this.after();
}
// 善后处理
private void after() {
}
// 预处理
private void before() {
}
}
代理的优点
- 职责清晰。真实角色就是完成实际的业务逻辑,不关心其他非本职责的事务
- 高扩展性。代理类可以在不修改原来业务代码的条件下,进行修改
代理类为被代理预处理消息、过滤消息并在此之后转发给代理类,之后还能对消息后置处理。代理类和被代理类存在关联关系,代理类本身不实现服务,而是通过被代理类中的方法提供服务。
下面通过一个例子来进一步理解
静态代理
有一个明星(被代理类),通常人们都见不到他,也联系不到他。粉丝们只能通过经纪人(代理类)传达自己的爱意,经纪人(代理)就可以对粉丝信息筛选过滤,选择一些有用的给明星,也防止一些无脑粉丝伤害明星。
这时候有人要和明星进行商务合作,同样是通过和经纪人的谈判。经纪人如何知道明星会接哪些合作、有什么喜好呢?因为经纪人和明星实现了同样的接口或者抽象类,经纪人知道明星的所有。经纪人为明星接了一个跳舞的演出活动,经纪人知道明星会跳舞(继承了这个方法),具体执行还是明星去跳舞。
明星接口:
public interface StarInterface {
void dance();
}
周杰伦:
public class JayChou implements StarInterface{
@Override
public void dance() {
System.out.println("快使用双节棍,哼哼哈嘿!");
}
}
经纪人:
public class Proxy implements StarInterface{
private StarInterface star = new JayChou();
public Proxy(StarInterface _star){
this.star = _star;
}
@Override
public void dance() {
this.before();
star.dance();
this.after();
}
private void after() {
System.out.println("演出结束,支付尾款30w");
}
private void before() {
System.out.println("演出之前,付定金20w");
}
}
客户:
public class Client {
public static void main(String[] args) {
StarInterface jay = new JayChou();
Proxy proxy = new Proxy(jay);
proxy.dance();
}
}
输出:
演出之前,付定金20w
快使用双节棍,哼哼哈嘿!
演出结束,支付尾款30w
静态代理的缺点:
如果有这样的需求,某个程序猿为了脱单,给心仪女神请了20个明星为他助威。有的明星唱歌,有的明星跳舞,有的明星说相声…这时候需要代理的方法就多了,唱歌、跳舞、相声等等。那么怎么解决呢?
方案一:为这些方法创建不同的代理类
方案二:创建一个Proxy,实现所有的明星接口。
显然方案一会让代码有大量重复,第二种方案会使得Proxy极为复杂,如果两个明星都会唱歌,还要加入不同的判断逻辑。
动态代理
动态代理可以解决静态代理的缺点,动态代理可以在运行时,动态生成一个持有具体明星、并实现代理接口的Proxy,同时注入我们相同的扩展逻辑。动态代理就是上面的方案一的进一步抽象和封装,不同的是proxy的创建都是自动的而且在运行期通过反射生成的,减少了代码的重复。
明星接口StarInterface和周杰伦JayChou不变。构建一个Handler类来实现InnovationHandler接口
public class ProxyHandler implements InvocationHandler {
private Object obj;
public ProxyHandler(Object _obj){
this.obj = _obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
this.before();
method.invoke(obj, args);
this.after();
return null;
}
private void before() {
System.out.println("演出之前,支付定金20w");
}
private void after() {
System.out.println("演出结束,支付尾款30w");
}
}
执行动态代理
public class Client2 {
public static void main(String[] args) {
StarInterface jay = new JayChou();
InvocationHandler handler = new ProxyHandler(jay);
StarInterface proxyStar = (StarInterface) Proxy.newProxyInstance(jay.getClass().getClassLoader(), jay.getClass().getInterfaces(), handler);
proxyStar.dance();
}
}
通过Proxy类的静态方法返回一个接口的代理实例,针对不同的代理类,传入相应的代理程序控制器InvocationHandler。如果再来一个明星JJ,如:
public class JJ implements StarInterface{
@Override
public void dance() {
System.out.println("我不会跳舞,但是我唱歌好听!");
}
}
执行过程:
public class Client2 {
public static void main(String[] args) {
StarInterface jay = new JayChou();
StarInterface jj = new JJ();
InvocationHandler handler = new ProxyHandler(jay);
InvocationHandler jjHandler = new ProxyHandler(jj);
StarInterface proxyJay = (StarInterface) Proxy.newProxyInstance(jay.getClass().getClassLoader(), jay.getClass().getInterfaces(), handler);
StarInterface proxyJJ = (StarInterface) Proxy.newProxyInstance(jj.getClass().getClassLoader(), jj.getClass().getInterfaces(), jjHandler);
proxyJay.dance();
proxyJJ.dance();
}
}
输出:
演出之前,支付定金20w
快使用双节棍,哼哼哈嘿!
演出结束,支付尾款30w
演出之前,支付定金20w
我不会跳舞,但是我唱歌好听!
演出结束,支付尾款30w
几种代理的区别
静态代理的代表为AspectJ;动态代理则以Spring AOP为代表。
-
AspectJ是静态代理的增强,所谓静态代理,就是会在编译阶段生成代理类,他会在编译阶段将AspectJ(切面)织入到Java字节码中,运行的时候就是增强之后的代理对象。
-
Spring AOP使用的动态代理,所谓的动态代理就是说AOP框架不会去修改字节码,而是每次运行时在内存中临时为方法生成一个AOP对象,这个AOP对象包含了目标对象的全部方法,并且在特定的切点做了增强处理,并回调原对象的方法。
Spring AOP中的动态代理主要有两种方式,JDK动态代理和CGLIB动态代理:
- JDK动态代理只提供接口的代理,不支持类的代理。核心是InvocationHandler接口和Proxy类,InvocationHandler 通过invoke()方法反射来调用目标类中的代码,动态地将横切逻辑和业务编织在一起;接着,Proxy利用InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。
- 如果代理类没有实现 InvocationHandler 接口,那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB(Code Generation Library),是一个代码生成的类库,可以在运行时动态的生成指定类的一个子类对象,并覆盖其中特定方法并添加增强代码,从而实现AOP。CGLIB是通过继承的方式做的动态代理,因此如果某个类被标记为final,那么它是无法使用CGLIB做动态代理的
-
静态代理的效率相对动态代理来说相对高一些,但是静态代理代码冗余大,一单需要修改接口,代理类和委托类都需要修改。
框架中的应用
- Mybatis使用cglib达到延迟加载的效果
- Mybatis使用JDK动态代理开发插件。Mybatis可编写的插件:ParameterHandler、ResultSetHandler、StatementHandler、Executor四种接口插件