RestTemplate组件：ClientHttpRequestFactory、ClientHttpRequestInterceptor、ResponseExtractor【享学Spring MVC】（中）-阿里云开发者社区

池化技术一般用于长连接，那么像Http这种适合连接池吗？

HttpClient 4.3以后中使用了PoolingHttpClientConnectionManager连接池来管理持有连接，同一条TCP链路上，连接是可以复用的。HttpClient通过连接池的方式进行连接持久化（所以它这个连接池其实是tcp的连接池。它里面有一个很重要的概念：Route的概念，代表一条线路。比如baidu.com是一个route，163.com是一个route…）。

连接池：可能是http请求，也可能是https请求

加入池话技术，就不用每次发起请求都新建一个连接（每次连接握手三次，效率太低）

AbstractClientHttpRequestFactoryWrapper

对其它ClientHttpRequestFactory的一个包装抽象类，它有如下两个子类实现

InterceptingClientHttpRequestFactory（重要）

Interceptor拦截的概念，还是蛮重要的。它持有的ClientHttpRequestInterceptor对于我们若想要拦截发出去的请求非常之重要（比如全链路压测中，可以使用它设置token之类的~）

// @since 3.1
public class InterceptingClientHttpRequestFactory extends AbstractClientHttpRequestFactoryWrapper {
  // 持有所有的请求拦截器
  private final List<ClientHttpRequestInterceptor> interceptors;
  public InterceptingClientHttpRequestFactory(ClientHttpRequestFactory requestFactory, @Nullable List<ClientHttpRequestInterceptor> interceptors) {
    super(requestFactory);
    // 拦截器只允许通过构造函数设置进来，并且并没有提供get方法方法~
    this.interceptors = (interceptors != null ? interceptors : Collections.emptyList());
  }
  // 此处返回的是一个InterceptingClientHttpRequest，显然它肯定是个ClientHttpRequest嘛~
  @Override
  protected ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory) {
    return new InterceptingClientHttpRequest(requestFactory, this.interceptors, uri, httpMethod);
  }
}

InterceptingClientHttpRequest的execute()方法的特点是：若存在拦截器，交给给拦截器去执行发送请求return nextInterceptor.intercept(request, body, this)，否则就自己上。

ClientHttpRequestInterceptor

关于请求拦截器，Spring MVC内置了两个最基础的实现

BasicAuthorizationInterceptor：

// @since 4.3.1  但在Spring5.1.1后推荐使用BasicAuthenticationInterceptor
@Deprecated
public class BasicAuthorizationInterceptor implements ClientHttpRequestInterceptor {
  private final String username;
  private final String password;
  // 注意：username不允许包含:这个字符，但是密码是允许的
  public BasicAuthorizationInterceptor(@Nullable String username, @Nullable String password) {
    Assert.doesNotContain(username, ":", "Username must not contain a colon");
    this.username = (username != null ? username : "");
    this.password = (password != null ? password : "");
  }
  @Override
  public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
    // 用户名密码连接起来后，用Base64对字节码进行编码~
    String token = Base64Utils.encodeToString((this.username + ":" + this.password).getBytes(StandardCharsets.UTF_8));
    // 放进请求头：key为`Authorization`  然后执行请求的发送
    request.getHeaders().add("Authorization", "Basic " + token);
    return execution.execute(request, body);
  }
}

这个拦截器木有对body有任何改动，只是把用户名、密码帮你放进了请求头上。

需要注意的是：若你的header里已经存在了Authorization这个key，这里也不会覆盖的，这会添加哦。但并不建议你有覆盖现象~

BasicAuthenticationInterceptor：

它是用来代替上类的。它使用标准的授权头来处理，参考HttpHeaders#setBasicAuth、HttpHeaders#AUTHORIZATION

public class BasicAuthenticationInterceptor implements ClientHttpRequestInterceptor {
  private final String username;
  private final String password;
  // 编码，一般不用指定
  @Nullable
  private final Charset charset;
  ... // 构造函数略
  @Override
  public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
    HttpHeaders headers = request.getHeaders();
    // 只有当请求里不包含`Authorization`这个key的时候，此处才会设置授权头哦
    if (!headers.containsKey(HttpHeaders.AUTHORIZATION)) {
      // 这个方法是@since 5.1之后才提供的~~~~~
      // 若不包含此key，就设置标准的授权头（根据用户名、密码） 它内部也有这如下三步：
      // String credentialsString = username + ":" + password;
      // byte[] encodedBytes = Base64.getEncoder().encode(credentialsString.getBytes(charset));
      // String encodedCredentials = new String(encodedBytes, charset);
      // 注意：它内部最终还是调用set(AUTHORIZATION, "Basic " + encodedCredentials);这个方法的
      headers.setBasicAuth(this.username, this.password, this.charset);
    }
    return execution.execute(request, body);
  }
}

