Retrofit 源码解析

简介

一个用于Android和Java平台的类型安全的网络框架。Retrofit 是一个Square开发的类型安全的REST安卓客户端请求库。这个库为网络认证、API请求以及用OkHttp发送网络请求提供了强大的框架，底层对网络的访问默认也是基于OkHttp。

官网地址

Github
官网

依赖

implementation 'com.squareup.retrofit2:retrofit:2.9.0'

用法基本用法

// 创建网络请求接口

interface Api {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user") user:String):Call>
}


val baseUrl = "https://api.github.com/"

val okHttpClient = OkHttpClient.Builder()
    .connectTimeout(30, TimeUnit.SECONDS)
    .readTimeout(60, TimeUnit.SECONDS)
    .writeTimeout(90, TimeUnit.SECONDS)
    .build()
    
// 创建 Retrofit 的实例
val retrofit = Retrofit.Builder()
    .baseUrl(baseUrl)
    .addConverterFactory(GsonConverterFactory.create())
    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
    .client(okHttpClient)
    .build()

// 创建网络请求接口的实例，并调用接口中的方法获取 Call 对象
val api = retrofit.create(Api::class.java)
val call = api.listRepos("")    
// 同步请求
call.execute()
// 异步请求
call.enqueue(object :retrofit2.Callback> {
      override fun onFailure(call: retrofit2.Call>, t: Throwable) {}

      override fun onResponse(call: retrofit2.Call>, response: retrofit2.Response>) {}
   })

源码解析创建 Retrofit 的实例

Retrofit 成员变量

// Retrofit.java 源码

  // ServiceMethod 的缓存，解析接口注解后相关信息（网络请求的方法、数据转换器、网络请求适配器、网络请求工厂、基地址等）的存储
  private final Map> serviceMethodCache = new  ConcurrentHashMap<>();
  // 网络请求器工厂，默认为OkHttpClient
  final okhttp3.Call.Factory callFactory;
  // 网络请求的 url 地址
  final HttpUrl baseUrl;
  // 数据转换器工厂的集合
  final List converterFactories;
  // 网络请求适配器的集合
  final List callAdapterFactories;
  // 回调函数的执行器，也就是回调函数执行的线程，Android 中默认为 MainThreadExecutor
  final @Nullable Executor callbackExecutor;
  // 一个标志位，用来判断是否需要加载 ServiceMethod
  final boolean validateEagerly;

Retrofit实例通过Builder（建造者）模式创建，接下来看下Builder的构造方法

// Retrofit.java 源码

public static final class Builder {
    //平台类型对象
    private final Platform platform;
    private @Nullable okhttp3.Call.Factory callFactory;
    private @Nullable HttpUrl baseUrl;
    private final List converterFactories = new ArrayList<>();
    private final List callAdapterFactories = new ArrayList<>();
    private @Nullable Executor callbackExecutor;
    private boolean validateEagerly;

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

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

可以看到构造方法Builder()内通过Platform.get()获取当前平台，一般是Android，当然也支持其他平台比如Java8等，get() 方法中又调用了 findPlatform() 方法。

// Platform.java 源码

class Platform {
  private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  // 判断当前运行平台
  private static Platform findPlatform() {
    return "Dalvik".equals(System.getProperty("java.vm.name"))
        ? new Android() //
        : new Platform(true);
  }

 
  @Nullable
  Executor defaultCallbackExecutor() {
    return null;
  }
  
  ...
  
  static final class Android extends Platform {
    Android() {
      super(Build.VERSION.SDK_INT >= 24);
    }

    @Override
    public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Nullable
    @Override
    Object invokeDefaultMethod(
        Method method, Class declaringClass, Object object, Object... args) throws Throwable {
      if (Build.VERSION.SDK_INT < 26) {
        throw new UnsupportedOperationException(
            "Calling default methods on API 24 and 25 is not supported");
      }
      return super.invokeDefaultMethod(method, declaringClass, object, args);
    }

    static final class MainThreadExecutor implements Executor {
      // 主线程的handler
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override
      public void execute(Runnable r) {
      //通过Handler切换到主线程
        handler.post(r);
      }
    }
    
  }
  
}

可以看到，Builder()方法主要是用来查找当前运行的平台，Retrofit 支持 Android与Java平台。defaultCallbackExecutor()方法默认回调执行器是Null,如果当前运行平台是Android, 那么返回是MainThreadExecutor 执行器。

接下来，Builder如何配置url、网络请求器工厂、数据转换器工厂等

// Retrofit.java 源码
 
 // 配置OkHttpClient
 public Builder client(OkHttpClient client) {
      return callFactory(Objects.requireNonNull(client, "client == null"));
 }
 // 配置请求地址
 public Builder baseUrl(URL baseUrl) {
      Objects.requireNonNull(baseUrl, "baseUrl == null");
      return baseUrl(HttpUrl.get(baseUrl.toString()));
 }
 
