Retrofit 里用到的一些设计模式

设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。根据其目的分为创建型 Creational、结构型 Structual、行为型 Behavioral。

为了提高软件系统的可维护性和可复用性，增加软件的可扩展性和灵活性，开发时要尽量根据 7 条原则来开发程序，从而提高软件开发效率、节约软件开发成本和维护成本。分别是

• 开闭原则（Open Closed Principle，OCP）：软件实体应当对扩展开放，对修改关闭（Software entities should be open for extension，but closed for modification）。

• 里氏替换原则（Liskov Substitution Principle，LSP）：继承必须确保超类所拥有的性质在子类中仍然成立（Inheritance should ensure that any property proved about supertype objects also holds for subtype objects）。里氏替换原则主要阐述了有关继承的一些原则，也就是什么时候应该使用继承，什么时候不应该使用继承，以及其中蕴含的原理。里氏替换原是继承复用的基础，它反映了基类与子类之间的关系，是对开闭原则的补充，是对实现抽象化的具体步骤的规范。

• 依赖倒置原则（Dependence Inversion Principle，DIP）：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象（High level modules shouldnot depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details. Details should depend upon abstractions）。其核心思想是：要面向接口编程，不要面向实现编程。依赖倒置原则是实现开闭原则的重要途径之一，降低了客户与实现模块之间的耦合。

• 单一职责原则（Single Responsibility Principle，SRP）：这里的职责是指类变化的原因，单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分（There should never be more than one reason for a class to change）。对象不应该承担太多职责。

• 接口隔离原则（Interface Segregation Principle，ISP）：客户端不应该被迫依赖于它不使用的方法（Clients should not be forced to depend on methods they do not use）。该原则还有另外一个定义：一个类对另一个类的依赖应该建立在最小的接口上（The dependency of one class to another one should depend on the smallest possible interface）。
  以上两个定义的含义是：要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。
  接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想。

• 迪米特法则（Law of Demeter，LoD）：只与你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
  “朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

• 合成复用原则（Composite Reuse Principle，CRP）：要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。如果要使用继承关系，则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的，两者都是开闭原则的具体实现规范。

Retrofit

Retrofit 是一个类型安全的 Http 客户端，主要有以下功能特点

1. 将 Http 请求对象化，函数化。让接口的函数代表具体请求。
2. 利用注解的方式标记参数，将 HTTP 的请求方法，请求头，请求参数，请求体等等都用注解的方式标记，使用起来非常方便。
3. 支持 Multipart，以及文件上传（file upload）。
4. 直接将 Http 的 Response 转换成对象。用户可以根据 Response 的具体内容，更换转换器，或者自己新建转化器。
5. Retrofit 默认使用 OkHttp 开源库请求后台，用户也可以使用自定义的具体请求方式。方便扩展。
6. 自带提供了异步处理 Http 请求的方式。

我们结合 Retrofit 来看看他使用了什么设计模式，是如何实现解耦的。

先来看看 Retrofit 的使用流程：

Retrofit adapts a Java interface to HTTP calls by using annotations on the declared methods to
define how requests are made. Create instances using the builder and pass your interface to create to generate an implementation.

将HTTP请求抽象成java接口类，用注解描述和配置网络请求参数，封装Url地址和网络数据请求。通过new Retrofit.Builder().build() 构建 Retrofit 实例对象，同时进行具体配置。

public interface GitHubService {
  @GET("users/{user}/repos")
  Call> listRepos(@Path("user") String user);
}

Create an implementation of the API defined by the service interface.

Retrofit.create() 返回了一个 Service Interface 的 proxy。

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

GitHubService service = retrofit.create(GitHubService.class);

The Retrofit class generates an implementation of the GitHubService interface.Each Call from the created GitHubService can make a synchronous or asynchronous HTTP request to the remote webserver.

Call> repos = service.listRepos("octocat");

网络请求流程：

1. 通过解析网络请求接口的注解配置网络请求参数

2. 通过动态代理生成网络请求对象

3. 通过网络请求适配器将网络请求对象进行平台适配

4. 通过网络请求执行器发送网络请求

5. 通过数据转换器解析服务器返回的数据

6. 通过回调执行器切换线程（子线程 ->>主线程）

7. 用户在主线程处理返回结果

这是别人画的一张图，基本都标出来了，简单的工厂、建造者、单例没有标。

网上大佬画的图

外观模式 Facade

定义：

系统外部与一个子系统的通信必须通过一个统一的外观对象进行，为子系统中的一组接口提供一个一致的界面。外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。外观模式又称为门面模式，它是一种对象结构型模式。

Retrofit 对客户端模块提供统一接口，Retrofit 类内部封装了 ServiceMethod、CallAdapter 和 Converter 等组件。并且 CallAdapter 和 Converter 都是抽象为接口，用户可以扩展自定义的实现。

public final class Retrofit {
  private final Map> serviceMethodCache = new ConcurrentHashMap<>();

  final okhttp3.Call.Factory callFactory;
  final HttpUrl baseUrl;
  final List converterFactories;
  final List callAdapterFactories;
  final @Nullable Executor callbackExecutor;
  final boolean validateEagerly;

  Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List converterFactories, List callAdapterFactories,
      @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
    this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
  }
    /*...*/
}

动态代理 Proxy

