OkHttp的同步和异步请求
Retrofit在使用OkHttpCall进行网络请求的时候,里面其实就是封装了OkHttp来进行网络请求。在分析OkHttpCall之前,先看下OkHttp怎么来实现同步和异步请求。
1)同步请求
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url("http://www.baidu.com").build();
final Call call = client.newCall(request);
new Thread() {
@Override
public void run() {
try {
Response response = call.execute();
Log.d(TAG, "code = " + response.code() + " , msg = " + response.body().string());
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
2)异步请求
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url("http://www.baidu.com").build();
Call call = client.newCall(request);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (response.isSuccessful()) {
Log.d(TAG, "code = " + response.code() + " , msg = " + response.body().string());
}
}
});
从上面的代码中看到就包括下面四个步骤:
1)创建一个OkHttpClient对象client。
2)通过Request对象进行配置网络请求参数。
3)通过client对象创建出Call
4)调用call中的同步请求或异步请求的方法
那么我们在Retrofit中的OkHttpCall实际上就是对这些过程进行了封装。进入源码学习下
1、实例化
在Retrofit的create()中通过动态代理创建接口实例的时候,会取实例化OkHttpCall
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
查看源码,就是将OkHttpCall里面的serviceMethod和args,其中serviceMethod就是网络请求所需要的数据,args就是我们创建的网络接口的方法的参数。
OkHttpCall(ServiceMethod<T> serviceMethod, Object[] args) {
this.serviceMethod = serviceMethod;
this.args = args;
}
2、成员变量
private final ServiceMethod<T> serviceMethod;
private final Object[] args;
//该请求是否被取消标记位
private volatile boolean canceled;
//OkHttp请求的实例
private okhttp3.Call rawCall;
private Throwable creationFailure; // Either a RuntimeException or IOException.
//是否执行的标记位
private boolean executed;
我们可以看到里面存在的rawCall就是OkHttp请求的实例。
3、同步请求
@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 {
throw (RuntimeException) creationFailure;
}
}
//将call进行赋值,在第一次调用的时候,会检查该实例是否创建,如果创建则直接赋值使用,如果没有创建则通过下面的方法进行创建
call = rawCall;
if (call == null) {
try {
call = rawCall = createRawCall();
} catch (IOException | RuntimeException e) {
creationFailure = e;
throw e;
}
}
}
//如果被用户取消了请求,则调用call的取消方法来取消该次请求
if (canceled) {
call.cancel();
}
//直接返回
return parseResponse(call.execute());
}
从源码中可以看到,使用synchronized同步锁来保证每次只有一个线程可以访问该方法,executed标记位用来标记每次请求只能调用一次。同时我们会将rawCall的实例赋值给局部变量call,第一次rawCall并没有被赋值,则通过CreateRawCall()进行创建rawCall实例,否则直接赋值给局部变量call即可。最后调用call.execute()执行OkHttp的execute()方法,将OkHttp返回的数据转换成Retrofit的所需要的数据格式。
我们看下rawCall的创建过程和返回数据的转换过程。
1)createRawCall()
private okhttp3.Call createRawCall() throws IOException {
Request request = serviceMethod.toRequest(args);
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}
首先就是根据我们之前创建的网络接口转换成OkHttp的Request请求对象。 对应OkHttp请求实例中的
Request request = new Request.Builder().url("http://www.baidu.com").build();
然后通过serviceMethod来获取OkHttp的实例。从Retrofit的源码我们可以了解到,
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
//。。。。代码省略。。。。
}
在Retrofit.Builder的build()这里的callFactory就是实例化OkHttp中的OkHttpClient,那么对应这个newCall()即OkHttpClient中对应的方法。也就是执行了我们之前的OkHttp例子的
OkHttpClient client = new OkHttpClient();
final Call call = client.newCall(request);
2)cancel()
public void cancel() {
canceled = true;
okhttp3.Call call;
synchronized (this) {
call = rawCall;
}
if (call != null) {
call.cancel();
}
就是调用的OkHttp的cancel(),不多解释
3)parseResponse(call.execute())
在该方法中调用call.execute()来通过OkHttp请求网络,最后将OkHttp的response转换成Retrofit的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) {
return Response.success(null, rawResponse);
}
ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
//将OkHttp返回的内容根据设置的数据转换器的格式转换成Retrofit的返回结果
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;
}
}
上述3步已经完成了同步请求。
4、异步请求
@Override public void enqueue(final Callback<T> callback) {
if (callback == null) throw new NullPointerException("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) {
failure = creationFailure = t;
}
}
}
//异常情况处理
if (failure != null) {
callback.onFailure(this, failure);
return;
}
//被取消了请求
if (canceled) {
call.cancel();
}
//调用OkHttp的call的方法进行请求数据
call.enqueue(new okhttp3.Callback() {
@Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
throws IOException {
Response<T> 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<T> response) {
try {
callback.onResponse(OkHttpCall.this, response);
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
同同步请求一致,都是先获取到OkHttp的实例,然后分别调用OkHttp的实例对应的异步请求的方法来完成请求。
总结
OkHttpCall在Retrofit中其实就是采用装饰模式对OkHttp的进行包装:
1)OkHttpClient是在通过Builder来创建Retrofit实例的时候,在build()方法中进行实例化,设置到Retrofit的默认的callFactory;
2)Request的创建在于我们调用OkHttpCall的enqueue()或者execute()的方法里面,创建OkHttp对象的时候,通过serviceMethod的toRequest(),将定义的网络接口类转换成OkHttp的Request对象。同时通过调用callFactory.newCall(),实际上就是调用了OkHttpClient的newCall()来创建出call实例
3)最后我们就通过OkHttpCall对外提供的同步或者异步的方法来进行调用OkHttp对应的方法。
后面要在分析下OkHttp的源码,学习源码就是去学习别人的一些设计思想。