1 簡介

提供給使用者的接口類：Retrofit

Retrofit用注解的方式為HTTP接口適配了帶有回調(diào)的java接口，通過這些java接口可以實(shí)現(xiàn)HTTP請(qǐng)求。

本文Retrofit版本：2.6.0

2 Retrofit組成：

image

2.1 Builder: Retrofit構(gòu)建器（Builder模式）

作用：在保證Retrofit有默認(rèn)組件的情況下，方便使用者自定義相關(guān)Retrofit組件。

小細(xì)節(jié)Platform：
Builder也可以配置Platform，默認(rèn)情況下，Bulder會(huì)自動(dòng)獲取對(duì)應(yīng)的平臺(tái)。

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

可以看到有三個(gè)平臺(tái)，Android（繼承Platform）,Java8（繼承Platform）和Platform自己。

下面再看三個(gè)平臺(tái)區(qū)別：

2.1.1 Platform

Platform平臺(tái)應(yīng)該是用來支持java8版本之下的java平臺(tái)。

class Platform {
    ...
    // 平臺(tái)無回調(diào)執(zhí)行器，應(yīng)該在哪里創(chuàng)建的，就在哪里回調(diào)
  Executor defaultCallbackExecutor() {
    return null;
  }
  // 平臺(tái)默認(rèn)的回調(diào)適配器工廠列表為new DefaultCallAdapterFactory(callbackExecutor)
  List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
      @Nullable Executor callbackExecutor) {
    return singletonList(new DefaultCallAdapterFactory(callbackExecutor));
  }
  // 默認(rèn)回調(diào)適配器工廠數(shù)量為1
    int defaultCallAdapterFactoriesSize() {
    return 1;
  }
  // 默認(rèn)的轉(zhuǎn)換器工廠列表為空列表
    List<? extends Converter.Factory> defaultConverterFactories() {
    return emptyList();
  }
  // 是否是默認(rèn)方法
    boolean isDefaultMethod(Method method) {
    return false;
  }
  // 調(diào)用指定類默認(rèn)的方法會(huì)拋異常，即不支持調(diào)用非默認(rèn)方法
 @Nullable Object invokeDefaultMethod(Method method, Class<?> declaringClass, Object object,
      @Nullable Object... args) throws Throwable {
    throw new UnsupportedOperationException();
  }
    ...
    
}

• isDefaultMethod()返回false，表示傳入的Method都告知不是默認(rèn)方法（默認(rèn)方法是一種公共的非抽象實(shí)例方法，即帶有主體的非靜態(tài)方法，在接口中聲明）
• invokeDefaultMethod返回異常，表示調(diào)用非默認(rèn)方法不支持

2.1.2 Android

static class Android extends Platform {
    // 平臺(tái)默認(rèn)的回調(diào)執(zhí)行器 可以看出默認(rèn)的回調(diào)線程是UI線程，所以使用者不用在回調(diào)里做線程切換
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }
    // 是否是默認(rèn)方法
    @Override boolean isDefaultMethod(Method method) {
    // 如果安卓構(gòu)建版本小于24（安卓7.0），則直接返回是非默認(rèn)方法，否則正常返回method.isDefault()
      if (Build.VERSION.SDK_INT < 24) {
        return false;
      }
      return method.isDefault();
    }
    //回調(diào)執(zhí)行器必須不為空，回調(diào)適配器工廠列表版本小于Android7返回new DefaultCallAdapterFactory(callbackExecutor)單獨(dú)組成的不可變list，否則返回CompletableFutureCallAdapterFactory.INSTANCE和DefaultCallAdapterFactory(callbackExecutor)組成的不可變list
    @Override List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
        @Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);
      // CompletableFutureCallAdapterFactory是支持CompletableFutureCall，是java8特性
      return Build.VERSION.SDK_INT >= 24
        ? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)
        : singletonList(executorFactory);
    }
    // 默認(rèn)的回調(diào)適配器工程個(gè)數(shù)，和defaultCallAdapterFactories對(duì)應(yīng)
    @Override int defaultCallAdapterFactoriesSize() {
      return Build.VERSION.SDK_INT >= 24 ? 2 : 1;
    }
    // 默認(rèn)的轉(zhuǎn)換器工廠
    @Override List<? extends Converter.Factory> defaultConverterFactories() {
    // 如果平臺(tái)支持java8，則讓Converter支持java8操作符
      return Build.VERSION.SDK_INT >= 24
          ? singletonList(OptionalConverterFactory.INSTANCE)
          : Collections.<Converter.Factory>emptyList();
    }
    // 默認(rèn)轉(zhuǎn)換器工廠個(gè)數(shù)
    @Override int defaultConverterFactoriesSize() {
      return Build.VERSION.SDK_INT >= 24 ? 1 : 0;
    }

    //安卓平臺(tái)的主線程執(zhí)行器
    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }

