Retrofit 源碼解析

簡單用法

Retrofit最簡單的用法就是定義一個接口，創建Retrofit對象，調用create()方法得到一個service,
然后自己根據service中的方法去做同步或者異步的請求，拿到數據對象，十分簡單快速，簡單代碼如下：

public interface GitHub {
   @GET("/repos/{owner}/{repo}/contributors")
   Call<List<Integer>> contributors(@Path("owner") String owner,@Path("repo") String repo);
}

.創建
Retrofit retrofit = new Retrofit.Builder().baseUrl("xxx").build();
.代理
GitHub gitHub = retrofit.create(GitHub.class);
Call<List<Integer>> call = gitHub.contributors("xx", "xx");
.執行
call.enqueue(new Callback<List<Integer>>() {
    @Override
    public void onResponse(Call<List<Integer>> call, Response<List<Integer>> response) {

    }
    @Override
    public void onFailure(Call<List<Integer>> call, Throwable t) {

    }
});

流程分析

創建

那這么簡單的過程，剛開始看的時候覺得有點懵逼呀，怎么他就幫你完成了請求，你明明什么都沒有做，下面我們按照它的流程慢慢來解析一下整個過程。
我們要用Retrofit,首先自然是要創建它,也就是這行代碼Retrofit retrofit = new Retrofit.Builder().baseUrl("xxx").build();.
這里創建Retrofit是通過它的一個內部類Builder來創建的，也就是創建者模式，這個模式很簡單，不知道的自行百度，谷歌。
好，我們來看看這個builder做了什么,除了初始化有個Platform.get(),直接看最后的build(),其余的方法都是設置參數，主要就是這個build()：

public Builder() {
      this(Platform.get());
}
public Retrofit build() {
  1.
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }
  2.
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
  3.
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }
  4.
      // Make a defensive copy of the adapters and add the default Call adapter.
      List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
 5.
      // Make a defensive copy of the converters.
      List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

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

首先一初始化，就做了一件事情，是啥Platform.get()，Platform是啥？直譯過來就是平臺啊，平臺是啥？為啥要有平臺？看下面這個代碼get()其實
就是一個就是調用findPlatform()：

private static final Platform PLATFORM = findPlatform();

static Platform get() {return PLATFORM;}

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和Java8兩種平臺，Android我們還是能理解的，為啥還有個Java8，不要問我，我也不知道啊，Retrofit的作者炒雞暖男，關心全世界各種碼農，
我是個寫android代碼的我們就看Android平臺就好了
下面我們來看一下build()這個方法：

• 第一步很簡單，沒有baseUrl拋出異常，最基本的沒有，事情沒法干是吧。
• 第二步，如果沒有給他設置callFactory，那默認給他一個callFactory，默認就是新創建一個OkHttpClient，這里可能我們會有自己做過一些
  處理的OkHttpClient,比如加了Interceptor啊之類的，設置進來就好了，就不會用默認的。
  有人可能會問啥是callFactory啊 ？callFactory嘛，就是call的factory嘛，call是啥，就是請求，factory是啥，就是工廠，callFactory就是創建請求的
  工廠，OkHttpClient就是一個很牛逼的創建請求的工廠，不在本文討論范圍內，就不多言了。
• 第三步，設置callbackExecutor,又來一個，這callbackExecutor又是啥呢？callback就是回調嘛，啥回調，就是網絡請求返回回來數據的回調，executor呢，就是執行者
  ，合起來就是回調的執行者，意思網絡成功了之后交給他它了。如果你沒有設置它就自己整一個默認的回調嘛，不能沒有。但是這里它要搞事情了，它返回了一個啥？
  platform.defaultCallbackExecutor();來，我們看一下android下它返回的是啥：

static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

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

是啥？MainThreadExecutor()啊，啥意思就是主線程啊，下面寫的明明白白的Looper.getMainLooper()再把要執行的Runnablepost到主線程上執行
因為它是默認的嘛，可能就說大多數人都是得到數據更新UI啊啥的，所以就默認在主線程上執行回調了。我就不想拿到數據在主線程座做咋辦，我拿到數據我就想更新數據庫，
我想在IO線程上搞事情，那就自己寫個callbackExecutor，自己在IO線程上做就好了，人家提供了一個方法callbackExecutor(Executor executor)給你，你自己設置進去就好了

• 第四步是啥？看代碼說話，那就是設置callAdapterFactory啊 。callAdapterFactory又是什么鬼啊，和上面一樣啊，拆分一下呀。CallAdapter啥意思，就是請求的
  適配器，請求的適配器是什么鬼啊。來來來我告訴你，你看看源碼里面根目錄是不是有一個包名字叫做'retrofit-adapter',這個包就是實現了一些列的CallAdapter
  意思就是你想將返回的數據用什么東西包裝起來，比如你用Rxjava的話想返回Observable，或者高興，想用Java8的CompletableFuture，這些都由你呀。
  但是這些都實現了一個叫CallAdapter的接口。我們來簡單看看這個接口：

