Retrofit是Square团队对网络请求库Okhttp的进一步封装,趁着刚分析完Okhttp源码的热乎劲顺带着把Retrofit源码又过了一遍。Okhttp源码分析戳这里
Retrofit基本使用
老规矩分析源码从最简单的流程来,一个简单的Retrofit请求如下:
OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://news.baidu.com/")
.client(okHttpClient)
.build();
ApiService mApiService = retrofit.create(ApiService.class);
Call<ResponseBody> call = mApiService.getData();
// //同步请求
// call.execute();
//异步请求
call.enqueue(new Callback<ResponseBody>() {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
try {
Log.e("tag", "请求成功:" + response.body().string());
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
Log.e("tag", "请求失败");
t.printStackTrace();
}
});
可以看到一个最基本的Retrofit请求仅仅需要创建OkhttpClient和Service两个对象,而仅使用Okhttp不但要创建OkhttpClient、Call,而且每次使用都要配置一点点配置Request,Retrofit提供了api接口的统一配置位置–>Service。
Retrofit请求流程
可以大致分为3个步骤:
1> 通过Java动态代理创建Service代理对象
2>通过代理对象创建请求,调用代理方法返回Call对象
3>通过Call对象发起请求,返回响应结果
备注:这里简单考虑,先不管CallAdapter直接返回请求结果的流程
先上一张Retrofit请求流程图,然后再具体分析:
1.动态代理创建Service代理对象
如下面代码所示,熟悉的Java动态代理常见代码,Retrofit的create(Service.class)通过动态代理创建了Service的代理对象:
public <T> T create(final Class<T> 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 {
......
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.adapt(okHttpCall);
}
});
}
2.代理对象通过invoke()调用代理方法
继续看上面代码匿名类invoke()方法的实现,首先调用loadServiceMethod(method)创建了一个ServiceMethod对象,先看一下这个方法的实现:
ServiceMethod<?, ?> loadServiceMethod(Method method) {
ServiceMethod<?, ?> result = serviceMethodCache.get(method);
if (result != null) return result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
//创建ServiceMethod,内部读取了method方法信息以及各种注解配置,将信息保存在创建ServiceMethod对象中
result = new ServiceMethod.Builder<>(this, method).build();
//将创建ServiceMethod对象缓存起来,下次直接使用
serviceMethodCache.put(method, result);
}
}
return result;
}
方法内部直接通过Builder模式创建了个ServiceMethod对象,并加入到了缓存中,接着看ServiceMethod是怎么Build的
Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
//获取被代理方法注解
this.methodAnnotations = method.getAnnotations();
//获取被代理方法参数类型
this.parameterTypes = method.getGenericParameterTypes();
//获取被代理方法参数注解
this.parameterAnnotationsArray = method.getParameterAnnotations();
}
public ServiceMethod build() {
//创建CallAdapter
callAdapter = createCallAdapter();
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?");
}
//获取响应数据转换器
responseConverter = createResponseConverter();
//遍历方法解析注解
for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
......
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);
}
......
return new ServiceMethod<>(this);
}
看一下创建Builder的过程,它的构造方法内部通过被代理方法method引用读取了方法的注解、参数类型、参数注解等一系列信息。
再看一下build()方法,我们先不去管CallAdapter和Converter的逻辑,build()内部首先遍历了并解析了方法注解,获取请求Method、Header等一系列的信息,然后又遍历了参数及参数注解获取参数信息,统一保存在ServiceMethod对象中
具体的解析过程比较长,主要是一些逻辑判断,也没有什么比较复杂的逻辑,这里不再具体分析,简单看一下下面的简略代码就好:
//解析方法注解
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);
} else if (annotation instanceof HEAD) {
......
} else if (annotation instanceof POST) {
......
}
}
//解析参数注解
private ParameterHandler<?> parseParameterAnnotation(
int p, Type type, Annotation[] annotations, Annotation annotation) {
if (annotation instanceof Url) {
......
} else if (annotation instanceof Path) {
......
return new ParameterHandler.Path<>(name, converter, path.encoded());
} else if (annotation instanceof Query) {
......
} else if (annotation instanceof Header) {
......
}
......
return null; // Not a Retrofit annotation.
}
至此ServiceMethod对象创建完毕,我们回到匿名类InvokeHandler的invoke()方法中。接下来Service对象又作为构造方法参数创建了OkhttpCall对象,最后serviceMethod调用adapt(okhttpCall)将结果最终返回。
T adapt(Call<R> call) {
return callAdapter.adapt(call);
}
可以看到adapt()内部实际上是通过callAdapter调用了同名方法,callAdapter接口CallAdapter的实现类对象,使用这可以自己实现CallAdapter接口,这里是典型的策略模式的使用。
回到前面我们分析ServiceMethod的build()方法中有这么一行代码:
callAdapter = createCallAdapter();
跟踪代码,它最终会走到Retrofit类的nextCallAdapter()方法,遍历callAdapterFactories集合通过工厂类获取到callAdapter实例
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
......
int start = callAdapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = callAdapterFactories.size(); i < count; i++) {
CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
.......
}
文章开头示例并没有添加任何的CallAdapter.Factory,其实Retrofit在通过build()模式最后构建的时候添加了一个默认的工厂类DefaultCallAdapterFactory,它的adapt()方法没有对Call对象做任何处理直接返回原始对象,即OkhttpCall对象,具体实现如下:
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();
@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
//默认的CallAdapter匿名实现,adapt()方法直接返回了OkhttpCall
return new CallAdapter<Object, Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public Call<Object> adapt(Call<Object> call) {
return call;
}
};
}
}
梳理一下整个代理方法逻辑:
其实是读取被代理方法的注解、参数等信息,保存到ServiceMethod对象中(ServiceMethod其实就是一个各种请求配置的解析类和载体),创建Retrofit的Call对象OkhttpCall并返回给代理方法。
这里我们还可以看到代理方法的返回值类型取决于CallAdapter的adapt()方法的返回值类型。我们结合RxJava使用所接收到的Obserable类型,也一定是这里adapt()中实现其数据类型转换的,顺便上一下RxJava2CallAdapter的代码:
@Override public Object adapt(Call<R> call) {
Observable<Response<R>> responseObservable = isAsync
? new CallEnqueueObservable<>(call)
: new CallExecuteObservable<>(call);
Observable<?> observable;
if (isResult) {
observable = new ResultObservable<>(responseObservable);
} else if (isBody) {
observable = new BodyObservable<>(responseObservable);
} else {
observable = responseObservable;
}
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();
}
return observable;
}
3.Call对象发起请求并获取响应结果
同步请求:
OkhttpCall的execute方法内部其实是创建了Okhttp的Call对象执行了其execute()方法,请求逻辑转到了Okhttp中执行
@Override public Response<T> execute() throws IOException {
okhttp3.Call call;
synchronized (this) {
......
if (call == null) {
try {
//创建Okhttp的Call对象
call = rawCall = createRawCall();
} catch (IOException | RuntimeException | Error e) {
throwIfFatal(e); // Do not assign a fatal error to creationFailure.
creationFailure = e;
throw e;
}
}
}
......
//通过Call对象真正发起请求
return parseResponse(call.execute());
}
异步请求同理,仅仅是把Okhttp的异步调用封装了一下,和同步请求同样通过parseResponse()对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();
//处理一些常见的状态码逻辑
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);
}
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
T body = serviceMethod.toResponse(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
catchingBody.throwIfCaught();
throw e;
}
}
从方法内部可以很清晰的看到,Retrofit对Okhttp请求的Response进行了初步解析,帮我们处理了一些常见的状态码逻辑,最后调用serviceMethod.toResponse(catchingBody)对Response进行了进一步的转换
R toResponse(ResponseBody body) throws IOException {
return responseConverter.convert(body);
}
这里又涉及到Converter的概念,在这里它是一个转换器,用于把响应结果Response进行处理加工转换成其他类型的对象。它是一个接口,我们同样可以实现自己的转换策略,开源库考虑到不同使用场景的扩展性,策略设计模式还是很常见的。
与CallAdapter逻辑相似Retrofit在build()构建的时候同样给我们创建了默认的Converter工厂类对象:BuiltInConverters。默认的的Converter同样没有对okhttp的Response做任何处理,我们当然也可以自定义Converter对其进行加工,参考GsonConverterFactory实现:
//默认的ResponseConverter
static final class StreamingResponseBodyConverter implements Converter<ResponseBody, ResponseBody> {
static final StreamingResponseBodyConverter INSTANCE = new StreamingResponseBodyConverter();
@Override public ResponseBody convert(ResponseBody value) {
return value;
}
}
//GsonConverter
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 {
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();
}
}
}
在OkhttpCall的parseResponse()方法最后,Okhttp响应结果Response会被进一步封装成Retrofit的Response,同步请求直接返回,异步请求通过回调返回。
至此,整个Retrofit执行流程分析完毕。