三方库源码笔记（7）-超详细的Retrofit源码解析

公众号：字节数组，希望对你有所帮助

对于 Android Developer 来说，很多开源库都是属于开发必备的知识点，从使用方式到实现原理再到源码解析，这些都需要我们有一定程度的了解和运用能力。所以我打算来写一系列关于开源库源码解析和实战演练的文章，初定的目标是 EventBus、ARouter、LeakCanary、Retrofit、Glide、OkHttp、Coil 等七个知名开源库，希望对你有所帮助

系列文章导航：

• 三方库源码笔记（1）-EventBus 源码详解
• 三方库源码笔记（2）-EventBus 自己实现一个
• 三方库源码笔记（3）-ARouter 源码详解
• 三方库源码笔记（4）-ARouter 自己实现一个
• 三方库源码笔记（5）-LeakCanary 源码详解
• 三方库源码笔记（6）-LeakCanary 扩展阅读
• 三方库源码笔记（7）-Retrofit 源码详解
• 三方库源码笔记（8）-Retrofit 与 LiveData 的结合使用
• 三方库源码笔记（9）-Glide 源码详解
• 三方库源码笔记（10）-Glide 你可能不知道的知识点
• 三方库源码笔记（11）-OkHttp 源码详解
• 三方库源码笔记（12）-OkHttp / Retrofit 开发调试利器
• 三方库源码笔记（13）-可能是全网第一篇 Coil 的源码分析文章

一、前言

Retrofit 也是现在 Android 应用开发中的标配之一了吧？笔者使用 Retrofit 蛮久的了，一直以来用着也挺舒心的，没遇到啥大的坑。总这样用着不来了解下其实现原理也好像不太好，趁着动笔写 三方库源码笔记 系列文章就来对 Retrofit 进行一次（自我感觉的）全面的源码解析吧

Retrofit 的源码并不算太复杂，但由于应用了很多种设计模式，所以在流程上会比较绕。笔者从 2020/10/10 开始看源码，陆陆续续看了几天源码后就开始动笔，但总感觉没法阐述得特别清晰，写着写着就成了目前的样子。读者如果觉得我有哪里写得不太好的地方也欢迎给下建议

Retrofit 是这么自我介绍的：A type-safe HTTP client for Android and Java.

说明 Retrofit 的内部实现并不需要依赖于 Android 平台，而是可以用于任意的 Java 客户端，Retrofit 只是对 Android 平台进行了特殊实现而已（例如，在 main 线程进行回调）。但现在 Android 平台的主流开发语言早已是 Kotlin 了，所以本篇文章所写的例子就都还是用 Kotlin 语言来实现吧~

对 Kotlin 语言不熟悉的同学可以看我的这篇文章来入门：两万六千字带你Kotlin入门

二、小例子

先来看几个简单的小例子，后续的讲解都会围绕这几个例子来展开

先引入当前 Retrofit 的最新版本：

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
}

在除了 Retrofit 外不引入其它任何依赖库的情况下，我们发起一个网络请求的流程都大致如下所示：

/**
 * 作者：leavesC
 * 时间：2020/10/13 0:05
 * 描述：
 * GitHub：https://github.com/leavesC
 */
interface ApiService {

    @GET("getUserData")
    fun getUserData(): Call

}

fun main() {
    val retrofit = Retrofit.Builder()
        .baseUrl("https://mockapi.eolinker.com/9IiwI82f58c23411240ed608ceca204b2f185014507cbe3/")
        .build()
    val service = retrofit.create(ApiService::class.java)
    val call: Call = service.getUserData()
    call.enqueue(object : Callback {
        override fun onResponse(call: Call, response: Response) {
            val userBean = response.body()?.string()
            println("userBean: $userBean")
        }

        override fun onFailure(call: Call, t: Throwable) {
            println("onFailure: $t")
        }
    })
}

输出结果：

userBean: {"userName":"JBl","userAge":7816977017260632}

Retrofit 是建立在 OkHttp 之上的一个网络请求封装库，内部依靠 OkHttp 来完成实际的网络请求。Retrofit 在使用上很简洁，API 是通过 interface 来声明的。不知道读者第一次使用 Retrofit 的时候是什么感受，我第一次使用的时候就觉得 Retrofit 好神奇，我只需要通过 interface 来声明API 路径、请求方式、请求参数、返回值类型等各个配置项，然后调用方法就可以发起网络请求了，相比 OkHttp 和 Volley 这些网络请求库真的是简洁到没朋友

