spring-retry笔记

我就是我 2024-03-17 19:15 72阅读 0赞

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