Retrofit2 源码解析

注意: 本文是对源码的一个跟踪,会对每一行代码有具体的阐述,但是不会介绍 Retrofit 的设计模式。

Retrofit:一个 Restful 设计风格的 HTTP 网络请求框架的封装。基于 OkHttp

A type-safe HTTP client for Android and Java

0. 基本使用

1、Retrofit 将我们的 HTTP API 转换成一个 接口形式。所以我们第一步定义一个 interface

public interface GitHubService {
    @GET("user/{user}/repos")
    Call<List<Integer>> listRepos(@Path("user") String user);
}

2、然后构建一个 Retrofit,通过 create 方法生成 GitHubService 的一个实现。

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

GitHubService service = retrofit.create(GitHubService.class);

3、调用 listRepos 拿到 Call 实例,可以做同步或异步请求。

 Call<List<Integer>> repos = service.listRepos("octocat");

每个 Call 实例只能使用一次,但调用 clone() 将创建一个可以使用的新实例。

1. Retrofit 构建

1.1 Retrofit

首先看看 Retrofit 吧,这个类里面有7个实例变量。我们根据类型和变量名先猜猜是干什么用的,留个大体印象即可。

  // 一个线程安全的、支持高效并发的HashMap,Key 是 Method,Value 是 ServiceMethod。 
  // Method 我们能猜到应该就是上面接口中定义的 listRepos 方法,而这个方法中有很多注解,@GET、@Path 啥的,那这个 ServiceMethod 很有可能是这个方法的封装。
  // 而变量名带个 Cache 说明,会把这个 Method 对应的 ServiceMethod 缓存起来。
  private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();

  // 想必你知道 Retrofit 就是基于 OkHttp 的封装,那这个 Call.Factory,明显就是 Call 的工厂类。
  // 至于 Call 是干嘛的,负责创建 HTTP 请求,HTTP 请求被抽象为了 okhttp3.Call 类,它表示一个已经准备好,可以随时执行的 HTTP 请求。
  // 所以这个 Factory 就是用来生产 Call 对象的。注意是 okhttp 里的 Call 对象。
  final okhttp3.Call.Factory callFactory;
  // 这个很好理解了,就是上面 基本使用 中的 baseUrl,可是这是个 HttpUrl 类型的,我们传的可是 String 类型的呀,那估计是通过 Builder 做了处理的。
  final HttpUrl baseUrl;
  // Converter 根据字面意思可得 这应该是个转换器,用于把我们的 响应 转换成特定的格式
  final List<Converter.Factory> converterFactories;
  // CallAdapter 根据字面意思,难道是对 Call 的一个适配?这里的 CallAdapter 是 Retrofit 包下的。
  final List<CallAdapter.Factory> callAdapterFactories;
  // Executor 很熟悉了,这是个回调 Executor,想必就是用来切换线程的了
  final @Nullable Executor callbackExecutor;
  // 这个就猜不出了,只能暂时理解为一个标志位
  final boolean validateEagerly;

再来看看 Retrofit 的构造函数

  Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List<Converter.Factory> converterFactories, List<CallAdapter.Factory> 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;
  }

并没做什么特殊的处理,就是简单的赋值,那想必所有初始化的操作都在 Builder 里了。

那么成功建立一个 Retrofit 对象的标准就是:配置好Retrofit 里的成员变量。

  • callFactory : 网络请求 工厂
  • baseUrl :网络请求的基本 Url 地址
  • converterFactories :数据转换器 工厂集合
  • callAdapterFactories :网络请求适配器 工厂集合
  • callbackExecutor :回调方法执行器

1.2 Retrofit.Builder

public static final class Builder {
    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private final List<Converter.Factory> converterFactories = new ArrayList<>();
    private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();
    private @Nullable Executor callbackExecutor;
    private boolean validateEagerly;

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

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

    // ... ...
    }

我们可以看到 Builder 与 Retrofit 的参数几乎一样,只是少了 serviceMethodCache,多了个 Platform。这个 Platform 很重要。我们通过 Builder 的构造函数可以知道,调用了 Platform.get()方法,然后赋值给自己的 platform 变量。 我们看看这个 Platform 类。

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

  // ... ...
 }