Android有默認(rèn)的MainThreadExecutor，就是Android主線程任務(wù)執(zhí)行器，默認(rèn)的CallAdapter.Factory任務(wù)回調(diào)適配器工廠。

從這里就可以看出Android平臺(tái)上，Retrofit執(zhí)行任務(wù)默認(rèn)是在主線程。

2.1.3 java8

  static class Java8 extends Platform {
  // 默認(rèn)method.isDefault()
    @Override boolean isDefaultMethod(Method method) {
      return method.isDefault();
    }
    // 支持調(diào)用默認(rèn)方法
    @Override Object invokeDefaultMethod(Method method, Class<?> declaringClass, Object object,
        @Nullable Object... args) throws Throwable {
      // Because the service interface might not be public, we need to use a MethodHandle lookup
      // that ignores the visibility of the declaringClass.
      Constructor<Lookup> constructor = Lookup.class.getDeclaredConstructor(Class.class, int.class);
      constructor.setAccessible(true);
      return constructor.newInstance(declaringClass, -1 /* trusted */)
          .unreflectSpecial(method, declaringClass)
          .bindTo(object)
          .invokeWithArguments(args);
    }
    // 默認(rèn)適配器工廠列表，和Android差不多
    @Override List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
        @Nullable Executor callbackExecutor) {
      List<CallAdapter.Factory> factories = new ArrayList<>(2);
      factories.add(CompletableFutureCallAdapterFactory.INSTANCE);
      factories.add(new DefaultCallAdapterFactory(callbackExecutor));
      return unmodifiableList(factories);
    }
    // 默認(rèn)適配器工廠個(gè)數(shù)
     @Override int defaultCallAdapterFactoriesSize() {
      return 2;
    }
    // 默認(rèn)轉(zhuǎn)換器工廠列表
    @Override List<? extends Converter.Factory> defaultConverterFactories() {
      return singletonList(OptionalConverterFactory.INSTANCE);
    }
    // 默認(rèn)轉(zhuǎn)換器工廠個(gè)數(shù)
    @Override int defaultConverterFactoriesSize() {
      return 1;
    }
  }

• isDefaultMethod():返回method.isDefault()
• invokeDefaultMethod()：調(diào)用非默認(rèn)方法接口。

總結(jié)一下：

2.2 合成Retrofit的組件：

Retrofit是一個(gè)門面，這個(gè)門面通過組合各種組件來為使用者提供API。以下就是合成Retrofit的必要組件：

• callFactory:okhttp3.Call.Factory 生成（HTTP調(diào)用對(duì)象）的工廠
• baseUrl:HttpUrl HTTP url相關(guān)
• converterFactories:List<Converter.Factory>
• adapterFactories:List<CallAdapter.Factory>
• callbackExecutor: Executor
• validateEagerly: boolean

2.2.1 okhttp3.Call.Factory

http調(diào)用（call）工廠，就是生產(chǎn)http調(diào)用對(duì)象的工廠

可以看看okhttp3.Call接口

// 表示單個(gè)請(qǐng)求/響應(yīng)，不能執(zhí)行兩次，它是可以取消的。
public interface Call extends Cloneable {
  // 返回發(fā)起請(qǐng)求回調(diào)的Request
  Request request();
  // 同步執(zhí)行
  Response execute() throws IOException;
 //  異步執(zhí)行
  void enqueue(Callback responseCallback);
 // 取消    
  void cancel();
  // 是否已執(zhí)行
  boolean isExecuted();
 // 是否已取消
  boolean isCanceled();
    // 克隆方法
  Call clone();

// 工廠接口
  interface Factory {
  // 工廠方法
    Call newCall(Request request);
  }
}

