Android开源框架之Retrofit （二）

源码解析

Retrofit通过使用大量的设计模式进行功能模块的解耦。

Retrofit将各个功能模块进行了封装，只暴露了Retrofit核心类，只管配置Retrofit，然后做请求。剩下的事情就跟上层无关了，只需要等待回调，这就是外观模式的运用。

1、Retrofit实例是使用建造者模式通过内部Builder类进行创建的。

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

    Builder(Platform platform) {
      this.platform = platform;
      //添加一个默认的Converter
      converterFactories.add(new BuiltInConverters());
    }

    public Builder() {
      //Platform.get()获取支持的平台，Android
      this(Platform.get());
    }
    //这个一般不会用到
    Builder(Retrofit retrofit) {
      platform = Platform.get();
      callFactory = retrofit.callFactory;
      baseUrl = retrofit.baseUrl;
      converterFactories.addAll(retrofit.converterFactories);
      adapterFactories.addAll(retrofit.adapterFactories);
      // Remove the default, platform-aware call adapter added by build().
      adapterFactories.remove(adapterFactories.size() - 1);
      callbackExecutor = retrofit.callbackExecutor;
      validateEagerly = retrofit.validateEagerly;
    }

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

    public Builder callFactory(okhttp3.Call.Factory factory) {
      this.callFactory = checkNotNull(factory, "factory == null");
      return this;
    }


    public Builder baseUrl(String baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      HttpUrl httpUrl = HttpUrl.parse(baseUrl);
      if (httpUrl == null) {
        throw new IllegalArgumentException("Illegal URL: " + baseUrl);
      }
      return baseUrl(httpUrl);
    }


    public Builder baseUrl(HttpUrl baseUrl) {
      checkNotNull(baseUrl, "baseUrl == null");
      List pathSegments = baseUrl.pathSegments();
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }
      this.baseUrl = baseUrl;
      return this;
    }

    public Builder addConverterFactory(Converter.Factory factory) {
      converterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }

    public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
      adapterFactories.add(checkNotNull(factory, "factory == null"));
      return this;
    }

    public Builder callbackExecutor(Executor executor) {
      this.callbackExecutor = checkNotNull(executor, "executor == null");
      return this;
    }

    public Builder validateEagerly(boolean validateEagerly) {
      this.validateEagerly = validateEagerly;
      return this;
    }

    //这里可以看出baseUrl不能为空
    public Retrofit build() {
      if (baseUrl == null) {
        throw new IllegalStateException("Base URL required.");
      }
      //判断callFactory是否为空，如果不设置为空的话就创建一个OkHttpClient
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        //获取Android平台下的CallbackExecutor，返回的是MainThreadExecutor
        callbackExecutor = platform.defaultCallbackExecutor();
      }
      
      List adapterFactories = new ArrayList<>(this.adapterFactories);
      //获取默认的CallAdapterFactory，返回的是ExecutorCallAdapterFactory
      adapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

      List converterFactories = new ArrayList<>(this.converterFactories);

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

在创建Builder实例时调用的是Builder的无参构造放法，里面调用了Builder(Platform)这个构造方法，传入的是Platform.get()返回数据，这个方法是获取适配平台，返回Android。

可以通过Builder传入BaseUrl、callFactory、ConverterFactory、CallAdapterFactory等等。

调用build方法中主要是为了进行判断，设置默认的信息。最后创建一个Rretrofit对象返回。

Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
  List converterFactories, List adapterFactories,
  Executor callbackExecutor, boolean validateEagerly) {
    //将Builder中传入的对象存储到对应的变量中
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = unmodifiableList(converterFactories); 
    this.adapterFactories = unmodifiableList(adapterFactories);
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
}

Retrofit对象创建完毕后，然后调用create方法生成接口实例对象。

2、create方法

create方法中使用的是动态代理的形式去生成实例接口对象。

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, @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