前言

• 在Andrroid開發中，網路請求十分常用
• 而在Android網路請求庫中，Retrofit是當下最熱的一個網路請求庫

• 今天，我將手把手帶你深入剖析Retrofit v2.0的原始碼，希望你們會喜歡

目錄

1. 簡介

特別注意：

• 準確來說，Retrofit 是一個 RESTful 的 HTTP 網路請求框架的封裝。
• 原因：網路請求的工作本質上是 OkHttp 完成，而 Retrofit 僅負責 網路請求介面的封裝

• App應用程式通過 Retrofit 請求網路，實際上是使用 Retrofit 介面層封裝請求引數、Header、Url 等資訊，之後由 OkHttp 完成後續的請求操作
• 在服務端返回資料之後，OkHttp 將原始的結果交給 Retrofit，Retrofit根據使用者的需求對結果進行解析

2. 與其他網路請求開源庫對比

除了Retrofit，如今Android中主流的網路請求框架有：

• Android-Async-Http
• Volley
• OkHttp

下面是簡單介紹：

一圖讓你瞭解全部的網路請求庫和他們之間的區別！

附：各個主流網路請求庫的Github地址

3. Retrofit 的具體使用

4. 原始碼分析

4.1 Retrofit的本質流程

一般從網路通訊過程如下圖：

• 其實Retrofit的本質和上面是一樣的套路
• 只是Retrofit通過使用大量的設計模式進行功能模組的解耦，使得上面的過程進行得更加簡單 & 流暢

如下圖：

具體過程解釋如下：

1. 通過解析 網路請求介面的註解 配置 網路請求引數
2. 通過 動態代理 生成 網路請求物件

3. 通過 網路請求介面卡 將 網路請求物件 進行平臺適配

   平臺包括：Android、Rxjava、Guava和java8

4. 通過 網路請求執行器 傳送網路請求

5. 通過 資料轉換器 解析伺服器返回的資料
6. 通過 回撥執行器 切換執行緒（子執行緒 ->>主執行緒）
7. 使用者在主執行緒處理返回結果

下面介紹上面提到的幾個角色

4.2 原始碼分析

先來回憶Retrofit的使用步驟：
1. 建立Retrofit例項
2. 建立 網路請求介面例項 並 配置網路請求引數
3. 傳送網路請求

封裝了 資料轉換、執行緒切換的操作
4. 處理伺服器返回的資料

4.2.1 建立Retrofit例項

a. 使用步驟

 Retrofit retrofit = new Retrofit.Builder()
                                 .baseUrl("http://fanyi.youdao.com/")
                                 .addConverterFactory(GsonConverterFactory.create())
                                 .build();

b. 原始碼分析

Retrofit例項是使用建造者模式通過Builder類進行建立的

建造者模式：將一個複雜物件的構建與表示分離，使得使用者在不知道物件的建立細節情況下就可以直接建立複雜的物件。具體請看文章：建造者模式（Builder Pattern）- 最易懂的設計模式解析

接下來，我將分五個步驟對建立Retrofit例項進行逐步分析

步驟1

<-- Retrofit類 -->
 public final class Retrofit {

  private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();
  // 網路請求配置物件（對網路請求介面中方法註解進行解析後得到的物件）
  // 作用：儲存網路請求相關的配置，如網路請求的方法、資料轉換器、網路請求介面卡、網路請求工廠、基地址等

  private final HttpUrl baseUrl;
  // 網路請求的url地址

  private final okhttp3.Call.Factory callFactory;
  // 網路請求器的工廠
  // 作用：生產網路請求器（Call）
  // Retrofit是預設使用okhttp

   private final List<CallAdapter.Factory> adapterFactories;
  // 網路請求介面卡工廠的集合
  // 作用：放置網路請求介面卡工廠
  // 網路請求介面卡工廠作用：生產網路請求介面卡（CallAdapter）
  // 下面會詳細說明


  private final List<Converter.Factory> converterFactories;
  // 資料轉換器工廠的集合
  // 作用：放置資料轉換器工廠
  // 資料轉換器工廠作用：生產資料轉換器（converter）

  private final Executor callbackExecutor;
  // 回撥方法執行器

private final boolean validateEagerly; 
// 標誌位
// 作用：是否提前對業務介面中的註解進行驗證轉換的標誌位


<-- Retrofit類的建構函式 -->
Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,  
      List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,  
      Executor callbackExecutor, boolean validateEagerly) {  
    this.callFactory = callFactory;  
    this.baseUrl = baseUrl;  
    this.converterFactories = unmodifiableList(converterFactories); 
    this.adapterFactories = unmodifiableList(adapterFactories);   
    // unmodifiableList(list)近似於UnmodifiableList<E>(list)
    // 作用：建立的新物件能夠對list資料進行訪問，但不可通過該物件對list集合中的元素進行修改
    this.callbackExecutor = callbackExecutor;  
    this.validateEagerly = validateEagerly;  
  ...
  // 僅貼出關鍵程式碼
}

