Android进阶必学retrofit源码解析，Android开发者跳槽面试

最新推荐文章于 2024-10-07 14:56:02 发布

2401_84149814

最新推荐文章于 2024-10-07 14:56:02 发布

阅读量583

点赞数 8

分类专栏：程序员文章标签： android retrofit 跳槽

本文链接：https://blog.csdn.net/2401_84149814/article/details/137446993

版权

程序员专栏收录该内容

265 篇文章 1 订阅

订阅专栏

注解的解析

CallAdapter和Converter等到后面再分析，这里先看看parseMethodAnnotation(annotation)，功能和其名字一样，其对方法注解进行了解析

/**

解析方法注解，呜啦啦
通过判断注解类型来解析
@param annotation
*/
private void parseMethodAnnotation(Annotation annotation) {
if (annotation instanceof DELETE) {
parseHttpMethodAndPath(“DELETE”, ((DELETE) annotation).value(), false);
} else if (annotation instanceof GET) {
parseHttpMethodAndPath(“GET”, ((GET) annotation).value(), false);
}
// 其他的一些方法注解的解析
…
}
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
if (this.httpMethod != null) {// 已经赋值过了
throw methodError(“Only one HTTP method is allowed. Found: %s and %s.”,
this.httpMethod, httpMethod);
}
this.httpMethod = httpMethod;
this.hasBody = hasBody;
// value为设置注解方法时候，设置的值，官方例子中的users/{user}/repos or user
if (value.isEmpty()) {
return;
}
// 查询条件的一些判断
…
this.relativeUrl = value;
this.relativeUrlParamNames = parsePathParameters(value);
}
`

在解析注解时，先通过instanceof判断出注解的类型，之后调用parseHttpMethodAndPath方法解析注解参数值，并设置httpMethod、relativeUrl、relativeUrlParamNames等属性。

上面说了API中方法注解的解析，现在来看看方法参数注解的解析，这是通过调用parseParameterAnnotation方法生成ParameterHandler实例来实现的，代码比较多，这里挑选@Query来看看。

else if (annotation instanceof Query) {
Query query = (Query) annotation;
String name = query.value();
boolean encoded = query.encoded();
Class<?> rawParameterType = Utils.getRawType(type);// 返回基础的类
gotQuery = true;
// 可以迭代，Collection
if (Iterable.class.isAssignableFrom(rawParameterType)) {
if (!(type instanceof ParameterizedType)) {
throw parameterError(p, rawParameterType.getSimpleName()

" must include generic type (e.g., "
rawParameterType.getSimpleName()
“)”);
}
ParameterizedType parameterizedType = (ParameterizedType) type;
Type iterableType = Utils.getParameterUpperBound(0, parameterizedType);// 返回基本类型
Converter<?, String> converter = retrofit.stringConverter(iterableType, annotations); return new ParameterHandler.Query<>(name, converter, encoded).iterable(); } else if (rawParameterType.isArray()) {// Array Class<?> arrayComponentType = boxIfPrimitive(rawParameterType.getComponentType());// 如果是基本类型，自动装箱
Converter<?, String> converter =
retrofit.stringConverter(arrayComponentType, annotations);
return new ParameterHandler.Query<>(name, converter, encoded).array();
} else {// Other
Converter<?, String> converter =
retrofit.stringConverter(type, annotations);
return new ParameterHandler.Query<>(name, converter, encoded);
}

在@Query中，将分成Collection、array、other三种情况处理参数，之后根据这些参数，调用ParameterHandler中的Query静态类，创建出一个ParameterHandler实例。这样循环直到解析了所有的参数注解，组合成为全局变量parameterHandlers，之后构建请求时会用到

OkHttpCall

ServiceMethod创建完成之后，我们来看看下一行代码中的OkHttpCall类，里面的包含了请求的执行和响应处理，我们来看看异步请求的做法

OkHttpCall(ServiceMethod<T, ?> serviceMethod, Object[] args) {
this.serviceMethod = serviceMethod;
this.args = args;
}
@Override public void enqueue(final Callback 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 {
call = rawCall = createRawCall();// 创建OkHttp3.Call
} catch (Throwable t) {
failure = creationFailure = t;
}
}
}
if (failure != null) {
callback.onFailure(this, failure);
return;
}
if (canceled) {
call.cancel();
}
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
throws IOException {
Response response;
try {
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 response) {
try {
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
private okhttp3.Call createRawCall() throws IOException {
Request request = serviceMethod.toRequest(args);// 根据ParameterHandler组装Request.Builder，生成Request
okhttp3.Call call = serviceMethod.callFactory.newCall(request);// Retrofit中创建的new OkHttpClient().newCall(request)
…
return call;
}

CallAdapter

现在来看看enqueue传入的参数callback,这个参数可能和很多人心中想的并不一样，它并不是用户在使用时传入的那个Callback对象。那么他是从哪里来的呢？不知道你还记不记得我之前在Retrofit.Builder.build()方法中提到过一句代码Platform.get()。在不使用addCallAdapterFactory的情况下。将会使用Platform的一种内部类，在Android环境下将会使用到Android类（这其实是个策略模式）

static class Android extends Platform {
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
return new ExecutorCallAdapterFactory(callbackExecutor);
}
static class MainThreadExecutor implements Executor {
// Looper.getMainLooper()就是为嘛响应会在主线程的原因
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post®;
}
}
}

上面的代码先稍微放一下，我们继续看retrofit.Bulider.build,其中有几句比较关键的代码

callFactory = new OkHttpClient();
callbackExecutor = platform.defaultCallbackExecutor();
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

结合Android类中的代码可以看出，其最后生成了ExecutorCallAdapterFactory类。虽然看到了CallAdapter.Factory，但是到底是哪里执行了enqueue方法呢？现在我们来看看retrofit.create的最后一句代码serviceMethod.callAdapter.adapt(okHttpCall)。

Converter

现在回到OkhttpCall.enqueue方法中，在其中还有一句重要的代码没有看，那就是response = parseResponse(rawResponse);,我们来看看这其中做了什么。

Response parseResponse(okhttp3.Response rawResponse) throws IOException
ResponseBody rawBody = rawResponse.body();
// Remove the body’s source (the only stateful object) so we can pass th
rawResponse = rawResponse.newBuilder()
.body(new NoContentResponseBody(rawBody.contentType(), rawBody.conte
.build();
…
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
T body = serviceMethod.toResponse(catchingBody);// 解析body，比如Gson解析
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
// If the underlying source threw an exception, propagate that rather
// a runtime exception.
catchingBody.throwIfCaught();
throw e;
}
}

ServiceMethod

R toResponse(ResponseBody body) throws IOException {
return responseConverter.convert(body);
}

可以看出parseResponse最终调用了Converter.convert方法。这里以常用的GsonConverterFactory为例。

GsonConverterFactory

@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
return new GsonResponseBodyConverter<>(gson, adapter);
}

GsonResponseBodyConverter

final class GsonResponseBodyConverter implements Converter<ResponseBody, T> {
private final Gson gson;
private final TypeAdapter adapter;
GsonResponseBodyConverter(Gson gson, TypeAdapter adapter) {
this.gson = gson;
this.adapter = adapter;
}
@Override public T convert(ResponseBody value) throws IOException {
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
return adapter.read(jsonReader);
} finally {
value.close();
}
}
}