 public Builder baseUrl(String baseUrl) {
      Objects.requireNonNull(baseUrl, "baseUrl == null");
      return baseUrl(HttpUrl.get(baseUrl));
 }
 
 public Builder baseUrl(HttpUrl baseUrl) {
      Objects.requireNonNull(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(Objects.requireNonNull(factory, "factory == null"));
      return this;
 }
 
 // 添加请求适配器工厂
 public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
      callAdapterFactories.add(Objects.requireNonNull(factory, "factory == null"));
      return this;
 }

生成Retrofit实例最后需要调用build(), 那么我们来看看该方法的实现

// Retrofit.java 源码

 public Retrofit build() {
      // baseUrl 是必须要设置的，否则报异常
      if (baseUrl == null) {
        throw new IllegalStateException("base URL required.");
      }

      // 如果没有设置 callFactory，则默认使用 OkHttpClient
      okhttp3.Call.Factory callFactory = this.callFactory;
      if (callFactory == null) {
        callFactory = new OkHttpClient();
      }

      //如果没有设置 callbackExecutor，则使用当前运行平台的默认 callbackExecutor
      Executor callbackExecutor = this.callbackExecutor;
      if (callbackExecutor == null) {
        callbackExecutor = platform.defaultCallbackExecutor();
      }

      // 配置 CallAdapter.Factory 的集合，首先往集合中添加客户端设置的
      // 添加当前平台默认的 CompletableFutureCallAdapterFactory（Java8）与DefaultCallAdapterFactory
      List callAdapterFactories = new ArrayList<>(this.callAdapterFactories);
      callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

      // 配置 Converter.Factory 的集合
      List converterFactories =
          new ArrayList<>(
              1 + this.converterFactories.size() + platform.defaultConverterFactoriesSize());

      // 首先往集合中添加 BuiltInConverters
      converterFactories.add(new BuiltInConverters());
      // 然后添加客户端设置的 GsonConverterFactory
      converterFactories.addAll(this.converterFactories);
      // 最后添加当前平台默认的（OptionalConverterFactory）
      converterFactories.addAll(platform.defaultConverterFactories());
      
      // 调用 Retrofit 的构造函数来完成 Retrofit 中常量的赋值
      return new Retrofit(
          callFactory,
          baseUrl,
          unmodifiableList(converterFactories),
          unmodifiableList(callAdapterFactories),
          callbackExecutor,
          validateEagerly);
    }

上面代码使用了建造者模式去创建Retrofit的实例，创建的过程中主要配置了网络请求器工厂（callFactory）、网络请求的url地址（baseUrl）、数据转换器工厂的集合（converterFactories）、网络请求适配器工厂的集合（callAdapterFactories）、回调方法执行器（callbackExecutor）。

创建网络请求接口的实例

val api = retrofit.create(Api::class.java)

这部分用了动态代理以及外观模式创建了接口实例，以下是源码

// Retrofit.java 源码

public  T create(final Class service) {
   // 验证是否是接口
    validateServiceInterface(service);
    return (T)
        // 通过动态代理创建接口的实例
        Proxy.newProxyInstance(
           //参数1：classLoader,被代理对象的类加载器
            service.getClassLoader(),
           // 参数2：接口类型数组,被代理对象需要实现的全部接口
            new Class[] {service},
            // InvocationHandler，实现了 InvocationHandler 接口的对象
            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 的方法,那就直接调用
                if (method.getDeclaringClass() == Object.class) {
                  return method.invoke(this, args);
                }
                args = args != null ? args : emptyArgs;
                return platform.isDefaultMethod(method)
                    ? platform.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(method).invoke(args);
              }
            });
  }

invoke()方法为InvocationHandler接口需要重写的方法，该方法里面会通过Java反射机制调用被代理对象的方法。该方法中参数1（proxy动态代理对象）对应例子中Api类，参数2（method 被代理对象的方法）对应例子中listRepos（）方法，参数3（args被代理对象方法的参数）对应例子中listRepos（）方法参数。

platform.isDefaultMethod()判断该方法是Java8默认方法，则执行该平台的默认方法。否则，会调用loadServiceMethod()方法得到ServiceMethod后再调用invoke()方法。

// Retrofit.java 源码

 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);
        //将解析出的信息添加到ConcurrentHashMap中供之后用
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

首先会从 ServiceMethod 缓存集合中取出当前方法对应的 ServiceMethod，如果不为空，则直接返回。如果为空，则创建一个新的 ServiceMethod，即调用parseAnnotations()方法创建，然后再存到缓存集合中。

//ServiceMethod 源码

static  ServiceMethod parseAnnotations(Retrofit retrofit, Method method) {
    // 调用 RequestFactory 的 parseAnnotations() 方法解析网络请求接口中的注解（关注点1）
    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.");
    }
      //将接口方法的调用调整为HTTP请求（关注点2）
    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

上面的方法，主要做了三件工作：首先，RequestFactory调用parseAnnotations（）方法解析请求接口注解（解析方法、方法注解、参数类型、参数注解数组）；接着，对返回类型进行判断；最后，HttpServiceMethod调用parseAnnotations（）方法返回对应的请求。

