0. 前言
Retrofit中关于 [ 数据结构 <----> Model ] 之间的相互转换包括两个方面:
即我们进行源码分析的两个突破口
- 请求, 即 通过
@Body注解添加的自定义 Model --> RequestBody - 响应, 即 ResponseBody --> 自定义Model
这里的数据结构包含常用的json, xml , 最关键的是以上两个操作都是自动完成的, diao的不行, 根本不需要我们手动参与 自己进行解析转换;
那到底是如何做到的呢? 本文以json为例进行详细分析~
以上两个方面对应的http request和response 中的header 中的
content-type都为application/json
1. 用法
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(BuildConfig.HOST)
.client(httpClient)
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.build();
2. Convert 的简要说明
关于json转换部分 具体是通过addConverterFactory()传入我们需要的ConverFactory;
也就是说, 最终通过ConverterFactory创建convert 完成从responseBody-> Model的转换; 以下是Converter 接口以及Converter.Factory的源码
public interface Converter<F, T> {
T convert(F value) throws IOException;
abstract class Factory {
public @Nullable Converter<ResponseBody, ?> responseBodyConverter(Type type,
Annotation[] annotations, Retrofit retrofit) {
return null;
}
public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
return null;
}
public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
Retrofit retrofit) {
return null;
}
protected static Type getParameterUpperBound(int index, ParameterizedType type) {
return Utils.getParameterUpperBound(index, type);
}
protected static Class<?> getRawType(Type type) {
return Utils.getRawType(type);
}
}
}
其实看了以上convert接口的源码就明确了本文的最终目的, 就是convert.convert()方法具体是在哪调用的???
关于Convert的具体实现, 如下有很多, 支持市面上大部分开源库:
我们这里用GsonConverterFactory.
3.源码分析
(非核心代码用...忽略)
3.1 Retrofit 核心代码
Retrofit.java中最终用来创建service的create方法
public <T> T create(final Class<T> service) {
...
//通过动态代理创建service的代理对象
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
private final Platform platform = Platform.get();
@Override public Object invoke(Object proxy, Method method, @Nullable Object[] args)
throws Throwable {
...
//1. 创建并缓存ServiceMethod ,这个对象用来解析并包装我们在service中自定义的各种方法
ServiceMethod<Object, Object> serviceMethod = (ServiceMethod<Object, Object>) loadServiceMethod(method);
//2. call 的包装类
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
//3. 用我们传入的callAdapter 进行方法返回值的转换
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
这里使用了动态代理 创建了service接口的代理对象, 因此每次调用service对象中的方法, 本质就是执行 invocationHandler.invoke() 方法 (关于动态代理的原理这暂且不详谈);
因此每个方法执行的核心代码就上面123 三句话;
而关于ResponseBody/RequestBody <---> Model的转换就在OkHttpCall的execute()中;
@Override public Response<T> execute() throws IOException {
okhttp3.Call call;
...
synchronized (this) {
call = rawCall;
if (call == null) {
//注释1. request的创建从这里开始
call = rawCall = createRawCall();
}
}
...
//注释2. response的创建在这里
return parseResponse(call.execute());
}
3.2 Model --> RequestBody的转换
okHttpCall.execute()方法中注释1reateRawCall();创建call
private okhttp3.Call createRawCall() throws IOException {
//核心代码
Request request = serviceMethod.toRequest(args);
//这里的callFactory取得就是retrofit中的callFactory, 即httpClient
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
...
return call;
}
以上核心代码便是ServiceMethod中关于request的创建,
/** Builds an HTTP request from method arguments. */
Request toRequest(@Nullable Object... args) throws IOException {
RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
contentType, hasBody, isFormEncoded, isMultipart);
@SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;
int argumentCount = args != null ? args.length : 0;
...
//在这里, 遍历每个ParameterHandler对 service的方法参数进行处理
for (int p = 0; p < argumentCount; p++) {
handlers[p].apply(requestBuilder, args[p]);
}
return requestBuilder.build();
}
既然我们用的是@Body注解, 那么直接看Body 这个ParameterHandler的实现
static final class Body<T> extends ParameterHandler<T> {
private final Converter<T, RequestBody> converter;
Body(Converter<T, RequestBody> converter) {
this.converter = converter;
}
@Override void apply(RequestBuilder builder, @Nullable T value) {
...
RequestBody body;
//找到了
body = converter.convert(value);
builder.setBody(body);
}
}
那这个converter又是哪里来的? 其实就是最初我们构建retrofit的时候, 通过addConverterFactory()传进去的GsonConverterFactory创建的GsonRequestBodyConverter;
以上~
至于ParameterHandler的数组又是如何初始化的, 各种注解怎么解析的, 都在ServiceMethod这个类里, 慢慢欣赏~
这里只贴一下解析@Body的源码
else if (annotation instanceof Body) {
if (isFormEncoded || isMultipart) {
throw parameterError(p,
"@Body parameters cannot be used with form or multi-part encoding.");
}
if (gotBody) {
throw parameterError(p, "Multiple @Body method annotations found.");
}
Converter<?, RequestBody> converter;
try {
//看, 伟大的requestBodyConverter
converter = retrofit.requestBodyConverter(type, annotations, methodAnnotations);
} catch (RuntimeException e) {
// Wide exception range because factories are user code.
throw parameterError(e, p, "Unable to create @Body converter for %s", type);
}
gotBody = true;
return new ParameterHandler.Body<>(converter);
}
3.3 ResponseBody --> Model的转换
okHttpCall.execute()方法中的最后一句parseResponse(Response rawResp)创建了Rerofit2.Response<T>,
看到这个泛型 T 了吧, 其实里面封装了T body变量, 也就是我们最终拿到的model
(注意区别于okhttp中的Response)
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();
...
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
//核心代码
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;
}
}
下面来看T body = serviceMethod.toResponse(catchingBody);的实现
/** Builds a method return value from an HTTP response body. */
R toResponse(ResponseBody body) throws IOException {
return responseConverter.convert(body);
}
那上面这个responseConverter又是怎么来的呢? 具体弯弯绕绕就不看了, 其实就是我们在创建retrofit的时候,通过addConverterFactory()传进去的GsonConverterFactory创建的GsonResponseBodyConverter;
下面来看直接来看GsonResponseBodyConverter
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 {
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
return adapter.read(jsonReader);
} finally {
value.close();
}
}
}
如此, T 也就是我们自定义的Model最终转换完成;
至于okHttpCall.execute()又是在何时被谁调用的在这里就不继续深究了, 因为不同的callAdapter有不同的实现, 已超出本文探究范围, 要具体探究的话可以看invoke()中的第3句核心代码serviceMethod.callAdapter.adapt(okHttpCall);
ps. RxJava的相关实现在RxJavaCallAdapter
