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四种接口插件
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
