Android：这是一份全面 & 详细的Retrofit 2.0 源码分析指南

前言

Android

Android

Retrofit

Retrofit v2.0

目录

1. 简介

OkHttp

2. 与其他网络请求开源库对比

3. Retrofit 的具体使用

4. 源码分析

4.1 Retrofit的本质流程

4.2 源码分析

4.2.1 创建Retrofit实例

a. 使用步骤

Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://fanyi.youdao.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();

b. 源码分析

步骤1

<-- Retrofit类 -->
public final class Retrofit {

private final Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();
// 网络请求配置对象（对网络请求接口中方法注解进行解析后得到的对象）
// 作用：存储网络请求相关的配置，如网络请求的方法、数据转换器、网络请求适配器、网络请求工厂、基地址等

private final HttpUrl baseUrl;
// 网络请求的url地址

private final okhttp3.Call.Factory callFactory;
// 网络请求器的工厂
// 作用：生产网络请求器（Call）
// Retrofit是默认使用okhttp

private final List<CallAdapter.Factory> adapterFactories;
// 网络请求适配器工厂的集合
// 作用：放置网络请求适配器工厂
// 网络请求适配器工厂作用：生产网络请求适配器（CallAdapter）
// 下面会详细说明

private final List<Converter.Factory> converterFactories;
// 数据转换器工厂的集合
// 作用：放置数据转换器工厂
// 数据转换器工厂作用：生产数据转换器（converter）

private final Executor callbackExecutor;
// 回调方法执行器

private final boolean validateEagerly;
// 标志位
// 作用：是否提前对业务接口中的注解进行验证转换的标志位

<-- Retrofit类的构造函数 -->
Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,
Executor callbackExecutor, boolean validateEagerly) {
this.callFactory = callFactory;
this.baseUrl = baseUrl;
this.converterFactories = unmodifiableList(converterFactories);
this.adapterFactories = unmodifiableList(adapterFactories);
// unmodifiableList(list)近似于UnmodifiableList<E>(list)
// 作用：创建的新对象能够对list数据进行访问，但不可通过该对象对list集合中的元素进行修改
this.callbackExecutor = callbackExecutor;
this.validateEagerly = validateEagerly;
...
// 仅贴出关键代码
}

serviceMethod

baseUrl

callFactory

adapterFactories

converterFactories

callbackExecutor

xxxFactory

CallAdapterFactory

Factory

CallAdapter

CallAdapter

CallAdapter

详细介绍

OkHttpCall

Retrofit

OkHttpCall

ExecutorCallbackCall

Rxjava

Rxjava

RxJavaCallAdapterFactoryCallAdapter

OkHttpCall

Rxjava(Scheduler):     

// 把response封装成rxjava的Observeble，然后进行流式操作
Retrofit.Builder.addCallAdapterFactory(newRxJavaCallAdapterFactory().create());
// 关于RxJava的使用这里不作更多的展开

步骤2

步骤3

步骤4

GsonConverterFactory.creat()

addConverterFactory（）

addConverterFactory（）

// 将上面创建的GsonConverterFactory放入到 converterFactories数组
// 在第二步放入一个内置的数据转换器工厂BuiltInConverters(）后又放入了一个GsonConverterFactory
public Builder addConverterFactory(Converter.Factory factory) {
converterFactories.add(checkNotNull(factory, "factory == null"));
return this;
}

步骤5

总结

2. 创建网络请求接口的实例

2.1 使用步骤

<-- 步骤1：定义接收网络数据的类 -->
<-- JavaBean.java -->
public class JavaBean {
.. // 这里就不介绍了
}

