用法：retrofit是怎么創(chuàng)建service接口實(shí)例的？

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

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

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

// Retrofit.class
public <T> T create(final Class<T> service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class<?>[] {service},
            new InvocationHandler() {
              private final Platform platform = Platform.get();
              private final Object[] emptyArgs = new Object[0];

              @Override
              public @Nullable 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);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });
  }

調(diào)用retrofit 的create方法，通過動(dòng)態(tài)代理技術(shù)返回一個(gè)service接口的代理實(shí)例，之后對service接口的訪問，都會(huì)走到InvocationHandler#invoke()方法。
如果調(diào)用的是 Object 的方法，例如 equals，toString，那就直接調(diào)用。
如果是 default 方法（Java 8 引入），就調(diào)用 default 方法。
否則就通過loadServiceMethod(method).invoke(args)調(diào)用service的接口，拿到返回值。

// 生成的代理類：
class $Proxy0 extends Proxy implements GitHubApiService {

    protected $Proxy0(InvocationHandler h) {
        super(h);
    }

    // 調(diào)用interface的方法其實(shí)就是調(diào)用代理對象對應(yīng)的方法，然后代理對象在對應(yīng)的方法中調(diào)用InvocationHandler#invoke()
    @Override
    public void listRepos(String user) {

        Method method = Class.forName("GitHubService").getMethod("listRepos", String.class);

        super.h.invoke(this, method, new Object[]{user});
    }
}

動(dòng)態(tài)代理技術(shù)，簡而言之，就是動(dòng)態(tài)生成接口的實(shí)現(xiàn)類（當(dāng)然生成實(shí)現(xiàn)類有緩存機(jī)制），并創(chuàng)建其實(shí)例（稱之為代理），代理把對接口的調(diào)用轉(zhuǎn)發(fā)給 InvocationHandler 實(shí)例，而在 InvocationHandler 的實(shí)現(xiàn)中，除了執(zhí)行真正的邏輯（例如再次轉(zhuǎn)發(fā)給真正的實(shí)現(xiàn)類對象），我們還可以進(jìn)行一些有用的操作，例如統(tǒng)計(jì)執(zhí)行時(shí)間、進(jìn)行初始化和清理、對接口調(diào)用進(jìn)行檢查等。

為什么要用動(dòng)態(tài)代理？
因?yàn)閷涌诘乃蟹椒ǖ恼{(diào)用都會(huì)集中轉(zhuǎn)發(fā)到 InvocationHandler#invoke函數(shù)中，我們可以集中進(jìn)行處理，更方便了。你可能會(huì)想，我也可以手寫這樣的代理類，把所有接口的調(diào)用都轉(zhuǎn)發(fā)到 InvocationHandler#invoke 呀，當(dāng)然可以，但是可靠地自動(dòng)生成豈不更方便？

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

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = ServiceMethod.parseAnnotations(this, method);
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

ServiceMethod

一個(gè) ServiceMethod 對象對應(yīng)于一個(gè) API interface 的一個(gè)方法，Retrofit#loadServiceMethod(method)方法負(fù)責(zé)加載 ServiceMethod：
這里實(shí)現(xiàn)了緩存邏輯，同一個(gè) API 的同一個(gè)方法，只會(huì)創(chuàng)建一次。這里由于我們每次獲取 API 實(shí)例都是傳入的 class 對象，而 class 對象是進(jìn)程內(nèi)單例的，所以獲取到它的同一個(gè)方法 Method 實(shí)例也是單例的，所以這里的緩存是有效的。

// ServiceMethod.java
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
    // 獲取方法的注解、參數(shù)的注解、參數(shù)的類型，得到http的請求方式、請求參數(shù)、請求頭，baseUrl，relativeUrl等，包裝成RequestFactory
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    // 獲取方法的返回類型
    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }

    // 將RequestFactory傳給HttpServiceMethod，返回一個(gè)HttpServiceMethod
    // 之后在ServiceMethod#loadServiceMethod中會(huì)調(diào)用HttpServiceMethod#invoke()方法，在invoke方法中創(chuàng)建OkHttpCall時(shí)將RequestFactory傳給OkHttpCall，在OkHttpCall的enqueue方法中，會(huì)通過RequestFactory的create方法創(chuàng)建一個(gè)okhttp.Request
    // 另外callFactory、callAdapter、responseConverter都是在parseAnnotations中被賦值給HttpServiceMethod的
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

