Android进阶:七、Retrofit2.0原理解析之最简流程【下】

时间:2022-06-01 20:37:01

Android进阶:七、Retrofit2.0原理解析之最简流程【下】

紧接上文Android进阶:七、Retrofit2.0原理解析之最简流程【上】

一.请求参数整理

我们定义的接口已经被实现,但是我们还是不知道我们注解的请求方式,参数类型等是如何发起网络请求的呢?

这时我们可能应该关注一下ServiceMethod<Object, Object>对象的构建了:

  ServiceMethod<Object, Object> serviceMethod =
                (ServiceMethod<Object, Object>) loadServiceMethod(method);

主要的逻辑都在这个loadServiceMethod(method)里面,我们看看方法体:

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

    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder<>(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

逻辑很简单,就是先从一个 serviceMethodCache中取ServiceMethod<?, ?>对象,如果没有,则构建ServiceMethod<?, ?>对象,然后放进去serviceMethodCache中,这个serviceMethodCache是一个HashMap:

private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap<>();

所以构建ServiceMethod<?, ?>对象的主要逻辑还不在这个方法里,应该在new ServiceMethod.Builder<>(this, method).build();里面。这也是个链式调用,一般都是参数赋值,我们先看看Builder<>(this, method)方法:

Builder(Retrofit retrofit, Method method) {
      this.retrofit = retrofit;
      this.method = method;
      this.methodAnnotations = method.getAnnotations();
      this.parameterTypes = method.getGenericParameterTypes();
      this.parameterAnnotationsArray = method.getParameterAnnotations();
    }

果然,这里获取了几个重要的参数:

  • retrofit实例
  • method,接口方法
  • 接口方法的注解methodAnnotations,在retrofit里一般为请求方式
  • 参数类型parameterTypes
  • 参数注解数组parameterAnnotationsArray,一个参数可能有多个注解

    我们再看看build()的方法:
 public ServiceMethod build() {
      callAdapter = createCallAdapter();
      responseType = callAdapter.responseType();
      responseConverter = createResponseConverter();

      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

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

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

      return new ServiceMethod<>(this);
    }

这个方法挺长的,删了些无关紧要的代码还是很长。首先一开始先获取几个重要对象:callAdapter、responseType和responseConverter,这三个对象都跟最后的结果有关,我们先不管。

看到一个for循环,遍历方法的注解,然后解析:

for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }
private void parseMethodAnnotation(Annotation annotation) {
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } 

        ....

这个方法的方法体我删掉了后面的一部分,因为逻辑都是一样,根据不同的方法注解作不同的解析,得到网络请求的方式httpMethod。但是主要的方法体还是if里面的方法:

private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {

      ....

      // Get the relative URL path and existing query string, if present.
      int question = value.indexOf('?');
      if (question != -1 && question < value.length() - 1) {
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
        if (queryParamMatcher.find()) {
          throw methodError("URL query string \"%s\" must not have replace block. "
              + "For dynamic query parameters use @Query.", queryParams);
        }
      }

      this.relativeUrl = value;
      this.relativeUrlParamNames = parsePathParameters(value);
    }

逻辑不复杂,就是校验这个value的值 是否合法,规则就是不能有“?”如果有则需要使用@Query注解。最后this.relativeUrl = value;。这个relativeUrl就相当于省略域名的URL,一般走到这里我们能得到的是:users/{name}/repos这样的。里面的“{name}”是一会我们需要赋值的变量

我们继续看刚才的build()方法:

解析完方法的注解之后,需要解析参数的注解数组,这里实例化了一个一维数组:

parameterHandlers = new ParameterHandler<?>[parameterCount];

然后遍历取出参数的类型:

Type parameterType = parameterTypes[p];

取出参数注解:

Annotation[] parameterAnnotations = parameterAnnotationsArray[p];

然后把参数类型、参数注解都放在一起进行解析,解析的结果放到刚才实例化的数组parameterHandlers里面:

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

那我们再看看这个方法里做了什么:

private ParameterHandler<?> parseParameter(int p, Type parameterType, Annotation[] annotations) {
      ParameterHandler<?> result = null;
      for (Annotation annotation : annotations) {
        ParameterHandler<?> annotationAction = parseParameterAnnotation(
            p, parameterType, annotations, annotation);
      }

    }

这个方法的主要代码也很简单,解析参数注解,得到一个ParameterHandler<?> annotationAction对象。

