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

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

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);
    }
}

@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);
    }
}