java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > spring-retry重试机制

Spring中的spring-retry重试机制解析

作者:ThinkPet

这篇文章主要介绍了Spring中的spring-retry重试机制解析,spring-retry可以通过注解,在不入侵原有业务逻辑代码的方式下,优雅的实现重处理功能,在spring-retry中,所有配置都是基于简单注释的,需要的朋友可以参考下

spring-retey的依赖

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

spring-retry无注解方式使用

定义重试任务

package com.example.demo.retry;
import cn.hutool.core.util.RandomUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.remoting.RemoteAccessException;
@Slf4j
public class RetryDemoTask {
    public static boolean retryTask(String param){
        log.info("收到请求参数:{}",param);
        int i = RandomUtil.randomInt(0,11);
        log.info("param - i:{}",i);
        if (i==0){
            throw new IllegalArgumentException("参数异常");
        }else if (i==1){
            return true;
        }else if (i==2){
            return false;
        }else {
            throw new RemoteAccessException("远程访问异常");
        }
    }
}

构建重试逻辑并执行调用

package com.example.demo;
import com.example.demo.retry.RetryDemoTask;
import com.example.demo.retry.SpringRetryDemo;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.retry.backoff.*;
import org.springframework.retry.policy.*;
import org.springframework.retry.support.RetryTemplate;
import java.util.HashMap;
import java.util.Map;
@Slf4j
@SpringBootTest
public class SpringRetryTests {
 private long fixedPeriodTime = 1000L;
    private int maxRetryTimes = 3;
    private Map<Class<? extends Throwable>, Boolean> exceptionMap = new HashMap<>();
    /**
     * spring-retry支持的重试策略有
     *
     * NeverRetryPolicy 只允许retryCallback一次,不允许重试
     * AlwaysRetryPolicy 允许无限重试,直到成功,此方式逻辑不当会导致死循环
     * SimpleRetryPolicy 固定次数重试,默认重试最大次数为3次,RetryTemplate默认使用的策略
     * TimeoutRetryPolicy 超时时间重试策略,默认超时时间为1秒,在指定的超时时间内允许重试
     * ExceptionClassifierRetryPolicy 设置不同异常的重试策略
     * CircuitBreakerRetryPolicy 有熔断功能的重试策略,需要设置3个参数openTimeout\restTimeout和delegate
     * CompositeRetryPolicy: 组合重试策略,有2种组合方式,乐观组合重试策略是指只要有一个策略允许即可以重试,
     * 悲观组合重试策略是指只要有一个策略不允许即可以重试,但不管哪种组合方式,组合中的每一个策略都会执行
     *
     * spring-retry支持的重试回退策略有
     *
     * NoBackOffPolicy:无退避算法策略,每次重试时立即重试
     * FixedBackOffPolicy: 固定时间的退避策略,需设置参数sleeper 等待策略和backOffPeriod休眠时间,默认1s
     * UniformRandomBackOffPolicy: 随机时间退避策略,需设置sleeper\minBackOffPeriod 和 maxBackOffPeriod
     * ExponentialBackOffPolicy 指数退避策略,需设置sleeper\initialInterval\maxInterval等参数
     * ExponentialRandomBackOffPolicy 随机指数退避策略,引入随机乘数可以实现随机乘数回退
     *
     */
    @Test
    void t1() {
        exceptionMap.put(RemoteAccessException.class, true);
        //构建重试模版
        RetryTemplate retryTemplate = new RetryTemplate();
        //设置重试回退策略
        // FixedBackOffPolicy主要设置重试间隔时间
        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(fixedPeriodTime);
        //设置重试策略,主要设置重试次数
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxRetryTimes, exceptionMap);
        retryTemplate.setRetryPolicy(retryPolicy);
        retryTemplate.setBackOffPolicy(backOffPolicy);
        Boolean execute = retryTemplate.execute(
                //RetryCallback
                retryContext -> {
                    boolean abc = RetryDemoTask.retryTask("abc");
                    log.info("调用的结果:{}", abc);
                    return abc;
                },
                //RecoveryCallback
                retryContext -> {
                    log.info("已达到最大重试次数或抛出了不重试的异常...");
                    return false;
                }
        );
        log.info("执行结果:{}", execute);
    }
}

spring-retry注解方式使用

启用@EnableRetry 注解

@EnableRetry //spring-retry 基于注解的使用
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

定义重试任务

package com.example.demo.retry;
import cn.hutool.core.util.RandomUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.remoting.RemoteAccessException;
@Slf4j
public class RetryDemoTask {
    public static boolean retryTask(String param){
        log.info("收到请求参数:{}",param);
        int i = RandomUtil.randomInt(0,11);
        log.info("param - i:{}",i);
        if (i==0){
            throw new IllegalArgumentException("参数异常");
        }else if (i==1){
            return true;
        }else if (i==2){
            return false;
        }else {
            throw new RemoteAccessException("远程访问异常");
        }
    }
}

定义重试服务层控制逻辑

package com.example.demo.retry;
import lombok.extern.slf4j.Slf4j;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
@Slf4j
@Service
public class SpringRetryDemoService {
    //发生RemoteAccessException时重试
    //最大重试3次
    //第一次间隔2秒,以后都是次数的2倍,也就是第二次4秒,第三次6秒
    @Retryable(value = {RemoteAccessException.class},
            maxAttempts = 3,
            backoff = @Backoff(delay = 2000L,multiplier = 2))
    public boolean call(String param){
        return RetryDemoTask.retryTask(param);
    }
    @Recover
    public boolean recover(Exception e,String param){
        log.error("达到最大重试次数,或抛出了一个没有指定进行重试的异常",e);
        log.info("recover param:{}",param);
        return false;
    }
}

执行重试调用

@Slf4j
@SpringBootTest
public class SpringRetryTests2 {
    @Autowired
    private SpringRetryDemoService springRetryDemoService;
    @Test
    public void retry712(){
        boolean abc = springRetryDemoService.call("abc");
        log.info("---结果是:{}---",abc);
    }
}    

到此这篇关于Spring中的spring-retry重试机制解析的文章就介绍到这了,更多相关spring-retry重试机制内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文