Retrofit 大体框架

Retrofit
本人第一次撰写博客，希望和大家共同学习，有不足或者错误之处望不吝赐教，多谢各位。
我将从Retrofit 的大体框架出发，进而分析Retrofit 各个阶段所做的工作。最后将总结 Retrofit 值得我们学习的地方。
我们都知道Retrofit 并不负责真正的网络请求，而是对 OkHttp 的二次封装，所以有人就会问：为什么放着好好的 OkHttp 不用，非得用Retrofit 呢。这是因为OkHttp 用着不方便，原因有以下几点：

请求前网络请求配置繁琐，模板代码多，特别是配置复杂的body、请求头、参数的时候。
网络返回时，客户端需要手动拿到ResponseBody 进行解析，且无法复用。
网络返回时无法做到线程切换。

Retrofit 就是为了解决这几个问题：网络配置、数据转换、线程切换

一、大体框架

关键类：Retrofit、ServiceMethod、HttpServiceMethod、CallAdapted、RequestFactory、DefaultCallAdapterFactory、OkHttpCall。

类	作用
Retrofit	网络请求的门面，build方法配置参数，create 方法运用动态代理，生成代理类，进行统一的操作，形成切面
ServiceMethod	Retrofit 动态代理执行的方法所属类，解析方法上的注解
HttpServiceMethod	ServiceMethod 的子类，用于组装解析好的注解，和retrofit 实例中的属性callFactory、responseConverter、callAdapter
CallAdapted	请求适配发起的类，将okHttp 的Call 转化需要适配的请求
RequestFactory	解析 Retrofit 注解，并作为类属性存储
DefaultCallAdapterFactory	默认网络适配器
OkHttpCall	执行网络请求的类，接收requestFactory，callFactory，responseConverter
Converter	数据转换器
ExecutorCallbackCall	Retrofit 构建默认返回的Call 对象

