重试组件 Spring Retry

已于 2023-01-11 17:08:24 修改
阅读量1.1k 收藏 6
点赞数 1
分类专栏： spring 文章标签： Spring Retry 接口重试
于 2022-09-12 18:44:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34850743/article/details/126820853
版权

spring-retry是spring社区的一个成员，它提供了一种对失败操作进行自动重试的能力，可以作为某些瞬时错误（例如短暂的网络抖动）的解决方案。

作为spring生态的一部分，spring-retry自然地支持声明式（Declarative）方式使用。此外，它也支持命令式（Impertive）方式在代码里直接调用。

1. 项目集成

引入依赖：

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.2.2.RELEASE</version>
</dependency>

它的版本交给spring boot管理，以获得与spring良好的兼容性。

项目当前使用的是spring-boot版本为1.5.13.RELEASE，它管理的spring-retry版本是1.2.2.RELEASE。

2. 声明式使用方式

  1. 在spring boot启动类上增加@EnableRetry注解：

    @EnableRetry(proxyTargetClass = true)
@SpringBootApplication
public class TestApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }
}

    该注解的proxyTargetClass属性默认为false，表示使用JDK的动态代理。如果设置为true，则表示使用CGLIB作为动态代理。

  2. 在需要重试的方法上，增加@Retryable注解：

    @Service
@Slf4j
public class RetryAnnotationTest {

    @Retryable(value = {RemoteAccessException.class}, maxAttempts = 5, backoff = @Backoff(delay = 1000L), recover = "recoverCall")
    public boolean call(String param){
        System.out.println(new Date());
        return RetryTask.retryTask(param);
    }

    @Recover
    public boolean recoverCall(Exception e,String param) {
        log.error("达到最大重试次数,或抛出了一个没有指定进行重试的异常:", e);
        return false;
 }
}

    如上示例中，当call方法抛出RemoteAccessException异常时，spring retry会重新调用call方法，重试次数为5次，两次重试之间间隔为1s。

    如果超过最大重试次数仍未成功，或者抛出非RemoteAccessException异常，则调用recoverCall方法。

    注：@Retryable注解也可以作用在类上，作用在类上之后，spring retry会对类的全部方法进行重试。

3. 命令式使用方式

  1. 配置RetryTemplate：

    @Configuration
public class SpringRetryConfig {
   
    @Bean("retryTemplateFixed")
    public RetryTemplate retryTemplateFixed() {
        // 1.重试策略
        // 触发条件
        Map<Class<? extends Throwable>, Boolean> exceptionMap = new HashMap<>();
        exceptionMap.put(RemoteAccessException.class, true);
        
        // 重试次数设置为3次
        int maxAttempts = 3;
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxAttempts, exceptionMap);

        // 2.重试间隔设置为1秒
        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(1000);

        // 3.构造RetryTemplate
        RetryTemplate retryTemplate = new RetryTemplate();
        retryTemplate.setRetryPolicy(retryPolicy);
        retryTemplate.setBackOffPolicy(backOffPolicy);
        return retryTemplate;
    }
    
    @Bean("retryTemplate")
    public RetryTemplate retryTemplate() {
        // 定义简易重试策略，最大重试次数为3次,重试间隔为3s
        return RetryTemplate.builder()
                .maxAttempts(3)
                .fixedBackoff(3000)
                .retryOn(RuntimeException.class)
                .build();
    }
    
}

    注：可以配置多个RetryTemplate，用以适应不同重试场景。

    spring retry支持的重试策略和退避策略如下：

    @Bean("retryTemplateDemo")