retrofit通過getGenericReturnType來獲取類型信息。

jdk的class、Method、Field類提供了一系列獲取 泛型類型 的相關(guān)方法。
以Method為例，getGenericReturnType獲取帶泛型信息的返回類型，getGenericParameterTypes獲取帶泛型信息的參數(shù)類型。
具體看Retrofit/gson是怎么獲取泛型擦除后的類型的

ServiceMethod#parseAnnotations(...)調(diào)用HttpServiceMethod#parseAnnotations()生成對應(yīng)的HttpServiceMethod的子類：

// HttpServiceMethod.class

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    
    ...
    
    if (isKotlinSuspendFunction) {
      // 獲取kotlin suspend 方法的adapterType
    } else {
      adapterType = method.getGenericReturnType();
    }

    // 創(chuàng)建CallAdapter
    CallAdapter<ResponseT, ReturnT> callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
    
    ...
    
    Type responseType = callAdapter.responseType();
    
    Converter<ResponseBody, ResponseT> responseConverter =
        createResponseConverter(retrofit, method, responseType);

    // 從retrofit獲取callFactory，并傳給HttpServiceMethod的子類，后面要用它來創(chuàng)建OkHttpCall
    okhttp3.Call.Factory callFactory = retrofit.callFactory; 
    
    if (!isKotlinSuspendFunction) {
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      return (HttpServiceMethod<ResponseT, ReturnT>)
          new SuspendForResponse<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
    } else {
      return (HttpServiceMethod<ResponseT, ReturnT>)
          new SuspendForBody<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
              continuationBodyNullable);
    }
  }

  private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
      Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
      return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
  }

  private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
      Retrofit retrofit, Method method, Type responseType) {
      return retrofit.responseBodyConverter(responseType, annotations);
  }

ServiceMethod#parseAnnotations()返回了一個(gè)HttpServiceMethod的子類實(shí)例后，調(diào)用了HttpServiceMethod#invoke()方法：

// HttpServiceMethod.class
  @Override
  final @Nullable ReturnT invoke(Object[] args) {
    // args參數(shù)是GitHubService里邊方法的參數(shù)
    // 創(chuàng)建了OkHttpCall對象，就是GitHubService里邊方法的返回值Call對象
    Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    return adapt(call, args);
  }

HttpServiceMethod有3個(gè)子類：CallAdapted<ResponseT, ReturnT>、SuspendForResponse<ResponseT>、SuspendForBody<ResponseT>

static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT>

static final class SuspendForResponse<ResponseT> extends HttpServiceMethod<ResponseT, Object>

static final class SuspendForBody<ResponseT> extends HttpServiceMethod<ResponseT, Object>

在不使用 Kotlin 協(xié)程的情況下，其實(shí)調(diào)用的是子類 CallAdapted 的 adapt方法

static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
    private final CallAdapter<ResponseT, ReturnT> callAdapter;

    CallAdapted(
        RequestFactory requestFactory,
        okhttp3.Call.Factory callFactory,
        Converter<ResponseBody, ResponseT> responseConverter,
        CallAdapter<ResponseT, ReturnT> callAdapter) {
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
    }

    @Override
    protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
      return callAdapter.adapt(call);
    }
}

Retrofit的OkHttpCall是如何做網(wǎng)絡(luò)請求的？

// OkHttpCall.class

public void enqueue(final Callback<T> callback) {

  ...
  call = rawCall = createRawCall();
  ...

  call.enqueue(new okhttp3.Callback() {
     @Override
     public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
     // 省略部分try catch代碼
       // 解析相應(yīng)數(shù)據(jù)，將OkHttp.Response轉(zhuǎn)換成Rerofit.Response
       Response<T> response = parseResponse(rawResponse);
       callback.onResponse(OkHttpCall.this, response);
    }
    
    // 省略onFailure()的代碼
  }
}

private okhttp3.Call createRawCall() throws IOException {
    // callFactory 和 requestFactory在HttpServiceMethod#parseAnnotations中被賦值的
    // requestFactory.create(args)創(chuàng)建okhttp.Request對象
    // callFactory是okHttpClient，newCall(request)創(chuàng)建RealCall對象
    okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
}

requestFactory

