Retrofit 学习第三弹—源码分析篇

Retrofit 是目前作为网络请求的主流框架，使用起来很方便，仅需在接口中定义方法，打上注解，而且和 Rxjava 配合起来，可以更好的完成网络请求时的线程切换问题。那么这样一个框架，我们有必要对它的源码分析一下，希望能够从中吸取到一定的东西，Retrofit 框架里面用到了很设多计模式，像外观模式，代理模式，工厂模式，适配器模式，装饰者模式等等，这无疑是学习设计模式很好的一个实例。

如果对 Retrofit 的使用还不是很熟练的话，可以看看我之前写的两篇文章：

Retrofit2.0 学习第一弹——准备篇

Retrofit2.0 学习第二弹——使用篇

在看源码之前，先来看几个问题，带着问题去看源码，这样更有目的性，不至于陷于源码的细节而不能自拔。

(1) 定义网络请求是一个接口，里面的方法都是抽象方法，这些抽象方法是怎么被执行的？

(2) 方法上的注解是如何被解析，转化成网络请求的？

(3) 网络请求我们一般采用异步请求，那么请求结果回来时，是如何进行线程切换的，即切换到主线程？

Retrofit 实例构建

构建 Retrofit 实例是通过 Retrofit.Builder 来构建的，采用构建者模式，配置参数更清晰，而且能够链式调用

Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();

接下来就来看下 Builder 中有哪些参数

public static final class Builder {

    // 平台类型对象：Android
    private final Platform platform;
    
    // 网络请求的工厂，默认为 okhttp3 中的 OkHttpClient,OkHttpClient 实现了 okhttp3.Call.Factory
    private @Nullable okhttp3.Call.Factory callFactory;
    
    // 网络请求的url地址,如 www.baidu.com
    private HttpUrl baseUrl;
    
    // 数据转换器工厂的集合
    private final List converterFactories = new ArrayList<>();
    
    // 网络请求适配器工厂的集合
    private final List callAdapterFactories = new ArrayList<>();
    
    // 回调方法执行器
    private @Nullable Executor callbackExecutor;
    
    // 是否校验接口（针对 java8，java8 中接口方法有默认实现）
    private boolean validateEagerly;

    Builder(Platform platform) {
      this.platform = platform;
    }

    public Builder() {
      this(Platform.get());
    }

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

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

      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        // 默认是 Android平台 中的主线程调度器
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // 网络请求适配器工厂的集合
      List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // 数据转换器工厂的集合
      List converterFactories =
          new ArrayList<>(1 + this.converterFactories.size());
      converterFactories.add(new BuiltInConverters());
      converterFactories.addAll(this.converterFactories);
      // 创建 Retrofit 实例
      return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }
  }

使用 Builder 构建 Retrofit 可以设置这几个参数：

参数	描述	说明
Platform	平台类型	支持 Android，IOS，Java8
okhttp3.Call	用来网络请求 Call 对象，默认为 OkHttpClient	最终生成的是 okhttp3 中的 RealCall 对象，Retrofit 中的 OkHttpCall 是对 okhttp3.Call 的一个包装
HttpUrl	网络请求的url地址	设置的基地址，如 www.baidu.com，接口中注解的是 path
Converter	数据转换器	用于转化数据，将 responseBody 转化为对象，同也可以对请求完成转化
CallAdapter	网络请求适配器	可以对 okhttp3.Call 进行包装适配，如适配使用 Rxjava 请求
Executor	请求结果调度执行器	对网络请求结果进行请求，默认是 Android 平台的 MainThreadExecutor，用来切换到主线程，可进行 UI 更新操作

上面表格中是对各个参数的一个说明，有些参数可以不用设置，会有默认参数：

(1) HttpUrl 必须指定，这个不用多说