<-- 步骤2：定义网络请求的接口类 -->
<-- AccessApi.java -->
public interface AccessApi {
// 注解GET：采用Get方法发送网络请求
// Retrofit把网络请求的URL分成了2部分：1部分baseurl放在创建Retrofit对象时设置；另一部分在网络请求接口设置（即这里）
// 如果接口里的URL是一个完整的网址，那么放在创建Retrofit对象时设置的部分可以不设置
@GET("openapi.do?keyfrom=Yanzhikai&key=2032414398&type=data&doctype=json&version=1.1&q=car")

// 接受网络请求数据的方法
Call<JavaBean> getCall();
// 返回类型为Call<*>，*是解析得到的数据类型，即JavaBean
}

<-- 步骤3：在MainActivity创建接口类实例  -->
AccessApi NetService = retrofit.create(AccessApi.class);

<-- 步骤4：对发送请求的url进行封装，即生成最终的网络请求对象  -->
Call<JavaBean> call = NetService.getCall();

2.2 源码分析

<-- 步骤3：在MainActivity创建接口类实例  -->
AccessApi NetService = retrofit.create(NetService.class);

<-- 步骤4：对发送请求的url进行封装，即生成最终的网络请求对象  -->
Call<JavaBean> call = NetService.getCall();

步骤3讲解：

AccessApi NetService = retrofit.create(NetService.class);

