Android框架源码分析——从设计模式角度看 Retrofit 核心源码

Retrofit中用到了许多常见的设计模式：代理模式、外观模式、构建者模式等。我们将从这三种设计模式入手，分析 Retrofit2 的核心源码。

1. 宏观 Retrofit 是一个外观模式的设计

外观模式：让开发人员能够用轻松地使用子系统。

OkHttp网络请求框架很大，对于初学开发人员来说使用起来非常繁杂，如果不进行封装，代码会很繁杂。Retrofit 通过外观模式的设计，将 OkHttp3 进行再封装，让用户使用起来更轻松。

OkHttp3网络请求框架有以下缺点：

用户网络请求的接口配置繁琐，尤其是重复配置复杂的 body,请求头,参数等。
数据解析过程需要用户手动对 ResponseBody 进行解析。
无法自动进行线程的切换
存在嵌套网络请求，会陷入“回调地狱”

Retrofit 对 OkHttp 这个子系统进行了再封装，在使用前后分别加上了一些便捷功能，使得网络请求能够更加便捷：

我们接下来逐个了解 Retrofit 是如何实现上述四个核心功能的：

统一配置网络请求头
将请求 Request 进行统一适配
将响应 ResponseBody 进行统一数据类型转换适配
对核心的 OkHttpCall 交给上层处理（默认处理为将callback切换回主线程执行）也可以交给RxJava的Observable对callback回调进行事件发射。
本文中只看默认的 DefaultCallAdapterFactory实现线程切换

2. 统一配置网络请求头——构建者模式

构建者模式可以用在对配置的灵活设置：一个系统有一系列的设置，用户可以选择自主配置某些设置，剩下的使用默认设置。

构建者模式使用背景：由于用户可以选择的方案很多，我们无法通过构造方法的重载（reload）进行初始设置。如果用户使用一系列的 setter() 工作量和代码量也不小，这时上述的构建者模式“灵活设置”的优势就体现出来了。

Retrofit 有上面谈到的四个核心功能，这四个功能是可拓展的，具体如何实现，可以通过设置来决定，例如如何对响应 Response 进行数据适配，用户可以选择 Gson、Jacson、SimpleXML 等多种方案，也使用默认方案。

我们来看一下 Retrofit 是如何做到“灵活配置”的：

Retrofit中有许多参数可以自定义设置，我们看到源码：

public static final class Builder {//Retrofit 运行的平台:Java or Android，通过虚拟机来判断，如果是“Dalvik”就认为是 Android 平台，主要用于选择用哪种方式进行线程切换。（策略模式）private final Platform platform;//OkHttp3.Call 真正请求角色的创建工厂private @Nullable okhttp3.Call.Factory callFactory;//当前Retrofit下请求url的前缀，如果一个系统需要访问多个baseUrl的服务器，就需要多个Retrofitprivate @Nullable HttpUrl baseUrl;//对响应Response统一适配的工具，将Response通过Gson等方式转为Javabeanprivate final List<Converter.Factory> converterFactories = new ArrayList<>();//对请求Request统一适配的工具,对 Request进行预处理private final List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>();//用于线程切换，将回调函数放到响应线程执行，如切换到主线程执行private @Nullable Executor callbackExecutor;private boolean validateEagerly;//...
}

通过构建者模式实例化 Retrofit 示例：

Retrofit retrofit = new Retrofit.Builder()//构建者模式，原类的构造器隐藏，由内部类Builder()来完成构建。.baseUrl("https://localhost/")//注意要以/结尾.addConverterFactory(GsonConverterFactory.create()).build();

3. 将请求体Request 进行统一配置，获得ExecutorCallbackCall<>——代理模式

Retrofit 使用的特点是使用接口和注解进行请求 Request 的统一设置：

public interface IDemoService {@GET("user")Call<ResponseBody> getData1(@Query("username") String username);@Headers({"phone-type:android", "version:1.1.1"})@GET("user/emails")Call<ResponseBody> getHeadersData();@GET("orgs/{page}")Call<ResponseBody> getPathData(@Query("username") String username, @Path("page") int page);@POST("user/emails")@FormUrlEncodedCall<ResponseBody> getPostData2(@FieldMap Map<String,Object> map);//...
}