public interface CallAdapter<R, T> {
  Type responseType();
  T adapt(Call<R> call);
  abstract class Factory {
    public abstract CallAdapter<?, ?> get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    protected static Class<?> getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

其實接口里面就是兩個方法還有一個靜態的工廠類。responseType()這個方法決定請求回來之后返回的是什么類型的數據。比如在示例用法中我們的List<Integer>
adapt()這個方法是干嘛的呢？就是適配嘛，就是怎樣把返回回來的數據通過這個方法包裝成你想要的對象。
這里看到這個名字adapter你想到了啥，其實就是傳說中的適配器模式啊，就是我給你定義一個接口放這里，我在框架里的邏輯就用這個接口來做就好了，至于你想要怎樣的實現，
想用框架供給你的一些實現比如Rxjava或者Java8的CallAdapter,或者是你自己心情好想用自己的實現一個其他的CallAdapter，你自己決定就好了。這就是傳說中的啥？？擴展性好啊。
繼續看build()
這個方法，它調用的是adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));· 再回來Platform看defaultCallAdapterFactory()返回的是一個ExecutorCallAdapterFactory。這個類他么的又來干嘛，當然是搞事情。 進去瞅一眼，發現了什么？它當然是繼承CallAdapter.Factory了，這個不說了，看幾句代碼來，看它的get()方法，看看這個工廠是怎么造CallAdapter`的：

  public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter<Object, Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call<Object> adapt(Call<Object> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }

返回了一個簡單新創建的實現CallAdapter的匿名類。注意看看這里的adapt()方法，前面講了就是用它來實現到底返回什么包裝對象的邏輯。這里返回的是一個
ExecutorCallbackCall,ExecutorCallbackCall是這ExecutorCallAdapterFactory里面的一個內部類.來看看它的代碼：

static final class ExecutorCallbackCall<T> implements Call<T> {
  final Executor callbackExecutor;
  final Call<T> delegate;

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

  @Override public void enqueue(final Callback<T> callback) {
    if (callback == null) throw new NullPointerException("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();
  }
}

它實現了Call這個接口，Call我們前面說了，是啥，就是一個請求嘛，然而我們看這里并沒有實際做請求而是用了一個靜態代理，
通過代理類的實現來實現call請求，而在這里面做了一些其他的邏輯比如cancel的邏輯，而實際上做請求的還是交個了delegate -> OkHttpCall.

• 第五步，接著看上面的build()的代碼，不要著急，第一段代碼還沒講完呢。第五步是什么？List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
  這一步就是關于Converter，顧名思義，它就是一個轉換器，什么轉換器，數據的轉換器，我們從后端獲取到的數據，一般都是一些序列化的數據，例如json,xml,protobuf之類的
  而我們前端用到的需要的是一個對象，我們就需要吧這些序列化的數據轉換成我們想要的能直接用的用起來爽的對象，這時候就需要現在登場的這個東西。現在json用的
  比較多，我們平時都會用什么gson,jackson或者其他的三方庫來轉化它，你覺得哪個用起來高興就可以用什么寫一個Converter,然后用Builder中的addConverterFactory
  就可以用你想要的了，而且你都不用寫，因為官方提供了好多種Converter的，在根目錄下的'retrofit-converters'這個包下面，你只需要用就好了，那我們這里如果沒有設置過converterFactories
  咋辦？咋辦？沒設置，后面找不到會報錯的。
  這里的Response是Retrofit對OkHttp的ResponseBody封裝了一些邏輯的類，源碼就不貼了，自己點進去看看。
  這里我們順便看看Converter這個接口：

public interface Converter<F, T> {
  T convert(F value) throws IOException;
  abstract class Factory {
    
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }
    public Converter<?, RequestBody> requestBodyConverter(Type type,
        Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
      return null;
    }
    public Converter<?, String> stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }
  }
}

接口就一個方法，就是轉換，然后里面還有一個靜態的工廠類我們看到里面有3個方法，其實很好理解。我們需要把返回來的ResponseBody里的數據轉換
成我們想要的東西，我們也會想要把我們RequestBody程序里的東西轉換成后端想要的東西.就是這個邏輯拉，這個工廠類就是給我們提供各種轉換器，我們
只需要根據我們自己的需求來實現或者使用對應的就好了。這又是啥，還是和上面一樣啊，給你定義一個接口，接口是什么，就是標準，給你一個標準
你實現這個標準就行，我用我這套標準來實現我內部的邏輯，至于你怎么實現，想用啥方法實現，玩成什么花樣都可以，我不管，只要你遵循了標準，就可以。這樣
擴展性就好呀。這就是人家大神牛逼之處啊，代碼寫到高處就是寫標準啊。
講到這里，我們示例用法中的第一句Retrofit retrofit = new Retrofit.Builder().baseUrl("xxx").build();總算講完了。中間這么多邏輯，這么
多心血，你看，你一句話就搞定了，是不是該學習學習。

代理

build好了之后，就是需要的材料都搞齊了，要工廠有工廠要材料有材料，下面我們來講講這第二句，第二句，那厲害了。其實他就是啥，利用你定義的一個充滿各種注解的接口interface GitHub()來簡單粗暴的做了一個動作，
那就是create()。這個動作看似簡單，實則過于粗暴啊，進去看看代碼

public <T> T create(final Class<T> service) {
  1.
    Utils.validateServiceInterface(service);
  2.
    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, Object... args)
              throws Throwable {
            3.
            // If the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            4.
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            5.
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            6.
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

這里你首先要了解的知識是泛型，反射，動態代理。如果不懂，請自行google.好吧，我說下動態代理，動態代理就是動態的代理，就是只要你實現了一個借口，Proxy就可以根據這個接口來對你
實現代理，也就是說Proxy只能代理實現了接口的類。這也就是為什么我們要寫一個Interface來作為Service,然后在里面寫一些注解之類的。如果接觸過JAVAEE的話，
Spring里的AOP動態代理是采用cglib來修改字節碼實現的動態代理，而且不需要實現接口，感興趣的朋友可以看一下。回到這里，就是通過Proxy這個類利用反射，對你寫的接口進行解析
獲取到你申明的方法，然后對你的方法實現框架想要實現的邏輯，來完成所謂的代理。
我們來看代碼。

• 第一步，就是檢驗你定義的service接口是不是正確。簡單看下代碼,首先如果不是接口會拋出異常，還有為了避免出現bug,和保證API都是統一的標準，不允許定義的Service接口繼承別的接口

static <T> void validateServiceInterface(Class<T> service) {
    if (!service.isInterface()) {
      throw new IllegalArgumentException("API declarations must be interfaces.");
    }
    // Prevent API interfaces from extending other interfaces. This not only avoids a bug in
    // Android (http://b.android.com/58753) but it forces composition of API declarations which is
    // the recommended pattern.
    if (service.getInterfaces().length > 0) {
      throw new IllegalArgumentException("API interfaces must not extend other interfaces.");
    }
  }

• 第二步，如果你在前面creat()的時候，設置過validateEagerly為true的話，它會在這一步將所有的你Service中聲明的Method在這里都初始化了,并且緩存起來

private void eagerlyValidateMethods(Class<?> service) {
    Platform platform = Platform.get();
    for (Method method : service.getDeclaredMethods()) {
      if (!platform.isDefaultMethod(method)) {
        loadServiceMethod(method);
      }
    }
  }

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

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder<>(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

這里在解析你用annotations標注的Method時也一樣用到了Builder這種模式，通過ServiceMethod這個類來解析你的標注，將標準轉化為實際的邏輯。
這里面的代碼比較多，我就不再貼了，其實里面的邏輯比較單一，但是比較復雜。主要就是根據不同的標注，來生成對應的對象，你用著有多簡單就有框架來給你承受多復雜。只看一下他的Constructor
最后會得到著一些東西。

  ServiceMethod(Builder<R, T> builder) {
    this.callFactory = builder.retrofit.callFactory();
    this.callAdapter = builder.callAdapter;
    this.baseUrl = builder.retrofit.baseUrl();
    this.responseConverter = builder.responseConverter;
    this.httpMethod = builder.httpMethod;
    this.relativeUrl = builder.relativeUrl;
    this.headers = builder.headers;
    this.contentType = builder.contentType;
    this.hasBody = builder.hasBody;
    this.isFormEncoded = builder.isFormEncoded;
    this.isMultipart = builder.isMultipart;
    this.parameterHandlers = builder.parameterHandlers
  }

• 第三步，這時候就進入到每個方法的代理實現里來了。實際上這里面是已經進入了上面例子中的第三句了，因為是為每一個其中的方法實現代理Call<List<Integer>> call = gitHub.contributors("xx", "xx");的流程了。
  如果是Object聲明的方法，直接執行原方法，然后platform.isDefaultMethod(method)在Android平臺直接返回false，所以這里直接忽略。
• 第四步，這里如果第二步沒有build過這個方法，或者緩存里沒有會build這個方法，緩存里有的話直接取過來。
• 第五步，根據serviceMethod初始化OkHttpCall,真正執行請求是交給這個類來執行的。
• 第六步，根據OkHttpCall最后返回CallAdapter適配后的你想要的類型.到這里就通過代理得到了一個所有參數，headers或者其他都準備好了的，并且也通過CallAdapter實現了返回數據包裝的一個完整的數據類型.

講到這里，準備工作都已經做齊了，就等著最后執行了。這里的Call是根據你設置的CallAdapter來返回的，比如如果你熟悉Rxjava，那結合Rxjava，這里也可以
返回一個Observable.當然你在定義這個Service接口的時候也應該聲明為這個返回類型。就算是Call ,也不是返回OkHttpCall,前面講到了ExecutorCallbackCall來靜態代理了
OkHttpCall，實際上這里返回的是ExecutorCallbackCall.

執行

如果是ExecutorCallbackCall的話，提供了同步的excute和異步的enqueue來執行這個請求，并且提供一個Callback回調的接口來處理調用成功
或者失敗。調用之后是如何拿到數據之后，被Converter轉化，被CallAdapter包裝然后返回給我們的呢？
來我們慢慢分析。前面我們提到了，其實所有的請求執行，實際上都是OkHttpCall這個類在操作。OkHttpCall實現了Call接口，就是一些請求的常用邏輯，同步異步cancel等等，
不管是同步還是異步，最后都是拿到返回的Response轉換成我們想要的數據。我們挑一個OkHttpCall中同步的方法看看：

  @Override 
  public Response<T> execute() throws IOException {
      okhttp3.Call call;

      synchronized (this) {
        ... 中間邏輯很簡單就省略了

      return parseResponse(call.execute());
     }
  }


 Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();
    rawResponse = rawResponse.newBuilder()
        .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
        .build();

    int code = rawResponse.code();
    if (code < 200 || code >= 300) {
      try {
        // Buffer the entire body to avoid future I/O.
        ResponseBody bufferedBody = Utils.buffer(rawBody);
        return Response.error(bufferedBody, rawResponse);
      } finally {
        rawBody.close();
      }
    }

    if (code == 204 || code == 205) {
      rawBody.close();
      return Response.success(null, rawResponse);
    }

    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }

首先我們就來看Retrofit在執行后是怎么講response轉換成我們想要的數據的。excute()執行后中間有點失敗取消的邏輯，最后就是直接把成功后的response交給
parseResponse()這個方法，這里先轉化為一個沒有body數據的response來做狀態判斷，如果需要轉換數據，把原來的ResponseBody轉換為一個靜態代理的ExceptionCatchingRequestBody
交給serviceMethod.toResponse(catchingBody)，主要是為了做一些異常處理。順著這個流程我們進ServiceMethod來看看toResponse（）這個方法。

/** Builds a method return value from an HTTP response body. */
 public ServiceMethod build() {
   ...
    responseConverter = createResponseConverter();
    ...
 }

  R toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
  }

 

private Converter<ResponseBody, T> createResponseConverter() {
      Annotation[] annotations = method.getAnnotations();
      try {
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }

很簡單就是交給了Converter來做轉換。Converter看起來是不是很眼熟。前面我們好像設置了啊。最后又回到了Retrofit這個類，來看看
responseBodyConverter（）這個方法：

  public <T> Converter<T, RequestBody> requestBodyConverter(Type type,
      Annotation[] parameterAnnotations, Annotation[] methodAnnotations) {
    return nextRequestBodyConverter(null, type, parameterAnnotations, methodAnnotations);
  }

  public <T> Converter<T, RequestBody> nextRequestBodyConverter(Converter.Factory skipPast,
      Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations) {
    checkNotNull(type, "type == null");
    checkNotNull(parameterAnnotations, "parameterAnnotations == null");
    checkNotNull(methodAnnotations, "methodAnnotations == null");

    int start = converterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = converterFactories.size(); i < count; i++) {
      Converter.Factory factory = converterFactories.get(i);
      Converter<?, RequestBody> converter =
          factory.requestBodyConverter(type, parameterAnnotations, methodAnnotations, this);
      if (converter != null) {
        //noinspection unchecked
        return (Converter<T, RequestBody>) converter;
      }
    }

   ...build string
    throw new IllegalArgumentException(builder.toString());
  }

其實很簡單，就是返回factory.requestBodyConverter(type, parameterAnnotations, methodAnnotations, this);，就是工廠造一個Converter
這個工廠造的Converter怎么造，框架是不管的，總之你按照我給你定義的標準造一個來就是了。感興趣就去看看'retrofit-converters'這個包里是怎么造的，也很簡單
然后通過Converter的convert()方法就把你想要的類型數據返回給你了，這個convert()方法也是你在實現Converter要自己實現的，當然源碼里提供了一些實現，你自己去看。

整個流程就是這樣的。希望對你閱讀源代碼有幫助。