Retrofit源码解析

Retrofit在代码中的构建方式

Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http:/xx/xx/xx/")
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
service = retrofit.create(APIService.class);
service.getCall();

根据构建方式，我们先来看一下Retrofit类源码

（1）Retrofit中的七个重要的成员变量

//Method是Http的请求方法，ServiceMethod是网络请求接口解析注解后的请求方法的对象
  private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();
//网络请求的工厂
  final okhttp3.Call.Factory callFactory;
//网路请求的基地址，与接口中配置的地址拼接起来就是完整的请求地址
  final HttpUrl baseUrl;
//数据转换器工厂的集合，工厂的作用用于生产数据转换器，比如converter-gson
  final List<Converter.Factory> converterFactories;
//网络请求适配器的工厂集合，比如Call转换成RxJava平台的Call
  final List<CallAdapter.Factory> adapterFactories;
//用于执行回调，处理异步请求。在Android平台默认使用的是MainThreadExcecutor主线程执行器
  final @Nullable Executor callbackExecutor;
//布尔类型，是否需要立即解析接口中的方法，解析java接口中注解的请求方法和参数用到的
  final boolean validateEagerly;
//构造方法
Retrofit(okhttp3.Call.Factory callFactory, HttpUrl baseUrl,
      List<Converter.Factory> converterFactories, List<CallAdapter.Factory> adapterFactories,
      @Nullable Executor callbackExecutor, boolean validateEagerly) {
    this.callFactory = callFactory;
    this.baseUrl = baseUrl;
    this.converterFactories = unmodifiableList(converterFactories); // Defensive copy at call site.
    this.adapterFactories = unmodifiableList(adapterFactories); // Defensive copy at call site.
    this.callbackExecutor = callbackExecutor;
    this.validateEagerly = validateEagerly;
  }

（2）Retrofit中静态内部类Builder

public static final class Builder {
    //基本上和Retrofit中成员变量一致
    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private HttpUrl baseUrl;
    private final List<Converter.Factory> converterFactories = new ArrayList<>();
    private final List<CallAdapter.Factory> adapterFactories = new ArrayList<>();
    private @Nullable 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());
    }

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

  （省略部分代码）
    ........
    ........

    /**
     * Create the {@link Retrofit} instance using the configured values.
     * <p>
     * Note: If neither {@link #client} nor {@link #callFactory} is called a default {@link
     * OkHttpClient} will be created and used.
     */
    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);
    }
  }

成功建立一个Retrofit对象的标准：配置好Retrofit类里的成员变量，即配置好：
serviceMethod：包含所有网络请求信息的对象
baseUrl：网络请求的url地址
callFactory：网络请求工厂
adapterFactories：网络请求适配器工厂的集合
converterFactories：数据转换器工厂的集合
callbackExecutor：回调方法执行器

在Retrofit内部类Builder默认的构造方法中，我们可以看到调用了带参数的构造方法this(Platform.get())，那么Platform是做什么的呢

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) {
    }
    return new Platform();
  }

  @Nullable Executor defaultCallbackExecutor() {
    return null;
  }

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

  boolean isDefaultMethod(Method method) {
    return false;
  }

  @Nullable Object invokeDefaultMethod(Method method, Class<?> declaringClass, Object object,
      @Nullable Object... args) throws Throwable {
    throw new UnsupportedOperationException();
  }

  @IgnoreJRERequirement // Only classloaded and used on Java 8.
  static class Java8 extends Platform {
    @Override boolean isDefaultMethod(Method method) {
      return method.isDefault();
    }

    @Override Object invokeDefaultMethod(Method method, Class<?> declaringClass, Object object,
        @Nullable Object... args) throws Throwable {
      // Because the service interface might not be public, we need to use a MethodHandle lookup
      // that ignores the visibility of the declaringClass.
      Constructor<Lookup> constructor = Lookup.class.getDeclaredConstructor(Class.class, int.class);
      constructor.setAccessible(true);
      return constructor.newInstance(declaringClass, -1 /* trusted */)
          .unreflectSpecial(method, declaringClass)
          .bindTo(object)
          .invokeWithArguments(args);
    }
  }

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