从上述例子可以看到，getUserData()方法所代表的 API 的请求结果是一个 Json 格式的字符串，其返回值类型被定义为 Call，此处的 ResponseBody 即 okhttp3.ResponseBody，是 OkHttp 提供的对网络请求结果的包装类，Call 即retrofit2.Call，是 Retrofit 对 okhttp3.Call做的一层包装，OkHttp 在实际发起请求的时候使用的回调是 okhttp3.Call，回调内部就会来中转调用 retrofit2.Call，以便将请求结果转交给外部

1、converter-gson

上述例子虽然简单，但还不够方便，因为既然 API 的返回值我们已知就是 Json 格式的了，那么我们自然就希望 getUserData() 方法的返回值直接就是一个 Bean 对象，而不是拿到一个 String 对象后还需要自己再去进行反序列化，这可以通过converter-gson这个库来达到这个效果

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.5.0'
}

代码再做点小改动，之后就可以直接在 Callback 中拿到 UserBean 对象了

/**
 * 作者：leavesC
 * 时间：2020/10/13 0:05
 * 描述：
 * GitHub：https://github.com/leavesC
 */
interface ApiService {

    @GET("getUserData")
    fun getUserData(): Call

}

data class UserBean(val userName: String, val userAge: Long)

fun main() {
    val retrofit = Retrofit.Builder()
        .baseUrl("https://mockapi.eolinker.com/9IiwI82f58c23411240ed608ceca204b2f185014507cbe3/")
        .addConverterFactory(GsonConverterFactory.create())
        .build()
    val service = retrofit.create(ApiService::class.java)
    val call: Call = service.getUserData()
    call.enqueue(object : Callback {
        override fun onResponse(call: Call, response: Response) {
            val userBean = response.body()
            println("userBean: $userBean")
        }

        override fun onFailure(call: Call, t: Throwable) {
            println("onFailure: $t")
        }
    })
}

2、adapter-rxjava2

再然后，如果我们也看 Call不爽，想要通过 RxJava 的方式来进行网络请求可不可以？也行，此时就需要再使用到 adapter-rxjava2 这个库了

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.5.0'
    implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'
}

代码再来做点小改动，此时就完全不用使用到 Call.enqueue来显式发起网络请求了，当进行 subscribe 的时候就会触发网络请求

/**
 * 作者：leavesC
 * 时间：2020/10/13 0:05
 * 描述：
 * GitHub：https://github.com/leavesC
 */
interface ApiService {

    @GET("getUserData")
    fun getUserData(): Observable

}

data class UserBean(val userName: String, val userAge: Long)

fun main() {
    val retrofit = Retrofit.Builder()
        .baseUrl("https://mockapi.eolinker.com/9IiwI82f58c23411240ed608ceca204b2f185014507cbe3/")
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .build()
    val service = retrofit.create(ApiService::class.java)
    val call: Observable = service.getUserData()
    call.subscribe(object : Consumer {
        override fun accept(userBean: UserBean?) {
            println("userBean: $userBean")
        }

    }, object : Consumer {
        override fun accept(t: Throwable?) {
            println("onFailure: $t")
        }
    })
}

3、小疑问

可以看到，Retrofit 在抽象程度上是很高的。不管是需要 Call 类还是 Observable 类型的包装类，只需要添加不同的 CallAdapterFactory 即可，就算想返回 LiveData 类型都是可以实现的。也不管是需要 ResponseBody 类型还是具体的 Bean 对象类型，也只需要添加不同的 ConverterFactory 即可，就算 API 的返回值是 XML 格式也可以进行映射解析

那么，我们就需要带着几个问题来逐步看 Retrofit 的源码：

1. Retrofit 是如何将 interface 内部的方法转化为一个个实际的 GET、POST、DELETE 等各式各样的网络请求的呢？例如，Retrofit 是如何将 getUserData() 转换为一个 OkHttp 的 GET 请求的呢？
2. Retrofit 是如何将 API 的返回值映射为具体的 Bean 对象的呢？例如，ResponseBody 是如何映射为 UserBean 的呢？
3. Retrofit 是如何抽象不同的 API 返回值包装类的呢？例如，Call 是如何替换为 Observable 的呢？

