Retrofit源码简析

Retrofit相关时序图

创建Retrofit对象实例

通常使用Retrofit，如下：

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

new Retrofit.Builder()

 

public Builder() {
  this(Platform.get());
}
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());
}

Platform.get()

static Platform get() {
    return PLATFORM;
  }

PLATFORM

private static final Platform PLATFORM = findPlatform();

findPlatform()

private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      //目前是在Android里面应用，所以走的这个分支
      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();
  }

new Android()

//Android类是继承自Platform的,重写了Platform的两个方法
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 {
      //这里Handler初始化用的是getMainLooper(),说明此Handler最后是运行在UI线程的
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }

baseUrl这儿略过，只是设置一个基础的HttpUrl，不做深入研究。

client()方法：

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

    //在这里可能会有疑问，如果在new Retrofit.Builder对象的时候，没有调用Client方法，
    //那么岂不是没有可用于发送网络请求的OkHttpClient了？这个问题接着往下看会做解释
    public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = checkNotNull(factory, "factory == null");
      return this;
    }

Client方法其实就是给Retrofit.Builder对象设置一个OkHttpClient对象，用于后续网络请求时使用，Retrofit其实就是对OkHttp的封装；在这里可能会有疑问，如果在new Retrofit.Builder对象的时候，没有调用Client方法，那么岂不是没有可用于发送网络请求的OkHttpClient了？这个问题接着往下看就会明白，其实是在Retrofit.Builder的build方法中，发现client为null的时候，就会new 一个OkHttpClient出来。

下面要上关键点了，主要看addCallAdatperFactory和addConvertFactory，搞清楚这两个东西的调用和来源，基本上Retrofit的原理就清晰很多了：

addCallAdatperFactory和addConvertFactory:

addCallAdatperFactory

private final List converterFactories = new ArrayList<>();
private final List adapterFactories = new ArrayList<>();   

public Builder addConverterFactory(Converter.Factory factory) {
    //把ConvertFactory添加到一个List集合中，集合会在Retrofit.Builder的build方法中被使用
    converterFactories.add(checkNotNull(factory, "factory == null"));
    return this;
}

public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
    //把CallAdatperFactory添加到一个List集合中，集合会在Retrofit.Builder的build方法中被使用
    adapterFactories.add(checkNotNull(factory, "factory == null"));
    return this;
}

接下来看Retrofit.Builder的build方法：

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

      okhttp3.Call.Factory callFactory = this.callFactory;
      //如果在调用build()方法之前，并没有调用client方法，那么在此处会new 一个OkHttpClient
      //用于后续做网络请求
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      Executor callbackExecutor = this.callbackExecutor;
      //默认的Executor是DefaultCallbackExecutor由于是在Android平台使用，
      //这里是Platformat的内部类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，也就是说callbackExecutor，其实就是类MainThreadExecutor的对象实例
      //如果调用execute方法同步执行网络请求，那么就是执行的MainThreadExecutor的execute方法，通过创建UI线程的Handler对象，
      //将execute的任务post出来，然后执行。
      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);
    }
  }

到这里，Retrofit对象就创建完毕了，接下来该是生成请求接口对象实例了，一般都是调用Retrofit.create方法：

//生成网络请求接口实例
//这里需要思考一个问题，Java中Interface是没有办法实例化的，那么Retrofit是通过怎样的方式生成Interface实例对象的呢，答案就是动态代理
WanAndroidApi wanAndroidApi = retrofit.create(WanAndroidApi.class);

//Retrofit.java
public  T create(final Class service) {
    Utils.validateServiceInterface(service);
    if (validateEagerly) {
      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, Object[] args)
              throws Throwable {
            // If the method is a method from Object then defer to normal invocation.
            //如果调用的方法是Object类的方法，比如wait，toString，hashCode等，那么不做额外处理，直接调用返回
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            //跟踪代码可知，platform的isDefaultMethod返回false，故此分支进不去
            /*
            boolean isDefaultMethod(Method method) {
                return false;
            }
            */
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            //最终会执行loadServiceMethod方法
            ServiceMethod serviceMethod =
                (ServiceMethod) loadServiceMethod(method);
            OkHttpCall