1.前言
經(jīng)過(guò)前面幾章的學(xué)習(xí),對(duì)于andorid中的網(wǎng)絡(luò)庫(kù)已經(jīng)有了充分的了解,但是技術(shù)一直是向前發(fā)展的,所以我們每時(shí)每刻也都得超越自己
本章網(wǎng)絡(luò)庫(kù)系列的最后一章,講解的是又一android端最為流行的網(wǎng)絡(luò)庫(kù)框架Retrofit,他同樣也是由square出品,他和Volley一樣是一個(gè)網(wǎng)絡(luò)封裝庫(kù),底層是由OkHttp完成的,通過(guò)注解實(shí)現(xiàn)RESTful式的Http網(wǎng)絡(luò)請(qǐng)求
2.目錄
目錄
3.Retrofit
3.1.Retrofit的優(yōu)點(diǎn)
- 1.耦合性極低
- 2.可以自由配置底層網(wǎng)絡(luò)請(qǐng)求框架
- 3.支持同步異步,并且可結(jié)合RxJava使用
- 4.可以配置不同的交互數(shù)據(jù)解析工具來(lái)解析數(shù)據(jù)
- 5.使用靈活方便
3.2.Retrofit的簡(jiǎn)單使用
- 1.申明API接口
private interface RetrofitService {
//測(cè)試調(diào)用(wanandroid主頁(yè))
@GET("article/list/{page}/json")
Call<ResponseBody> getArticle(@Path("page") int page);
}
- 2.構(gòu)建
Retrofit對(duì)象
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://www.wanandroid.com/")
.build();
- 3.獲取API接口,直接調(diào)用回去實(shí)體回調(diào)的
Call
RetrofitService service = retrofit.create(RetrofitService.class);
Call<ResponseBody> article = service.getArticle(1);
- 4.執(zhí)行
Call獲取響應(yīng)
// 同步調(diào)用 什么線程執(zhí)行 回調(diào)就在什么線程
Response<ResponseBody> response = article.execute();
String json = response.body().string();
// 異步調(diào)用 不同于OkHttp會(huì)回調(diào)到主線程
Call<ResponseBody> article = service.getArticle(1);
article.enqueue(new Callback<ResponseBody>() {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
// 有IOException
String json = response.body().string();
}
@Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
}
});
3.3.Retrofit源碼分析
首先查看Retrofit的構(gòu)建過(guò)程
public final class Retrofit {
// 以Method-ServiceMethod映射緩存網(wǎng)絡(luò)請(qǐng)求相關(guān)配置,防止并發(fā)問(wèn)題使用的ConcurrentHashMap
private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();
//網(wǎng)絡(luò)請(qǐng)求工廠
final okhttp3.Call.Factory callFactory;
//基準(zhǔn)Url
final HttpUrl baseUrl;
//數(shù)據(jù)轉(zhuǎn)換器工廠集合
final List<Converter.Factory> converterFactories;
//網(wǎng)絡(luò)請(qǐng)求適配器工廠集合
final List<CallAdapter.Factory> callAdapterFactories;
//回調(diào)方法執(zhí)行器
final @Nullable Executor callbackExecutor;
//是否緩存創(chuàng)建的ServiceMethod
final boolean validateEagerly;
public Retrofit build() {
//基準(zhǔn)Url必須設(shè)定 且怒能為null
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
//設(shè)置配置的網(wǎng)絡(luò)請(qǐng)求工程
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
//默認(rèn)為OkHttpClient
callFactory = new OkHttpClient();
}
//請(qǐng)求回調(diào)方法執(zhí)行器
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
//
callbackExecutor = platform.defaultCallbackExecutor();
}
//添加配置的CallAdapter.Factory 再追加platform.defaultCallAdapterFactories
// Make a defensive copy of the adapters and add the default Call adapter.
List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));
//添加BuiltInConverters
//和配置的Conver.Factory
//以及platform.defaultConverterFactories
// Make a defensive copy of the converters.
List<Converter.Factory> converterFactories = new ArrayList<>(
1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());
// Add the built-in converter factory first. This prevents overriding its behavior but also
// ensures correct behavior when using converters that consume all types.
converterFactories.add(new BuiltInConverters());
converterFactories.addAll(this.converterFactories);
converterFactories.addAll(platform.defaultConverterFactories());
//構(gòu)建Retrofit對(duì)象
return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}
}
然后再查看網(wǎng)絡(luò)接口的構(gòu)建過(guò)程
RetrofitService service = retrofit.create(RetrofitService.class)
public <T> T create(final Class<T> service) {
//對(duì)service進(jìn)行校驗(yàn) 必須是一個(gè)接口 且沒(méi)有繼承其它接口
Utils.validateServiceInterface(service);
//是否需要提前驗(yàn)證
if (validateEagerly) {
eagerlyValidateMethods(service);
}
//利用動(dòng)態(tài)代理技術(shù),自動(dòng)生成Service接口的實(shí)現(xiàn)類(lèi),將Service接口中的參數(shù)交給InvocationHandler處理
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
private final retrofit2.Platform platform = retrofit2.Platform.get();
private final Object[] emptyArgs = new Object[0];
@Override public @Nullable Object invoke(Object proxy, Method method,
@Nullable Object[] args) throws Throwable {
//Object類(lèi)的方法 直接調(diào)用
// If the method is a method from Object then defer to normal invocation.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
//對(duì)應(yīng)平臺(tái)擁有的方法 直接調(diào)用
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
//否則就通過(guò)loadServiceMethod(method)方法獲取對(duì)應(yīng)的serviceMethod 并invoke
return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);
}
});
}
這里最后就是用了動(dòng)態(tài)代理生成Service接口的實(shí)現(xiàn)類(lèi),將參數(shù)交由InvocationHandler執(zhí)行invoke()方法,再下來(lái)再看看loadServiceMethod(method)方法
ServiceMethod<?> loadServiceMethod(Method method) {
//先從緩存中獲取
ServiceMethod<?> result = serviceMethodCache.get(method);
//有則直接返回
if (result != null) return result;
synchronized (serviceMethodCache) {
//再次獲取 多線阻塞的情況下 可能已由其它線程創(chuàng)建完畢(雙重校驗(yàn))
result = serviceMethodCache.get(method);
if (result == null) {
//解析注解 創(chuàng)建ServiceMethod
result = ServiceMethod.parseAnnotations(this, method);
//存入緩存
serviceMethodCache.put(method, result);
}
}
return result;
}
從緩存獲取解析注解獲取ServiceMethod,前面提前驗(yàn)證判斷也會(huì)調(diào)用這個(gè)方法,然后再看整個(gè)解析過(guò)程ServiceMethod.parseAnnotations()
static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
//將解析轉(zhuǎn)化為RequestFactory
RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
//獲取返回類(lèi)型
Type returnType = method.getGenericReturnType();
//是不是無(wú)法解析的類(lèi)型
if (Utils.hasUnresolvableType(returnType)) {
throw methodError(method,
"Method return type must not include a type variable or wildcard: %s", returnType);
}
//返回值類(lèi)型不能void
if (returnType == void.class) {
throw methodError(method, "Service methods cannot return void.");
}
//交由HttpServiceMethod解析
return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
}
接著查看RequestFactory.parseAnnotations()
static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
//建造者模式配置參數(shù)
return new RequestFactory.Builder(retrofit, method).build();
}
Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
//獲取網(wǎng)絡(luò)請(qǐng)求方法里的注解
this.methodAnnotations = method.getAnnotations();
//獲取參數(shù)類(lèi)型
this.parameterTypes = method.getGenericParameterTypes();
//獲取參數(shù)注解
this.parameterAnnotationsArray = method.getParameterAnnotations();
}
RequestFactory build() {
for (Annotation annotation : methodAnnotations) {
//解析注解參數(shù) 異常判斷
parseMethodAnnotation(annotation);
}
//錯(cuò)誤檢測(cè),最后會(huì)拋IllegalArgumentException
...
int parameterCount = parameterAnnotationsArray.length;
parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
parameterHandlers[p] =
//解析注解參數(shù) 異常判斷
parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
}
//錯(cuò)誤檢測(cè),最后會(huì)拋IllegalArgumentException
...
return new RequestFactory(this);
}
然后再查看HttpServiceMethod.parseAnnotations()
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
Retrofit retrofit, Method method, RequestFactory requestFactory) {
boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
boolean continuationWantsResponse = false;
boolean continuationBodyNullable = false;
Annotation[] annotations = method.getAnnotations();
Type adapterType;
//如果方法是kotlin中的suspend方法
if (isKotlinSuspendFunction) {
//獲取泛型參數(shù)
Type[] parameterTypes = method.getGenericParameterTypes();
Type responseType = Utils.getParameterLowerBound(0,
(ParameterizedType) parameterTypes[parameterTypes.length - 1]);
//如果參數(shù)是Response類(lèi)型
if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {
// Unwrap the actual body type from Response<T>.
responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
//設(shè)置為true 說(shuō)明需要的是Response
continuationWantsResponse = true;
} else {
// TODO figure out if type is nullable or not
// Metadata metadata = method.getDeclaringClass().getAnnotation(Metadata.class)
// Find the entry for method
// Determine if return type is nullable or not
}
adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
} else {
//否則湖區(qū)方法返回值的泛型參數(shù) 即為請(qǐng)求需要的返回值類(lèi)型
adapterType = method.getGenericReturnType();
}
//根據(jù)網(wǎng)絡(luò)請(qǐng)求接口方法的返回值和注解類(lèi)型
//從Retrofit對(duì)象中獲取網(wǎng)絡(luò)請(qǐng)求適配器
CallAdapter<ResponseT, ReturnT> callAdapter =
createCallAdapter(retrofit, method, adapterType, annotations);
//得到響應(yīng)類(lèi)型
Type responseType = callAdapter.responseType();
if (responseType == okhttp3.Response.class) {
throw methodError(method, "'"
+ getRawType(responseType).getName()
+ "' is not a valid response body type. Did you mean ResponseBody?");
}
if (responseType == Response.class) {
throw methodError(method, "Response must include generic type (e.g., Response<String>)");
}
// TODO support Unit for Kotlin?
if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
throw methodError(method, "HEAD method must use Void as response type.");
}
//根據(jù)網(wǎng)絡(luò)請(qǐng)求接口方法的返回值和注解類(lèi)型從Retrofit對(duì)象中獲取對(duì)應(yīng)的數(shù)據(jù)轉(zhuǎn)換器
Converter<ResponseBody, ResponseT> responseConverter =
createResponseConverter(retrofit, method, responseType);
okhttp3.Call.Factory callFactory = retrofit.callFactory;
if (!isKotlinSuspendFunction) {
//不是suspend方法的話則直接創(chuàng)建并返回一個(gè)CallAdapted對(duì)象
return new HttpServiceMethod.CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
} else if (continuationWantsResponse) {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
//返回Response類(lèi)型的HttpServiceMethod
return (HttpServiceMethod<ResponseT, ReturnT>) new HttpServiceMethod.SuspendForResponse<>(requestFactory,
callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
} else {
//noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
//返回具體類(lèi)型的HttpServiceMethod
return (HttpServiceMethod<ResponseT, ReturnT>) new HttpServiceMethod.SuspendForBody<>(requestFactory,
callFactory, responseConverter, (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
continuationBodyNullable);
}
}
上述方法主要作用是獲取CallAdapter以及Converter對(duì)象,并構(gòu)建對(duì)應(yīng)的HttpServiceMethod,根據(jù)是否是kotlin suspend方法,如果是構(gòu)建并返回一個(gè)CallAdapter對(duì)象,否則根據(jù)是否需要具體類(lèi)型返回SuspendForBody和SuspendForResponse
接著來(lái)查看CallAdapter的獲取方法 createCallAdapter()
private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(
Retrofit retrofit, Method method, Type returnType, Annotation[] annotations) {
try {
//noinspection unchecked
return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create call adapter for %s", returnType);
}
}
public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
checkNotNull(returnType, "returnType == null");
checkNotNull(annotations, "annotations == null");
int start = callAdapterFactories.indexOf(skipPast) + 1;
//遍歷CallAdapter.Factory集合尋找合適的CallAdapter
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
//否則拋出異常
StringBuilder builder = new StringBuilder("Could not locate call adapter for ")
.append(returnType)
.append(".\n");
if (skipPast != null) {
builder.append(" Skipped:");
for (int i = 0; i < start; i++) {
builder.append("\n * ").append(callAdapterFactories.get(i).getClass().getName());
}
builder.append('\n');
}
builder.append(" Tried:");
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
builder.append("\n * ").append(callAdapterFactories.get(i).getClass().getName());
}
throw new IllegalArgumentException(builder.toString());
}
接著來(lái)查看Converter的獲取方法 createResponseConverter()
,和CallAdapter的獲取方法相似
private static <ResponseT> Converter<ResponseBody, ResponseT> createResponseConverter(
Retrofit retrofit, Method method, Type responseType) {
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.responseBodyConverter(responseType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(method, e, "Unable to create converter for %s", responseType);
}
}
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
return nextResponseBodyConverter(null, type, annotations);
}
public <T> Converter<ResponseBody, T> nextResponseBodyConverter(
@Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
checkNotNull(type, "type == null");
checkNotNull(annotations, "annotations == null");
int start = converterFactories.indexOf(skipPast) + 1;
//遍歷converterFactories集合,找到合適的Converter
for (int i = start, count = converterFactories.size(); i < count; i++) {
Converter<ResponseBody, ?> converter =
converterFactories.get(i).responseBodyConverter(type, annotations, this);
if (converter != null) {
//noinspection unchecked
return (Converter<ResponseBody, T>) converter;
}
}
//沒(méi)找到則拋出IllegalArgumentException
StringBuilder builder = new StringBuilder("Could not locate ResponseBody converter for ")
.append(type)
.append(".\n");
if (skipPast != null) {
builder.append(" Skipped:");
for (int i = 0; i < start; i++) {
builder.append("\n * ").append(converterFactories.get(i).getClass().getName());
}
builder.append('\n');
}
builder.append(" Tried:");
for (int i = start, count = converterFactories.size(); i < count; i++) {
builder.append("\n * ").append(converterFactories.get(i).getClass().getName());
}
throw new IllegalArgumentException(builder.toString());
}
然后回到剛開(kāi)始動(dòng)態(tài)代理創(chuàng)建網(wǎng)絡(luò)接口Service的地方
//獲取響應(yīng)類(lèi)型
abstract @Nullable T invoke(Object[] args);
然后看HttpServiceMethod對(duì)invoke()方法的實(shí)現(xiàn)
@Override final @Nullable ReturnT invoke(Object[] args) {
Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
return adapt(call, args);
}
//抽象方法 有HttpServiceMethod的子類(lèi)實(shí)現(xiàn)
protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);
非協(xié)程情況下是CallAdapter,最終由ExecutorCallbackCall(也是一個(gè)Call對(duì)象)執(zhí)行網(wǎng)絡(luò)請(qǐng)求
return new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public Call<Object> adapt(Call<Object> call) {
return executor == null
? call
: new DefaultCallAdapterFactory.ExecutorCallbackCall<>(executor, call);
}
};
接著回到call的創(chuàng)建Call<ResponseBody> article = service.getArticle(1),上面也已講解到最終會(huì)調(diào)用InvocationHandler.invoke()方法,默認(rèn)情況下得到的是ExecutorCallbackCall對(duì)象
接著查看請(qǐng)求的執(zhí)行,同步請(qǐng)求Response<ResponseBody> response = article.execute()
@Override public Response<T> execute() throws IOException {
okhttp3.Call call;
//防止并發(fā)安全
synchronized (this) {
//同一個(gè)請(qǐng)求只能執(zhí)行一次
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
if (creationFailure != null) {
if (creationFailure instanceof IOException) {
throw (IOException) creationFailure;
} else if (creationFailure instanceof RuntimeException) {
throw (RuntimeException) creationFailure;
} else {
throw (Error) creationFailure;
}
}
call = rawCall;
if (call == null) {
try {
//創(chuàng)建OkHttp的Call對(duì)象
call = rawCall = createRawCall();
} catch (IOException | RuntimeException | Error e) {
throwIfFatal(e); // Do not assign a fatal error to creationFailure.
creationFailure = e;
throw e;
}
}
}
if (canceled) {
//取消請(qǐng)求
call.cancel();
}
//執(zhí)行請(qǐng)求并解析返回結(jié)果
return parseResponse(call.execute());
}
接著查看Call對(duì)象的創(chuàng)建createRawCall()
private okhttp3.Call createRawCall() throws IOException {
//callFactory默認(rèn)為OkHttpClient 創(chuàng)建RealCall的過(guò)程
okhttp3.Call call = callFactory.newCall(requestFactory.create(args));
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
下面接著查看請(qǐng)求執(zhí)行后,響應(yīng)結(jié)果的解析parseResponse (),會(huì)拋出
IOException
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 OkHttpCall.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);
}
OkHttpCall.ExceptionCatchingResponseBody catchingBody = new OkHttpCall.ExceptionCatchingResponseBody(rawBody);
try {
//調(diào)用Converter解析body
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;
}
}
同步調(diào)用這樣執(zhí)行完成了,總的來(lái)說(shuō)就是通過(guò)動(dòng)態(tài)代理來(lái)生成網(wǎng)絡(luò)接口Service,并解析注解獲取請(qǐng)求方式和參數(shù),然后調(diào)用invoke()方法獲取Call,最后同步執(zhí)行請(qǐng)求
下面接著查看異步請(qǐng)求的過(guò)程article.enqueue(new Callback())
@Override public void enqueue(final Callback<T> callback) {
checkNotNull(callback, "callback == null");
okhttp3.Call call;
Throwable failure;
synchronized (this) {
if (executed) throw new IllegalStateException("Already executed.");
executed = true;
call = rawCall;
failure = creationFailure;
if (call == null && failure == null) {
try {
//創(chuàng)建OkHttp的Call對(duì)象
call = rawCall = createRawCall();
} catch (Throwable t) {
throwIfFatal(t);
failure = creationFailure = t;
}
}
}
if (failure != null) {
//回調(diào)失敗
callback.onFailure(this, failure);
return;
}
if (canceled) {
//取消請(qǐng)求
call.cancel();
}
//調(diào)用call的異步執(zhí)行方法 根據(jù)OkHttp的Callback設(shè)置回調(diào)結(jié)果
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
Response<T> response;
try {
//解析返回結(jié)果(和同步調(diào)用的方法一致)
response = parseResponse(rawResponse);
} catch (Throwable e) {
throwIfFatal(e);
callFailure(e);
return;
}
try {
//回調(diào)成功
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
throwIfFatal(t);
t.printStackTrace(); // TODO this is not great
}
}
@Override public void onFailure(okhttp3.Call call, IOException e) {
//回調(diào)異常
callFailure(e);
}
private void callFailure(Throwable e) {
try {
//回調(diào)異常
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
throwIfFatal(t);
t.printStackTrace(); // TODO this is not great
}
}
});
}
異步請(qǐng)求的實(shí)現(xiàn)是創(chuàng)建一個(gè)RealCall,然后eqeue()到請(qǐng)求隊(duì)列中,通過(guò)監(jiān)聽(tīng)OkHttp的Callback來(lái)設(shè)置自己的回調(diào)
4.自定義Factory
4.1. GsonConverterFactory數(shù)據(jù)解析工廠
首先看一下GsonConverterFactory,他是在配置Retrofit時(shí)添加的
public Retrofit.Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
然后再查看GsonConverterFactory
public final class GsonConverterFactory extends Converter.Factory {
//創(chuàng)建Gson轉(zhuǎn)換器
public static retrofit2.converter.gson.GsonConverterFactory create() {
return create(new Gson());
}
//創(chuàng)建GsonConverterFactory
@SuppressWarnings("ConstantConditions")
public static retrofit2.converter.gson.GsonConverterFactory create(Gson gson) {
if (gson == null) throw new NullPointerException("gson == null");
return new retrofit2.converter.gson.GsonConverterFactory(gson);
}
private final Gson gson;
//傳入Gson實(shí)例
private GsonConverterFactory(Gson gson) {
this.gson = gson;
}
//轉(zhuǎn)化響應(yīng)體(在獲取響應(yīng)數(shù)據(jù)時(shí)調(diào)用)
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
//type為響應(yīng)實(shí)體
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}
//轉(zhuǎn)換請(qǐng)求體(在解析注解請(qǐng)求方法時(shí)調(diào)用)
@Override
public Converter<?, RequestBody> requestBodyConverter(Type type,
Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonRequestBodyConverter<>(gson, adapter);
}
}
然后再查看GsonRequestBodyConverter類(lèi)
final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
private final Gson gson;
private final TypeAdapter<T> adapter;
//傳入Gson對(duì)象和類(lèi)型適配器
GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
this.gson = gson;
this.adapter = adapter;
}
//將ResponseBody轉(zhuǎn)化為實(shí)體類(lèi)
@Override public T convert(ResponseBody value) throws IOException {
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
T result = adapter.read(jsonReader);
if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
throw new JsonIOException("JSON document was not fully consumed.");
}
return result;
} finally {
value.close();
}
}
}
4.2. RxJava2CallAdapterFactory數(shù)據(jù)回調(diào)適配工廠
同上RxJava2CallAdapterFactory也是在Retrofit初始化時(shí)配置的
public Retrofit.Builder addCallAdapterFactory(CallAdapter.Factory factory) {
callAdapterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}
接著查看RxJava2CallAdapterFactory類(lèi)
public final class RxJava2CallAdapterFactory extends CallAdapter.Factory {
//RxJava2CallAdapterFactory初始化
public static RxJava2CallAdapterFactory create() {
return new RxJava2CallAdapterFactory(null, false);
}
public static RxJava2CallAdapterFactory createAsync() {
return new RxJava2CallAdapterFactory(null, true);
}
@SuppressWarnings("ConstantConditions") // Guarding public API nullability.
public static RxJava2CallAdapterFactory createWithScheduler(Scheduler scheduler) {
if (scheduler == null) throw new NullPointerException("scheduler == null");
return new RxJava2CallAdapterFactory(scheduler, false);
}
//線程調(diào)度器
private final @Nullable Scheduler scheduler;
//同步還是異步請(qǐng)求
private final boolean isAsync;
private RxJava2CallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync) {
this.scheduler = scheduler;
this.isAsync = isAsync;
}
@Override public @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit) {
//returnType 就是請(qǐng)求方法的返回值類(lèi)型 Observable<TestBean>
//返回的class Observable.class
Class<?> rawType = getRawType(returnType);
//Completable 只關(guān)心onComplete事件 實(shí)體類(lèi)為void
if (rawType == Completable.class) {
// Completable is not parameterized (which is what the rest of this method deals with) so it
// can only be created with a single configuration.
return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
false, true);
}
boolean isFlowable = rawType == Flowable.class;
boolean isSingle = rawType == Single.class;
boolean isMaybe = rawType == Maybe.class;
if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) {
return null;
}
boolean isResult = false;
boolean isBody = false;
Type responseType;
//如果不是泛型類(lèi) 則拋出異常
if (!(returnType instanceof ParameterizedType)) {
String name = isFlowable ? "Flowable"
: isSingle ? "Single"
: isMaybe ? "Maybe" : "Observable";
throw new IllegalStateException(name + " return type must be parameterized"
+ " as " + name + "<Foo> or " + name + "<? extends Foo>");
}
//獲取響應(yīng)數(shù)據(jù)類(lèi)型 實(shí)體類(lèi)TestBean
Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
//再次獲取數(shù)據(jù)類(lèi)型的class
Class<?> rawObservableType = getRawType(observableType);
if (rawObservableType == Response.class) {
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Response must be parameterized"
+ " as Response<Foo> or Response<? extends Foo>");
}
responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
} else if (rawObservableType == Result.class) {
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Result must be parameterized"
+ " as Result<Foo> or Result<? extends Foo>");
}
responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
isResult = true;
} else {
//設(shè)置實(shí)體類(lèi) TestBean
responseType = observableType;
isBody = true;
}
//生成具體的RxJava2CallAdapter
return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
isSingle, isMaybe, false);
}
}
然后再看RxJava2CallAdapter的創(chuàng)建
final class RxJava2CallAdapter<R> implements CallAdapter<R, Object> {
//返回Observable的方法
@Override public Object adapt(Call<R> call) {
//根據(jù)請(qǐng)求是同步還是異步 創(chuàng)建不同的Observable
Observable<Response<R>> responseObservable = isAsync
? new CallEnqueueObservable<>(call)
: new CallExecuteObservable<>(call);
Observable<?> observable;
if (isResult) {
observable = new ResultObservable<>(responseObservable);
} else if (isBody) {
//響應(yīng)實(shí)體類(lèi) isBody為true
observable = new BodyObservable<>(responseObservable);
} else {
observable = responseObservable;
}
//設(shè)置線程調(diào)度器
if (scheduler != null) {
observable = observable.subscribeOn(scheduler);
}
if (isFlowable) {
return observable.toFlowable(BackpressureStrategy.LATEST);
}
if (isSingle) {
return observable.singleOrError();
}
if (isMaybe) {
return observable.singleElement();
}
if (isCompletable) {
return observable.ignoreElements();
}
//返回BodyObservable
return RxJavaPlugins.onAssembly(observable);
}
}
大概就介紹到這里,后面再了解RxJava源碼時(shí),再回頭復(fù)習(xí)下
5.總結(jié)
這一章節(jié)學(xué)習(xí)了android中的又一流行框架,使用起來(lái)是非常靈活的,耦合性非常低,可以自定義CallAdapterFactory和ConverterFactory,設(shè)計(jì)的十分巧妙