三、Retrofit.create()

先来看下retrofit.create方法做了什么

public  T create(final Class service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class[] {service},
            new InvocationHandler() {
              private final Platform platform = Platform.get();
              private final Object[] emptyArgs = new Object[0];

              @Override
              public @Nullable 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) {
                //如果外部调用的是 Object 中声明的方法的话则直接调用
                //例如 toString()、hashCode() 等方法
                  return method.invoke(this, args);
                }
                args = args != null ? args : emptyArgs;
                //根据 method 是否默认方法来决定如何调用
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });
  }

这里的重点就是Proxy.newProxyInstance所实现的动态代理模式了。通过动态代理，Retrofit 会将我们对 ApiService 的调用操作转发给 InvocationHandler 来完成。Retrofit 在后续会通过反射拿到我们在声明 getUserData()时标注的各个配置项，例如API 路径、请求方式、请求参数、返回值类型等各个信息，然后将这些配置项拼接为 OkHttp 的一个原始网络请求。当我们调用了call.enqueue方法时，这个操作就会触发 InvocationHandler 去发起 OkHttp 网络请求了

Retrofit 会根据 method 是否是默认方法来决定如何调用，这里主要看loadServiceMethod(method)方法，该方法的主要逻辑是：

1. 将每个代表接口方法的 method 对象转换为 ServiceMethod 对象，该对象中就包含了 API 的具体信息
2. 因为 API 可能先后会被调用多次，所以将构造出来的 ServiceMethod 对象缓存到 serviceMethodCache 中以实现复用

  private final Map> serviceMethodCache = new ConcurrentHashMap<>();  

  ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result = serviceMethodCache.get(method);
    if (result != null) return result;

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        //重点
        result = ServiceMethod.parseAnnotations(this, method);
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

四、ServiceMethod

从上面可知，loadServiceMethod(method)方法返回的是一个 ServiceMethod 对象，从名字上来看也可以猜出，每个 ServiceMethod 对象就对应一个 API 接口方法，其内部就包含了对 API 的解析结果。loadServiceMethod(method).invoke(args) 这个操作就对应调用 API 方法并传递参数这个过程，即对应val call: Call = service.getUserData() 这个过程

ServiceMethod 是一个抽象类，仅包含一个抽象的 invoke(Object[] args)方法。ServiceMethod 使用到了工厂模式，由于 API 的最终请求方式可能是多样化的，既可能是通过线程池来执行，也可能是通过 Kotlin 协程来执行，使用工厂模式的意义就在于可以将这种差异都隐藏在不同的 ServiceMethod 实现类中，而外部统一都是通过 parseAnnotations 方法来获取 ServiceMethod 的实现类

parseAnnotations方法返回的 ServiceMethod 实际上是 HttpServiceMethod，所以重点就要来看 HttpServiceMethod.parseAnnotations方法返回的 HttpServiceMethod 具体是如何实现的，并是如何拼接出一个完整的 OkHttp 请求调用链

abstract class ServiceMethod {
  static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    //requestFactory 包含了对 API 的注解信息进行解析后的结果
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    Type returnType = method.getGenericReturnType();
    //如果返回值包含未确定的泛型类型或者是包含通配符的话，那么就抛出异常
    //因为 Retrofit 无法构造出一个不具有确定类型的对象作为返回值
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    //返回值类型不能是 void
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }
    
    //重点
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  abstract @Nullable T invoke(Object[] args);
}

五、HttpServiceMethod

通过查找引用，可以知道 ServiceMethod 这个抽象类的直接子类只有一个，即 HttpServiceMethod。HttpServiceMethod 也是一个抽象类，其包含两个泛型声明，ResponseT 表示的是 API 方法返回值的外层包装类型，ReturnT 表示的是我们实际需要的数据类型。例如，对于 fun getUserData(): Call 方法，ResponseT 对应的是 Call，ReturnT 对应的是 UserBean。此外，HttpServiceMethod 也实现了父类的 invoke 方法，并将操作转交给了另一个抽象方法 adapt 来完成，所以说，API 方法对应的网络请求具体的发起操作主要看 adapt 方法即可