IDemoService 扮演者代理模式中的interface接口，它表明了委托人和代理人所共有的能力。开发人员无需了解具体实现类是如何进行操作的，只需要通过代理获得最终结果即可。Retrofit 中，用户通过代理获取生成的请求体Call<>，代理返回的结果是 ExecutorCallbackCall<>类型的请求体Call<>。

Retrofit 使用的是动态代理方案。

Retrofit 获得网络请求代理：

IDemoService userServiceProxy = retrofit.create(IDemoService.class);

由代理去生成 ExecutorCallbackCall<>：

//用户调用了代理的getData0()的方法
Call<ResponseBody> data0 = userServiceProxy.getData0();

后续可以使用这个Call<>去进行网络请求：

Call<ResponseBody> executorCallbackCall = userServiceProxy.getData0();
//发起异步网络请求
executorCallbackCall.enqueue(new Callback<ResponseBody>() {//返回到这里，默认回调到主线程！@Overridepublic void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {}@Overridepublic void onFailure(Call<ResponseBody> call, Throwable t) {}
});

Retrofit 会创建一个IxxxService的代理类：

//[Retrofit.java]
public <T> T create(final Class<T> service) {validateServiceInterface(service);return (T)Proxy.newProxyInstance(service.getClassLoader(),new Class<?>[] {service},new InvocationHandler() {//获取到平台为Androidprivate final Platform platform = Platform.get();  @Overridepublic @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)throws Throwable {                return loadServiceMethod(method).invoke(args);}});
}

这里使用了动态代理，Proxy.newProxyInstance() 返回一个 IxxxService 的代理类对象。当用户调用 IxxxService 的如 getData0() 方法时，会调用上述的 invoke()方法。传递的参数为：proxy:代理本身，method:代理对象调用的方法，args:参数。

例如我们调用了 IxxxService.getData0()，那么这个invoke()传入的参数为：

proxy: IxxxService对象

method：getData0()的方法对象

args: 空数组，由于我们没有传递参数

Retrofit 调用 loadServiceMethod(method) ，loadServiceMethod()返回一个 ServiceMethod对象，然后调用这个对象的invoke()方法，最后给用户返回一个由OkHttpCall<>适配而来的ExecutorCallbackCall<> 对象。

在产生ServiceMethod对象的过程中，还根据Retrofit的设置，构建了：

请求适配器，将OkHttpCall<>适配为 ExecutorCallbackCall<>给上层使用
数据转换器，可以将数据进行解析，如GsonConverterFactory产出的转换器可以完成：Gson<->Javabean。

产生 ServiceMethod 对象的入口 loadServiceMethod：

ServiceMethod<?> loadServiceMethod(Method method) {//线程安全DCL检查//使用缓存保存之前生成的 ServiceManager，减轻了反射带来的性能损耗ServiceMethod<?> result = serviceMethodCache.get(method);if (result != null) return result;synchronized (serviceMethodCache) {result = serviceMethodCache.get(method);if (result == null) {//如果没获取到，就生成一个result = ServiceMethod.parseAnnotations(this, method);serviceMethodCache.put(method, result);}}return result;
}

由于过程利用到反射，会损耗性能，所以使用 serviceMethodCache进行反射后结果的缓存，减少反射性能损耗带来的负面影响。

abstract class ServiceMethod<T> {static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {//初始化 requestFactoryRequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);//记录返回类型Type returnType = method.getGenericReturnType();//return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);}abstract @Nullable T invoke(Object[] args);
}

默认返回的是 ServiceMethod 的实现类： HttpServiceMethod，在实例化它之前，先实例化了请求适配工具 CallAdapter 和数据转换工具 Converter

//[HttpServiceMethod.java]
//核心成员变量：
private final RequestFactory requestFactory;
private final okhttp3.Call.Factory callFactory;
private final Converter<ResponseBody, ResponseT> responseConverter;//核心方法：
static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {//获得method的返回值类型adapterType = method.getGenericReturnType();//1.获取方法上的注解Annotation[] annotations = method.getAnnotations();//2.创建请求统一适配工具：CallAdapterCallAdapter<ResponseT, ReturnT> callAdapter =//调用 Retrofit.callAdapter()createCallAdapter(retrofit, method, adapterType, annotations);//3.创建数据转换工具：ConverterConverter<ResponseBody, ResponseT> responseConverter =//调用 Retrofit.responseBodyConverter()createResponseConverter(retrofit, method, responseType);//SuspendForResponse、SuspendForBody都是HttpServiceMethod的子类，主要实现了 adapt()方法。//如果是响应返回过程中if(continuationWantsResponse){return new SuspendForResponse<>(...);}else{//如果是请求过程中return new SuspendForBody<>(...);}
}

由于Retrofit中保存了各种工厂的设置，所以HTTPServiceMethod将工厂生产的具体实现，交给了 Retrofit 来做。

我们来看一下 Retrofit 是如何创建请求体适配工具 CallAdapter和数据转换工具Converter的：

//[Retrofit.java]
public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType, Annotation[] annotations) {int start = callAdapterFactories.indexOf(skipPast) + 1;for (int i = start, count = callAdapterFactories.size(); i < count; i++) {//由工厂创建 请求体适配工具CallAdapter实例：CallAdapter<?, ?> adapter = callAdapterFactories.get(i).get(returnType, annotations, this);if (adapter != null) {return adapter;}}
}public <T> Converter<T, RequestBody> nextRequestBodyConverter(@Nullable Converter.Factory skipPast,Type type,Annotation[] parameterAnnotations,Annotation[] methodAnnotations) {int start = converterFactories.indexOf(skipPast) + 1;for (int i = start, count = converterFactories.size(); i < count; i++) {Converter.Factory factory = converterFactories.get(i);//由工厂创建 响应数据适配工具Converter实例：Converter<?, RequestBody> converter =factory.requestBodyConverter(type, parameterAnnotations, methodAnnotations, this);if (converter != null) {//noinspection uncheckedreturn (Converter<T, RequestBody>) converter;}}
}

他们都由工厂来构建，我们先看一下请求适配工具 CallAdapter 是如何构建的：

//[DefaultCallAdapterFactory.java]
public @Nullable CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);final Executor executor =Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)? null: callbackExecutor;return new CallAdapter<Object, Call<?>>() {@Overridepublic Type responseType() {return responseType;}//请求体适配器用来对传入的请求体进行统一适配，适配给Retrofit使用@Overridepublic Call<Object> adapt(Call<Object> call) {return executor == null ? call : new ExecutorCallbackCall<>(executor, call);}};
}

可以发现，请求体适配器的核心作用是：将传入的Call<>都适配成了 ExecutorCallbackCall<>对象给上层使用。

实例化请求体适配器CallAdapter 之后，我们再看看数据转换器Converter是怎么由工厂 ConverterFactory生成的：

//[Converter.java]
public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,Annotation[] parameterAnnotations,Annotation[] methodAnnotations,Retrofit retrofit) {return null;
}

我们发现这是一个空实现，需要具体的工厂来完成，工厂的选择可以是默认的，也可以是用户给 Retrofit 初始化时设置的工厂：例如设置了 GsonConverterFactory 工厂用于生产 Gson 的数据转换器：

Retrofit retrofit = new Retrofit.Builder().baseUrl("https://localhost/")//注意要以/结尾.addConverterFactory(GsonConverterFactory.create())//设置Converter的构建工厂.build();

由于数据转换器需要完成 json 到 javabean 的转换，以及 javabean 到 json的转换，所以数据转换器的convert()方法有两种实现：

请求过程中：从 javabean 转换到 json：

//[GsonResponseBodyConverter<T>.java]
@Override public T convert(ResponseBody value) throws IOException {JsonReader jsonReader = gson.newJsonReader(value.charStream());try {return adapter.read(jsonReader);} finally {value.close();}
}

响应过程中：从 javabean 到 json：

//[GsonRequestBodyConverter<T>.java]
@Override public RequestBody convert(T value) throws IOException {Buffer buffer = new Buffer();Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);JsonWriter jsonWriter = gson.newJsonWriter(writer);adapter.write(jsonWriter, value);jsonWriter.close();return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
}

