Retrofit 源码解析

Retrofit 源码解析

简单用法

Retrofit最简单的用法就是定义一个接口，创建Retrofit对象，调用create()方法得到一个service,
然后自己根据service中的方法去做同步或者异步的请求，拿到数据对象，十分简单快速，简单代码如下：

public interface GitHub {
   @GET("/repos/{owner}/{repo}/contributors")
   Call> contributors(@Path("owner") String owner,@Path("repo") String repo);
}

.创建
Retrofit retrofit = new Retrofit.Builder().baseUrl("xxx").build();
.代理
GitHub gitHub = retrofit.create(GitHub.class);
Call> call = gitHub.contributors("xx", "xx");
.执行
call.enqueue(new Callback>() {
    @Override
    public void onResponse(Call> call, Response> response) {

    }
    @Override
    public void onFailure(Call> call, Throwable t) {

    }
});

流程分析

创建

那这么简单的过程，刚开始看的时候觉得有点懵逼呀，怎么他就帮你完成了请求，你明明什么都没有做，下面我们按照它的流程慢慢来解析一下整个过程。
我们要用Retrofit,首先自然是要创建它,也就是这行代码Retrofit retrofit = new Retrofit.Builder().baseUrl("xxx").build();.
这里创建Retrofit是通过它的一个内部类Builder来创建的，也就是创建者模式，这个模式很简单，不知道的自行百度，谷歌。
好，我们来看看这个builder做了什么,除了初始化有个Platform.get(),直接看最后的build(),其余的方法都是设置参数，主要就是这个build()：

public Builder() {
      this(Platform.get());
}
public Retrofit build() {
  1.
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }
  2.
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }
  3.
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }
  4.
      // Make a defensive copy of the adapters and add the default Call adapter.
      List adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));
 5.
      // Make a defensive copy of the converters.
      List converterFactories = new ArrayList<>(this.converterFactories);

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

首先一初始化，就做了一件事情，是啥Platform.get()，Platform是啥？直译过来就是平台啊，平台是啥？为啥要有平台？看下面这个代码get()其实
就是一个就是调用findPlatform()：

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

有Android和Java8两种平台，Android我们还是能理解的，为啥还有个Java8，不要问我，我也不知道啊，Retrofit的作者炒鸡暖男，关心全世界各种码农，
我是个写android代码的我们就看Android平台就好了
下面我们来看一下build()这个方法：

• 第一步很简单，没有baseUrl抛出异常，最基本的没有，事情没法干是吧。
• 第二步，如果没有给他设置callFactory，那默认给他一个callFactory，默认就是新创建一个OkHttpClient，这里可能我们会有自己做过一些
  处理的OkHttpClient,比如加了Interceptor啊之类的，设置进来就好了，就不会用默认的。
  有人可能会问啥是callFactory啊 ？callFactory嘛，就是call的factory嘛，call是啥，就是请求，factory是啥，就是工厂，callFactory就是创建请求的
  工厂，OkHttpClient就是一个很牛逼的创建请求的工厂，不在本文讨论范围内，就不多言了。
• 第三步，设置callbackExecutor,又来一个，这callbackExecutor又是啥呢？callback就是回调嘛，啥回调，就是网络请求返回回来数据的回调，executor呢，就是执行者
  ，合起来就是回调的执行者，意思网络成功了之后交给他它了。如果你没有设置它就自己整一个默认的回调嘛，不能没有。但是这里它要搞事情了，它返回了一个啥？
  platform.defaultCallbackExecutor();来，我们看一下android下它返回的是啥：

static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
      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);
      }
    }
  }

是啥？MainThreadExecutor()啊，啥意思就是主线程啊，下面写的明明白白的Looper.getMainLooper()再把要执行的Runnablepost到主线程上执行
因为它是默认的嘛，可能就说大多数人都是得到数据更新UI啊啥的，所以就默认在主线程上执行回调了。我就不想拿到数据在主线程座做咋办，我拿到数据我就想更新数据库，
我想在IO线程上搞事情，那就自己写个callbackExecutor，自己在IO线程上做就好了，人家提供了一个方法callbackExecutor(Executor executor)给你，你自己设置进去就好了

• 第四步是啥？看代码说话，那就是设置callAdapterFactory啊 。callAdapterFactory又是什么鬼啊，和上面一样啊，拆分一下呀。CallAdapter啥意思，就是请求的
  适配器，请求的适配器是什么鬼啊。来来来我告诉你，你看看源码里面根目录是不是有一个包名字叫做'retrofit-adapter',这个包就是实现了一些列的CallAdapter
  意思就是你想将返回的数据用什么东西包装起来，比如你用Rxjava的话想返回Observable，或者高兴，想用Java8的CompletableFuture，这些都由你呀。
  但是这些都实现了一个叫CallAdapter的接口。我们来简单看看这个接口：

public interface CallAdapter {
  Type responseType();
  T adapt(Call call);
  abstract class Factory {
    public abstract CallAdapter get(Type returnType, Annotation[] annotations,
        Retrofit retrofit);
    protected static Type getParameterUpperBound(int index, ParameterizedType type) {
      return Utils.getParameterUpperBound(index, type);
    }
    protected static Class getRawType(Type type) {
      return Utils.getRawType(type);
    }
  }
}

其实接口里面就是两个方法还有一个静态的工厂类。responseType()这个方法决定请求回来之后返回的是什么类型的数据。比如在示例用法中我们的List
adapt()这个方法是干嘛的呢？就是适配嘛，就是怎样把返回回来的数据通过这个方法包装成你想要的对象。
这里看到这个名字adapter你想到了啥，其实就是传说中的适配器模式啊，就是我给你定义一个接口放这里，我在框架里的逻辑就用这个接口来做就好了，至于你想要怎样的实现，
想用框架供给你的一些实现比如Rxjava或者Java8的CallAdapter,或者是你自己心情好想用自己的实现一个其他的CallAdapter，你自己决定就好了。这就是传说中的啥？？扩展性好啊。
继续看build()
这个方法，它调用的是adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));· 再回来Platform看defaultCallAdapterFactory()返回的是一个ExecutorCallAdapterFactory。这个类他么的又来干嘛，当然是搞事情。 进去瞅一眼，发现了什么？它当然是继承CallAdapter.Factory了，这个不说了，看几句代码来，看它的get()方法，看看这个工厂是怎么造CallAdapter`的：

  public CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public Call