image

如果你使用過OkHttp3，會(huì)發(fā)現(xiàn)這就是OkHttp3常用的外部接口。所以O(shè)kHttpClient就是它的一個(gè)實(shí)現(xiàn)。所以Retrofit框架里沒有自己擴(kuò)展Call.Factory，那么默認(rèn)工廠就是用的OkHttp3框架里實(shí)現(xiàn)的OkHttpClient。

okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

上面取自Retrofit.Builder.build()里的代碼，可以看到如果用戶沒有指定自定義的okhttp3.Call.Factory，那么默認(rèn)就是用OkHttpClient。

2.2.2 baseUrl:HttpUrl

image

HttpUrl對(duì)象可通過HttpUrl.Build對(duì)象的parse()方法構(gòu)造。HttpUrl包含一個(gè)Http Url的組成信息，比如域名，端口，用戶名，密碼等都可以設(shè)置。

HttpUrl就是Retrofit的基地址，它可以通過HttpUrl.parse(String baseUrl)的匹配校驗(yàn)生成一個(gè)HttpUrl對(duì)象。

例：

 /**
     * Set the API base URL.
     *
     * @see #baseUrl(HttpUrl)
     */
    public Builder baseUrl(String baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      return baseUrl(HttpUrl.get(baseUrl));
    }
    
    public Builder baseUrl(HttpUrl baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      List<String> pathSegments = baseUrl.pathSegments();
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }
      this.baseUrl = baseUrl;
      return this;
    }

上面取自Retrofit.Builder.build()里的代碼，可以得知我們通常set的地址，最后會(huì)轉(zhuǎn)化成一個(gè)HttpUrl對(duì)象。

2.2.3 converterFactories:List<Converter.Factory>

Converter是從一個(gè)對(duì)象轉(zhuǎn)為另一種對(duì)象過程的抽象，簡明一點(diǎn)就叫轉(zhuǎn)換器。比如說你總要把用戶的請(qǐng)求信息轉(zhuǎn)為OkHttp標(biāo)準(zhǔn)的請(qǐng)求結(jié)構(gòu)(Request)，或者是OkHttp的標(biāo)準(zhǔn)響應(yīng)信息(Response)轉(zhuǎn)為用戶數(shù)據(jù)。

把它抽象為一個(gè)接口，接口里就有一個(gè)convert方法

public interface Converter<F, T> {
    // T是目標(biāo)類型，F(xiàn)是原始類型
  T convert(F value) throws IOException;
  }

然而Converter又可以是多種多樣的，這樣就最好是用工廠類來生產(chǎn)：

  abstract class Factory {
    // 生產(chǎn)responseBody轉(zhuǎn)換器
    public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type,
        Annotation[] annotations, Retrofit retrofit) {
      return null;
    }
    // 目標(biāo)為RequestBody的轉(zhuǎn)換器 type為原始類型的type,parameterAnnotations為參數(shù)上的注解（因?yàn)橹С諦ody,Part,PartMap注解），methodAnnotations為方法注解，retrofit是門面
    public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
      return null;
    }
    // 生產(chǎn)目標(biāo)為String類型的轉(zhuǎn)換器
    public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }
    // 泛型參數(shù)type的指定位置參數(shù)的上限，比如Map<? extends String,Long>這個(gè)type索引位置0參數(shù)的type的上限為String，1為Long
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    // 一般用于獲取泛型參數(shù)前的type，比如List<String>會(huì)返回List.class
    protected static Class<?> getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }

想要轉(zhuǎn)換肯定要知道原始類型和目標(biāo)類型，所以可以從生成方法中的參數(shù)

Retrofit庫已經(jīng)為我們實(shí)現(xiàn)了很多Converter,如下圖:

image

常用的GsonConverterFactory實(shí)現(xiàn):