![RetrofitSequence.png](https://img-blog.csdnimg.cn/img_convert/16dcd5ebd11763f7bb1f42895dfe8b37.png#averageHue=#faf9f9&clientId=uc02fdeaa-7c7f-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=u7f860ec6&margin=[object Object]&name=RetrofitSequence.png&originHeight=1059&originWidth=1694&originalType=binary&ratio=1&rotation=0&showTitle=true&size=131101&status=done&style=none&taskId=u21e250ac-5d9c-412b-999e-ae3c00199d7&title=Retrofit 流程图 “Retrofit 流程图”)

1.Retrofit 使用方式

//网络请求的接口类
public interface NetworkService {Call<JsonObject> request(@HeaderMap Map<String, Object> headers, @Body RequestBody requestBody);
}//构建 Retrofit 对象Retrofit retrofit = new Retrofit.Builder().baseUrl(BASE_URL).client(okHttpClient).addCallAdapterFactory(RxJava2CallAdapterFactory.create()).addConverterFactory(GsonConverterFactory.create()).build();//获得实现接口的实体类对象
networkService = retrofit.create(NetworkService.class);//调用接口方法，实现网络请求
networkService.request().enqueue(new Callback<JsonObject>() {@Overridepublic void onResponse(Call<JsonObject> call, Response<JsonObject> response) {}@Overridepublic void onFailure(Call<JsonObject> call, Throwable t) {}});

Retrofit 使用起来非常方便，共包含以上四个步骤

书写网络请求的接口类
构建 Retrofit 对象
使用retrofit 对象获得实现接口的实体类对象
调用接口方法，实现网络请求

这里，如果是没有阅读过源码的同学可能就会有以下问题：

Retrofit 构建者模式中传递的参数有何用，在哪里用
发起网络请求的实体类对象 networkService 从何而来。为什么使用retrofit 对象能够获得实现接口的实体类对象

我们带着这两个问题进入源码。

问题一：Retrofit 构建者模式中传递的参数有何用，在哪里用

查看 build() 方法源码，可见只是将一些属性传递给 Retrofit，并且会给一些默认值，如callFactory、callbackExecutor、callAdapterFactories。

public Retrofit build() {//服务器地址if (baseUrl == null) {throw new IllegalStateException("Base URL required.");}//Call Factory 在 Build.client 中赋值，网络请求的 Call 对应clientokhttp3.Call.Factory callFactory = this.callFactory;if (callFactory == null) {callFactory = new OkHttpClient();}//回调方法执行器，默认为安卓的执行器 PlatForm.Android.defaultCallbackExecutor Handler 实现Executor callbackExecutor = this.callbackExecutor;if (callbackExecutor == null) {callbackExecutor = platform.defaultCallbackExecutor();}// 网络请求适配器 List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));// 添加数据转换器List<Converter.Factory> converterFactories = new ArrayList<>(1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());// Add the built-in converter factory first. This prevents overriding its behavior but also// ensures correct behavior when using converters that consume all types.converterFactories.add(new BuiltInConverters());converterFactories.addAll(this.converterFactories);converterFactories.addAll(platform.defaultConverterFactories());return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
}

最后调用 Retrofit 构造方法返回Retrofit 实例

  Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,List<Converter.Factory> converterFactories, List<CallAdapter.Factory> callAdapterFactories,@Nullable Executor callbackExecutor, boolean validateEagerly) {this.callFactory = callFactory;this.baseUrl = baseUrl;this.converterFactories = converterFactories; // Copy+unmodifiable at call site.this.callAdapterFactories = callAdapterFactories; // Copy+unmodifiable at call site.this.callbackExecutor = callbackExecutor;this.validateEagerly = validateEagerly;}

其中赋值了Retrofit 所需的基本参数

参数	功能
callFactory	网络请求器，对应 client
baseUrl	访问服务器域名地址
converterFactories	数据转换器
callAdapterFactories	网络请求适配器
callbackExecutor	回调方法执行器

提前先说明各个参数在何处用，让大家形成一个宏观的结构。

问题二：发起网络请求的实体类对象 networkService 从何而来。为什么使用retrofit 对象能够获得实现接口的实体类对象

create 方法使用动态代理，生成代理类，形成切面，完成统一操作。所有的方法都执行到了loadServiceMethod(method).invoke(args != null ? args : emptyArgs) 这一行代码。所以查看loadServiceMethod 方法和 invoke（）方法的源码。看一下返回和执行的到底是一个什么东西。

 public <T> T create(final Class<T> service) {Utils.validateServiceInterface(service);return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },new InvocationHandler() {private final Platform platform = Platform.get();private final Object[] emptyArgs = new Object[0];@Override public @Nullable Object invoke(Object proxy, Method method,@Nullable Object[] args) throws Throwable {// If the method is a method from Object then defer to normal invocation.if (method.getDeclaringClass() == Object.class) {return method.invoke(this, args);}if (platform.isDefaultMethod(method)) {     return platform.invokeDefaultMethod(method, service, proxy, args);}//关键代码return loadServiceMethod(method).invoke(args != null ? args : emptyArgs);}});}

loadServiceMethod 方法 method(类方法) -> ServiceMethod，里面还有缓存处理，暂时不必关注这一块

  ServiceMethod<?> loadServiceMethod(Method method) {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;}

查看 ServiceMethod 类中的 parseAnonotations 方法，这里解析了方法上的注解，组装网络请求的工厂，并在HttpServiceMethod进行进一步的数据解析。

static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {//这里解析注解，组装了网络请求的工场RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);//将解析的注解作为HttpServiceMethod构造器参数return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);}

进而查看HttpServiceMethod （ServiceMethod 的子类）的构造器，这里不深入，只查看方法返回的类型

  static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);}

这里由传入的retrofit 对象获取callFactory，responseConverter，callAdapter（重点关注这个） 以及解析的注解的requestFactory。
CallAdapted 是 HttpServiceMethod 的子类。

  static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {private final CallAdapter<ResponseT, ReturnT> callAdapter;CallAdapted(RequestFactory requestFactory, okhttp3.Call.Factory callFactory,Converter<ResponseBody, ResponseT> responseConverter,CallAdapter<ResponseT, ReturnT> callAdapter) {super(requestFactory, callFactory, responseConverter);this.callAdapter = callAdapter;}@Override protected ReturnT adapt(Call<ResponseT> call, Object[] args) {return callAdapter.adapt(call);}}

回过头查看动态代理中的invoke方法，发现最后调用的是 HttpServiceMethod 的invoke 方法

  @Override final @Nullable ReturnT invoke(Object[] args) {Call<ResponseT> call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);return adapt(call, args);}

invoke 方法中构造了一个 OkHttpCall 的实例，最后执行 adapt 函数，即执行到了上述子类 CallAdapted 的 adapt 函数。

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

所以最终我们要查看 callAdapter 究竟是如何构建的。
这就涉及到细节了，这里就放到下一节说明。这里我们知道 callAdapter只是将 OkHttpCall 适配成为 ExecutorCallbackCall，所以最终接口方法执行后返回的就是一个 ExecutorCallbackCall 的实例。