abstract class HttpServiceMethod extends ServiceMethod {
 
  @Override
  final @Nullable ReturnT invoke(Object[] args) {
    Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    return adapt(call, args);
  }

  protected abstract @Nullable ReturnT adapt(Call call, Object[] args);
    
  ···

}

再来看 HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory)方法是如何构建出一个 HttpServiceMethod 对象的，并且该对象的adapt方法是如何实现的

abstract class HttpServiceMethod extends ServiceMethod {
  /**
   * Inspects the annotations on an interface method to construct a reusable service method that
   * speaks HTTP. This requires potentially-expensive reflection so it is best to build each service
   * method only once and reuse it.
   */
  static  HttpServiceMethod parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    //是否是 Suspend 函数，即是否以 Kotlin 协程的方式来进行请求
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    boolean continuationWantsResponse = false;
    boolean continuationBodyNullable = false;

    Annotation[] annotations = method.getAnnotations();
    Type adapterType;
    if (isKotlinSuspendFunction) {
        //省略 Kotlin 协程的一些处理逻辑
    } else {
      adapterType = method.getGenericReturnType();
    }
    
    //重点1
    CallAdapter callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
      
    //拿到包装类内部的具体类型，例如，Observable 内部的 UserBean
    //responseType 不能是 okhttp3.Response 或者是不包含具体泛型类型的 Response
    Type responseType = callAdapter.responseType();
    if (responseType == okhttp3.Response.class) {
      throw methodError(
          method,
          "'"
              + getRawType(responseType).getName()
              + "' is not a valid response body type. Did you mean ResponseBody?");
    }
    if (responseType == Response.class) {
      throw methodError(method, "Response must include generic type (e.g., Response)");
    }
    // TODO support Unit for Kotlin?
    if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
      throw methodError(method, "HEAD method must use Void as response type.");
    }
    
    //重点2
    Converter responseConverter =
        createResponseConverter(retrofit, method, responseType);

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    if (!isKotlinSuspendFunction) {
      //重点3
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } 
    
    //省略 Kotlin 协程的一些处理逻辑
    ···
        
  }

  ···
    
}

Retrofit 目前已经支持以 Kotlin 协程的方式来进行调用了，但本例子和协程无关，所以此处先忽略协程相关的处理逻辑，后面会再讲解，parseAnnotations 方法的主要逻辑是：

1. 先通过createCallAdapter(retrofit, method, adapterType, annotations 方法拿到 CallAdapter 对象，CallAdapter 就用于实现 API 方法的不同返回值包装类处理逻辑。例如，getUserData()方法的返回值包装类类型如果是 Call ，那么返回的 CallAdapter 对象就对应 DefaultCallAdapterFactory 包含的 Adapter；如果是 Observable，那么返回的就是 RxJava2CallAdapterFactory包含的 Adapter
2. 再通过 createResponseConverter(retrofit, method, responseType)方法拿到 Converter 对象，Converter 就用于实现 API 方法的不同返回值处理逻辑。例如，getUserData()方法的目标返回值类型如果是 ResponseBody ，那么 Converter 对象就对应 BuiltInConverters；如果是 UserBean，那么就对应 GsonConverterFactory
3. 根据前两个步骤拿到的值，构造出一个 CallAdapted 对象并返回

CallAdapted 正是 HttpServiceMethod 的子类，在 InvocationHandler 中通过loadServiceMethod(method).invoke(args)发起的调用链，会先创建出一个 OkHttpCall 对象，并最后调用到 callAdapter.adapt(call)方法

abstract class HttpServiceMethod extends ServiceMethod {
    
    @Override
    final @Nullable ReturnT invoke(Object[] args) {
        Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
        return adapt(call, args);
    }
    
}


static final class CallAdapted extends HttpServiceMethod {
    private final CallAdapter callAdapter;

    CallAdapted(
        RequestFactory requestFactory,
        okhttp3.Call.Factory callFactory,
        Converter responseConverter,
        CallAdapter callAdapter) {
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
    }

    @Override
    protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);
    }
  }

六、OkHttpCall