get 方法会去调用 findPlatform 方法,这个里面很明显跟平台相关,Class.forName 要求 JVM 根据 className 查找并加载指定的类,如果未找到则抛出 ClassNotFoundException 。这里很明显我们分析 Android 平台,所以会 return 一个 Android()对象。

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

我们在这里面可以看到两个重要的方法

  • defaultCallbackExecutor :这个方法返回的是个 Executor ,我们想到 Retrofit 正好有个 Executor 类型的变量,那么想必就是它了,它是 MainThreadExecutor 类型的,内部采用 handler 执行任务。
  • defaultCallAdapterFactory :这个方法返回的是个 CallAdapter.Factory,Retrofit 成员变量中也正好有个 CallAdapter.Factory 类型的变量,所以说这个 Platform 很重要嘛,跟我们 Retrofit 类中的两个成员变量都有重大的关系。这里最终返回的是个 ExecutorCallAdapterFactory ,话说我们一开始就不知道这个 CallAdapter 是什么,更不用说这个 Factory 了,那我们先看看这个 ExecutorCallAdapterFactory 吧。
final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
  final Executor callbackExecutor;

  ExecutorCallAdapterFactory(Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }

  @Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call<Object> adapt(Call<Object> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }

  //... ... 省略
}

这里我们可以看到,把我们传进来的 Executor 保存起来了,这个 Executor 想必就是 MainThreadExecutor 了。至于 get 方法,我们暂时还不知道哪里用到了,所以后面的暂时不看了,到了这里还是不知道 CallAdapter.Factory 干嘛用的。

看来 Builder 方法很复杂呀,写了这么多只是讲了个 Platform,不过幸好这里面也包括了 Executor 和 CallAdapter.Factory ,那么现在我们正式看看 Builder.build()方法。

public Retrofit build() {
      // 这一句告诉我们,baseUrl 是必不可少的。
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      // 这里如果你没配置 callFactory , 会默认配置为 OkHttpClient
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      // 同样的,没配置的话,会默认配置为 Platform 的 defaultCallbackExecutor,这里我们之前分析过,它所返回的就是 MainThreadExecutor
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // 这里会把你所配置的 CallAdapter.Factory 加到 List 里去,
      // 最后把 Platform 默认的 defaultCallAdapterFactory 即 ExecutorCallAdapterFactory 加到 List 的最后边,
      List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // 这里一样会把你配置的 Converter.Factory 加到 List 里去,但是会把一个 BuiltInConverters 加到第一个,而不是最后一个,请注意这点。
      // Make a defensive copy of the converters.
      List<Converter.Factory> 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);

      //最后返回一个 Retrofit 对象
      return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }

到这里,我们的 Retrofit 就构建完成了。如果按照我们 基本使用 中的例子,那么此刻,Retrofit 成员变量的值如下:

  • serviceMethodCache :暂时为空的 HashMap 集合
  • callFactory : OkHttpClient 对象
  • baseUrl : 根据配置的baseUrl ” https://api.github.com/ ” 字符串, 构建出了一个 HttpUrl 对象
  • converterFactories :一个 ArrayList 对象,里面存放着一个BuiltInConverters 对象
  • callAdapterFactories :一个 ArrayList 对象,里面存放着一个 ExecutorCallAdapterFactory 对象
  • callbackExecutor :MainThreadExecutor 对象
  • validateEagerly :默认值 false

2. 创建网络请求接口实例,即 GitHubService service = retrofit.create(GitHubService.class);

接下来我们看看是怎样获得 GitHubService 实例的。
同样上源码,注意这里的 create 是非常重要的一个方法,这里使用了 外观模式 和 代理模式。

    public <T> T create(final Class<T> 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<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

这里我们看到了 validateEagerly 变量,让我们看看它到底控制了什么。进 eagerlyValidateMethods 方法。

  private void eagerlyValidateMethods(Class<?> service) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
      if (!platform.isDefaultMethod(method)) {
        loadServiceMethod(method);
      }
    }
  }

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