public <T> T create(final Class<T> service) {

if (validateEagerly) {
// 判断是否需要提前验证
eagerlyValidateMethods(service);
// 具体方法作用：
// 1. 给接口中每个方法的注解进行解析并得到一个ServiceMethod对象
// 2. 以Method为键将该对象存入LinkedHashMap集合中
// 特别注意：如果不是提前验证则进行动态解析对应方法（下面会详细说明），得到一个ServiceMethod对象，最后存入到LinkedHashMap集合中，类似延迟加载（默认）
}

// 创建了网络请求接口的动态代理对象，即通过动态代理创建网络请求接口的实例 （并最终返回）
// 该动态代理是为了拿到网络请求接口实例上所有注解
return (T) Proxy.newProxyInstance(
service.getClassLoader(),      // 动态生成接口的实现类
new Class<?>[] { service },    // 动态创建实例
new InvocationHandler() {     // 将代理类的实现交给 InvocationHandler类作为具体的实现（下面会解释）
private final Platform platform = Platform.get();

// 在 InvocationHandler类的invoke（）实现中，除了执行真正的逻辑（如再次转发给真正的实现类对象），还可以进行一些有用的操作
// 如统计执行时间、进行初始化和清理、对接口调用进行检查等。
@Override
public Object invoke(Object proxy, Method method, Object... args)
throws Throwable {

// 下面会详细介绍 invoke（）的实现
// 即下面三行代码
ServiceMethod serviceMethod = loadServiceMethod(method);
OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}

// 特别注意
// return (T) roxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler invocationHandler)
// 可以解读为：getProxyClass(loader, interfaces) .getConstructor(InvocationHandler.class).newInstance(invocationHandler);
// 即通过动态生成的代理类，调用interfaces接口的方法实际上是通过调用InvocationHandler对象的invoke（）来完成指定的功能
// 先记住结论，在讲解步骤4的时候会再次详细说明

<-- 关注点1：eagerlyValidateMethods（） -->
private void eagerlyValidateMethods(Class<?> service) {
Platform platform = Platform.get();
for (Method method : service.getDeclaredMethods()) {
if (!platform.isDefaultMethod(method)) {  loadServiceMethod(method); }
// 将传入的ServiceMethod对象加入LinkedHashMap<Method, ServiceMethod>集合
// 使用LinkedHashMap集合的好处：lruEntries.values().iterator().next()获取到的是集合最不经常用到的元素，提供了一种Lru算法的实现
}
}

1. 外观模式

retrofit.create()

2. 代理模式

return (T) roxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler invocationHandler)

InvocationHandler类

NetService

getCall（）

下面看源码分析

InvocationHandler类 # invoke（）

关注点1：

ServiceMethod serviceMethod = loadServiceMethod(method);

<-- loadServiceMethod(method)方法讲解 -->
// 一个 ServiceMethod 对象对应于网络请求接口里的一个方法
// loadServiceMethod（method）负责加载 ServiceMethod：

ServiceMethod loadServiceMethod(Method method) {
ServiceMethod result;
// 设置线程同步锁
synchronized (serviceMethodCache) {

result = serviceMethodCache.get(method);
// ServiceMethod类对象采用了单例模式进行创建
// 即创建ServiceMethod对象前，先看serviceMethodCache有没有缓存之前创建过的网络请求实例

// 若没缓存，则通过建造者模式创建 serviceMethod 对象
if (result == null) {
// 下面会详细介绍ServiceMethod生成实例的过程
result = new ServiceMethod.Builder(this, method).build();
serviceMethodCache.put(method, result);
}
}
return result;
}
// 这里就是上面说的创建实例的缓存机制：采用单例模式从而实现一个 ServiceMethod 对象对应于网络请求接口里的一个方法
// 注：由于每次获取接口实例都是传入 class 对象
// 而 class 对象在进程内单例的，所以获取到它的同一个方法 Method 实例也是单例的，所以这里的缓存是有效的。

serviceMethod

步骤1：

ServiceMethod类

构造函数

<-- ServiceMethod 类 -->
public final class ServiceMethod {
final okhttp3.Call.Factory callFactory;   // 网络请求工厂
final CallAdapter<?> callAdapter;
// 网络请求适配器工厂
// 具体创建是在new ServiceMethod.Builder(this, method).build()最后的build()中
// 下面会详细说明

private final Converter<ResponseBody, T> responseConverter;
// Response内容转换器
// 作用：负责把服务器返回的数据（JSON或者其他格式，由 ResponseBody 封装）转化为 T 类型的对象；

private final HttpUrl baseUrl; // 网络请求地址
private final String relativeUrl; // 网络请求的相对地址
private final String httpMethod;   // 网络请求的Http方法
private final Headers headers;  // 网络请求的http请求头 键值对
private final MediaType contentType; // 网络请求的http报文body的类型

private final ParameterHandler<?>[] parameterHandlers;
// 方法参数处理器
// 作用：负责解析 API 定义时每个方法的参数，并在构造 HTTP 请求时设置参数；
// 下面会详细说明

// 说明：从上面的成员变量可以看出，ServiceMethod对象包含了访问网络的所有基本信息

<-- ServiceMethod 类的构造函数 -->
// 作用：传入各种网络请求参数
ServiceMethod(Builder<T> builder) {

this.callFactory = builder.retrofit.callFactory();
this.callAdapter = builder.callAdapter;
this.responseConverter = builder.responseConverter;

this.baseUrl = builder.retrofit.baseUrl();
this.relativeUrl = builder.relativeUrl;
this.httpMethod = builder.httpMethod;
this.headers = builder.headers;
this.contentType = builder.contentType; .
this.hasBody = builder.hasBody; y
this.isFormEncoded = builder.isFormEncoded;
this.isMultipart = builder.isMultipart;
this.parameterHandlers = builder.parameterHandlers;
}

步骤2：

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();
}

步骤3：

ServiceMethod的build（）

// 作用：控制ServiceMethod对象的生成流程

public ServiceMethod build() {

callAdapter = createCallAdapter();
// 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取对应的网络请求适配器  -->关注点1

responseType = callAdapter.responseType();
// 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取该网络适配器返回的数据类型

responseConverter = createResponseConverter();
// 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取对应的数据转换器  -->关注点3
// 构造 HTTP 请求时，我们传递的参数都是String
// Retrofit 类提供 converter把传递的参数都转化为 String
// 其余类型的参数都利用 Converter.Factory 的stringConverter 进行转换
// @Body 和 @Part 类型的参数利用Converter.Factory 提供的 requestBodyConverter 进行转换
// 这三种 converter 都是通过“询问”工厂列表进行提供，而工厂列表我们可以在构造 Retrofit 对象时进行添加。

for (Annotation annotation : methodAnnotations) {
parseMethodAnnotation(annotation);
}
// 解析网络请求接口中方法的注解
// 主要是解析获取Http请求的方法
// 注解包括：DELETE、GET、POST、HEAD、PATCH、PUT、OPTIONS、HTTP、retrofit2.http.Headers、Multipart、FormUrlEncoded
// 处理主要是调用方法 parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) ServiceMethod中的httpMethod、hasBody、relativeUrl、relativeUrlParamNames域进行赋值

int parameterCount = parameterAnnotationsArray.length;
// 获取当前方法的参数数量

parameterHandlers = new ParameterHandler<?>[parameterCount];
for (int p = 0; p < parameterCount; p++) {
Type parameterType = parameterTypes[p];
Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
// 为方法中的每个参数创建一个ParameterHandler<?>对象并解析每个参数使用的注解类型
// 该对象的创建过程就是对方法参数中注解进行解析
// 这里的注解包括：Body、PartMap、Part、FieldMap、Field、Header、QueryMap、Query、Path、Url
parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
}
return new ServiceMethod<>(this);

<-- 总结 -->
// 1. 根据返回值类型和方法标注从Retrofit对象的的网络请求适配器工厂集合和内容转换器工厂集合中分别获取到该方法对应的网络请求适配器和Response内容转换器；
// 2. 根据方法的标注对ServiceMethod的域进行赋值
// 3. 最后为每个方法的参数的标注进行解析，获得一个ParameterHandler<?>对象
// 该对象保存有一个Request内容转换器——根据参数的类型从Retrofit的内容转换器工厂集合中获取一个Request内容转换器或者一个String内容转换器。
}

<-- 关注点1：createCallAdapter() -->
private CallAdapter<?> createCallAdapter() {

// 获取网络请求接口里方法的返回值类型
Type returnType = method.getGenericReturnType();

// 获取网络请求接口接口里的注解
// 此处使用的是@Get
Annotation[] annotations = method.getAnnotations();
try {

return retrofit.callAdapter(returnType, annotations);
// 根据网络请求接口方法的返回值和注解类型，从Retrofit对象中获取对应的网络请求适配器
// 下面会详细说明retrofit.callAdapter（） -- >关注点2
}
...

<-- 关注点2：retrofit.callAdapter()  -->
public CallAdapter<?> callAdapter(Type returnType, Annotation[] annotations) {
return nextCallAdapter(null, returnType, annotations);
}

public CallAdapter<?> nextCallAdapter(CallAdapter.Factory skipPast, Type returnType,
Annotation[] annotations) {

// 创建 CallAdapter 如下
// 遍历 CallAdapter.Factory 集合寻找合适的工厂（该工厂集合在第一步构造 Retrofit 对象时进行添加（第一步时已经说明））
// 如果最终没有工厂提供需要的 CallAdapter，将抛出异常
for (int i = start, count = adapterFactories.size(); i < count; i++) {
CallAdapter<?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
if (adapter != null) {
return adapter;
}
}

<--   关注点3：createResponseConverter（） -->

private Converter<ResponseBody, T> createResponseConverter() {
Annotation[] annotations = method.getAnnotations();
try {

// responseConverter 还是由 Retrofit 类提供  -->关注点4
return retrofit.responseBodyConverter(responseType, annotations);
} catch (RuntimeException e) {
throw methodError(e, "Unable to create converter for %s", responseType);
}
}

<--   关注点4：responseBodyConverter（） -->
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
return nextResponseBodyConverter(null, type, annotations);
}

public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory skipPast,

int start = converterFactories.indexOf(skipPast) + 1;
for (int i = start, count = converterFactories.size(); i < count; i++) {

// 获取Converter 过程：（和获取 callAdapter 基本一致）
Converter<ResponseBody, ?> converter =
converterFactories.get(i).responseBodyConverter(type, annotations, this);
// 遍历 Converter.Factory 集合并寻找合适的工厂（该工厂集合在构造 Retrofit 对象时进行添加（第一步时已经说明））
// 由于构造Retroifit采用的是Gson解析方式，所以取出的是GsonResponseBodyConverter
// Retrofit - Converters 还提供了 JSON，XML，ProtoBuf 等类型数据的转换功能。
// 继续看responseBodyConverter（） -->关注点5
}

<--   关注点5：responseBodyConverter（） -->
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type,
Annotation[] annotations, Retrofit retrofit) {

TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
// 根据目标类型，利用 Gson#getAdapter 获取相应的 adapter
return new GsonResponseBodyConverter<>(gson, adapter);
}

// 做数据转换时调用 Gson 的 API 即可。
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 {
return adapter.read(jsonReader);
} finally {
value.close();
}
}
}