在ServiceMethod#parseAnnotations中調(diào)用，負(fù)責(zé)解析service中對應(yīng)方法的注解、參數(shù)的注解、參數(shù)的類型，得到http的請求方式、請求參數(shù)、請求頭，baseUrl，relativeUrl等，包裝成RequestFactory。

// RequestFactory.class
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
    return new Builder(retrofit, method).build();
}

// RequestFactory.Builder.class
Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;
      
      // 獲取方法上的注解
      this.methodAnnotations = method.getAnnotations();
      
      // 獲取參數(shù)類型
      this.parameterTypes = method.getGenericParameterTypes();
      
      // 獲取參數(shù)上的注解
      this.parameterAnnotationsArray = method.getParameterAnnotations();
}

RequestFactory build(){
    for (Annotation annotation : methodAnnotations) {
        // 解析并保存方法上的注解
        parseMethodAnnotation(annotation);
    }
    ...
    int parameterCount = parameterAnnotationsArray.length;
    parameterHandlers = new ParameterHandler<?>[parameterCount];
    for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
      // 解析并保存方法參數(shù)上的注解
      parameterHandlers[p] = parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
    }
    ...
    return new RequestFactory(this);
}

// 解析方法上的注解，如: @GET
private void parseMethodAnnotation(Annotation annotation) {
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        .. 其他類似，省略
      }
}

// 解析方法上的注解以及對應(yīng)的value中的路徑，如：@GET("listRepos")，則會(huì)將GET、listRepos保存起來
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
...      
      // 保存http請求方式
      this.httpMethod = httpMethod;
      this.hasBody = hasBody;

      if (value.isEmpty()) {
        return;
      }
...
      // 保存請求路徑
      this.relativeUrl = value;
      // 解析路徑中的參數(shù)并保存在Set中
      this.relativeUrlParamNames = parsePathParameters(value);
}

// 解析路徑中的參數(shù)，例如：@GET("users/{id}")，則解析路徑中的id，并保存在set中
static Set<String> parsePathParameters(String path) {
      Matcher m = PARAM_URL_REGEX.matcher(path);
      Set<String> patterns = new LinkedHashSet<>();
      while (m.find()) {
        patterns.add(m.group(1));
      }
      return patterns;
}

// 解析方法的參數(shù)上的注解，根據(jù)方法的參數(shù)下標(biāo)（第幾個(gè)參數(shù)）、參數(shù)類型、參數(shù)的注解等，返回對應(yīng)的ParameterHandler
private @Nullable ParameterHandler<?> parseParameter(
        int p, Type parameterType, @Nullable Annotation[] annotations, boolean allowContinuation) {
      ParameterHandler<?> result = null;
      if (annotations != null) {
        for (Annotation annotation : annotations) {
          // 遍歷解析參數(shù)的注解，就是 @Path @Query @Field 等注解
          ParameterHandler<?> annotationAction =
              parseParameterAnnotation(p, parameterType, annotations, annotation);

          if (annotationAction == null) {
            continue;
          }

          result = annotationAction;
        }
      }

      if (result == null) {
        // 如果是kotlin的suspend方法，則方法的最后一個(gè)參數(shù)是Continuation
        // 如果是方法的最后一個(gè)參數(shù)，allowContinuation為true
        if (allowContinuation) {
          try {
            // 如果最后一個(gè)參數(shù)是Continuation，則說明是suspend函數(shù)，將isKotlinSuspendFunction設(shè)為true，后面在HttpServiceMethod#parseAnnotations()中會(huì)根據(jù)isKotlinSuspendFunction判斷返回HttpServiceMethod子類的類型
            if (Utils.getRawType(parameterType) == Continuation.class) {
              isKotlinSuspendFunction = true;
              return null;
            }
          } catch (NoClassDefFoundError ignored) {
          }
        }
        throw parameterError(method, p, "No Retrofit annotation found.");
      }

      return result;
}

