Retrofit2.3.0源码分析

此文章只对 Retrofit构建流程 和 网络请求流程 的主干思路分析。

1.Retrofit创建

Retrofit源码我们需要从Retrofit的使用开始，Retrofit明显使用了Builder模式进行初始化创建，根据Retrofit对象创建主要有六个步骤分析，分别为Builder()、baseUrl(String baseUrl)、client()、addConverterFactory()、addCallAdapterFactory()、build()。

Retrofit mRetrofit = new Retrofit.Builder()
       .baseUrl(HOST)
       .client(new OkHttpClient())
       .addConverterFactory(FastJsonConverterFactory.create())
	   .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
       .build();

1.1 Builder()构建

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() {
  // 获取平台（有Android、Java8）
  this(Platform.get());
}

Builder(Retrofit retrofit) {
  platform = Platform.get();
  callFactory = retrofit.callFactory;
  baseUrl = retrofit.baseUrl;
  converterFactories.addAll(retrofit.converterFactories);
  adapterFactories.addAll(retrofit.adapterFactories);
  // Remove the default, platform-aware call adapter added by build().
  adapterFactories.remove(adapterFactories.size() - 1);
  callbackExecutor = retrofit.callbackExecutor;
  validateEagerly = retrofit.validateEagerly;
}

构造方法中参数Platform.get() 我们来看一下获取的是什么

private static final Platform PLATFORM = findPlatform();

static Platform get() {
  return 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();
}

可以看到Retrofit支持多平台包括Android和Java8，它会根据不同的平台设置不同的线程池，此处记录下当前的平台标记，后面使用到再做分析。

1.2 baseUrl(String baseUrl)

/**
 * Set the API base URL.
 *
 * @see #baseUrl(HttpUrl)
 */
public Builder baseUrl(String baseUrl) {
  checkNotNull(baseUrl, "baseUrl == null");
  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;
}

很容易理解，baseUrl(String baseUrl)是配置服务器地址，如果为空会抛出异常。

1.3 client(OkHttpClient client)

/**
 * The HTTP client used for requests.
 * 

 * This is a convenience method for calling {@link #callFactory}.
 */
public Builder client(OkHttpClient client) {
  return callFactory(checkNotNull(client, "client == null"));
}

/**
 * Specify a custom call factory for creating {@link Call} instances.
 * 

 * Note: Calling {@link #client} automatically sets this value.
 */
public Builder callFactory(okhttp3.Call.Factory factory) {
  this.callFactory = checkNotNull(factory, "factory == null");
  return this;
}

client(OkHttpClient client)方法也只是记录下传进来的OkHttpClient对象，如果不传后面使用的时候会直接new OkHttpClient()进行赋值，所以需要对OkHttpClient对象进行超时设置或者其他拦截可以传入该对象。

1.4 addConverterFactory(FastJsonConverterFactory.create())

/** Add converter factory for serialization and deserialization of objects. */
public Builder addConverterFactory(Converter.Factory factory) {
  converterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

细心的同学已经注意到我们在Buidler()构造的时候有以下一行代码，那我们主动将一个FastJsonConverterFactory添加到converterFactories中是什么用意呢？

converterFactories.add(new BuiltInConverters())

其实Converter主要作用是将HTTP返回的数据解析成Java对象，比如我们常见的网络传输数据Xml、Json、Protobuf等，而FastJsonConverterFactory则将Json转换成我们要的Java对象，不需要我们重新去解析Json数据。

1.5 addCallAdapterFactory(RxJava2CallAdapterFactory.create())

/**
 * Add a call adapter factory for supporting service method return types other than {@link
 * Call}.
 */
public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
  adapterFactories.add(checkNotNull(factory, "factory == null"));
  return this;
}

可以看到CallAdapter同样是被使用list集合维护的对象，说明是可以添加多个的，但也会有默认的一个，我看下面build()方法的源码。

1.6 build()

/**
 * Create the {@link Retrofit} instance using the configured values.
 * 

 * Note: If neither {@link #client} nor {@link #callFactory} is called a default {@link
 * OkHttpClient} will be created and used.
 */
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);
}

build()方法的思路分析一下，baseUrl为空则抛出异常；callFactory为传入的OkHttpClient对象，如果没传就new一个直接使用；callbackExecutor为线程池执行类，根据平台platform创建线程池使用，platform.defaultCallAdapterFactory(callbackExecutor)意思就是默认添加了一个CallAdapter，如果有平台线程池创建ExecutorCallAdapterFactory。callAdapter其实也是运用了适配器模式，是网络请求器Call的适配器，而Retrofit中Call就是指OkHttp，那么CallAdapter就是用来将OkHttp适配给不同平台的，Retrofit主要提供了以下四种CallAdapter：

1. ExecutorCallAdapterFactory（默认）

2. GuavaCallAdapterFactory

3. Java8CallAdapterFactory

4. RxJavaCallAdapterFactory

1.7 Builder模式流程图

综上使用Builder模式创建的Retrofit实例大致思路分析完毕，Retrofit负责接收我们配置的功能然后进行对象的初始化，这个就是Builder模式屏蔽掉创建对象的复杂过程的好处，下面梳理下流程图:

2.网络请求分析

ApiService api = retrofit.create(ApiService.java);
ApiResponse response = api.request(String param);

上面为最简单的网络请求创建，具体RxJava这里不做详细说明，主要分析一下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