一定能看懂的 Retrofit 最详细的源码解析-CFANZ编程社区

前提

友情提醒

1.这篇文章主要讲retrofit如何request 和 response 2.不会详细到每个api 3.文章会以一个flow 来讲解

上图

retrofit初始化配置

 private Retrofit createRetrofit(OkHttpClient client, String url) {
 return new Retrofit.Builder()
 .baseUrl(url)
 .client(client)
 .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
 .addConverterFactory(GsonConverterFactory.create())
 .build();
 }

这里我们只说一下主要的东西，大家都知道retrofit的adapter 我们根据我们api请求的不同设置不同的adapter来让retrofit执行不同的操作，当我们在设置他的CallAdapter时，点进源码可以看到，retrofit把这个CallAdapter存入了一个集合中

final List

然后通过build把这个集合回传给了retrofit的这个全局边变量List<CallAdapter.Factory> adapterFactories保存着这些CallAdapter，仔细看的同学会发现，retrofit会默认给你添加一个CallAdapter

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

以上就说到这里，知道有个CallAdapterFactory集合存在Retrofit的全局变量中。

配置Api

public interface Api {

 @Multipart
 @POST("upload")
 Observable postVoice(@Part("deviceNo") RequestBody deviceNo,
 @Part("duration") RequestBody duration,
 @Part("title") RequestBody title,
 @Part MultipartBody.Part file);
 @GET("selfList")
 Call getVoiceList(@Query("deviceNo")String deviceNo);

}

Request

当我们要发起请求的时候，我们是不是这样做，拿到之前配置好的Retrofit然后调用他的Create方法然后把相应的api传入. Retroift.create(Api.class)这样的操作

现在我们进入源码查看这个retrofit最亮点的地方（create（api.class）），通过反射实例化接口，然后拦截接口中的方法，来做api的请求。返回给这个method。

先把源码晾上然后讲解

 public  T create(final Class 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 {
 ·······省略的代码·······
 ServiceMethod

上面的代码已经是把无关紧要的代码剔除了，我们只看重要的代码

我们可以看到create这个方法通过代理反射实例化我们传进来的api接口
然后通过ServiceMethod和OkHttpCall来拿到这个方法的相关参数，来invoke这个方法
最后通过serviceMethod.callAdapter.adapt(okHttpCall)把请求到的值返回回去

其实在最后一步大家应该明白了，请求是来自于ServiceMethod的callAdapter参数，然后通过adapt来进行okhttp请求。

下面我会讲解这个calladapter 如何而来。

ServiceMethod如何发起请求

这是一个流程哈，我们这时候进入代码core部分，他的ServiceMethod时通过retrofit的loadServiceMethod拿到的实例化对象。我们进入这个方法可以看到其实这是一个全局的ServiceMethod的cacheMap

 ServiceMethod<?, ?> loadServiceMethod(Method method) {
 ServiceMethod<?, ?> result = serviceMethodCache.get(method);
 if (result != null) return result;

 synchronized (serviceMethodCache) {
 result = serviceMethodCache.get(method);
 if (result == null) {
 result = new ServiceMethod.Builder<>(this, method).build();
 serviceMethodCache.put(method, result);
 }
 }
 return result;
 }

但是不论他做不做缓存肯定有new 的地方，然后才能加入缓存中吧。从上图代码中我们可以看到这个new 的地方。

if (result == null) {
 result = new ServiceMethod.Builder<>(this, method).build();
 serviceMethodCache.put(method, result);
 }

这下清楚了ServiceMethod哪里来的了吧，通过new ServiceMethod.Builder<>(this, method).build()这句话来的。看源码不都这样吗！一步一步的进入源码然后理解他的每一层意思和目的。to be continue

上ServiceMethod.Builder的源码，我们只看重要的代码，其他的忽略

 Builder(Retrofit retrofit, Method method) {
 this.retrofit = retrofit;
 this.method = method;
 this.methodAnnotations = method.getAnnotations();
 this.parameterTypes = method.getGenericParameterTypes();
 this.parameterAnnotationsArray = method.getParameterAnnotations();
 }

 public ServiceMethod build() {
 callAdapter = createCallAdapter();
 responseType = callAdapter.responseType();
 ·······省略的代码·······
 }

小伙子们，是不是看到了我们一直最关心的calladapter了，在build的时候通过createCallAdapter来初始化了这个值。进入方法看个究竟

private CallAdapter

看到了吧，小伙伴这个calladapter 来自于retrofit里面的方法，我们在loadServiceMethod的时候还记得这句代码吗？new ServiceMethod.Builder<>(this, method).build()我们把retrofit传了进来，然后这里通过retrofit的callAdapter来获取ServiceMethod的adapter。下面是retrofit的源码获取c

 public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
  }
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
   ·······省略的代码·······
   int start = adapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = adapterFactories.size(); i < count; i++) {
      CallAdapter<?, ?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }

  ·······省略的代码·······
  }

