本平台的文章更新会有延迟，大家可以关注微信公众号-顾林海，包括年底前会更新kotlin由浅入深系列教程，目前计划在微信公众号进行首发，如果大家想获取最新教程，请关注微信公众号，谢谢!
在上一节《Android小知识-剖析Retrofit中ServiceMethod相关参数以及创建过程》介绍了动态代理类中三行核心代码的第一行，通过loadServiceMethod方法获取ServiceMethod对象，在loadServiceMethod方法中先会检查缓存集合中是否有对应网络请求接口方法的ServiceMethod对象，如果不存在就通过Builder模式创建，同时介绍了ServiceMethod内部的一些成员变量，其实ServiceMethod就是对网络请求接口内部一个个方法的封装，通过解析方法内部或方法上的注解来封装ServiceMethod对象。这节来介绍三行核心代码的剩余两行。
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 {
...
//核心代码1
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
//核心代码2
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
//核心代码3
return serviceMethod.adapt(okHttpCall);
}
});
}
在核心代码2处创建OkHttpCall，OkHttpCall是Call的实现类，在Retrofit中内部是通过OkHttp来进行网络的请求，这个OkHttpCall就是对OkHttp请求的封装。
final class OkHttpCall<T> implements Call<T> {
....
private @Nullable okhttp3.Call rawCall;
OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {
this.serviceMethod = serviceMethod;
this.args = args;
}
}
在OkHttpCall中可以看到rawCall，它是OkHttp的Call，这也验证之前所说的内部会通过OkHttp来实现网络请求，OkHttpCall构造函数传入两个参数，serviceMethod对象和args网络请求参数，接着看核心代码3。
return serviceMethod.adapt(okHttpCall);
serviceMethod的adapt方法中会调用callAdatper的adapter方法，通过适配器的adapt方法来将OkHttpCall转换成其他平台使用的对象，这个callAdapter是在创建serviceMethod时通过构建者模式创建的，它代表网络请求的适配器，这里使用的RxJava平台。
回到一开始的实例代码：
private void initRetrofit() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://icould.glh/")
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.build();
NetworkInterface networkInterface = retrofit.create(NetworkInterface.class);
Map<String, String> params = new HashMap<>();
params.put("newsId", "1");
params.put("token", "yud133f");
Call call = networkInterface.getNewsDetails(params);
call.enqueue(new Callback() {
@Override
public void onResponse(Call call, Response response) {
System.out.println(response.body());
}
@Override
public void onFailure(Call call, Throwable t) {
System.out.println("请求错误");
}
});
}
通过networkInterface接口调用getNewsDetails是不行的，因此在Retrofit的create获取网络接口的动态代理，在执行networkInterface的getNewDetails方法时，通过动态代理拦截，并执行动态代理对象内InvocationHandler中的invoke方法，将OkHttpCall转换成RxJava平台的适用的Call，而这个OkHttpCall对象是对OkHttp网络库的封装，最后返回OkHttpCall类型的Call对象，有了这个Call对象就可以进行同步或异步请求，OkHttpCall内提供了同步请求方法execute和异步请求方法enqueue，接着下来重点分析这两个方法。
在Retrofit同步请求流程中，首先需要对网络请求接口中方法以及参数进行解析，通过ParameterHandler进行解析，然后根据ServiceMethod对象创建OkHttp的Request对象，ServiceMethod对象内部包含了网络请求的所有信息，它是对网络接口方法的封装，有了Request对象后就可以通过OkHttp这个库来进行网络请求，最后解析服务端给客户端返回的数据，通过converter数据转换器来完成数据的转换。
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());
}
下面贴出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;
}
}
...
}
...
}
上面代码中一开始创建了一个OkHttp的call对象，下面是一个同步代码块，通过判断executed是否执行过通过请求，如果执行过就会抛出异常，接着判断creationFailure，不为null时，判断异常类型并抛出异常，execute方法的前段部分就是对异常的判断。
@Override public Response<T> execute() throws IOException {
okhttp3.Call call;
synchronized (this) {
...
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;
}
}
}
...
}
当没有任何异常时，将rawCall也就是OkHttp的原生call赋值给局部变量call，当call为null时，通过createRawCall方法创建OkHttp的Call对象以及Request。
进入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的toCall方法将传入的请求参数转换成Call对象。
进入serviceMethod的toCall方法：
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;
...
for (int p = 0; p < argumentCount; p++) {
handlers[p].apply(requestBuilder, args[p]);
}
return callFactory.newCall(requestBuilder.build());
}
RequestBuilder内部保存着网络请求的相关参数，接着在for循环中通过ParameterHandler对参数进行解析，最后通过callFactory的newCall创建OkHttp的Call对象，newCall内部传入的是Request对象，通过requestBuilder.build()创建Request对象，到这里将OkHttp的Call对象返回给execute方法内部的成员变量call以及OkHttpCall的成员变量rawCall。
@Override public Response<T> execute() throws IOException {
okhttp3.Call call;
...
if (canceled) {
call.cancel();
}
return parseResponse(call.execute());
}
有了OkHttp的Call之后，就通过call.execute()进行阻塞式的同步请求，并将返回的Response传入parseResponse方法中。
进入parseResponse方法：
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
...
try {
T body = serviceMethod.toResponse(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
...
}
}
只看核心代码，通过调用serviceMethod的toResponse方法返回body，进入toResponse方法，看它到底做了哪些操作。
R toResponse(ResponseBody body) throws IOException {
return responseConverter.convert(body);
}
原来是调用了数据转换器将OkHttp返回的Response转换成Java对象，这里我们使用的Gson，也就是通过Gson将服务器返回的数据转换成我们需要的Java对象，最后通过Response的success方法将返回的Java对象封装成Response。
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
...
return Response.success(body, rawResponse);
}
进入Response的success方法：
public static <T> Response<T> success(@Nullable T body, okhttp3.Response rawResponse) {
...
return new Response<>(rawResponse, body, null);
}
返回创建好的Response，将body也就是我们的Java对象传过去。
Response的构造函数：
private Response(okhttp3.Response rawResponse, @Nullable T body,
@Nullable ResponseBody errorBody) {
this.rawResponse = rawResponse;
this.body = body;
this.errorBody = errorBody;
}
到这里大家应该很熟悉了，我们利用Retrofit进行网络的同步或异步请求，最终会返回一个Response对象并通过response.body来获取结果，这个body就是通过转换器转换好的Java对象。
接下来分析异步请求：
call.enqueue(new Callback() {
@Override
public void onResponse(Call call, Response response) {
System.out.println(response.body());
}
@Override
public void onFailure(Call call, Throwable t) {
System.out.println("请求错误");
}
});
执行异步请求的流程和同步类似，只不过异步请求的结果是通过回调来传递的，异步是通过enqueue方法来执行的，而这个Call的实现类是OkHttpCall，进入OkHttpCall的enqueue方法。
OkHttpCall的enqueue方法（上半部分）：
@Override public void enqueue(final Callback<T> callback) {
...
okhttp3.Call call;
...
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;
}
}
}
...
}
可以发现enqueue的上半部分与上面介绍同步请求时是一样的，创建OkHttp的Call，并检查相关异常，如果call为null，就通过createRawCall方法创建OkHttp的Call以及请求所需要的Request。
OkHttpCall的enqueue方法（下半部分）：
@Override public void enqueue(final Callback<T> callback) {
...
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();
}
}
...
});
}
上面这段代码不用我讲，大家也应该知道就是通过OkHttp的Call的enqueue方法进行异步请求，关于OkHttp相关知识可以阅读之前写的OkHttp分析的相关系列教程，在OkHttp的Call的enqueue方法的回调方法onResponse方法中，将返回的Response通过parseResponse方法转换成Java对象并返回Retrofit的Response对象，通过前面传入的Callback对象将Response回调给客户端。
到这里关于Retrofit网络请求框架的封装就讲解完毕了！
