日韩在线资源,国产一区二区三区在线,91欧美激情一区二区三区成人

Android源碼進階之深入理解Retrofit工作原理

前言

Retrofit是一個基于AOP思想，對RestfulApi注解進行動態代理的網絡框架;

今天我們就來探討下實現原理，一起進步

一、使用Retrofit

1、包引用

在gradle文件中引用retrofit

compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'com.squareup.retrofit2:retrofit-converters:2.3.0'
compile 'com.squareup.retrofit2:retrofit-adapters:2.3.0'

如果需要使用更多擴展功能，比如gson轉換，rxjava適配等，可以視自己需要繼續添加引用;

compile 'com.squareup.retrofit2:converter-gson:2.3.0'
compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'

如果現有的擴展包不能滿足需要，還可以自己擴展converter，adapter等;

2、定義接口

Retrofit要求定義一個網絡請求的接口，接口函數里要定義url路徑、請求參數、返回類型;

public interface INetApiService {
@GET("/demobiz/api.php")
Call<BizEntity> getBizInfo(@Query("id") String id);
}

在這個接口定義中，用注解@GET("/demobiz/api.php")聲明了url路徑，用注解@Query("id") 聲明了請求參數;

最重要的是，用Call聲明了返回值是一個Retrofit的Call對象，并且聲明了這個對象處理的數據類型為BizEntity，BizEntity是我們自定義的數據模型;

3、依次獲得Retrofit對象、接口實例對象、網絡工作對象

首先，需要新建一個retrofit對象;

然后，根據上一步的接口，實現一個retrofit加工過的接口對象;

最后，調用接口函數，得到一個可以執行網絡訪問的網絡工作對象;

//新建一個Retrofit對象
Retrofit retrofit=new Retrofit.Builder()
.baseUrl(Config.DOMAIN)//要訪問的網絡地址域名，如http://www.zhihu.com
.addConverterFactory(GsonConverterFactory.create())
.build();
...
//用retrofit加工出對應的接口實例對象
INetApiService netApiService= retrofit.create(INetApiService.class);
//可以繼續加工出其他接口實例對象
IOtherService otherService= retrofit.create(IOtherService.class);
···
//調用接口函數，獲得網絡工作對象
Call<BizEntity> callWorker= netApiService.getBizInfo("id001");

這個復雜的過程下來，最終得到的callWorker對象，才可以執行網絡訪問。

4、訪問網絡數據

用上一步獲取的worker對象，執行網絡請求

callWorker.enqueue(new Callback<BizEntity>() {
@Override
public void onResponse(Call<BizEntity> call, Response<BizEntity> response) {...}
@Override
public void onFailure(Call<BizEntity> call, Throwable t) {...}
});

在回調函數里，取得我們需要的BizEntity數據對象

二、Retrofit實現原理

Android源碼進階之深入理解Retrofit工作原理

1、Retrofit對象的構建就是簡單的builder模式，直接看create

//Retrofit.java
public <T> T create(final Class<T> service) {
//驗證
validateServiceInterface(service);
return (T)
//動態代理
Proxy.newProxyInstance(
service.getClassLoader(), //類加載器
new Class<?>[] {service}, //一組接口
new InvocationHandler() {
//判斷android和jvm平臺及其版本
private final Platform platform = Platform.get();
@Override
public Object invoke(Object proxy, Method method, Object[] args){
//如果該方法是Object的方法，直接執行不用管
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
//isDefaultMethod：檢查是否是java8開始支持的接口默認方法
return platform.isDefaultMethod(method)
? platform.invokeDefaultMethod(method, service, proxy, args)
: loadServiceMethod(method).invoke(args); //我們關注這里
}
});
}

Proxy.newProxyInstance動態代理，運行期會生成一個類(字節碼)如$ProxyN，實現傳入的接口即WanApi，重寫接口方法然后轉發給InvocationHandler的invoke

class $ProxyN extends Proxy implements WanApi{
Call<WanArticleBean> articleList(@Path("page") int page){
//轉發給invocationHandler
invocationHandler.invoke(this,method,args);
}
}

2、validateServiceInterface驗證邏輯