成功建立一個Retrofit物件的標準：配置好Retrofit類裡的成員變數，即配置好：

• serviceMethod：包含所有網路請求資訊的物件
• baseUrl：網路請求的url地址
• callFactory：網路請求工廠
• adapterFactories：網路請求介面卡工廠的集合
• converterFactories：資料轉換器工廠的集合
• callbackExecutor：回撥方法執行器

所謂xxxFactory、“xxx工廠”其實是設計模式中工廠模式的體現：將“類例項化的操作”與“使用物件的操作”分開，使得使用者不用知道具體引數就可以例項化出所需要的“產品”類。

這裡詳細介紹一下：CallAdapterFactory：該Factory生產的是CallAdapter，那麼CallAdapter又是什麼呢？

CallAdapter詳細介紹

• 定義：網路請求執行器（Call）的介面卡

  1. Call在Retrofit裡預設是OkHttpCall
  2. 在Retrofit中提供了四種CallAdapterFactory： ExecutorCallAdapterFactory（預設）、GuavaCallAdapterFactory、Java8CallAdapterFactory、RxJavaCallAdapterFactory

• 作用：將預設的網路請求執行器（OkHttpCall）轉換成適合被不同平臺來呼叫的網路請求執行器形式

  1. 如：一開始Retrofit只打算利用OkHttpCall通過ExecutorCallbackCall切換執行緒；但後來發現使用Rxjava更加方便（不需要Handler來切換執行緒）。想要實現Rxjava的情況，那就得使用RxJavaCallAdapterFactoryCallAdapter將OkHttpCall轉換成Rxjava(Scheduler)：

// 把response封裝成rxjava的Observeble，然後進行流式操作
Retrofit.Builder.addCallAdapterFactory(newRxJavaCallAdapterFactory().create()); 
// 關於RxJava的使用這裡不作更多的展開

1. Retrofit還支援java8、Guava平臺。

• 好處：用最小代價相容更多平臺，即能適配更多的使用場景

所以，接下來需要分析的步驟2、步驟3、步驟4、步驟4的目的是配置好上述所有成員變數

步驟2

我們先來看Builder類

請按下面提示的步驟進行檢視

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

// 從上面可以發現， Builder類的成員變數與Retrofit類的成員變數是對應的
// 所以Retrofit類的成員變數基本上是通過Builder類進行配置
// 開始看步驟1

<-- 步驟1 -->
// Builder的構造方法（無參）
 public Builder() {
      this(Platform.get());
// 用this呼叫自己的有參構造方法public Builder(Platform platform) ->>步驟5（看完步驟2、3、4再看）
// 並通過呼叫Platform.get（）傳入了Platform物件
// 繼續看Platform.get()方法 ->>步驟2
// 記得最後繼續看步驟5的Builder有參構造方法
    }
...
}

<-- 步驟2 -->
class Platform {

  private static final Platform PLATFORM = findPlatform();
  // 將findPlatform()賦給靜態變數

  static Platform get() {
    return PLATFORM;    
    // 返回靜態變數PLATFORM，即findPlatform() ->>步驟3
  }

<-- 步驟3 -->
private static Platform findPlatform() {
    try {

      Class.forName("android.os.Build");
      // Class.forName(xxx.xx.xx)的作用：要求JVM查詢並載入指定的類（即JVM會執行該類的靜態程式碼段）
      if (Build.VERSION.SDK_INT != 0) {
        return new Android(); 
        // 此處表示：如果是Android平臺，就建立並返回一個Android物件 ->>步驟4
      }
    } catch (ClassNotFoundException ignored) {
    }

    try {
      // 支援Java平臺
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }

    try {
      // 支援iOS平臺
      Class.forName("org.robovm.apple.foundation.NSObject");
      return new IOS();
    } catch (ClassNotFoundException ignored) {
    }

// 從上面看出：Retrofit2.0支援3個平臺：Android平臺、Java平臺、IOS平臺
// 最後返回一個Platform物件（指定了Android平臺）給Builder的有參構造方法public Builder(Platform platform)  --> 步驟5
// 說明Builder指定了執行平臺為Android
    return new Platform();
  }
...
}

