超详细Retrofit源码解析（一）

一、什么是Retrofit

A type-safe HTTP client for Android and Java

以上是官网给出的答案，翻译成中文：Retrofit是Android和Java上类型安全的http客户端。

简而言之，Retrofit是对http网络请求框架的封装，与Volley\AsyncHttpClient等类似，简化了用户的http请求流程。

它支持DELETE\GET\POST\PUT\HEADER\OPTION\PATCH等请求方式，默认使用okhttp作为网络请求引擎。

二、Retrofit的一些重要类及接口

• Call

该接口代表一个实际的http请求，它的主要作用有三个：
1. 调用createRawCall创建请求；
2. 调用okhttp发送请求；
3. 将okhttp返回的响应解析成Retrofit对应的Response
4. 对于异步的enqueue操作，还有执行相应的onResponse和onFailure回调操作

抛开mock测试相关，该类的实现类主要有：OkHttpCall\ExecutorCallbackCall。

---

• CallAdapter

顾名思义，该接口的主要作用是适配，将一个带有响应类型为R的Call请求适配成需要的类型T。所以该接口的定义是CallAdapter。其核心方法T adapt(Call call)的作用就在于此。

该类内部还封装了一个抽象工厂类Factory。通过Retrofit.create会产生一个接口对象，该接口对象内部的方法的返回值都具有返回类型。Factory正是用于创建基于该返回类型而生的CallAdapter。

抛开mock测试相关，CallAdapter的实现类主要有：BodyCallAdapter\ResponseCallAdapter\RxJavaCallAdapter\RxJava2CallAdapter。

抛开mock测试相关，CallAdapter.Factory的实现类分布在retrofit-adapters包中，有GuavaCallAdapterFactory\Java8CallAdapterFactory\RxJavaCallAdapterFactory\RxJava2CallAdapterFactory\ScalaCallAdapterFactory

---

• Converter

Converter主要有三个方法，对应三个作用。
1. 当请求带有请求体时，将请求体转换成OkHttp对应的RequestBody
2. 将响应解析成需要的实体对象T
3. 将Field\FieldMap\Header\HeaderMap\Path\Query\QueryMap等的值转换成String类型

当需要自定义数据转换机制时，可以实现该接口，并注册到Retrofit中。目前默认的数据转换采用Gson，也可根据需要自定义成xml\protoBuf\fastJson等。

---

三、根据设计模式分析源码

首先放一张stay大神画的Retrofit请求的流程图

接下来我们将根据这张流程图的走势，结合遇到的设计模式，分析Retrofit的设计源码。对于一些常见的、简单的设计模式，本文不做分析。

---

• 外观（门面）模式

  我们知道，在使用Retrofit库时，基本是围绕着Retrofit这个类本身来使用的。该类内部封装了不同的组件，如CallAdapter\ServiceMethod\Converter等。

  我们在使用Retrofit时，并没有直接与CallAdapter\ServiceMethod\Converter等打交道，而是通过Retrofit提供的接口间接去使用这些组件。这种对外提供简单统一的接口、隐蔽内部子系统的具体实现、将变化隔离的设计方式称为“外观模式”，也叫“门面模式”。

   private final Map<Method, ServiceMethod> serviceMethodCache = new ConcurrentHashMap<>();
  
   final okhttp3.Call.Factory callFactory;
   final HttpUrl baseUrl;
   final List converterFactories;
   final List adapterFactories;
   final @Nullable Executor callbackExecutor;
   final boolean validateEagerly; 
  
  

  ---

