之前我們分析過了Okhttp這個(gè)優(yōu)秀的網(wǎng)絡(luò)請(qǐng)求庫(kù)，但是在實(shí)際的使用時(shí)，還是會(huì)覺得有很多的不方便，你會(huì)發(fā)現(xiàn)它跟HttpUrlConnection感凤，或者HttpClient一樣，是一個(gè)比較底層的網(wǎng)絡(luò)請(qǐng)求庫(kù)粒督，處理的是底層的網(wǎng)絡(luò)請(qǐng)求和響應(yīng)的問題陪竿。而我們?cè)跇I(yè)務(wù)中要處理上層的邏輯，比如響應(yīng)內(nèi)容解析屠橄，方便的API實(shí)現(xiàn)等族跛，這都需要我們對(duì)它進(jìn)行重新封裝，以適合我們特定的業(yè)務(wù)邏輯锐墙。那有沒有比較簡(jiǎn)潔礁哄，方便，優(yōu)雅的封裝方式來封裝Okhttp的使用呢贮匕，Square早以為我們考慮了這個(gè)問題姐仅，于是配套Okhttp花枫，推出了Retrofit作為上層的網(wǎng)絡(luò)請(qǐng)求庫(kù)刻盐。Retrofit是Okhttp高效化封裝之后的產(chǎn)物掏膏，雖然它之前也是可以定義使用其他底層網(wǎng)絡(luò)庫(kù)的（在Retrofit2之后去除了這個(gè)擴(kuò)展）。在后面漸漸形成了Retrofit+Okhttp+RxJava網(wǎng)絡(luò)請(qǐng)求三劍客的趨勢(shì)敦锌。
Retrofit優(yōu)點(diǎn)
那么Retrofit的優(yōu)點(diǎn)是什么馒疹？（哈哈，沒有優(yōu)點(diǎn)乙墙，我憑什么使用它）
- 有容乃大颖变，可擴(kuò)展性強(qiáng)，底層網(wǎng)絡(luò)請(qǐng)求集成了Okhttp听想，異步處理可集成RxJava腥刹，內(nèi)容解析可集成Gson，Jackson等汉买。
- 全面支持Restful請(qǐng)求衔峰，并且通過注解的方式，支持鏈?zhǔn)秸{(diào)用蛙粘，使用簡(jiǎn)潔方便垫卤。
- 精妙的源碼設(shè)計(jì)模式，內(nèi)部層次分工明確出牧，解耦性強(qiáng)穴肘。
一句話概括就是它以優(yōu)秀的設(shè)計(jì)思想讓我們能以輕松簡(jiǎn)潔的方式進(jìn)行網(wǎng)絡(luò)數(shù)據(jù)的請(qǐng)求。
Retrofit使用方式
接下來我們用一個(gè)簡(jiǎn)單的例子來看看它是如何處理的舔痕。
1.定義Bean類评抚，代表請(qǐng)求數(shù)據(jù)的類型。
public class ZhihuDaily{
@SerializedName("date")
private String date;
@SerializedName("top_stories")
private ArrayList<ZhihuDailyItem> mZhihuDailyItems;
@SerializedName("stories")
private ArrayList<ZhihuDailyItem> stories;
//get,set方法省略
...
}
public class ZhihuDailyItem{
@SerializedName("images")
private String[] images;
@SerializedName("type")
private int type;
@SerializedName("id")
private String id;
@SerializedName("title")
private String title;
private String date;
//get,set方法省略
...
}
2.定義一個(gè)API請(qǐng)求接口赵讯，里面包括要訪問的Restful api請(qǐng)求盈咳。
public interface RequestApi {
@GET("/api/4/news/latest")
Observable<ZhihuDaily> getLastDaily();
@GET("/api/4/news/before/{date}")
Observable<ZhihuDaily> getTheDaily(@Path("date") String date);
@GET("/api/4/news/{id}")
Call<ZhihuStory> getStory(@Path("id") String id);
@GET("http://lab.zuimeia.com/wallpaper/category/1/?page_size=1")
Observable<ImageResponse> getImage();
}
就是先定義一個(gè)接口，然后將開發(fā)文檔中的一個(gè)REST API對(duì)應(yīng)的寫一個(gè)方法边翼，在方法上加上注解鱼响，在方法參數(shù)上加上注解，返回值返回Call或者Observable组底，泛型類型為該數(shù)據(jù)解析之后的bean類型丈积。這樣一個(gè)請(qǐng)求接口就完成了。
3.獲取Retrofit客戶端對(duì)象债鸡。
//創(chuàng)建OkHttpClient對(duì)象江滨，并對(duì)其進(jìn)行配置
OkHttpClient client = new OkHttpClient.Builder()
.addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
.addInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
.cache(cache)
.build();
//創(chuàng)建Retrofit對(duì)象，并對(duì)其進(jìn)行配置
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.client(client)
.addConverterFactory(GsonConverterFactory.create())
.build().create(ZhihuApi.class);
創(chuàng)建一個(gè)Retrofit對(duì)象厌均，對(duì)其進(jìn)行初始化配置唬滑，這里可以對(duì)OkHttpClient對(duì)象進(jìn)行配置，比如添加日志攔截，緩存設(shè)置晶密，超時(shí)設(shè)置等擒悬，對(duì)Retrofit對(duì)象可以對(duì)CallAdapterFactory調(diào)用適配器和ConverterFactory響應(yīng)數(shù)據(jù)解析器進(jìn)行配置。
4.創(chuàng)建請(qǐng)求接口對(duì)象稻艰，調(diào)用響應(yīng)的API方法懂牧。
RequestApi apiService = retrofit.create(RequestApi.class);
apiService.getLastDaily()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Joke>() {
@Override public void call(Joke joke) {
callBack.onSuccess(joke);
}
}, new Action1<Throwable>() {
@Override public void call(Throwable throwable) {
callBack.onFailure(throwable);
}
});
這是配合RxJava的使用方式，調(diào)用了getLastDaily方法請(qǐng)求數(shù)據(jù)尊勿，指定了請(qǐng)求在其他線程執(zhí)行僧凤，響應(yīng)回到主線程，成功響應(yīng)到callBack.onSuccess(joke); 網(wǎng)絡(luò)請(qǐng)求錯(cuò)誤到callBack.onFailure(throwable);
在層次上來看元扔，其實(shí)就是獲取一個(gè)配置好的Retrofit客戶端躯保，然后根據(jù)配置好的RequestApi接口創(chuàng)建RequestApi對(duì)象，調(diào)用其中的某個(gè)API方法澎语，然后采用RxJava的方式就可以完成一次網(wǎng)絡(luò)數(shù)據(jù)的請(qǐng)求和解析處理了吻氧。我們?cè)賹?duì)其進(jìn)行適合封裝，會(huì)發(fā)現(xiàn)使用起來超級(jí)方便咏连。
Retrofit整體架構(gòu)
那么Retrofit內(nèi)部是如何實(shí)現(xiàn)的盯孙，整體流程是怎么樣的呢？在這里引用一張圖讓大家有Retrofit結(jié)構(gòu)一個(gè)大體的了解祟滴。
Retrofit類分析
Retrofit使用建造者模式來創(chuàng)建對(duì)象振惰，這樣可以方便在創(chuàng)建Retrofit之前就對(duì)其進(jìn)行一次性相應(yīng)的配置。既然是采用建造者模式垄懂，里面必定是涉及一系列屬性的設(shè)置骑晶，我們直接看看它的屬性和內(nèi)部Build構(gòu)造方法。
public final class Retrofit {
//用于記錄請(qǐng)求RequestApi中某個(gè)請(qǐng)求方法對(duì)應(yīng)的處理方式
private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();
//okhttp的請(qǐng)求調(diào)用Factory
private final okhttp3.Call.Factory callFactory;
//封裝的基礎(chǔ)請(qǐng)求url草慧，具體的請(qǐng)求就是將參數(shù)附加在其上得到具體的api地址
private final HttpUrl baseUrl;
//響應(yīng)數(shù)據(jù)解析器列表
private final List<Converter.Factory> converterFactories;
//請(qǐng)求調(diào)用轉(zhuǎn)換器列表
private final List<CallAdapter.Factory> adapterFactories;
//用于響應(yīng)后的回調(diào)執(zhí)行桶蛔，默認(rèn)是將響應(yīng)post到主線程處理
private final Executor callbackExecutor;
//是否需要立即生成請(qǐng)求方法對(duì)應(yīng)的處理對(duì)象，如果是漫谷，在create創(chuàng)建接口時(shí)就會(huì)生成一系列的ServiceMethod對(duì)象
private final boolean validateEagerly;
public static final class Builder {
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
//沒有指定OkHttpClient仔雷，則使用默認(rèn)創(chuàng)建的OkHttpClient對(duì)象，它是實(shí)際處理底層網(wǎng)絡(luò)請(qǐng)求的
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
//android平臺(tái)舔示，默認(rèn)callbackExecutor是ExecutorCallAdapterFactory碟婆，也就是將響應(yīng)post到主線程處理
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
//調(diào)用轉(zhuǎn)換器列表
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
//響應(yīng)數(shù)據(jù)解析器列表
List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
//生成Retrofit對(duì)象
return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
callbackExecutor, validateEagerly);
}
}
}
Retrofit創(chuàng)建接口對(duì)象
接下來我們分析Retrofit是如何根據(jù)定義的接口創(chuàng)建響應(yīng)的可執(zhí)行對(duì)象的。
public final class Retrofit {
public <T> T create(final Class<T> service) {
//驗(yàn)證是否接口惕稻，不是的話拋異常
Utils.validateServiceInterface(service);
//判斷是否需要提前加載service中所有的method對(duì)應(yīng)的ServiceMethod
if (validateEagerly) {
eagerlyValidateMethods(service);
}
//使用動(dòng)態(tài)代理的方式創(chuàng)建一個(gè)實(shí)現(xiàn)接口的對(duì)象
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
//獲取平臺(tái)竖共，這里是android平臺(tái)AndroidPlatform
private final Platform platform = Platform.get();
@Override public Object invoke(Object proxy, Method method, Object... args)
throws Throwable {
//默認(rèn)是接口，不執(zhí)行
// If the method is a method from Object then defer to normal invocation.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
//默認(rèn)AndroidPlatform返回false俺祠，不執(zhí)行
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
//最終執(zhí)行這里
//加載調(diào)用方法對(duì)應(yīng)的處理方式ServiceMethod
ServiceMethod serviceMethod = loadServiceMethod(method);
//創(chuàng)建一個(gè)原始的OkHttpCall公给，它內(nèi)部直接使用Okhttp進(jìn)行網(wǎng)絡(luò)請(qǐng)求操作
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
//這里將OkHttpCall封裝轉(zhuǎn)換成另一種類型的對(duì)象借帘，比如說Observable
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
//提前加載service中所有的method對(duì)應(yīng)的ServiceMethod
private void eagerlyValidateMethods(Class<?> service) {
Platform platform = Platform.get();
for (Method method : service.getDeclaredMethods()) {
if (!platform.isDefaultMethod(method)) {
loadServiceMethod(method);
}
}
}
//加載service中的method對(duì)應(yīng)的ServiceMethod
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;
}
}
可以看到，Retrofit是使用動(dòng)態(tài)代理的方式創(chuàng)建了一個(gè)實(shí)現(xiàn)service接口的對(duì)象淌铐，當(dāng)外部調(diào)用service接口方法姻蚓，會(huì)調(diào)用invoke方法，然后加載當(dāng)前方法對(duì)應(yīng)的處理方式ServiceMethod匣沼，和創(chuàng)建原始的OkHttpCall，用于內(nèi)部使用Okhttp去執(zhí)行真正的網(wǎng)絡(luò)請(qǐng)求捂龄，然后再將OkHttpCall對(duì)象封裝轉(zhuǎn)換成另一種類型的對(duì)象释涛。
ServiceMethod的創(chuàng)建
接下來我們分析ServiceMethod做了什么。它同樣使用了建造者模式進(jìn)行對(duì)象創(chuàng)建倦沧，主要用于解析對(duì)應(yīng)的接口方法唇撬。
final class ServiceMethod<T> {
static final class Builder<T> {
final Retrofit retrofit;
//對(duì)應(yīng)方法
final Method method;
//方法上的注解
final Annotation[] methodAnnotations;
//方法參數(shù)上的注解
final Annotation[][] parameterAnnotationsArray;
//方法參數(shù)類型
final Type[] parameterTypes;
//返回的響應(yīng)類型
Type responseType;
//判斷是否找到了對(duì)應(yīng)的注解
boolean gotField;
boolean gotPart;
boolean gotBody;
boolean gotPath;
boolean gotQuery;
boolean gotUrl;
//http請(qǐng)求方法，Get,Post等
String httpMethod;
//是否有請(qǐng)求體
boolean hasBody;
boolean isFormEncoded;
boolean isMultipart;
//方法上注解的相對(duì)地址url
String relativeUrl;
Headers headers;
MediaType contentType;
Set<String> relativeUrlParamNames;
//參數(shù)解析器展融，對(duì)諸如@GET("/api/4/news/{id}")進(jìn)行解析窖认，得到最終的url地址
ParameterHandler<?>[] parameterHandlers;
//響應(yīng)內(nèi)容轉(zhuǎn)換器，將ResponseBody轉(zhuǎn)換為其他類型
Converter<ResponseBody, T> responseConverter;
//請(qǐng)求調(diào)用轉(zhuǎn)換器
CallAdapter<?> callAdapter;
}
//構(gòu)建ServiceMethod對(duì)象
public ServiceMethod build() {
//創(chuàng)建CallAdapter
callAdapter = createCallAdapter();
//callAdapter的泛型類型告希，如某個(gè)Bean
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?");
}
//創(chuàng)建響應(yīng)數(shù)據(jù)轉(zhuǎn)換器
responseConverter = createResponseConverter();
//解析方法注解
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
if (httpMethod == null) {
throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
}
if (!hasBody) {
if (isMultipart) {
throw methodError(
"Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
}
if (isFormEncoded) {
throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
+ "request body (e.g., @POST).");
}
}
//解析參數(shù)注解
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
Type parameterType = parameterTypes[p];
if (Utils.hasUnresolvableType(parameterType)) {
throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
parameterType);
}
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
if (parameterAnnotations == null) {
throw parameterError(p, "No Retrofit annotation found.");
}
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
if (relativeUrl == null && !gotUrl) {
throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
}
if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
throw methodError("Non-body HTTP method cannot contain @Body.");
}
if (isFormEncoded && !gotField) {
throw methodError("Form-encoded method must contain at least one @Field.");
}
if (isMultipart && !gotPart) {
throw methodError("Multipart method must contain at least one @Part.");
}
//創(chuàng)建最終ServiceMethod對(duì)象
return new ServiceMethod<>(this);
}
}
可以看到創(chuàng)建一個(gè)ServiceMethod對(duì)象需要依次創(chuàng)建CallAdapter請(qǐng)求調(diào)用轉(zhuǎn)換器扑浸，創(chuàng)建ResponseConverter響應(yīng)數(shù)據(jù)轉(zhuǎn)換器，解析方法注解燕偶，方法參數(shù)注解喝噪，最后得到ServiceMethod對(duì)象。而CallAdapter和ResponseConverter的創(chuàng)建過程是通過查找Retrofit中的adapterFactories和converterFactories列表指么，根據(jù)方法的返回類型和參數(shù)類型查找是否有相應(yīng)的Factory符合酝惧，如果有符合的Factory，即就可以得到最終的CallAdapter和ResponseConverter伯诬。
final class ServiceMethod<T> {
private CallAdapter<?> createCallAdapter() {
//方法返回值類型
Type returnType = method.getGenericReturnType();
if (Utils.hasUnresolvableType(returnType)) {
throw methodError(
"Method return type must not include a type variable or wildcard: %s", returnType);
}
if (returnType == void.class) {
throw methodError("Service methods cannot return void.");
}
//方法注解
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(e, "Unable to create call adapter for %s", returnType);
}
}
}
public final class Retrofit {
public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");
int start = adapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = adapterFactories.size(); i < count; i++) {
CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
//Factory獲取的CallAdapter不為空晚唇，說明找到合適的CallAdapter了
if (adapter != null) {
return adapter;
}
}
...
}
}
默認(rèn)CallAdapter的轉(zhuǎn)換過程
默認(rèn)Converter.Factory的列表中有一個(gè)ExecutorCallAdapterFactory，它的get方法返回一個(gè)CallAdapter對(duì)象盗似，這個(gè)CallAdapter對(duì)象會(huì)將原始的OkHttpCall轉(zhuǎn)換為ExecutorCallbackCall哩陕，這個(gè)ExecutorCallbackCall就是我們接口方法中返回值定義的Call接口，它封裝了原始OkHttpCall用于網(wǎng)絡(luò)請(qǐng)求和MainThreadExecutor用于響應(yīng)數(shù)據(jù)時(shí)的線程切換赫舒。如
@GET("/api/4/news/{id}")
Call<ZhihuStory> getStory(@Path("id") String id);
//這個(gè)call就是ExecutorCallbackCall對(duì)象
Call<ZhihuStory> call = apiService.getStory("100");
call.enqueue(new Callback<Joke>() {
@Override public void onResponse(Call<Joke> call, Response<Joke> response) {
}
@Override public void onFailure(Call<Joke> call, Throwable t) {
}
});
當(dāng)call調(diào)用它的enqueue方法時(shí)萌踱，就會(huì)調(diào)用它內(nèi)部的OkHttpCall的enqueue方法，進(jìn)而執(zhí)行執(zhí)行Okhttp的enqueue方法開始異步網(wǎng)絡(luò)請(qǐng)求号阿，響應(yīng)返回時(shí)并鸵，用MainThreadExecutor對(duì)象將響應(yīng)過程切換到主線程（默認(rèn)Okhttp的響應(yīng)方法是在其他線程中，MainThreadExecutor內(nèi)部使用Handler將響應(yīng)回調(diào)post到主線程處理）扔涧。
RxjavaCallAdapter的轉(zhuǎn)換過程
如果添加了Rxjava的支持园担，那么在Converter.Factory列表中會(huì)有一個(gè)RxjavaCallAdapterFactory届谈，它的get方法最終會(huì)返回一個(gè)SimpleCallAdapter對(duì)象（如果接口方法返回類型的泛型是我們定義的Bean類的話），這個(gè)SimpleCallAdapter對(duì)象會(huì)將原始的OkHttpCall轉(zhuǎn)換為一個(gè)Observable對(duì)象弯汰。有了這個(gè)Observable對(duì)象就可以很方便的作線程切換和后續(xù)的其他處理了艰山。接口方法返回類型的泛型是Response或Result，那么RxjavaCallAdapterFactory的get方法會(huì)返回ResponseCallAdapter或ResultCallAdapter咏闪。
public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {
static final class SimpleCallAdapter implements CallAdapter<Observable<?>> {
private final Type responseType;
private final Scheduler scheduler;
SimpleCallAdapter(Type responseType, Scheduler scheduler) {
this.responseType = responseType;
this.scheduler = scheduler;
}
@Override public Type responseType() {
return responseType;
}
@Override public <R> Observable<R> adapt(Call<R> call) {
//這里將OkHttpCall對(duì)象轉(zhuǎn)換為Observable對(duì)象
//CallOnSubscribe用于觸發(fā)請(qǐng)求調(diào)用操作
Observable<R> observable = Observable.create(new CallOnSubscribe<>(call)) //
.lift(OperatorMapResponseToBodyOrError.<R>instance());
if (scheduler != null) {
return observable.subscribeOn(scheduler);
}
return observable;
}
}
}
然后它在CallOnSubscribe中觸發(fā)請(qǐng)求的調(diào)用曙搬。
public final class RxJavaCallAdapterFactory extends CallAdapter.Factory {
static final class CallOnSubscribe<T> implements Observable.OnSubscribe<Response<T>> {
private final Call<T> originalCall;
CallOnSubscribe(Call<T> originalCall) {
this.originalCall = originalCall;
}
@Override public void call(final Subscriber<? super Response<T>> subscriber) {
//這里觸發(fā)請(qǐng)求調(diào)用
// Since Call is a one-shot type, clone it for each new subscriber.
Call<T> call = originalCall.clone();
// Wrap the call in a helper which handles both unsubscription and backpressure.
RequestArbiter<T> requestArbiter = new RequestArbiter<>(call, subscriber);
subscriber.add(requestArbiter);
subscriber.setProducer(requestArbiter);
}
}
static final class RequestArbiter<T> extends AtomicBoolean implements Subscription, Producer {
private final Call<T> call;
private final Subscriber<? super Response<T>> subscriber;
RequestArbiter(Call<T> call, Subscriber<? super Response<T>> subscriber) {
this.call = call;
this.subscriber = subscriber;
}
@Override public void request(long n) {
if (n < 0) throw new IllegalArgumentException("n < 0: " + n);
if (n == 0) return; // Nothing to do when requesting 0.
if (!compareAndSet(false, true)) return; // Request was already triggered.
//這里調(diào)用OkHttpCall的execute方法進(jìn)行網(wǎng)絡(luò)請(qǐng)求
try {
Response<T> response = call.execute();
if (!subscriber.isUnsubscribed()) {
subscriber.onNext(response);
}
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
if (!subscriber.isUnsubscribed()) {
subscriber.onError(t);
}
return;
}
if (!subscriber.isUnsubscribed()) {
subscriber.onCompleted();
}
}
@Override public void unsubscribe() {
call.cancel();
}
@Override public boolean isUnsubscribed() {
return call.isCanceled();
}
}
}
這樣完成的RxJava式的轉(zhuǎn)換請(qǐng)求流程就走通了。
CallAdapter的轉(zhuǎn)換過程
那么響應(yīng)數(shù)據(jù)是在哪里轉(zhuǎn)換成我們定義的類型的呢鸽嫂？它是在OkhttpCall中進(jìn)行響應(yīng)數(shù)據(jù)解析轉(zhuǎn)換的纵装，不論是它的enqueue還是excute方法，響應(yīng)結(jié)果都會(huì)交給parseResponse處理据某。
final class OkHttpCall<T> implements Call<T> {
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
//響應(yīng)體
ResponseBody rawBody = rawResponse.body();
//用原始響應(yīng)體封裝一個(gè)新的響應(yīng)體橡娄，是能夠進(jìn)行類型轉(zhuǎn)換
// 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();
//響應(yīng)碼
int code = rawResponse.code();
if (code < 200 || code >= 300) {
//錯(cuò)誤響應(yīng)
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) {
//響應(yīng)碼為無內(nèi)容，沒有數(shù)據(jù)時(shí)癣籽，成功挽唉，但返回空
return Response.success(null, rawResponse);
}
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
//這里調(diào)用serviceMethod去將響應(yīng)體數(shù)據(jù)轉(zhuǎn)換為指定類型
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;
}
}
}
可以看到在enqueue或者excute方法執(zhí)行得到響應(yīng)數(shù)據(jù)后會(huì)到parseResponse將響應(yīng)體數(shù)據(jù)轉(zhuǎn)換為指定類型，是調(diào)用當(dāng)前serviceMethod的toResponse方法進(jìn)行轉(zhuǎn)換筷狼，里面會(huì)調(diào)用responseConverter進(jìn)行convert轉(zhuǎn)換瓶籽，如果我們?cè)赗etrofit配置時(shí)添加了GsonConverterFactory支持，那么就會(huì)使用GsonConverterFactory中的GsonResponseBodyConverter進(jìn)行類型轉(zhuǎn)換埂材，而GsonResponseBodyConverter內(nèi)部是使用gson進(jìn)行類型轉(zhuǎn)換棘劣。
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
private final Gson gson;
private final TypeAdapter<T> adapter;
GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
this.gson = gson;
this.adapter = adapter;
}
@Override public T convert(ResponseBody value) throws IOException {
//使用gson對(duì)ResponseBody轉(zhuǎn)換為指定類型
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
return adapter.read(jsonReader);
} finally {
value.close();
}
}
}
這樣響應(yīng)數(shù)據(jù)類型的轉(zhuǎn)換就走通了。
總結(jié)
Retrofit源碼涉及了不少涉及模式楞遏，結(jié)構(gòu)清晰茬暇，我想它最大的特點(diǎn)就是讓我們以最簡(jiǎn)便的方式實(shí)現(xiàn)了我們的網(wǎng)絡(luò)請(qǐng)求業(yè)務(wù)，同時(shí)高度的擴(kuò)展性使能充分利用其它庫(kù)的優(yōu)點(diǎn)為其服務(wù)寡喝。Okhttp為其處理底層網(wǎng)絡(luò)請(qǐng)求（還包括緩存處理糙俗，日志攔截等），RxJava為其提供更加廣闊的調(diào)用處理方式预鬓，Gson等其他解析為響應(yīng)數(shù)據(jù)解析提供了保證等等巧骚。所以借用農(nóng)夫三拳的話說，“我們不生產(chǎn)水 我們只是大自然的搬運(yùn)工”格二，哈哈劈彪，Retrofit，一個(gè)安靜的集成管理者（美男子）顶猜。