<-- 步驟4 -->
// 用於接收伺服器返回資料後進行執行緒切換在主執行緒顯示結果

static class Android extends Platform {

    @Override
      CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {

      return new ExecutorCallAdapterFactory(callbackExecutor);
    // 建立預設的網路請求介面卡工廠
    // 該預設工廠生產的 adapter 會使得Call在非同步呼叫時在指定的 Executor 上執行回撥
    // 在Retrofit中提供了四種CallAdapterFactory： ExecutorCallAdapterFactory（預設）、GuavaCallAdapterFactory、Java8CallAdapterFactory、RxJavaCallAdapterFactory
    // 採用了策略模式

    }

    @Override 
      public Executor defaultCallbackExecutor() {
      // 返回一個預設的回撥方法執行器
      // 該執行器作用：切換執行緒（子->>主執行緒），並在主執行緒（UI執行緒）中執行回撥方法
      return new MainThreadExecutor();
    }

    static class MainThreadExecutor implements Executor {

      private final Handler handler = new Handler(Looper.getMainLooper());
      // 獲取與Android 主執行緒繫結的Handler 

      @Override 
      public void execute(Runnable r) {


        handler.post(r);
        // 該Handler是上面獲取的與Android 主執行緒繫結的Handler 
        // 在UI執行緒進行對網路請求返回資料處理等操作。
      }
    }

// 切換執行緒的流程：
// 1. 回撥ExecutorCallAdapterFactory生成了一個ExecutorCallbackCall物件
//2. 通過呼叫ExecutorCallbackCall.enqueue(CallBack)從而呼叫MainThreadExecutor的execute()通過handler切換到主執行緒
  }

// 下面繼續看步驟5的Builder有參構造方法
<-- 步驟5 -->
//  Builder類的建構函式2（有參）
  public  Builder(Platform platform) {

  // 接收Platform物件（Android平臺）
      this.platform = platform;

// 通過傳入BuiltInConverters()物件配置資料轉換器工廠（converterFactories）

// converterFactories是一個存放資料轉換器Converter.Factory的陣列
// 配置converterFactories即配置裡面的資料轉換器
      converterFactories.add(new BuiltInConverters());

// BuiltInConverters是一個內建的資料轉換器工廠（繼承Converter.Factory類）
// new BuiltInConverters()是為了初始化資料轉換器
    }

對Builder類分析完畢，總結：Builder設定了預設的

• 平臺型別物件：Android

• 網路請求介面卡工廠：CallAdapterFactory

  CallAdapter用於對原始Call進行再次封裝，如Call到Observable

• 資料轉換器工廠： converterFactory

• 回撥執行器：callbackExecutor

特別注意，這裡只是設定了預設值，但未真正配置到具體的Retrofit類的成員變數當中

步驟3

還是按部就班按步驟來觀看

<-- 步驟1 -->
public Builder baseUrl(String baseUrl) {

      // 把String型別的url引數轉化為適合OKhttp的HttpUrl型別
      HttpUrl httpUrl = HttpUrl.parse(baseUrl);     

    // 最終返回帶httpUrl型別引數的baseUrl（）
    // 下面繼續看baseUrl(httpUrl) ->> 步驟2
      return baseUrl(httpUrl);
    }


<-- 步驟2 -->
    public Builder baseUrl(HttpUrl baseUrl) {

      //把URL引數分割成幾個路徑碎片
      List<String> pathSegments = baseUrl.pathSegments();   

      // 檢測最後一個碎片來檢查URL引數是不是以"/"結尾
      // 不是就丟擲異常    
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }     
      this.baseUrl = baseUrl;
      return this;
    }

• 至此，步驟3分析完畢
• 總結：baseUrl（）用於配置Retrofit類的網路請求url地址
  

  將傳入的String型別url轉化為適合OKhttp的HttpUrl型別的url

