发布于 由admin

JAVA 如何使用 Spring Retry 实现接口自动重试与失败告警？

Spring Retry 实战：接口自动重试与失败告警

各位朋友，大家好！今天我们来聊聊如何利用 Spring Retry 框架，实现接口的自动重试和失败告警功能。在分布式系统中，由于网络抖动、服务不稳定等因素，接口调用失败是常有的事。如果每次失败都需要人工干预，那将耗费大量时间和精力。通过 Spring Retry，我们可以优雅地解决这个问题，并且在重试多次失败后，及时发送告警，以便我们快速定位和解决问题。

一、Spring Retry 简介

Spring Retry 是 Spring 家族提供的一个用于简化重试逻辑的框架。它提供了一系列注解和接口，帮助我们声明式地定义重试策略，而无需编写大量的重复代码。

核心概念：

  • @Retryable: 标注在需要重试的方法上，表示该方法在抛出特定异常时可以进行重试。
  • @Recover: 标注在重试耗尽后执行的方法上，用于处理重试失败的情况。通常用于发送告警或者进行补偿操作。
  • RetryTemplate: Spring Retry 的核心类，用于配置重试策略，例如重试次数、重试间隔等。
  • RetryPolicy: 定义重试策略，例如 SimpleRetryPolicy (固定次数重试)、TimeoutRetryPolicy (超时时间限制)、CircuitBreakerRetryPolicy (熔断器模式) 等。
  • BackoffPolicy: 定义重试间隔策略，例如 FixedBackOffPolicy (固定间隔)、ExponentialBackOffPolicy (指数增长间隔) 等。

二、环境搭建和依赖引入

首先，我们需要创建一个 Spring Boot 项目，并引入 Spring Retry 的依赖。

Maven 依赖：

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
</dependency>

spring-retry 是 Spring Retry 框架的核心依赖，spring-aspects 是为了支持 @Retryable 注解的 AOP 切面。

开启重试支持：

在 Spring Boot 应用的启动类上添加 @EnableRetry 注解，开启重试功能。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.retry.annotation.EnableRetry;

@SpringBootApplication
@EnableRetry
public class RetryApplication {

    public static void main(String[] args) {
        SpringApplication.run(RetryApplication.class, args);
    }
}

三、简单的接口重试示例

接下来，我们创建一个简单的接口，并使用 @Retryable 注解进行重试。

Service 接口：

public interface RemoteService {

    String callRemoteService() throws Exception;
}

Service 实现类：

import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
public class RemoteServiceImpl implements RemoteService {

    private int retryCount = 0;

    @Override
    @Retryable(value = {Exception.class}, maxAttempts = 3)
    public String callRemoteService() throws Exception {
        retryCount++;
        System.out.println("Attempting to call remote service, retry count: " + retryCount);
        if (retryCount < 3) {
            throw new RuntimeException("Remote service failed");
        }
        return "Remote service call successful";
    }
}

在这个例子中，@Retryable 注解指定了重试的异常类型为 Exception.class，最大重试次数为 3。 retryCount 变量用于模拟远程服务调用失败的情况。 只有在第三次调用时，才会返回成功。

Controller 类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private RemoteService remoteService;

    @GetMapping("/call")
    public String callRemote() throws Exception {
        return remoteService.callRemoteService();
    }
}

当调用 /call 接口时，callRemoteService() 方法会被执行。如果方法抛出异常，Spring Retry 会自动进行重试，直到达到最大重试次数或者方法成功返回。

四、重试失败后的告警

当重试次数耗尽后，我们需要及时发送告警，以便我们能够快速处理问题。我们可以使用 @Recover 注解来实现这个功能。

修改 Service 实现类：

import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
public class RemoteServiceImpl implements RemoteService {

    private int retryCount = 0;

    @Override
    @Retryable(value = {Exception.class}, maxAttempts = 3)
    public String callRemoteService() throws Exception {
        retryCount++;
        System.out.println("Attempting to call remote service, retry count: " + retryCount);
        if (retryCount < 3) {
            throw new RuntimeException("Remote service failed");
        }
        return "Remote service call successful";
    }

    @Recover
    public String recover(Exception e) {
        System.out.println("重试达到最大次数，告警！" + e.getMessage());
        // 在这里可以调用告警服务，例如发送邮件、短信或者推送消息
        return "Remote service call failed after multiple retries. Alert sent!";
    }
}

在这个例子中，@Recover 注解标注了一个 recover 方法。当 callRemoteService() 方法重试失败后，recover 方法会被调用。我们可以在 recover 方法中编写告警逻辑。 注意：recover方法的参数必须是重试方法抛出的异常类型或其父类。 recover 方法必须和 @Retryable 方法在同一个类中，且参数类型必须匹配。

五、更灵活的配置方式：RetryTemplate