这里又见到了 Platform ,在 Retrofit.Builder 我们知道它返回的是 Android() 对象。 接着是个 循环 ,循环取出接口中的 Method ,接着调用 loadServiceMethod 。 loadServiceMethod 里面会根据 Method 生成一个 ServiceMethod,然后存入 serviceMethodCache , 那么我们大概知道,这是属于提前验证,会提前把接口中每个方法进行解析得到一个 ServiceMethod 对象,然后存入缓存中。 在 loadServiceMethod 中会取缓存中的值,如果有就直接返回 ServiceMethod。

由此可以知道 validateEagerly 变量是用于 判断是否需要提前验证解析的。

create 方法中 继续往下走,会看到 return 一个 代理对象 Proxy ,并转成了 T 类型,即 GitHubService 。
此时我们这句代码 GitHubService service = retrofit.create(GitHubService.class); 中的 service 有值了,它指向一个 实现了 GitHubService 接口的 代理对象 Proxy 。

3. 拿到 Call 对象 , 即 Call<List<Repo>> repos = service.listRepos("octocat");

这里我们的 service 是个代理对象,所以执行 listRepos 方法时, 会先走 InvocationHandler 中的 invoke 方法。

  public <T> T create(final Class<T> 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.
            // 如果这个方法是声明在 Object 类中,那么不拦截,直接执行
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            // 这个总是返回的false,所以不用关心
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }

            // 下面三行代码非常重要,重点分析,分别对应 3.1 3.2 3.3 三个小节
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.adapt(okHttpCall);
          }
        });
  }

3.1 ServiceMethod<Object, Object> serviceMethod = (ServiceMethod<Object, Object>) loadServiceMethod(method);