public final class GsonConverterFactory extends Converter.Factory {
    // 實(shí)例化一個(gè)GsonConverterFactory
    public static GsonConverterFactory create() {
    return create(new Gson());
  }
  
    public static GsonConverterFactory create(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    return new GsonConverterFactory(gson);
  }
  
    private final Gson gson;
    // 構(gòu)造方法
    private GsonConverterFactory(Gson gson) {
    this.gson = gson;
  }
  // 把ResponseBody轉(zhuǎn)為指定類型對(duì)象
  @Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonResponseBodyConverter<>(gson, adapter);
  }
  // 把指定類型轉(zhuǎn)為RequestBody
  @Override
  public Converter<?, RequestBody> requestBodyConverter(Type type,
      Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonRequestBodyConverter<>(gson, adapter);
  }
  
}

Gson是怎么解析的？

GsonRequestBodyConverter類里:

// 這里實(shí)際也就是把對(duì)象轉(zhuǎn)為Json字符串寫入到RequestBody里而已。
@Override public RequestBody convert(T value) throws IOException {
    Buffer buffer = new Buffer();
    Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
    JsonWriter jsonWriter = gson.newJsonWriter(writer);
    adapter.write(jsonWriter, value);
    jsonWriter.close();
    return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
  }

使用Gson的jsonWriter配合TypeAdapter寫入Buffer,然后構(gòu)造RequestBody。

GsonResponseBodyConverter<T>類里：

final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }
    // 就是把body里面的Json字符串讀出來然后轉(zhuǎn)為指定類型的對(duì)象
  @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();
    }
  }
}

2.2.4 adapterFactories:List<CallAdapter.Factory> 適配器工廠

功能：將默認(rèn)的網(wǎng)絡(luò)請(qǐng)求執(zhí)行器（OkHttpCall）轉(zhuǎn)換成適合被不同平臺(tái)來調(diào)用的網(wǎng)絡(luò)請(qǐng)求執(zhí)行器形式，相當(dāng)于返回一個(gè)代理。

CallAdapter.java

// R為原始響應(yīng)Java對(duì)象類型，T為目標(biāo)響應(yīng)類型
public interface CallAdapter<R, T> {
    // 返回想要響應(yīng)轉(zhuǎn)成的Java對(duì)象類型
    Type responseType();
    // 返回一個(gè)call的代理
    T adapt(Call<R> call);
}

對(duì)應(yīng)的工廠類：其實(shí)跟前面的轉(zhuǎn)換器差不多

abstract class Factory {
    // 返回一個(gè)回調(diào)適配器
    public abstract @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);
    // 獲取容器指定索引位置的存放值類型
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    // 獲取原始Class
    protected static Class<?> getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

同樣的Retrofit也為我們實(shí)現(xiàn)了幾個(gè)現(xiàn)成的適配器工廠

image

DefaultCallAdapterFactory 默認(rèn)的Call適配器工廠

重寫get():

 @Override public @Nullable CallAdapter<?, ?> get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
      // 若返回類型Type不是Call.class，返回適配器null
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    // 返回類型Type必須為帶泛型參數(shù)的Type
    if (!(returnType instanceof ParameterizedType)) {
      throw new IllegalArgumentException(
          "Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
    }
    // 取得返回類型的泛型參數(shù)第一個(gè)參數(shù)的Type實(shí)例
    final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
    // 獲取回調(diào)執(zhí)行器
    final Executor executor = Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
        ? null
        : callbackExecutor;

    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
      // 適配器適配的類型Type
        return responseType;
      }

      @Override public Call<Object> adapt(Call<Object> call) {
      // 適配器適配后的對(duì)象
        return executor == null
            ? call
            : new ExecutorCallbackCall<>(executor, call);
      }
    };
  }

擴(kuò)展Call:代替原來的call，將原call的一些方法放在指定的執(zhí)行器執(zhí)行

