Retrofit2源码分析

一、Retrofit2源码地址
    Retrofit2源码地址：https://github.com/square/retrofit

二、Retrofit2简单使用
    1、首先创建用于网络请求的API接口：

public interface NetService {
    @GET("cozing")
    Call serviceApi();
}

    2、创建用于接收请求返回的数据接收：

public class NetResponse {
    private int id;
    private String name;
}

    3、创建Retrofit实例并做交易请求：

public class Retrofit2TestForBlogActivity extends BaseActivity{
...
    private void retrofitTest(){
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://github.com/") //必须以"/"结尾，不然将抛出异常
                .addConverterFactory(GsonConverterFactory.create())
                //.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
 
        NetService netApi = retrofit.create(NetService.class);
        Call call = netApi.serviceApi();
        try {
            //① 同步请求
            Response response = call.execute();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //②异步请求
        call.enqueue(new Callback() {
            @Override
            public void onResponse(Call call, Response response) {
 
            }
 
            @Override
            public void onFailure(Call call, Throwable t) {
 
            }
        });
    }
}

      通过以上代码，咱们完成了请求，其中咱们向：

url = https://github.com/cozing
发送GET请求，在注释①处发起同步请求，在注释②处发送异步请求，交易的结果通过调用返回的Response对象实例的response.body()获取，这个结果就是咱们在构建网络请求时传入的NetResponse数据结构。

接下来看Retrofit2整体架构流程图。

 

三、架构流程
1、流程图

2、流程讲解
    1、创建Retrofit实例；

    2、创建网络请求接口和相关属性注解；

    3、通过动态代理解析请求接口的注解，并生成网络请求对象；

    4、通过CallAdapter进行平台适配，平台包括（Android/java8/iOS）；

    5、通过OkHttpCall发送网络请求；

    6、通过Converter数据转换适配器转换交易返回的数据；

    7、通过线程切换执行器切换到主线程（仅限异步请求）。

 

四、源码分析
1、Retrofit的内部成员变量

public final class Retrofit {
  private final Map> serviceMethodCache = new ConcurrentHashMap<>(); //网络请求缓存，如：请求方法、请求头、请求体，各种适配器等
 
  final okhttp3.Call.Factory callFactory; //okhttp工厂，真正发送交易的处理类
  final HttpUrl baseUrl; //请求url前半部，基地址
  final List converterFactories; //数据转换器工厂集
  final List adapterFactories; //网络请求适配器工厂集
  final @Nullable Executor callbackExecutor; //异步请求结果线程切换执行器
  final boolean validateEagerly; //标志位、是否马上解析接口方法
...
}

2、Retrofit内部类Builder

public final class Retrofit {
...
  public static final class Builder {
    private final Platform platform; //适配平台，通常默认android
    private @Nullable okhttp3.Call.Factory callFactory; //okhttp网络请求工厂，默认okhttp
    private HttpUrl baseUrl; //基地址
    private final List converterFactories = new ArrayList<>(); //数据转换器集，用于生产数据转换器，默认GsonConverterFactory
    private final List adapterFactories = new ArrayList<>(); //网络请求适配器，如RxJava2CallAdapterFactory
    private @Nullable Executor callbackExecutor; //执行异步回调的线程切换
    private boolean validateEagerly; //是否立即解析接口注解方法
  } 
...
}

3、创建Retrofit实例

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

内部类Builder实现：

public final class Retrofit {
...
  public static final class Builder {
   ...
    Builder(Platform platform) {
      this.platform = platform;
      converterFactories.add(new BuiltInConverters());//添加默认数据解析器
    }
 
    public Builder() {
      this(Platform.get());
    }
  }
}

    咱们在创建Builder实例时调用的是Builder的无参构造放法，里面调用了Builder(Platform)这个构造方法，传入的是Platform.get()返回数据，这个方法是获取适配平台，默认是Android，其他平台咱们不做过多分析，直接查看Android：

class Platform {
...
  static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }
 
    @Override CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
      if (callbackExecutor == null) throw new AssertionError();
      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);
      }
    }
  }
...
}

    可以看到在创建Builder实例的设配平台时，将工作线程切换到了主线程，这也是后面可以通过主线程回调返回请求数据的原因。

    接着将会在Builder的有参构造方法中的添加Retrofit默认的数据解析器：

converterFactories.add(new BuiltInConverters());
4、Builder.build()方法

public final class Retrofit {
...
  public static final class Builder {
    ...
    public Retrofit build() {
      if (baseUrl == null) { //对baseurl进行非空判断
        throw new IllegalStateException("Base URL required.");
      }
 
      //注释①
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient(); //创建okhttp客户端
      }
      //注释②
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }
 
      List adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
 
      List converterFactories = new ArrayList<>(this.converterFactories);
 
      return new Retrofit(callFactory, baseUrl, converterFactories, adapterFactories,
          callbackExecutor, validateEagerly);
    }
  }
}

    首先咱们看注释①处，上面说过Retrofit2框架的底层发送交易其实是提交给了okhttp框架，在okhttp3源码讲解时咱们说过在okhttp中OkhttpClient在整个进程中只创建一次，所以在这里做了相关判断。

    注释②处，可以看到是获取回调执行器，如果没有设置回调执行器，就创建一个默认的主线程回调执行器。

    最后调用Retrofit的构造方法，创建一个Retrofit实例。可以看到整个创建Retrofit过程中，通过构建者模式来执行一系列初始化和对象的创建。

5、retrofit.create()
    接着咱们创建了网络请求接口类NetService.class，在下面的步骤中咱们调用retrofit.create(NetService.class)，这个方法是Retrofit的核心，内部采用动态代理，将咱们自定义的网络请求接口转换成一个ServiceMethod对象，ServiceMethod就是咱们Retrofit中的具体请求对象，里面封装了网络请求所必须的全部信息，包括请求方法、url、请求头、请求体等网络配置参数！

    咱们现在看看create（）源码：

...
  public  T create(final Class service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) { //创建retrofit实例时提到的标志位
      //注释①
      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, @Nullable 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 =
                (ServiceMethod) loadServiceMethod(method);
            OkHttpCall