前言
今天分享的文章是关于设计模式中的代理模式，代理模式在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[] interfaces, InvocationHandler h)
- param loader 类加载器
- param interfaces 代理的接口
- param h 事务处理类
- return 返回代理对象
通过以上两个类，我们就可以实现一个动态代理模式。
实现方式：
为了方便对比创建两个ISubject 实现类：
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、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。
温馨提示： 我创建了一个技术交流群，群里有各个行业的大佬都有，大家可以在群里畅聊技术方面内容，以及文章推荐；如果有想加入的伙伴加我微信号【luotaosc】备注一下“加群” 另外关注公众号，还有一些个人收藏的视频： 回复“学习资源” ，获取学习视频。
文章不易，如果觉得写得好，扫码关注一下点个赞，是我最大的动力。
关注我，一定会有意想不到的东西等你：