Retrofit 源碼閱讀

當前版本2.9.0

簡單示例

1. 添加依賴

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'

2. 代碼

interface GitHubService {
    @GET("users/{user}/repos")
    Call<List<Repo>> listRepos(@Path("user") String user);
}
// 創建Retrofit
Retrofit retrofit =
        new Retrofit.Builder()
                .baseUrl("https://api.github.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
// 創建目標對象的代理對象(動態代理實現)
GitHubService service = retrofit.create(GitHubService.class);
// 返回Call對象,該對象中包含OkHttpCall
Call<List<Repo>> call = service.listRepos("octocat");
try {
    // 同步請求
    call.execute();
} catch (IOException e) {
    e.printStackTrace();
}
// 異步請求
call.enqueue(new Callback<List<Repo>>() {
    @Override
    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
    }
    @Override
    public void onFailure(Call<List<Repo>> call, Throwable t) {
    }
});

Retrofit客戶端創建

Retrofit.Builder()與.baseUrl(XXXX)

public final class Retrofit {
...
    public static final class Builder {
        // 最終走這裏
        Builder(Platform platform) {
          this.platform = platform;
        }
        public Builder() {
          // 看看Platform
          this(Platform.get());
        }
        // 爲Retrofit.Builder設置BaseUrl
        public Builder baseUrl(String baseUrl) {
          // HttpUrl.get(baseUrl): 將字符串解析爲HttpUrl對象.此處不細看了.
          return baseUrl(HttpUrl.get(baseUrl));
        }
        public Builder baseUrl(HttpUrl baseUrl) {
          Objects.requireNonNull(baseUrl, "baseUrl == null");
          List<String> pathSegments = baseUrl.pathSegments();
          // baseUrl最後必須是"/"結尾
          if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
            throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
          }
          // 爲Retrofit.Builder設置BaseUrl
          this.baseUrl = baseUrl;
          return this;
        }
    }
}

Platform.get()

class Platform {
    // Platform對象是一個單例
    private static final Platform PLATFORM = findPlatform();
    // 獲取Platform對象
    static Platform get() {
      return PLATFORM;
    }
    private static Platform findPlatform() {
      return "Dalvik".equals(System.getProperty("java.vm.name"))
          ? new Android() // Android平臺
          : new Platform(true);
    }
    // Android類
    static final class Android extends Platform {
        Android() {
          super(Build.VERSION.SDK_INT >= 24);
        }
        // response回調到主線程將由MainThreadExecutor對象來處理
        @Override
        public Executor defaultCallbackExecutor() {
          return new MainThreadExecutor();
        }
        // MainThreadExecutor類
        static final class MainThreadExecutor implements Executor {
          // 主線程Handler,可以將執行任務切換到主線程中執行  
          private final Handler handler = new Handler(Looper.getMainLooper());
          @Override
          public void execute(Runnable r) {
            handler.post(r);
          }
        }
    }
}

.addConverterFactory(GsonConverterFactory.create())與.addCallAdapterFactory(RxJava2CallAdapterFactory.create())

添加轉換器工廠,比如需要將請求服務器得到的Json數據格式化爲Call<List<Repo>>類型.

public final class Retrofit {
    public static final class Builder {
        // 爲Retrofit.Builder對象中的converterFactories集合中添加數據轉換器工廠
        // converterFactories爲Builder中專門存放數據轉換器工程的集合
        public Builder addConverterFactory(Converter.Factory factory) {
          converterFactories.add(Objects.requireNonNull(factory, "factory == null"));
          return this;
        }
        // 爲Retrofit.Builder對象中的callAdapterFactories集合中添呼叫適配器工廠,比如Retrofit自帶的DefaultCallAdapterFactory.
        public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
          callAdapterFactories.add(Objects.requireNonNull(factory, "factory == null"));
          return this;
        }
    }
}

.build();