public RetryTemplate retryTemplateDemo() {
    // 1.重试策略
    // 不重试
    NeverRetryPolicy neverRetryPolicy = new NeverRetryPolicy();

    // 无限重试
    AlwaysRetryPolicy alwaysRetryPolicy = new AlwaysRetryPolicy();

    // 设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
    ExceptionClassifierRetryPolicy exceptionClassifierRetryPolicy = new ExceptionClassifierRetryPolicy();
    final Map<Class<? extends Throwable>, RetryPolicy> policyMap = new HashMap<>(3);
    policyMap.put(IOException.class, alwaysRetryPolicy);
    policyMap.put(InterruptedIOException.class, neverRetryPolicy);
    policyMap.put(UnknownHostException.class, neverRetryPolicy);
    exceptionClassifierRetryPolicy.setPolicyMap(policyMap);

    // 固定次数重试，默认最大重试次数为5次，RetryTemplate默认重试策略
    SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();
    simpleRetryPolicy.setMaxAttempts(5);

    // 超时时间重试，默认超时时间为1秒，在指定的超时时间内重试
    TimeoutRetryPolicy timeoutRetryPolicy = new TimeoutRetryPolicy();
    timeoutRetryPolicy.setTimeout(3000);

    /*
     * 组合重试策略，有两种组合方式：
     *  1.悲观默认重试，有不重试的策略则不重试。
     *  2.乐观默认不重试，有需要重试的策略则重试。
     */
    CompositeRetryPolicy compositeRetryPolicy = new CompositeRetryPolicy();
    compositeRetryPolicy.setOptimistic(true);
    compositeRetryPolicy.setPolicies(new RetryPolicy[]{simpleRetryPolicy, timeoutRetryPolicy});

    // 有熔断功能的重试
    CircuitBreakerRetryPolicy circuitBreakerRetryPolicy = new CircuitBreakerRetryPolicy(compositeRetryPolicy);
    // 5s内失败10次，则开启熔断
    circuitBreakerRetryPolicy.setOpenTimeout(5000);
    // 10s之后熔断恢复
    circuitBreakerRetryPolicy.setResetTimeout(10000);

    // 2.退避策略（上一次执行失败之后，间隔多久进行下一次重试）
    // 立即重试
    NoBackOffPolicy noBackOffPolicy = new NoBackOffPolicy();

    // 固定时间后重试，默认1s
    FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
    fixedBackOffPolicy.setBackOffPeriod(1000);

    // 随机时间后重试（如下：从500ms到1500ms内取一个随机时间后进行重试）
    UniformRandomBackOffPolicy uniformRandomBackOffPolicy = new UniformRandomBackOffPolicy();
    uniformRandomBackOffPolicy.setMinBackOffPeriod(500);
    uniformRandomBackOffPolicy.setMaxBackOffPeriod(1500);

    // 指数退避策略（如下：初始休眠时间100ms，最大休眠时间30s，下一次休眠时间为当前休眠时间*2）
    ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
    exponentialBackOffPolicy.setInitialInterval(100);
    exponentialBackOffPolicy.setMaxInterval(30000);
    exponentialBackOffPolicy.setMultiplier(2);

    // 随机指数退避策略
    ExponentialRandomBackOffPolicy exponentialRandomBackOffPolicy = new ExponentialRandomBackOffPolicy();
    exponentialRandomBackOffPolicy.setInitialInterval(100);
    exponentialRandomBackOffPolicy.setMaxInterval(30000);
    exponentialRandomBackOffPolicy.setMultiplier(2);

    // 3.return
    RetryTemplate retryTemplate = new RetryTemplate();
    retryTemplate.setRetryPolicy(circuitBreakerRetryPolicy);
    return retryTemplate;
}

  2. 在代码中调用

    @Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class RetryTest {

    // 注入RetryTemplate
    @Resource
    private RetryTemplate retryTemplateFixed;

    @Test
    public void test() {
        // 执行
        Boolean execute = retryTemplateFixed.execute(
                // 重试回调
                retryContext -> {
                    System.out.println(new Date());
                    boolean b = RetryTask.retryTask("abc");
                    log.info("调用的结果:{}", b);
                    return b;
                },
                // 恢复回调（达到最大重试次数，或者抛出不满足重试条件的异常）
                retryContext -> {
                    log.info("已达到最大重试次数或抛出了不重试的异常~~~");
                    return false;
                }
        );

        log.info("执行结果:{}",execute);

    }

}

  3. 监听重试过程

    通过实现RetryListener接口，重写open、close、onError这三个方法，既可以完成对重试过程的追踪，也可以添加额外的处理逻辑。

    @Slf4j