// 將方法的參數(shù)類型、參數(shù)的注解、參數(shù)值等，封裝成對應(yīng)的ParameterHandler并返回
private ParameterHandler<?> parseParameterAnnotation(
        int p, Type type, Annotation[] annotations, Annotation annotation) {

    if (annotation instanceof Url) {
        // 返回@URL對應(yīng)的ParameterHandler，即ParameterHandler.RelativeUrl
        if (type == HttpUrl.class
            || type == String.class
            || type == URI.class
            || (type instanceof Class && "android.net.Uri".equals(((Class<?>) type).getName()))) {
          return new ParameterHandler.RelativeUrl(method, p);
        } 
    } else if(annotation instanceof Path){
        // 返回@PATH對應(yīng)的ParameterHandler，即ParameterHandler.Path
        Path path = (Path) annotation;
        String name = path.value();
        validatePathName(p, name);

        Converter<?, String> converter = retrofit.stringConverter(type, annotations);
        return new ParameterHandler.Path<>(method, p, name, converter, path.encoded());
    } else if(...){
        ...
    }

}

callFactory

負(fù)責(zé)創(chuàng)建 HTTP 請求，HTTP 請求被抽象為了 okhttp3.Call 類，它表示一個(gè)已經(jīng)準(zhǔn)備好，可以隨時(shí)執(zhí)行的 HTTP 請求。

// Retrofit.Builder.class

public Builder client(OkHttpClient client) {
      return callFactory(Objects.requireNonNull(client, "client == null"));
}

// OkHttpClient implements okhttp3.Call.Factory
public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = Objects.requireNonNull(factory, "factory == null");
      return this;
}

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

      return new Retrofit(
          callFactory,
          baseUrl,
          unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories),
          callbackExecutor,
          validateEagerly);
}

所以，Retrofit.callFactory是OkHttpClient。

callAdapter

在HttpServiceMethod#parseAnnotation中創(chuàng)建

// HttpServiceMethod.class

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    
    ...
    
    if (isKotlinSuspendFunction) {
      // 獲取kotlin suspend 方法的adapterType
    } else {
      adapterType = method.getGenericReturnType();
    }

    // 創(chuàng)建CallAdapter
    CallAdapter<ResponseT, ReturnT> callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
    Type responseType = callAdapter.responseType();
    
    ...
    
    Converter<ResponseBody, ResponseT> responseConverter =
        createResponseConverter(retrofit, method, responseType);

    // 從retrofit獲取callFactory，并傳給HttpServiceMethod的子類，后面要用它來創(chuàng)建OkHttpCall
    okhttp3.Call.Factory callFactory = retrofit.callFactory; 
    
    if (!isKotlinSuspendFunction) {
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      return (HttpServiceMethod<ResponseT, ReturnT>)
          new SuspendForResponse<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
    } else {
      return (HttpServiceMethod<ResponseT, ReturnT>)
          new SuspendForBody<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
              continuationBodyNullable);
    }
  }

  private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
      Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
      return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
  }

  private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
      Retrofit retrofit, Method method, Type responseType) {
      return retrofit.responseBodyConverter(responseType, annotations);
  }

// Retrofit.class
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
}

public CallAdapter<?, ?> nextCallAdapter(
      CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {

    // callAdapterFactories會(huì)在調(diào)用Retrofit.Builder#addCallAdapterFactory(CallAdapter.Factory)時(shí)添加CallAdapterFactory，例如：builder.addCallAdapterFactory(RxJavaCallAdapterFactory.create()) 
    // 找到第一個(gè)開始遍歷的CallAdapterFactory
    int start = callAdapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
      // CallAdapterFactory根據(jù)返回類型拿到CallAdapter，之后會(huì)在HttpServiceMethod#invoke中調(diào)用對應(yīng)子類的adapt()方法，然后就會(huì)調(diào)用CallAdapter#adapt()方法
      CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }
}

adapt()方法會(huì)把 retrofit2.Call<R> 轉(zhuǎn)為 其他類型<R>，例如Observable<R>（注意將 retrofit2.Call 和 okhttp3.Call 區(qū)分開來，retrofit2.Call 表示的是對一個(gè) Retrofit 方法的調(diào)用），如果沒有給retrofit添加CallAdapter.Factory，會(huì)有個(gè)默認(rèn)的factory，在adapt(call, args)中返回Call<R>。

之后會(huì)通過adapt(call, args)返回的類進(jìn)行網(wǎng)絡(luò)請求，如果返回的是個(gè)Call<R>對象，則直接調(diào)用enqueue(callback)方法進(jìn)行網(wǎng)絡(luò)請求，其他類似，例如返回的是Observable<R>(ps: Call<R>被包裝在了Observable中 )，在subscribe()中會(huì)調(diào)用call.enqueue(callback)進(jìn)行網(wǎng)絡(luò)請求，然后在callback的onResponse中調(diào)用observer的onNext(response)和onComplete()，在onFailure()中調(diào)用observer.onError(throwable)。