public final class Retrofit {
    public static final class Builder {
        public Retrofit build() {
          // BaseUrl必須存在  
          if (baseUrl == null) {
            throw new IllegalStateException("Base URL required.");
          }
          okhttp3.Call.Factory callFactory = this.callFactory;
          if (callFactory == null) {
            // callFactory可以自己手動添加client(OkHttpClient client)
            // 如果不添加,則默認創建一個OkHttpClient對象.
            callFactory = new OkHttpClient();
          }
          Executor callbackExecutor = this.callbackExecutor;
          if (callbackExecutor == null) {
            // 從platform對象中獲取一個回調執行器,下面會看下這裏
            callbackExecutor = platform.defaultCallbackExecutor();
          }
          // 在之前呼叫適配器工廠集合基礎上重新構建一個集合
          List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
          // 另外這裏將Retrofit中默認的呼叫適配器工廠也添加到了集合中  
          callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
          // 數據轉換器工廠集合  
          List<Converter.Factory> converterFactories =
              new ArrayList<>(
                  1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
          // BuiltInConverters 數據轉換器是給Streaming註解使用的,下面會詳細分析.  
          converterFactories.add(new BuiltInConverters());
          // 將Builder對象中的數據轉換器工廠集合全部添加到新的集合中 
          converterFactories.addAll(this.converterFactories);
          // 另外這裏將Retrofit中默認的數據轉換器工廠添加到新集合中  
          converterFactories.addAll(platform.defaultConverterFactories());
          // 最後一步是創建Retrofit對象
          return new Retrofit(
              callFactory,
              baseUrl,
              unmodifiableList(converterFactories),
              unmodifiableList(callAdapterFactories),
              callbackExecutor,
              validateEagerly);
        }
    }
}

platform.defaultCallbackExecutor()與platform.defaultConverterFactories(),platform.defaultCallAdapterFactories(callbackExecutor)

class Platform {
    // 返回一個數據轉換器工廠集合,集合中的成員變量類型OptionalConverterFactory,這個工廠最終會生成一個OptionalConverter對象,
    // 將Response轉換之後生成Optional<T>類型,這個沒用過.
    List<? extends Converter.Factory> defaultConverterFactories() {
      return hasJava8Types ? singletonList(OptionalConverterFactory.INSTANCE) : emptyList();
    }
    // 返回一個數據呼叫適配器工廠集合
    List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
        @Nullable Executor callbackExecutor) {
      // executorFactory: 這個是Retrofit 中自帶默認呼叫適配器工廠.
      DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);
      return hasJava8Types
          ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
          : singletonList(executorFactory);
    }
    ...
    // Android類
    static final class Android extends Platform {
        Android() {
          super(Build.VERSION.SDK_INT >= 24);
        }
        // platform.defaultCallbackExecutor() 返回回調執行器對象
        @Override
        public Executor defaultCallbackExecutor() {
          return new MainThreadExecutor();
        }
        ...
    }
}

new Retrofit()

public final class Retrofit {
    private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
    final okhttp3.Call.Factory callFactory;
    final HttpUrl baseUrl;
    final List<Converter.Factory> converterFactories;
    final List<CallAdapter.Factory> callAdapterFactories;
    final @Nullable Executor callbackExecutor;
    final boolean validateEagerly;
    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;
    }
}

創建API接口的代理對象以及接口中方法調用

retrofit.create(GitHubService.class);