代理模式是结构型模式。当无法或不想直接访问某个对象，或者访问某个对象比较复杂的时候，可以通过一个代理对象来间接访问，代理对象向客户端提供和真实对象同样的接口功能。经典设计模式中，代理模式有四种角色：

• Subject 抽象主题类——申明代理对象和真实对象共同的接口方法；
• RealSubject 真实主题类——实现了 Subject 接口，真实执行业务逻辑的地方；
• ProxySubject 代理类——实现了 Subject 接口，持有对 RealSubject 的引用，在实现的接口方法中调用 RealSubject 中相应的方法执行；
• Cliect 客户端类——使用代理对象的类。

public class Client
{
    public static void main(String[] args)
    {
        ProxySubject proxy=new ProxySubject();
        proxy.request();
    }
}
//抽象主题
interface Subject
{
    void request();
}
//真实主题
class RealSubject implements Subject
{
    public void request()
    {
        System.out.println("访问真实主题方法...");
    }
}
//代理
class ProxySubject implements Subject
{
    private RealSubject realSubject;
    public void request()
    {
        if (realSubject==null)
        {
            realSubject=new RealSubject();
        }
        preRequest();
        realSubject.request();
        postRequest();
    }
    public void preRequest()
    {
        System.out.println("访问真实主题之前的预处理。");
    }
    public void postRequest()
    {
        System.out.println("访问真实主题之后的后续处理。");
    }
}

代理模式分为静态代理和动态代理，严格按照上述角色定义编写的代码属于静态代理，即在代码运行前 ProxySubject 代理类的 .class 编译文件就已存在。Retrofit使用的是动态代理，是通过反射机制来动态生成方法接口的代理对象的。动态代理的实现是通过 JDK 提供的 InvocationHandler 接口，实现该接口重写其调用方法 invoke。

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。

先看老师给的示例代码（）

定义 Isubject 接口，里面有两个方法

public interface ISubject {
   public void request();
   public void output();
}

RealSubject 实现接口，是真实主题

public class RealSubject implements ISubject {

   @Override
   public void request() {
      System.out.println("从房主处租房");

   }
   
   public void output(){
      try {
         Thread.sleep(100);
         System.out.println("装修");
      } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   }

}

动态代理类，实现 InvocationHandler 接口，重写 invoke 方法中体现了代理类的工作

/**
 * 该代理类的内部属性是Object类型，实际使用的时候通过该类的构造方法传递进来一个对象
 * 此外，该类还实现了invoke方法，该方法中的method.invoke其实就是调用被代理对象的将来执行的方法，
 * 方法参数是obj,表示该方法从属于obj，通过动态代理类，我们可以在执行真是对象的方法前后加入额外的一些方法
 * @author Zan Wang
 *
 */
public class DynamicSubject implements InvocationHandler {
   private Object obj;
   Date t1, t2;
   long dateDiff;
   
   public DynamicSubject(Object obj) {
      this.obj = obj;
   } 

// Object proxy:代理对象
// Method method:目标类要执行的方法，
// Object[] args:方法中的参数
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      t1 = new Date(System.currentTimeMillis());
      System.out.println(method.getName() + "操作前的时间: " + new SimpleDateFormat("yyyy/MM/dd-HH:mm:ss:SSS").format(t1));
      
      method.invoke(obj, args);//真实主题的工作
      
      t2 = new Date(System.currentTimeMillis());
      System.out.println(method.getName() + "操作后的时间: " + new SimpleDateFormat("yyyy/MM/dd-HH:mm:ss:SSS").format(t2));
      
      dateDiff = t2.getTime() - t1.getTime(); 
      System.out.println(dateDiff + "毫秒完成了操作");
      return null;
   }

}

public class DynamicClient {

   public static void main(String[] args) {
      System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
      System.out.println(System.getProperties().get("sun.misc.ProxyGenerator.saveGeneratedFiles"));
      //真实主题 
      RealSubject realSubject = new RealSubject();
       //动态代理
      InvocationHandler handler = new DynamicSubject(realSubject);
       //获得类信息
      Class clazz = handler.getClass();
      System.out.println("$Proxy0.class全名: "+Proxy.getProxyClass(clazz.getClassLoader(), realSubject.getClass().getInterfaces()));
      
      //下面的代码一次性生成代理
      ISubject subject = (ISubject)Proxy.newProxyInstance(clazz.getClassLoader(), 
            realSubject.getClass().getInterfaces(), handler);
      subject.request();
      subject.output();
      System.out.println(subject.getClass());
   }

}

再看看 Retrofit 的代码

public  T create(final Class service) {
  Utils.validateServiceInterface(service);
  if (validateEagerly) {
    eagerlyValidateMethods(service);
  }
    //返回动态代理类
  return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service },
      new InvocationHandler() {
        private final Platform platform = Platform.get();

          //处理 method 分为三种情况：Object 的方法，直接返回 Object 的实现；判断是否 Java8 支持的 DefaultMethod；或创建 OkHttpCall，通过 ServiceMethod 转换为接口的动态代理类。
        @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
            throws Throwable {
          // If the method is a method from Object then defer to normal invocation.
          if (method.getDeclaringClass() == Object.class) {
            return method.invoke(this, args);
          }
          if (platform.isDefaultMethod(method)) {
            return platform.invokeDefaultMethod(method, service, proxy, args);
          }
          ServiceMethod serviceMethod =
              (ServiceMethod) loadServiceMethod(method);
          OkHttpCall