Retrifit简单的梳理

Retrofit

Retrofit的 一次网络请求流程，以及API接口中的参数是如何获取的

内部使用的OkHttp，先把OkHttp的使用放上，在Retrofit的源码中我们知道什么地方开始调用了OkHttpClient了。

OkHttp的使用

OkHttpClient okHttpClient = new OkHttpClient();
        Request request = new Request.Builder()
                .url("www.baidu.com")
                .build();

            okHttpClient.newCall(request).enqueue(new okhttp3.Callback() {
                @Override
                public void onFailure(okhttp3.Call call, IOException e) {

                }

                @Override
                public void onResponse(okhttp3.Call call, okhttp3.Response response) throws IOException {

                }
            });

下面是Retrofit的具体使用：

定义的接口APi：

   @GET("wor/word")
    Call getData(@Header("apikey")String apikey,
                       @Query("num")String num,
                       @Query("page")String page);

具体的请求方法，这里用的是最简单的，没有配置其他的，基本都是默认的：

 Retrofit retrofit = new Retrofit.Builder()
 					.baseUrl("")
                 .addConverterFactory(GsonConverterFactory.create())
                 .build();
        // 通过动态代理的方式创建请求对象
        AccountApi accountApi = retrofit.create(AccountApi.class);

        Call dataCall = accountApi.getData("xxx", "xxx", "xxx");

        // 异步加载
        dataCall.enqueue(new Callback() {
            @Override
            public void onResponse(Call call, Response response) {
                Data data = response.body();
            }

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

            }
        });
        

这些配置的数据不重要，只看看整个流程，每一步是怎么走的：

先看一下Retrofit build做了哪些配置处理，除了我们配的的哪些参数。

 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) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

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

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

      // 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());
      converterFactories.addAll(this.converterFactories);

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

需要注意三个地方：

第一个地方是这里, callFactory我们没有配置必然是null，默认直接new的OkHttpClient，OkHttpClient实现了Call.Factory这个接口，所以OkHttpClient就是一个callFactory。

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

第二个地方是这里，

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

这里用到了platform,

Builder(Platform platform) {
      this.platform = platform;
    }

    public Builder() {
      this(Platform.get());
    }

    Builder(Retrofit retrofit) {
      platform = Platform.get();
      callFactory = retrofit.callFactory;
      baseUrl = retrofit.baseUrl;

      converterFactories.addAll(retrofit.converterFactories);
      // Remove the default BuiltInConverters instance added by build().
      converterFactories.remove(0);

      callAdapterFactories.addAll(retrofit.callAdapterFactories);
      // Remove the default, platform-aware call adapter added by build().
      callAdapterFactories.remove(callAdapterFactories.size() - 1);

      callbackExecutor = retrofit.callbackExecutor;
      validateEagerly = retrofit.validateEagerly;
    }

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

...

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

Platform最后返回的就是anroid，在platform.defaultCallAdapterFactory就是这个里面的defaultCallAdapterFactory方法。Retrifit看到这里就可以了。

第三个地方是这里，添加了一个默认的allAdapterFactory对象callAdapterFactories.add(platform.defaultCallAdapterFactory(callbackExecutor));

具体看一下是哪一个CallAdapter对象：

CallAdapter.Factory defaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    if (callbackExecutor != null) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }
    return DefaultCallAdapterFactory.INSTANCE;
  }
  

DefaultCallAdapterFactory类很简单没做什么,注意一下adapt这个方法返回的传进来的参数。

 */
final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();

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