Retrofit 源碼解析

時間 2019-11-11

標籤 retrofit 源碼解析简体版

原文原文鏈接

簡介

Retrofit 是 Square 推出的 HTTP 框架，主要用於 Android 和 Java。Retrofit 將網絡請求變成方法的調用，使用起來很是簡潔方便。本文先簡要介紹一下 Retrofit 的用法，而後具體分析其源碼執行的流程。git

基本用法

Retrofit 把HTTP API 變成 Java 的接口。下面是 Retrofit 官網的一個例子：github

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

在 GithubService 接口中有一個方法 listRepos，這個方法用了 @GET 的方式註解，這代表這是一個 GET 請求。在後面的括號中的 users/{user}/repos 是請求的路徑，其中的 {user} 表示的是這一部分是動態變化的，它的值由方法的參數傳遞過來，而這個方法的參數@Path("user") String user 便是用於替換 {user} 。另外注意這個方法的返回值是 Call<List<Repo>>。能夠看出 Retrofit 用註解的方式來描述一個網絡請求相關的參數。api

上面纔是開始，下面要發出這個網絡請求：緩存

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

GitHubService service = retrofit.create(GitHubService.class);
Call<List<Repo>> repos = service.listRepos("octocat");
repos.enqueue(new Callback<List<Repo>>() {
    @Override
    public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
            
    }
    @Override
    public void onFailure(Call<List<Repo>> call, Throwable t) {

    }
 });

能夠看出，先是構建了一個 Retrofit 對象，其中傳入了 baseUrl 參數，baseUrl 和上面的 GET 方法後面的路徑組合起來纔是一個完整的 url。除了 baseUrl，還有一個 converterFactory，它是用於把返回的 http response 轉換成 Java 對象，對應方法的返回值 Call<List<Repo>> 中的 List<Repo>>，其中 Repo 是自定義的類。有了Retrofit 對象，接着調用它的 create 方法建立了 GitHubService 的實例，而後就能夠調用這個實例的方法來請求網絡了。調用 listRepo 方法獲得一個 Call對象，而後可使用 enqueue 或者 execute 來執行發起請求，enqueue 是異步執行，而 execute 是同步執行。網絡

Retrofit 的基本用法就是這樣，其它還有一些細節能夠查看官網。框架

源碼分析

我第一次接觸 Retrofit 的時候以爲這個東西挺神奇的，用法跟通常的網絡請求不同。下面就來看看 Retrofit 的源碼是怎麼實現的。異步

Retrofit 的建立

從 Retrofit 的建立方法能夠看出，使用的是 Builder 模式。Retrofit 中有以下的幾個關鍵變量：ide

//用於緩存解析出來的方法
  private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();
  
  //請求網絡的OKHttp的工廠，默認是 OkHttpClient
  private final okhttp3.Call.Factory callFactory;
  
  //baseurl
  private final HttpUrl baseUrl;
  
  //請求網絡獲得的response的轉換器的集合 默認會加入 BuiltInConverters     
  private final List<Converter.Factory> converterFactories;
  
  //把Call對象轉換成其它類型
  private final List<CallAdapter.Factory> adapterFactories;
  
  //用於執行回調 Android中默認是 MainThreadExecutor
  private final Executor callbackExecutor;
  
  //是否須要當即解析接口中的方法
  private final boolean validateEagerly;

再看一下Retrofit 中的內部類 Builder 的 build 方法：源碼分析

public Retrofit build() {
  if (baseUrl == null) {
    throw new IllegalStateException("Base URL required.");
  }

  okhttp3.Call.Factory callFactory = this.callFactory;
  if (callFactory == null) {
    //默認建立一個 OkHttpClient
    callFactory = new OkHttpClient();
  }

  Executor callbackExecutor = this.callbackExecutor;
  if (callbackExecutor == null) {
     //Android 中返回的是 MainThreadExecutor
    callbackExecutor = platform.defaultCallbackExecutor();
  }

  // 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));

  // Make a defensive copy of the converters.
  List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);

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

在建立 Retrofit 的時候，若是沒有指定 OkHttpClient，會建立一個默認的。若是沒有指定 callbackExecutor，會返回平臺默認的，在 Android 中是 MainThreadExecutor，並利用這個構建一個 CallAdapter加入 adapterFactories。ui

create 方法

有了 Retrofit 對象後，即可以經過 create 方法建立網絡請求接口類的實例，代碼以下：

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, Object... args)
          throws Throwable {
        // If the method is a method from Object then defer to normal invocation.若是是Object中的方法，直接調用
        if (method.getDeclaringClass() == Object.class) {
          return method.invoke(this, args);
        }
        //爲了兼容 Java8 平臺，Android 中不會執行
        if (platform.isDefaultMethod(method)) {
          return platform.invokeDefaultMethod(method, service, proxy, args);
        }
        //下面是重點，解析方法
        ServiceMethod serviceMethod = loadServiceMethod(method);
        OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
        return serviceMethod.callAdapter.adapt(okHttpCall);
      }
});