public final class Retrofit {
    private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
    final okhttp3.Call.Factory callFactory;
    final HttpUrl baseUrl;
    final List<Converter.Factory> converterFactories;
    final List<CallAdapter.Factory> callAdapterFactories;
    final @Nullable Executor callbackExecutor;
    final boolean validateEagerly;
    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;// 該變量表示是否需要提前加載API接口中的方法信息
    }
    
    public <T> T create(final Class<T> service) {
      // 是否需要提交加載API接口中方法信息  
      validateServiceInterface(service);
      // 這裏就是創建API接口的代理對象
      // 當由代理對象調用接口中的方法時,最終會調用到代理對象中的invoke().
      return (T)
          Proxy.newProxyInstance(
              service.getClassLoader(),
              new Class<?>[] {service},
              new InvocationHandler() {
                private final Platform platform = Platform.get();
                private final Object[] emptyArgs = new Object[0];
                ===================================================
                // 注意:當前方法將在調用service.listRepos("XXX");時候觸發
                ===================================================
                @Override
                public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
                    throws Throwable {
                  ...
                  args = args != null ? args : emptyArgs;
                  // 最終執行 loadServiceMethod(method).invoke(args);
                  // method: 對應的就是代理對象所調用的方法
                  // loadServiceMethod(method): 最終返回的是HttpServiceMethod對象
                  return platform.isDefaultMethod(method)
                      ? platform.invokeDefaultMethod(method, service, proxy, args)
                      : loadServiceMethod(method).invoke(args);
                }
              });
    }
    // 該方法作用是是否提前解析API接口
    private void validateServiceInterface(Class<?> service) {
      ...
      // validateEagerly: 該變量表示是否需要提前加載API接口中的方法信息
      if (validateEagerly) {
        Platform platform = Platform.get();
        for (Method method : service.getDeclaredMethods()) {
          if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
            // 是否將API接口中的方法信息加載到serviceMethodCache中
            loadServiceMethod(method);
          }
        }
      }
    }
    
    // 該方法將根據網絡API接口方法信息返回HttpServiceMethod對象
    ServiceMethod<?> loadServiceMethod(Method method) {
      ServiceMethod<?> result = serviceMethodCache.get(method);
      // 假如API方法信息已經解析過了,就將HttpServiceMethod對象返回.
      if (result != null) return result;
      synchronized (serviceMethodCache) {
        result = serviceMethodCache.get(method);
        if (result == null) {
          // 如果API方法信息還沒解析,就開始解析.
          result = ServiceMethod.parseAnnotations(this, method);
          // 將解析後的HttpServiceMethod對象存入集合中
          serviceMethodCache.put(method, result);
        }
      }
      return result;
    }
}

ServiceMethod.parseAnnotations(this, method);

abstract class ServiceMethod<T> {
    // 通過API接口方法信息解析
    static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
      // RequestFactory.parseAnnotations(retrofit, method):解析API接口中的方法,得到請求報文工廠
      RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
      // 通過API接口方法信息得到方法的返回類型
      Type returnType = method.getGenericReturnType();
      ...
      // 返回類型不能爲空  
      if (returnType == void.class) {
        throw methodError(method, "Service methods cannot return void.");
      }
      // 返回一個HttpServiceMethod對象看看.
      return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
    }
    // 這是一個抽象方法,當API接口代理對象調用接口中方法時候,代理對象的invoke()將被調用, 最後會委託給HttpServiceMethod對象的invoke().
    abstract @Nullable T invoke(Object[] args);
}

final class RequestFactory {
    static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
      // 這裏也是用的構建者模式  
      return new Builder(retrofit, method).build();
    }
    // Builder類
    static final class Builder {
        Builder(Retrofit retrofit, Method method) {
          this.retrofit = retrofit;
          this.method = method;
          this.methodAnnotations = method.getAnnotations(); //獲取API接口方法中的註解
          this.parameterTypes = method.getGenericParameterTypes(); // 獲取API接口方法中的參數類型
          this.parameterAnnotationsArray = method.getParameterAnnotations();// 獲取API接口中方法的參數註解
        }
        RequestFactory build() {
          for (Annotation annotation : methodAnnotations) {
            // 這個方法是解析GET,POST,Headers,FormUrlEncoded等等信息
            parseMethodAnnotation(annotation);
          }
          ...   
          // 最後返回RequestFactory, 這個類就是將API接口中方法註解逐步的拆解,得到請求報文工廠
          return new RequestFactory(this);
        }
    }
}

HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);

abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
    static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {
      // 獲取API接口方法的返回值類型  
      Type adapterType = method.getGenericReturnType();
      ...
      // 通過返回值類型,API接口方法信息等,創建一個呼叫適配器 
      CallAdapter<ResponseT, ReturnT> callAdapter =createCallAdapter(retrofit, method, adapterType, annotations);
      // 獲取響應數據類型  
      Type responseType = callAdapter.responseType();
      ...
      // 通過響應數據類型,API接口方法信息等創建一個響應數據轉換器  
      Converter<ResponseBody, ResponseT> responseConverter =createResponseConverter(retrofit, method, responseType);
      // 這個是OkHttp對象  
      okhttp3.Call.Factory callFactory = retrofit.callFactory;
      // 最後返回CallAdapted對象,這個不要與上面的callAdapter對象弄混淆了
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    }
    // 創建真實的呼叫適配器對象
    private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
      try {
        return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(method, e, "Unable to create call adapter for %s", returnType);
      }
    }
    // 創建響應數據轉換器
    private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(Retrofit retrofit, Method method, Type responseType) {
      Annotation[] annotations = method.getAnnotations();
      try {
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(method, e, "Unable to create converter for %s", responseType);
      }
    }    
}

retrofit.callAdapter(returnType, annotations)與retrofit.responseBodyConverter(responseType, annotations);

這一段是創建呼叫適配器,以便返回相匹配的Call.另外還會創建匹配的數據轉換器,以便返回正確的響應數據類型.

public final class Retrofit {
    public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
      return nextCallAdapter(null, returnType, annotations);
    }
    public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {
      ...
      // start = 0  
      int start = callAdapterFactories.indexOf(skipPast) + 1;
      for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
        // 呼叫適配器工廠集合, 這裏拿Retrofit默認呼叫適配器對象來分析吧
        // 假如callAdapterFactories.get(i)取得的對象是DefaultCallAdapterFactory類型,來分析他的get()
        CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
        if (adapter != null) {
          return adapter;
        }
      }
      ...
    }
    // 創建響應數據轉換器 
    public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
      return nextResponseBodyConverter(null, type, annotations);
    }
    public <T> Converter<ResponseBody, T> nextResponseBodyConverter(@Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
      Objects.requireNonNull(type, "type == null");
      Objects.requireNonNull(annotations, "annotations == null");
      // start = 0    
      int start = converterFactories.indexOf(skipPast) + 1;
      for (int i = start, count = converterFactories.size(); i < count; i++) {
        // 這裏和查找匹配的呼叫適配器是一樣的操作
        // 這裏假如converterFactories.get(i)找到的是GsonConverterFactory,來看看他的responseBodyConverter()方法
        // type是一個JavaBean類,就是請求網絡返回的數據類型.
        Converter<ResponseBody, ?> converter =converterFactories.get(i).responseBodyConverter(type, annotations, this);
      }
    }
}
// DefaultCallAdapterFactory類
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
    @Override
    public @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
      // 假如API接口方法中的返回值類型不是Call.class,那就說明這個呼叫工廠適配器就不滿足這個API接口方法,
      // 那麼上一步中的nextCallAdapter()方法中的循環遍歷查找呼叫適配器工廠集合還會繼續遍歷
      if (getRawType(returnType) != Call.class) {
        return null;
      }
      ...
      // 獲取最終返回的數據類型,例如returnType的類型爲Call<List<Repo>>
      // Utils.getParameterUpperBound(0, (ParameterizedType) returnType)最終得到的類型就是List<Repo>
      // 參考文章:https://www.jianshu.com/p/cfa74c980b25  
      final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
      ...
      return new CallAdapter<Object, Call<?>>() {
        // 該方法是用來返回響應數據類型的
        @Override
        public Type responseType() {
          return responseType;
        }
        // 該方法用來返回網絡請求的代理對象Call.
        @Override
        public Call<Object> adapt(Call<Object> call) {
          return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
        }
      };
    }
}
// GsonConverterFactory類
public final class GsonConverterFactory extends Converter.Factory {
    private final Gson gson;
    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
      // type是一個JavaBean類,就是請求網絡返回的數據類型.  
      TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
      return new GsonResponseBodyConverter<>(gson, adapter);
    }
}
// GsonResponseBodyConverter類
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
    GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
      this.gson = gson;
      this.adapter = adapter;
    }
    // 該方法就是將ResponseBody 返回的數據轉換爲JavaBean類.
    @Override
    public T convert(ResponseBody value) throws IOException {
      JsonReader jsonReader = gson.newJsonReader(value.charStream());
      try {
        T result = adapter.read(jsonReader);
        if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
          throw new JsonIOException("JSON document was not fully consumed.");
        }
        return result;
      } finally {
        value.close();
      }
    }
}

