1 簡介

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

Retrofit用註解的方式爲HTTP接口適配了帶有回調的java接口，通過這些java接口可以實現HTTP請求。

本文Retrofit版本：2.6.0

2 Retrofit組成：

2.1 Builder: Retrofit構建器（Builder模式）

作用：在保證Retrofit有默認組件的情況下，方便使用者自定義相關Retrofit組件。

小細節Platform：
Builder也可以配置Platform，默認情況下，Bulder會自動獲取對應的平臺。

  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

可以看到有三個平臺，Android（繼承Platform）,Java8（繼承Platform）和Platform自己。

下面再看三個平臺區別：

2.1.1 Platform

Platform平臺應該是用來支持java8版本之下的java平臺。

class Platform {
    ...
    // 平臺無回調執行器，應該在哪裏創建的，就在哪裏回調
  Executor defaultCallbackExecutor() {
    return null;
  }
  // 平臺默認的回調適配器工廠列表爲new DefaultCallAdapterFactory(callbackExecutor)
  List<? extends CallAdapter.Factory> defaultCallAdapterFactories(
      @Nullable Executor callbackExecutor) {
    return singletonList(new DefaultCallAdapterFactory(callbackExecutor));
  }
  // 默認回調適配器工廠數量爲1
    int defaultCallAdapterFactoriesSize() {
    return 1;
  }
  // 默認的轉換器工廠列表爲空列表
    List<? extends Converter.Factory> defaultConverterFactories() {
    return emptyList();
  }
  // 是否是默認方法
    boolean isDefaultMethod(Method method) {
    return false;
  }
  // 調用指定類默認的方法會拋異常，即不支持調用非默認方法
 @Nullable Object invokeDefaultMethod(Method method, Class<?> declaringClass, Object object,
      @Nullable Object... args) throws Throwable {
    throw new UnsupportedOperationException();
  }
    ...
    
}

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

2.1.2 Android

static class Android extends Platform {
    // 平臺默認的回調執行器 可以看出默認的回調線程是UI線程，所以使用者不用在回調裏做線程切換
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }
    // 是否是默認方法
    @Override boolean isDefaultMethod(Method method) {
    // 如果安卓構建版本小於24（安卓7.0），則直接返回是非默認方法，否則正常返回method.isDefault()
      if (Build.VERSION.SDK_INT < 24) {
        return false;
      }
      return method.isDefault();
    }
    //回調執行器必須不爲空，回調適配器工廠列表版本小於Android7返回new DefaultCallAdapterFactory(callbackExecutor)單獨組成的不可變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);
    }
    // 默認的回調適配器工程個數，和defaultCallAdapterFactories對應
    @Override int defaultCallAdapterFactoriesSize() {
      return Build.VERSION.SDK_INT >= 24 ? 2 : 1;
    }
    // 默認的轉換器工廠
    @Override List<? extends Converter.Factory> defaultConverterFactories() {
    // 如果平臺支持java8，則讓Converter支持java8操作符
      return Build.VERSION.SDK_INT >= 24
          ? singletonList(OptionalConverterFactory.INSTANCE)
          : Collections.<Converter.Factory>emptyList();
    }
    // 默認轉換器工廠個數
    @Override int defaultConverterFactoriesSize() {
      return Build.VERSION.SDK_INT >= 24 ? 1 : 0;
    }

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

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

Android有默認的MainThreadExecutor，就是Android主線程任務執行器，默認的CallAdapter.Factory任務回調適配器工廠。

從這裏就可以看出Android平臺上，Retrofit執行任務默認是在主線程。

2.1.3 java8

  static class Java8 extends Platform {
  // 默認method.isDefault()
    @Override boolean isDefaultMethod(Method method) {
      return method.isDefault();
    }
    // 支持調用默認方法
    @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);
    }
    // 默認適配器工廠列表，和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);
    }
    // 默認適配器工廠個數
     @Override int defaultCallAdapterFactoriesSize() {
      return 2;
    }
    // 默認轉換器工廠列表
    @Override List<? extends Converter.Factory> defaultConverterFactories() {
      return singletonList(OptionalConverterFactory.INSTANCE);
    }
    // 默認轉換器工廠個數
    @Override int defaultConverterFactoriesSize() {
      return 1;
    }
  }

isDefaultMethod():返回method.isDefault()
invokeDefaultMethod()：調用非默認方法接口。

總結一下：

平臺	默認回調執行器	默認回調適配器工廠	默認轉換器工廠	判斷methos是默認方法	Object invokeDefaultMethod()
Platform	無	DefaultCallAdapterFactory(callbackExecutor)	無	false	不支持
Java8	無	DefaultCallAdapterFactory(callbackExecutor)和CompletableFutureCallAdapterFactory.INSTANCE	OptionalConverterFactory.INSTANCE	method.isDefault()	支持
Android	MainThreadExecutor	一個DefaultCallAdapterFactory(callbackExecutor)或者DefaultCallAdapterFactory(callbackExecutor)和CompletableFutureCallAdapterFactory.INSTANCE	OptionalConverterFactory.INSTANCE	SDK_INT< 24 ? false:method.isDefault()	不支持