首先 ServiceMethod 我们之前猜测过,应该是对 Method 的一个封装, 而这个 loadServiceMethod ,如果你还记得的话,我们在 create 的时候就碰到过,eagerlyValidateMethods 这个方法内部调用过 loadServiceMethod ,是为了加载这个 ServiceMethod 。现在我们来深入分析这个 loadServiceMethod 方法。

  ServiceMethod<?, ?> loadServiceMethod(Method method) {
    // 首先从 缓存 serviceMethodCache 中取 ServiceMethod ,如果存在就返回,不存在继续往下走。
    // 也就是说 我们的 ServiceMethod 只会创建一次。
    ServiceMethod<?, ?> result = serviceMethodCache.get(method);
    if (result != null) return result;

    synchronized (serviceMethodCache) {
      //这里又从缓存取了一遍,看到这里有没有一种熟悉的感觉,是不是跟 DCL 单例模式特别像,双重校验。
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder<>(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

到这里其实 loadServiceMethod 已经分析完了,很简单,就是个 DCL 单例模式,然后获得 ServiceMethod 。
那其实我们现在的分析任务就很明确了,弄清楚这个 ServiceMethod 究竟是什么 。

3.1.1 ServiceMethod 分析
 final class ServiceMethod<R, T> {
  // ... 省略部分代码
  private final okhttp3.Call.Factory callFactory;
  private final CallAdapter<R, T> callAdapter;
  private final HttpUrl baseUrl;
  private final Converter<ResponseBody, R> responseConverter;

  // 同样先猜猜什么意思吧
  // 应该是网络请求的 Http 方法,比如 GET、POST 啥的
  private final String httpMethod;
  // 相对地址 ,应该就是 "user/{user}/repos" 这一段
  private final String relativeUrl;
  // http 请求头
  private final Headers headers;
  // 网络请求的 http 报文的 body 的类型
  private final MediaType contentType;
  // 是否有 body
  private final boolean hasBody;
  // post 提交数据时,是否使用 表单提交 方式
  private final boolean isFormEncoded;
  // post 提交数据时,是否使用 Mutipart 方式,一般用来文件上传
  private final boolean isMultipart;
  // 方法参数处理器,应该是解析方法中的 参数 的吧,这个估计也得详细分析下。
  private final ParameterHandler<?>[] parameterHandlers;

  ServiceMethod(Builder<R, T> builder) {
    this.callFactory = builder.retrofit.callFactory();
    this.callAdapter = builder.callAdapter;
    this.baseUrl = builder.retrofit.baseUrl();
    this.responseConverter = builder.responseConverter;
    this.httpMethod = builder.httpMethod;
    this.relativeUrl = builder.relativeUrl;
    this.headers = builder.headers;
    this.contentType = builder.contentType;
    this.hasBody = builder.hasBody;
    this.isFormEncoded = builder.isFormEncoded;
    this.isMultipart = builder.isMultipart;
    this.parameterHandlers = builder.parameterHandlers;
  }

  // ... 省略部分代码

首先看看 ServiceMethod 的构造方法。 也是通过建造者模式构建的。其中很多变量其实都很熟悉了,比如 callFactory 、 baseUrl 。 对于 callAdapter、responseConverter 我们别弄混了,我们在 Retrofit 类中的变量是 callAdapterFactories 和 converterFactories , 是它们的工厂,是生产它们的地方。

接下来看 Builder 吧,毕竟这是真正做事的。

  public ServiceMethod build() {
      // 拿到具体的 CallAdapter 即 网络请求适配器,具体看 3.1.1.1
      callAdapter = createCallAdapter();
      // 根据上面拿到的 callAdapter 获取 响应类型,在 3.1.1.1 小节分析完后可知道
      // 在我们的例子中 responseType = java.util.List<java.lang.Integer>
      responseType = callAdapter.responseType();
      if (responseType == Response.class || responseType == okhttp3.Response.class) {
        throw methodError("'"
            + Utils.getRawType(responseType).getName()
            + "' is not a valid response body type. Did you mean ResponseBody?");
      }
      // 获取 响应转换器 ,具体看 3.1.1.2 小节
      responseConverter = createResponseConverter();
      // 解析网络请求接口中方法的注解,这里我们就只有一个 @GET 注解,具体看 3.1.1.3 小节
      // 这里解析完可以拿到 Http 请求方法、请求体、相对 url、相对 url 中的参数
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }
      //解析完方法上的注解后,做校验
      if (httpMethod == null) {
        throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      if (!hasBody) {
        if (isMultipart) {
          throw methodError(
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        if (isFormEncoded) {
          throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
        }
      }

      // 解析当前方法的参数,这里就我们的例子而言
      // parameterAnnotationsArray 就是 @Path ,所以这里的 length 就是 1
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        // parameterTypes 是参数类型,就本例而言是 String
        Type parameterType = parameterTypes[p];
        if (Utils.hasUnresolvableType(parameterType)) {
          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
              parameterType);
        }

        // 拿到第一个参数的 注解数组
        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        if (parameterAnnotations == null) {
          throw parameterError(p, "No Retrofit annotation found.");
        }
        // 解析参数
        // p : 0
        // parameterType : String
        // parameterAnnotations : 虽然是数组,但是就一个元素 @Path
        // 这个 parseParameter 就不分析了,大家自己看看源码就清楚了,无非就是构建 ParameterHandler 数组,而这个 ParameterHandler 其实就是负责解析 API 定义时每个方法的参数,并在构造 HTTP 请求时设置参数
        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }
      // 解析完方法中参数的注解后,做校验
      if (relativeUrl == null && !gotUrl) {
        throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
      }
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError("Non-body HTTP method cannot contain @Body.");
      }
      if (isFormEncoded && !gotField) {
        throw methodError("Form-encoded method must contain at least one @Field.");
      }
      if (isMultipart && !gotPart) {
        throw methodError("Multipart method must contain at least one @Part.");
      }

      return new ServiceMethod<>(this);
    }
3.1.1.1 createCallAdapter ()
  private CallAdapter<T, R> createCallAdapter() {
      // 拿到网络请求接口里方法的返回值类型,在我们的例子中会返回如下类型
      // retrofit2.Call<java.util.List<java.lang.Integer>>
      Type returnType = method.getGenericReturnType();

      if (Utils.hasUnresolvableType(returnType)) {
        throw methodError(
            "Method return type must not include a type variable or wildcard: %s", returnType);
      }
      // 如果返回类型是 void ,抛出异常
      if (returnType == void.class) {
        throw methodError("Service methods cannot return void.");
      }
      // 拿到方法的 注解 ,在我们的例子中就是如下所示,大家可以自己实验下
      // @retrofit2.http.GET(value=users/{user}/repos)
      Annotation[] annotations = method.getAnnotations();
      try {
        // 拿到注解后,返回个 CallAdapter ,跟进去看看究竟是做了什么
        return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create call adapter for %s", returnType);
      }
    }


  public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
    // 这里会去调用 nextCallAdapter
    return nextCallAdapter(null, returnType, annotations);
  }

  // 这里的参数大家注意
  // skipPast 上面传的是 null
  // returnType 就是 retrofit2.Call<java.util.List<java.lang.Integer>>
  // annotations 在我们的例子中就是 @retrofit2.http.GET(value=users/{user}/repos)
  public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {
    checkNotNull(returnType, "returnType == null");
    checkNotNull(annotations, "annotations == null");

    // callAdapterFactories 是一个 ArrayList 对象,里面存放着一个 ExecutorCallAdapterFactory 对象 ,这个是在 Retrofit Builder 的时候创建的,也就是我们上面所说的生产 CallAdapter 的地方,大家可以回过头去看看。 这里的 skipPast 是null, 所以 indexOf 肯定返回的 -1, 所以这里 start = 0
    int start = callAdapterFactories.indexOf(skipPast) + 1;
    // 循环, 这里由于我们的 callAdapterFactories 只有一个 元素, 所以直接看 ExecutorCallAdapterFactory 的 get方法
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }

    // 错误信息 builder
    StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
        .append(returnType)
        .append(".\n");
    if (skipPast != null) {
      builder.append(" Skipped:");
      for (int i = 0; i < start; i++) {
        builder.append("\n * ").append(callAdapterFactories.get(i).getClass().getName());
      }
      builder.append('\n');
    }
    builder.append(" Tried:");
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      builder.append("\n * ").append(callAdapterFactories.get(i).getClass().getName());
    }
    throw new IllegalArgumentException(builder.toString());
  }