其中findPlatform()方法中Class.forName("android.os.Build")

Class.forName(xxx.xx.xx)返回的是一个类。
Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类，也就是说JVM会执行该类的静态代码段。
关于生成对象两种方式的区别可以看这里初始化一个类，生成一个实例的时候，newInstance()方法和new关键字

Android回调中的线程切换

我们主要是看android，所以重点看其中静态内部类Android，该类中有一个defaultCallbackExecutor()的方法，返回的是Android中一个静态内部类MainThreadExecutor 的实例，我们可以看到在这里做了线程切换，采用Looper.getMainLooper()（主线程的looper）构造了handler，post了Runnable。

（3）baseUrl说明

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<String> pathSegments = baseUrl.pathSegments();
      if (!"".equals(pathSegments.get(pathSegments.size() - 1))) {
        throw new IllegalArgumentException("baseUrl must end in /: " + baseUrl);
      }
      this.baseUrl = baseUrl;
      return this;
    }

关于Retrofit中的baseUrl并没有强制怎么写，我可以写成https://api.github.com也可以写成 https://api.github.com/repos/,区别在哪呢?

https://api.github.com的格式可以看成scheme://host[:port]（此种类型是不是以 /（斜线）结尾都可以，均不会抛出IllegalArgumentException异常）;
https://api.github.com/repos/的格式可以看成scheme://host[:port]/path（此种类型必须以/（斜线）结尾，否则会抛出IllegalArgumentException异常）.

还是建议baseUrl统一以“/”结尾

（4）GsonConverter/GsonConverterFactory

addConverterFactory(Converter.Factory factory)就是将数据转换器工厂添加到Retrofit的数据转换器的集合中
GsonConverterFactory.create(Gson gson)/GsonConverterFactory.create()，创建了一个持有gson实例的Gson数据转换器工厂，前者可以自己定义gson实例的一些特性，后者是采用了默认的gson实例。

（5）CallAdapter/CallAdapterFactory

addCallAdapterFactory(CallAdapter.Factory factory)同样就是将网络请求适配器工厂添加到Retrofit的网络请求适配器的集合中

RxJava2CallAdapterFactory代码很短，以下是部分代码，其中Scheduler 是RxJava中的调度器，后面会介绍，通过create我们创建了一个RxJava2CallAdapterFactory，然后将其加到Retrofit的网络请求适配器的集合中

/**
   * Returns an instance which creates synchronous observables that do not operate on any scheduler
   * by default.
   */
  public static RxJava2CallAdapterFactory create() {
    return new RxJava2CallAdapterFactory(null, false);
  }

  private final @Nullable Scheduler scheduler;
  private final boolean isAsync;

  private RxJava2CallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync) {
    this.scheduler = scheduler;
    this.isAsync = isAsync;
  }

下面我们具体看一下RxJava2CallAdapterFactory
RxJava2CallAdapterFactory继承自CallAdapter.Factory，Factory是接口CallAdapter的一个内部类，CallAdapter负责将Retroift中的Call转换成java对象，

@POST("heart.do")
Call<ABaseBean>  addFriendShip(@Body HashMap addInfo);
@POST("heart.do")
Observable<ABaseBean> addFriendShip(@Body HashMap addInfo);

public interface CallAdapter<R, T> {
  
  Type responseType();

  T adapt(Call<R> call);

  abstract class Factory {
   
    public abstract @Nullable 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);
    }
  }
}

（1） Type responseType()，此处的Type就是Http请求返回的Response解析后的类型，并不是接口的返回类型，而是接口返回类型中泛型参数的实参，比如上述代码中ABaseBean。
（2）T adapt(Call<R> call)，T对应相应平台的对象，比如RxJava2CallAdapter中T对应Observable。
（3）get方法根据接口类型、注解类型获取需要的CallAdapter
（4）getRawType获取原始类型，在RxJava2CallAdapter中根据这个类型来选择生成不同的CallAdapter