关注1

// RequestFactory 源码

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

// RequestFactory-Builder 源码
Builder(Retrofit retrofit, Method method) {
      // Retrofit 对象
      this.retrofit = retrofit;
      // 方法
      this.method = method;
      // 方法注解
      this.methodAnnotations = method.getAnnotations();
      // 参数类型
      this.parameterTypes = method.getGenericParameterTypes();
      // 参数注解数组
      this.parameterAnnotationsArray = method.getParameterAnnotations();
}  

// RequestFactory-Builder 源码
RequestFactory build() {
  
   for (Annotation annotation : methodAnnotations) {
        // 对请求方式（比如GET、POST）和请求地址进行解析
        parseMethodAnnotation(annotation);
   }
   
   // 省略部分判断...
   
   int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler[parameterCount];
      for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
        parameterHandlers[p] =
            // 对方法中的参数注解进行解析（比如@Query、@Part）
            parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
     }
    
    // 省略部分判断...
    
    // 网络请求接口中的注解已经解析出来了，然后创建 RequestFactory 对象并进行赋值后返回
    return new RequestFactory(this);
}

RequestFactory(Builder builder) {
    // 方法
    method = builder.method;
    // baseUrl
    baseUrl = builder.retrofit.baseUrl;
    // http 方法
    httpMethod = builder.httpMethod;
    // 相对路径
    relativeUrl = builder.relativeUrl;
    // 请求头，没有设置，默认为 null
    headers = builder.headers;
    // contentType，没有设置，默认为 null
    contentType = builder.contentType;
    // hasBody，没有设置，默认为 false
    hasBody = builder.hasBody;
    // isFormEncoded，没有设置，默认为 false
    isFormEncoded = builder.isFormEncoded;
    // isMultipart，没有设置，默认为 false
    isMultipart = builder.isMultipart;
     // 参数数组，例子中没有传参数，所以为 null
    parameterHandlers = builder.parameterHandlers;
    // 是否kotlin协程中挂起的函数
    isKotlinSuspendFunction = builder.isKotlinSuspendFunction;
  }

关注2

// HttpServiceMethod 源码

 static  HttpServiceMethod parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
    ...
    //获取方法注解
    Annotation[] annotations = method.getAnnotations();
    Type adapterType;
    if (isKotlinSuspendFunction) {
      ...
    } else {
      //网络请求方法的返回值类型就是请求适配器的类型
      adapterType = method.getGenericReturnType();
    }

    // 根据网络请求接口中的返回类型与注解
    // 获取相对应的网络请求适配器（CallAdapter）
    CallAdapter callAdapter = createCallAdapter(retrofit, method);
     // 获取响应类型
    Type responseType = callAdapter.responseType();
    
    // 根据网络请求接口中的返回类型与注解获取相对应的数据转换器（Converter）
     Converter responseConverter = createResponseConverter(retrofit, method, responseType);
     // 获取网络请求器工厂（okhttp3.Call.Factory）
     okhttp3.Call.Factory callFactory = retrofit.callFactory;
     
     if (!isKotlinSuspendFunction) {
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    }
    ...
}

抽象类HttpServiceMethod调用parseAnnotations（）方法用来获取相对应的网络请求适配器（CallAdapter）、数据转换器（Converter）与网络请求器工厂（okhttp3.Call.Factory），最后再通过这些来创建HttpServiceMethod对象进行返回，CallAdapted类继承自HttpServiceMethod类，并实现adapt()抽象方法，而HttpServiceMethod继承自ServiceMethod。通过分析上面的源码可知，retrofit的create()方法中loadServiceMethod(method)方法实际上返回就是HttpServiceMethod对象。

现在loadServiceMethod方法()执行流程分析完毕，接着调用invoke()方法。

// create ()方法最后调用invoke 方法
loadServiceMethod(method).invoke(args);

// ServiceMethod 源码
abstract T invoke(Object[] args);

// HttpServiceMethod 源码
 @Override
  final @Nullable ReturnT invoke(Object[] args) {
    Call call = new OkHttpCall<>(requestFactory, args, callFactory, responseConverter);
    // call 类型为OkHttpCall
    return adapt(call, args);
  }
  
// 抽象类HttpServiceMethod 的abstract adapt()
protected abstract @Nullable ReturnT adapt(Call call, Object[] args);

//CallAdapted继承了HttpServiceMethod
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;
    }
  //adapt方法的实现，调用callAdapter的adapt方法
    @Override
    protected ReturnT adapt(Call call, Object[] args) {
      return callAdapter.adapt(call);
    }
  }
  
// DefaultCallAdapterFactory 源码
@Override
  public @Nullable CallAdapter get(
      Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    if (!(returnType instanceof ParameterizedType)) {
      throw new IllegalArgumentException(
          "Call return type must be parameterized as Call or Call");
    }
    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

Retrofit 源码解析

Java相关栏目本月热门文章