那我继续看方法里面的代码。当我们点进parseParameterAnnotation( p, parameterType, annotations, annotation);的源码里面去之后发现这个方法的代码接近500行!但是大部分逻辑类似,都是通过if else判断参数的注解,我们取一段我们刚才的例子相关的代码出来:

 if (annotation instanceof Path) {
        if (gotQuery) {
          throw parameterError(p, "A @Path parameter must not come after a @Query.");
        }
        if (gotUrl) {
          throw parameterError(p, "@Path parameters may not be used with @Url.");
        }
        if (relativeUrl == null) {
          throw parameterError(p, "@Path can only be used with relative url on @%s", httpMethod);
        }
        gotPath = true;

        Path path = (Path) annotation;
        String name = path.value();
        validatePathName(p, name);

        Converter<?, String> converter = retrofit.stringConverter(type, annotations);
        return new ParameterHandler.Path<>(name, converter, path.encoded());

      }

前面做了一些校验,后面取出注解的名字:name,然后用正则表达校验这个name是否合法。然后构建一个Converter<?, String>对象:

 Converter<?, String> converter = retrofit.stringConverter(type, annotations);

点击去看看:

public <T> Converter<T, String> stringConverter(Type type, Annotation[] annotations) {
      ....
    for (int i = 0, count = converterFactories.size(); i < count; i++) {
      Converter<?, String> converter =
          converterFactories.get(i).stringConverter(type, annotations, this);
      if (converter != null) {
        //noinspection unchecked
        return (Converter<T, String>) converter;
      }
    }
    return (Converter<T, String>) BuiltInConverters.ToStringConverter.INSTANCE;
  }

看到核心代码是converter的stringConverter(type, annotations, this)方法:

因为我们刚才的示例中被没有通过:addConverterFactory(ConverterFactory)添加一个ConverterFactory,所以这里会返回一个空:

 public @Nullable Converter<?, String> stringConverter(Type type, Annotation[] annotations,
        Retrofit retrofit) {
      return null;
    }

所以最后会执行最后一句代码:

return (Converter<T, String>) BuiltInConverters.ToStringConverter.INSTANCE;

我们点进去看看这个INSTANCE:

static final ToStringConverter INSTANCE = new ToStringConverter();

是BuiltInConverters内的内部类ToStringConverter的单例。所以这里我们得到的就

是BuiltInConverters.ToStringConverter的实例。

最后用这个对象构建一个Path(因为示例中的参数类型是path,所以我们看这个代码):

new ParameterHandler.Path<>(name, converter, path.encoded());

我们看看这个Path类的构造函数:

Path(String name, Converter<T, String> valueConverter, boolean encoded) {
      this.name = checkNotNull(name, "name == null");
      this.valueConverter = valueConverter;
      this.encoded = encoded;
    }

只是赋值,并且我们看到这个类继承自:ParameterHandler,所以我们回到刚才的build()方法,发现把参数类型,参数注解放在一起解析之后存储到了这个ParameterHandler数组中,中间主要做了多种合法性校验,并根据注解的类型,生成不同的

ParameterHandler子类,如注解是Url则生成ParameterHandler.RelativeUrl()对象,如果注解是Path,则生成:

ParameterHandler.Path<>(name, converter, path.encoded())对象等等。

我们查看了ParameterHandler类,发现它有一个抽象方法:

abstract void apply(RequestBuilder builder, @Nullable T value) throws IOException;

这个方法每个子类都必须复写,那我们看看Path里面怎么复写的:

  @Override
    void apply(RequestBuilder builder, @Nullable T value) throws IOException {
         builder.addPathParam(name, valueConverter.convert(value), encoded);
    }

就是把value被添加到RequestBuilder中,我们看一下这个addPathParam方法:

void addPathParam(String name, String value, boolean encoded) {

    relativeUrl = relativeUrl.replace("{" + name + "}", canonicalizeForPath(value, encoded));
  }

这个方法把我们传进来的值value按照编码格式转换,然后替换relativeUrl中的{name},构成一个有效的省略域名的URL。至此,URL的拼接已经完成!

总结:Retrofit使用动态代理模式实现我们定义的网络请求接口,在重写invoke方法的时候构建了一个ServiceMethod对象,在构建这个对象的过程中进行了方法的注解解析得到网络请求方式httpMethod,以及参数的注解分析,拼接成一个省略域名的URL

二.Retrofit网络请求

