一文搞懂Android设计模式之代理模式
前言
今天分享的文章是关于设计模式中的代理模式，代理模式在中的应用还是很广的，而且也是比较常用的一种设计模式。本来说是连续的写一系列的设计模式的文章的，但是发现这样效果可能不好，所以就穿插着写，希望大家喜欢。如果文中有任何错误的地方，欢迎大家指正，如果有更好的想法可以加我文末微信，直接给我提出，感谢你的不吝赐教。
本文主要是写个简单的demo来带着大家熟悉认识代理模式，最后举例分析一个我们常用的网络框架中代理模式的使用，加深对代理模式的设计。
设计模式之代理模式
代理模式的定义
什么是代理模式？
代理模式的分类：
代理模式的实现
中比较常用的代理模式——智能引用代理，我们就以此为例，一步一步的来实现代理模式。
代理的实现方式主要有两种：
静态代理：代理和被代理对象在代理之前都是被确定的，他们都实现相同的接口或者是继承相同的抽象类，这里一张经典的图
上面这张图我们可以看出：和都是继承了，请求的()方法，本应该是调用中的()方法AI一键帮你写论文，但是我们实际看到的却是调用的方法中的()方法，在方法中的()方法中再去调用中的()方法。我们实际看到的是方法中的()方法代理模式，这样就完成了代理。
动态代理：
静态代理之聚合的方式
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();
}
}可以看到我们在构造方法里面创建了一个的实现类对象，在调用Proxy的()方法的时候，实际是调用的对象的的()方法，但是经常我们还会附加一些逻辑在里面比如我们需要打印一些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","代理开结束...")
}
}这样的好处就是正在实现类的逻辑不用做任何改变即可实现。
写到这里可能有很多的人有疑问，我直接创建的实现类，调用()方法和你在代理中再创建调用有啥区别，反而增加了类和代码。按照这个说法确实是如此，但是不要忘记了我们 的设计模式中是有六大原则：
这几个原则不是我们的这篇文章重点要讲述的，感兴趣的朋友可以看下这篇文章写得比较完整、清楚
设计模式六大原则
因此如果直接用调用()，就不符合我们的设计模式的六大原则。
静态代理之继承的方式
和上面的聚合方式只有最后的代理类有点区别：
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, "日志结束。。。");
}
}我们在中执行两种方式：
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: 日志结束。。。复制代码这样我们就可以看出我们的聚合方式的静态代理的优点。
到了这里我想很多的小伙伴都看到了一个缺点，要是我们的真实执行逻辑的类有很多种类型呢？例如我们今天要去上班，你会有多种方式：走路、骑自行车、开汽车、坐地铁、公交等等。。。很多的方式，难道我们每一个都要去实现一篇，然后添加日志功能、时间功能？这样是不是太不符合我们的代码的设计模式了。因此，我们有没有一种动态的方式，传入什么出行的工具，那么就给我记录什么工具呢？那就是我们接下来要讲解的动态代理模式，也是我们最重要的一种模式。
动态代理模式
学习动态代理之前，首先我们要知道类：
/**
* 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;
}
}是个接口，只有一个抽象方法 ( proxy, , [] args)，四个参数的意义：
其次就是我们的Proxy即动态代理类，它当中有个方法：Proxy.( ,Class
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: 结束日志。。。复制代码这样我们的动态代理就实现成功了代理模式，我们不管传入什么样的实现类，都可以通过动态代理获取到代理对象，进而实现代理功能。
中的动态代理模式应用
通过我上面对源码的截图，以及上面的标注就可以看出，这个的creat()方法是个典型的动态代理的模式
总结
优点：
1、代理模式能够协调调用者和被调用者，在一定程度上降低了系统的耦合度；
2、代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了保护目标对象的作用。
缺点：
1、由于在客户端和真实对象之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢；
2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。
温馨提示：
我创建了一个技术交流群，群里有各个行业的大佬都有，大家可以在群里畅聊技术方面内容，以及文章推荐；如果有想加入的伙伴加我微信号【】备注一下“加群”
手机浏览，点击图片保存二维码到相册，然后打开微信扫一扫选择本二维码图片就可以进入，电脑端微信“扫一扫”二维码，进入找聊天搭子平台，里面有找饭搭子、找对象、找陪伴服务等等
