Retrofit源码分析

前言

        Retrofit是Square公司开源的一个针对OkHttp网络请求接口进行二次封装的框架，其网络请求的实质工作仍是由OkHttp来完成，主要工作是将网络请求通过一系列注解的形式进行拆解，并在最终执行网络请求前，将注解解析生成OkHttp请求所需的Okhttp3.Call。通过分析Retrofit源码，来达到深入理解Retrofit的工作流程与原理，以及学习一些值得借鉴的设计模式和启发一些解决问题的思路。
        对于源码中各种参数类型的相关知识，如有不理解的地方，可以参考贾博岩的两篇文章：我眼中的Java-Type体系。
https://www.jianshu.com/p/7649f86614d3
https://www.jianshu.com/p/e8eeff12c306

基本使用

第一步：集成

implementation 'com.squareup.retrofit2:retrofit:2.4.0'
implementation 'com.squareup.retrofit2:converter-gson:2.4.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.4.0'

第二步：创建接口

public interface JianShuApi {

    @GET("user/{userName}/info")
    Observable getPersonalInfo(@Path("userName") String userName);

}

第三步：配置Retrofit并实例化

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://www.jianshu.com")
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .addConverterFactory(GsonConverterFactory.create())
        .build();

第四步：获取接口对象

JianShuApi api = retrofit.create(JianShuApi.class);

第五步：执行请求

Call call = api.getPersonalInfo("zhangSanLisi");
//异步请求
call.enqueue(new Callback() {
        @Override
        public void onResponse(Call call, Response response) {
        //成功回调
        }

       @Override
       public void onFailure(Call call, Throwable t) {
        //失败回调
       }
});

//同步请求
try {
      Response response = call.execute();
} catch (IOException e) {
      e.printStackTrace();
}

源码分析

下面我们按照使用流程来分析：

1、自定义接口类

里面的请求方法，主要通过注解的方式来实现各种参数的灵活配置。如常用的请求方式@POST @GET，添加请求参数的@Query @QueryMap，大文件下载@Streaming，多文件提交@Multipart，请求头内容@Header @Headers...，具体注解使用请参考retrofit2.http里面的内容，每个注解都有相关的注释。

2、Retrofit.Builder

通过Retrofit.Builder构造者模式来实例化Retrofit对象，主要可配置的内容如下：

public static final class Builder {
    // 具体使用平台，Platform.get()方法来获取，这里只分析Android
    private final Platform platform;
    // 指定用来构建Call实例的Call.Factory类
    private @Nullable okhttp3.Call.Factory callFactory;
    // 请求的baseUrl，注释建议我们使用相对路径的方式来配置
    // Base URL: http://example.com/api/
    // Endpoint: foo/bar/
    // Result: http://example.com/api/foo/bar/
    private HttpUrl baseUrl;
    // 用于对象序列化(serialization)和反序列化(deserialization)，常用GsonConverterFactory
    private final List converterFactories = new ArrayList<>();
    // 请求返回类型(除了Call之外)，若Retrofit结合RxJava一起使用，那么就可以添加RxJava2CallAdapterFactory
    // 来返回Observable类型，无缝对接RxJava
    private final List callAdapterFactories = new ArrayList<>();
    // 异步回调执行者
    private @Nullable Executor callbackExecutor;
    // 是否提前校验注解方法
    private boolean validateEagerly;

    ......

    public Retrofit build() {
        // 必须指定baseUrl，否则异常
        if (baseUrl == null) {
             throw new IllegalStateException("Base URL required.");
        }
        //默认OkHttpClient来创建请求Call
        okhttp3.Call.Factory callFactory = this.callFactory;
        if (callFactory == null) {
            callFactory = new OkHttpClient();
        }
        // Android平台默认回调在主线程
        Executor callbackExecutor = this.callbackExecutor;
        if (callbackExecutor == null) {
           callbackExecutor = platform.defaultCallbackExecutor();
        }
        // 默认添加一个CallAdapter和Converter
        // Make a defensive copy of the adapters and add the default Call adapter.
        List callAdapterFactories = new ArrayList<>(this.callAdapterFactories); 
        callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

        // Make a defensive copy of the converters.
        List converterFactories = new ArrayList<>(1 + this.converterFactories.size());
        // 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);

        return new Retrofit(callFactory, baseUrl, unmodifiableList(converterFactories),
                    unmodifiableList(callAdapterFactories), callbackExecutor, validateEagerly);
    }
}

3、Retrofit.create()

public final class Retrofit {
......
public  T create(final Class service) {
        // 校验class必须是接口，并且不能继承其他接口
        Utils.validateServiceInterface(service);
        // 是否提前校验方法，提前创建ServiceMethod，如果自定义的接口方法存在不合规范则抛出异常
        if (validateEagerly) {
                eagerlyValidateMethods(service);
        }
        // 返回一个代理对象，当调用api方法的时候，代理对象执行
        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, 
                                            @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);
                         }
                         // 下面这两行是核心代码，生成ServiceMethod和请求OkHttpCall
                         ServiceMethod serviceMethod =
                                    (ServiceMethod) loadServiceMethod(method);
                         OkHttpCall