集成spring重试策略-蒲公英云

集成spring重试策略

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

<dependency>
<!--spring retry依赖-->
      <groupId>org.springframework.retry</groupId>
      <artifactId>spring-retry</artifactId>
      <version>1.2.4.RELEASE</version>
    </dependency>
<!--retry底层依赖AOP实现，所以需要引入aspectj的依赖-->
    <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