2.2 合成Retrofit的組件：

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

callFactory:okhttp3.Call.Factory 生成（HTTP調用對象）的工廠
baseUrl:HttpUrl HTTP url相關
converterFactories:List<Converter.Factory>
adapterFactories:List<CallAdapter.Factory>
callbackExecutor: Executor
validateEagerly: boolean

2.2.1 okhttp3.Call.Factory

http調用（call）工廠，就是生產http調用對象的工廠

可以看看okhttp3.Call接口

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

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

如果你使用過OkHttp3，會發現這就是OkHttp3常用的外部接口。所以OkHttpClient就是它的一個實現。所以Retrofit框架裏沒有自己擴展Call.Factory，那麼默認工廠就是用的OkHttp3框架裏實現的OkHttpClient。

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

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

2.2.2 baseUrl:HttpUrl

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

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

例：

 /**
     * 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的地址，最後會轉化成一個HttpUrl對象。

2.2.3 converterFactories:List<Converter.Factory>

Converter是從一個對象轉爲另一種對象過程的抽象，簡明一點就叫轉換器。比如說你總要把用戶的請求信息轉爲OkHttp標準的請求結構(Request)，或者是OkHttp的標準響應信息(Response)轉爲用戶數據。

把它抽象爲一個接口，接口裏就有一個convert方法

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

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


  abstract class Factory {
    // 生產responseBody轉換器
    public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type,
        Annotation[] annotations, Retrofit retrofit) {
      return null;
    }
    // 目標爲RequestBody的轉換器 type爲原始類型的type,parameterAnnotations爲參數上的註解（因爲支持Body,Part,PartMap註解），methodAnnotations爲方法註解，retrofit是門面
    public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
      return null;
    }
    // 生產目標爲String類型的轉換器
    public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }
    // 泛型參數type的指定位置參數的上限，比如Map<? extends String,Long>這個type索引位置0參數的type的上限爲String，1爲Long
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    // 一般用於獲取泛型參數前的type，比如List<String>會返回List.class
    protected static Class<?> getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }

想要轉換肯定要知道原始類型和目標類型，所以可以從生成方法中的參數

Retrofit庫已經爲我們實現了很多Converter,如下圖:

常用的GsonConverterFactory實現:

public final class GsonConverterFactory extends Converter.Factory {
    // 實例化一個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;
    // 構造方法
    private GsonConverterFactory(Gson gson) {
    this.gson = gson;
  }
  // 把ResponseBody轉爲指定類型對象
  @Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonResponseBodyConverter<>(gson, adapter);
  }
  // 把指定類型轉爲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類裏:

// 這裏實際也就是把對象轉爲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,然後構造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字符串讀出來然後轉爲指定類型的對象
  @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> 適配器工廠

功能：將默認的網絡請求執行器（OkHttpCall）轉換成適合被不同平臺來調用的網絡請求執行器形式，相當於返回一個代理。

CallAdapter.java

// R爲原始響應Java對象類型，T爲目標響應類型
public interface CallAdapter<R, T> {
    // 返回想要響應轉成的Java對象類型
    Type responseType();
    // 返回一個call的代理
    T adapt(Call<R> call);
}

對應的工廠類：其實跟前面的轉換器差不多

abstract class Factory {
    // 返回一個回調適配器
    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也爲我們實現了幾個現成的適配器工廠

DefaultCallAdapterFactory 默認的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必須爲帶泛型參數的Type
    if (!(returnType instanceof ParameterizedType)) {
      throw new IllegalArgumentException(
          "Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
    }
    // 取得返回類型的泛型參數第一個參數的Type實例
    final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
    // 獲取回調執行器
    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) {
      // 適配器適配後的對象
        return executor == null
            ? call
            : new ExecutorCallbackCall<>(executor, call);
      }
    };
  }

擴展Call:代替原來的call，將原call的一些方法放在指定的執行器執行

static final class ExecutorCallbackCall<T> implements Call<T> {
    // 回調執行器
    final Executor callbackExecutor;
    // 我理解爲原始call，但不知道這裏爲什麼要命名爲delegate,獲取是把原對象看作代理吧
    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 支持轉爲ompletableFuture<>的Call適配器工廠

重寫get():

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

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

BodyCallAdapter :將Call轉爲CompletableFuture<Body>,是java8平臺支持的特性

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轉爲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的實現

public final class RxJava2CallAdapterFactory extends CallAdapter.Factory {
    // 默認傳的調度器是爲空的
    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);
  }
  // 調度器
  private final @Nullable Scheduler scheduler;
  // 是否異步
  private final boolean isAsync;
  // 構造器
   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相當於Runable,執行任務不會發射數據
    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,因爲RxJava2只有這幾種被觀察者
    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>");
    }
    // 獲取觀察的數據類型
    Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
    Class<?> rawObservableType = getRawType(observableType);
    if (rawObservableType == Response.class) {
        // 如果觀察的數據類型爲Response,則Response必須要有泛型參數，即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的泛型參數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構造器，構造出對應條件的Call適配器
    return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
        isSingle, isMaybe, false);
  }
}

RxJava2CallAdapter.java

// 負責把Call<R>轉爲Rxjava的被觀察者<R>
final class RxJava2CallAdapter<R> implements CallAdapter<R, Object> {
    // 響應類型
  private final Type responseType;
  // 調度器
  private final @Nullable Scheduler scheduler;
  // 是否異步
  private final boolean isAsync;
  // 是否原始結果
  private final boolean isResult;
  // 是否是body結果
  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) {
  // 不管怎樣，先轉爲Observable<Response<R>>
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

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

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

2.2.5 `callbackExecutor: Executor`

回調執行器，即回調執行在哪個線程池提供的線程中：其實在Platform裏面Android平臺已經有一個MainThreadExecutor了，也可以自定義線程池，Retrofit在Androdi平臺回調默認在主線程回調，所有沒必要在切換線程

2.2.6 validateEagerly:boolean

是否提前驗證Service接口方法，默認爲false

3 Retrofit如何通過動態代理把一個接口轉爲具體的實現實例？

關鍵代碼：

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的，那麼就執行object對應的方法
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            // 如果平臺支持默認方法實現，則調用默認方法實現，一般都不這樣做，也許是適配最新的java接口支持默認實現
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            // 大多數情況下都是先從Method中提取出ServiceMethod,然後通過ServiceMethod調用HttpCall來實現請求
             return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
          }
        });
  }

首先是拿到用戶自定義的Service接口class，然後用java的Proxy.newProxyInstance構造出一個動態代理，但是該代理並沒有持有常規意義上已存在的被代理者的引用,而只是取得一個代理執行權，當然也可以理解成是代理HTTP Call。它首先從method中提取出HttpServiceMethod,HttpServiceMethod相當於是HttpCall調用方法的適配器，從而實現動態代理在被調用方法時，最終就是在調用HttpCall，這個就是Retrofit的精髓之處，Retrofit結合註解然後代理OkHttp，使使用者在做請求時以簡潔的代碼快速構造請求代碼，比如你不必再寫很多Request.Builder代碼，不必再設計回調結果的轉換代碼等。

Retrofit源碼解讀 1 簡介 2 Retrofit組成：

1 簡介

2 Retrofit組成：

2.1 Builder: Retrofit構建器（Builder模式）

2.1.1 Platform

2.1.2 Android

2.1.3 java8

2.2 合成Retrofit的組件：

2.2.1 okhttp3.Call.Factory

2.2.2 baseUrl:HttpUrl

2.2.3 converterFactories:List<Converter.Factory>

常用的GsonConverterFactory實現:

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

DefaultCallAdapterFactory 默認的Call適配器工廠

CompletableFutureCallAdapterFactory 支持轉爲ompletableFuture<>的Call適配器工廠

適配第三方框架：RxJava2CallAdapterFactory的實現

2.2.5 `callbackExecutor: Executor`

2.2.6 validateEagerly:boolean

3 Retrofit如何通過動態代理把一個接口轉爲具體的實現實例？

杭州的 IT 崩盤了麼？

雲原生週刊：Kubernetes 十週年｜ 2024.6.11

開源高性能結構化日誌模塊NanoLog

Python 潮流週刊#55：分享 9 個高質量的技術類信息源！

WinForm應用實戰開發指南 - 表格數據錄入問題解析

Azure Virtual Network (22) 多訂閱使用Azure DNS解析問題 Windows Azure Platform 系列文章目錄

【簡寫Mybatis-02】註冊機的實現以及SqlSession處理

手繪二維碼

.NET藉助虛擬網卡實現一個簡單異地組網工具

20200306

Java知識總結之線程安全與數據同步 1 synchronized 2 程序死鎖的原因及其診斷

我的MarkDown寫作工具何爲MarkDown? 爲何用MarkDown? md編輯器我用有道雲筆記免費版，我想貼圖片怎麼辦？

Retrofit源碼解讀 1 簡介 2 Retrofit組成：

Android源碼之AsyncTask 參考 1 AsyncTask簡單用法 2 源碼解讀大致類關係圖結語

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Retrofit源碼解讀 1 簡介 2 Retrofit組成：

1 簡介

2 Retrofit組成：

2.1 Builder: Retrofit構建器（Builder模式）

2.1.1 Platform

2.1.2 Android

2.1.3 java8

2.2 合成Retrofit的組件：

2.2.1 okhttp3.Call.Factory

2.2.2 baseUrl:HttpUrl

2.2.3 converterFactories:List<Converter.Factory>

常用的GsonConverterFactory實現:

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

DefaultCallAdapterFactory 默認的Call適配器工廠

CompletableFutureCallAdapterFactory 支持轉爲ompletableFuture<>的Call適配器工廠

適配第三方框架：RxJava2CallAdapterFactory的實現

2.2.5 callbackExecutor: Executor

2.2.6 validateEagerly:boolean

3 Retrofit如何通過動態代理把一個接口轉爲具體的實現實例？

2.2.5 `callbackExecutor: Executor`