【业务场景实战】请允许我再试一次！

仰望-星空~~

已于 2024-08-18 14:41:55 修改

阅读量462

点赞数 5

文章标签：前端

于 2024-08-18 14:36:55 首次发布

本文链接：https://blog.csdn.net/weixin_65935065/article/details/141297358

版权

大家好，我是仰望星空~~

今天给大家带来一篇文章，关于重试机制SpringRetry。

我们在实际项目开发过程中，可能遇到像网络异常或者程序阻塞而出现的异常，这种异常其实我们可以通过重试机制来解决。

一、SpringRetry简介

Spring Retry是Spring框架自带的一种功能，它实现了一套简洁实用的重试机制。

该机制具有间隔重试、包含异常、排除异常和控制重试频率等特点。此功能是从Spring Batch 2.2.0版本独立出来的，主要负责实现重试和熔断策略。

在实际工作中，重新处理某些任务是一个常见的需求，例如：消息发送失败、远程服务调用失败或锁争抢失败等。这些错误可能是由于网络波动造成的，稍后重试就有可能成功。

通常的做法是使用try/catch或while循环进行重处理，但这种方法缺乏统一性且不太方便。而Spring Retry则允许开发者通过注解的方式，在不改变原有业务逻辑代码的基础上，优雅地实现重处理功能。

接下来就来讲讲SpringRetry注解实现方式吧！

二、基于注解实现重试

1、导入依赖

<!--SpringRetry重试机制-->
<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.1</version>
</dependency>

2、启动重试机制

启动类上加上这个注解@EnableRetry

3、创建异常任务类

该类主要用于模拟真实项目中处理请求过程中出现的一些异常。这里只是模拟一下出现异常的情况

如果是在项目中的话，这个类里面就是封装一些业务逻辑。不过还需要提前知道在请求过程中会出现哪些类型的异常，这样才能被系统正确捕捉到。

@Slf4j
public class RetryDemoTask02 {

    /**
     * 重试方法
     * @return
     */
    public static boolean retryTask(String param)  {
        log.info("收到请求参数:{}",param);

        int i = RandomUtils.nextInt(0,11);
        log.info("随机生成的数:{}",i);
        if (i == 0) {
            log.info("为0,抛出参数异常.");
            throw new IllegalArgumentException("参数异常");
        }else if (i  == 1){
            log.info("为1,返回true.");
            return true;
        }else if (i == 2){
            log.info("为2,返回false.");
            return false;
        }else{
            //为其他
            log.info("大于2,抛出自定义异常.");
            throw new RemoteAccessException("大于2,抛出远程访问异常");
        }
    }

}

4、重试服务类

package com.example.SpingRetryAOP;

import com.example.TaskRetryUtil.RetryDemoTask02;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

/**
 * SpringRetry重试机制的注解使用
 * 调用重试服务类
 */
@Service
public class SpringRetryDemo {
    /**
     * 创建一个计数器，获取接口每次重试调用的次数
     */
    private static final Logger log = LoggerFactory.getLogger(SpringRetryDemo.class);
    private int retryCount = 0;

    /**
     * 重试所调用方法
     * @param param
     * @return
     */
    @Retryable(value = {RemoteAccessException.class,RuntimeException.class,IllegalArgumentException.class},maxAttempts = 4,backoff = @Backoff(delay = 2000L,multiplier = 2))
    public boolean call(String param){
        log.info("重试次数： {}", retryCount++);
        return RetryDemoTask02.retryTask(param);
        //atttempts: 尝试次数
    }

    /**
     * 达到最大重试次数,或抛出了一个没有指定进行重试的异常
     * recover 机制
     * @param e 异常
     */
    @Recover
    public boolean recover(Exception e,String param) {
        log.error("达到最大重试次数,或抛出了一个没有指定进行重试的异常:",e);
        return false;
    }
}

创建计时器，记录每次重试的次数

注解：@Retryable(value = {RemoteAccessException.class, RuntimeException.class,IllegalArgumentException.class},maxAttempts = 4,backoff = @Backoff(delay = 2000L,multiplier = 2))

出现RemoteAccessException.class, RuntimeException.class,IllegalArgumentException.class

异常，程序进行重试

maxAttempts = 4表示最大重试次数为4次
backoff = @Backoff(delay = 2000L,multiplier = 2)表示第一次间隔2秒，后面都是次数的2倍，第二次4秒。

需要注意：

这里的最大重试次数为4，是程序在重试到第三次的时候就会终止

其实只能正常重试3次

5、请求接口

@Autowired
    private SpringRetryDemo springRetryDemo;

    @GetMapping
    public Boolean spring(String param){
        boolean result = springRetryDemo.call(param);
        log.info("--结果是:{}--",result);
        return  result;
    }

执行流程：

1、首先项目启动之后，会扫描注解，自动开启重试机制

2、请求接口：将请求参数传入springRetryDemo中

3、记录重试次数，执行RetryDemoTask02.retryTask(param)方法

4、达最大重试次数后，执行recover 机制

结果可以看到
最大重试了3次，三次后，若没有重试成功则抛出异常。

二、降级处理

在实际应用中，除了重试，我们可能还希望在多次重试失败后执行降级操作，以避免一直等待不确定的恢复时间。

@Recover注解标记了fallback方法，当call方法的重试次数达到上限时，将执行fallback方法中的降级逻辑。

@Recover
    public boolean recover(Exception e,String param) {
        log.error("达到最大重试次数,或抛出了一个没有指定进行重试的异常:",e);
        return false;
    }

除了这些之外，还有一些其他的重试方法。

三、异步重试

通过@Async注解表示callAsyncThirdPartyApi方法是异步的

@Service
 public class AsyncThirdPartyService {
 
     @Async
     @Retryable(
         value = { RestClientException.class },
         maxAttempts = 3,
         backoff = @Backoff(delay = 1000, multiplier = 2)
     )
     public CompletableFuture<String> callAsyncThirdPartyApi() {
         // 异步调用第三方API的逻辑
         // ...
     }
 }

四、熔断机制

除了重试机制外，熔断机制也是一种常见的容错处理手段。Hystrix是一款流行的断路器实现库，可以与Spring Boot集成，用于实现熔断机制。

1、依赖引入

<dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
 </dependency>

2、实现熔断

@Service
 public class ThirdPartyService {
 
     @HystrixCommand(fallbackMethod = "fallback")
     public String callThirdPartyApi() {
         // 调用第三方API的逻辑
         // ...
     }
 
     public String fallback() {
         // 熔断时的降级逻辑
         // ...
     }

配置启动熔断@EnableHystrix

好了，今天的分享就到这里，喜欢的兄弟可以点赞关注一下，我们下期再见！