(2) okhttp3.Call.Factory 这个参数可以不用设置，默认是 OkHttpClient，OkHttpClient 是 okhttp3 中的，它实现了 okhttp3.Call.Factory 这个接口，当然一般情况下，我们在使用时会自己设置一个 OkHttpClient，对它设置一些 log 打印，证书验证，添加 header 等

(3) Converter 使用来进行数据转化的，一般使用 GsonConverterFactory，默认是 BuiltInConverters

(4) CallAdapter.Factory 是用来生产 CallAdapter 对象的，CallAdapter 是对 okhttp3.Call 进行包装，包装后主要用于控制线程的切换操作，默认由平台提供 platform.defaultCallAdapterFactory(callbackExecutor)

(5) Executor 是请求结果调度执行器，用来切换到主线程，可进行 UI 更新操作，对于 Android 平台，默认提供的是 MainThreadExecutor，默认通过 platform.defaultCallbackExecutor() 获取

Builder 中完成这些参数的设置，就可以创建 Retrofit 的实例了，对于 Retrofit 的参数也就是 Builder 中的参数，这就是构建者模式完成的任务。有些参数可能不是很好理解，后面在流程中会慢慢引入。

构建 Call

动态代理

public interface MyService {

    @GET("v1/user")
    Call getUsers();

假设有这样一个 Service 接口，想实现构建 Call实例，通过反射能够做到么？

(1) 反射是用于获取已创建实例的方法或者属性，并对其进行调用或者赋值；

(2) 反射能够加载一个类，通过 newInstance 方法创建实例，但是接口不行

基于这两条，可以得出对于接口,使用反射不能构建出 Call 实例。在 java 中还有另外一个工具，动态代理。这里对动态代理的机制做一个简单的介绍。

动态代理主要通过 Proxy.newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h) 方法创建接口代理实例，loader 为类加载器，interfaces 是需要生成代理对象的接口数组，handler 是用于自定义处理逻辑的对象。

Class service = MyService.class;
MyInvocationHandler handler = new MyInvocationHandler();
MyService proxy = Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service }, handler);
Call call = proxy.getUsers();

public class MyInvocationHandler implements InvocationHandler {

    public MyInvocationHandler() {
        
    }

    // proxy 是代理实例对象
    // method 这个参数表示传入接口中的所有 Method 对象
    // args => 这个参数对应当前 method 方法中的参数
    @Override
    public void invoke(Object proxy, Method method, Object[] args) {
        ...
    }
}

这么看有些童鞋可能还是不是很理解动态代理，那么看下面的代理类：

public class MyServiceProxy implements MyService {

    private InvocationHandler handler;

    public MyServiceProxy(InvocationHandler handler) {
        
    }

    @Override
    @GET("v1/user")
    public Call getUsers(){
        try {
            Method method = com.xx.proxy.MyService.class.getMethod("getUsers");
            this.handler.invoke(this, method, null);
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

这样看来，代理类是这样的一个类，是不是就能理解了动态代理的机制了。动态代理就是创建这样一个类，然后通过类加载器加载到内存，然后再通过反射创建出代理实例，obj 就是 MyServiceProxy 的一个实例。

Class clazz = classLoader.loadClass("com.xx.proxy.MyServiceProxy");
        Constructor constructor = clazz.getConstructor(InvocationHandler.class);
        Object obj = constructor.newInstance(handler);

Retrofit 中的动态代理

好，现在回到 Retrofit 中，看看 Retrofit 是如何使用动态代理创建 Call 对象的。

在 Retrofit 实例构建中，我们能够拿到 Retrofit 对象 retrofit，通过这个对象调用 create 方法创建 MyServiceProxy 实例，即 retrofit.create(MyService.class)。

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 {
            // 方法是 Object 的一个方法，则直接执行
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            // 如果是 java8 中接口的默认实现，则直接执行
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            // 重点是这三行，也是网络请求执行的代码
            ServiceMethod serviceMethod =
                (ServiceMethod) loadServiceMethod(method);
            OkHttpCall