Spring Cloud升级之路 - Hoxton - 5. 实现微服务调用重试

た入场券 2023-02-15 12:59 27阅读 0赞

## feign 实现重试 ##

我们继续使用`resilience4j`实现重试，根据上一篇[Spring Cloud升级之路 - Hoxton - 4. 使用Resilience4j实现实例级别的隔离与熔断][Spring Cloud_ - Hoxton - 4. _Resilience4j]，我们已经加载了`RetryReqistry`这个核心配置`Bean`。

`Retry`相关的配置：[create-and-configure-retry][]

<table> 
 <thead> 
  <tr> 
   <th>配置项</th> 
   <th>默认值</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>maxAttempts</td> 
   <td>3</td> 
   <td>最大重试次数，<strong>包括本身那次调用</strong></td> 
  </tr> 
  <tr> 
   <td>waitDuration</td> 
   <td>500[ms]</td> 
   <td>重试间隔时间</td> 
  </tr> 
  <tr> 
   <td>intervalFunction</td> 
   <td>numOfAttempts -&gt; waitDuration</td> 
   <td>重试间隔时间函数，和 waitDuration 只能设置一个，默认就是 waitDuration</td> 
  </tr> 
  <tr> 
   <td>retryOnResultPredicate</td> 
   <td>result -&gt; false</td> 
   <td>通过结果判断是否重试，默认是只要获取到结果就不重试</td> 
  </tr> 
  <tr> 
   <td>retryOnExceptionPredicate</td> 
   <td>throwable -&gt; true</td> 
   <td>通过抛出的异常判断是否重试，默认是只要有异常就会重试</td> 
  </tr> 
  <tr> 
   <td>retryExceptions</td> 
   <td>empty</td> 
   <td>配置抛出这些异常以及子类则会重试</td> 
  </tr> 
  <tr> 
   <td>ignoreExceptions</td> 
   <td>empty</td> 
   <td>配置抛出这些异常以及子类则不会重试</td> 
  </tr> 
 </tbody> 
</table>

我们这里的配置是：

resilience4j.retry:
      configs:
        default:
          maxRetryAttempts: 2
          waitDuration: 1
          retryExceptions:
            - java.lang.Exception
        service-provider2:
          maxRetryAttempts: 4

参考之前我们的[`LoadBalancerConfig`][LoadBalancerConfig]

//对于非返回200的接口，抛出异常
    if (execute.status() != HttpStatus.OK.value()) {
        throw new ResponseWrapperException(execute.toString(), execute);
    }

所以，只要配置了所有异常都重试，对于非200返回也会重试。

实现重试，需要在负载均衡器作用之前，由于`Spring-Cloud`中可能会有很多的胶水代码，所以利用实现`FeignBlockingLoadBalancerClient`的方式可能扩展性不太好，这里使用切面的方式，实现重试。

[`CustomizedCircuitBreakerAspect`][CustomizedCircuitBreakerAspect]

//配置哪些包下的FeignClient进行重试，必须含有@FeignClient注解
    @Around("execution(* com.github.hashjang.hoxton..*(..)) && @within(org.springframework.cloud.openfeign.FeignClient)")
    public Object feignClientWasCalled(final ProceedingJoinPoint pjp) throws Throwable {
        boolean isGet = false;
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        FeignClient annotation = signature.getMethod().getDeclaringClass().getAnnotation(FeignClient.class);
        String serviceName = annotation.value();
        if (StringUtils.isBlank(serviceName)) {
            serviceName = annotation.name();
        }
    
        //查看是否是GET请求
        RequestMapping requestMapping = signature.getMethod().getAnnotation(RequestMapping.class);
        if (requestMapping != null &&
                (requestMapping.method().length == 0 ||
                        Arrays.asList(requestMapping.method()).contains(RequestMethod.GET))
        ) {
            isGet = true;
        }
        GetMapping getMapping = signature.getMethod().getAnnotation(GetMapping.class);
        if (getMapping != null) {
            isGet = true;
        }
        Retry retry;
        try {
            retry = retryRegistry.retry(serviceName, serviceName);
        } catch (ConfigurationNotFoundException e) {
            retry = retryRegistry.retry(serviceName);
        }
        if (!isGet) {
            //非GET请求，只有在断路器打开的情况下，才会重试
            retry = Retry.of(serviceName, RetryConfig.from(retry.getRetryConfig()).retryExceptions().retryOnException(throwable -> {
                Throwable cause = throwable.getCause();
                if (cause instanceof CallNotPermittedException) {
                    //对于断路器，不区分方法，都重试，因为没有实际调用
                    log.info("retry on circuit breaker is on: {}", cause.getMessage());
                    return true;
                }
                return false;
            }).build());
        }
        //对于GET请求，启用重试机制
        Supplier<Object> objectSupplier = Retry.decorateSupplier(retry, () -> {
            try {
                return pjp.proceed();
            } catch (Throwable throwable) {
                ReflectionUtils.rethrowRuntimeException(throwable);
                return null;
            }
        });
        return Try.ofSupplier(objectSupplier).get();
    }

