Android 主流框架源码分析 - Retrofit源码分析

  今天我来记录一下我对Retrofit框架的理解。不得不说，Retrofit的架构设计极其优秀，既保证了使用上的方便，又高度解耦。同时Retrofit又是学习设计模式的不二典范，里面使用的设计模式数不胜数。今天我们来详细的剖析这个框架。
  本文参考资料：

  1. 这是一份很详细的 Retrofit 2.0 使用教程（含实例讲解 )
  2. Android:手把手带你深入剖析 Retrofit 2.0 源码

  由于Retrofit里面涉及到RxJava和Gson相关知识，所以在阅读本文之前，最好是对RxJava原理有一定的了解。至于Gson，只要会用就行，其实我也不太了解Gson的原理。

1. 先逼逼几句

  众所周知，Retrofit是基于OkHttp设计的一个网络请求框架。其实说Retrofit是一个网络不是那么准确，准确来说，Retrofit就是OkHttp的一个外壳，Retrofit的底层网络请求使用就是OkHttp。
  同时，Retrofit完全兼容RxJava，这使得它的使用范围进一步扩大，因为这个特性，进一步促进演变近几年比较火的Android架构框架 - RxJava + Retrofit + MVP。
  本文打算从Retrofit的基本使用开始，深入分析Retrofit的整个工作流程，包括线程调度、与RxJava兼容等等。

2. Retrofit组成部分

  Retrofit分为4个部分，我们来看看。

名字	含义
自定义的请求接口	主要定义一些网络请求基本参数，比如请求方式(get或者post)，表单等等
由请求接口生成OkHttp的Request	根据自定义的请求接口，生成对应的可以执行的Request，此过程只要在ServiceMethod里面完成
网络请求执行器-Call	用来执行生成的Request,在Retrofit里面，使用了装饰者模式，OkHttpCall只是外壳，内部的Call才是真正执行Request的
数据转换器-Converter	主要是将返回的Response解析成为我们想要的Java类对象

  提一句，Retrofit是适合于Restful API的网络请求框架，如果想要让Retrofit支持非Restful API，可以参考这一篇文章：如何使用Retrofit请求非Restful API(悄悄的给你们说一句，这个问题，我在腾讯面试被问过)
  我们先大体看看Retrofit怎么通过这四个部分来进行工作。

3. 基本使用

  本文简单介绍一下Retrofit的基本使用，让大家有一个印象。但是毕竟不是初级文章，不会在方面花很多的时间。
  首先需要定义一个接口。

public interface Service {

  @POST("getSongPoetry")
  @FormUrlEncoded
  Observable getCall(@Field("page") int page, @Field("count") int count);
}

  然后创建一个Retrofit的对象。

  private Retrofit mRetrofit = new Retrofit.Builder()
    .baseUrl("http://api.apiopen.top/")
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    .addConverterFactory(GsonConverterFactory.create())
    .build();

  然后通过Retrofit的对象获得接口的代理对象。

    Service service = mRetrofit.create(Service.class);

  最后调用对应的接口来请求数据。

    service.getCall(1, 20)
      .observeOn(Schedulers.newThread())
      .subscribeOn(AndroidSchedulers.mainThread())
      .subscribe(new Observer() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Bean bean) {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
      });

  整个Retrofit的网络请求过程就是这样，是不是非常的简单？这里面我们根本不需要考虑线程调度的问题，以及数据解析的问题，Retrofit已经给我们做了。

4. Retrofit

  从现在开始，我们正式开始分析Retrofit整个工作流程。我们先来看看Retrofit对象的创建。

  private Retrofit mRetrofit = new Retrofit.Builder()
    .baseUrl("http://api.apiopen.top/")
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    .addConverterFactory(GsonConverterFactory.create())
    .build();

  从这里，我们已经可以看到两个设计模式--建造者模式和工厂模式。当然我们也没必要紧张，就是两个的设计模式而已。
  这里通过调用Retrofit一个内部类Builder一系列的方法，进而初始化了Retrofit一些必须的对象。

(1).Builder

  我们先来看看Builder类,我们先从它的成员变量开始

    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private final List converterFactories = new ArrayList<>();
    private final List callAdapterFactories = new ArrayList<>();
    private @Nullable Executor callbackExecutor;
    private boolean validateEagerly;