//Retrofit.java
private void validateServiceInterface(Class<?> service) {
//檢查：WanApi不是接口就拋異常...
//檢查：WanApi不能有泛型參數，不能實現其他接口...
if (validateEagerly) { //是否進行嚴格檢查，默認關閉
Platform platform = Platform.get();
for (Method method : service.getDeclaredMethods()) { //遍歷WanApi方法
//不是默認方法，并且不是靜態方法
if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
//把方法提前加載進來（檢查下有沒有問題）
loadServiceMethod(method);
}
}
}
}

如果開了validateEagerly，會一次性把接口WanApi的所有方法都檢查一遍并加載進來，可以在debug模式下開啟，提前發現錯誤寫法，比如在@GET請求設置了@Body這種錯誤就會拋出異常：

java.lang.IllegalArgumentException: Non-body HTTP method cannot contain @Body.

3、loadServiceMethod

然后是loadServiceMethod(method).invoke(args)，看名字可知是先找方法，然后執行

//Retrofit.java
//緩存，用了線程安全ConcurrentHashMap
final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap<>();
ServiceMethod<?> loadServiceMethod(Method method) {
ServiceMethod<?> result = serviceMethodCache.get(method);
//WanApi的articleList方法已緩存，直接返回
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
//解析articleList的注解，創建ServiceMethod并緩存起來
result = ServiceMethod.parseAnnotations(this, method);
serviceMethodCache.put(method, result);
}
}
return result;
}

跟進ServiceMethod.parseAnnotations

//ServiceMethod.java
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//1.
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
//檢查：articleList方法返回類型不能用通配符和void...
//2.
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}

4、 RequestFactory.parseAnnotations

//RequestFactory.java
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
return new Builder(retrofit, method).build();
}
class Builder {
RequestFactory build() {
//解析方法注解如GET
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
//省略各種檢查...
//解析參數注解如Path
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
parameterHandlers[p] =
parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
}
//省略各種檢查...
return new RequestFactory(this);
}
}

得到RequestFactory后， HttpServiceMethod.parseAnnotations，HttpServiceMethod負責適配和轉換處理，將接口方法的調用調整為HTTP調用

//HttpServiceMethod.java
//ResponseT響應類型如WanArticleBean，ReturnT返回類型如Call
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
//省略kotlin協程邏輯...
Annotation[] annotations = method.getAnnotations();
//遍歷找到合適的適配器
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
//得到響應類型，如WanArticleBean
Type responseType = callAdapter.responseType();
//遍歷找到合適的轉換器
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
}

5、最終返回了一個CallAdapted，看到CallAdapted

//CallAdapted extends HttpServiceMethod extends ServiceMethod
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.Builder

//Retrofit.Builder.java
public Retrofit build() {
Executor callbackExecutor = this.callbackExecutor;
//如果沒設置線程池，則給android平臺設置一個默認的MainThreadExecutor（用Handler將回調切回主線程）
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
//添加默認的DefaultCallAdapterFactory
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
}

DefaultCallAdapterFactory這個工廠創建具體的CallAdapter實例

//DefaultCallAdapterFactory.java
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);
//如果指定了SkipCallbackExecutor注解，就表示不需要切回主線程
final Executor executor =
Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
? null
: callbackExecutor;
return new CallAdapter<Object, Call<?>>() {
@Override
public Type responseType() {
return responseType;
}
@Override
public Call<Object> adapt(Call<Object> call) {
//默認情況下，返回用主線程池包裝的Call，他的enqueue會使用主線程池的execute
return executor == null ? call : new ExecutorCallbackCall<>(executor, call);
}
};
}

6、invoke

前邊loadServiceMethod得到了CallAdapted，然后執行invoke，實現在父類HttpServiceMethod里，

//HttpServiceMethod.java
final ReturnT invoke(Object[] args) {
//終于見到okhttp了！
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
return adapt(call, args);
}
class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
private final CallAdapter<ResponseT, ReturnT> callAdapter;
@Override
protected ReturnT adapt(Call<ResponseT> call, Object[] args) {
//用前邊得到的適配器，把OkHttpCall包成ExecutorCallbackCall
return callAdapter.adapt(call);
}
}