RxJava2CallAdapter中的adapt方法中，会将Retrofit.create()方法过程中生成的携带了ServiceMethod对象的OkHttpCall进行适配，后面会讲到：

public Object adapt(Call<R> call) {
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return observable;
  }

上述判断条件分别是根据getRawType中获取到的类型生成的布尔值

（6）retrofit.create(xxx.class)，创建网络请求接口实例，create使用了外观模式和动态代理模式

Retrofit中的create方法：

public <T> T create(final Class<T> 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 the method is a method from Object then defer to normal invocation.
            if (method.getDeclaringClass() == Object.class) {
              return method.invoke(this, args);
            }
            if (platform.isDefaultMethod(method)) {
              return platform.invokeDefaultMethod(method, service, proxy, args);
            }
            ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);
            OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
            return serviceMethod.callAdapter.adapt(okHttpCall);
          }
        });
  }

validateEagerly，这是上面提到过的Retrofit的七个重要的成员变量之一，是否提前验证解析接口，如果为true，调用eagerlyValidateMethods方法，这部分调用的说明写在下方代码注释中

private void eagerlyValidateMethods(Class<?> service) {
    Platform platform = Platform.get();//获取平台，之前提到过Android、Java等
    for (Method method : service.getDeclaredMethods()) {//利用反射获取到网络请求接口中定义的method集合，遍历各个method
      if (!platform.isDefaultMethod(method)) {//此方法点进去可以看到默认返回false，则这里条件默认为true
        loadServiceMethod(method);
      }
    }
  }

/**
*该方法采用了常规的保存到缓存以及从缓存中获取目标对象的方式
*获取的ServiceMethod是对应接口中网络请求的一个方法的封装，其中包含了url以及配置参数等等
*/
  ServiceMethod<?, ?> loadServiceMethod(Method method) {
  //serviceMethodCache，这是上面提到过的Retrofit的七个重要的成员变量之一，缓存生成的http请求接口方法的
    ServiceMethod<?, ?> result = serviceMethodCache.get(method);
    if (result != null) return result;//如果从缓存中获取到，则直接返回

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {//如果没有获取到，则创建并缓存到serviceMethodCache
        result = new ServiceMethod.Builder<>(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;//返回目标对象ServiceMethod
  }

接下来，我们回到Retrofit的create方法中，非常重要的来了，动态代理动态创建网路请求，我们选其中重要的代码来看：

ServiceMethod<Object, Object> serviceMethod = (ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);

loadServiceMethod上面已经说过了，我们先来看看ServiceMethod这个类

ServiceMethod的成员变量：

  //生产网络请求call的工厂
  final okhttp3.Call.Factory callFactory;
  //网络请求适配器，使网络请求适配不同平台,比如RxJava平台
  final CallAdapter<R, T> callAdapter;
   //网络请求基地址
  private final HttpUrl baseUrl;
  //数据转换器
  private final Converter<ResponseBody, R> responseConverter;
  //网络请求的方法，比如GET、POST等等
  private final String httpMethod;
  //网络请求的相对地址，与上面baseUrl拼接成完整的请求地址
  private final String relativeUrl;
  //网络请求的头部信息
  private final Headers headers;
 //网络请求的http报文的body类型
  private final MediaType contentType;
  private final boolean hasBody;
  private final boolean isFormEncoded;
  private final boolean isMultipart;
//非常重要的：网络请求接口中参数、方法的处理器，包括注解啊、参数啊等等
  private final ParameterHandler<?>[] parameterHandlers;

从loadServiceMethod方法中我们看到生成ServiceMethod时使用的也是构建者模式，看一下ServiceMethod的内部类Builder

Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;
      this.methodAnnotations = method.getAnnotations();//网络请求接口中的请求方法以及header等注解，比如POST/GET/Multipart/FormUrlEncoded/Headers
      this.parameterTypes = method.getGenericParameterTypes();//网路请求接口方法中参数的类型
      this.parameterAnnotationsArray = method.getParameterAnnotations();//网路请求接口方法中注解的内容
    }

public ServiceMethod build() {
      callAdapter = createCallAdapter();
      responseType = callAdapter.responseType();//获取该网络请求适配器的数据返回类型

      ...省略部分代码

      responseConverter = createResponseConverter();
      //遍历网络请求接口中方法的网络请求方式（就是接口名称上边那些）的注解
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);//其中通过if判断是否是哪种网络请求方式做相应解析
      }

     ...省略部分代码

      /**
      * 解析网络请求接口方法中的参数（注解和参数）
      */
      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];

        ...省略部分代码

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];

       ...省略部分代码

        parameterHandlers[p] = parseParameter(p, parameterType, parameterAnnotations);
      }

     ...省略部分代码

      return new ServiceMethod<>(this);
    }