采用工厂模式使得各功能模块高度解耦

ServiceMethod

okHttpCall对象

第二行：

OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);

ServiceMethod

okHttpCall

第三行：

return serviceMethod.callAdapter.adapt(okHttpCall);

OkHttpCall

serviceMethod

adapt（）

Call<>

Observable<>

步骤4讲解：

Call<JavaBean> call = NetService.getCall();

NetService

Proxy.newProxyInstance（）

NetService

getCall（）

Proxy.newProxyInstance（）

InvocationHandler # invoke（）

invoke(Object proxy, Method method, Object... args)

Object proxy:

Method method

getCall()

Object... args

getCall（*）

getCall（）

ServiceMethod对象

OkHttpCall

OkHttpCall

OkHttp

OkHttpCall

Request

总结

serviceMethod

serviceMethod

serviceMethod

OkHttpCall

3. 执行网络请求

Retrofit

OkHttp

OkHttpCall类

retrofit2.Call<T>

OkHttpCall

OkHttpCall.execute()

OkHttpCall.enqueue()

3.1 同步请求

OkHttpCall.execute()

3.1.1 发送请求过程

ParameterHandler

ServiceMethod

OkHttp

Request

OkHttp

Request

Response<T>

3.1.2 具体使用

Response<JavaBean> response = call.execute();

