Retrofit源码解析

一，前言

Retrofit其实是将OKhttp封装起来，和volley一样。那解析Retrofit其实就是解析它如何封装使用OKhttp，那我直接从其使用上来跟踪源码。

总体上可以分为四步：

1. 创建Retrofit对象
2. 通过Retrofit获取接口对象
3. 通过接口对象获取请求服务的Call对象
4. 最后通过Call的异步enqueue或同步execute来执行网络请求并回调结果。

下面也是通过这四步来解析源码

二，创建Retrofit对象

先占时不考虑RxJava的使用

Retrofit retrofit = new Retrofit.Builder()  //1
    .baseUrl(baseUrl)   //2
    .addConverterFactory(GsonConverterFactory.create()) //3
    .build();   //4

Retrofit是通过建造者模式来构建对象的，那很明显，这里只是配置了请求网络的参数而已，而这些配置在后面的网络请求和结果转换用到了。

第二步是为了配置请求服务的地址；第三部是配置返回结果的转换器，使结果为对象。

2.1 Builder()

public static final class Builder {
    private final Platform platform;
    // 网络请求器的工厂
    private @Nullable okhttp3.Call.Factory callFactory;
    // 网络请求的url地址
    private HttpUrl baseUrl;
    // 数据转换器工厂的集合，生产数据转换器（converter）
    private final List converterFactories = new ArrayList<>();
    // 网络请求适配器工厂的集合，生产网络请求适配器（CallAdapter）
    private final List adapterFactories = new ArrayList<>();
    //// 请求结束后回调方法的执行Executor
    private @Nullable Executor callbackExecutor;
    // 是否提前对业务接口中的注解进行验证转换的标志位
    private boolean validateEagerly;
    
    Builder(Platform platform) {
      this.platform = platform;
      // 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());
    }
    
    public Builder() {
      this(Platform.get());
    }
    ...
}

Builder里存储的参数都会在Retrofit创建时赋值给它，后面的build()再介绍。

在创建Builder()对象时，其实只赋值了两个属性：platform 和converterFactories。可以知道默认的请求结果转换器为BuiltInConverters，我们开发中一般使用GsonConverterFactory.create()。

2.1.1 Platform

Platform是单例模式，通过Platform.get()来获取对象。

class Platform {
  //单例对象是通过findPlatform()创建的
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  private static Platform findPlatform() {
    try {
      //如果是安卓系统，就返回Android()
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
     // Java8()
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }
  
  static class Android extends Platform {
    //请求结果回调使用的Executor，如果Builder没有赋值给callbackExecutor，就会调用这个方法赋值
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    //Builder里的CallAdapter.Factory，最后会在build()里赋值给adapterFactories，作为默认的网络请求适配器
    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      //那可以看出默认的网络适配器是ExecutorCallAdapterFactory实现的
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

    //调用handler使回调在主线程执行
    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }
}

最为安卓平台，Platform最终赋值的对象是静态内部类Android，这个对象作为默认配置，会在Builder的build()方法中调用赋值。

defaultCallbackExecutor是返回回调执行的Executor，返回的MainThreadExecutor是使用handler让回调操作在主线程执行。如果在Builder中没有指定回调的Executor，会调用defaultCallbackExecutor指定异步网络请求的回调在主线程执行。

defaultCallAdapterFactory则是指定默认网络适配器工厂为ExecutorCallAdapterFactory，调用接口方法返回的Call，就是这个类创建的。具体等后面使用其功能再介绍。

2.2 其它配置

2.2.1 baseUrl

就是将String类型的url，经过合格性检测，拆分存储，再转换成HttpUrl赋值给baseUrl。

public Builder baseUrl(String baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  //将String的转为HttpUrl
  HttpUrl httpUrl = HttpUrl.parse(baseUrl);
  if (httpUrl == null) {
    throw new IllegalArgumentException("Illegal URL: " + baseUrl);
  }
  return baseUrl(httpUrl);
}
public Builder baseUrl(HttpUrl baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  List pathSegments = baseUrl.pathSegments();
  //如果路径结尾不是以"/"结尾，会抛出异常
  if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
    throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
  }
  this.baseUrl = baseUrl;
  return this;
}

值得注意的是，路径必须以"/"结尾

2.2.2 addConverterFactory

//将转换工厂保存到converterFactories中，在构造器中，已经add了一个BuiltInConverters
public Builder addConverterFactory(Converter.Factory factory) {
  converterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

上面的例子是添加GsonConverterFactory，下面来看看它是如何转换的。

2.2.2.1 GsonConverterFactory

public final class GsonConverterFactory extends Converter.Factory {

  @Override
  public Converter responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    TypeAdapter adapter = gson.getAdapter(TypeToken.get(type));
    //返回对应的Converter对象
    return new GsonResponseBodyConverter<>(gson, adapter);
  }
}