我们刚才解析了apply方法,我们看看apply方法是谁调用的呢?跟踪一下就发先只有toCall(args);方法:

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

    @SuppressWarnings("unchecked") // It is an error to invoke a method with the wrong arg types.
    ParameterHandler<Object>[] handlers = (ParameterHandler<Object>[]) parameterHandlers;

    int argumentCount = args != null ? args.length : 0;
    if (argumentCount != handlers.length) {
      throw new IllegalArgumentException("Argument count (" + argumentCount
          + ") doesn't match expected count (" + handlers.length + ")");
    }

    for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);
    }

    return callFactory.newCall(requestBuilder.build());
  }

这个方法一开始就构建了RequestBuilder,传进去的参数包含:

httpMethod,baseUrl,relativeUrl,headers,contentType,hasBody,isFormEncoded,isMultipart!

然后获取了parameterHandlers,我们上边分析的时候,知道这个数组是存参数注解的解析结果的,并对其进行遍历调用了如下方法:

for (int p = 0; p < argumentCount; p++) {
      handlers[p].apply(requestBuilder, args[p]);
    }

把参数值传进RequestBuilder中。

最后调用callFactory.newCall(requestBuilder.build())生成一个okhttp3.Call。

我们看一下这个build方法:

Request build() {
    HttpUrl url;
    HttpUrl.Builder urlBuilder = this.urlBuilder;
    if (urlBuilder != null) {
      url = urlBuilder.build();
    } else {
      // No query parameters triggered builder creation, just combine the relative URL and base URL.
      //noinspection ConstantConditions Non-null if urlBuilder is null.
      url = baseUrl.resolve(relativeUrl);
      if (url == null) {
        throw new IllegalArgumentException(
            "Malformed URL. Base: " + baseUrl + ", Relative: " + relativeUrl);
      }
    }

    RequestBody body = this.body;
    if (body == null) {
      // Try to pull from one of the builders.
      if (formBuilder != null) {
        body = formBuilder.build();
      } else if (multipartBuilder != null) {
        body = multipartBuilder.build();
      } else if (hasBody) {
        // Body is absent, make an empty body.
        body = RequestBody.create(null, new byte[0]);
      }
    }

    MediaType contentType = this.contentType;
    if (contentType != null) {
      if (body != null) {
        body = new ContentTypeOverridingRequestBody(body, contentType);
      } else {
        requestBuilder.addHeader("Content-Type", contentType.toString());
      }
    }

    return requestBuilder
        .url(url)
        .method(method, body)
        .build();
  }

可以看到okhttp的请求体在这里构建,当所有的参数满足的时候,则调用了

Request.Builder requestBuilder
        .url(url)
        .method(method, body)
        .build();

这是发起okhttp的网络请求 。

那这个toCall(args);谁调用的呢?继续往回跟!

 private okhttp3.Call createRawCall() throws IOException {
    okhttp3.Call call = serviceMethod.toCall(args);
    return call;
  }

那谁调用了createRawCall()呢?继续看谁调用了!于是发现调用方有三个地方,并且都是OkHttpCall里面!我们一个一个看吧:

  1. Request request()方法:
  2. enqueue(final Callback callback)方法
  3. Response execute()的方法

    很明显上面三个方法都是retrofit的发起网络请求的方式,分别是同步请求和异步请求。我们的示例中在最后一步就是调用了request方法和enqueue方法发起网络请求。至此我们已经疏通了retrofit是如何进行网络请求的了。

    总结:当我们调用Retrofit的网络请求方式的时候,就会调用okhttp的网络请求方式,参数使用的是实现接口的方法的时候拿到的信息构建的RequestBuilder对象,然后在build方法中构建okhttp的Request,最终发起网络请求

三.总结

至此retrofit的流程讲完了,文章很长,代码很多,读者最好下载代码导入IDE,跟着文章一起看代码

Retrofit主要是在create方法中采用动态代理模式实现接口方法,这个过程构建了一个ServiceMethod对象,根据方法注解获取请求方式,参数类型和参数注解拼接请求的链接,当一切都准备好之后会把数据添加到Retrofit的RequestBuilder中。然后当我们主动发起网络请求的时候会调用okhttp发起网络请求,okhttp的配置包括请求方式,URL等在Retrofit的RequestBuilder的build()方法中实现,并发起真正的网络请求。

Retrofit封装了okhttp框架,让我们的网络请求更加简洁,同时也能有更高的扩展性。当然我们只是窥探了Retrofit源码的一部分,他还有更复杂更强大的地方等待我们去探索包括返回值转换工厂,拦截器等,这些都属于比较难的地方,我们需要循序渐进的去学习,当我们一点一点的看透框架的本质之后,我们使用起来才会熟能生巧。大神的代码,对于Android想要进阶的同学来说很有好处,不仅教会我们如何设计代码更多的是解决思想。