请求体适配器 CallAdapter 和数据转换器 Converter 构造好之后，loadServiceMethod()返回一个ServiceManager，用户调用 loadServiceMethod().invoke() 方法。

如果是请求过程，返回的是 HttpServiceMethod 的子类 SuspendForBody<>，如果是响应过程，返回的是 SuspendForResponse<>。

看到 HttpServiceMethod 的 invoke() 方法:

//[HttpServiceMethod.java]
@Override
final @Nullable ReturnT invoke(Object[] args) {Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);return adapt(call, args);
}
//这个 adapt() 是个空实现，由子类 SuspendForBody 和 SuspendForResponse 实现
protected abstract @Nullable ReturnT adapt(Call<ResponseT> call, Object[] args);

两个子类的adapt()方法都一样：

//[SuspendForBody.java][SuspendForResponse.java]
@Override
protected Object adapt(Call<ResponseT> call, Object[] args) {call = callAdapter.adapt(call);return call;
}

至此，上面的流程图就走通了：

代理类 userServiceProxy 调用了 getData0()，实际是通过 InvocationHandler的invoke()方法，让委托人去完成具体任务
委托人先根据 Retrofit 中的设置，创建好请求体适配器 CallAdapter 和数据转换器 Converter.
委托人返回请求体时，本来返回的是 OkHttpCall<>，但是返回过程中经过了请求体适配器CallAdapter，被适配为了 ExecutorCallbackCall<>返回给用户。

