一文搞懂Android设计模式之代理模式

前言

今天分享的文章是关于设计模式中的代理模式，代理模式在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

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】备注一下“加群”
另外关注公众号，还有一些个人收藏的视频：
回复“学习资源” ，获取学习视频。
文章不易，如果觉得写得好，扫码关注一下点个赞，是我最大的动力。
关注我，一定会有意想不到的东西等你：