static final class ExecutorCallbackCall<T> implements Call<T> {
    // 回調(diào)執(zhí)行器
    final Executor callbackExecutor;
    // 我理解為原始call，但不知道這里為什么要命名為delegate,獲取是把原對(duì)象看作代理吧
    final Call<T> delegate;

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

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

      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          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);
            }
          });
        }
      });
    }

    @Override public boolean isExecuted() {
      return delegate.isExecuted();
    }

    @Override public Response<T> execute() throws IOException {
      return delegate.execute();
    }

    @Override public void cancel() {
      delegate.cancel();
    }

    @Override public boolean isCanceled() {
      return delegate.isCanceled();
    }

    @SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
    @Override public Call<T> clone() {
      return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
    }

    @Override public Request request() {
      return delegate.request();
    }
  }

CompletableFutureCallAdapterFactory 支持轉(zhuǎn)為ompletableFuture<>的Call適配器工廠

重寫get():

  @Override public @Nullable CallAdapter<?, ?> get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
      // 返回類型必須為CompletableFuture.class
    if (getRawType(returnType) != CompletableFuture.class) {
      return null;
    }
    //  返回類型必須為泛型參數(shù)Type
    if (!(returnType instanceof ParameterizedType)) {
      throw new IllegalStateException("CompletableFuture return type must be parameterized"
          + " as CompletableFuture<Foo> or CompletableFuture<? extends Foo>");
    }
    // 返回類型第一個(gè)參數(shù)Type
    Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType);
    // 如果返回類型第一個(gè)參數(shù)Type不是Response，則返回BodyCallAdapter
    if (getRawType(innerType) != Response.class) {
      // Generic type is not Response<T>. Use it for body-only adapter.
      return new BodyCallAdapter<>(innerType);
    }

    // 如果返回類型第一個(gè)參數(shù)Type是Response,則必須也為泛型參數(shù)化Type
    if (!(innerType instanceof ParameterizedType)) {
      throw new IllegalStateException("Response must be parameterized"
          + " as Response<Foo> or Response<? extends Foo>");
    }
    // 返回ResponseCallAdapter實(shí)例
    Type responseType = getParameterUpperBound(0, (ParameterizedType) innerType);
    return new ResponseCallAdapter<>(responseType);
  }

BodyCallAdapter :將Call轉(zhuǎn)為CompletableFuture<Body>,是java8平臺(tái)支持的特性

private static final class BodyCallAdapter<R> implements CallAdapter<R, CompletableFuture<R>> {
    private final Type responseType;

    BodyCallAdapter(Type responseType) {
      this.responseType = responseType;
    }

    @Override public Type responseType() {
      return responseType;
    }

    @Override public CompletableFuture<R> adapt(final Call<R> call) {
      final CompletableFuture<R> future = new CompletableFuture<R>() {
        @Override public boolean cancel(boolean mayInterruptIfRunning) {
          if (mayInterruptIfRunning) {
            call.cancel();
          }
          return super.cancel(mayInterruptIfRunning);
        }
      };

      call.enqueue(new Callback<R>() {
        @Override public void onResponse(Call<R> call, Response<R> response) {
          if (response.isSuccessful()) {
            future.complete(response.body());
          } else {
            future.completeExceptionally(new HttpException(response));
          }
        }

        @Override public void onFailure(Call<R> call, Throwable t) {
          future.completeExceptionally(t);
        }
      });

      return future;
    }
  }

ResponseCallAdapter:將原始Call轉(zhuǎn)為CompletableFuture<Response>

private static final class ResponseCallAdapter<R>
      implements CallAdapter<R, CompletableFuture<Response<R>>> {
    private final Type responseType;

    ResponseCallAdapter(Type responseType) {
      this.responseType = responseType;
    }

    @Override public Type responseType() {
      return responseType;
    }

    @Override public CompletableFuture<Response<R>> adapt(final Call<R> call) {
      final CompletableFuture<Response<R>> future = new CompletableFuture<Response<R>>() {
        @Override public boolean cancel(boolean mayInterruptIfRunning) {
          if (mayInterruptIfRunning) {
            call.cancel();
          }
          return super.cancel(mayInterruptIfRunning);
        }
      };

      call.enqueue(new Callback<R>() {
        @Override public void onResponse(Call<R> call, Response<R> response) {
          future.complete(response);
        }

        @Override public void onFailure(Call<R> call, Throwable t) {
          future.completeExceptionally(t);
        }
      });

      return future;
    }
  }