生成ServiceMethod，主要是解析了网络请求接口中的注解和参数等，生成了相应的网络请求适配器和数据转换器。

build中生成了ServiceMethod实例，我们分别来看看build方法中的关键步骤

1. 生成网络请求的适配器 callAdapter = createCallAdapter();

private CallAdapter<T, R> createCallAdapter() {
      Type returnType = method.getGenericReturnType();
      ...省略部分代码
      Annotation[] annotations = method.getAnnotations();
      try {
        return (CallAdapter<T, R>) retrofit.callAdapter(returnType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create call adapter for %s", returnType);
      }
    }

最终调用了ServiceMethod创建时传进来的Retrofit对象的callAdapter(Type returnType, Annotation[] annotations)方法

在retrofit中方法如下：

  public CallAdapter<?, ?> callAdapter(Type returnType, Annotation[] annotations) {
    return nextCallAdapter(null, returnType, annotations);
  }
  public CallAdapter<?, ?> nextCallAdapter(@Nullable CallAdapter.Factory skipPast, Type returnType,
      Annotation[] annotations) {
    ...省略部分代码
    int start = adapterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = adapterFactories.size(); i < count; i++) {
      CallAdapter<?, ?> adapter = adapterFactories.get(i).get(returnType, annotations, this);
      if (adapter != null) {
        return adapter;
      }
    }
    ...省略部分代码
  }

这里根据获取到的type和annotations从工厂类中生成相应的网络请求适配器，没有得到会抛出异常

1. 生成数据转换器 responseConverter = createResponseConverter();

private Converter<ResponseBody, T> createResponseConverter() {
      Annotation[] annotations = method.getAnnotations();
      try {
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }

同样，生成数据转换器也调用了ServiceMethod创建时传进来的Retrofit对象的方法，responseBodyConverter(Type type, Annotation[] annotations)

Retrofit中方法如下（和生成网络请求适配器非常类似）：

  public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
    return nextResponseBodyConverter(null, type, annotations);
  }

  public <T> Converter<ResponseBody, T> nextResponseBodyConverter(
      @Nullable Converter.Factory skipPast, Type type, Annotation[] annotations) {
    ...省略部分代码
    int start = converterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = converterFactories.size(); i < count; i++) {
      Converter<ResponseBody, ?> converter =
          converterFactories.get(i).responseBodyConverter(type, annotations, this);
      if (converter != null) {
        //noinspection unchecked
        return (Converter<ResponseBody, T>) converter;
      }
    }
    ...省略部分代码
  }

converterFactories.get(i)获取到相应的数据转换器工厂，调用数据转换器工厂中相应的responseBodyConverter方法，比如常用的GsonConverterFactory

public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonResponseBodyConverter<>(gson, adapter);
  }

3 之后build中还对网络请求接口中方法的注解和参数进行了解析，这部分都是在ServiceMethod类中的方法完成的，不再单独介绍，上述build方法代码中有简单的注释。

到这部分，Retrofit.create()方法中的三行核心代码中的第一行，ServiceMethod<Object, Object> serviceMethod = (ServiceMethod<Object, Object>) loadServiceMethod(method)，生成ServiceMethod的实现基本分析完毕。
那么接下来继续看第二行OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args)