到这里,我们别忘了我们是在干嘛,我们是在获取 CallAdapter<T, R> ,好了,继续看 ExecutorCallAdapterFactory 的 get方法 。 解释都在代码注释里哟,一定要看看才知道现在到底是在干啥。话说源码分析,还是得靠自己认认真真读一次源码才行。

  @Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    // getRawType 会返回该类型的原始类类型 , 比如传进去的是 List<? extends Runnable> 会返回 List.class
    // 那么在我们的例子中,我们的 returnType 是 retrofit2.Call<java.util.List<java.lang.Integer>>
    // 那么 getRawType 后,返回的是 retrofit2.Call ,所以这里是相等的
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    // 根据 returnType 拿到 responseType ,这里就不跟进了,可以自己去看看
    // 在我们的例子中, responseType = java.util.List<java.lang.Integer>
    final Type responseType = Utils.getCallResponseType(returnType);
    // 最后返回一个 CallAdapter
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call<Object> adapt(Call<Object> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }

到这里,其实我们大概知道这个 CallAdapter 有什么用了,就是提供两个东西

  • 网络请求响应要返回的类型 responseType
  • retrofit2.Call< T > ,注意这里不是 okhttp3 下的 Call ,这里暂不深究。

因为我们不要忘了现在在做什么,我们现在是在获取 ServiceMethod 中的 callAdapter 变量值。所以看到这里返回了一个 CallAdapter 对象即可。

3.1.1.2 createResponseConverter ()