適配第三方框架：RxJava2CallAdapterFactory的實(shí)現(xiàn)

public final class RxJava2CallAdapterFactory extends CallAdapter.Factory {
    // 默認(rèn)傳的調(diào)度器是為空的
    public static RxJava2CallAdapterFactory create() {
    return new RxJava2CallAdapterFactory(null, false);
  }
   public static RxJava2CallAdapterFactory createAsync() {
    return new RxJava2CallAdapterFactory(null, true);
  }
    public static RxJava2CallAdapterFactory createWithScheduler(Scheduler scheduler) {
    if (scheduler == null) throw new NullPointerException("scheduler == null");
    return new RxJava2CallAdapterFactory(scheduler, false);
  }
  // 調(diào)度器
  private final @Nullable Scheduler scheduler;
  // 是否異步
  private final boolean isAsync;
  // 構(gòu)造器
   private RxJava2CallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync) {
    this.scheduler = scheduler;
    this.isAsync = isAsync;
  }
  // 獲取Call適配器
  @Override
  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    Class<?> rawType = getRawType(returnType);
    // 如果返回類型為 Completable，則適配為Completable，為Completable相當(dāng)于Runable,執(zhí)行任務(wù)不會(huì)發(fā)射數(shù)據(jù)
    if (rawType == Completable.class) {
      return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
          false, true);
    }

    boolean isFlowable = rawType == Flowable.class;
    boolean isSingle = rawType == Single.class;
    boolean isMaybe = rawType == Maybe.class;
    // 如果不是Observable、Flowable,Single,Maybe，則適配為null,因?yàn)镽xJava2只有這幾種被觀察者
    if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) {
      return null;
    }

    boolean isResult = false;
    boolean isBody = false;
    Type responseType;
    if (!(returnType instanceof ParameterizedType)) {
      String name = isFlowable ? "Flowable"
          : isSingle ? "Single"
          : isMaybe ? "Maybe" : "Observable";
      throw new IllegalStateException(name + " return type must be parameterized"
          + " as " + name + "<Foo> or " + name + "<? extends Foo>");
    }
    // 獲取觀察的數(shù)據(jù)類型
    Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
    Class<?> rawObservableType = getRawType(observableType);
    if (rawObservableType == Response.class) {
        // 如果觀察的數(shù)據(jù)類型為Response,則Response必須要有泛型參數(shù)，即observableType為ParameterizedType。然后不是result,也不是body.比如Observable<Response<String>>
      if (!(observableType instanceof ParameterizedType)) {
        throw new IllegalStateException("Response must be parameterized"
            + " as Response<Foo> or Response<? extends Foo>");
      }
      // 獲取Response的泛型參數(shù)Type
      responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
    } else if (rawObservableType == Result.class) {
      // Result和Response同理，是result,比如Observable<Result<String>>
      if (!(observableType instanceof ParameterizedType)) {
        throw new IllegalStateException("Result must be parameterized"
            + " as Result<Foo> or Result<? extends Foo>");
      }
      responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
      isResult = true;
    } else {
      // 否則為body,即使用者自定義類型，比如Observable<String>
      responseType = observableType;
      isBody = true;
    }
    // 然后傳給RxJava2CallAdapter構(gòu)造器，構(gòu)造出對(duì)應(yīng)條件的Call適配器
    return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
        isSingle, isMaybe, false);
  }
}

RxJava2CallAdapter.java

// 負(fù)責(zé)把Call<R>轉(zhuǎn)為Rxjava的被觀察者<R>
final class RxJava2CallAdapter<R> implements CallAdapter<R, Object> {
    // 響應(yīng)類型
  private final Type responseType;
  // 調(diào)度器
  private final @Nullable Scheduler scheduler;
  // 是否異步
  private final boolean isAsync;
  // 是否原始結(jié)果
  private final boolean isResult;
  // 是否是body結(jié)果
  private final boolean isBody;
  // 是否背壓
  private final boolean isFlowable;
  // 是否Single
  private final boolean isSingle;
  // 是否Maybe
  private final boolean isMaybe;
  // 是否是Completable
  private final boolean isCompletable;