步驟4

我們從裡往外看，即先看GsonConverterFactory.creat()

public final class GsonConverterFactory extends Converter.Factory {

<-- 步驟1 -->
  public static GsonConverterFactory create() {
    // 建立一個Gson物件
    return create(new Gson()); ->>步驟2
  }

<-- 步驟2 -->
  public static GsonConverterFactory create(Gson gson) {
    // 建立了一個含有Gson物件例項的GsonConverterFactory
    return new GsonConverterFactory(gson); ->>步驟3
  }

  private final Gson gson;

<-- 步驟3 -->
  private GsonConverterFactory(Gson gson) {
    if (gson == null) throw new NullPointerException("gson == null");
    this.gson = gson;
  }

• 所以，GsonConverterFactory.creat()是建立了一個含有Gson物件例項的GsonConverterFactory，並返回給addConverterFactory（）
• 接下來繼續看：addConverterFactory（）

// 將上面建立的GsonConverterFactory放入到 converterFactories陣列
// 在第二步放入一個內建的資料轉換器工廠BuiltInConverters(）後又放入了一個GsonConverterFactory
  public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }

• 至此，分析完畢
• 總結：步驟4用於建立一個含有Gson物件例項的GsonConverterFactory並放入到資料轉換器工廠converterFactories裡
  

  1. 即Retrofit預設使用Gson進行解析
     
  2. 若使用其他解析方式（如Json、XML或Protocobuf），也可通過自定義資料解析器來實現（必須繼承 Converter.Factory）

步驟5

終於到了最後一個步驟了。

    public Retrofit build() {

 <--  配置網路請求執行器（callFactory）-->
      okhttp3.Call.Factory callFactory = this.callFactory;
      // 如果沒指定，則預設使用okhttp
      // 所以Retrofit預設使用okhttp進行網路請求
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

 <--  配置回撥方法執行器（callbackExecutor）-->
      Executor callbackExecutor = this.callbackExecutor;
      // 如果沒指定，則預設使用Platform檢測環境時的預設callbackExecutor
      // 即Android預設的callbackExecutor
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

 <--  配置網路請求介面卡工廠（CallAdapterFactory）-->
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      // 向該集合中添加了步驟2中建立的CallAdapter.Factory請求介面卡（新增在集合器末尾）
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
    // 請求介面卡工廠集合儲存順序：自定義1介面卡工廠、自定義2介面卡工廠...預設介面卡工廠（ExecutorCallAdapterFactory）

 <--  配置資料轉換器工廠：converterFactory -->
      // 在步驟2中已經添加了內建的資料轉換器BuiltInConverters(）（新增到集合器的首位）
      // 在步驟4中又插入了一個Gson的轉換器 - GsonConverterFactory（新增到集合器的首二位）
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
      // 資料轉換器工廠集合儲存的是：預設資料轉換器工廠（ BuiltInConverters）、自定義1資料轉換器工廠（GsonConverterFactory）、自定義2資料轉換器工廠....

// 注：
//1. 獲取合適的網路請求介面卡和資料轉換器都是從adapterFactories和converterFactories集合的首位-末位開始遍歷
// 因此集合中的工廠位置越靠前就擁有越高的使用許可權

      // 最終返回一個Retrofit的物件，並傳入上述已經配置好的成員變數
      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }

• 至此，步驟5分析完畢
• 總結：在最後一步中，通過前面步驟設定的變數，將Retrofit類的所有成員變數都配置完畢。
• 所以，成功建立了Retrofit的例項

總結

Retrofit 使用建造者模式通過Builder類建立了一個Retrofit例項，具體建立細節是配置了：

• 平臺型別物件（Platform - Android）
• 網路請求的url地址（baseUrl）

• 網路請求工廠（callFactory）

預設使用OkHttpCall

網路請求介面卡工廠的集合（adapterFactories）

本質是配置了網路請求介面卡工廠- 預設是ExecutorCallAdapterFactory

資料轉換器工廠的集合（converterFactories）

本質是配置了資料轉換器工廠

回撥方法執行器（callbackExecutor）
預設回撥方法執行器作用是：切換執行緒（子執行緒 - 主執行緒）

由於使用了建造者模式，所以開發者並不需要關心配置細節就可以建立好Retrofit例項，建造者模式get。