如何支持 Kotlin 協(xié)程的 suspend 掛起函數(shù)的？

• 通過 RequestFactory 解析方法上的最后一個(gè)參數(shù)是否Continuation，來判斷是不是一個(gè)掛起函數(shù)，是的話把 isKotlinSuspendFunction 變量置為 true
• 根據(jù) isKotlinSuspendFunction 這個(gè)變量來判斷響應(yīng)類型是否是 Response 類型，是的話把continuationWantsResponse 置為 true
• 根據(jù) continuationWantsResponse 這個(gè)變量，來返回 SuspendForResponse對象，還是SuspendForBody對象
• 如果是SuspendForResponse對象，后面調(diào)用 SuspendForResponse 的 adapt方法時(shí)，通過 Call 的擴(kuò)展函數(shù)awaitResponse()，來調(diào)用 Call 的 enqueue方法
• 請求結(jié)束后通過協(xié)程來返回

static final class SuspendForResponse<ResponseT> extends HttpServiceMethod<ResponseT, Object> {
    private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;

    @Override
    protected Object adapt(Call<ResponseT> call, Object[] args) {
      // 如果沒有添加額外的CallAdpter.Factory的話，默認(rèn)的factory返回的adapter會(huì)通過adapt返回原來的call對象
      call = callAdapter.adapt(call);

      // kotlin的suspend函數(shù)經(jīng)過編譯后，在方法的參數(shù)列表里面會(huì)多一個(gè)Continuation參數(shù)，在最后一個(gè)參數(shù)的位置
      Continuation<Response<ResponseT>> continuation =
          (Continuation<Response<ResponseT>>) args[args.length - 1];

      try {
        // 調(diào)用suspend Call<T>.awaitResponse(): Retrofit.Resonse<T>，獲取網(wǎng)絡(luò)請求結(jié)果
        return KotlinExtensions.awaitResponse(call, continuation);
      } catch (Exception e) {
        return KotlinExtensions.suspendAndThrow(e, continuation);
      }
    }
}

// KotlinExtensions.class
suspend fun <T> Call<T>.awaitResponse(): Response<T> {
  return suspendCancellableCoroutine { continuation ->
    continuation.invokeOnCancellation {
      cancel()
    }
    // 調(diào)用Retrofit.Call#enquque(Retrofit.Callback)進(jìn)行網(wǎng)絡(luò)請求
    enqueue(object : Callback<T> {
      override fun onResponse(call: Call<T>, response: Response<T>) {
        // 通過continuation.resume()將網(wǎng)絡(luò)請求結(jié)果回調(diào)到調(diào)用該方法的地方，即SuspendForResponse#adapt()
        continuation.resume(response)
      }

      override fun onFailure(call: Call<T>, t: Throwable) {
        continuation.resumeWithException(t)
      }
    })
  }
}

responseConverter

請求響應(yīng)結(jié)果是如何解析的？
在前面章節(jié)“Retrofit的OkHttpCall是如何做網(wǎng)絡(luò)請求的？”中，可以看到在retrofit.call#enqueue(retrofit.callback)的callback#onResponse()中，調(diào)用了parseResponse(response)

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();

    // ...不需要ResponseBody的情況

    ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
    // 使用ResponseConverter將ResponseBody轉(zhuǎn)化為我們需要的類型
    T body = responseConverter.convert(catchingBody);
    // 將我們需要的類型和okhttp.Response包裝成retrofit.Response
    return Response.success(body, rawResponse);
  }

responseConverter賦值過程
類似于callAdapter，在HttpServiceMethod#parseAnnotation中創(chuàng)建

//OkHttpCall.java
private final Converter<ResponseBody, T> responseConverter;

OkHttpCall(
    RequestFactory requestFactory,
    Object[] args,
    okhttp3.Call.Factory callFactory,
    Converter<ResponseBody, T> responseConverter) {
  this.requestFactory = requestFactory;
  this.args = args;
  this.callFactory = callFactory;
  //在構(gòu)造中賦值
  this.responseConverter = responseConverter;
}