OkHttpCall 是实际发起 OkHttp 请求的地方。当我们调用 fun getUserData(): Call 方法时，返回的 Call 对象实际上是 OkHttpCall 类型，而当我们调用 call.enqueue(Callback)方法时，enqueue 方法中会发起一个 OkHttp 请求，传入的 Callback 对象就会由 okhttp3.Callback本身收到回调时再进行中转调用

final class OkHttpCall implements Call {
  private final RequestFactory requestFactory;
  private final Object[] args;
  private final okhttp3.Call.Factory callFactory;
  private final Converter responseConverter;

  private volatile boolean canceled;

  @GuardedBy("this")
  private @Nullable okhttp3.Call rawCall;

  @GuardedBy("this") // Either a RuntimeException, non-fatal Error, or IOException.
  private @Nullable Throwable creationFailure;

  @GuardedBy("this")
  private boolean executed;
    
  @Override
  public void enqueue(final Callback callback) { 
    ···
    okhttp3.Call call;
    ··· 
    call.enqueue( new okhttp3.Callback() {
          @Override
          public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
            Response response;
            try {
              response = parseResponse(rawResponse);
            } catch (Throwable e) {
              throwIfFatal(e);
              callFailure(e);
              return;
            }

            try {
              callback.onResponse(OkHttpCall.this, response);
            } catch (Throwable t) {
              throwIfFatal(t);
              t.printStackTrace(); // TODO this is not great
            }
          }

          @Override
          public void onFailure(okhttp3.Call call, IOException e) {
            callFailure(e);
          }

          private void callFailure(Throwable e) {
            try {
              callback.onFailure(OkHttpCall.this, e);
            } catch (Throwable t) {
              throwIfFatal(t);
              t.printStackTrace(); // TODO this is not great
            }
          }
        });
  }
 
  
   ···
    
}

七、小总结

以上几个小节的内容讲了在发起如下请求的过程中涉及到的所有流程，但单纯这样看的话其实有点难把握各个小点（我自己看着都有点绕），所以这里就再来回顾下以上内容，把所有知识点给串联起来

/**
 * 作者：leavesC
 * 时间：2020/10/13 0:05
 * 描述：
 * GitHub：https://github.com/leavesC
 */
interface ApiService {

    @GET("getUserData")
    fun getUserData(): Call

}

fun main() {
    val retrofit = Retrofit.Builder()
        .baseUrl("https://mockapi.eolinker.com/9IiwI82f58c23411240ed608ceca204b2f185014507cbe3/")
        .build()
    val service = retrofit.create(ApiService::class.java)
    val call: Call = service.getUserData()
    call.enqueue(object : Callback {
        override fun onResponse(call: Call, response: Response) {
            val userBean = response.body()?.string()
            println("userBean: $userBean")
        }

        override fun onFailure(call: Call, t: Throwable) {
            println("onFailure: $t")
        }
    })
}

首先，我们通过 retrofit.create(ApiService::class.java)得到一个 ApiService 的动态实现类，这是通过 Java 原生提供的Proxy.newProxyInstance 代表的动态代理功能来实现的。在拿到 ApiService 的实现类后，我们就可以直接调用 ApiService 中声明的所有方法了

而当我们调用了service.getUserData()方法时，Retrofit 会将每一个 API 方法都抽象封装为一个 ServiceMethod 对象并缓存起来，我们的操作会转交给 ServiceMethod 来完成，由 ServiceMethod 来负责返回我们的目标类型，对应的是 ServiceMethod.invoke(Object[] args)方法，args 代表的是我们调用 API 方法时需要传递的参数，对应本例子就是一个空数组

abstract class ServiceMethod {
  static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    //requestFactory 包含了对 API 的注解信息进行解析后的结果
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    Type returnType = method.getGenericReturnType();
    //如果返回值包含未确定的泛型类型或者是包含通配符的话，那么就抛出异常
    //因为 Retrofit 无法构造出一个不具有确定类型的对象作为返回值
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    //返回值类型不能是 void
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }
    
    //重点
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  abstract @Nullable T invoke(Object[] args);
}

而实际上，ServiceMethod 只具有一个唯一的直接子类，即 HttpServiceMethod，而 HttpServiceMethod 会在 invoke 方法中构建出一个 OkHttpCall 对象，然后调用其抽象方法 adapt