3.1.3 源码分析

@Override
public Response<T> execute() throws IOException {
okhttp3.Call call;

// 设置同步锁
synchronized (this) {
call = rawCall;
if (call == null) {
try {
call = rawCall = createRawCall();
// 步骤1：创建一个OkHttp的Request对象请求 -->关注1
} catch (IOException | RuntimeException e) {
creationFailure = e;
throw e;
}
}
}

return parseResponse(call.execute());
// 步骤2：调用OkHttpCall的execute()发送网络请求（同步）
// 步骤3：解析网络请求返回的数据parseResponse（） -->关注2
}

<-- 关注1：createRawCall()  -->
private okhttp3.Call createRawCall() throws IOException {

Request request = serviceMethod.toRequest(args);
// 从ServiceMethod的toRequest（）返回一个Request对象
okhttp3.Call call = serviceMethod.callFactory.newCall(request);
// 根据serviceMethod和request对象创建 一个okhttp3.Request

if (call == null) {
throw new NullPointerException("Call.Factory returned null.");
}
return call;
}

<--  关注2：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) {
}

if (code == 204 || code == 205) {
return Response.success(null, rawResponse);
}

ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
try {
T body = serviceMethod.toResponse(catchingBody);
// 等Http请求返回后 & 通过状态码检查后，将response body传入ServiceMethod中，ServiceMethod通过调用Converter接口（之前设置的GsonConverterFactory）将response body转成一个Java对象，即解析返回的数据

// 生成Response类
return Response.success(body, rawResponse);
} catch (RuntimeException e) {
... // 异常处理
}
}

ServiceMethod

OkHttpCall

ServiceMethod