除了使用注解之外，我们还可以使用 RetryTemplate 来进行更灵活的配置。

配置 RetryTemplate：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.retry.RetryPolicy;
import org.springframework.retry.backoff.FixedBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;

@Configuration
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();

        // 设置重试策略
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(3);
        retryTemplate.setRetryPolicy(retryPolicy);

        // 设置重试间隔
        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(1000); // 1 秒
        retryTemplate.setBackOffPolicy(backOffPolicy);

        return retryTemplate;
    }
}

在这个例子中，我们创建了一个 RetryTemplate Bean，并配置了重试策略和重试间隔。 SimpleRetryPolicy 设置最大重试次数为 3，FixedBackOffPolicy 设置重试间隔为 1 秒。

使用 RetryTemplate：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.retry.support.RetryTemplate;
import org.springframework.stereotype.Service;

@Service
public class RemoteServiceImpl implements RemoteService {

    @Autowired
    private RetryTemplate retryTemplate;

    private int retryCount = 0;

    @Override
    public String callRemoteService() throws Exception {
        retryCount++;
        System.out.println("Attempting to call remote service, retry count: " + retryCount);
        if (retryCount < 3) {
            throw new RuntimeException("Remote service failed");
        }
        return "Remote service call successful";
    }

    public String callRemoteServiceWithRetry() throws Exception {
        return retryTemplate.execute(context -> {
            // 在这里执行需要重试的逻辑
            return callRemoteService();
        }, context -> {
            // 在这里处理重试失败的情况
            System.out.println("重试达到最大次数，告警！");
            return "Remote service call failed after multiple retries. Alert sent!";
        });
    }
}

在这个例子中，我们使用 retryTemplate.execute() 方法来执行需要重试的逻辑。 第一个参数是一个 RetryCallback，用于执行需要重试的逻辑。 第二个参数是一个 RecoveryCallback，用于处理重试失败的情况。

Controller 类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private RemoteService remoteService;

    @GetMapping("/callWithRetryTemplate")
    public String callRemoteWithRetryTemplate() throws Exception {
        return ((RemoteServiceImpl) remoteService).callRemoteServiceWithRetry();
    }
}

当调用 /callWithRetryTemplate 接口时，callRemoteServiceWithRetry() 方法会被执行，并使用 RetryTemplate 进行重试。

六、自定义重试策略

Spring Retry 提供了多种内置的重试策略和间隔策略，但有时我们需要根据实际情况自定义重试策略。

自定义 RetryPolicy：

import org.springframework.retry.RetryContext;
import org.springframework.retry.RetryPolicy;
import org.springframework.retry.context.RetryContextSupport;

public class MyRetryPolicy implements RetryPolicy {

    private int maxAttempts;
    private int currentAttempts = 0;

    public MyRetryPolicy(int maxAttempts) {
        this.maxAttempts = maxAttempts;
    }

    @Override
    public boolean canRetry(RetryContext context) {
        return currentAttempts < maxAttempts;
    }

    @Override
    public RetryContext open(RetryContext parent) {
        currentAttempts = 0;
        return new RetryContextSupport(parent);
    }

    @Override
    public void close(RetryContext context) {
        // Nothing to do
    }

    @Override
    public void registerThrowable(RetryContext context, Throwable throwable) {
        currentAttempts++;
        System.out.println("Registering throwable, current attempts: " + currentAttempts);
    }
}

在这个例子中，我们创建了一个自定义的 MyRetryPolicy，它实现了 RetryPolicy 接口。 canRetry() 方法用于判断是否可以进行重试，open() 方法用于初始化重试上下文，close() 方法用于关闭重试上下文，registerThrowable() 方法用于注册异常。

自定义 BackoffPolicy：

import org.springframework.retry.BackOffContext;
import org.springframework.retry.BackOffPolicy;
import org.springframework.retry.backoff.BackOffContextSupport;

public class MyBackOffPolicy implements BackOffPolicy {

    private long initialInterval;
    private double multiplier;
    private long maxInterval;

    public MyBackOffPolicy(long initialInterval, double multiplier, long maxInterval) {
        this.initialInterval = initialInterval;
        this.multiplier = multiplier;
        this.maxInterval = maxInterval;
    }

    @Override
    public BackOffContext start(RetryContext context) {
        return new BackOffContextSupport();
    }

    @Override
    public void backOff(BackOffContext backOffContext) throws InterruptedException {
        long currentInterval = initialInterval;
        BackOffContextSupport backOffContextSupport = (BackOffContextSupport) backOffContext;

        if (backOffContextSupport.getAttribute("attempts") != null) {
            int attempts = (int) backOffContextSupport.getAttribute("attempts");
            currentInterval = (long) (initialInterval * Math.pow(multiplier, attempts));
            currentInterval = Math.min(currentInterval, maxInterval);
        }

        backOffContextSupport.setAttribute("attempts", (backOffContextSupport.getAttribute("attempts") == null ? 1 : (int) backOffContextSupport.getAttribute("attempts") + 1));
        System.out.println("Backing off for " + currentInterval + "ms");
        Thread.sleep(currentInterval);
    }
}