// OkHttpCall 在 HttpServiceMethod#invoke()中實(shí)例化
//注意換類了
//HttpServiceMethod.java
private final Converter<ResponseBody, ResponseT> responseConverter;

HttpServiceMethod(
    RequestFactory requestFactory,
    okhttp3.Call.Factory callFactory,
    Converter<ResponseBody, ResponseT> responseConverter) {
  this.requestFactory = requestFactory;
  this.callFactory = callFactory;
   //在構(gòu)造中賦值
  this.responseConverter = responseConverter;
}

@Override
  final @Nullable ReturnT invoke(Object[] args) {
    // 構(gòu)造OkHttpCall
    Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    return adapt(call, args);
}

static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
    Retrofit retrofit, Method method, RequestFactory requestFactory) {
   ...
  CallAdapter<ResponseT, ReturnT> callAdapter =
      createCallAdapter(retrofit, method, adapterType, annotations);

  // 1 實(shí)例化responseConverter
  Converter<ResponseBody, ResponseT> responseConverter =
      createResponseConverter(retrofit, method, responseType);

  okhttp3.Call.Factory callFactory = retrofit.callFactory;
  
  // 實(shí)例化HttpServiceMethod的子類，傳入responseConverter
  if (!isKotlinSuspendFunction) {
    //2 CallAdapted的實(shí)例化賦值
    return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
  } 
  ...
}

private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
    Retrofit retrofit, Method method, Type responseType) {
  Annotation[] annotations = method.getAnnotations();
  
    //調(diào)用的是 retrofit的方法
    return retrofit.responseBodyConverter(responseType, annotations);
}

// Retrofit.java
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) {
      
    // 找到第一個(gè)開始遍歷的ConverterFactory
    int start = converterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = converterFactories.size(); i < count; i++) {
      // 從ConverterFactory中根據(jù) responseType返回值類型 來取到對應(yīng)的 Converter，如果不為空，直接返回此 Converter 對象，后續(xù)就用這個(gè)Converter轉(zhuǎn)換數(shù)據(jù)類型；如果為空，則取下一個(gè)ConverterFactory繼續(xù)判斷是否能取到Converter
      // 在Retrofit.parseResponse(okhttp.Response)中調(diào)用Converter#convert(responseBody)，將ResponseBody轉(zhuǎn)化為需要的數(shù)據(jù)類型
      // 例如通常我們會(huì)在Service的方法中返回Call<BaseResponse<User>>，我們可以自定義Converter，“脫去”BaseResponse，直接返回User，這樣我們就可以在Service的方法中聲明返回Call<User>
      // converterFactories會(huì)在調(diào)用Retrofit.Builder#addConverterFactory(Converter.Factory)時(shí)添加Converter.Factory，例如：builder.addConverterFactory(GsonConverterFactory.create())
)
      Converter<ResponseBody, ?> converter = converterFactories.get(i).responseBodyConverter(type, annotations, this);
      if (converter != null) {
        return (Converter<ResponseBody, T>) converter;
      }
    }
}

注意：是怎么找到ConverterFactory來調(diào)用 Converter 的 convert方法的呢？ 在遍歷converterFactories時(shí)會(huì)根據(jù) responseType來找到對應(yīng)的Converter，如果responseType能被識(shí)別處理，則ConverterFactory返回Converter，否則ConverterFactory返回null，之后繼續(xù)遍歷converterFactories，取下一個(gè)ConverterFactory來獲取Converter。

看一下 converterFactories 這個(gè)對象的賦值過程

//Retrofit.java
final List<Converter.Factory> converterFactories;

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.
  //通過 Retrofit 的構(gòu)造賦值，Retrofit的 初始化是通過內(nèi)部 Builder 類的build方法
  this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.
  this.callbackExecutor = callbackExecutor;
  this.validateEagerly = validateEagerly;
}

