Retrofit源码简单解析一

因为最近要找工作，所以重温了一下Retrofit。

先看下Retrofit的基本使用

public static Retrofit getRetrofit()
    {
        if (retrofit==null)
        {
            retrofit = new Retrofit.Builder()
                    .baseUrl(Api.BASE_URL)
                    .client(getClient())
                    .addConverterFactory(ScalarsConverterFactory.create())
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())//使用rxjava
                    .build();
        }
        return retrofit;
    }

从创建开始分析，Retrofit的创建过程同样也是熟悉的建造者模式。

先看第一行，baseUrl()这个大家都知道，就是配置你的主机地址。

client()，这个是配置OkHttpClient，因为Retrofit其实是对OkHttp的进一步封装，所以要依赖OkHttpClient

再往后是两个add...Factory() ，这个先暂且不谈，我们直接看build（）方法

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<CallAdapter.Factory> adapterFactories = new ArrayList<>(this.adapterFactories);
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

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

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

可以看到，先判断baseUrl,如果为空直接抛异常。这就告诉我们baseUrl必须配置

然后判断CallFactory,如果我们没有配置的话，他会直接给创建一个新的OkHttpClient，所以为了方便起见

我们还是配置自己的OkHttpClient。

再往下是一个callbackExecutor

Executor??? 这是个啥？？？

Executor只是一个接口，它是Java／Android线程池框架的基础，它将任务的提交与任务的执行分离开来。

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

好吧。它里面只有一个方法，excute(Runnable command)；里面接受一个Runnable对象

也就是一个线程。暂且先知道这么多，接着看

出现了platform,这个又是个啥？？？

咱们找一下它

 public static final class Builder {
    private Platform platform;
    private okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private List<Converter.Factory> converterFactories = new ArrayList<>();
    private List<CallAdapter.Factory> adapterFactories = new ArrayList<>();
    private Executor callbackExecutor;
    private boolean validateEagerly;

    Builder(Platform platform) {
      this.platform = platform;
      // 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());
    }

    public Builder() {
      this(Platform.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) {
    }
    try {
      Class.forName("org.robovm.apple.foundation.NSObject");
      return new IOS();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }

发现他是通过Class.forName()；返回你的系统类型。

那咱们再回过头来看。

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

发现调用了defaultCallbackExecutor()方法，接着看

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

找到了，原来最后还是通过Looper.getMainLooper()得到的主线程的Handler。

然后利用Handler.post()方法进行的线程切换。

好吧。

今天先到这吧。

明天接着来。