• 建造者模式

  在使用Retrofit前，需要先创建出Retrofit对象。Retrofit的构造方法的访问权限是protected级别的，非继承类无法直接通过new Retrofit的方式创建Retrofit对象，同时Retrofit类又是final类型的，因此无法被继承。也就是说，直接通过new Retrofit来构造Retrofit对象的方式是行不通的。

  幸运的是，Retrofit内部提供了Builder建造者类，用于构建Retrofit对象，也就出现了我们使用Retrofit时的通用写法：

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

  通过Builder的build方法，最终生成一个Retrofit对象。这里需要详细分析一下构建流程，以便我们理解Builder中几个重要对象的默认赋值，也便于更好地理解后续文章的分析。

  //无参的构造方法默认调用带有platform参数的构造方法
  public Builder() {
    this(Platform.get());
  }
  
  Builder(Platform platform) {
    this.platform = platform;
  }
  

  在创建Builder对象时，最终会调用带有platForm参数的构造方法。Platform又是什么呢？顾名思义，它代表的是平台的意思，我们跟踪进PlatForm源码查看，会发现内部封装了一个静态私有变量PLATFORM。毫无疑问，这就是我们在Builder构造时传入的参数了。该参数通过findPlatform静态方法获取。

  private static Platform findPlatform() {
  try {
    Class.forName("android.os.Build");
    if (Build.VERSION.SDK_INT != 0) {
      return new Android();
    }
  } catch (ClassNotFoundException ignored) {
  }
  try {
    Class.forName("java.util.Optional");
    return new Java8();
  } catch (ClassNotFoundException ignored) {
  }
  return new Platform();
  }

  当ClassLoader可以查找到android.os.Build，则代表该平台是Android；
  当ClassLoader可以查找到java.util.Optional，则代表是Java8；
  否则直接返回Platform。

  Android和Java8都继承自Platform。

  //Android类定义
  static class Android extends Platform {
      ...
  }
  
  //Java8类定义
  static class Java8 extends Platform {
      ...
  }

  显然，我们的程序是运行在Android上的，因此该处优先返回的自然是Android对象。Android的内部结构如下，大家先熟悉一下，关注重点是ExecutorCallAdapterFactory和MainThreadExecutor。这两个结构在接下来将起到重要作用。

  先小小地剧透一下MainThreadExecutor的作用：它是用来将异步请求的回调从子线程切换到主线程执行的！！！

   static class Android extends Platform {
  @Override public Executor defaultCallbackExecutor() {
    return new MainThreadExecutor();
  }
  
  @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    if (callbackExecutor == null) throw new AssertionError();
    return new ExecutorCallAdapterFactory(callbackExecutor);
  }
  
  static class MainThreadExecutor implements Executor {
    private final Handler handler = new Handler(Looper.getMainLooper());
  
    @Override public void execute(Runnable r) {
      handler.post(r);
    }
  }
  }

  创建完Builder对象之后，接下来就是调用Builder的build方法来构建出具体的Retrofit对象了。

  public Retrofit build() {
  
    okhttp3.Call.Factory callFactory = this.callFactory;
    if (callFactory == null) {
      callFactory = new OkHttpClient();
    }
  
    Executor callbackExecutor = this.callbackExecutor;
    if (callbackExecutor == null) {
      callbackExecutor = platform.defaultCallbackExecutor();
    }
  
    List adapterFactories = new ArrayList<>(this.adapterFactories);
    adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
  
    List converterFactories =
        new ArrayList<>(1 + this.converterFactories.size());
  
  
    converterFactories.add(new BuiltInConverters());
    converterFactories.addAll(this.converterFactories);
  
    return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
        callbackExecutor, validateEagerly);
  }

  build方法里面主要执行了以下几个初始化操作：

  1. 判断callFactory是否为null，，显然，由于使用了无参的Builder构造方法，因此callFactory==null，callFactory默认被赋值为OkHttpClient，即默认使用okhttp作为网络请求引擎。

  2. 判断callbackExecutor是否为null，同样callbackExecutor==null，进入到callbackExecutor = platform.defaultCallbackExecutor()，根据上述分析，这里调用的是Android的defaultCallbackExecutor()，最终返回MainThreadExecutor对象。

  3. adapterFactories添加适配器工厂，默认添加了platform.defaultCallAdapterFactory(callbackExecutor)，回溯到Android类中，发现该方法返回ExecutorCallAdapterFactory对象。

  4. converterFactories添加转换器工厂，默认内置了BuiltInConverters，同时也添加用户自定义的转换器。

  执行完以上初始化操作后，最终会调用Retrofit的构造方法创建对象。

---

• 动态代理

  在创建完Retrofit对象后，还记得接下来的使用姿势吗？

  是的，我们还需要一个接口，在这个接口里面需要预定义一些方法，这些方法使用Retrofit提供的注解声明参数，范式如下：

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

  声明完接口之后，接下来就是调用Retrofit的create方法返回一个接口代理对象，而后就可以通过这个代理对象调用接口中的方法了，范式如下：

  GitHubService service = retrofit.create(GitHubService.class);
  
  Call> repos = service.listRepos("octocat");

  create方法是Retrofit动态代理的核心所在。

   public  T create(final Class service) {
   //传入的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 {
          // 如果方法隶属于Object，则当做普通方法处理
          if (method.getDeclaringClass() == Object.class) {
            return method.invoke(this, args);
          }
          //如果是接口里default方法(Java8新特性)，则调
          //用默认方法处理
          if (platform.isDefaultMethod(method)) {
            return platform.invokeDefaultMethod(method, service, proxy, args);
          }
  
          ServiceMethod serviceMethod =
              (ServiceMethod) loadServiceMethod(method);
          OkHttpCall