//Retrofit.java 內(nèi)部類 Builder 類的build方法
//Builder.java
 public Retrofit build() {
   ...
      List<Converter.Factory> converterFactories =
          new ArrayList<>(
              1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
        // 添加默認(rèn)的構(gòu)建的轉(zhuǎn)換器，如果Service的方法用@STREAMING修飾，則返回StreamingResponseBodyConverter，否則返回BufferingResponseBodyConverter
      converterFactories.add(new BuiltInConverters());
        // 加入我們自己添加的ConverterFactory，例如addConverterFactory(GsonConverterFactory.create())
      converterFactories.addAll(this.converterFactories);
      
      // 如果是 Java8(Android sdk >= 24) 就是一個(gè) OptionalConverterFactory 的轉(zhuǎn)換器，否則就是一個(gè)空列表converterFactories.addAll(platform.defaultConverterFactories));

      return new Retrofit(
          callFactory,
          baseUrl,
          unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories),
          callbackExecutor,
          validateEagerly);
}

parameterHandlers

內(nèi)部封裝了參數(shù)類型、參數(shù)的注解、參數(shù)值等值。詳見RequestFactory一節(jié)。

Retrofit使用流程

Retrofit創(chuàng)建代理類流程

Retrofit請求過程

Retrofit請求結(jié)果轉(zhuǎn)換過程

Type的類型
也可以參考這篇文章

Retrofit整個(gè)請求流程是怎樣的？

1、我們在調(diào)用Retrofit.create(GithubService.class)時(shí)生成代理對象，代理對象持有InvocationHandler
2、當(dāng)我們調(diào)用代理對象的方法時(shí)，會(huì)調(diào)用Invocation#invoke方法
3、在Invocation#invoke方法中，會(huì)調(diào)用Retrofit#loadServiceMethod方法，在該方法中會(huì)調(diào)用RequestFactory#parseAnnotations()解析代理方法的參數(shù)；會(huì)調(diào)用HttpServiceMethod#parseAnnotations()根據(jù)方法類型生成不同的子類。
4、之后調(diào)用HttpServiceMethod#invoke方法，在該方法中會(huì)生成OkHttpCall對象，然后調(diào)用HttpServiceMethod子類的adapt()方法，將Call對象轉(zhuǎn)換成用戶想要的類型，例如Observable，默認(rèn)還是返回OkHttpCall
5、之后會(huì)調(diào)用OkHttpCall#enqueue(retrofit.callback)方法，在該方法中會(huì)通過RequestFactory創(chuàng)建一個(gè)okhttp.Request對象，并通過CallFactory.newCall(okhttp.Request)創(chuàng)建一個(gè)okhttp.Call對象，之后就是通過okhttp.Call#enqueue(okhttp.Callback)進(jìn)行網(wǎng)絡(luò)請求
6、請求成功后會(huì)通過Converter將服務(wù)端返回的數(shù)據(jù)轉(zhuǎn)換成用戶感興趣的數(shù)據(jù)類型，并回調(diào)retrofit.callback接口

參考鏈接：一定能看懂的 Retrofit 最詳細(xì)的源碼解析！

什么是動(dòng)態(tài)代理？

動(dòng)態(tài)代理就是指運(yùn)行期，創(chuàng)建一個(gè)代理類，代理類與委托類實(shí)現(xiàn)了相同的接口，代理類主要負(fù)責(zé)為委托類預(yù)處理、過濾、轉(zhuǎn)發(fā)，以及事后處理等。代理類與委托類之間通常會(huì)存在關(guān)聯(lián)關(guān)系，一個(gè)代理類的實(shí)例與它的委托類的實(shí)例是關(guān)聯(lián)的。代理類的實(shí)例本身是并不真正關(guān)心被調(diào)用方法的內(nèi)部邏輯，而是會(huì)通過內(nèi)部訪問 調(diào)用 委托類的實(shí)例真正實(shí)現(xiàn)了的方法，來為調(diào)用者提供服務(wù)。

動(dòng)態(tài)代理實(shí)現(xiàn)原理

在內(nèi)存中動(dòng)態(tài)生成的代理類，不但繼承了Proxy類，還實(shí)現(xiàn)了和委托類相同的接口，并持有了InvocationHandler，當(dāng)調(diào)用代理類的方法時(shí)，在方法中會(huì)調(diào)用InvocationHandler#invoke方法。
而InvocationHandler構(gòu)建時(shí)持有了委托類的實(shí)例，當(dāng)InvocationHandler#invoke方法被調(diào)用時(shí)，會(huì)調(diào)用委托類對應(yīng)的方法，這樣就實(shí)現(xiàn)了代理實(shí)例執(zhí)行委托實(shí)例的方法。參考這里