前言
今天分享的文章是关于设计模式中的代理模式，代理模式在Android中的应用还是很广的，而且也是比较常用的一种设计模式。
本文主要是写个简单的demo来带着大家熟悉认识代理模式，最后举例分析一个我们Android常用的网络框架Retrofit中代理模式的使用，加深对代理模式的设计。
设计模式之代理模式
代理模式的定义
什么是代理模式？
- 简单一句话解释：为其他对象提供代理对象，以控制对这个对象的访问
- 详细的解释：为其他对象提供代理以控制对这个对象的访问，代理对象起到了中介作用，不涉及功能服务，亦可增加额外的服务；
代理模式的分类：
- 远程代理：为不同的地理对象提供局域网代表对象。典型的设计有：C/S架构属于远程代理的缩影
- 虚拟代理：根据需要将资源消耗很大的对象进行延迟，真正需要的时候再创建。典型设计：经常我们看到很多APP在加载图片的时候，会先加载一个默认的图片，等真正的图片加载完了之后再显示出来，这样非常的友好。
- 智能引用代理：提供对目标对象的额外的服务。典型设计：现实场景中随处可见，我们的火车、汽车票代售处、代购等等都是属于代理模式的范畴。
- 保护代理：控制用户的访问权限。典型设计：就像我们的公众号的文章留言功能，只有你这个用户关注了该公众号之后才能留言，否则你就只能浏览不能留言。
代理模式的实现
Android 中比较常用的代理模式——智能引用代理，我们就以此为例，一步一步的来实现代理模式。
代理的实现方式主要有两种：
静态代理：
代理和被代理对象在代理之前都是被确定的，他们都实现相同的接口或者是继承相同的抽象类，这里一张经典的图
上面这张图我们可以看出：ProxySubject和RealSbuject都是继承了Subject，Client请求Subjct的doSomething()方法，本应该是调用RealSubject中的doSomething()方法，但是我们实际看到的却是调用的ProxySubject方法中的doSomething()方法，在ProxySubject方法中的doSomething()方法中再去调用RealSubject中的doSomething()方法。我们实际看到的是ProxySubject方法中的doSomething()方法，这样就完成了代理。
静态代理：
静态代理之聚合的方式
1.按照之前的定义我们先定义一个接口：
public interface Subject{
public void doSomeThing();
}
2.创建被代理的角色，逻辑执行者：
public class RealSubject implements Subject{
@Override
public void doSomeThing() {
//do some things
}
}
3.创建我们的代理类：
public class Proxy implements Subject{
private Subject subject = null;
public Proxy(){
subject = new RealSubject();
}
@Override
public void doSomeThing() {
subject.doSomeThing();
}
}
可以看到我们在构造方法里面创建了一个RealSubjecj的实现类对象，在调用Proxy的doSomething()方法的时候，实际是调用的RealSubject对象的的doSomething()方法，但是经常我们还会附加一些逻辑在里面比如我们需要打印一些Log日志，直接这样加就可以了：
public class Proxy implements Subject{
private Subject subject = null;
public Proxy(){
subject = new RealSubject();
}
@Override
public void doSomeThing() {
log.d("TAG","代理开始...")
subject.doSomeThing();
log.d("TAG","代理开结束...")
}
}
这样的好处就是正在实现类的逻辑不用做任何改变即可实现。
写到这里可能有很多的人有疑问，我直接创建RealSubject的实现类，调用doSomething()方法和你在代理中再创建调用有啥区别，反而增加了类和代码。按照这个说法确实是如此，但是不要忘记了我们Android 的设计模式中是有六大原则：
- 单一职责原则
- 里氏替换原则
- 依赖倒置原则
- 接口隔离原则
- 迪米特原则
- 开闭原则
这几个原则不是我们的这篇文章重点要讲述的，感兴趣的朋友可自行查
因此如果直接用RealSubject调用doSomething()，就不符合我们的设计模式的六大原则。
静态代理之继承的方式
和上面的聚合方式只有最后的代理类有点区别：
public class Proxy extends Subject{
@Override
public void doSomeThing() {
log.d("TAG","代理开始...")
super.doSomeThing();
log.d("TAG","代理开结束...")
}
}
这种方式和上诉的方式有着相同结果，也称为静态代理之继承方式。
可能大家都可能会想到，既然静态代理有两种模式，那我们使用的时候到底应该使用哪种呢？
其实这个问题我们先不说其他的，就以实现接口和继承来说，必然是实现接口更加符合我们的设计模式。接下来我举个例子我想大家就应该很清楚使用哪种方式更加的合适：
就以上面的例子来说，上面的继承模式中我只添加了Log的功能，假设我要为我们的代理增加两个功能：1.计算时间
2.增加权限管理。现在我们的代理类就又三个功能：1.Log能力 2.时间 3.权限。假设需求不断的改变：1/2/3能力的顺序不断改变，我们是不是就要不断的增加继承的类，所以这种方式并不是我们推荐的方式，也不符合我们的设计模式。因此，我们的聚合的方式是更加的适合静态代理模式。
因此综上所述，我们在使用静态代理模式的时候，我们更加的倾向于使用聚合的方式，也就是实现接口这种方式，而非继承。
可能有的小伙伴就会说了，聚合的方式到底该怎么实现呢？
创建接口
public interface ISubject {
//出行
public void doSomething();
}
实现接口真实执行逻辑
public class RealSubject implements ISubject {
private static final String TAG = "RealSubject";
@Override
public void doSomething() {
Log.e(TAG, "doSomething: 执行中");
}
}
创建时间代理
public class TimeProxy implements ISubject {
private static final String TAG = "TimeProxy";
private ISubject iSubject;
public TimeProxy(ISubject iSubject) {
this.iSubject = iSubject;
}
@Override
public void doSomething() {
Log.e(TAG, "开始执行时间...");
iSubject.doSomething();
Log.e(TAG, "结束执行时间...");
}
建log代理
public class LogProxy implements ISubject {
private static final String TAG = "LogProxy";
private ISubject iSubject;
public LogProxy(ISubject iSubject) {
this.iSubject = iSubject;
}
@Override
public void doSomething() {
Log.e(TAG, "日志开始。。。");
iSubject.doSomething();
Log.e(TAG, "日志结束。。。");
}
}
我们在MainActivity中执行两种方式：
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
RealSubject realSubject = new RealSubject();
//先记录时间 在打印日志
ISubject logProxy = new LogProxy(realSubject);
TimeProxy timeProxy = new TimeProxy(logProxy);
timeProxy.doSomething();
Log.e(TAG, "============================================ ");
//先打印日志 再记录时间
TimeProxy timeProxy1 = new TimeProxy(realSubject);
ISubject logProxy1 = new LogProxy(timeProxy1);
logProxy1.doSomething();
}
运行结果：
07-09 23:20:06.516 27723-27723/com.lt.proxy E/TimeProxy: 开始执行时间...
07-09 23:20:06.516 27723-27723/com.lt.proxy E/LogProxy: 日志开始。。。
07-09 23:20:06.516 27723-27723/com.lt.proxy E/RealSubject: doSomething: 执行中
07-09 23:20:06.516 27723-27723/com.lt.proxy E/LogProxy: 日志结束。。。
07-09 23:20:06.516 27723-27723/com.lt.proxy E/TimeProxy: 结束执行时间...
07-09 23:20:06.516 27723-27723/com.lt.proxy E/MainActivity: ============================================
07-09 23:20:06.516 27723-27723/com.lt.proxy E/LogProxy: 日志开始。。。
07-09 23:20:06.516 27723-27723/com.lt.proxy E/TimeProxy: 开始执行时间...
07-09 23:20:06.516 27723-27723/com.lt.proxy E/RealSubject: doSomething: 执行中
07-09 23:20:06.516 27723-27723/com.lt.proxy E/TimeProxy: 结束执行时间...
07-09 23:20:06.516 27723-27723/com.lt.proxy E/LogProxy: 日志结束。。。
复制代码这样我们就可以看出我们的聚合方式的静态代理的优点。
到了这里我想很多的小伙伴都看到了一个缺点，要是我们的真实执行逻辑的类RealSubject有很多种类型呢？例如我们今天要去上班，你会有多种方式：走路、骑自行车、开汽车、坐地铁、公交等等。。。很多的方式，难道我们每一个都要去实现一篇，然后添加日志功能、时间功能？这样是不是太不符合我们的代码的设计模式了。因此，我们有没有一种动态的方式，传入什么出行的工具，那么就给我记录什么工具呢？那就是我们接下来要讲解的动态代理模式，也是我们最重要的一种模式。
动态代理模式
学习动态代理之前，首先我们要知道InvocationHandler类：
/**
* Created by Scorpio on 2018/7/9.
* 该类经常称之为事务处理类
*/
public class DynamicProxy implements InvocationHandler {
/**
*
* @param proxy 代理类
* @param method 被代理的方法
* @param args 被代理方法的参数
* @return 返回代理对象
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
}
InvocationHandler是个接口，只有一个抽象方法 invoke(Object proxy, Method method, Object[] args)，四个参数的意义：
- param proxy 代理类
- param method 被代理的方法
- param args 被代理方法的参数
- return 方法的返回值
其次就是我们的Proxy即动态代理类，它当中有个方法：Proxy.newProxyInstance(ClassLoader loader,Class class,Proxy proxy)
public class RealSubject implements ISubject {
private static final String TAG = "RealSubject";
@Override
public void doSomething() {
Log.e(TAG, "doSomething: 执行中");
}
}
public class RealSubject2 implements ISubject {
private static final String TAG = RealSubject2.class.getName();
@Override
public void doSomething() {
Log.e(TAG, "doSomething: 执行中");
}
}
2.创建事务处理类
/**
* Created by Scorpio on 2018/7/9.
* 该类经常称之为事务处理类
*/
public class DynamicProxy implements InvocationHandler {
private static final String TAG = "DynamicProxy";
private Object target;
public DynamicProxy(Object target) {
this.target = target;
}
/**
* @param proxy 代理类
* @param method 被代理的方法
* @param args 被代理方法的参数
* @return 返回代理对象
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Log.e(target.getClass().getName(), "开始日志。。。");
method.invoke(target);
Log.e(target.getClass().getName(), "结束日志。。。");
return null;
}
}
3.代码中使用：
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.e(TAG, "===================RealSubject========================= ");
RealSubject realSubject = new RealSubject();
DynamicProxy dynamicProxy = new DynamicProxy(realSubject);
ClassLoader classLoader = realSubject.getClass().getClassLoader();
ISubject proxyInstance = (ISubject) Proxy.newProxyInstance(classLoader, realSubject.getClass().getInterfaces(), dynamicProxy);
proxyInstance.doSomething();
Log.e(TAG, "===================RealSubject2========================= ");
RealSubject2 realSubject2 = new RealSubject2();
DynamicProxy dynamicProxy2 = new DynamicProxy(realSubject2);
ClassLoader classLoader2 = realSubject2.getClass().getClassLoader();
ISubject proxyInstance2 = (ISubject) Proxy.newProxyInstance(classLoader2, realSubject2.getClass().getInterfaces(), dynamicProxy2);
proxyInstance2.doSomething();
}
}
运行结果：
07-10 00:07:30.284 30241-30241/com.lt.proxy E/MainActivity: ===================RealSubject=========================
07-10 00:07:30.285 30241-30241/com.lt.proxy E/com.lt.proxy.RealSubject: 开始日志。。。
07-10 00:07:30.285 30241-30241/com.lt.proxy E/RealSubject: doSomething: 执行中
07-10 00:07:30.285 30241-30241/com.lt.proxy E/com.lt.proxy.RealSubject: 结束日志。。。
07-10 00:07:30.285 30241-30241/com.lt.proxy E/MainActivity: ===================RealSubject2=========================
07-10 00:07:30.285 30241-30241/com.lt.proxy E/com.lt.proxy.RealSubject2: 开始日志。。。
07-10 00:07:30.285 30241-30241/com.lt.proxy E/com.lt.proxy.RealSubject2: doSomething: 执行中
07-10 00:07:30.285 30241-30241/com.lt.proxy E/com.lt.proxy.RealSubject2: 结束日志。。。
复制代码这样我们的动态代理就实现成功了，我们不管传入什么样的实现类，都可以通过动态代理获取到代理对象，进而实现代理功能。
Android Retrofit 中的动态代理模式应用
通过我上面对Retrofit源码的截图，以及上面的标注就可以看出，这个Retrofit的creat()方法是个典型的动态代理的模式
总结
优点：
1、代理模式能够协调调用者和被调用者，在一定程度上降低了系统的耦合度；
2、代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了保护目标对象的作用。
缺点：
1、由于在客户端和真实对象之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢；
2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。
————————————————
版权声明：本文为CSDN博主「lt_sc」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_34560959/article/details/80981890