@Component
public class RetryListenerTemplate implements RetryListener {
    // 进入重试前调用
    @Override
    public <T, E extends Throwable> boolean open(RetryContext retryContext, RetryCallback<T, E> retryCallback) {
        log.info("--------------------------进入重试方法--------------------------");
    return true;
    }

    // 重试结束后调用
    @Override
    public <T, E extends Throwable> void close(RetryContext retryContext, RetryCallback<T, E> retryCallback, Throwable throwable) {
    log.info("--------------------------重试方法结束--------------------------");
    }

    // 捕获到异常时调用
    @Override
    public <T, E extends Throwable> void onError(RetryContext retryContext, RetryCallback<T, E> retryCallback, Throwable throwable) {
        log.info("--------------------------第" + retryContext.getRetryCount() + "次重试--------------------------");
        log.error(throwable.getMessage(), throwable);
}
}

    或者，通过继承RetryListenerSupport，也可以从open、close、onError这三个方法中，选择性的重写。

    public class RetryListener4Open extends RetryListenerSupport {
    @Override
    public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
        return super.open(context, callback);
    }
}

    在实例化RetryTemplate时，配置上该RetryListener实例即可。

    retryTemplate.setListeners(new RetryListener[] {retryListenerTemplate});

    注：

    1. V2.0版本以后，新增一个doOnSuccess方法，可以在调用成功之后，根据返回的结果值，来决定是否要进行重试。
    2. 每个RetryTemplate可以注册多个监听器，其中onOpen、onClose方法按照注册顺序执行，onError按照注册顺序的相反顺序执行。

参考资料：

  1. Spring-Retry 和 Guava-Retry
  2. Spring Retry Github地址