new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);

abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
    static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {
      // 獲取API接口方法的返回值類型  
      Type adapterType = method.getGenericReturnType();
      ...
      // 通過返回值類型,API接口方法信息等,創建一個呼叫適配器 
      CallAdapter<ResponseT, ReturnT> callAdapter =createCallAdapter(retrofit, method, adapterType, annotations);
      // 獲取響應數據類型  
      Type responseType = callAdapter.responseType();
      ...
      // 通過響應數據類型,API接口方法信息等創建一個響應數據轉換器  
      Converter<ResponseBody, ResponseT> responseConverter =createResponseConverter(retrofit, method, responseType);
      // 這個是OkHttp對象  
      okhttp3.Call.Factory callFactory = retrofit.callFactory;
      // 最後返回CallAdapted對象,這個不要與上面的callAdapter對象弄混淆了
      // 
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    }
    // 在Retrofit.create(GitHubService.class)會創建一個API接口的代理對象,當代理對象調用接口中方法時候,
    // 最終就會調用代理對象中的invoke()方法, 該方法最終會返回一個Call對象.
    // loadServiceMethod(method).invoke(args):這個invoke()方法就是此處的invoke().
    @Override
    final @Nullable ReturnT invoke(Object[] args) {
      // loadServiceMethod(method)方法其實最終的類型爲下面的HttpServiceMethod.CallAdapted類, 他實現了adapt()方法.
      Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
      // 這裏創建了了一個OkHttpCall對象. 
      // adapt(call, args)最終返回一個ExecutorCallbackCall類型的對象. 
      return adapt(call, args);
    }
    // 這個抽象方法最終由HttpServiceMethod.CallAdapted實現
    protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);

    // CallAdapted類
    static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
        private final CallAdapter<ResponseT, ReturnT> callAdapter;
        @Override
        protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
          // 假設callAdapter爲DefaultCallAdapterFactory創建,看下DefaultCallAdapterFactory中的adapte().
          // 這裏特地說下call是OkHttpCall類型的對象.
          // 下面分下到callAdapter.adapt(call)最終返回一個ExecutorCallbackCall類型的對象.  
          return callAdapter.adapt(call);
        }
    }
}
// DefaultCallAdapterFactory類
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
    // 這裏再說明下, 這個get()方法其實在HttpServiceMethod.parseAnnotations()中創建呼叫適配器的時候已經執行過了.
    // 他將get()中創建的CallAdapter對象返回了,被傳遞到了HttpServiceMethod.CallAdapted類中爲callAdapter屬性值.
    @Override
    public @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
      ...
      return new CallAdapter<Object, Call<?>>() {
        @Override
        public Type responseType() {
          return responseType;
        }
        // 該方法最終在HttpServiceMethod.CallAdapted.adapt()中被執行.
        @Override
        public Call<Object> adapt(Call<Object> call) {
          return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
        }
      };
    }
}

ExecutorCallbackCall

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
    // ExecutorCallbackCall類
    static final class ExecutorCallbackCall<T> implements Call<T> {
        final Executor callbackExecutor;// 這個如果按照之前分析的就是MainThreadExecutor對象了,可以將回調發送到主線程中執行.
        final Call<T> delegate;// 這個對象其實就是OkHttpCall對象了
        ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
          this.callbackExecutor = callbackExecutor;
          this.delegate = delegate;
        }
    }
}

正式開始網絡請求

call.execute();與call.enqueue()

