Retrofit2实例源码浅析

从Retrofit最基本的用法着手，一步步分析内部调用流程。

此处以一个POST请求为例：

一.构建Retrofit

OkHttpClient client = new OkHttpClient();
retrofit = new Retrofit.Builder()
    .baseUrl(BASE_URL)
    .addConverterFactory(GsonConverterFactory.create())
    .client(client)
    .build();

二.构建接口

public interface ApiService {
    @FormUrlEncoded
    @POST("user/info")
    Call loadUserInfo(@FieldMap Map map);
}

三.发起请求

Call call = retrofit.create(ApiService.class).loadUserInfo(map);
call.enqueue(new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
    }

    @Override
    public void onFailure(Call call, Throwable t) {
    }
});

源码分析

结合上面的例子，看看每一个步骤中源码做了哪些操作

一.构建Retrofit

1）new Retrofit.Builder()

Retrofit通过Builder构建，先看Retrofit.Builder的构造方法

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

构造方法中保存了一个Platform对象，看看Platform是什么

class Platform {
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }
  ···
}

可以看到get()是获取静态成员变量PLATFORM，它又是通过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();
  }

该方法通过反射类名是否存在判断当前运行于哪个平台，这里是Android

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

defaultCallbackExecutor方法内部定义了一个线程池，CallbackExecutor顾名思义就是决定处理response回调时所处线程。这里的线程池MainThreadExecutor创建了一个主线程handler，当执行runnable时，会将任务扔到主线程执行。

defaultCallAdapterFactory方法创建一个ExecutorCallAdapterFactory对象，它继承自CallAdapter.Factory，后面再分析。

2）baseUrl(BASE_URL)

baseUrl方法其实就是将传入的url转换成okhttp3中的HttpUrl对象保存起来

public Builder baseUrl(String baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      // 调用okhttp3的HttpUrl.parse方法转换url
      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();
      // 检查url格式，必须是以"/"结尾
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }
      this.baseUrl = baseUrl;
      return this;
}

3）addConverterFactory(GsonConverterFactory.create())

添加转换器工厂，用于请求、响应对象的序列化和反序列化

public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
}

可以看看本例中传入的GsonConverterFactory，它继承Converter.Factory并实现了其中两个方法，responseBodyConverter和requestBodyConverter：

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

  @Override
  public Converter requestBodyConverter(Type type,
      Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
    TypeAdapter adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonRequestBodyConverter<>(gson, adapter);
  }

分别创建并返回Converter接口的实现类GsonRequestBodyConverter和GsonResponseBodyConverter。GsonRequestBodyConverter负责将请求参数转换成RequestBody，GsonResponseBodyConverter负责将ResponseBody映射成实体类。

public interface Converter {
  T convert(F value) throws IOException;
}

4）client(client)

保存开头创建的OkHttpClient，实际保存okhttp3.Call.Factory接口的实现，后续调用它的newCall方法返回RealCall对象。

public Builder client(OkHttpClient client) {
      return callFactory(checkNotNull(client, "client == null"));
}

public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = checkNotNull(factory, "factory == null");
      return this;
}

5）build()

根据前面设置的参数构建Retrofit实例

public Retrofit build() {
      // 可以看出baseUrl是必填参数
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      // 若开头未设置client，这里也会自动创建
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      // 若为设置callbackExecutor，则调用platform.defaultCallbackExecutor方法，通过上文可以知道，这里返回MainThreadExecutor线程池
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // Make a defensive copy of the adapters and add the default Call adapter.
      // 创建自定义的调用适配器列表的副本，并添加默认调用适配器，默认适配器中保存的线程池即MainThreadExecutor
      List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

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

      // 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());
      converterFactories.addAll(this.converterFactories);

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

Retrofit构造方法

Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List converterFactories, List callAdapterFactories,
      @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = converterFactories; // Copy+unmodifiable at call site.
    this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
}

这里传入的List为不可修改的List。validateEagerly为true的话，在后续的create方法中会立即进行解析ApiService中定义的method，该值默认为false。

以上就是Retrofit初始化时，一些主要的配置项。本例中没有使用addCallAdapterFactory，可以通过该方法配置RxJava使用（需要引入rxjava库依赖），例如：

.addCallAdapterFactory(RxJavaCallAdapterFactory.create())

二.构建接口

上面的例子中定义了一个接口，并且声明了一个方法，Retrofit会根据这个方法上的注解、参数以及返回值进行解析，通过动态代理转换成具体的请求。

三.发起请求

1）retrofit.create(ApiService.class)

创建定义的接口的代理实例

public  T create(final Class service) {
    // 对传入的类进行检查，必须是interface且没有继承扩展其他接口
    Utils.validateServiceInterface(service);
    // validateEagerly可在Retrofit初始化时设置，默认为false
    if (validateEagerly) {
      // 立即加载接口中声明的方法，将方法解析成对应的ServiceMethod对象
      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 {
            // 执行代理类会回调此方法。参数1为代理类实例；参数2为调用的方法；参数3为调用方法中传入的参数
            ···
          }
        });
}

2）loadUserInfo(map)

获得代理类后，调用loadUserInfo方法，返回Call对象。当执行时即触发了代理回调方法invoke()

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.
            // 判断该方法所在类是否是Object
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            // isDefaultMethod默认返回false
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            // 以下三行是关键
            ServiceMethod serviceMethod =
                (ServiceMethod) loadServiceMethod(method);
            OkHttpCall