以下內(nèi)容是以kotlin協(xié)程作為retrofit返回掛起函數(shù)解析排拷，其實都一樣，rxjava或者livedata锅尘，因為現(xiàn)在這兩個在協(xié)程面前都是小弟监氢，所以就不理他們了。
第一步：要分析咱們就透徹點鉴象，很顯然我們第一步是寫接口。
interface IMApi {
/**
* 獲取token
*/
@POST("/{org_name}/{app_name}/token")
suspend fun requestToken(@Path("org_name") org_name: String,
@Path("app_name") app_name: String,
@Body body: Map<String, String>): BaseBean<TokenBean>
}
第二步：創(chuàng)建并獲取IMApi接口的實現(xiàn)何鸡；
object RetrofitManager {
fun imApiImpl() = Retrofit.Builder()
.baseUrl("http://a1.easemob.com/")
.addCallAdapterFactory(BaseAdapterFactory(MainThreadExecutor()))
.addConverterFactory(BaseConverterFactory.create())
.client(initClient())
.build().create(IMApi::class.java)
/*
OKHttp創(chuàng)建
*/
private fun initClient(): OkHttpClient {
return OkHttpClient.Builder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.build()
}
internal class MainThreadExecutor : Executor {
private val handler = Handler(Looper.getMainLooper())
override fun execute(r: Runnable) {
handler.post(r)
}
}
}
第三步：發(fā)起請求纺弊；
RetrofitManager.imApiImpl().requestToken(org_name,app_name,body)
接下來正式解析：
- 盡然要解析，首先我們就要知道內(nèi)部是怎么獲取到實例骡男，并且觸發(fā)我們請求的方法的淆游。所以我們從create()方法開始看：可以看到以動態(tài)代理的凡是攔截解析方法，最終調(diào)用以下關(guān)鍵方法：
ServiceMethod<?> loadServiceMethod(Method method) {
//方法重點
result = ServiceMethod.parseAnnotations(this, method)隔盛；
return result;
}
//以上方法最終觸發(fā)以下方法：
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
//對于我們這個分析犹菱，此處isKotlinSuspendFunction應該是true（因為我們請求方法是supend修飾的。具體什么時候確定這個值的啦吮炕？下面會單獨分析）
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
boolean continuationWantsResponse = false;
boolean continuationBodyNullable = false;
Annotation[] annotations = method.getAnnotations();
//獲取到Type類型腊脱，這個類型就是我們IMApi接口的方法返回類型。
//（但是注意使用協(xié)程的時候龙亲，獲取的到時Call<接口返回類型>陕凹，是Call包裹過的悍抑，下面的特殊處理可以看出來）
Type adapterType;
if (isKotlinSuspendFunction) {
Type[] parameterTypes = method.getGenericParameterTypes();
Type responseType = Utils.getParameterLowerBound(0,
(ParameterizedType) parameterTypes[parameterTypes.length - 1]);
if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {
// Unwrap the actual body type from Response<T>.
responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
continuationWantsResponse = true;
}
adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
} else {
adapterType = method.getGenericReturnType();
}
//獲取CallAdapter對象，此處獲取的就是我們創(chuàng)建retrofit的時候add進去的BaseAdapterFactory（注意杜耙，深入方法會發(fā)現(xiàn)搜骡，我們只會獲取list的第一個CallAdapter處理我們請求數(shù)據(jù)）
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
Type responseType = callAdapter.responseType();
//同理獲取Converter對象，此處獲取的就是我們創(chuàng)建retrofit的時候add進去的BaseConverterFactory（注意佑女，深入方法會發(fā)現(xiàn)记靡，我們只會獲取list的第一個
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
//獲取我們添加的okhttp實例對象的Factory
okhttp3.Call.Factory callFactory = retrofit.callFactory;
//判斷是否是kotlin協(xié)程方式，并且返回相應的對象团驱。
if (!isKotlinSuspendFunction) {
return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
} else if (continuationWantsResponse) {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
return (HttpServiceMethod<ResponseT, ReturnT>) new SuspendForResponse<>(requestFactory,
callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
return (HttpServiceMethod<ResponseT, ReturnT>) new SuspendForBody<>(requestFactory,
callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable);
}
}
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;分析：
一直跟下去我們會發(fā)現(xiàn)他是在RequestFactory-->parseParameter()摸吠，然而觸發(fā)這個方法的地方就是在我們上面見到的ServiceMethod-->parseAnnotations()，所以我們可以得到結(jié)論：當動態(tài)代理獲取解析方法和方法參數(shù)的時候就已經(jīng)確定了這個值店茶。
continuationWantsResponse = false解析：
根據(jù)此方法里面的判斷getRawType()是獲取我們接口里面方法的返回類型最外層蜕便，很明顯不滿足條件所以為false。
綜合上面分析贩幻，我們處理請求解析應該通過SuspendForBody()對象里面處理轿腺。根據(jù)上面分析我們已經(jīng)知道最終處理我們返回結(jié)果數(shù)據(jù)是在SuspendForBody類里面做的處理，那現(xiàn)在關(guān)心的是怎么觸發(fā)我們自定義的adapter和conver的啦丛楚？
- 首選看我們自定義的adapter：
進入SuspendForBody類族壳，我們能找到以下函數(shù),會發(fā)現(xiàn)這個函數(shù)是否和我們自定義里面的adapter里面函數(shù)相識的樣子，而且這個類是把我們自定義的adapter帶進來趣些，還進行了觸發(fā)仿荆，最終通過攜程返回一個掛起函數(shù)，這里正好和我們定義接口里面的函數(shù)是掛起函數(shù)相呼應坏平。這個時候我們就能理解為什么我們寫接口里面函數(shù)的時候要寫掛起函數(shù)了吧拢操。
@Override protected Object adapt(Call<ResponseT> call, Object[] args) {
call = callAdapter.adapt(call);
//noinspection unchecked Checked by reflection inside RequestFactory.
Continuation<ResponseT> continuation = (Continuation<ResponseT>) args[args.length - 1];
try {
return isNullable
? KotlinExtensions.awaitNullable(call, continuation)
: KotlinExtensions.await(call, continuation);
} catch (Exception e) {
return KotlinExtensions.suspendAndThrow(e, continuation);
}
}
}
接下來我們看Conver在哪里觸發(fā)，我們發(fā)現(xiàn)上面類是傳入了我們的conver的舶替，但是里面卻沒有使用它令境，而且傳給了父類，所以我們找找父類顾瞪，發(fā)現(xiàn)在invoke方法里面把我們的conver傳遞給了OKHttpCall舔庶，然而這個invoke又是在我們動態(tài)代理加載函數(shù)的時候觸發(fā)的,所以大致推測，肯定是在這個類里面觸發(fā)我們conver()方法的 陈醒，接著我們跟進去惕橙，找到了以下函數(shù)：
我們能很清晰的看到，如果接口情況成功code滿足添加的話就會觸發(fā)我們的conver钉跷，這個時候我們就知道我們自定義解析返回值觸發(fā)是在okhttpcall里面解析返回值的時候了弥鹦，從這里我們還能看出，如果請求結(jié)果（code < 200 || code >= 300 || code == 204 || code == 205）都不會觸發(fā)我們的自定義conver爷辙。
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
// Remove the body's source (the only stateful object) so we can pass the response along.
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);
}
ExceptionCatchingResponseBody catchingBody = new ExceptionCatchingResponseBody(rawBody);
try {
T body = responseConverter.convert(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;
}
}
總結(jié)：所以根據(jù)上面分析惶凝，我們大致羅列一下整個流程：（流程圖太麻煩吼虎，就不畫了）
create-->loadServiceMethod--> ServiceMethod.parseAnnotations--> ServiceMethod.parseAnnotations[整個函數(shù)做了幾件事：createCallAdapter，createResponseConverter苍鲜， new SuspendForBody<>(requestFactory,
callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable);]-->SuspendForBody-->adapt-->invoke-->OkHttpCall-->parseResponse.
整個觸發(fā)流程大致如此思灰，到這里我們retrofit解析respose就結(jié)束了。
