Retrofit2源码解析

Retrofit2是针对于Android/Java的、基于okHttp的、一种轻量级且安全的、并使用注解方式的网络请求框架。简单的说它是一个基于OkHttp的RESTFUL Api请求工具，它通过接口注解的方式，把注解信息封装成一个Http请求，然后用OkHttp去发送这个请求。
以下是Retrofit的基本使用方法（代码来自网络）：

public interface ZhuanLanApi {
    @GET("/api/columns/{user} ")
    Call getAuthor(@Path("user") String user)
}

public static final String API_URL = "https://zhuanlan.zhihu.com";

Create a very simple REST adapter which points the Zhuanlan API.
Retrofit retrofit = new Retrofit.Builder()
    .baseUrl(API_URL)
    .addConverterFactory(GsonConverterFactory.create())
    .build();

ZhuanLanApi api = retrofit.create(ZhuanLanApi.class);
Call call = api.getAuthor("qinchao");

// 请求数据，并且处理response
call.enqueue(new Callback() {
    @Override
    public void onResponse(Response author) {
        System.out.println("name： " + author.getName());
    }
    @Override
    public void onFailure(Throwable t) {
    }
});

一、Retrofit的构建

Retrofit通过Builder模式创建，我们先看它的成员变量：

    private Platform platform;//平台：安卓、java等
    private okhttp3.Call.Factory callFactory; //okhttp的Call工厂类,自定义newCall将Request转为Call
    private HttpUrl baseUrl;//okhttp中的类，保存解析过的url
    private List converterFactories = new ArrayList<>();//类型转换工厂列表。
    private List adapterFactories = new ArrayList<>();//CallAdapter工厂列表。
    private Executor callbackExecutor;//回调线程池

Platform会根据不同平台创建不同的Platform：

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

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

MainThreadExecutor是主线程回调线程池，ExecutorCallAdapterFactory是默认的类型转换工厂。
build方法中，初始化了网络请求Call、回调线程池callbackExecutor，以及Call适配器CallAdapter和类型转换器converterFactories：

    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 adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

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

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

二、ServiceMethod类：把接口注解数据转出请求数据

当我们要发起一个网络请求时，我们会先定义一个请求接口，通过create方法建构一个Call，那么接口里设置的参数、信息是如果传递到网络请求的呢？或者说，为什么一个接口就可以决定网络请求的方式、网络请求的请求数据呢？看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