此外，对于不同的请求方式，ServiceMethod.parseAnnotations 方法最终会返回不同的 HttpServiceMethod 子类。对应本例子，最终返回的会是 CallAdapted 对象

abstract class HttpServiceMethod extends ServiceMethod {
 
  @Override
  final @Nullable ReturnT invoke(Object[] args) {
    Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    return adapt(call, args);
  }

  protected abstract @Nullable ReturnT adapt(Call call, Object[] args);
    
  ···

}


static final class CallAdapted extends HttpServiceMethod {
    private final CallAdapter callAdapter;

    CallAdapted(
        RequestFactory requestFactory,
        okhttp3.Call.Factory callFactory,
        Converter responseConverter,
        CallAdapter callAdapter) {
      super(requestFactory, callFactory, responseConverter);
      this.callAdapter = callAdapter;
    }

    @Override
    protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);
    }
  }

所以，当我们调用 val call: Call = service.getUserData()时，返回的 Call实际上是 OkHttpCall

而当我们调用 call.enqueue方法时，OkHttpCall 的 enqueue 方法内部就会发起一个 OkHttp 请求，并为这个请求设置一个回调对象 okhttp3.Callback，然后在这个回调中再来回调我们传递进去的 retrofit2.Callback。这样，外部也就可以收到网络请求成功或者失败的事件回调了

final class OkHttpCall implements Call {

  @Override
  public void enqueue(final Callback callback) { 
    ···
    okhttp3.Call call;
    ··· 
    call.enqueue( new okhttp3.Callback() {
          @Override
          public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse) {
            Response response;
            try {
              response = parseResponse(rawResponse);
            } catch (Throwable e) {
              throwIfFatal(e);
              callFailure(e);
              return;
            }

            try {
              callback.onResponse(OkHttpCall.this, response);
            } catch (Throwable t) {
              throwIfFatal(t);
              t.printStackTrace(); // TODO this is not great
            }
          }

          @Override
          public void onFailure(okhttp3.Call call, IOException e) {
            callFailure(e);
          }

          private void callFailure(Throwable e) {
            try {
              callback.onFailure(OkHttpCall.this, e);
            } catch (Throwable t) {
              throwIfFatal(t);
              t.printStackTrace(); // TODO this is not great
            }
          }
        });
  }
 
  
   ···
    
}

八、API 方法是如何解析的？

Retrofit 是如何将 interface 内部的方法转化为一个个实际的 GET、POST、DELETE 等各式各样的网络请求的呢？例如，Retrofit 是如何将 getUserData() 转换为一个 OkHttp 的 GET 请求的呢？

这个过程在 ServiceMethod 的 parseAnnotations 方法中就已经完成的了，对应的是 RequestFactory.parseAnnotations(retrofit, method)方法

abstract class ServiceMethod {
  static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    //重点
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }

    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

  abstract @Nullable T invoke(Object[] args);
}

前文说了，Retrofit 是建立在 OkHttp 之上的一个网络请求封装库，内部依靠 OkHttp 来完成实际的网络请求。而 OkHttp 的一般请求方式如下所示

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}

OkHttp 需要构建一个 Request 对象来配置请求方式和请求参数，并以此来发起网络请求。所以，Retrofit 也需要一个构建 Request 对象的过程，这个过程就隐藏在 RequestFactory 中

RequestFactory 采用了 Builder 模式，这里无需过多理会其构建过程，我们只要知道 RequestFactory 中包含了对 API 方法的各项解析结果即可。其 create(Object[] args)方法就会根据各项解析结果，最终返回一个 okhttp3.Request 对象

final class RequestFactory {
  static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
    return new Builder(retrofit, method).build();
  }

  private final Method method;
  private final HttpUrl baseUrl;
  final String httpMethod;
  private final @Nullable String relativeUrl;
  private final @Nullable Headers headers;
  private final @Nullable MediaType contentType;
  private final boolean hasBody;
  private final boolean isFormEncoded;
  private final boolean isMultipart;
  private final ParameterHandler[] parameterHandlers;
  final boolean isKotlinSuspendFunction;

  okhttp3.Request create(Object[] args) throws IOException {
    @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
    ParameterHandler