Retrofit 框架原理和源码分析

一、简单使用

具体使用流程和方法说明详见：使用教程

简单的代码示例：

//步骤1：创建接口类
public interface WanAndroidService {
    @GET("article/list/{index}/json")
    Call getArticles(@Path("index") int index);
}

//步骤2:构建Retrofit实例
Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://wanandroid.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();

//步骤3:通过Retrofit.create方法创建接口类的代理对象
WanAndroidService wanAndroidService = retrofit.create(WanAndroidService.class);

//步骤4:调用接口代理对象方法返回Call类实例或者其他自定义请求类
Call articles  = wanAndroidService.getArticles(0);

//步骤5:调用Call类实例的同步或者异步请求方法，发起网络请求（.body()方法为获取请求成功后返回的实体数据对象）
JsonObject body = articles.execute().body();

二、原理分析

2.1、创建接口对象

2.1.1、源码

步骤1和2比较简单，创建接口类，然后根据实际的情况构建Retrofit类实例即可

源码分析从步骤3Retrofit.create方法开始：

public  T create(final Class service) {
    //校验是否接口是否存在类型变量，存在则抛出异常
    //如果Retrofit实例设置了立即校验，会先解析注解，将结果保存到缓存中备用（详解loadServiceMethod方法分析）
    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 {
                // 如果方法来自Object类，则调用Object类方法的默认实现，不做任何处理.
                if (method.getDeclaringClass() == Object.class) {
                  return method.invoke(this, args);
                }
                args = args != null ? args : emptyArgs;
                //isDefaultMethod(method)，判断是否是java8并且是默认实现方法
                //如果是，则直接调用方法实现，不做任何处理
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    //请求方法真正的调用逻辑
                    : loadServiceMethod(method).invoke(args);
              }
            });
  }

2.1.2、总结

1. 通过JDK动态代理技术生成我们定义请求接口的代理对象。

2. 接口方法的调用最终会调用到InvocationHandler的invoke方法。

3. invoke方法内部接口是否合法（非泛型接口），并且不是Object的方法，接口方法也不存在默认实现（JAVA8开始支持），则最终调用loadServiceMethod(method).invoke(args);方法开始解析封装网络请求。

2.2、接口方法调用

按照2.1的结论，接口方法的调用最终会调用到loadServiceMethod(method).invoke(args);方法，具体源码分析如下：

2.2.1、源码

loadServiceMethod(method)

a. 解析注解，生成ServiceMethod对象（loadServiceMethod(method)）

ServiceMethod loadServiceMethod(Method method) {
    //先从缓存获取，缓存获取到直接返回
    ServiceMethod result = serviceMethodCache.get(method);
    if (result != null) return result;

    synchronized (serviceMethodCache) {
      //double check 再检查一次缓存
      result = serviceMethodCache.get(method);
      if (result == null) {
        //开始解析方法注解，生成ServiceMethod对象
        result = ServiceMethod.parseAnnotations(this, method);
        //缓存该方法对应的ServiceMethod解析结果，下次请求可以直接从缓存获取
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

b. 解析注解，返回ServiceMethod对象（ServiceMethod.parseAnnotations(this, method)）

static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    //生成RequestFactory对象，创建实例的同时会解析注解获取网络请求数据，解析的同时会校验各个注解的合法性（比如请求方法注解必须是默认GET/POST/...等等校验）
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);
    //获取返回参数类型
    Type returnType = method.getGenericReturnType();
    //校验返回参数类型，类型不能为以下类型：
    //1、类型变量类型(T,E等等)、通配符表达式、
    //2、参数类型<>中的参数类型不能存在类型变量或者通配符(即可以是List、不能是List或者List、
    //3、泛型数组类型元素类型也不能存在类型变量或者通配符类型)
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    //返回类型也不能是void.class
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }
    //校验通过调用HttpServiceMethod的parseAnnotations方法解析注解
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

c. 继续解析注解，返回HttpServiceMethod对象（HttpServiceMethod.parseAnnotations(this, method, requestFactory)）

//关键代码
static  HttpServiceMethod parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    ......
    boolean continuationWantsResponse = false;
    boolean continuationBodyNullable = false;
    
    Annotation[] annotations = method.getAnnotations();
    Type adapterType;
    if (isKotlinSuspendFunction) {
      ......
    } else {
      //获取方法的返回参数类型
      adapterType = method.getGenericReturnType();
    }
    //创建请求适配器（内部通过CallAdpater.Factory创建，如果不自定义，并且方法返回值是Call；则使用DefaultCallAdapterFactory创建CallAdapter；可以通过Retrofit配置新增Factory改变默认行为）
    CallAdapter callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
    Type responseType = callAdapter.responseType();
    ......

    //创建响应数据转换器(流程类似请求适配器创建)
    Converter responseConverter =
        createResponseConverter(retrofit, method, responseType);

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    if (!isKotlinSuspendFunction) {
      //返回CallAdapted实例，传递的参数说明：
      //1、requestFactory：内部保存注解解析到的请求方法，请求参数，URL等等数据；
      //2、callFactory：即OkHttpClient；
      //3、responseConverter：数据解析转换器；
      //4、callAdapter：请求适配器，可以自定义实现线程切换等逻辑，Android默认适配器功能是将异步请求响应回调切换到主线程)
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      ......
    } else {
      ......
    }
  }

默认的DefaultCallAdapterFactory请求适配器创建工厂源码如下：

final class DefaultCallAdapterFactory extends CallAdapter.Factory {
  private final @Nullable Executor callbackExecutor;

  //如果是Android 默认传入的是Platform.MainThreadExecutor实例（可以通过Retrofit配置修改）
  DefaultCallAdapterFactory(@Nullable Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }

  @Override
  public @Nullable CallAdapter get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
    //返回值类型不为Call.class，则返回null
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    //检查返回参数类型
    if (!(returnType instanceof ParameterizedType)) {
      throw new IllegalArgumentException(
          "Call return type must be parameterized as Call or Call");
    }
    //获取Call，xxx参数对应的类型
    final Type responseType = Utils.getParameterUpperBound(0, (ParameterizedType) returnType);

    final Executor executor =
        Utils.isAnnotationPresent(annotations, SkipCallbackExecutor.class)
            ? null
            : callbackExecutor;

    return new CallAdapter>() {
      @Override
      public Type responseType() {
        return responseType;
      }

      @Override
      public Call