在建立Retrofit物件時，你可以通過更多更靈活的方式去處理你的需求，如使用不同的Converter、使用不同的CallAdapter，這也就提供了你使用RxJava來呼叫Retrofit的可能

2. 建立網路請求介面的例項

2.1 使用步驟

<-- 步驟1：定義接收網路資料的類 -->
<-- JavaBean.java -->
public class JavaBean {
  .. // 這裡就不介紹了
  }

<-- 步驟2：定義網路請求的介面類 -->
<-- AccessApi.java -->
public interface AccessApi {
    // 註解GET：採用Get方法傳送網路請求
    // Retrofit把網路請求的URL分成了2部分：1部分baseurl放在建立Retrofit物件時設定；另一部分在網路請求介面設定（即這裡）
    // 如果接口裡的URL是一個完整的網址，那麼放在建立Retrofit物件時設定的部分可以不設定
    @GET("openapi.do?keyfrom=Yanzhikai&key=2032414398&type=data&doctype=json&version=1.1&q=car")

    // 接受網路請求資料的方法
    Call<JavaBean> getCall();
    // 返回型別為Call<*>，*是解析得到的資料型別，即JavaBean
}

<-- 步驟3：在MainActivity建立介面類例項  -->
AccessApi NetService = retrofit.create(AccessApi.class);

<-- 步驟4：對傳送請求的url進行封裝，即生成最終的網路請求物件  --> 
        Call<JavaBean> call = NetService.getCall();

2.2 原始碼分析

• 結論：Retrofit是通過外觀模式 & 代理模式 使用create（）方法建立網路請求介面的例項（同時，通過網路請求接口裡設定的註解進行了網路請求引數的配置）
  

  1. 外觀模式：定義一個統一介面，外部與通過該統一的介面對子系統裡的其他介面進行訪問。具體請看：外觀模式（Facade Pattern） - 最易懂的設計模式解析
     
  2. 下面主要分析步驟3和步驟4：

<-- 步驟3：在MainActivity建立介面類例項  -->
AccessApi NetService = retrofit.create(NetService.class);

<-- 步驟4：對傳送請求的url進行封裝，即生成最終的網路請求物件  --> 
        Call<JavaBean> call = NetService.getCall();