final class GsonRequestBodyConverter implements Converter {

    @Override public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      //将ResponseBody转为泛型对象
      return adapter.read(jsonReader);
    } finally {
      value.close();
    }
  }

通过convert转换的类型，是在调用responseBodyConverter创建对象时传入的请求接口的返回类的泛型。也就是例子中的HttpResult。

如果要自定义Converter来实现请求结果转化，按上面那样就可以了，使用工厂方法模式。

1. 继承Converter，在convert方法中返回转换后的结果，比如GsonRequestBodyConverter中是把ResponseBody转成自己需要转的类型。
2. 继承Converter.Factory，在responseBodyConverter中将相应的Converter对象返回。
3. 在Retrofit的创造器中调用addConverterFactory添加相应的Converter.Factory。

2.3 build()

这部将根据先前的配置生成Retrofit，其实Builder中的配置属性几乎都赋值给了Retrofit。

public Retrofit build() {

    //callFactory是类okhttp3.Call.Factory的对象，如果自己没有设置了OkHttp对象，则会自己创建一个。
  okhttp3.Call.Factory callFactory = this.callFactory;
  if (callFactory == null) {
    callFactory = new OkHttpClient();
  }

  //回调方法执行器
  Executor callbackExecutor = this.callbackExecutor;
  //没有指定的话，就用构造器中赋值的platform中的，也就是将回调放在主线程
  if (callbackExecutor == null) {
    callbackExecutor = platform.defaultCallbackExecutor();
  }

  // 将配置的网络适配器进行保护性拷贝
  List adapterFactories = new ArrayList<>(this.adapterFactories);
  //添加默认的网络适配器，也就是ExecutorCallAdapterFactory
  adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

  // 与网络适配器的排序不同，默认的BuiltInConverters放在第一位，后面才是添加的
  List converterFactories = new ArrayList<>(this.converterFactories);

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

对于网络适配器队列存储顺序和数据转化器的队列顺序不同，其实是在后面给ServiceMethod赋值相应属性时，采取了不同的取值策略。网络适配器优先获取队列前面的；数据转化器虽然也是从队列前面开始适配，但默认的BuiltInConverters要接口返回类型为ResponseBody或Void才会返回Converter对象，返回类型为其它时，会继续遍历后面的数据转化器，所以在设定返回值为对象时，GsonConverterFactory会起作用。具体后面ServiceMethod创建时会介绍。

2.4 总结

在最后build()中，可以发现创建Retrofit时，传入了6个参数。

1. OKHttp对象。比如设置连接超时时间的OKHttp
2. 服务器地址。必填
3. 请求结果的数据转换器。对于请求结果的返回类型进行转换
4. 网络适配器。默认为ExecutorCallAdapterFactory，通常设置为RxJava2CallAdapterFactory.create()。
5. 回调方法执行器。默认回调在主线程执行。
6. 是否提前对业务接口中的注解进行验证转换的标志位。在create中有用到。

比较重要的类有设置默认回调方法执行器和默认网络适配器的Platform；默认的数据转换器BuiltInConverters。

三 通过Retrofit获取接口对象

MovieService movieService = retrofit.create(MovieService.class);

public interface MovieService {
    //get请求
    @GET("top250")
    //网络请求数据的方法，@Query配置请求参数
    Call>> getTopMovie(@Query("start")int start, @Query("count")int count);
}

MovieService是个接口，里面定义了一个方法，通过注解上面配置了请求接口的参数配置，retrofit通过方法的参数创建接口对象。

那来看看如何通过接口来获取对象。

3.1 create

public  T create(final Class service) {
    Utils.validateServiceInterface(service);
    //是否提前通过注解加验证加载请求接口，会将接口中的方法都解析成ServiceMethod，并加入serviceMethodCache缓存中
    if (validateEagerly) {
      eagerlyValidateMethods(service);
    }
    //创建动态代理对象，用来代理接口
    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class[] { service },
    new InvocationHandler() {   //将代理类的实现交给 InvocationHandler类作为具体的实现
      private final Platform platform = Platform.get();

      //被代理执行的方法，是通过在InvocationHandler中的invoke方法调用的
      @Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
          throws Throwable {
        // Object的方法直接调用原方法
        if (method.getDeclaringClass() == Object.class) {
          return method.invoke(this, args);
        }
        //android默认为false，不走
        if (platform.isDefaultMethod(method)) {
          return platform.invokeDefaultMethod(method, service, proxy, args);
        }
        
        //这里才是被代理方法真正执行的地方
        //通过接口方法的注解来获取ServiceMethod
        ServiceMethod serviceMethod =
            (ServiceMethod) loadServiceMethod(method);
        OkHttpCall