<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("收到請求參數(shù):{}",param);
        int i = RandomUtil.randomInt(0,11);
        log.info("param - i:{}",i);
        if (i==0){
            throw new IllegalArgumentException("參數(shù)異常");
        }else if (i==1){
            return true;
        }else if (i==2){
            return false;
        }else {
            throw new RemoteAccessException("遠(yuǎn)程訪問異常");
        }
    }
}

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 允許無限重試，直到成功，此方式邏輯不當(dāng)會導(dǎo)致死循環(huán)
     * SimpleRetryPolicy 固定次數(shù)重試,默認(rèn)重試最大次數(shù)為3次，RetryTemplate默認(rèn)使用的策略
     * TimeoutRetryPolicy 超時時間重試策略,默認(rèn)超時時間為1秒,在指定的超時時間內(nèi)允許重試
     * ExceptionClassifierRetryPolicy 設(shè)置不同異常的重試策略
     * CircuitBreakerRetryPolicy 有熔斷功能的重試策略,需要設(shè)置3個參數(shù)openTimeout\restTimeout和delegate
     * CompositeRetryPolicy: 組合重試策略，有2種組合方式，樂觀組合重試策略是指只要有一個策略允許即可以重試，
     * 悲觀組合重試策略是指只要有一個策略不允許即可以重試,但不管哪種組合方式,組合中的每一個策略都會執(zhí)行
     *
     * spring-retry支持的重試回退策略有
     *
     * NoBackOffPolicy:無退避算法策略，每次重試時立即重試
     * FixedBackOffPolicy: 固定時間的退避策略,需設(shè)置參數(shù)sleeper 等待策略和backOffPeriod休眠時間,默認(rèn)1s
     * UniformRandomBackOffPolicy: 隨機(jī)時間退避策略，需設(shè)置sleeper\minBackOffPeriod 和 maxBackOffPeriod
     * ExponentialBackOffPolicy 指數(shù)退避策略,需設(shè)置sleeper\initialInterval\maxInterval等參數(shù)
     * ExponentialRandomBackOffPolicy 隨機(jī)指數(shù)退避策略,引入隨機(jī)乘數(shù)可以實(shí)現(xiàn)隨機(jī)乘數(shù)回退
     *
     */
    @Test
    void t1() {
        exceptionMap.put(RemoteAccessException.class, true);
        //構(gòu)建重試模版
        RetryTemplate retryTemplate = new RetryTemplate();
        //設(shè)置重試回退策略
        // FixedBackOffPolicy主要設(shè)置重試間隔時間
        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(fixedPeriodTime);
        //設(shè)置重試策略，主要設(shè)置重試次數(shù)
        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("調(diào)用的結(jié)果:{}", abc);
                    return abc;
                },
                //RecoveryCallback
                retryContext -> {
                    log.info("已達(dá)到最大重試次數(shù)或拋出了不重試的異常...");
                    return false;
                }
        );
        log.info("執(zhí)行結(jié)果:{}", 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("收到請求參數(shù):{}",param);
        int i = RandomUtil.randomInt(0,11);
        log.info("param - i:{}",i);
        if (i==0){
            throw new IllegalArgumentException("參數(shù)異常");
        }else if (i==1){
            return true;
        }else if (i==2){
            return false;
        }else {
            throw new RemoteAccessException("遠(yuǎn)程訪問異常");
        }
    }
}

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 {
    //發(fā)生RemoteAccessException時重試
    //最大重試3次
    //第一次間隔2秒,以后都是次數(shù)的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("達(dá)到最大重試次數(shù),或拋出了一個沒有指定進(jìn)行重試的異常",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("---結(jié)果是:{}---",abc);
    }
}