变量名	类型	作用
platform	Platform	平台的对象，通过调用Platform的get方法,可以获得适合当前环境的平台，包括Java8、Android(似乎Retrofit 2.4.0将其他的平台移除了)。Platform可以通过调用defaultCallAdapterFactory方法可以获得网络执行适配器的工厂类，调用defaultCallbackExecutor方法可以获得线程调度的对象
callFactory	okhttp3.Call.Factory	网络请求执行器的工厂类，用来创建网络请求执行器的对象
baseUrl	HttpUrl	网络请求的URL基地址，完整的URL地址应当是baseUrl + relativeUrl。其中，调用Builder的baseUrl方法设置的就是基地址，在接口中@Post注解里面的值就是relativeUrl
converterFactories	List	数据转换器的数组，当收到Response时，Retrofit会根据接口里面定义的返回类型在converterFactories里面找到合适的数据转换器，从而将Response转换成为正确的类型。
callAdapterFactories	List	网络请求执行适配器的数组，跟List一样，会根据接口里面定义的类型来找到合适的适配器。但是二者有所不同，待会会详细的分析。
callbackExecutor	Executor	回调线程池，主要是将结果发送到指定的线程，比如，在Android平台上，肯定是将结果发送到主线程。
validateEagerly	boolean	是否提前将接口里面的方法解析成为ServiceMethod。至于什么是ServiceMethod,后面会详细的解释。

  上表中详细的解释了Builder每一个成员变量的作用，在Builder类中，每一个成员变量都有一个对应的方法用来赋值。比如说addCallAdapterFactory方法可以往callAdapterFactories添加一个适配器，其他的也是如此。
  接下来我们看看Builder的build方法。

    public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // Make a defensive copy of the adapters and add the default Call adapter.
      List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      List converterFactories =
          new ArrayList<>(1 + this.converterFactories.size());

      // Add the built-in converter factory first. This prevents overriding its behavior but also
      // ensures correct behavior when using converters that consume all types.
      converterFactories.add(new BuiltInConverters());
      converterFactories.addAll(this.converterFactories);

      return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }

  哟哟，这个build方法里面还做了不少的事情的，我们来看重点。

      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

  从这里，我们可以看出来，如果我们设置网络请求执行器，默认就是OkHttpClient，这个OkHttpClient在OkHttp是一个非常核心的类，是网络请求必须的类。这里不对OkHttpClient进行展开，毕竟是OKHttp的相关知识。

      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

  同理，如果回调线程池默认也为该平台的回调线程池。比如说，如果是Android平台，那么肯定是调用这段代码：

    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

  从MainThreadExecutor的名字，我们就可以得出结果，肯定是用来回调到主线程的，毕竟在Android中，只有主线程才能更新UI。
  至于其他的，都是常规的赋值，这里就不详细讲解了。
  在build方法最后一行代码，创建了一个Retrofit的对象。我们来看看Retrofit的构造方法。

  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;
  }

  其实也没做什么事情，就是将Builder的成员变量对应的赋值给Retrofit。

(2).Retrofit的创建为什么要使用建造者模式？

  我们发现，经过一些操作，最终的目的就是创建一个Retrofit对象，然后给Retrofit的成员变量赋值，为什么我们需要多一个Builder，然后绕一大圈来创建一个Retrofit对象呢？
  我首先问一句，在外面写这么一句代码就能创建完整的Retrofit对象，觉得爽不爽？

  private Retrofit mRetrofit = new Retrofit.Builder()
    .baseUrl("http://api.apiopen.top/")
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    .addConverterFactory(GsonConverterFactory.create())
    .build();

  不用说，肯定爽，首先外部代码简洁，通过调用对应方法来给变量赋值，链式编程方格6的不行。其次，在Retrofit的构造方法也是非常的简洁，没有各种判断，所有的工作都在Builder的build方法做了。
  所以，我们从Retrofit里面得到，如果一个对象得创建需要给很多的成员变量，不妨使用建造者模式，这使得你的代码更加的简洁。外部使用起来也是非常的简单。

(3).create方法

  从上面的栗子，我们可以知道，当创建完毕一个Retrofit的对象时，如果想要进行网络请求的话，还必须创建接口的代理对象，也就是通过调用create方法来获得一个对象。
  从我的言语之间，你们应该都知道，create方法肯定使用了代理模式，要不然何来代理对象之称。我们来看看create方法的实现。

  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();

          @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