步驟3講解：AccessApi NetService = retrofit.create(NetService.class);

 public <T> T create(final Class<T> service) {

       if (validateEagerly) {  
      // 判斷是否需要提前驗證
      eagerlyValidateMethods(service); 
      // 具體方法作用：
      // 1. 給介面中每個方法的註解進行解析並得到一個ServiceMethod物件
      // 2. 以Method為鍵將該物件存入LinkedHashMap集合中
     // 特別注意：如果不是提前驗證則進行動態解析對應方法（下面會詳細說明），得到一個ServiceMethod物件，最後存入到LinkedHashMap集合中，類似延遲載入（預設）
    }  


        // 建立了網路請求介面的動態代理物件，即通過動態代理建立網路請求介面的例項 （並最終返回）
        // 該動態代理是為了拿到網路請求介面例項上所有註解
    return (T) Proxy.newProxyInstance(
          service.getClassLoader(),      // 動態生成介面的實現類 
          new Class<?>[] { service },    // 動態建立例項
          new InvocationHandler() {     // 將代理類的實現交給 InvocationHandler類作為具體的實現（下面會解釋）
          private final Platform platform = Platform.get();

         // 在 InvocationHandler類的invoke（）實現中，除了執行真正的邏輯（如再次轉發給真正的實現類物件），還可以進行一些有用的操作
         // 如統計執行時間、進行初始化和清理、對介面呼叫進行檢查等。
          @Override 
           public Object invoke(Object proxy, Method method, Object... args)
              throws Throwable {

            // 下面會詳細介紹 invoke（）的實現
            // 即下面三行程式碼
            ServiceMethod serviceMethod = loadServiceMethod(method);     
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

// 特別注意
// return (T) roxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler invocationHandler)
// 可以解讀為：getProxyClass(loader, interfaces) .getConstructor(InvocationHandler.class).newInstance(invocationHandler);
// 即通過動態生成的代理類，呼叫interfaces介面的方法實際上是通過呼叫InvocationHandler物件的invoke（）來完成指定的功能
// 先記住結論，在講解步驟4的時候會再次詳細說明


<-- 關注點1：eagerlyValidateMethods（） -->
private void eagerlyValidateMethods(Class<?> service) {  
    Platform platform = Platform.get();  
    for (Method method : service.getDeclaredMethods()) {  
      if (!platform.isDefaultMethod(method)) {  loadServiceMethod(method); } 
      // 將傳入的ServiceMethod物件加入LinkedHashMap<Method, ServiceMethod>集合
     // 使用LinkedHashMap集合的好處：lruEntries.values().iterator().next()獲取到的是集合最不經常用到的元素，提供了一種Lru演算法的實現
    }  
}  

建立網路介面例項用了外觀模式 & 代理模式：

使用外觀模式進行訪問，裡面用了代理模式

1. 外觀模式

• 外觀模式：定義一個統一介面，外部與通過該統一的介面對子系統裡的其他介面進行訪問。具體請看：外觀模式（Facade Pattern） - 最易懂的設計模式解析

• Retrofit物件的外觀（門店） = retrofit.create()

• 通過這一外觀方法就可以在內部呼叫各個方法建立網路請求介面的例項和配置網路請求引數
  

  大大降低了系統的耦合度

2. 代理模式

• 代理模式：通過訪問代理物件的方式來間接訪問目標物件
  

  分為靜態代理 & 動態代理：
  1. 靜態代理：代理類在程式執行前已經存在的代理方式
  2. 動態代理：代理類在程式執行前不存在、執行時由程式動態生成的代理方式
  具體請看文章代理模式（Proxy Pattern）- 最易懂的設計模式解析

• return (T) roxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler invocationHandler)通過代理模式中的動態代理模式，動態生成網路請求介面的代理類，並將代理類的例項建立交給InvocationHandler類 作為具體的實現，並最終返回一個動態代理物件。
  生成例項過程中含有生成實現類的快取機制（單例模式），下面會詳細分析

使用動態代理的好處：

• 當NetService物件呼叫getCall（）介面中方法時會進行攔截，呼叫都會集中轉發到 InvocationHandler#invoke （），可集中進行處理
• 獲得網路請求介面例項上的所有註解
• 更方便封裝ServiceMethod

下面看原始碼分析

下面將詳細分析`InvocationHandler類 # invoke（）`裡的具體實現

 new InvocationHandler() {   
          private final Platform platform = Platform.get();

  @Override 
           public Object invoke(Object proxy, Method method, Object... args)
              throws Throwable {

            // 將詳細介紹下面程式碼
            // 關注點1
            // 作用：讀取網路請求接口裡的方法，並根據前面配置好的屬性配置serviceMethod物件
            ServiceMethod serviceMethod = loadServiceMethod(method);     

            // 關注點2
            // 作用：根據配置好的serviceMethod物件建立okHttpCall物件 
            OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);

            // 關注點3
            // 作用：呼叫OkHttp，並根據okHttpCall返回rejava的Observe物件或者返回Call
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }

下面將詳細介紹3個關注點的程式碼。

關注點1： ServiceMethod serviceMethod = loadServiceMethod(method);

<-- loadServiceMethod(method)方法講解 -->
// 一個 ServiceMethod 物件對應於網路請求接口裡的一個方法
// loadServiceMethod（method）負責載入 ServiceMethod：

  ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
      // 設定執行緒同步鎖
    synchronized (serviceMethodCache) {

      result = serviceMethodCache.get(method);
      // ServiceMethod類物件採用了單例模式進行建立
      // 即建立ServiceMethod物件前，先看serviceMethodCache有沒有快取之前建立過的網路請求例項

      // 若沒快取，則通過建造者模式建立 serviceMethod 物件
      if (result == null) {
      // 下面會詳細介紹ServiceMethod生成例項的過程
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }
// 這裡就是上面說的建立例項的快取機制：採用單例模式從而實現一個 ServiceMethod 物件對應於網路請求接口裡的一個方法
// 注：由於每次獲取介面例項都是傳入 class 物件
// 而 class 物件在程序內單例的，所以獲取到它的同一個方法 Method 例項也是單例的，所以這裡的快取是有效的。

下面，我將分3個步驟詳細分析serviceMethod例項的建立過程：

步驟1：ServiceMethod類 建構函式

<-- ServiceMethod 類 -->
public final class ServiceMethod {
final okhttp3.Call.Factory callFactory;   // 網路請求工廠  
final CallAdapter<?> callAdapter;  
// 網路請求介面卡工廠
// 具體建立是在new ServiceMethod.Builder(this, method).build()最後的build()中
// 下面會詳細說明

private final Converter<ResponseBody, T> responseConverter; 
// Response內容轉換器  
// 作用：負責把伺服器返回的資料（JSON或者其他格式，由 ResponseBody 封裝）轉化為 T 型別的物件；

private final HttpUrl baseUrl; // 網路請求地址  
private final String relativeUrl; // 網路請求的相對地址  
private final String httpMethod;   // 網路請求的Http方法  
private final Headers headers;  // 網路請求的http請求頭 鍵值對  
private final MediaType contentType; // 網路請求的http報文body的型別  

private final ParameterHandler<?>[] parameterHandlers;  
  // 方法引數處理器
  // 作用：負責解析 API 定義時每個方法的引數，並在構造 HTTP 請求時設定引數；
  // 下面會詳細說明

// 說明：從上面的成員變數可以看出，ServiceMethod物件包含了訪問網路的所有基本資訊

<-- ServiceMethod 類的建構函式 -->
// 作用：傳入各種網路請求引數
ServiceMethod(Builder<T> builder) {

    this.callFactory = builder.retrofit.callFactory();  
    this.callAdapter = builder.callAdapter;   
    this.responseConverter = builder.responseConverter;   

    this.baseUrl = builder.retrofit.baseUrl();   
    this.relativeUrl = builder.relativeUrl;   
    this.httpMethod = builder.httpMethod;  
    this.headers = builder.headers;  
    this.contentType = builder.contentType; .  
    this.hasBody = builder.hasBody; y  
    this.isFormEncoded = builder.isFormEncoded;   
    this.isMultipart = builder.isMultipart;  
    this.parameterHandlers = builder.parameterHandlers;  
}

步驟2：ServiceMethod的Builder（）

   public Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;

      // 獲取網路請求介面方法裡的註釋
      this.methodAnnotations = method.getAnnotations();
      // 獲取網路請求介面方法裡的引數型別       
      this.parameterTypes = method.getGenericParameterTypes();  
      //獲取網路請求介面方法裡的註解內容    
      this.parameterAnnotationsArray = method.getParameterAnnotations();    
    }

步驟3：ServiceMethod的build（）

// 作用：控制ServiceMethod物件的生成流程

 public ServiceMethod build() {

      callAdapter = createCallAdapter();    
      // 根據網路請求介面方法的返回值和註解型別，從Retrofit物件中獲取對應的網路請求介面卡  -->關注點1

      responseType = callAdapter.responseType();    
     // 根據網路請求介面方法的返回值和註解型別，從Retrofit物件中獲取該網路介面卡返回的資料型別

      responseConverter = createResponseConverter();    
      // 根據網路請求介面方法的返回值和註解型別，從Retrofit物件中獲取對應的資料轉換器  -->關注點3
      // 構造 HTTP 請求時，我們傳遞的引數都是String
      // Retrofit 類提供 converter把傳遞的引數都轉化為 String 
      // 其餘型別的引數都利用 Converter.Factory 的stringConverter 進行轉換
      // @Body 和 @Part 型別的引數利用Converter.Factory 提供的 requestBodyConverter 進行轉換
      // 這三種 converter 都是通過“詢問”工廠列表進行提供，而工廠列表我們可以在構造 Retrofit 物件時進行新增。


       for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }
      // 解析網路請求介面中方法的註解
      // 主要是解析獲取Http請求的方法
     // 註解包括：DELETE、GET、POST、HEAD、PATCH、PUT、OPTIONS、HTTP、retrofit2.http.Headers、Multipart、FormUrlEncoded
     // 處理主要是呼叫方法 parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) ServiceMethod中的httpMethod、hasBody、relativeUrl、relativeUrlParamNames域進行賦值

     int parameterCount = parameterAnnotationsArray.length;
     // 獲取當前方法的引數數量

      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        // 為方法中的每個引數建立一個ParameterHandler<?>物件並解析每個引數使用的註解型別
        // 該物件的建立過程就是對方法引數中註解進行解析
        // 這裡的註解包括：Body、PartMap、Part、FieldMap、Field、Header、QueryMap、Query、Path、Url 
        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      } 
      return new ServiceMethod<>(this);

<-- 總結 -->
// 1. 根據返回值型別和方法標註從Retrofit物件的的網路請求介面卡工廠集合和內容轉換器工廠集合中分別獲取到該方法對應的網路請求介面卡和Response內容轉換器；
// 2. 根據方法的標註對ServiceMethod的域進行賦值
// 3. 最後為每個方法的引數的標註進行解析，獲得一個ParameterHandler<?>物件
// 該物件儲存有一個Request內容轉換器——根據引數的型別從Retrofit的內容轉換器工廠集合中獲取一個Request內容轉換器或者一個String內容轉換器。
    }


<-- 關注點1：createCallAdapter() -->
 private CallAdapter<?> createCallAdapter() {

      // 獲取網路請求接口裡方法的返回值型別
      Type returnType = method.getGenericReturnType();      

      // 獲取網路請求介面接口裡的註解
      // 此處使用的是@Get
      Annotation[] annotations = method.getAnnotations();       
      try {

      return retrofit.callAdapter(returnType, annotations); 
      // 根據網路請求介面方法的返回值和註解型別，從Retrofit物件中獲取對應的網路請求介面卡
      // 下面會詳細說明retrofit.callAdapter（） -- >關注點2
      }
...


<-- 關注點2：retrofit.callAdapter()  -->
 public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
  }

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

    // 建立 CallAdapter 如下
    // 遍歷 CallAdapter.Factory 集合尋找合適的工廠（該工廠集合在第一步構造 Retrofit 物件時進行新增（第一步時已經說明））
    // 如果最終沒有工廠提供需要的 CallAdapter，將丟擲異常
    for (int i = start, count = adapterFactories.size(); i < count; i++) {
      CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);      
      if (adapter != null) {
        return adapter;
      }
    }


<--   關注點3：createResponseConverter（） -->

 private Converter<ResponseBody, T> createResponseConverter() {
      Annotation[] annotations = method.getAnnotations();
      try {

        // responseConverter 還是由 Retrofit 類提供  -->關注點4
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) { 
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }

<--   關注點4：responseBodyConverter（） -->
  public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
    return nextResponseBodyConverter(null, type, annotations);
  }

 public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory skipPast,

    int start = converterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = converterFactories.size(); i < count; i++) {

       // 獲取Converter 過程：（和獲取 callAdapter 基本一致）
         Converter<ResponseBody, ?> converter =
          converterFactories.get(i).responseBodyConverter(type, annotations, this); 
       // 遍歷 Converter.Factory 集合並尋找合適的工廠（該工廠集合在構造 Retrofit 物件時進行新增（第一步時已經說明））
       // 由於構造Retroifit採用的是Gson解析方式，所以取出的是GsonResponseBodyConverter
       // Retrofit - Converters 還提供了 JSON，XML，ProtoBuf 等型別資料的轉換功能。
       // 繼續看responseBodyConverter（） -->關注點5    
    }


<--   關注點5：responseBodyConverter（） -->
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, 
    Annotation[] annotations, Retrofit retrofit) {


  TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
  // 根據目標型別，利用 Gson#getAdapter 獲取相應的 adapter
  return new GsonResponseBodyConverter<>(gson, adapter);
}

// 做資料轉換時呼叫 Gson 的 API 即可。
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;
  }

  @Override 
   public T convert(ResponseBody value) throws IOException {
    JsonReader jsonReader = gson.newJsonReader(value.charStream());
    try {
      return adapter.read(jsonReader);
    } finally {
      value.close();
    }
  }
}

• 當選擇了RxjavaCallAdapterFactory後，Rxjava通過策略模式選擇對應的adapter
  
• 具體過程是：根據網路介面方法的返回值型別來選擇具體要用哪種CallAdapterFactory，然後建立具體的CallAdapter例項

採用工廠模式使得各功能模組高度解耦

• 上面提到了兩種工廠：CallAdapter.Factory & Converter.Factory分別負責提供不同的功能模組
• 工廠負責如何提供、提供何種功能模組
• Retrofit 只負責提供選擇何種工廠的決策資訊（如網路介面方法的引數、返回值型別、註