上一篇Retrofi分析(二) 分析了下Retrofit和Service的创建,经过一系列的封装,最终返回的是GitHubService接口的代理实现类。下面就是调用实现类中的方法开始请求网络了。
Call<List<Repo>> call = service.listRepos("octocat");
try {
//同步请求
Response<List<Repo>> execute = call.execute();
List<Repo> body = execute.body();
} catch (IOException e) {
e.printStackTrace();
}
//异步请求
call.enqueue(new Callback<List<Repo>>() {
@Override
public void onResponse(Call<List<Repo>> call, Response<List<Repo>> response) {
Log.i("response",response.body().toString());
}
@Override
public void onFailure(Call<List<Repo>> call, Throwable t) {
Log.i("onFailure",t.toString());
}
});
先看同步请求:
上一篇我们知道生成的代理类封装进OkHttpCall中,因为OkHttpCall是实现retrofit2.Call接口的具体实现类,所以
call.execute()实际调用是OkHttpCall的execute()方法
@Override public Response<T> execute() throws IOException {
okhttp3.Call call;
synchronized (this) {
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 {
call = rawCall = createRawCall();
} catch (IOException | RuntimeException | Error e) {
throwIfFatal(e); // Do not assign a fatal error to creationFailure.
creationFailure = e;
throw e;
}
}
}
if (canceled) {
call.cancel();
}
return parseResponse(call.execute());
}
可以看到调用的createRawCall()l来获取一个okhttp3.Call,然后调用parseResponse()来获取retrofit2.Response。
createRawCall()方法:
private okhttp3.Call createRawCall() throws IOException {
okhttp3.Call call = serviceMethod.toCall(args);
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
调用serviceMethod的callFactory对象的toCall来获取一个okhttp3.Call call。传入方法的参数
okhttp3.Call toCall(@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;
if (argumentCount != handlers.length) {
throw new IllegalArgumentException("Argument count (" + argumentCount
+ ") doesn't match expected count (" + handlers.length + ")");
}
for (int p = 0; p < argumentCount; p++) {
handlers[p].apply(requestBuilder, args[p]);
}
return callFactory.newCall(requestBuilder.build());
}
方法注释:从方法参数构建HTTP请求。
首先创建了RequestBuilder ,RequestBuilder这个类,主要就是用于创建一个okHttp的Request,里面有很多方法用于设置Request的一些参数。
看有多少参数,并判断参数跟以前赋值的ParameterHandler的数量是不是一样
然后赋值一个ParameterHandler。它是一个参数处理类,循环调用它的apply方法。apply(RequestBuilder builder, T value)方法是抽象的,需要子类去实现。它的子类跟我们的的参数注解对应比如Path,Field,FieldMap,Part,PartMap,Query等
最后调用callFactory.newCall(requestBuilder.build());创建okhttp3.Call。第一篇中我们知道callFactory其实就是okhttp中的OkHttpClient对象。所以剩下的就是okhttp中的方法了。
parseResponse(call.execute())方法: 处理响应
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) {
// If the underlying source threw an exception, propagate that rather than indicating it was
// a runtime exception.
catchingBody.throwIfCaught();
throw e;
}
}
(1)Retrofit是先取出ResponseBody
(2)调用rawResponse.newBuilder()的build()方法构建一个* 空的 *响应的体的rawResponse。
(3)根据HTTP状体码来判断是否成功与失败
(4)如果成功且是204或者205则说明内容或者重复内容则不用关心响应体,则调用Response.success(null, rawResponse)方法
(5)最后,调用ServiceMethod实例的toResponse(catchingBody)方法来获取一个类型是T的对象
R toResponse(ResponseBody body) throws IOException {
return responseConverter.convert(body);
}
可以看到 ServiceMethod类的parseResponse() 方法内部调用的是responseConverter.convert(body),responseConverter是ServiceMethod.Builder的build()方法中获取的通过调用createResponseConverter()来获取的。这里我们使用的是GsonResponseBodyConverter所以看看它的convert方法。
@Override public T convert(ResponseBody value) throws IOException {
JsonReader jsonReader = gson.newJsonReader(value.charStream());
try {
return adapter.read(jsonReader);
} finally {
value.close();
}
}
这样就实现了网络响应体的反序列化。我们就可以通过response.body()来获取响应的对象了。
再看异步请求
因为OkHttpCall是实现retrofit2.Call接口的具体实现类,所以call.enqueue()实际调用是OkHttpCall的enqueue()方法。看下OkHttpCall的enqueue()方法的源码
@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 {
call = rawCall = createRawCall();
} catch (Throwable t) {
throwIfFatal(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) {
Response<T> response;
try {
response = parseResponse(rawResponse);
} catch (Throwable e) {
callFailure(e);
return;
}
try {
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
@Override public void onFailure(okhttp3.Call call, IOException e) {
callFailure(e);
}
private void callFailure(Throwable e) {
try {
callback.onFailure(OkHttpCall.this, e);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
可以看到里面最终还是调用了okhttp3.Call的异步的方法,异步操作跟同步的最大区别就是在子线程中执行,别的基本都一样。
将请求成功或者失败的结果通过回调接口回调到主线程。我们知道okhttp3.Call的异步请求的回调最后也是在子线程中。这里的回调直接回调到主线程中,我们就可以直接操作UI界面了。
总结:
Retrofit的流程,首选创建Retrofit,配置响应的参数,Retrofit总体使用的是外观模式,Retrofit持有所有子系统的引用;Retrofit有两个比较重要的两个Factory,一个是用来生成对应”Call”的CallAdapter的CallAdapterFactory;一个是用来进行响应数据转化(反序列化)的ConvertFactory;这两个都是list集合,用户可以自己进行添加
在我们自定义的Service中,每一个method一一对应一个ServiceMethod,而ServiceMethod持有一个Retrofit,前面两个Factory以及生成的Request的RequestBuilder,在okHttp中,Request需要自己进行定义创建,而Retrofit简化了这个操作,进行相应的封装,使用注解的方式来定义RequestBuilder相关参数信息;
具体的注解信息的解析则在parseMethodAnnotation()方法里面和parseParameterAnnotation()方法里面分别解析方法注解和参数注解。最终通过RequestBuilder来具体生成一个Request
RequestBuilder中持有okHttp中的Request.Builder类的引用,其创建Request的过程其实都是交给okHttp来操作的;生成的Request最终封装成一个OkHttpCall,
OkHttpCall则可以看做是对okHttp中Call的代理,同时对okHttp的返回Response进行解析,使用convertFactory将其解析为用户所期望的返回类型。
Retrofit内部使用了动态代理,方便了使用,通过retrofit.create返回的其实是一个动态代理类,所有具体的逻辑处理交给ServiceMethod来进行处理。
OK结束。