我感觉只要不眼瞎都能看到这个serviceMethod的calladapter 是来自于我们retrofit之前进行初始化配置时候的RxJavaCallAdapterFactory.create() 其实我们可以在之前的图中看到这个flow，.addCallAdapterFactory(RxJavaCallAdapterFactory.create())最终指向的是ServiceMethod的CallAdapter。

进入RxJavaCallAdapterFactory的源码吧。其实这里的代码并不多，只不过有些杂乱。下面我会把不需要的代码过滤

public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {
  /**
   * Returns an instance which creates synchronous observables that do not operate on any scheduler
   * by default.
   */
  public static RxJavaCallAdapterFactory create() {
    return new RxJavaCallAdapterFactory(null, false);
  }

  /**
   * Returns an instance which creates asynchronous observables. Applying
   * {@link Observable#subscribeOn} has no effect on stream types created by this factory.
   */
  public static RxJavaCallAdapterFactory createAsync() {
    return new RxJavaCallAdapterFactory(null, true);
  }

  /**
   * Returns an instance which creates synchronous observables that
   * {@linkplain Observable#subscribeOn(Scheduler) subscribe on} {@code scheduler} by default.
   */
  @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
  public static RxJavaCallAdapterFactory createWithScheduler(Scheduler scheduler) {
    if (scheduler == null) throw new NullPointerException("scheduler == null");
    return new RxJavaCallAdapterFactory(scheduler, false);
  }

  private final @Nullable Scheduler scheduler;
  private final boolean isAsync;

  private RxJavaCallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync) {
    this.scheduler = scheduler;
    this.isAsync = isAsync;
  }

@Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
   ·······省略的代码·······

    if (isCompletable) {
      return new RxJavaCallAdapter(Void.class, scheduler, isAsync, false, true, false, true);
    }

   ·······省略的代码·······

    return new RxJavaCallAdapter(responseType, scheduler, isAsync, isResult, isBody, isSingle,
        false);
  }
}

可以看到这个RxJavaCallAdapterFactory继承了CallAdapter.Factory，实现了他的get方法，在get方法中我们就可以拿到这个CallAdapter,然后进行我们的adapt方法请求。从上面的代码可以看到真正实现CallAdapter的是 RxJavaCallAdapter 我们继续看看这个RxJavaCallAdapter到底干了什么！！！同样我会过滤不需要的代码

final class RxJavaCallAdapter implements CallAdapter

好了，这下清晰了许多

这个RxJavaCallAdapter实现了CallAdapter的adapt请求。然后在adapt中需要传入参数就是Call 然而我们可以回到图中看到，OkHttpCall正好是Call的实现类。这里就是上图中的右边部分。

可以在这个方法中看到了，同步异步请求对应的不一样的然后调用不同的CallEnqueueOnSubscribe，CallExecuteOnSubscribe进行request

进入CallEnqueueOnSubscribe源码看看

final class CallEnqueueOnSubscribe implements OnSubscribe

看到了吧这里终于发起请求了可以看到，执行了OkHttpCall.enqueue请求，同时通过arbiter.emitResponse(response);把参数回调了回来。

这就是retrofit的请求flow。

思路整理

配置retrofit（addCallAdapterFactory）
创建ApiService
通过retrofit的create实例化ApiService接口
创建ServiceMethod
通过retrofit的AdapterFactories拿到ServiceMethod的CallAdapter
创建OkHttpCall请求工具类
通过ServiceMethod的CallAdapter的adapt进行请求并把第六步写好的call当参数传给adapt。
把ServiceMethod请求回来的参数返回给对应的ApiService里面的方法
请求完成