在这个例子中，我们创建了一个自定义的 MyBackOffPolicy，它实现了 BackOffPolicy 接口。 start() 方法用于初始化重试间隔上下文，backOff() 方法用于计算重试间隔并进行休眠。 这个 MyBackOffPolicy 实现了一个带上限的指数退避策略。

使用自定义策略：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.retry.RetryPolicy;
import org.springframework.retry.backoff.BackOffPolicy;
import org.springframework.retry.support.RetryTemplate;

@Configuration
public class RetryConfig {

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();

        // 设置自定义重试策略
        RetryPolicy retryPolicy = new MyRetryPolicy(5);
        retryTemplate.setRetryPolicy(retryPolicy);

        // 设置自定义重试间隔
        BackOffPolicy backOffPolicy = new MyBackOffPolicy(1000, 2, 10000);
        retryTemplate.setBackOffPolicy(backOffPolicy);

        return retryTemplate;
    }
}

在这个例子中，我们将自定义的 MyRetryPolicy 和 MyBackOffPolicy 应用到了 RetryTemplate 中。

七、使用 Spring AOP 实现更通用的重试

除了直接在方法上使用 @Retryable 注解外，我们还可以利用 Spring AOP 实现更通用的重试逻辑，例如对整个 Service 层的方法进行重试。

创建 AOP 切面：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.retry.support.RetryTemplate;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class RetryAspect {

    @Autowired
    private RetryTemplate retryTemplate;

    @Around("@within(org.springframework.stereotype.Service)") // 对所有 Service 类的方法进行拦截
    public Object retryServiceMethods(ProceedingJoinPoint joinPoint) throws Throwable {
        return retryTemplate.execute(context -> {
            try {
                return joinPoint.proceed();
            } catch (Throwable e) {
                throw new RuntimeException(e); // 需要将 checked exception 转换为 unchecked exception
            }
        }, context -> {
            System.out.println("重试达到最大次数，告警！ " + joinPoint.getSignature());
            // 在这里可以调用告警服务，例如发送邮件、短信或者推送消息
            return null; // 或者抛出异常，取决于你的业务逻辑
        });
    }
}

在这个例子中，我们创建了一个 RetryAspect，它使用了 @Around 注解来拦截所有标注了 @Service 注解的类的方法。 retryServiceMethods() 方法使用 RetryTemplate 来执行被拦截的方法。 注意： 因为 joinPoint.proceed() 方法可能会抛出 checked exception，而 RetryCallback 接口的 doWithRetry() 方法声明不允许抛出 checked exception，所以我们需要将 checked exception 转换为 unchecked exception。

修改 Service 实现类：

import org.springframework.stereotype.Service;

@Service
public class RemoteServiceImpl implements RemoteService {

    private int retryCount = 0;

    @Override
    public String callRemoteService() throws Exception {
        retryCount++;
        System.out.println("Attempting to call remote service, retry count: " + retryCount);
        if (retryCount < 3) {
            throw new Exception("Remote service failed");
        }
        return "Remote service call successful";
    }
}

在这个例子中，我们去掉了 @Retryable 注解，因为重试逻辑已经通过 AOP 切面实现了。

八、更细粒度的控制：RetryContext

RetryContext 提供了重试过程中的上下文信息，例如重试次数、上一次抛出的异常等。 我们可以利用 RetryContext 来进行更细粒度的控制。

获取 RetryContext 信息：

import org.springframework.retry.RetryCallback;
import org.springframework.retry.RetryContext;
import org.springframework.retry.support.RetryTemplate;
import org.springframework.stereotype.Service;

@Service
public class RemoteServiceImpl implements RemoteService {

    @Autowired
    private RetryTemplate retryTemplate;

    private int retryCount = 0;

    @Override
    public String callRemoteService() throws Exception {
        retryCount++;
        System.out.println("Attempting to call remote service, retry count: " + retryCount);
        if (retryCount < 3) {
            throw new RuntimeException("Remote service failed");
        }
        return "Remote service call successful";
    }

    public String callRemoteServiceWithRetryContext() throws Exception {
        return retryTemplate.execute(new RetryCallback<String, Exception>() {
            @Override
            public String doWithRetry(RetryContext context) throws Exception {
                System.out.println("Retry count: " + context.getRetryCount());
                return callRemoteService();
            }
        }, context -> {
            System.out.println("重试达到最大次数，告警！ " + context.getLastThrowable().getMessage());
            return "Remote service call failed after multiple retries. Alert sent!";
        });
    }
}