service.listRepos("XXXX");最終得到的對象爲ExecutorCallbackCall類型,下面就開始調用網絡了

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
    // ExecutorCallbackCall類
    static final class ExecutorCallbackCall<T> implements Call<T> {
        final Executor callbackExecutor;// 這個如果按照之前分析的就是MainThreadExecutor對象了,可以將回調發送到主線程中執行.
        final Call<T> delegate;// 這個對象其實就是OkHttpCall對象了
        ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
          this.callbackExecutor = callbackExecutor;
          this.delegate = delegate;
        }
        // 同步調用
        @Override
        public Response<T> execute() throws IOException {
          return delegate.execute();
        }
        // 異步調用
        @Override
        public void enqueue(final Callback<T> callback) {
          Objects.requireNonNull(callback, "callback == null");
          delegate.enqueue(
              new Callback<T>() {
                @Override
                public void onResponse(Call<T> call, final Response<T> response) {
                  // 得到響應數據,就使用MainThreadExecutor類型對象將回調發送到主線程執行
                  callbackExecutor.execute(
                      () -> {
                        if (delegate.isCanceled()) {
                          // 這是客戶端的取消回調,被髮送到主線程執行
                          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(() -> callback.onFailure(ExecutorCallbackCall.this, t));
                }
              });
        }
    }
}

delegate.execute()與delegate.enqueue()

final class OkHttpCall<T> implements Call<T> {
    OkHttpCall(RequestFactory requestFactory,Object[] args,okhttp3.Call.Factory callFactory,Converter<ResponseBody, T> responseConverter) {
      // 請求報文  
      this.requestFactory = requestFactory;
      this.args = args;
      // OkHttpClient  
      this.callFactory = callFactory;
      // 響應數據轉換器  
      this.responseConverter = responseConverter;
    }
    // 同步方法
    @Override
    public Response<T> execute() throws IOException {
      okhttp3.Call call;
      synchronized (this) {
        executed = true;
        // 看下這個,獲取一個RealCall
        call = getRawCall();
      }
      ...
      // call.execute() 這裏就是通過RealCall對象執行同步方法了.
      // 再看下parseResponse() 
      return parseResponse(call.execute());
    }
    // 異步方法
    @Override
    public void enqueue(final Callback<T> callback) {
      ...  
      try {
        // 獲取RealCall
        call = rawCall = createRawCall();
      }
      ... 
      // 這裏就是像OkHttp中那樣進行異步請求操作了   
      call.enqueue(
          new okhttp3.Callback() {
            @Override
            public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
              Response<T> response;
              try {
                // 解析異步請求的響應數據
                response = parseResponse(rawResponse);
              } ...
              try {
                // 回調onResponse(),到主線程執行
                callback.onResponse(OkHttpCall.this, response);
              } ...
            }
            @Override
            public void onFailure(okhttp3.Call call, IOException e) {
              callFailure(e);
            }
            private void callFailure(Throwable e) {
              try {
                // 回調onFailure(),到主線程執行
                callback.onFailure(OkHttpCall.this, e);
              } ...
            }
          });
    }
    // 獲取RealCall方法
    @GuardedBy("this")
    private okhttp3.Call getRawCall() throws IOException {
      okhttp3.Call call = rawCall;
      ...
      try {
        // 接着往下看 獲取RealCall
        return rawCall = createRawCall();
      } catch (RuntimeException | Error | IOException e) {
        ...
      }
    }
    // 到這裏就能看清, 這裏是獲取一個RealCall
    private okhttp3.Call createRawCall() throws IOException {
      // callFactory就是一個OkHttpClient,OkHttpClient.newCall()返回的就是一個RealCall
      okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
      ...
      return call;
    }
    // 解析網絡請求的響應數據
    Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
      ResponseBody rawBody = rawResponse.body();
      ...
      ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
      try {
        // 數據轉換器,上面用的是GsonResponseBodyConverter來分析的,上面已經分析過這裏就不說了.
        T body = responseConverter.convert(catchingBody);
        // 最後就是創建一個Response類型的數據返回了.
        return Response.success(body, rawResponse);
      }
    }
    // 寫到最後真的不想寫了...
}