## Spring Cloud Gateway 实现重试 ##

Spring Cloud Gateway 默认有自己的重试，并且`resilience4j`的`Retry`和 Spring Cloud Gateway 的 Reactor 机制是不兼容的，所以需要写一些额外的胶水代码，这里为了简便，就使用 Spring Cloud Gateway 默认有自己的重试。利用这个重试实现重试`Filter`插入到 Spring Cloud Gateway 中。

Spring Cloud Gateway 的重试`Filter`通过`RetryGatewayFilterFactory`实现，我们想对每个微服务调用生效，将他做成一个`GlobalFilter`.并且这个重试需要在负载均衡选择实例之前，所以，这个重试，必须要在`RouteToRequestUrlFilter`还有`LoadBalancerClientFilter`之前(这两个负责对于`lb:`路由查询负载均衡器获取实例重写 URL )。

我们想实现不同微服务不同配置，于是我们生成配置类`ApiGatewayRetryConfig`：

@Data
    @ConfigurationProperties(prefix = "spring.cloud.gateway")
    public class ApiGatewayRetryConfig {
        private Map<String, RetryGatewayFilterFactory.RetryConfig> retry;
    
        public RetryGatewayFilterFactory.RetryConfig getDefault() {
            return retry.computeIfAbsent("default", key -> new RetryGatewayFilterFactory.RetryConfig());
        }
    }

其中的`RetryConfig`包含如下我们使用到的属性：

<table> 
 <thead> 
  <tr> 
   <th>配置项</th> 
   <th>默认值</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>retries</td> 
   <td>3</td> 
   <td>最大重试次数，不包括本身那次调用</td> 
  </tr> 
  <tr> 
   <td>series</td> 
   <td>SERVER_ERROR</td> 
   <td>对于哪些响应码重试，默认是所有的5XX响应码</td> 
  </tr> 
  <tr> 
   <td>statuses</td> 
   <td>empty</td> 
   <td>对于哪些状态码重试，这个是具体的 HttpStatus，和 series 之间只能指定一个</td> 
  </tr> 
  <tr> 
   <td>methods</td> 
   <td>GET</td> 
   <td>对于哪些 HttpMethod 重试。</td> 
  </tr> 
  <tr> 
   <td>exceptions</td> 
   <td>List.of(IOException.class, TimeoutException.class)</td> 
   <td>对于哪些异常重试，默认是IO异常和超时异常</td> 
  </tr> 
  <tr> 
   <td>backoff</td> 
   <td></td> 
   <td>backOff配置，决定之后如何重试</td> 
  </tr> 
  <tr> 
   <td>- firstBackoff</td> 
   <td>5[ms]</td> 
   <td>第一次重试间隔</td> 
  </tr> 
  <tr> 
   <td>- maxBackoff</td> 
   <td></td> 
   <td>最大重试间隔</td> 
  </tr> 
  <tr> 
   <td>- factor</td> 
   <td>2</td> 
   <td>每次的重试间隔 = firstBackoff * (factor ^ (次数 - 1))，最大是maxBackoff</td> 
  </tr> 
  <tr> 
   <td>- basedOnPreviousValue</td> 
   <td>true</td> 
   <td>是否基于上次请求的 backoff，如果是，则保留上次 backoff 时间，下次从这个 backoff 时间开始作为第一次重试间隔</td> 
  </tr> 
 </tbody> 
</table>

我们的配置：

spring:
      cloud:
        gateway:
          # 这是我们自定义的重试配置：ApiGatewayRetryConfig,
          retry:
            default:
              retries: 1
              series: SERVER_ERROR,CLIENT_ERROR
              methods: GET
              # 对于断路器打开也会重试
              exceptions: io.github.resilience4j.circuitbreaker.CallNotPermittedException, org.springframework.cloud.gateway.support.TimeoutException, java.io.IOException
              backoff:
                basedOnPreviousValue: true
                factor: 2
                firstBackoff: 100ms
                maxBackoff: 500ms

[Spring Cloud_ - Hoxton - 4. _Resilience4j]: https://blog.csdn.net/zhxdick/article/details/106566509
[create-and-configure-retry]: https://resilience4j.readme.io/docs/retry#create-and-configure-retry
[LoadBalancerConfig]: https://github.com/HashZhang/spring-cloud-scaffold/blob/master/spring-cloud-hoxton/spring-cloud-hoxton-service-consumer/src/main/java/com/github/hashjang/hoxton/service/consumer/config/CommonLoadBalancerConfig.java
[CustomizedCircuitBreakerAspect]: https://github.com/HashZhang/spring-cloud-scaffold/blob/master/spring-cloud-hoxton/spring-cloud-hoxton-service-consumer/src/main/java/com/github/hashjang/hoxton/service/consumer/config/CustomizedCircuitBreakerAspect.java