技术教程 编程教程 怎么集成Spring Retry实现失败重试和熔断器模式 正文

怎么集成Spring Retry实现失败重试和熔断器模式

2023-05-15,

这篇“怎么集成Spring Retry实现失败重试和熔断器模式”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“怎么集成Spring Retry实现失败重试和熔断器模式”文章吧。

    背景

    在我们的大多数项目中，会有一些场景需要重试操作，而不是立即失败，让系统更加健壮且不易发生故障。

    场景如下：

    • 瞬时网络抖动故障

    • 服务器重启

    • 偶发死锁

    • 某些上游的异常或者响应码，需要进行重试

    • 远程调用

    • 从数据库中获取或存储数据

    以上皆为瞬时故障。

    也会有一些场景，例如不是瞬时故障，例如接口响应一直很慢，需要的是断路器，如果还是继续重试，会对服务有很大的影响，例如请求一次需要30s，如果还去不断的重试，会拖垮我们的系统，我们需要一定次数的失败后停止向服务发送进一步的请求，并在一段时间后恢复发送请求。

    Spring Retry提供了以下能力:

    • 失败重试

    • 断路器模式

    不支持舱壁bulkhead线程隔离
    不支持超时timeout机制

    实战

    添加依赖

    <dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.3.3</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>${version}</version>
</dependency>
或者
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <aifactId>spring-boot-starter-aop</artifactId>
</dependency>

    启用重试

    @Configuration
@EnableRetry
public class RetryConfig {
}

    @Retryable

    在需要重试的方法上加上@Retryable注解

    部分参数如下：

    • label: 重试的名字，系统唯一，默认 “”

    • maxAttempts：异常时重试次数，默认 3

    • maxAttemptsExpression: SpEL表达式 ，从配置文件获取maxAttempts的值，可以在application.yml设置，与maxAttempts二选一

    • exceptionExpression: SpEL表达式，匹配异常。例如：exceptionExpression = "#{message.contains('test')}"

    • include：需要重试的异常

    • exclude：不需要重试的异常

    • backoff：重试中的退避策略 ,@Backoff注解，部分参数如下：

    • value： 重试间隔ms，默认 1000

    • delay: 在指数情况下用作初始值，在均匀情况下用作最小值, 它与value属性不能共存，当delay不设置的时候会去读value属性设置的值，如果delay设置的话则会忽略value属性, 默认 0

    • delayExpression: SpEL表达式 ，从配置文件获取delay的值，可以在application.yml设置，与delay二选一

    • multiplier: 则用作产生下一个退避延迟的乘数 , 默认 0

    • delay = 2000, multiplier = 2 表示第一次重试间隔为2s，第二次为4秒，第三次为8s

    • maxDelay: 最大的重试间隔，当超过这个最大的重试间隔的时候，重试的间隔就等于maxDelay的值 默认 0

    @Service
@Slf4j
public class RetryService {
   
    @Retryable(value = RuntimeException.class)
    public void test(String param){
        log.info(param);
        throw new RuntimeException("laker Error");
    }
}

    当抛出RuntimeException时会尝试重试。

    根据@Retryable的默认行为，重试最多可能发生 3 次，重试之间有 1 秒的延迟。

    测试日志如下：

    2022-07-16 18:23:46.274  INFO 10204 --- [           main] com.example.demo.retry.RetryService      : laker
    2022-07-16 18:23:47.278  INFO 10204 --- [           main] com.example.demo.retry.RetryService      : laker
    2022-07-16 18:23:48.289  INFO 10204 --- [           main] com.example.demo.retry.RetryService      : laker

    java.lang.RuntimeException: laker Error
        at com.example.demo.retry.RetryService.test(RetryService.java:18)
        at com.example.demo.retry.RetryService$$FastClassBySpringCGLIB$$41aa3d8d.invoke(<generated>)
        at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)

    @Recover

    当@Retryable方法重试失败之后，最后就会调用@Recover方法。用于@Retryable失败时的兜底处理方法。

    @Recover的方法必须要与@Retryable注解的方法保持一致，第一入参为要重试的异常，其他参数与@Retryable保持一致，返回值也要一样，否则无法执行！,方法可以是public、private.

    @Service