final class OkHttpCall<T> implements Call<T> {
  private final ServiceMethod<T, ?> serviceMethod;//上面讲过的非常重要的一个对象
  private final @Nullable Object[] args;//参数
  private volatile boolean canceled;
  private @Nullable okhttp3.Call rawCall;//原生call，所有的操作最后实际上还是通过它来完成
  private @Nullable Throwable creationFailure; // Either a RuntimeException or IOException.
  private boolean executed;

   OkHttpCall(ServiceMethod<T, ?> serviceMethod, @Nullable Object[] args) {
    this.serviceMethod = serviceMethod;
    this.args = args;
  }
  ...省略了部分代码
}

OkHttpCall就是对OkHttp原生Call的封装，包含了各种Call的方法，比如enqueue、execute、cancel、isCanceled，总之需要用到OkHttp的Call中方法的来这里就对了。

第二行代码简单分析之后，然后就是第三行代码了：return serviceMethod.callAdapter.adapt(okHttpCall)
这里就是调用了adapt方法，比如加入使用了RxJava2CallAdapter，那callAdapter就对应RxJava2CallAdapter，如下：

public Object adapt(Call<R> call) {
    Observable<Response<R>> responseObservable = isAsync
        ? new CallEnqueueObservable<>(call)
        : new CallExecuteObservable<>(call);

    Observable<?> observable;
    if (isResult) {
      observable = new ResultObservable<>(responseObservable);
    } else if (isBody) {
      observable = new BodyObservable<>(responseObservable);
    } else {
      observable = responseObservable;
    }

    if (scheduler != null) {
      observable = observable.subscribeOn(scheduler);
    }

    if (isFlowable) {
      return observable.toFlowable(BackpressureStrategy.LATEST);
    }
    if (isSingle) {
      return observable.singleOrError();
    }
    if (isMaybe) {
      return observable.singleElement();
    }
    if (isCompletable) {
      return observable.ignoreElements();
    }
    return observable;
  }

（7）retrofit.create完成之后，具体去请求接口时：service.getCall()，因为service是一个接口，那接口去调用方法肯定是不行的，这里实际上是通过Retrofit中的create方法中动态代理进行了拦截，用InvocationHandler中的invoke方法进行实际操作，最后会返回一个OkHttpCall的适配器对象。

（8）Retrofit的同步和异步请求：

Retrofit同步请求流程：

ParameterHandler——>ServiceMethod——>Okhttp发送网络请求——>数据转换器converter

同步请求依然得依靠OkHttpCall中封装的请求方法来执行：

public Response<T> execute() throws IOException {
    okhttp3.Call call;
    ...省略部分代码
      call = rawCall;
      if (call == null) {
        try {
          call = rawCall = createRawCall();
        } catch (IOException | RuntimeException e) {
          creationFailure = e;
          throw e;
        }
      }
    }
    if (canceled) {//如果返回true，需要取消请求
      call.cancel();
    }
    return parseResponse(call.execute());
  }

  private okhttp3.Call createRawCall() throws IOException {
    Request request = serviceMethod.toRequest(args);
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);
    if (call == null) {
      throw new NullPointerException("Call.Factory returned null.");
    }
    return call;
  }

上述代码我们发现会有一个生成原生call的过程，可以看到先调用了ServiceMethod的toRequest生成一个request对象，然后去执行request返回得到call，得到call的过程实际上是用OkHttp库生成的。

ServiceMethod中的相关方法，根据传入的各个请求参数对应ParameterHandler进行解析：

Request toRequest(@Nullable Object... args) throws IOException {
    RequestBuilder requestBuilder = new RequestBuilder(httpMethod, baseUrl, relativeUrl, headers,
        contentType, hasBody, isFormEncoded, isMultipart);

    ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;

    int argumentCount = args != null ? args.length : 0;
    ...省略部分代码
    for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);
    }

    return requestBuilder.build();
  }