这里个方法是获取 响应转换器, 就是把网络请求得到的响应数据转换成相应的格式。

  private Converter<ResponseBody, T> createResponseConverter() {
      // 拿到方法上所有的注解,在我们的例子中就只有 @GET 注解
      Annotation[] annotations = method.getAnnotations();
      // 这里的 responseType 就是上面我们得到的 List<Integer>
      try {
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }

这里想必大家也知道套路了,跟获取 CallAdapter 是一样的,代码就不贴了,代码里同样是循环遍历 Retrofit 里的 converterFactories 变量。而这个 converterFactories 在我们的例子中是没有设置转换器的,所以它也只有一个默认的元素,即 BuiltInConverters 。 那么我们直接查看 它的 responseBodyConverter 方法。

 final class BuiltInConverters extends Converter.Factory {
  // 注意这里的参数,别忘了到底是什么
  // type : 就是我们的 responseType ,即 List<Integer>
  // annotations : 这里我们方法的注解只有一个,所以就是 @GET
  @Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    if (type == ResponseBody.class) {
      return Utils.isAnnotationPresent(annotations, Streaming.class)
          ? StreamingResponseBodyConverter.INSTANCE
          : BufferingResponseBodyConverter.INSTANCE;
    }
    if (type == Void.class) {
      return VoidResponseBodyConverter.INSTANCE;
    }
    return null;
  }

通过这里我们可以知道,其实它会返回 null 。 所以我们 ServiceMethod 中的 Builder 中的 responseConverter 变量就等于 null 。

3.1.1.3 parseMethodAnnotation ()

我们来看看 解析方法注解 ,注意我们例子中这个方法里传的参数是 @GET 注解

   private void parseMethodAnnotation(Annotation annotation) {
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        //我们这里是 GET 注解,所以进这个方法
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } else if (annotation instanceof HEAD) {
        parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
        if (!Void.class.equals(responseType)) {
          throw methodError("HEAD method must use Void as response type.");
        }
      }
      // 省略后续代码,后续还有很多其他类型的判断
    }


   // 这里的三个参数的值
   // httpMethod : GET
   // value : users/{user}/repos
   // hasBody : false
   private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
      // 此处判断 httpMethod 的值是否存在,说明只允许一个 HTTP 方法存在
      if (this.httpMethod != null) {
        throw methodError("Only one HTTP method is allowed. Found: %s and %s.",
            this.httpMethod, httpMethod);
      }
      this.httpMethod = httpMethod;
      this.hasBody = hasBody;

      if (value.isEmpty()) {
        return;
      }

      // 下面是解析 value 中的 相对 url
      // Get the relative URL path and existing query string, if present.
      int question = value.indexOf('?');
      if (question != -1 && question < value.length() - 1) {
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
        if (queryParamMatcher.find()) {
          throw methodError("URL query string \"%s\" must not have replace block. "
              + "For dynamic query parameters use @Query.", queryParams);
        }
      }

      this.relativeUrl = value;
      // 相对地址中的参数名字,这里不具体分析了,可以把结果告诉你
      // 在我们的例子中 value = “users/{user}/repos”
      // 这里的 relativeUrlParamNames 是个 Set<String> 集合 ,里面只有一个元素 user 。
      this.relativeUrlParamNames = parsePathParameters(value);
    }

至此,我们的 Builder 把 Http 的方法以及它的 Url 给分析完了,现在只剩 参数解析了。参数解析在 ServiceMethod 的 build 方法里已经讲过了 ,记得看注释。
呼~ 终于讲完了 ServiceMethod 的构造。这么大篇幅,由此可以看出 ServiceMethod 这个类非常重要。现在来总结一下,我们究竟拥有了些什么。

  • callFactory : ExecutorCallAdapterFactory 实例
  • callAdapter : ExecutorCallAdapterFactory中的get 方法返回的 CallAdapter 实例
  • baseUrl : HttpUrl 实例
  • responseConverter : 由于我们没设置,所以为 null
  • httpMethod : 字符串 GET
  • relativeUrl :字符串 users/{user}/repos
  • headers : 没有设置 Headers ,所以为 null
  • contentType : null
  • hasBody : false
  • isFormEncoded : false
  • isMultipart : false
  • parameterHandlers : 就我们例子而已,该数组有一个元素,Path 对象,它是 ParameterHandler 抽象类里的一个静态内部类。

由此可以看出,ServiceMethod 对象包含了访问网络的所有基本信息。

好吧,接下来还是得继续前行,别忘了,我们构建 ServiceMethod 只是在 invoke 方法内,并且这还只是第一步。接下来看第二步。

3.2 OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);

