铁杵磨成针, springboot 如何优雅重试之Spring Retry

素颜马尾好姑娘i 2023-10-10 17:01 41阅读 0赞

#### 铁杵磨成针 ✈️ ####

*   *  \`springboot 如何优雅重试\`, myql 乐观锁 更新/插入失败了之后
     *  Spring Retry 主要应用场景
     *  Spring Retry有什么限制或者缺点呢?
     *  我需要对整个事务进行重试，我要怎么使用Spring Retry的父项目Spring Batch来实现呢?
     *  总结

> 纯粹的喜欢是不管不顾的，你降临到我的世界，用喜怒哀乐代替四季，微笑就是白昼，哭泣就是黑夜

### `springboot 如何优雅重试`, myql 乐观锁 更新/插入失败了之后 ###

在使用乐观锁时，如果更新或插入失败，通常意味着其他线程已经更新了相同的数据。这时候，可以通过重试来尝试再次更新或插入数据。

在Spring Boot中，可以使用Spring Retry来实现优雅的重试。Spring Retry提供了一个简单的注解，可以将方法标记为需要重试的方法。当这个方法被调用时，Spring Retry会在指定的异常发生时重试方法调用。

下面是一个使用Spring Retry进行优雅重试的示例：

import org.springframework.retry.annotation.Backoff;
    import org.springframework.retry.annotation.Retryable;
    import org.springframework.stereotype.Service;
    
    @Service
    public class MyService {
        
    
        @Retryable(value = {
        OptimisticLockException.class}, maxAttempts = 3, backoff = @Backoff(delay = 100))
        public void updateWithOptimisticLock(MyEntity entity) {
        
            // 执行更新操作
        }
    }

在这个示例中，`@Retryable`注解用于标记`updateWithOptimisticLock`方法，指定了需要重试的异常类型为`OptimisticLockException`，最大重试次数为3次，每次重试之间的延迟为100毫秒。

### Spring Retry 主要应用场景 ###

Spring Retry 主要用于处理一些短暂、可恢复的故障，包括但不限于以下几种场景：

1.  网络超时：当应用程序向外部服务发送请求时，可能会因为网络超时而导致请求失败。这时候可以使用 Spring Retry 来进行重试，等待网络恢复。
2.  数据库死锁：在使用数据库时，可能会出现死锁的情况，导致更新或查询失败。这时候可以使用 Spring Retry 来进行重试，等待死锁解除。
3.  外部服务不可用：当应用程序依赖外部服务时，可能会出现外部服务不可用的情况，导致请求失败。这时候可以使用 Spring Retry 来进行重试，等待外部服务恢复。
4.  限流或熔断：当应用程序向外部服务发送请求时，可能会出现限流或熔断的情况，导致请求失败。这时候可以使用 Spring Retry 来进行重试，等待限流或熔断恢复。
5.  其他可恢复的故障：除了以上几种场景外，还有许多其他可恢复的故障，例如缓存故障、文件访问故障等，这些场景都可以使用 Spring Retry 来进行重试。

总的来说，Spring Retry 主要用于处理一些短暂、可恢复的故障，通过重试的方式来恢复服务的正常运行。在使用 Spring Retry 时，需要根据实际情况选择合适的重试策略，包括重试次数、重试间隔、异常类型等。

### Spring Retry有什么限制或者缺点呢? ###

尽管Spring Retry是一个非常强大的库，但它仍然有一些限制和缺点，需要在使用时注意。以下是一些可能需要考虑的因素：

1.  重试会增加系统负担：重试会增加系统负担，因为它会导致更多的方法调用和资源使用。如果重试的次数过多或重试的间隔时间过短，可能会导致系统负荷过大，从而影响系统的性能和可用性。
2.  不能解决所有的问题：重试只适用于一些特定类型的问题，如网络超时、数据库死锁等。如果出现其他类型的问题，例如无法访问某些资源、服务停机等，重试将无法解决这些问题，可能需要采用其他的方法来处理。
3.  可能导致不一致的结果：如果重试的过程中修改了数据，可能会导致数据的不一致性。例如，在更新某个记录的过程中，另一个线程可能已经修改了相同的记录。如果重试成功了，可能会覆盖另一个线程所做的修改，从而导致数据不一致。
4.  需要适当地配置：为了使Spring Retry正常工作，你需要适当地配置它，包括重试的次数、间隔时间等。如果配置不当，可能会导致重试无法正常工作或者重试次数过多导致系统负荷过大。

需要注意的是

> Spring Retry只能在方法级别上应用，不能对整个事务进行重试。如果需要对整个事务进行重试，可以考虑使用Spring Retry的父项目Spring Batch来实现。

### 我需要对整个事务进行重试，我要怎么使用Spring Retry的父项目Spring Batch来实现呢? ###

如果你需要对整个事务进行重试，可以考虑使用Spring Batch。Spring Batch是一个轻量级的、可扩展的批处理框架，可以用来处理大量数据的批处理任务。Spring Batch提供了事务管理、并发处理、错误处理、日志记录等功能，非常适合用于需要重试的任务。

下面是一个使用Spring Batch进行重试的示例：

首先，你需要在你的Spring Boot应用中添加Spring Batch的依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-batch</artifactId>
    </dependency>

然后，你需要编写一个批处理任务，这个任务需要包含需要重试的代码逻辑：

import org.springframework.batch.core.Job;
    import org.springframework.batch.core.Step;
    import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
    import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
    import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
    import org.springframework.batch.core.launch.support.RunIdIncrementer;
    import org.springframework.batch.core.repository.JobRepository;
    import org.springframework.batch.core.repository.support.JobRepositoryFactoryBean;
    import org.springframework.batch.support.transaction.ResourcelessTransactionManager;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.retry.annotation.Backoff;
    import org.springframework.retry.annotation.Retryable;
    
    @Configuration
    @EnableBatchProcessing
    public class MyBatchConfig {
        
    
        @Autowired
        private JobBuilderFactory jobBuilderFactory;
    
        @Autowired
        private StepBuilderFactory stepBuilderFactory;
    
        @Autowired
        private MyService myService;
    
        @Bean
        public Job myJob() throws Exception {
        
            return jobBuilderFactory.get("myJob")
                    .incrementer(new RunIdIncrementer())
                    .start(myStep())
                    .build();
        }
    
        @Bean
        public Step myStep() {
        
            return stepBuilderFactory.get("myStep")
                    .tasklet((stepContribution, chunkContext) -> {
        
                        // 在这里执行需要重试的代码逻辑
                        myService.updateWithOptimisticLock(entity);
                        return null;
                    })
                    .faultTolerant()
                    .retryLimit(3) // 最大重试次数
                    .retry(OptimisticLockException.class) // 重试的异常类型
                    .build();
        }
    
        @Bean
        public JobRepository jobRepository() throws Exception {
        
            JobRepositoryFactoryBean factory = new JobRepositoryFactoryBean();
            factory.setTransactionManager(new ResourcelessTransactionManager());
            factory.setIsolationLevelForCreate("ISOLATION_REPEATABLE_READ");
            factory.setDataSource(dataSource()); // 这里需要配置数据源
            factory.afterPropertiesSet();
            return factory.getObject();
        }
    
        // 配置数据源等其他一些必要的组件
    }

在这个示例中，`myJob()`方法定义了一个批处理任务，包含一个步骤`myStep()`。`myStep()`方法使用了Spring Batch的`faultTolerant()`方法来开启重试功能，并通过`retryLimit()`和`retry()`方法指定了最大重试次数和需要重试的异常类型。在`tasklet()`方法中执行了需要重试的代码逻辑。

需要注意的是，在使用Spring Batch时，你需要配置数据源、事务管理器等必要的组件。你还需要在应用中创建一个批处理作

### 总结 ###

综上所述，Spring Retry是一个非常有用的库，可以帮助处理一些特定类型的问题。但是，在使用时需要注意它的限制和缺点，并根据实际情况进行适当的配置和使用。