说明：这两个请求拦截器虽是Spring提供，但默认都是没有被"装配"的，所亲需要，请手动装配~

BufferingClientHttpRequestFactory

包装其它ClientHttpRequestFactory，使得具有缓存的能力。若开启缓存功能（有开关可控），会使用BufferingClientHttpRequestWrapper包装原来的ClientHttpRequest。这样发送请求后得到的是BufferingClientHttpResponseWrapper响应。

ResponseErrorHandler

用于确定特定响应是否有错误的策略接口。

// @since 3.0
public interface ResponseErrorHandler {
  // response里是否有错
  boolean hasError(ClientHttpResponse response) throws IOException;
  // 只有hasError = true时才会调用此方法
  void handleError(ClientHttpResponse response) throws IOException;
   // @since 5.0
  default void handleError(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {
    handleError(response);
  }
}

继承树如下：

DefaultResponseErrorHandler

Spring对此策略接口的默认实现，RestTemplate默认使用的错误处理器就是它。

// @since 3.0
public class DefaultResponseErrorHandler implements ResponseErrorHandler {
  // 是否有错误是根据响应码来的，所以请严格遵守响应码的规范啊
  // 简单的说4xx和5xx都会被认为有错，否则是无错的  参考：HttpStatus.Series
  @Override
  public boolean hasError(ClientHttpResponse response) throws IOException {
    int rawStatusCode = response.getRawStatusCode();
    HttpStatus statusCode = HttpStatus.resolve(rawStatusCode);
    return (statusCode != null ? hasError(statusCode) : hasError(rawStatusCode));
  }
  ...
  // 处理错误
  @Override
  public void handleError(ClientHttpResponse response) throws IOException {
    HttpStatus statusCode = HttpStatus.resolve(response.getRawStatusCode());
    if (statusCode == null) {
      throw new UnknownHttpStatusCodeException(response.getRawStatusCode(), response.getStatusText(), response.getHeaders(), getResponseBody(response), getCharset(response));
    }
    handleError(response, statusCode);
  }
  // protected方法，子类对它有复写
  protected void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {
    String statusText = response.getStatusText();
    HttpHeaders headers = response.getHeaders();
    byte[] body = getResponseBody(response); // 拿到body，把InputStream转换为字节数组
    Charset charset = getCharset(response); // 注意这里的编码，是从返回的contentType里拿的~~~
    // 分别针对于客户端错误、服务端错误 包装为HttpClientErrorException和HttpServerErrorException进行抛出
    // 异常内包含有状态码、状态text、头、body、编码等等信息~~~~
    switch (statusCode.series()) {
      case CLIENT_ERROR:
        throw HttpClientErrorException.create(statusCode, statusText, headers, body, charset);
      case SERVER_ERROR:
        throw HttpServerErrorException.create(statusCode, statusText, headers, body, charset);
      default:
        throw new UnknownHttpStatusCodeException(statusCode.value(), statusText, headers, body, charset);
    }
  }
  ...
}

到这里就可以给大家解释一下，为何经常能看到客户端错误，然后还有状态码+一串信息了，就是因为这两个异常。

HttpClientErrorException：

public class HttpClientErrorException extends HttpStatusCodeException {
  ...
  public static HttpClientErrorException create(
      HttpStatus statusCode, String statusText, HttpHeaders headers, byte[] body, @Nullable Charset charset) {
    switch (statusCode) {
      case BAD_REQUEST:
        return new HttpClientErrorException.BadRequest(statusText, headers, body, charset);
      case UNAUTHORIZED:
        return new HttpClientErrorException.Unauthorized(statusText, headers, body, charset);
      case FORBIDDEN:
        return new HttpClientErrorException.Forbidden(statusText, headers, body, charset);
      case NOT_FOUND:
        return new HttpClientErrorException.NotFound(statusText, headers, body, charset);
      case METHOD_NOT_ALLOWED:
        return new HttpClientErrorException.MethodNotAllowed(statusText, headers, body, charset);
      case NOT_ACCEPTABLE:
        return new HttpClientErrorException.NotAcceptable(statusText, headers, body, charset);
      case CONFLICT:
        return new HttpClientErrorException.Conflict(statusText, headers, body, charset);
      case GONE:
        return new HttpClientErrorException.Gone(statusText, headers, body, charset);
      case UNSUPPORTED_MEDIA_TYPE:
        return new HttpClientErrorException.UnsupportedMediaType(statusText, headers, body, charset);
      case TOO_MANY_REQUESTS:
        return new HttpClientErrorException.TooManyRequests(statusText, headers, body, charset);
      case UNPROCESSABLE_ENTITY:
        return new HttpClientErrorException.UnprocessableEntity(statusText, headers, body, charset);
      default:
        return new HttpClientErrorException(statusCode, statusText, headers, body, charset);
    }
  }
  ...
}

它针对不同的状态码HttpStatus，创建了不同的类型进行返回，方便使用者控制，这在监控上还是蛮有意义的

BadRequest、Unauthorized、Forbidden…等等都是HttpClientErrorException的子类

HttpServerErrorException代码类似，略~

ExtractingResponseErrorHandler

继承自DefaultResponseErrorHandler。在RESTful大行其道的今天，Spring5.0开始提供了此类。它将http错误响应利用HttpMessageConverter转换为对应的RestClientException

// @since 5.0 它出现得还是很晚的。继承自DefaultResponseErrorHandler 
// 若你的RestTemplate想使用它，请调用RestTemplate#setErrorHandler(ResponseErrorHandler)设置即可
public class ExtractingResponseErrorHandler extends DefaultResponseErrorHandler {
  private List<HttpMessageConverter<?>> messageConverters = Collections.emptyList();
  // 对响应码做缓存
  private final Map<HttpStatus, Class<? extends RestClientException>> statusMapping = new LinkedHashMap<>();
  private final Map<HttpStatus.Series, Class<? extends RestClientException>> seriesMapping = new LinkedHashMap<>();
  // 构造函数、set方法给上面两个Map赋值。因为我们可以自己控制哪些状态码应该报错，哪些不应该了~
  // 以及可以自定义：那个状态码抛我们自定义的异常，哪一系列状态码抛我们自定义的异常，这个十分的便于我们做监控
  ... // 省略构造函数和set方法。。。
  // 增加缓存功能~~~  否则在交给父类
  @Override
  protected boolean hasError(HttpStatus statusCode) {
    if (this.statusMapping.containsKey(statusCode)) {
      return this.statusMapping.get(statusCode) != null;
    } else if (this.seriesMapping.containsKey(statusCode.series())) {
      return this.seriesMapping.get(statusCode.series()) != null;
    } else {
      return super.hasError(statusCode);
    }
  }
  // 这个它做的事：extract：提取
  @Override
  public void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {
    if (this.statusMapping.containsKey(statusCode)) {
      extract(this.statusMapping.get(statusCode), response);
    } else if (this.seriesMapping.containsKey(statusCode.series())) {
      extract(this.seriesMapping.get(statusCode.series()), response);
    } else {
      super.handleError(response, statusCode);
    }
  }
  private void extract(@Nullable Class<? extends RestClientException> exceptionClass, ClientHttpResponse response) throws IOException {
    if (exceptionClass == null) {
      return;
    }
    // 这里使用到了ResponseExtractor返回值提取器,从返回值里提取内容(本文是提取异常)
    HttpMessageConverterExtractor<? extends RestClientException> extractor =
        new HttpMessageConverterExtractor<>(exceptionClass, this.messageConverters);
    RestClientException exception = extractor.extractData(response);
    if (exception != null) { // 若提取到了异常信息，抛出即可
      throw exception;
    }
  }
}

若你想定制请求异常的处理逻辑，你也是可以自定义这个接口的实现的，当然还是建议你通过继承DefaultResponseErrorHandler来扩展~

RestTemplate组件：ClientHttpRequestFactory、ClientHttpRequestInterceptor、ResponseExtractor【享学Spring MVC】（中）

AbstractClientHttpRequestFactoryWrapper

InterceptingClientHttpRequestFactory（重要）

InterceptingClientHttpRequest的execute()方法的特点是：若存在拦截器，交给给拦截器去执行发送请求return nextInterceptor.intercept(request, body, this)，否则就自己上。

ClientHttpRequestInterceptor

BufferingClientHttpRequestFactory

ResponseErrorHandler

DefaultResponseErrorHandler

ExtractingResponseErrorHandler

热门文章

最新文章

相关课程

相关电子书

相关实验场景