在这个例子中，我们使用匿名内部类的方式实现了 RetryCallback 接口。 在 doWithRetry() 方法中，我们可以通过 context.getRetryCount() 方法获取当前的重试次数，并将其打印出来。 在 RecoveryCallback 中，我们可以通过 context.getLastThrowable() 获取最后一次抛出的异常。

九、结合其他组件实现告警

@Recover 注解和 RetryTemplate 中的 RecoveryCallback 都提供了重试失败后的处理机制。 我们可以结合其他组件，例如邮件服务、短信服务或者消息队列，来实现告警功能。

示例：使用邮件服务发送告警：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
public class RemoteServiceImpl implements RemoteService {

    @Autowired
    private JavaMailSender mailSender;

    private int retryCount = 0;

    @Override
    @Retryable(value = {Exception.class}, maxAttempts = 3)
    public String callRemoteService() throws Exception {
        retryCount++;
        System.out.println("Attempting to call remote service, retry count: " + retryCount);
        if (retryCount < 3) {
            throw new RuntimeException("Remote service failed");
        }
        return "Remote service call successful";
    }

    @Recover
    public String recover(Exception e) {
        System.out.println("重试达到最大次数，发送邮件告警！" + e.getMessage());

        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("[email protected]");
        message.setTo("[email protected]");
        message.setSubject("Remote Service Call Failed");
        message.setText("Remote service call failed after multiple retries. Exception: " + e.getMessage());

        mailSender.send(message);

        return "Remote service call failed after multiple retries. Alert sent!";
    }
}

在这个例子中，我们使用了 JavaMailSender 来发送邮件告警。 需要配置 Spring Boot 的邮件配置，例如 spring.mail.host、spring.mail.username、spring.mail.password 等。

总结：灵活运用 Spring Retry 实现接口重试

今天我们详细介绍了 Spring Retry 框架的使用方法，包括 @Retryable 注解、@Recover 注解、RetryTemplate、自定义重试策略、AOP 切面以及结合其他组件实现告警功能。 希望通过今天的讲解，大家能够灵活运用 Spring Retry 框架，实现接口的自动重试和失败告警，提高系统的稳定性和可靠性。

接口重试策略的选择和应用

根据不同的业务场景，选择合适的重试策略至关重要。 常见的策略包括：

重试策略 描述 适用场景
固定次数重试 重试固定次数后停止。 对响应时间要求不高，且失败原因是偶发性的场景，例如网络抖动。
超时时间限制 在指定时间内进行重试，超过时间则停止。 对响应时间有要求的场景，避免长时间阻塞。
熔断器模式 当失败次数达到阈值时，开启熔断，一段时间内直接返回错误，避免雪崩效应。 服务不稳定，容易出现大量失败的场景。
指数退避策略 每次重试的间隔时间呈指数增长，避免瞬间对后端服务造成过大的压力。 后端服务压力较大，需要平滑重试的场景。
特定异常类型重试 只对特定类型的异常进行重试，例如网络连接异常。 需要区分不同类型的异常，只对可重试的异常进行重试的场景。
组合重试策略 将多种重试策略组合使用，例如先进行固定次数重试，如果仍然失败，则开启熔断器。 复杂的场景，需要根据不同的情况采取不同的重试策略。

在实际应用中，需要根据具体的业务场景和系统特点，选择合适的重试策略，并进行合理的配置，才能达到最佳的效果。

最佳实践建议

  • 幂等性设计： 确保需要重试的接口具有幂等性，即多次调用产生的结果与一次调用相同，避免重复操作导致数据错误。
  • 监控和告警： 完善的监控和告警机制是必不可少的。 需要监控重试次数、重试间隔、失败率等指标，并在达到阈值时及时发送告警，以便快速发现和解决问题。
  • 日志记录： 详细的日志记录可以帮助我们分析问题。 需要记录每次重试的开始时间、结束时间、异常信息等，以便追踪问题的根源。
  • 避免过度重试： 过度重试可能会导致系统资源耗尽，甚至引发雪崩效应。 需要根据实际情况设置合理的重试次数和间隔，并考虑使用熔断器模式。
  • 区分临时性错误和永久性错误： 有些错误是临时性的，可以通过重试解决，而有些错误是永久性的，例如参数错误，无法通过重试解决。 需要区分这两种类型的错误，只对临时性错误进行重试。
  • 考虑上下文信息： 在重试过程中，可以利用 RetryContext 获取上下文信息，例如重试次数、上一次抛出的异常等，并根据这些信息进行更细粒度的控制。

总结：构建高可用的系统

通过合理使用 Spring Retry 框架，结合合适的重试策略、告警机制和最佳实践，我们可以构建更加稳定、可靠和高可用的系统。 希望今天的分享能够帮助大家更好地理解和应用 Spring Retry 框架。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注