4. 发起网络请求 —— 外观模式

我们到了请求体 ExecutorCallbackCall<> 就可以发起网络请求了。但是我们回顾上面的流程，并没有发现 okhttp3.Call 的产生，那为什么 ExecutorCallbackCall<>可以发起网络请求呢？答案很简单，因为它封装的 OkHttpCall<> 中有 okhttp3.Call.Factory 可以用来构建真正的请求体：

为什么这么设计呢？因为构建请求体需要：

解析接口中定义的注解
将传入的参数根据后端要求，转换为 json 等格式
拼接好请求头、baseUrl等
最后拼接整合成为请求体Call<>需要的RequestBody

这个过程非常繁琐，框架的设计就是为了让开发人员更简单地使用子系统，所以上述两个构建过程，对上层来说设计为透明的，可以极大提高开发效率。

Retrofit 的外观设计模式将以上复杂的需求封装在了内部，成为了“黑盒”。“黑盒”将任务分别交给了 ExecutorCallbackCall 和 OkHttpCall：

ExecutorCallbackCall 负责将回传的数据进行线程切换，交还给用户；
OkHttpCall 负责构建请求体、发起网络请求、响应Response的数据适配转换；

ExecutorCallbackCall的enqueue()为调用入口:

Retrofit retrofit = new Retrofit.Builder().baseUrl("https://localhost/")//注意要以/结尾.addConverterFactory(GsonConverterFactory.create()).build();
IDemoService userServiceProxy = retrofit.create(IDemoService.class);
Call<ResponseBody> executorCallbackCall = userServiceProxy.getData0();
//调用入口
executorCallbackCall.enqueue(new Callback<ResponseBody>() {@Overridepublic void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {}@Overridepublic void onFailure(Call<ResponseBody> call, Throwable t) {}
});

用户传入了回调接口 new Callback() 用于获取网络请求返回的数据。executorCallbackCall.enqueue() 进入到“黑盒”进行一系列的构建。它主要完成了：

让OkHttpCall.enqueue()去进行请求体构建和发起网络请求
用 Callback 回调接口收取从 OkHttpCall 回传的数据
**线程切换：**将上层传来的 Callback接口的回调函数放在设定的线程环境中执行

