集成spring重试策略

系统管理员 2022-11-19 01:13 34阅读 0赞

最近在做服务端需求，涉及到重试场景。重试有很多注意的点。比如：方法兜底，指数退避策略等等。如果自己实现的话，需要注意的点很多。spring提供了重试解决方案spring retry，今天调研了一下，使用起来很方便，分享一下。  
***1.引入依赖***

<dependency>
    
          <groupId>org.springframework.retry</groupId>
          <artifactId>spring-retry</artifactId>
          <version>1.2.4.RELEASE</version>
        </dependency>
    
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.9.4</version>
        </dependency>

2.启用spring retry

@SpringBootApplication
    //启用spring retry依赖
    @EnableRetry
    public class Application {
        /**
         * spring boot的入口
         * @param args
         */
        public static void main(String[] args) {
            SpringApplication.run(Application.class,args);
        }
    }

3.编写测试业务类

package org.example.service;
    
    import org.springframework.retry.annotation.Backoff;
    import org.springframework.retry.annotation.Recover;
    import org.springframework.retry.annotation.Retryable;
    import org.springframework.stereotype.Service;
    
    import java.time.LocalDateTime;
    
    @Service
    public class WorkService {
    
        /**
         * 默认重试3次(包含第一次执行失败)
         */
        @Retryable
        public void work1() {
            System.out.println("执行方法1:" + LocalDateTime.now());
            throw new RuntimeException();
        }
    
        /**
         * 捕捉到RuntimeException异常时执行重试，最大重试4次，指数退避策略为2秒，每次重试*2,即第一次等待2秒，第二次重试等待4秒，第三次8秒，以此类推
         */
        @Retryable(include = {RuntimeException.class}, maxAttempts = 4, backoff = @Backoff(delay = 2000L, multiplier = 2))
        public void work2() {
            System.out.println("执行方法2:" + LocalDateTime.now());
            throw new RuntimeException();
        }
    
        /**
         *
         */
        @Retryable(include = NullPointerException.class)
        public void work3() {
            System.out.println("执行方法3:" + LocalDateTime.now());
            throw new NullPointerException();
        }
    
        /**
         * NullPointerException重试补偿方法。当重试完成后，执行该补偿方法
         * @param e
         */
        @Recover
        public void recover(NullPointerException e) {
            System.out.println("执行补偿方法:" + LocalDateTime.now());
        }
    
        /**
         * RuntimeException重试补偿方法。当重试完成后，执行该补偿方法
         * @param e
         */
        @Recover
        public void recover(RuntimeException e) {
            System.out.println("执行补偿方法:" + LocalDateTime.now());
        }
    }

4.编写测试方法  
(1).测试方法依赖

<dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
        </dependency>
        
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

(2).测试方法

@RunWith(SpringJUnit4ClassRunner.class)
    @SpringBootTest(classes = Application.class)
    public class ApplicationTest {
        @Autowired
        private WorkService workService;
        /**
         * Rigorous Test :-)
         */
        @Test
        public void shouldAnswerWithTrue() {
            workService.work2();
        }
    }

5.测试结果

//我们调用的是work2方法，所以可以看到指数退避策略
    执行方法2:2021-04-13T21:45:19.746
    执行方法2:2021-04-13T21:45:21.747
    执行方法2:2021-04-13T21:45:25.748
    执行方法2:2021-04-13T21:45:33.748
    执行补偿方法:2021-04-13T21:45:33.748

以上就是spring retry的使用。下一篇聊聊spring retry的底层实现。