create 方法接受一個 Class 對象，也就是咱們編寫的接口，裏面含有經過註解標識的請求網絡的方法。注意 return 語句部分，這裏調用了 Proxy.newProxyInstance 方法，這個很重要，由於用了動態代理模式。關於動態代理模式，能夠參考這篇文章：http://www.codekk.com/blogs/d...。簡單的描述就是，Proxy.newProxyInstance 根據傳進來的 Class 對象生成了一個實例 A，也就是代理類。每當這個代理類 A 執行某個方法時，老是會調用 InvocationHandler(Proxy.newProxyInstance 中的第三個參數) 的 invoke 方法，在這個方法中能夠執行一些操做(這裏是解析方法的註解參數等)，經過這個方法真正的執行咱們編寫的接口中的網絡請求。

方法解析和類型轉換

下面具體看一下在 invoke 中解析網絡請求方法的幾行。首先是 ServiceMethod serviceMethod = loadServiceMethod(method);，其中 loadServiceMethod 代碼以下：

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

能夠看出，這裏是先到緩存中找，緩存中沒有再去建立。這裏建立了 ServiceMethod 對象。ServiceMethod 用於把接口方法的調用轉換成一個 HTTP 請求。其實，在 ServiceMethod 中會解析接口中方法的註解、參數等，它還有個 toRequest 方法，用於生成一個 Request 對象。這個 Request 對象就是 OkHttp 中的 Request，表明了一條網絡請求(Retrofit 實際上把真正請求網絡的操做交給了 OkHttp 執行)。下面是建立 ServiceMethod 的部分代碼：

public ServiceMethod build() {
  //獲取 callAdapter
  callAdapter = createCallAdapter();
  responseType = callAdapter.responseType();
  if (responseType == Response.class || responseType == okhttp3.Response.class) {
    throw methodError("'"
        + Utils.getRawType(responseType).getName()
        + "' is not a valid response body type. Did you mean ResponseBody?");
  }
  //獲取 responseConverter 
  responseConverter = createResponseConverter();

  for (Annotation annotation : methodAnnotations) {
    //解析註解
    parseMethodAnnotation(annotation);
    //省略了一些代碼
    ...
  }
}

在獲得 ServiceMethod 對象後，把它連同方法調用的相關參數傳給了 OkHttpCall 對象，也就是這行代碼： OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);。下面介紹 OkHttpCall，OkHttpCall繼承於 Call 接口。Call 是Retrofit 的基礎接口，表明發送網絡請求與響應調用，它包含下面幾個接口方法：

Response<T> execute() throws IOException; //同步執行請求
void enqueue(Callback<T> callback); //異步執行請求，callback 用於回調
boolean isExecuted(); //是否執行過
void cancel(); //取消請求
boolean isCanceled(); //是否取消了
Call<T> clone(); //克隆一條請求
Request request(); //獲取原始的request

OkHttpCall 是 Call 的一個實現類，它裏面封裝了 OkHttp 中的原生 Call，在這個類裏面實現了 execute 以及 enqueue 等方法，實際上是調用了 OkHttp 中原生 Call 的對應方法。

接下來把 OkHttpCall 傳給 serviceMethod.callAdapter 對象，這裏的callAdapter又是什麼？在上面建立 ServiceMethod 的代碼中有一行代碼： callAdapter = createCallAdapter()，這裏建立了 calladapter，在這個代碼內部是根據方法的返回類型以及註解去尋找對應的 CallAdapter，去哪裏尋找？去 Retrofit 對象的 adapterFactories 集合中找。當咱們建立 Retrofit 的時候，能夠調用 addCallAdapter 向 adapterFactories 中添加 CallAdapter。在前面的基本用法裏面，咱們並無添加任何 CallAdapter，但 adapterFactories 中默認會添加一個 ExecutorCallAdapterFactory，調用其 get 方法即可得到 CallAdapter 對象。

那麼 CallAdapter 是幹嗎的呢？上面調用了adapt 方法，它是爲了把一個 Call 轉換成另外一種類型，好比當 Retrofit 和 RxJava 結合使用的時候，接口中方法能夠返回 Observable<T>，這裏至關於適配器模式。默認狀況下獲得的是一個 Call 對象，它是ExecutorCallbackCall，代碼以下：

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

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

}
這個 ExecutorCallbackCall 接受一個 callbackExecutor(Android 中默認爲 MainThreadExecutor，把返回的數據傳回主線程) 和一個 call，也就是 OkhttpCall。看下 ExecutorCallbackCall 部分代碼：

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

在 enqueue 方法中，調用了 OkHttpCall 的 enqueue，因此這裏至關於靜態的代理模式。OkHttpCall 中的 enqueue 其實又調用了原生的 OkHttp 中的 enqueue，這裏才真正發出了網絡請求，部分代碼以下：

@Override public void enqueue(final Callback<T> callback) {
    if (callback == null) throw new NullPointerException("callback == null");
    //真正請求網絡的 call
    okhttp3.Call call;
    Throwable failure;

    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;
      //省略了部分發代碼
      ...
      call = rawCall;
      //enqueue 異步執行
    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response<T> response;
        try {
        //解析數據 會用到 conveterFactory，把 response 轉換爲對應 Java 類型
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

  private void callFailure(Throwable e) {
    try {
      callback.onFailure(OkHttpCall.this, e);
    } catch (Throwable t) {
      t.printStackTrace();
    }
  }

  private void callSuccess(Response<T> response) {
    try {
      callback.onResponse(OkHttpCall.this, response);
    } catch (Throwable t) {
      t.printStackTrace();
    }
  }
 });
}

OkHttp 獲取數據後，解析數據並回調 callback 響應的方法，一次網絡請求便完成了。