这里是 new 一个 OkHttpCall 对象,这个 OkHttpCall 是 Retrofit 的 Call,它里面就是做请求的地方,会有 request、enqueue 等同步、异步请求方法,但是在这里面真正执行请求的是 okhttp3.Call ,即把请求委托给 okHttp 去执行。下面简要看看它的构造方法和一些成员变量吧,因为这里只是 new 操作,所以暂时不分析其余方法,用到的时候再看。

 final class OkHttpCall<T> implements Call<T> {
  // 含有所有网络请求参数信息的 ServiceMethod
  private final ServiceMethod<T, ?> serviceMethod;
  private final @Nullable Object[] args;

  private volatile boolean canceled;

  // 实际进行网络请求的 Call
  private @Nullable okhttp3.Call rawCall;
  @GuardedBy("this") // Either a RuntimeException, non-fatal Error, or IOException.
  private @Nullable Throwable creationFailure;
  @GuardedBy("this")
  private boolean executed;

  // 传入配置好的 ServiceMethod 和 请求参数
  OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {
    this.serviceMethod = serviceMethod;
    this.args = args;
  }

这样就把 OkHttpCall 给构建好了,接下来看第三步。

3.3 return serviceMethod.adapt(okHttpCall);

直接上代码

 T adapt(Call<R> call) { return callAdapter.adapt(call);
  }

这是 前面构建好的 ServiceMethod 中的 adapt 方法,会去调用 callAdapter 的 adapt 方法,我们知道 ServiceMethod 中的 callAdapter 是 ExecutorCallAdapterFactory中的get 方法返回的 CallAdapter 实例。而这个实例的 adapt 方法会返回一个 ExecutorCallbackCall 对象。

 <!-- ExecutorCallAdapterFactory 内部类 -->
 static final class ExecutorCallbackCall<T> implements Call<T> {
    // 这里在之前创建ExecutorCallAdapterFactory时,就知道它的值了,就是 MainThreadExecutor ,用来切换线程的
    final Executor callbackExecutor;
    // 这就是刚刚传进来的 OkHttpCall
    final Call<T> delegate;

    ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
      this.callbackExecutor = callbackExecutor;
      this.delegate = delegate;
    }

到这里为止,我们已经成功的返回了一个 Call<List<Integer>>

4. 调用 Call 的 enqueue

趁热打铁,我们执行异步请求,看看怎样切换线程的。

 <!-- ExecutorCallbackCall 内部 -->
 @Override
 public void enqueue(final Callback<T> callback) {
      checkNotNull(callback, "callback == null");

      // 真正的 Call 去执行请求
      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          // 回调后 利用 MainThreadExecutor 中的 Handler 切换到主线程中去。
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                // Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
              } else {
                callback.onResponse(ExecutorCallbackCall.this, response);
              }
            }
          });
        }

        @Override public void onFailure(Call<T> call, final Throwable t) {
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }

可以看到是 delegate 执行了 enqueue 操作,而 delegate 就是我们的 OkHttpCall ,在 OkHttpCall 里的 enqueue 方法是这样工作的。
通过 okhttp3.Call call = serviceMethod.toCall(args); 构建一个真正执行请求的 Call ,即把请求交给 okhttp 去完成。而构建一个 Call 利用到了 ServiceMethod 中的 ParameterHandler 对象,这个对象是用来处理参数的。 它会把具体参数的值与 RequestBuilder 绑定起来。当然也用到了 ServiceMethod 自己,ServiceMethod 类似请求响应的大管家。

别忘了拿到响应后,在 okhttp3.Callback 中会去调用 response = parseResponse(rawResponse); 将响应转换成自己想要的格式,即定义的 Converter 。

到这里终于结束了,当然在响应解析这里还有许多没讲,但是 Retrofit 一个主体的流程已经走完了。真累。。。
没啥总结的了,这篇文章只是用来跟踪具体的源码,具体到每一句代码都有解释。至于 Retrofit 的设计思路,别的文章都有讲。

总之,在自己跟着分析完这么一大段后,已经对 Retrofit 相当熟悉了,遇到问题,相信也可以定位到源码中去找到问题的根源,然后解决,至此,目标已达成。

参考
https://blog.csdn.net/carson_ho/article/details/73732115
https://www.jianshu.com/p/fb8d21978e38
https://blog.csdn.net/justloveyou_/article/details/72783008
https://imququ.com/post/four-ways-to-post-data-in-http.html