我们看到其enqueue() 方法：

//[ExecutorCallbackCall<T>.java]
static final class ExecutorCallbackCall<T> implements Call<T> {final Executor callbackExecutor;final Call<T> delegate;//构造函数，在上一章节调用//1.切换回调函数执行线程的工具//2.传入了OkHttpCall<>ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {this.callbackExecutor = callbackExecutor;this.delegate = delegate;}@Overridepublic void enqueue(final Callback<T> callback) {Objects.requireNonNull(callback, "callback == null");//OkHttpCall<T>.enqueue()delegate.enqueue(//回调接口，接收从OkHttpCall<T>回传的数据new Callback<T>() {@Overridepublic void onResponse(Call<T> call, final Response<T> response) {//在这里进行线程切换//step2. 将 Runnable 放到 callbackExecutor设置的线程中执行（默认CallAdapter工厂传入的是MainExecutor，即主线程）callbackExecutor.execute(//step1. 将接口回调的逻辑封装到 Runnable 中() -> {if (delegate.isCanceled()) {callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));} else {callback.onResponse(ExecutorCallbackCall.this, response);}});}//其他回调()...});}//同步发起网络请求@Overridepublic Response<T> execute() throws IOException {return delegate.execute();}//...其他回调 delegate.回调()
}

由此可见，为了减轻用户在使用Okhttp时候总要考虑线程切换的烦恼，Retrofit 将线程切换的功能放到了黑盒中，具体如何切换是一个策略模式，用户只需要在初始化 Retrofit 的时候设置一下就够了。（由于默认线程切换到主线程回调，所以用户甚至都不用设置！）

我们在接下去看 OkHttpCall ，它有三个主要任务：

createRawCall() 构建请求体
okhttp3.call.enqueue() 真正发起网络请求
对响应数据Response 进行数据适配转换（Convert）

进入到 OkHttpCall 的 enqueue() 方法中：

//[OkHttpCall.java]
@Override
public void enqueue(final Callback<T> callback) {okhttp3.Call call;Throwable failure;//线程安全synchronized (this) {//1. createRawCall()构建请求体call = createRawCall();}//2. okhttp3.call.enqueue() 真正由okhttp发起网络请求call.enqueue(new okhttp3.Callback() {@Overridepublic void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {Response<T> response;//3. 对响应数据Response 进行数据适配转换（Convert），这里是例如： gson->javabean 的转换(请求时 javabean->gson 的转换在请求体构建中完成)response = parseResponse(rawResponse);//将数据转换后的数据通过回调接口回传给ExecutorCallbackCallcallback.onResponse(OkHttpCall.this, response);}//其他回调...});
}

我们先来看一下第一步，构建请求体：

private okhttp3.Call createRawCall() throws IOException {okhttp3.Call call = callFactory.newCall(requestFactory.create(args));if (call == null) {throw new NullPointerException("Call.Factory returned null.");}return call;
}

显然构建请求体有两步：

构建Request
构建Call

由requestFactory.create() 来构建 Request：

//[RequestFactory.java]
okhttp3.Request create(Object[] args) throws IOException {//参数上的注解处理器ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;//Call需要用到的请求体RequestBuilder requestBuilder =new RequestBuilder(...);List<Object> argumentList = new ArrayList<>(argumentCount);//遍历所有传入参数for (int p = 0; p < argumentCount; p++) {argumentList.add(args[p]);//将传入参数和注解处理器的记录的标记进行结合/应用/绑定handlers[p].apply(requestBuilder, args[p]);}return requestBuilder.get().tag(Invocation.class, new Invocation(method, argumentList)).build();
}

其中 parameterHandlers 是初始化 RequestFactory 时传入的，RequestFactory是在动态代理 loadServiceMethod() -> ServiceMethod.parseAnnotations()的时候时候初始化的：

RequestFactory的主要任务是：解析方法上的和参数上的注解，并记录下来，成为构建 RequestBody 中需要使用的 key。