@Slf4j
public class RetryService {
    @Retryable(value = RuntimeException.class)
    public void test(String param) {
        log.info(param);
        throw new RuntimeException("laker Error");
    }
    @Recover
    void recover(RuntimeException e, String param) {
        log.info("recover e:{},param:{}", e, param);
    }
}

    在这里，当抛出RuntimeException时会尝试重试。

    test方法在 3 次尝试后不断抛出 RuntimeException，则会调用recover()方法。

    测试日志如下：

    2022-07-16 18:40:19.828  INFO 4308 --- [           main] com.example.demo.retry.RetryService      : laker
    2022-07-16 18:40:20.834  INFO 4308 --- [           main] com.example.demo.retry.RetryService      : laker
    2022-07-16 18:40:21.848  INFO 4308 --- [           main] com.example.demo.retry.RetryService      : laker
    2022-07-16 18:40:21.849  INFO 4308 --- [           main] com.example.demo.retry.RetryService      : recover e:java.lang.RuntimeException: laker Error,param:laker

    @CircuitBreaker

    熔断模式：指在具体的重试机制下失败后打开断路器，过了一段时间，断路器进入半开状态，允许一个进入重试，若失败再次进入断路器，成功则关闭断路器，注解为@CircuitBreaker,具体包括熔断打开时间、重置过期时间。

    同一个方法上与@Retryable注解只能二选一，否则注解失效

    相关代码参见CircuitBreakerRetryPolicy.java

    主要参数如下：

    • maxAttempts： 最大尝试次数（包括第一次失败），默认为 3

    • maxAttemptsExpression: SpEL表达式 ，从配置文件获取maxAttempts的值，可以在application.yml设置，与maxAttempts二选一

    • openTimeout：当在此超时时间内达到maxAttempts失败时，电路会自动打开，防止访问下游组件。默认为 5000

    • openTimeoutExpression: SpEL表达式

    • resetTimeout： 如果电路打开的时间超过此超时时间，则它会在下一次调用时重置，以使下游组件有机会再次响应。默认为 20000

    • resetTimeoutExpression: SpEL表达式

    • label：短路器的名字，系统唯一

    • include：需要短路的异常

    • exclude：不需要短路的异常

       @CircuitBreaker(maxAttempts = 2, openTimeout = 1000, resetTimeout = 2000, value = RuntimeException.class)
    public void testCircuitBreaker(String param) {
        log.info(param);
        throw new RuntimeException("laker Error");
    }

    @Recover
    void recover(RuntimeException e, String param) {
        log.info("recover e:{},param:{}", e, param);
    }

    当抛出RuntimeException时会尝试熔断。

    在openTimeout 1s时间内，触发异常超过2次，断路器打开，testCircuitBreaker业务方法不允许执行，直接执行恢复方法recover。

    经过resetTimeout 2s后，熔断器关闭，继续执行testCircuitBreaker业务方法。

    注意：这里没有上面@Retryable的能力了哦，但是这个实际项目还是很需要的。

    测试日志如下：

    2022-07-16 19:22:26.195  laker0
    2022-07-16 19:22:26.195  recover e:java.lang.RuntimeException: laker Error,param:laker0
    2022-07-16 19:22:26.196  laker1
    2022-07-16 19:22:26.196  recover e:java.lang.RuntimeException: laker Error,param:laker1
    2022-07-16 19:22:26.196  recover e:java.lang.RuntimeException: laker Error,param:laker2
    2022-07-16 19:22:26.197  recover e:java.lang.RuntimeException: laker Error,param:laker3
    2022-07-16 19:22:26.197  recover e:java.lang.RuntimeException: laker Error,param:laker4
    2022-07-16 19:22:26.197  recover e:java.lang.RuntimeException: laker Error,param:laker5
    2022-07-16 19:22:26.197  recover e:java.lang.RuntimeException: laker Error,param:laker6
    2022-07-16 19:22:26.197  recover e:java.lang.RuntimeException: laker Error,param:laker7
    2022-07-16 19:22:26.197  recover e:java.lang.RuntimeException: laker Error,param:laker8
    2022-07-16 19:22:26.197  recover e:java.lang.RuntimeException: laker Error,param:laker9
    2022-07-16 19:22:32.206  laker3
    2022-07-16 19:22:32.206  recover e:java.lang.RuntimeException: laker Error,param:laker0

    高级实战

    上面说到了，断路器@CircuitBreaker 并么有携带重试功能，所有我们实际项目要结合2者使用。

    方式一 @CircuitBreaker + RetryTemplate

    1.自定义RetryTemplate

    @Configuration