  RxJava2CallAdapter(Type responseType, @Nullable Scheduler scheduler, boolean isAsync,
      boolean isResult, boolean isBody, boolean isFlowable, boolean isSingle, boolean isMaybe,
      boolean isCompletable) {
    this.responseType = responseType;
    this.scheduler = scheduler;
    this.isAsync = isAsync;
    this.isResult = isResult;
    this.isBody = isBody;
    this.isFlowable = isFlowable;
    this.isSingle = isSingle;
    this.isMaybe = isMaybe;
    this.isCompletable = isCompletable;
  }

  @Override public Type responseType() {
    return responseType;
  }

  @Override public Object adapt(Call<R> call) {
  // 不管怎樣，先轉(zhuǎn)為Observable<Response<R>>
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable<?> observable;
    if (isResult) {
        // 如果是Result類型，則轉(zhuǎn)為ResultObservable
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
        // 如果是用戶自定義的Body類型，則轉(zhuǎn)為BodyObservable
      observable = new BodyObservable<>(responseObservable);
    } else {
        // 其它則返回Observable<Response<R>>
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }
    // 如果要支持背壓，則把observable轉(zhuǎn)為Flowable
    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    // 如果要Single，則把observable轉(zhuǎn)為Single
    if (isSingle) {
      return observable.singleOrError();
    }
    // 如果要Maybe，則把observable轉(zhuǎn)為Maybe
    if (isMaybe) {
      return observable.singleElement();
    }
    // 如果要Completable，則把observable轉(zhuǎn)為Completable
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return observable;
  }
}

2.2.5 callbackExecutor: Executor

回調(diào)執(zhí)行器，即回調(diào)執(zhí)行在哪個(gè)線程池提供的線程中：其實(shí)在Platform里面Android平臺(tái)已經(jīng)有一個(gè)MainThreadExecutor了，也可以自定義線程池，Retrofit在Androdi平臺(tái)回調(diào)默認(rèn)在主線程回調(diào)，所有沒必要在切換線程

2.2.6 validateEagerly:boolean

是否提前驗(yàn)證Service接口方法，默認(rèn)為false

3 Retrofit如何通過動(dòng)態(tài)代理把一個(gè)接口轉(zhuǎn)為具體的實(shí)現(xiàn)實(shí)例？

關(guān)鍵代碼：

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的，那么就執(zhí)行object對(duì)應(yīng)的方法
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            // 如果平臺(tái)支持默認(rèn)方法實(shí)現(xiàn)，則調(diào)用默認(rèn)方法實(shí)現(xiàn)，一般都不這樣做，也許是適配最新的java接口支持默認(rèn)實(shí)現(xiàn)
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            // 大多數(shù)情況下都是先從Method中提取出ServiceMethod,然后通過ServiceMethod調(diào)用HttpCall來實(shí)現(xiàn)請(qǐng)求
             return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });
  }

首先是拿到用戶自定義的Service接口class，然后用java的Proxy.newProxyInstance構(gòu)造出一個(gè)動(dòng)態(tài)代理，但是該代理并沒有持有常規(guī)意義上已存在的被代理者的引用,而只是取得一個(gè)代理執(zhí)行權(quán)，當(dāng)然也可以理解成是代理HTTP Call。它首先從method中提取出HttpServiceMethod,HttpServiceMethod相當(dāng)于是HttpCall調(diào)用方法的適配器，從而實(shí)現(xiàn)動(dòng)態(tài)代理在被調(diào)用方法時(shí)，最終就是在調(diào)用HttpCall，這個(gè)就是Retrofit的精髓之處，Retrofit結(jié)合注解然后代理OkHttp，使使用者在做請(qǐng)求時(shí)以簡潔的代碼快速構(gòu)造請(qǐng)求代碼，比如你不必再寫很多Request.Builder代碼，不必再設(shè)計(jì)回調(diào)結(jié)果的轉(zhuǎn)換代碼等。