//[RequestFactory.java]
//主要任务：解析方法上的和参数上的注解，并记录下来，成为RequestBody 中需要使用的 key
static final class Builder{//...//在这里解析注解！！！RequestFactory build(){for (Annotation annotation : methodAnnotations) {//1. 解析方法上的注解parseMethodAnnotation(annotation);}//..int parameterCount = parameterAnnotationsArray.length;parameterHandlers = new ParameterHandler<?>[parameterCount];for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {parameterHandlers[p] =//2. 解析参数上的注解parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);}return new RequestFactory(Builder.this);}
}

简单看一下解析方法上注解的实现，和解析参数上注解的实现：

解析方法上的注解（方法上的注解可能有多个，每个都解析一下）：

//[RequestFactory.java]
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) {parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);} //...else if (annotation instanceof FormUrlEncoded) {if (isMultipart) {throw methodError(method, "Only one encoding annotation is allowed.");}isFormEncoded = true;}//如果不是 Retrofit 能处理的注解，就不管了
}

解析参数上的注解（参数上的注解也可能有多个，每个都解析一下）：

//[RequestFactory.java]
private @Nullable ParameterHandler<?> parseParameter(...){for (Annotation annotation : annotations) {ParameterHandler<?> annotationAction =parseParameterAnnotation(p, parameterType, annotations, annotation);}//...
}private ParameterHandler<?> parseParameterAnnotation(...){//检验异常、注解间的互斥关系if(annotation instanceof Url){if (gotUrl) {throw parameterError(method, p, "Multiple @Url method annotations found.");}//...gotUrl = true;return new ParameterHandler.RelativeUrl(method,p);}
}

构建请求体的时候，需要将参数上的注解处理器parameterHandler和传入参数做绑定，调用的是 ParameterHandler<>的 apply 方法，主要任务是将注解意义和参数值结合起来交给 RequestBuilder：

我们看到它在 Header in ParameterHandler 中的实现，它主要做了两件事：

将数据进行转换Convert，如：javabean -> gson
将注解意义和参数值，填充到 RequestBuilder 中