@EnableRetry
public class RetryConfig {
    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
        // 退避策略 因为是瞬时异常 所以不宜过大，100ms即可
        fixedBackOffPolicy.setBackOffPeriod(100L);
        retryTemplate.setBackOffPolicy(fixedBackOffPolicy);
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        // 重试3次
        retryPolicy.setMaxAttempts(3);
        retryTemplate.setRetryPolicy(retryPolicy);
        return retryTemplate;
    }
}

    2.在断路器中用retryTemplate包裹一层

       @CircuitBreaker(maxAttempts = 2, openTimeout = 1000, resetTimeout = 2000, value = RuntimeException.class)
    public String testCircuitBreaker(String param) {
        return retryTemplate.execute(context -> {
            log.info(String.format("Retry count %d", context.getRetryCount()) + param);
            throw new RuntimeException("laker Error");
        });
    }
    @Recover
    String recover(RuntimeException e, String param) {
        log.info("recover e:{},param:{}", e, param);
        return "";
    }

    测试日志如下：

    2022-07-16 20:14:11.385 Retry count 0laker0
    2022-07-16 20:14:11.496 Retry count 1laker0
    2022-07-16 20:14:11.606 Retry count 2laker0
    2022-07-16 20:14:11.607 recover e:java.lang.RuntimeException: laker Error,param:laker0
    2022-07-16 20:14:11.608 Retry count 0laker1
    2022-07-16 20:14:11.714 Retry count 1laker1
    2022-07-16 20:14:11.826 Retry count 2laker1
    2022-07-16 20:14:11.826 recover e:java.lang.RuntimeException: laker Error,param:laker1
    2022-07-16 20:14:11.827 recover e:java.lang.RuntimeException: laker Error,param:laker2
    2022-07-16 20:14:11.827 recover e:java.lang.RuntimeException: laker Error,param:laker3
    2022-07-16 20:14:11.827 recover e:java.lang.RuntimeException: laker Error,param:laker4
    2022-07-16 20:14:11.827 recover e:java.lang.RuntimeException: laker Error,param:laker5
    2022-07-16 20:14:11.827 recover e:java.lang.RuntimeException: laker Error,param:laker6
    2022-07-16 20:14:11.827 recover e:java.lang.RuntimeException: laker Error,param:laker7
    2022-07-16 20:14:11.827 recover e:java.lang.RuntimeException: laker Error,param:laker8
    2022-07-16 20:14:11.827 recover e:java.lang.RuntimeException: laker Error,param:laker9

    方式二 @CircuitBreaker + @Retryable

    定义2个springBean，一个用于重试，一个用于熔断，且是熔断包含着重试，否则会失效。

    @Service
@Slf4j
public class RetryService {
    @Autowired
    RetryTemplate retryTemplate;

    @Retryable(value = RuntimeException.class,backoff = @Backoff(delay = 100))
    public void test(String param) {
        log.info(param);
        throw new RuntimeException("laker Error");
    }
}

@Service
@Slf4j
public class CircuitBreakerService {

    @Autowired
    RetryService retryService;

    @CircuitBreaker(maxAttempts = 2, openTimeout = 1000, resetTimeout = 2000, value = RuntimeException.class)
    public void testCircuitBreaker(String param) {
        // 这里是添加了重试注解的方法
        retryService.test(param);
    }

    @Recover
    void recover(RuntimeException e, String param) {
        log.info("recover e:{},param:{}", e, param);
    }
}

    以上就是关于“怎么集成Spring Retry实现失败重试和熔断器模式”这篇文章的内容，相信大家都有了一定的了解，希望小编分享的内容对大家有帮助，若想了解更多相关的知识内容，请关注本站行业资讯频道。

    《怎么集成Spring Retry实现失败重试和熔断器模式.doc》

    下载本文的Word格式文档，以方便收藏与打印。

    Copyright 2023. 昆居客 - IT编程,互联网信息技术文档大全!