我们先洗个请求的例子，如下
private void retrofitTest() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://wwwcom/")
.addConverterFactory(ScalarsConverterFactory.create())
.build();
ApiService service = retrofit.create(ApiService.class);
Call<String> call = service.getBlog("https://www.baidu.com", "abc");
call.enqueue(new Callback<String>() {
@Override
public void onResponse(Call<String> call, Response<String> response) {
}
@Override
public void onFailure(Call<String> call, Throwable t) {
}
});
}
interface ApiService {
@GET
Call<String> getBlog(
@Url String url,
@Query("type") int type
);
@FormUrlEncoded
@POST()
Call<String> getBlog1(
@Url String url,
@Field("type") String type,
@Field("address") String address
);
}例子是个get请求，ApiService 类中，使用了 @GET 注解，形参中使用了 @Url 和 @Query 注解，一旦使用 @Url，则以它对应的值为准，Retrofit.Builder() 中通过 baseUrl() 设置的基准url就不使用了；如果我们使用post请求，用表格形式，接口中方法除了使用 @POST() 注解外，还要使用 @FormUrlEncoded 注解，对应的形参中要有 @Field 或 @FieldMap 其中之一，否则会报错。
Retrofit 是载体，我们看看它的代码，首先是个 Builder 模式，构造方法中有个参数
public Builder() {
this(Platform.get());
converterFactories.add(new BuiltInConverters());
}看看 Platform.get() 对应的值
private static final Platform PLATFORM = findPlatform();
static Platform get() {
return PLATFORM;
}
private static Platform findPlatform() {
try {
Class.forName("android.os.Build");
if (Build.VERSION.SDK_INT != 0) {
return new Android();
}
} catch (ClassNotFoundException ignored) {
}
...
return new Platform();
}我们是在 Android 设备上使用该网络库，此时对应的就是 new Android() 生成的对象，看看它是什么
static class Android extends Platform {
@Override public Executor defaultCallbackExecutor() {
return new MainThreadExecutor();
}
@Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
return new ExecutorCallAdapterFactory(callbackExecutor);
}
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());
@Override public void execute(Runnable r) {
handler.post(r);
}
}
}它里面有两个方法，返回的对象分别是 MainThreadExecutor 和 ExecutorCallAdapterFactory。MainThreadExecutor 实现了 Executor 接口，方法中通过一个对应UI线程的Handler，把runnable 切换到主线程中。 retrofitTest() 中，如果在 Retrofit.Builder() 时，直接调用了 build() 方法
public Retrofit build() {
if (baseUrl == null) {
throw new IllegalStateException("Base URL required.");
}
okhttp3.Call.Factory callFactory = this.callFactory;
if (callFactory == null) {
callFactory = new OkHttpClient();
}
Executor callbackExecutor = this.callbackExecutor;
if (callbackExecutor == null) {
callbackExecutor = platform.defaultCallbackExecutor();
}
List<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
List<Converter.Factory> converterFactories = new ArrayList<>(this.converterFactories);
return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
callbackExecutor, validateEagerly);
}第一步就抛异常，所以 baseUrl 必须设置，按照规范，以反斜线结尾；如果没设置 callFactory，则在这里new一个OkHttpClient对象，它是 Okhttp 中的类，我们如果要定制，就在外部创建好，然后通过 callFactory() 方法设置进来；callbackExecutor 也是同样道理，默认使用就是 MainThreadExecutor 这个类；adapterFactories 是个空集合，这里往里面添加了一个对象，就是 ExecutorCallAdapterFactory，它的构造方法中接收了 MainThreadExecutor 这个类；
final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
final Executor callbackExecutor;
ExecutorCallAdapterFactory(Executor callbackExecutor) {
this.callbackExecutor = callbackExecutor;
}
@Override
public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
if (getRawType(returnType) != Call.class) {
return null;
}
final Type responseType = Utils.getCallResponseType(returnType);
return new CallAdapter<Call<?>>() {
@Override public Type responseType() {
return responseType;
}
@Override public <R> Call<R> adapt(Call<R> call) {
return new ExecutorCallbackCall<>(callbackExecutor, call);
}
};
}
}
注意它内部 get() 方法返回的对象是 CallAdapter 类型，在这里是 new 出的一个对象，它里面又有两个方法，其中创建 ExecutorCallbackCall 对象时把 callbackExecutor 和 call传递了进去。
converterFactories 集合在 Builder 的构造方法中传递了一个 BuiltInConverters 对象，它是 Converter.Factory 的子类，里面有三个方法，根据名字可知，responseBodyConverter() 是把返回的 ResponseBody 对象转换为定义的对象 requestBodyConverter() 是把请求的对象转换为 RequestBody，stringConverter() 是把请求参数转换为 String 类型，以上三个方法不一定都会用到。我们也可以继承 Converter.Factory ，根据自己的业务逻辑，来自定义自己的类。最后用这些参数创建一个 Retrofit 对象。
Retrofit 构造方法到此为止，接着看看 create() 方法做了什么
public <T> T create(final Class<T> service) {
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(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, Object... args)
throws Throwable {
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
ServiceMethod serviceMethod = loadServiceMethod(method);
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
这是个动态代理，动态代理的底层原理还是反射；这一步仅仅是通过传入一个class文件，返回一个对应的对象，动态代理的 InvocationHandler 中的方法并没有执行，service.getBlog("https://www.baidu.com", "abc") 执行这行代码时，才会触发 InvocationHandler 中的 invoke(Object proxy, Method method, Object... args) 方法，此时 proxy 代表的是 retrofit 对象，method 代表的是对应方法 getBlog(),args这个可变参数对应的是 method 方法中的参数，在这里对应的是 "https://www.baidu.com" 和 "abc" 这两个参数。动态代理的常规用法是传入一个代理对象，通过 Proxy 创建对象并返回，然后再外部调用方法，触发invoke() 方法中通过拿到的参数进行反射来触发要调用的方法。 Retrofit 中的这个动态代理没按照常规的逻辑执行，来看看它都做了什么，先看 loadServiceMethod(method) 方法
ServiceMethod loadServiceMethod(Method method) {
ServiceMethod result;
synchronized (serviceMethodCache) {
result = serviceMethodCache.get(method);
if (result == null) {
result = new ServiceMethod.Builder(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
这个里面是个Map缓存，如果有，则复用；如果没有，则创建，这里又引申出一个比较重要的类 ServiceMethod，它也是采用了 Builder 模式，看看其方法
public Builder(Retrofit retrofit, Method method) {
this.retrofit = retrofit;
this.method = method;
this.methodAnnotations = method.getAnnotations();
this.parameterTypes = method.getGenericParameterTypes();
this.parameterAnnotationsArray = method.getParameterAnnotations();
}上一篇文章中讲过方法中 Method 中这几个方法的作用，这里不再重复，看看 build() 方法
public ServiceMethod build() {
callAdapter = createCallAdapter();
responseType = callAdapter.responseType();
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];
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
...
return new ServiceMethod<>(this);
}此方法省略了一些校验的代码，有兴趣的可以看一下源码，这里讲一下大框架流程。createCallAdapter() 方法中获取的是其实就是上面的 ExecutorCallAdapterFactory 中创建的对象
private CallAdapter<?> createCallAdapter() {
Type returnType = method.getGenericReturnType();
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.callAdapter(returnType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(e, "Unable to create call adapter for %s", returnType);
}
}Retrofit:
public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}
public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {
int start = adapterFactories.indexOf(skipPast) + 1;
for (int i = start, count = adapterFactories.size(); i < count; i++) {
CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}
...
throw new IllegalArgumentException(builder.toString());
}returnType 是方法返回值的类型，adapterFactories 就是Retrofit中创建时添加对象的集合，此时遍历集合，通过 get() 方法来判断是否是需要的 CallAdapter，ExecutorCallAdapterFactory 中的 get() 方法返回的对象是 new 出来的 CallAdapter 对象，不为空，所以就是它了。
createResponseConverter() 方法返回对象 responseConverter，它的作用是响应体转换器，看看它的代码
private Converter<ResponseBody, T> createResponseConverter() {
Annotation[] annotations = method.getAnnotations();
try {
return retrofit.responseBodyConverter(responseType, annotations);
} catch (RuntimeException e) { // Wide exception range because factories are user code.
throw methodError(e, "Unable to create converter for %s", responseType);
}
}
Retrofit:
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
return nextResponseBodyConverter(null, type, annotations);
}
public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory skipPast,
Type type, Annotation[] annotations) {
int start = converterFactories.indexOf(skipPast) + 1;
for (int i = start, count = converterFactories.size(); i < count; i++) {
Converter<ResponseBody, ?> converter =
converterFactories.get(i).responseBodyConverter(type, annotations, this);
if (converter != null) {
return (Converter<ResponseBody, T>) converter;
}
}
...
throw new IllegalArgumentException(builder.toString());
}这个与上面的原理类似，由于该集合中有 BuiltInConverters 和 ScalarsConverterFactory 两个对象，一个是系统自带的，一个是我们方法中设置进去的，这时候会遍历，根据 responseBodyConverter() 返回值来确定使用哪个，BuiltInConverters 中的 Type 类型只支持两种，即 ResponseBody 和 Void，而我们这个接口中使用的返回值类型是 String，所以这个里面没有合适的，继续看 ScalarsConverterFactory，它里面支持 String 类型，返回的是 ScalarRequestBodyConverter 对象。
final class ScalarRequestBodyConverter<T> implements Converter<T, RequestBody> {
static final ScalarRequestBodyConverter<Object> INSTANCE = new ScalarRequestBodyConverter<>();
private static final MediaType MEDIA_TYPE = MediaType.parse("text/plain; charset=UTF-8");
private ScalarRequestBodyConverter() {
}
@Override public RequestBody convert(T value) throws IOException {
return RequestBody.create(MEDIA_TYPE, String.valueOf(value));
}
}接着是遍历 methodAnnotations 这个方法上的注解数组，我们例子中只有一个 @GET 注解，看看 parseMethodAnnotation() 方法
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 FormUrlEncoded) {
if (isMultipart) {
throw methodError("Only one encoding annotation is allowed.");
}
isFormEncoded = true;
}
}
private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
this.httpMethod = httpMethod;
this.hasBody = hasBody;
if (value.isEmpty()) {
return;
}
...
}这个方法就是确认请求头中请求格式，并做一些属性赋值，做逻辑判断。继续往下看，parameterAnnotationsArray 对应的形参中的注解，ParameterHandler 是个接口，这里是为了适配各种类型，注意 parseParameter() 方法
private ParameterHandler<?> parseParameter(int p, Type parameterType, Annotation[] annotations) {
ParameterHandler<?> result = null;
for (Annotation annotation : annotations) {
ParameterHandler<?> annotationAction = parseParameterAnnotation(p, parameterType, annotations, annotation);
if (annotationAction == null) {
continue;
}
if (result != null) {
throw parameterError(p, "Multiple Retrofit annotations found, only one allowed.");
}
result = annotationAction;
}
if (result == null) {
throw parameterError(p, "No Retrofit annotation found.");
}
return result;
}
这段代码的意思是，Call<String> getBlog(@Url String url,@Query("type") int type) 这个方法中，以它为例子，parameterAnnotationsArray 数组长度为2，第一个数组中对应的是 @Url String url 这个形参中的 @Url 注解，此时，p为0，parameterType 为String，annotations 数组中只有一个对象，指的是@Url，再通过 parseParameterAnnotation() 方法来生成
ParameterHandler 对象
private ParameterHandler<?> parseParameterAnnotation(
int p, Type type, Annotation[] annotations, Annotation annotation) {
if (annotation instanceof Url) {
...
gotUrl = true;
if (type == HttpUrl.class || type == String.class || type == URI.class
|| (type instanceof Class && "android.net.Uri".equals(((Class<?>) type).getName()))) {
return new ParameterHandler.RelativeUrl();
} else {
throw parameterError(p,
"@Url must be okhttp3.HttpUrl, String, java.net.URI, or android.net.Uri type.");
}
} else if (annotation instanceof Query) {
Query query = (Query) annotation;
String name = query.value();
boolean encoded = query.encoded();
Class<?> rawParameterType = Utils.getRawType(type);
gotQuery = true;
if (Iterable.class.isAssignableFrom(rawParameterType)) {
...
} else {
Converter<?, String> converter = retrofit.stringConverter(type, annotations);
return new ParameterHandler.Query<>(name, converter, encoded);
}
} else if (annotation instanceof Field) {
if (!isFormEncoded) {
throw parameterError(p, "@Field parameters can only be used with form encoding.");
}
Field field = (Field) annotation;
String name = field.value();
boolean encoded = field.encoded();
gotField = true;
Class<?> rawParameterType = Utils.getRawType(type);
if (Iterable.class.isAssignableFrom(rawParameterType)) {
...
} else {
Converter<?, String> converter = retrofit.stringConverter(type, annotations);
return new ParameterHandler.Field<>(name, converter, encoded);
}
}
...
return null; // Not a Retrofit annotation.
}这是简化后的代码，以 @GET、@Query、@Field 为例，方法形参 type 代表的是参数类型，annotations 是注解数组，只有一个对象，annotation 就是我们具体的注解，即 GET、Query、Field 等等，我们先看 Url，一堆校验后走到了 if 判断，此时我们参数是String类型，所以retrun的对象是 RelativeUrl，它是 ParameterHandler 的子类；Query 中，根据注解获取对应的值，query.value() 对应的就是type字符串，query.encoded() 默认是false，调用 retrofit.stringConverter(type, annotations) 获取对象，此时会重新遍历 converterFactories 集合，通过调用 stringConverter() 方法获取对应的值，这一次 BuiltInConverters 对象符合条件，返回的是 StringConverter
static final class StringConverter implements Converter<String, String> {
static final StringConverter INSTANCE = new StringConverter();
@Override public String convert(String value) throws IOException {
return value;
}
}
获取 Converter 后，创建 ParameterHandler.Query 对象；Field 注解中，会先校验 isFormEncoded 属性，这也是为什么必须使用 @FormUrlEncoded 注解的原因，最后返回 ParameterHandler.Field 对象，与 Query 类似。parameterHandlers 数组填充完毕后，会再校验一些属性，这个也可以称之为注解的组合使用规则。然后就是通过builder方法创建 ServiceMethod 对象了，把 Builder 中获取的值，尽数传递给 ServiceMethod。
loadServiceMethod(Method method) 方法分析到此结束，继续看动态代理的内容，创建 OkHttpCall 对象，把 serviceMethod 和参数 args 通过构造方法传递进去，然后调用 ServiceMethod 中的 callAdapter 属性对象的 adapt() 方法，此时 callAdapter 对应的就是 createCallAdapter() 方法生成的 ExecutorCallAdapterFactory 类中的 get() 方法中 return 的 CallAdapter 对象；serviceMethod.callAdapter.adapt(okHttpCall) 对应的就是 CallAdapter 对象中的 adapt() 方法，它 return 的值是 ExecutorCallbackCall， Call<String> call = service.getBlog( "https://www.baidu.com" , "abc" ) 中 call 实际上就是 ExecutorCallbackCall 类型。
然后就是 call.enqueue(new Callback<String>() {...}); 方法了，既然知道此时 call 是 ExecutorCallbackCall 类型，那么看看 ExecutorCallbackCall 的源码
static final class ExecutorCallbackCall<T> implements Call<T> {
final Executor callbackExecutor;
final Call<T> delegate;
ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
this.callbackExecutor = callbackExecutor;
this.delegate = delegate;
}
@Override public void enqueue(final Callback<T> callback) {
if (callback == null) throw new NullPointerException("callback == null");
delegate.enqueue(new Callback<T>() {
@Override public void onResponse(Call<T> call, final Response<T> response) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
if (delegate.isCanceled()) {
// Emulate OkHttp's behavior of throwing/delivering an IOException on cancellation.
callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
} else {
callback.onResponse(ExecutorCallbackCall.this, response);
}
}
});
}
@Override public void onFailure(Call<T> call, final Throwable t) {
callbackExecutor.execute(new Runnable() {
@Override public void run() {
callback.onFailure(ExecutorCallbackCall.this, t);
}
});
}
});
}
...
}明显的，这是个装饰模式，ExecutorCallbackCall 在创建时，传递了两个参数给构造方法，new ExecutorCallbackCall<>(callbackExecutor, call) 这两个参数类型分别对应 MainThreadExecutor 和 OkHttpCall 对象类型，所以 ExecutorCallbackCall 中的成员变量 callbackExecutor 是 MainThreadExecutor，是用 Handler 来切换线程的，delegate 是 OkHttpCall 类型，是来构建请求头和请求体的，注意 enqueue() 方法，先对 callback 进行非空判断，然后执行代理 delegate 的 enqueue() 方法，
OkHttpCall:
@Override
public void enqueue(final Callback<T> callback) {
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();
}
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();
}
}
});
}首先是调用 createRawCall() 生成一个 call 对象，如果生成的过程中抛出了异常，则创建 failure 对象，接下来先校验 failure 对象不为空，则直接执行失败方法的回调；如果接口被取消了，则里也是取消；然后是 call 执行它对应的 enqueue() 方法，注意，这时候它和回调都是 Okhttp 中的类了，这一步已经把网络请求交割给 Okhttp 了，然后就是它里面的成功和失败的回调了，成功的话会有个 parseResponse() 方法来封装得到的结果，转换类型。回调执行后，就回到了 ExecutorCallbackCall 中的 delegate 设置的回调中，在它的回调中，用 callbackExecutor 切换到UI线程，然后就回调到了 retrofitTest() 例子中对 call 设置的回到了，这里我们可以做自己的业务逻辑，再说一遍，此时就是UI线程了。大体流程清楚了，再来看看请求的细节，先看 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;
}ServiceMethod:
Request toRequest(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 requestBuilder.build();
}RequestBuilder 是一个转换封装请求头、请求体的类，感兴趣的可以看看，助理主要是 ParameterHandler 数组，通过for循环，执行对象中 apply() 方法，前面讲到了 @Url 和 @Field
注解对应的类型是 ParameterHandler 中内部类 RelativeUrl 和 Query
static final class RelativeUrl extends ParameterHandler<Object> {
@Override void apply(RequestBuilder builder, Object value) {
builder.setRelativeUrl(value);
}
}
static final class Query<T> extends ParameterHandler<T> {
@Override void apply(RequestBuilder builder, T value) throws IOException {
if (value == null) return; // Skip null values.
builder.addQueryParam(name, valueConverter.convert(value), encoded);
}
}通过这可以知道，通过 for 循环，把参数添加到了 requestBuilder 对象中，注意 Query 中的参数，name 是 getBlog(@Url String url,@Query("type") int type) 中 @Query("type")括号中的 "type"，value 是 retrofitTest() 中传递的参数 "abc"，valueConverter 指的是前面 parseParameterAnnotation()方法中获取的StringConverter 对象，此时它方法中返回的值是本身
static final class StringConverter implements Converter<String, String> {
static final StringConverter INSTANCE = new StringConverter();
@Override public String convert(String value) throws IOException {
return value;
}
}RequestBuilder 添加参数最终还是通过 HttpUrl 、 FormBody 等，这个和 Okhttp 里面的 Request 里面的原理是相同的，最终通过 build() 方法来创建 Request 对象，serviceMethod.callFactory.newCall(request) 中 serviceMethod.callFactory 对应的是 Retrofit 中的 callFactory 属性，也就是 OkHttpClient，它的 newCall() 方法返回的 Call 是 RealCall 类型的对象，所以 call执行enqueue()方法也就对应 RealCall 的 enqueue() 方法，在 Okhttp 中，用线程池开启线程请求网络接口；看看回调成功的逻辑，是如何转换返回的报文类型，关键是 parseResponse() 方法
Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
ResponseBody rawBody = rawResponse.body();
rawResponse = rawResponse.newBuilder()
.body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
.build();
int code = rawResponse.code();
if (code < 200 || code >= 300) {
try {
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);
try {
T body = serviceMethod.toResponse(catchingBody);
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
catchingBody.throwIfCaught();
throw e;
}
}前面三四行代码是给 rawResponse 中的body对象再包装一层 NoContentResponseBody，然后重新设置进去；获取code码，如果不在200和300之间，则创建一个ResponseBody对象，然后设置到 Response 的静态方法中，生成 Response 对象；如果是 204 或 205，也是静态方法返回 Response 对象，不过此时设置的报文为null； ExceptionCatchingRequestBody 装饰模式
，在它的 source() 方法中，当解读数据时，添加了 ForwardingSource 中间代理层，它的 read() 方法中加了try.catch 异常机制处理，当执行 serviceMethod.toResponse(catchingBody) 方法时会起到作用，serviceMethod 对应StringResponseBodyConverter ，它仅仅是获取 ResponseBody 中的 string()，然后转换为字符串返回，它会触发 bytes() 方法，这个方法触发了 ExceptionCatchingRequestBody 中的 source() 方法及 ForwardingSource 中的 read() 方法。
到此，例子中的讲解就此结束了，各位可以按照这个逻辑，自行阅读以下 pot 请求和同步线程请求。