//[Header in ParameterHandler.java]
static final class Header<T> extends ParameterHandler<T> {private final String name;private final Converter<T, String> valueConverter;Header(String name, Converter<T, String> valueConverter) {this.name = Objects.requireNonNull(name, "name == null");this.valueConverter = valueConverter;}@Overridevoid apply(RequestBuilder builder, @Nullable T value) throws IOException {if (value == null) return; // Skip null values.//数据转换器进行 javabean->gsonString headerValue = valueConverter.convert(value);if (headerValue == null) return; // Skip converted but null values.//将 key value 放到 requestBuilder 中builder.addHeader(name, headerValue);}
}

完全构造好后，回到 RequestFacoty.create()，将拼接好的 Request 返回给上层

//[RequestFactory.java]
okhttp3.Request create(Object[] args) throws IOException {//参数上的注解处理器ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;//Call需要用到的请求体RequestBuilder requestBuilder =new RequestBuilder(...);List<Object> argumentList = new ArrayList<>(argumentCount);//遍历所有传入参数for (int p = 0; p < argumentCount; p++) {argumentList.add(args[p]);//将传入参数和注解处理器的记录的标记进行结合/应用/绑定，拼接到requestBuilder 中handlers[p].apply(requestBuilder, args[p]);}return requestBuilder.get().tag(Invocation.class, new Invocation(method, argumentList)).build();
}

接下去就是构建call，并且发送网络请求。回到 OkHttpCall:

//[OkHttpCall.java]
@Override
public void enqueue(final Callback<T> callback) {okhttp3.Call call;Throwable failure;//线程安全synchronized (this) {//1. createRawCall()构建请求体call = createRawCall();}//2. okhttp3.call.enqueue() 真正由okhttp发起网络请求call.enqueue(new okhttp3.Callback() {@Overridepublic void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {Response<T> response;//3. 对响应数据Response 进行数据适配转换（Convert），这里是例如： gson->javabean 的转换(请求时 javabean->gson 的转换在请求体构建中完成)response = parseResponse(rawResponse);//将数据转换后的数据通过回调接口回传给ExecutorCallbackCallcallback.onResponse(OkHttpCall.this, response);}//其他回调...});
}

至此，网络请求发起完成。后续的线程切换，也在 ExecutorCallbackCall 中讲述过了。当然，线程切换可以支持其他工厂，如Rxjava，那么CallAdapter适配器就可以把 OkHttpCall 转成我们所需的 Observable 类型。

5. 总结

1.数据转换在哪里完成？

在OkHttpCall的enqueue()中，OkHttpCall主要负责三个任务：

通过RequestFactory解析来的注解，和传入参数，进行 requestBuilder的拼接，构建 okhttp3.Request
创建 okhttp3.Call 进行网络通信
将返回数据进行数据转换，返回给上层

从 javabean 到 string(如json)的转换，在ParameterHandler.apply()中完成，或者说是在将参数拼接到 requestBuilder的时候进行的转换

从 string(如json) 到 javabean 的转换，则是在响应数据 onResponse 时候做的，数据转换后再回调给上层。

2.Convert和CallAdapter的作用？

上面已经回答了 Convert 的作用。 CallAdapter主要是对 OkHttpCall的封装，用于上层处理网络请求的发起和结果，例如默认的 ExecutorCallbackCall 默认将上层回到接口转到主线程执行。也可以转成其他形式，例如 RxJava的Observable。

3. 动态代理在Retrofit中主要做了什么事？【获得对OkHttpCall进行再封装的上层对象】

将我们定义的接口Interface创建一个代理，代理中所有方法的实现，都是调用传入参数的 InvocationHandler 的 invoke() 方法，交给委托人来办具体的事务。这里的事务交给了 ServiceMethod，返回一个对OkHttpCall进行封装的类，默认是 DefaultCallAdapterFactory对OkHttpCall封装的ExecutorCallbackCall<>。它是用来做线程切换的。当然也可以返回一个由 RxJavaCallAdapterFactory 设计的 Observable。

4.Retrofit怎么知道接口需要交给哪个CallAdapterFactory做上层处理？【返回值类型】

特别的 Interface 中定义的方法如果返回值类型为 void 是不被允许的。

Interface中定义的方法的返回值类型是用来判断使用Retrofit的 callAdapterFactories集合中哪个 CallAdapterFactory 对该方法处理，如果全都无法处理，将会抛出异常！

比如返回值类型为 Call<>，现在有两个工厂: 一个是CompletableFutureCallAdapterFactory，一个是 DefaultCallAdapterFactory，第一个工厂发现返回值类型不是自己要的，返回空不作处理。直到遍历到 DefaultCallAdapterFactory 可以处理返回值类型为 Call<>的方法，就交给它对OkHttpCall包装。

一样的，RxJavaCallAdapterFactory 可以处理返回值为 Observable 的方法。

5. 相比直接用okhttp，使用retrofit有什么优势？
retrofit使用外观/门面设计模式对okhttp进行了再封装。okhttp有几大缺陷：对象头、参数等配置繁杂，返回结果需要手动解析，无法自动进行线程切换，可能会出现回调地狱。
1、retrofit通过构建者模式，将对象头等可以复用的信息保存在成员变量中
2.返回结果的处理使用策略模式让用户使用相关的库，例如 GsonConverterFactory进行javabean和json之间的转换，
3. OkHttpCall 封装简化了参数配置、数据解析，且可以让上层决定如何处理最后的回调接口的数据

6.retrofit用到了动态代理和反射，不会影响效率么？
动态代理和反射解析注解确实耗性能，但retrofit还涉及了缓存，将需要反射解析注解、动态代理才能生成的ServiceMethod进行了缓存，未来通过 Method 对象，就可以找到与它对应的 ServiceMethod对象，进行例如 Call<>、Observable<>等的构建，速度很快，只有两步：1.invoke()生成OkHttpCall（） 2. HttpServiceMethod子类的adapt进行适配，装饰为返回值类型。