在execute方法中，最终用了原生的call去执行，执行的结果又调用了parseResponse(okhttp3.Response rawResponse)方法来解析

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();
    rawResponse = rawResponse.newBuilder()
        .body(new NoContentResponseBody(rawBody.contentType(), rawBody.contentLength()))
        .build();

    int code = rawResponse.code();
    if (code < 200 || code >= 300) {
      try {
        // Buffer the entire body to avoid future I/O.
        ResponseBody bufferedBody = Utils.buffer(rawBody);
        return Response.error(bufferedBody, rawResponse);
      } finally {
        rawBody.close();
      }
    }

    if (code == 204 || code == 205) {
      rawBody.close();
      return Response.success(null, rawResponse);
    }

    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      // If the underlying source threw an exception, propagate that rather than indicating it was
      // a runtime exception.
      catchingBody.throwIfCaught();
      throw e;
    }
  }

可以看到获取网络请求的状态码等等，我们关注解析的核心过程serviceMethod.toResponse(catchingBody)，又是调用了ServiceMethod中的方法

R toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
  }

这里使用了数据转换器的convert方法，会使用我们的数据转换器，比如GsonRequestBodyConverter

final class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
  private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
  private static final Charset UTF_8 = Charset.forName("UTF-8");

  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }

  @Override public RequestBody convert(T value) throws IOException {
    Buffer buffer = new Buffer();
    Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
    JsonWriter jsonWriter = gson.newJsonWriter(writer);
    adapter.write(jsonWriter, value);
    jsonWriter.close();
    return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
  }
}

Retrofit异步请求：

public void enqueue(final Callback<T> callback) {
    checkNotNull(callback, "callback == null");

    okhttp3.Call call;
    Throwable failure;

    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          failure = creationFailure = t;
        }
      }
    }

    if (failure != null) {
      callback.onFailure(this, failure);
      return;
    }

    if (canceled) {
      call.cancel();
    }

    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response<T> response;
        try {
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      private void callFailure(Throwable e) {
        try {
          callback.onFailure(OkHttpCall.this, e);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }

      private void callSuccess(Response<T> response) {
        try {
          callback.onResponse(OkHttpCall.this, response);
        } catch (Throwable t) {
          t.printStackTrace();
        }
      }
    });
  }

异步请求会将执行结果交给一个回调执行器去处理请求结果。其中一些关键性的代码同步时已经说过，不再说了。

【END】到这里，整个的网络请求就完成了，相应的源码也就分析完成了，Retrofit使用了的设计模式有构建者模式（Retrofit、ServiceMethod）、动态代理模式（实际调用请求方法时）、工厂模式（CallAdapter）、静态工厂模式（Platform）、外观模式/门面模式（Retrofit内部封装了很多子系统ServiceMethod、Factory等）、策略模式（CallAdapter是抽象层、具体的CallAdapter比如RxJava2CallAdapter）、适配器模式（CallAdapter）、观察者模式（OkHttpCall和Callback）
外观模式/门面模式说明：比如android studio点击执行按钮去执行程序，内部实际上是执行了很多复杂的子系统之间的操作，开发者只需要通过android studio提供的按钮来操作就可以了，屏蔽了子系统之间的变化，高内聚低耦合。
策略模式：比如要完成一项任务，有很多方法，可以根据不同的情况使用不同的方法来完成。
工厂模式（强调生成不同的对象）和策略模式（adapt产生具体的实现，强调的是不同对象的方法不同的实现）
观察者模式：一个被观察者可以对应多个观察者，多个观察者之间没有相互联系

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 156,907评论 4赞 360
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 66,546评论 1赞 289
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 106,705评论 0赞 238
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 43,624评论 0赞 203
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 51,940评论 3赞 285
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,371评论 1赞 210
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 31,672评论 2赞 310
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,396评论 0赞 195
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,069评论 1赞 238
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,350评论 2赞 242
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 31,876评论 1赞 256
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,243评论 2赞 251
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 32,847评论 3赞 231
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 26,004评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,755评论 0赞 192
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 35,378评论 2赞 269
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,266评论 2赞 259

Retrofit源码解析

推荐阅读更多精彩内容