莫迟疑
关注
专栏目录
Spring框架中一个有用的小组件：Spring Retry
一个程序员
07-22 5454
1、概述 Spring Retry 是Spring框架中的一个组件， 它提供了自动重新调用失败操作的能力。这在错误可能是暂时发生的（如瞬时网络故障）的情况下很有帮助。 在本文中，我们将看到使用Spring Retry的各种方式：注解、RetryTemplate以及回调。 2、Maven依赖 让我们首先将spring-retry依赖项添加到我们的pom.xml文件中： <dependency> <groupId>org.springframework.retry</g
springboot重试组件
heroguo007的专栏
12-08 432
最近有一个业务需要有重试机制，感觉应该写一个能够重试的组件。   首先创建一个注解 /** * @Author GUOSHAOHUA093 * @Description 重试拦截 * @Date 9:14 2018/12/8 */ @Retention(RetentionPolicy.RUNTIME) public @interface IsTryAgain { int t...
重试框架SpringRetry一篇搞定！！！
最新发布
m0_65450831的博客
08-17 1227
本文将重试框架如何在项目中使用以及注意事项讲的一清二楚
Spring重试之Spring-Retry，Guava-Retry，Hystrix，Fast-Retry
上善若泪
12-23 653
我们只要在需要重试的方法上加@Retryable，在重试失败的回调方法上加@Recover，下面是这些注解的属性，表示是否开启重试序号属性类型默认值说明1booleanfalse指示是否要创建基于子类的(CGLIB)代理，而不是创建标准的基于Java接口的代理@Retryable，标注此注解的方法在发生异常时会进行重试序号属性类型默认值说明1String“”将interceptor的bean名称应用到retryable()2valueClass[]{}
Spring retry基本使用
weixin_33804990的博客
05-06 125
背景介绍 在实际工作过程中，重试是一个经常使用的手段。比如MQ发送消息失败，会采取重试手段，比如工程中使用RPC请求外部服务,可能因为网络 波动出现超时而采取重试手段......可以看见重试操作是非常常见的一种处理问题,系统设计的手段 而在之前我们项目中处理重拾操作依赖MQ自身的重试机制,但是这种机制不是很灵活,如果某些功能没有使用MQ的话,那么就不是那...
Spring Boot中使用Spring-Retry重试框架
C.
01-08 9198
文章目录Spring Boot中使用Spring-Retry重试框架Maven依赖注解使用开启Retry功能注解`@Retryable`注解`@Recover`注解`@CircuitBreaker`RetryTemplateRetryTemplate配置使用RetryTemplateRetryPolicyBackOffPolicyRetryListener参考 Spring Boot中使用Spring-Retry重试框架 Spring Retry提供了自动重新调用失败的操作的功能。这在错误可能是暂时的（例
Spring Retry 和 Guava Retrying重试机制的使用详解
03-18
Spring Retry 和 Guava Retrying 是两个常用且功能强大的重试库，它们为开发者提供了优雅且高效的重试解决方案。 首先，我们来详细了解Spring Retry。Spring Retry是Spring框架的一部分，它提供了一种声明式的重试...
Spring Cloud重试机制与各组件的重试总结
08-28
Spring Cloud重试机制与各组件的重试总结 Spring Cloud中的重试机制是指在远程请求实例不可达时，客户端发现后，去重试其他实例的机制。这种机制可以确保服务的高可用性和负载均衡。下面我们将讨论Spring Cloud中的...
Spring Retry实例与原理源码
07-18
在业务场景中 , 有时候会遇到异常后需要重复尝试的操作 , 例如调用三方接口 , 发送邮件/短信 , 推送消息等等 . Spring 提供了Retry组件 , 很方便的解决了上述问题
Spring Retry实践：重试与熔断机制解析
在实际应用中，Spring Retry可以与Spring的其他组件（如AOP切面）集成，通过注解或编程方式来决定哪些方法应该被重试。此外，还可以配置重试间隔、最大重试次数、重试后的回退逻辑等参数，以达到最佳的重试效果。 ...
Spring retry(一)-使用指南
Viogs的专栏
08-30 912
spring retry 从2.0.2版本之后，从spring batch里剥离出来成为一个单独的工程，因此我们引入spring retry最新版本可以直接如下引入</</</</</</</</启动类上打上注解@EnableRetry。
Spring 指南（spring-retry）
06-14 760
spring-retry 该项目为Spring应用程序提供声明式重试支持，它用于Spring Batch、Spring Integration、Apache Hadoop的Spring（以及其他），命令式重试也支持显式使用。 入门 声明式示例 @Configuration @EnableRetry public class Application { @Bean public Service service() { return new Service();
Spring Boot 整合——Spring retry有状态重试以及其注释和组件介绍
大风的博客
01-17 1265
关于版本 依赖 版本 springboot 2.4.0 spring retry 2.4.0 代码地址 因为每个例子涉及代码较多，且包含测试用例，如果都贴到文章中内容过多，所以只贴出了部分代码。全部的代码在这里：https://gitee.com/daifyutils/springboot-samples。 通过配置状态重试来使用CircuitBreaker带熔断功能的重试 无状态的重试 无状态重试，是在一个循环中执行完重试策略，即重试上下文保持在一个线程上下文中。 有状态的重试 有
Java实战：Spring Boot接口重试机制实现
oandy0的博客
02-27 1582
本文将详细介绍如何在Spring Boot应用程序中实现接口重试机制。我们将探讨重试机制的基本概念，以及如何使用Spring Boot和第三方库来实现接口的重试功能。
Spring Boot-整合Retry框架重试机制
qq_37661970的博客
03-22 1321
Retry重试框架，支持AOP切入的方式使用，支持注解;重试次数，重试延迟、重试触发条件、重试的回调方法等功能来实现重试机制项目中我们可以通过两种不同的方式使用Spring Retry重试功能，一种是@Retryable注解的方式，另种是RetryTemplate方式。
spring-retry
qq_35913663的博客
06-15 3841
spring retry的详细解析
spring-retry详解
初心不忘、始终方得
07-19 1214
上面的重试次数用完以后还是异常会抛出异常，此时异常我们可以选择在调用方（Retryable方法的调用法）继续处理，也可以选择单独加个方法只用来处理异常，这样调用方（Retryable方法的调用法）就可以只专注处理正常逻辑即可。可以看到，异常后正常进入到了这个方法，其实就是相当于把这个方法代理下将其放入到Retryable中的方法一起执行，所以需要保持两个方法的的高度一致（主要是出入参，同一个类中）。这也就达到了目的了，基础使用就是这样，下面一起看看参数该如何设置。可以看到确实在异常场景进行了重试，
重试框架Spring-Retry
qq_43657722的博客
01-03 857
重试框架Spring-Retry
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值