通过Retrofit2来看http

通过Retrofit2来看http

• 什么是retrofit2

从字面理解retrofit2就是用于Android和java平台的类型安全可靠的http请求框架。什么是类型安全呢，所谓类型安全就是编译阶段就已经做了类型检查，在程序运行阶段不会报类型错误。

上述文字是官网描述，这里个人再补充一点，retrofit2实际上是对http请求的一个封装，底层还是通过okhttp进行网络请求的，本节只对retrofit2进行源码分析，后续会补充okhttp的源码分析。

• retrofit2的简单使用

1.定义一个java接口以及http请求方法

public interface GitHubService {
  @GET("users/{user}/repos")
  Call> listRepos(@Path("user") String user);
}

2.构造Retrofit实例，可配置baseUrl

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

3.调用Retrofit实例的create方法生成GitHubService接口实例

GitHubService service = retrofit.create(GitHubService.class);

4.调用GitHubService的listRepos方法获取Call对象

Call> repos = service.listRepos("octocat");

5.通过Call对象去获取请求

repos.enqueue(new Callback() {
    @Override
    public void onResponse(Call> call, Response> response) {
    
    }
    @Override
    public void onFailure(Call> call, Throwable t) {
    }
});

• retrofit2的源码解读
  简单使用了解过后，接下来进行源码解读。该怎么读源码呢，博主的方法不是一行一行的去读，而是从入口去读，即从正在使用的地方去读，读懂过整个流程和框架，不过分去弄清每一行代码，要不然大把的时间耗费在里面得不偿失。

1.先来看看Retrofit的构造方法，看到builder()就知道是构造者模式创建的Retrofi实例，
这里只贴关键部分代码

    //使用的平台 Android 或者 java
    private final Platform platform;

	//用于网络请求的OkHttpClient
    private @Nullable okhttp3.Call.Factory callFactory;

   //请求服务器的baseUrl地址
    private HttpUrl baseUrl;

   //数据转换器工厂
    private final List converterFactories = new ArrayList<>();

   //网络适配器工厂
    private final List adapterFactories = new ArrayList<>();

    //任务执行器
    private @Nullable Executor callbackExecutor;

public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }

      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // Make a defensive copy of the adapters and add the default Call adapter.
      List adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      // Make a defensive copy of the converters.
      List converterFactories = new ArrayList<>(this.converterFactories);

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

这里重点关注callFactory，converterFactories，callFactory，callbackExecutor这几个对象，这里可以看到如果用户不自定callFactory，则new 一个 OkHttpClient对象。通过上述几个对象构造了Retrofit对象。

public Builder client(OkHttpClient client) {
      return callFactory(checkNotNull(client, "client == null"));
    }
·······················································
if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

然后我们看下callbackExecutor，通过platform.defaultCallbackExecutor()得到，我们先看看platfor是怎么获取的，platform = Platform.get();点击get()方法进去，

class Platform {
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

·········
}

可以看到返回PLATFORM，即findPlatform()方法，当Build.VERSION.SDK_INT != 0满足条件时，返回一个新生成的Android对象，否则返回一个Java8对象。再来看看Android类如下，所以 platform.defaultCallbackExecutor()返回的任务执行器实际上就是MainThreadExecutor对象，持有handler属性将异步任务会调到主线程中去。

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

List adapterFactories = new ArrayList<>(this.adapterFactories);
adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

接下来看看adapterFactories，无论是否自定义CallAdapter.Factory，都会在集合里面添加一个factory，可以看出是一个ExecutorCallAdapterFactory对象，并且将callbackExecutor作为参数传了进去。咱们先不看具体的ExecutorCallAdapterFactory类实现，回到主线代码来。

获取到Retrofit对象以后，执行create方法，点击进去

 public  T create(final Class service) {
   //验证interface接口，这里不贴具体代码了
   //1.首先验证是否是接口
   //2.验证是否有继承关系，Retrofit不允许此接口有继承关系
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
		//3.提前加载接口中的method
      eagerlyValidateMethods(service);
    }
    
    //4.动态代理
    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 serviceMethod =
                (ServiceMethod) loadServiceMethod(method);
            OkHttpCall