Retrofit(三)

Android知识总结

一、ServiceMethod

ServiceMethod是一个负责转化(适配)的类，负责把一个接口的抽象方法的执行过程的结果转化(适配)成一个网络请求(HTTP call)。

1、ServiceMethod 内部参数

final class ServiceMethod {
  // 用来校验的常量
  static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
  static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{(" + PARAM + ")\\}");
  static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
  /**
   * 网络请求工厂，用于生产我们的网络请求，
   * 这个call在Retrofit当中其实就是我们的OKHTTP Call,
   * 而OKHTTP Call呢就是Retrofit对它做了封装。它内部其实是调用了OKHTTP Call。
   */
  private final okhttp3.Call.Factory callFactory;
  // 网络请求适配器，把我们的Call请求适用于不同的平台。例如：RxJava等。
  private final CallAdapter callAdapter;
  //基础HttpUrl
  private final HttpUrl baseUrl;
  // 数据转换器。作用就是把服务器返回给我们的数据，转换成我们需要的java Bean对象。
  private final Converter responseConverter;
  // 网络请求的HTTP方法，比如：get, post, put等等。
  private final String httpMethod;
  // 网络请求的相对地址。 相对地址 + baseUrl = 网络请求的绝对地址。
  private final String relativeUrl;
  // HTTP网络请求的请求头。键值对。
  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;
  ...
}

2、ServiceMethod.Builder构造方法

 //Retrofit
    final Retrofit retrofit;
    //定义接口的抽象方法
    final Method method;
    //定义接口的抽象方法上面的注解数组
    final Annotation[] methodAnnotations;
     //注解二维数组：第一维对应参数序列，第二维对应注解序列；
    final Annotation[][] parameterAnnotationsArray;
     // 参数类型数组
    final Type[] parameterTypes;
    // 响应的类型
    Type responseType;
    //是否有用 @Field 或者FieldMap 注解
    boolean gotField;
     //是否 有用@Part 或者 @PartMap注解
    boolean gotPart;
    //是否有用 @body注解
    boolean gotBody;
     // 是否 有用@Path 注解
    boolean gotPath;
     //是否 有用@Query 或者@QueryName 注解
    boolean gotQuery;
     // 是否具有url
    boolean gotUrl;
     //http 请求的方法
    String httpMethod;
     //是否  需要请求体
    boolean hasBody;
    //是否 使用@FormUrlEncoded  注解
    boolean isFormEncoded;
    // 是否 使用了@Multipart  注解
    boolean isMultipart;
    // 相对路径
    String relativeUrl;
     //请求头
    Headers headers;
    //类型
    MediaType contentType;
     //相对路径的url参数
    Set relativeUrlParamNames;
     //参数处理数组
    ParameterHandler[] parameterHandlers;
     //响应转化器
    Converter responseConverter;
     //请求转化器
    CallAdapter callAdapter;

    Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      // 获取网络请求方法(get,post等)
      this.method = method;
      // 获取网络请求接口方法里面的注解
      this.methodAnnotations = method.getAnnotations();
      // 获取网络请求接口方法里的参数的类型，它是一个types。
      this.parameterTypes = method.getGenericParameterTypes();
      // 获取网络请求接口方法里注解的完整内容
      this.parameterAnnotationsArray = method.getParameterAnnotations()
    }

• build()方法

    public ServiceMethod build() {
      // 查找能够适配返回类型的CallAdpater
      callAdapter = createCallAdapter();
      //获取方法的返回类型
      responseType = callAdapter.responseType();
      if (responseType == Response.class || responseType == okhttp3.Response.class) {
        throw methodError("'"
            + Utils.getRawType(responseType).getName()
            + "' is not a valid response body type. Did you mean ResponseBody?");
      }
      //设置请求的数据适配器 converter
      responseConverter = createResponseConverter();
      // 解读方法的注解
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      if (httpMethod == null) {
        throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      if (!hasBody) {
        if (isMultipart) {
          throw methodError(
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        if (isFormEncoded) {
          throw methodError("FormUrlEncoded can only be specified on HTTP methods with "
              + "request body (e.g., @POST).");
        }
      }

      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler[parameterCount];
      for (int p = 0; p < parameterCount; p++) {
        Type parameterType = parameterTypes[p];
        if (Utils.hasUnresolvableType(parameterType)) {
          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
              parameterType);
        }

        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
        if (parameterAnnotations == null) {
          throw parameterError(p, "No Retrofit annotation found.");
        }

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

      if (relativeUrl == null && !gotUrl) {
        throw methodError("Missing either @%s URL or @Url parameter.", httpMethod);
      }
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError("Non-body HTTP method cannot contain @Body.");
      }
      if (isFormEncoded && !gotField) {
        throw methodError("Form-encoded method must contain at least one @Field.");
      }
      if (isMultipart && !gotPart) {
        throw methodError("Multipart method must contain at least one @Part.");
      }

      return new ServiceMethod<>(this);
    }

ServiceMethod#createCallAdapter

    private CallAdapter createCallAdapter() {
      //获取网络请求接口方法里的返回的类型。
      Type returnType = method.getGenericReturnType();
      if (Utils.hasUnresolvableType(returnType)) {
        throw methodError(
            "Method return type must not include a type variable or wildcard: %s", returnType);
      }
      if (returnType == void.class) {
        throw methodError("Service methods cannot return void.");
      }
      //获取网络请求接口里的注解，调用的反射当中的getAnnotations()。
      Annotation[] annotations = method.getAnnotations();
      try {
        //noinspection unchecked  callAdapter(返回值, 注解类型)
        return (CallAdapter) 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);
      }
    }

获取方法的返回类型默认调用ExecutorCallAdapterFactory#CallAdapter#responseType 方法：

  @Override
  public CallAdapter get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    //method方法返回值类型必须是Call
    if (getRawType(returnType) != Call.class) {
      return null;
    }
    //获取Call的泛型T的类型
    final Type responseType = Utils.getCallResponseType(returnType);
    return new CallAdapter>() {
      @Override public Type responseType() {
        //Call那么返回的就是JavaBean
        return responseType;
      }
      //最终invoke会执行的方法
      //adapt方法参数的call就是OKhttpCall
      @Override public Call