ServiceMethod

Converter

ServiceMethod

Map<Method, ServiceMethod> serviceMethodCache = new LinkedHashMap<>();

3.2 异步请求

OkHttpCall.enqueue()

ParameterHandler

ServiceMethod

OkHttp

Request

OkHttp

Request

Response<T>

call.enqueue(new Callback<JavaBean>() {
@Override
public void onResponse(Call<JavaBean> call, Response<JavaBean> response) {
System.out.println(response.isSuccessful());
if (response.isSuccessful()) {
response.body().show();
}
else {
try {
System.out.println(response.errorBody().string());
} catch (IOException e) {
e.printStackTrace();
} ;
}
}

call

<--  call.enqueue（）解析  -->
@Override
public void enqueue(final Callback<T> callback) {

delegate.enqueue(new Callback<T>() {
// 使用静态代理 delegate进行异步请求 ->>分析1
// 等下记得回来
@Override
public void onResponse(Call<T> call, final Response<T> response) {
// 步骤4：线程切换，从而在主线程显示结果
callbackExecutor.execute(new Runnable() {
// 最后Okhttp的异步请求结果返回到callbackExecutor
// callbackExecutor.execute（）通过Handler异步回调将结果传回到主线程进行处理（如显示在Activity等等），即进行了线程切换
// 具体是如何做线程切换 ->>分析2
@Override
public void run() {
if (delegate.isCanceled()) {
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);
}
});
}
});
}

<-- 分析1：delegate.enqueue（）解析 -->
@Override
public void enqueue(final Callback<T> callback) {

okhttp3.Call call;
Throwable failure;

// 步骤1：创建OkHttp的Request对象，再封装成OkHttp.call
// delegate代理在网络请求前的动作：创建OkHttp的Request对象，再封装成OkHttp.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();
// 创建OkHttp的Request对象，再封装成OkHttp.call
// 方法同发送同步请求，此处不作过多描述
} catch (Throwable t) {
failure = creationFailure = t;
}
}

// 步骤2：发送网络请求
// delegate是OkHttpcall的静态代理
// delegate静态代理最终还是调用Okhttp.enqueue进行网络请求
call.enqueue(new okhttp3.Callback() {
@Override
public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
throws IOException {
Response<T> response;
try {

// 步骤3：解析返回数据
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();
}
}
});
}

// 请回去上面分析1的起点

<-- 分析2：异步请求后的线程切换-->
// 线程切换是通过一开始创建Retrofit对象时Platform在检测到运行环境是Android时进行创建的：（之前已分析过）
// 采用适配器模式
static class Android extends Platform {

// 创建默认的回调执行器工厂
// 如果不将RxJava和Retrofit一起使用，一般都是使用该默认的CallAdapter.Factory
// 后面会对RxJava和Retrofit一起使用的情况进行分析
@Override
CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
return new ExecutorCallAdapterFactory(callbackExecutor);
}

@Override
public Executor defaultCallbackExecutor() {
// 返回一个默认的回调方法执行器
// 该执行器负责在主线程（UI线程）中执行回调方法
return new MainThreadExecutor();
}

// 获取主线程Handler
static class MainThreadExecutor implements Executor {
private final Handler handler = new Handler(Looper.getMainLooper());

@Override
public void execute(Runnable r) {
// Retrofit获取了主线程的handler
// 然后在UI线程执行网络请求回调后的数据显示等操作。
handler.post(r);
}
}

// 切换线程的流程：
// 1. 回调ExecutorCallAdapterFactory生成了一个ExecutorCallbackCall对象
// 2. 通过调用ExecutorCallbackCall.enqueue(CallBack)从而调用MainThreadExecutor的execute()通过handler切换到主线程处理返回结果（如显示在Activity等等）
}

5. 总结

Retrofit

RESTful

HTTP

OkHttp

Retrofit

Http

Java

HTTP

HTTP

Retrofit