簡介
Retrofit 是 Square 推出的 HTTP 框架，主要用於 Android 和 Java。Retrofit 將網路請求變成方法的呼叫，使用起來非常簡潔方便。本文先簡要介紹一下 Retrofit 的用法，然後具體分析其原始碼執行的流程。
基本用法
Retrofit 把HTTP API 變成 Java 的介面。下面是 Retrofit 官網的一個例子：
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 用註解的方式來描述一個網路請求相關的引數。
上面才是開始，下面要發出這個網路請求：
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 中有如下的幾個關鍵變數：
//用於快取解析出來的方法
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。
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 方法，這個很重要，因為用了動態代理模式。關於動態代理模式，可以參考這篇文章：www.codekk.com/blogs/detai… 根據傳進來的 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
execute() throws IOException; //同步執行請求 - void enqueue(Callback
callback); //非同步執行請求，callback 用於回撥 - boolean isExecuted(); //是否執行過
- void cancel(); //取消請求
- boolean isCanceled(); //是否取消了
- Call
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 響應的方法，一次網路請求便完成了。
總結
Retrofit 整個框架的程式碼不算太多，還是比較易讀的。主要就是通過動態代理的方式把 Java 介面中的解析為響應的網路請求，然後交給 OkHttp 去執行。並且可以適配不同的 CallAdapter，可以方便地與 RxJava 結合使用。