SpringBoot中的4种重试机制实现方案

使用重试机制保证SpringBoot应用的稳定性 没有人能保证自己的系统不出错,同样,在调用第三方系统时,也不能保证能够100%的成功。往往会因为程序逻辑、网络中断、边界值等各种各样的问题导致服务失败。在不同的业务领域对于服务的错误率有着不同的要求,一些金融领域的系统一般要求服务的错误率为0.01%。那么为了保证很低的错误率,则需要通过一些专门的机制来完成。而最常见的方式就是在出现错误时通过重试来解决。 阅读详情

在分布式系统和微服务架构中,服务调用失败是不可避免的现象。网络不稳定、服务过载、临时故障等因素都可能导致调用失败。重试机制作为一种处理临时性故障的解决方案,能够有效提高系统的可用性。

一、Spring Retry

1. 基本原理

Spring Retry是Spring官方提供的重试框架,作为Spring生态系统的一部分,它通过AOP(面向切面编程)实现了对方法调用的重试能力。当方法调用失败时,Spring Retry会根据配置的策略自动重新执行该方法,直到成功或达到最大重试次数。

Spring Retry的核心组件包括:

  • RetryOperations:定义重试操作的接口
  • RetryTemplate:RetryOperations的默认实现
  • RetryPolicy:定义何时进行重试(如最大次数、重试的异常类型等)
  • BackOffPolicy:定义重试间隔策略(如固定间隔、指数退避等)
  • RecoveryCallback:定义最终失败后的恢复策略

2. 集成配置

在SpringBoot项目中集成Spring Retry:

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

然后在启动类上启用重试功能:

@SpringBootApplication
@EnableRetry
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

3. 使用方法

Spring Retry提供了注解方式和编程方式两种使用方法。

注解方式

@Service
public class RemoteServiceClient {
    
    private static final Logger logger = LoggerFactory.getLogger(RemoteServiceClient.class);
    
    @Retryable(value = {ServiceException.class}, 
               maxAttempts = 3, 
               backoff = @Backoff(delay = 1000, multiplier = 2))
    public String callRemoteService(String param) {
        logger.info("调用远程服务,参数: {}", param);
        // 模拟调用失败
        if (Math.random() > 0.7) {
            logger.error("服务调用失败");
            throw new ServiceException("远程服务暂时不可用");
        }
        return "调用成功: " + param;
    }
    
    @Recover
    public String recover(ServiceException e, String param) {
        logger.warn("重试失败,执行恢复方法, 参数: {}", param);
        return "降级响应: " + param;
    }
}

在上面的例子中:

  • @Retryable 注解定义了需要重试的方法,包括触发重试的异常类型、最大重试次数和退避策略
  • backoff 属性设置初始延迟1秒,且每次延迟时间翻倍(指数退避)
  • @Recover 注解定义了重试失败后的恢复方法

编程方式

@Service
public class RemoteServiceClient {
    
    private final RetryTemplate retryTemplate;
    
    @Autowired
    public RemoteServiceClient(RetryTemplate retryTemplate) {
        this.retryTemplate = retryTemplate;
    }
    
    public String callWithRetry(String param) {
        return retryTemplate.execute(context -> {
            // 重试的业务逻辑
            if (Math.random() > 0.7) {
                throw new ServiceException("服务暂时不可用");
            }
            return "调用成功: " + param;
        }, context -> {
            // 重试失败后的恢复逻辑
            return "降级响应: " + param;
        });
    }
    
    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate template = new RetryTemplate();
        
        // 设置重试策略
        SimpleRetryPolicy policy = new SimpleRetryPolicy();
        policy.setMaxAttempts(3);
        
        // 设置退避策略
        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(1000);
        backOffPolicy.setMultiplier(2.0);
        
        template.setRetryPolicy(policy);
        template.setBackOffPolicy(backOffPolicy);
        
        return template;
    }
}

4. 优缺点

优点

  • 与Spring生态系统完美集成
  • 提供了丰富的重试策略和配置选项
  • 支持注解和编程两种方式,使用灵活
  • 可以精确控制重试的异常类型
  • 支持声明式事务回滚和提交

缺点

  • 依赖Spring框架
  • 代码侵入性相对较强
  • 在复杂场景下配置略显复杂
  • 与其他容错机制集成需要额外工作

5. 适用场景

  • Spring生态系统的项目
  • 需要精细控制重试条件和策略的场景
  • 与Spring事务结合的业务场景
  • 方法级别的重试需求

二、Resilience4j Retry

1. 基本原理

Resilience4j是受Netflix Hystrix启发而创建的轻量级容错库,其中Resilience4j Retry模块提供了强大的重试功能。与Spring Retry不同,Resilience4j采用函数式编程风格,使用装饰器模式实现重试功能。

Resilience4j Retry的特点:

  • 基于函数式接口
  • 无外部依赖,轻量级设计
  • 可与其他容错机制(如断路器、限流器)无缝集成
  • 提供丰富的监控指标

2. 集成配置

在SpringBoot项目中集成Resilience4j Retry:

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

配置application.yml:

resilience4j.retry:
  instances:
    backendService:
      maxAttempts: 3
      waitDuration: 1s
      enableExponentialBackoff: true
      exponentialBackoffMultiplier: 2
      retryExceptions:
        - java.io.IOException
        - java.util.concurrent.TimeoutException

3. 使用方法

Resilience4j同样支持注解方式和编程方式。

注解方式

@Service
public class BackendService {
    
    private static final Logger logger = LoggerFactory.getLogger(BackendService.class);
    
    @Retry(name = "backendService", fallbackMethod = "fallbackCall")
    public String callBackendService(String param) {
        logger.info("调用后端服务,参数: {}", param);
        
        if (Math.random() > 0.7) {
            logger.error("服务调用失败");
            throw new IOException("服务连接失败");
        }
        
        return "后端服务响应: " + param;
    }
    
    public String fallbackCall(String param, Exception ex) {
        logger.warn("所有重试失败,执行降级方法,参数: {}", param);
        return "降级响应: " + param;
    }
}

编程方式

@Service
public class BackendService {
    
    private final RetryRegistry retryRegistry;
    private final Logger logger = LoggerFactory.getLogger(BackendService.class);
    
    @Autowired
    public BackendService(RetryRegistry retryRegistry) {
        this.retryRegistry = retryRegistry;
    }
    
    public String executeWithRetry(String param) {
        // 获取已配置的重试实例
        Retry retry = retryRegistry.retry("backendService");
        
        // 创建一个可重试的函数
        CheckedFunction0<String> retryableFunction = Retry.decorateCheckedSupplier(
            retry, () -> callBackendService(param));
        
        try {
            // 执行重试函数
            return retryableFunction.apply();
        } catch (Throwable throwable) {
            logger.error("重试失败: {}", throwable.getMessage());
            return "降级响应: " + param;
        }
    }
    
    private String callBackendService(String param) throws IOException {
        logger.info("调用后端服务,参数: {}", param);
        
        if (Math.random() > 0.7) {
            throw new IOException("服务连接失败");
        }
        
        return "后端服务响应: " + param;
    }
}

4. 优缺点

优点

  • 轻量级设计,无外部依赖
  • 函数式编程风格,代码简洁
  • 提供丰富的监控和统计指标
  • 可与断路器、限流器等容错机制无缝集成
  • 支持多种高级重试策略

缺点

  • 学习曲线相对陡峭,尤其是函数式概念
  • 对于不熟悉函数式编程的开发者可能不够直观
  • 某些高级功能需要额外配置

5. 适用场景

  • 需要与其他容错机制结合的复杂场景
  • 微服务架构中的服务间调用
  • 需要详细监控指标的系统

三、Guava Retrying

1. 基本原理

Guava Retrying是Google Guava库提供的重试机制,它提供了一个简单灵活的API来实现重试功能。

Guava Retrying通过构建器模式提供了灵活的重试配置,可以自定义重试条件、停止策略、等待策略等。

2. 集成配置

在SpringBoot项目中集成Guava Retrying:

<dependency>
    <groupId>com.github.rholder</groupId>
    <artifactId>guava-retrying</artifactId>
    <version>2.0.0</version>
</dependency>

3. 使用方法

Guava Retrying主要采用编程方式使用:

@Service
public class ExternalServiceClient {
    
    private static final Logger logger = LoggerFactory.getLogger(ExternalServiceClient.class);
    
    public String callExternalService(String param) {
        Retryer<String> retryer = RetryerBuilder.<String>newBuilder()
            .retryIfException() // 发生任何异常时重试
            .retryIfResult(result -> result == null) // 结果为null时重试
            .withWaitStrategy(WaitStrategies.exponentialWait(1000, 10000, TimeUnit.MILLISECONDS)) // 指数退避
            .withStopStrategy(StopStrategies.stopAfterAttempt(3)) // 最多重试3次
            .withRetryListener(new RetryListener() {
                @Override
                public <V> void onRetry(Attempt<V> attempt) {
                    logger.info("第{}次重试", attempt.getAttemptNumber());
                    if (attempt.hasException()) {
                        logger.error("异常: {}", attempt.getExceptionCause().getMessage());
                    }
                }
            })
            .build();
        
        try {
            return retryer.call(() -> {
                logger.info("调用外部服务,参数: {}", param);
                
                // 模拟服务调用
                if (Math.random() > 0.7) {
                    throw new RuntimeException("服务暂时不可用");
                }
                
                return "外部服务响应: " + param;
            });
        } catch (RetryException | ExecutionException e) {
            logger.error("重试失败: {}", e.getMessage());
            return "降级响应: " + param;
        }
    }
}

在SpringBoot中创建可复用的Retryer bean:

@Configuration
public class RetryConfig {
    
    @Bean
    public <T> Retryer<T> defaultRetryer() {
        return RetryerBuilder.<T>newBuilder()
            .retryIfException()
            .retryIfResult(Predicates.isNull())
            .withWaitStrategy(WaitStrategies.exponentialWait(100, 1000, TimeUnit.MILLISECONDS))
            .withStopStrategy(StopStrategies.stopAfterAttempt(3))
            .build();
    }
}

@Service
public class ServiceWithRetry {
    
    private final Retryer<String> retryer;
    
    @Autowired
    public ServiceWithRetry(Retryer<String> retryer) {
        this.retryer = retryer;
    }
    
    public String executeWithRetry(String input) throws ExecutionException, RetryException {
        return retryer.call(() -> {
            // 业务逻辑
            return processInput(input);
        });
    }
}

4. 高级特性

Guava Retrying提供了丰富的定制选项:

Retryer<String> complexRetryer = RetryerBuilder.<String>newBuilder()
    // 定制重试条件
    .retryIfExceptionOfType(IOException.class)
    .retryIfException(e -> e instanceof TimeoutException)
    .retryIfResult(result -> result != null && result.contains("error"))
    
    // 定制等待策略
    .withWaitStrategy(WaitStrategies.join(
        WaitStrategies.fixedWait(1000, TimeUnit.MILLISECONDS),
        WaitStrategies.randomWait(1000, TimeUnit.MILLISECONDS, 2000, TimeUnit.MILLISECONDS)
    ))
    
    // 定制停止策略
    .withStopStrategy(StopStrategies.stopAfterDelay(30, TimeUnit.SECONDS))
    
    // 定制阻塞策略
    .withBlockStrategy(BlockStrategies.threadSleepStrategy())
    
    .build();

5. 优缺点

优点

  • API简单直观,容易上手
  • 高度可定制的重试条件、等待策略和停止策略
  • 不依赖Spring框架,可在任何Java项目中使用

缺点

  • 没有注解支持,只能通过编程方式使用
  • 缺乏与Spring生态系统的深度集成
  • 没有内置的监控和统计功能
  • 已停止更新

6. 适用场景

  • 简单的重试需求
  • 非Spring项目或对Spring依赖较少的项目
  • 需要高度自定义重试逻辑的场景

四、Failsafe

1. 基本原理

failsafe是一个相对较新的Java重试库,专注于高性能和低延迟场景。它的设计目标是提供一个简单、高效的重试机制,同时保持API的简洁性和使用的便捷性。failsafe支持同步和异步重试,具有灵活的重试策略和最小的依赖。

2. 集成配置

在SpringBoot项目中集成failsafe

<dependency>
    <groupId>dev.failsafe</groupId>
    <artifactId>failsafe</artifactId>
    <version>3.3.2</version>
</dependency>

failsafe通常通过dev.failsafe:failsafe库来使用,这是一个现代化的重试和容错库。

3. 使用方法

failsafe主要采用编程方式使用,具有流式API设计

@Service
public class FailsafeService {
    
    private static final Logger logger = LoggerFactory.getLogger(FailsafeService.class);
    
    public String executeWithRetry(String param) {
        return Failsafe.with(
            // 配置重试策略
            RetryPolicy.<String>builder()
                .handle(IOException.class, TimeoutException.class)
                .withMaxRetries(3)
                .withDelay(Duration.ofSeconds(1))
                .withMaxDuration(Duration.ofSeconds(10))
                .withBackoff(Duration.ofMillis(100), Duration.ofSeconds(2))
                .onRetry(event -> logger.info("第{}次重试,上次异常: {}", 
                                         event.getAttemptCount(), 
                                         event.getLastException().getMessage()))
                .onFailure(event -> logger.error("重试失败,尝试次数: {}, 总耗时: {}ms", 
                                            event.getAttemptCount(),
                                            event.getElapsedTime().toMillis()))
                .build()
        )
        .get(() -> {
            logger.info("执行操作,参数: {}", param);
            
            // 模拟操作
            if (Math.random() > 0.7) {
                throw new IOException("操作暂时失败");
            }
            
            return "操作成功: " + param;
        });
    }
    
    // 异步重试示例
    public CompletableFuture<String> executeWithRetryAsync(String param) {
        return Failsafe.with(
            RetryPolicy.<String>builder()
                .handle(IOException.class)
                .withMaxRetries(3)
                .withBackoff(Duration.ofMillis(100), Duration.ofSeconds(1))
                .build()
        )
        .getAsync(() -> {
            logger.info("异步执行操作,参数: {}", param);
            
            // 模拟异步操作
            if (Math.random() > 0.7) {
                throw new IOException("异步操作暂时失败");
            }
            
            return "异步操作成功: " + param;
        });
    }
    
    // 带降级的重试示例
    public String executeWithFallback(String param) {
        return Failsafe.with(
            RetryPolicy.<String>builder()
                .handle(IOException.class)
                .withMaxRetries(3)
                .build(),
            // 降级策略
            Fallback.of(e -> "降级响应: " + param)
        )
        .get(() -> {
            // 业务逻辑
            if (Math.random() > 0.7) {
                throw new IOException("操作失败");
            }
            return "操作成功: " + param;
        });
    }
}

在SpringBoot中创建可复用的RetryPolicy bean

@Configuration
public class FailsafeConfig {
    
    @Bean
    public RetryPolicy<Object> defaultRetryPolicy() {
        return RetryPolicy.builder()
            .handle(Exception.class)
            .withMaxRetries(3)
            .withBackoff(Duration.ofMillis(100), Duration.ofSeconds(1), 2.0)
            .build();
    }
    
    @Bean
    public Fallback<Object> defaultFallback() {
        return Fallback.of(e -> {
            if (e instanceof ServiceException) {
                return "服务异常降级";
            }
            return "通用降级响应";
        });
    }
}

@Service
public class ServiceWithFailsafeRetry {
    
    private final RetryPolicy<Object> defaultRetryPolicy;
    private final Fallback<Object> defaultFallback;
    
    @Autowired
    public ServiceWithFailsafeRetry(RetryPolicy<Object> defaultRetryPolicy, 
                               Fallback<Object> defaultFallback) {
        this.defaultRetryPolicy = defaultRetryPolicy;
        this.defaultFallback = defaultFallback;
    }
    
    public String executeWithRetry(String input) {
        return Failsafe.with(defaultRetryPolicy, defaultFallback)
            .get(() -> {
                // 业务逻辑
                return processInput(input);
            });
    }
}

4. 优缺点

优点

  • 极高的性能,适合高频调用场景
  • 支持同步和异步重试
  • 轻量级,依赖少
  • 与CompletableFuture良好集成
  • 内置丰富的监听器机制

缺点

  • 没有注解支持,只能通过编程方式使用
  • 与Spring框架集成度不高
  • 近几年更新也不活跃

5. 适用场景

  • 高性能、低延迟要求的应用
  • 需要异步重试能力的场景
  • 需要细粒度控制重试行为的场景

五、四种重试机制的对比

特性

Spring Retry

Resilience4j Retry

Guava Retrying

Failsafe

编程模型

AOP + 命令式

函数式

命令式

流式

注解支持

支持

支持

不支持

不支持

依赖

Spring

无外部依赖

Guava

最小依赖

性能开销

中等

低

中等

极低

异步支持

有限

良好

有限

优秀

监控集成

有限

丰富

无

基本

配置方式

注解/编程

配置文件/注解/编程

编程

编程

与其他容错机制集成

有限

原生支持

无

良好

学习曲线

中等

较陡

平缓

平缓

可定制性

高

高

高

高

适用场景

Spring项目

微服务/云原生应用

简单场景/非Spring项目

高性能场景

六、最佳实践与注意事项

1. 通用最佳实践

  1. 确保幂等性:重试机制最适合用于幂等操作,即多次执行产生相同结果的操作。对于非幂等操作,需要特别小心。
  2. 设置合理的超时和重试次数:避免无限重试或重试时间过长,通常3-5次足够处理大多数临时故障。
  3. 使用指数退避策略:随着重试次数增加,逐渐增加重试间隔,避免对目标服务造成过大压力。
  4. 区分临时故障和永久故障:只对可能自行恢复的临时故障进行重试,对于永久性错误不应重试。
  5. 添加监控和日志:记录重试次数、成功率等指标,便于问题排查和性能优化。

2. 避免常见陷阱

  1. 重试风暴:当多个客户端同时对一个故障服务进行重试时,可能导致服务负载激增。
  2. 资源泄漏:重试过程中要确保资源(如数据库连接、HTTP连接)正确释放。
  3. 过度重试:过度重试可能导致性能下降,应设置合理的最大重试次数和总超时时间。
  4. 重试成本:某些操作重试成本高昂(如涉及第三方付费API),需谨慎设计重试策略。

七、总结

选择合适的重试机制应基于项目的技术栈、复杂度和需求。无论选择哪种机制,都应遵循重试的最佳实践,避免常见陷阱,确保系统的稳定性和可靠性。

SpringBoot 2.3.4中WebClient抛出PrematureCloseException的5种修复方案(附完整代码) 本文深入解析SpringBoot 2.3.4中WebClient抛出PrematureCloseException的根源,并提供5种生产验证的修复方案,包括升级reactor-netty版本、优化超时配置、调整SSL/TLS设置、精细化连接池管理及自定义重试机制,帮助开发者彻底解决连接提前关闭问题。 阅读详情

相关推荐

LangChain4j流式输出避坑指南:解决SpringBoot中HttpServletResponse与Flux的兼容性问题

本文深入探讨了LangChain4j在SpringBoot中实现流式输出时遇到的HttpServletResponse与Flux兼容性问题,提供了包括响应头延迟提交、字符编码统一和长连接保持在内的工业级解决方案。通过实战案例和性能优化技巧,帮助开发者有效解决流式传输中的常见问题,提升系统稳定性和用户体验。

x1y2z的博客 840

SpringBoot中的7种重试机制

从手动重试,到使用 Spring AOP 自己动手实现,再到站在巨人肩上使用特别优秀的开源实现 Spring Retry 和 Google guava-retrying,经过对各种重试实现方式的介绍,可以看到以上几种方式基本上已经满足大部分场景的需要:如果是基于 Spring 的项目,使用 Spring Retry 的注解方式已经可以解决大部分问题如果项目没有使用 Spring 相关框架,则适合使用 Google guava-retrying:自成体系,使用起来更加灵活强大。

syc_java的博客 4159

SpringBoot项目里,用Apache HttpClient 4.5.6调用第三方API的完整避坑指南

本文详细介绍了在SpringBoot项目中使用Apache HttpClient 4.5.6调用第三方API的工业级实践,包括工程化配置、性能调优、请求执行策略、异常处理框架以及安全加固等关键环节。通过实战案例和最佳实践,帮助开发者避免常见陷阱,提升HTTP客户端调用的稳定性和效率。

weixin_30561425的博客 294

SpringBoot如何优雅的实现重试功能

如何优雅的实现重试

你若为我繁华,我愿成你烟花 2482

Spring Boot集成sms4j实现多厂商短信发送统一封装

短信服务作为现代应用的基础能力,其实现原理主要基于云服务商提供的API接口。通过抽象层设计,开发者可以屏蔽不同厂商SDK的差异,实现统一的短信发送逻辑。sms4j作为轻量级Java组件,采用Spring Boot自动装配机制,将阿里云、腾讯云等厂商的短信服务封装为标准化接口,显著提升开发效率。在技术价值层面,该方案不仅减少70%的重复代码,更支持快速切换服务商,适用于电商验证码、通知提醒等高并发场景。结合连接池优化和异步发送策略,能稳定支撑2000+ QPS的短信发送需求。

weixin_30444111的博客 262

RabbitMQ重试机制

1、RabbitMQ重试机制的简介 RabbitMQ 不会为未确认的消息设置过期时间,它判断此消息是否需要重新投递给消费者的唯一依据是消费该消息连接是否已经断开,这个设置的原因是 RabbitMQ 允许消费者消费一条消息的时间可以很久很久。 RabbitMQ 的 Web 管理平台上可以看到当前队列中的 “Ready” 状态和 “Unacknowledged” 状态的消息数,分别对应等待投递给消费者的消息数和已经投递给消费者但是未收到确认信号的消息数。如下图: 注意事项: 如果在处理消息的过程中

pan_junbiao的博客 1万+

Springboot_重试机制

SpringBoot重试机制

weixin_44582036的博客 696

Springboot 使用 Guava 的重试Retry ,轻便灵活

前言 重试,我承认是冷饭重炒了。 之前写过一些关于重试相关的实践介绍文章: Spring的Retry《Springboot 整合Retry 实现重试机制》: https://blog.youkuaiyun.com/qq_35387940/article/details/99676114使用DelayQueue 实现了更加动态灵活的 延迟重试: 《Springboot 指定重发的次数和延迟时间,定时异步执行 重发任务》:https://blog.youkuaiyun.com/qq_35387940/article/det

默默不代表沉默 4172

SpringBoot 4.0失败重试机制解析与实践

在分布式系统架构中,服务容错是保障系统稳定性的关键技术。失败重试机制通过自动重新执行失败操作,有效应对网络抖动、服务短暂不可用等常见问题。SpringBoot 4.0集成了Spring Framework 7.0的Resilience模块,提供声明式的@Retryable注解实现,基于AOP动态代理技术拦截异常并执行重试策略。该机制特别适用于微服务间的远程调用场景,如支付网关对接、数据同步等关键业务。通过配置重试次数、退避算法和异常过滤规则,开发者可以平衡系统可靠性与响应延迟。结合幂等设计、断路器模式等最佳

weixin_33824385的博客 339

Springboot 整合Retry 实现重试机制

重试,在项目需求中是非常常见的,例如遇到网络波动等,要求某个接口或者是方法可以最多/最少调用几次; 实现重试机制,非得用Retry这个重试框架吗?那肯定不是,相信很多伙伴手写一下控制流程的逻辑也可以达到重试的目的。 那么用Retry的好处是什么? 简单来说,就是优雅。 Retry重试框架,支持AOP切入的方式使用,而且能使用注解;想想,重试次数、重试延迟、重试触发条件、重试的回调方法等等我...

默默不代表沉默 1万+

R语言安装包镜像报错?5分钟教你快速切换国内镜像源(含清华/阿里云配置)

本文详细介绍了R语言安装包镜像报错的解决方案,包括如何快速切换国内镜像源(如清华、阿里云等),解决'无法读写貯藏處索引'等常见问题。通过图形界面和命令行两种方式,帮助用户高效配置镜像源,提升R语言包安装速度与稳定性。

weixin_29053073的博客 419

RocketMQ从实战到源码:SpringBoot整合RocketMQ

本文介绍了SpringBoot与RocketMQ的整合实践,主要内容包括: 环境准备:详细说明了JDK、SpringBoot、RocketMQ及starter的版本兼容性要求,推荐使用稳定版本组合 依赖配置:引入rocketmq-spring-boot-starter依赖,简化整合过程 配置文件:提供了完整的RocketMQ配置示例,包含NameServer地址、生产者/消费者参数等 代码实现: 消息实体类定义 生产者实现三种消息发送方式(同步、异步、单向) 消费者通过注解自动监听消息 测试验证:构建测试类

qq_43843951的博客 583

AXI VIP配置全指南:从报错到成功仿真的完整流程(Vivado 2023版)

本文详细解析了在Vivado 2023环境中配置AXI Verification IP(VIP)进行协议仿真的完整流程。针对常见的include和import报错问题,提供了具体的解决方案和代码示例,指导用户从IP核创建、参数化配置,到构建可工作的仿真测试平台,最终实现成功仿真。

gpt4scribbler的博客 236

Springboot整合Spring Retry实现重试机制

在项目开发过程中,经常会有这样的情况:第一次执行一个操作不成功,考虑到可能是网络原因造成,就多执行几次操作,直到得到想要的结果为止,这就是重试机制。 Springboot可以通过整合Spring Retry框架实现重试。 下面讲一下在之前新建的ibatis项目基础上整合Spring Retry框架的步骤: 1、首先要在pom.xml配置中加入spring-retry的依赖: <depende...

huanongying123的专栏 1万+

电源完整性之Cadence Sigrity Power DC_IR_Drop仿真

之前和大家分享过电源完整性之仿真设计原理链接: link.今天接着上一篇文章总结一下电源直流压降的的仿真操作流程及一些simulation中的设置参数,用到的时候Cadence Sigrity 中的Power DC组件,下面开始享受仿真的快乐吧: 1.仿真模式选择与文件导入 选择Cadence Sigrity下的Power DC组件,然后先择licence,最后就可以打开我们之前转化好的.SPD文件。操作如下图: 2.设置层叠信息和过孔焊盘参数 层叠信息:每层的介质厚度、材料、介电常数、介质损耗角等,如

刘小同学的博客 1万+

英飞凌TC3xx DSADC旋变软解码实战:从示波器波形到VX1000数据,手把手教你避坑

本文详细介绍了英飞凌TC3xx系列微控制器的DSADC模块在电机旋变软解码中的实战应用。从示波器波形分析到VX1000数据采集,提供了一套完整的调试方法论,帮助工程师快速定位和解决常见问题,提升解码精度和系统性能。

weixin_30598225的博客 517

SpringBoot 学习之重试机制

开发场景 当我们与其他第三方对接口的时候,正常是可以一次成功或是失败,但是偶尔也会遇到第三方网络异常或者响应异常。再或者你调用别人的接口回调的时候。可能需要多次尝试获取响应。 SpringBoot 实现重试机制 引入响应jar Maven 对应的pom.xml <dependency> <groupId>org.springframewo...

代码缔造者的博客 4234

STM32笔记:高精度脉冲宽度计 双输入捕获+DMA方式

本文介绍如何用STM32F107VC实现高精度的脉冲宽度计(测量周期脉冲的占空比)。 采用定时器的外部输入捕获功能,双输入+DMA方式,追求硬件的极限表现。

st01lsp的专栏 5289

Springboot @Retryable重试机制实现

场景 在开发的过程中,有的时候我们需要调用第三方的服务或方法 这时候可能会出现网络异常 等一些意外的情况这时候重试机制就会有用了 实现的步骤 加入引用 <dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId> </dependency> .在启动的主程序上加注解 @EnableRetr

坚持需要成为习惯 1198

【MODIS处理工具】MRT(MODIS Reprojection Tool) 下载及安装

【MODIS处理工具】MRT(MODIS Reprojection Tool) 下载及安装

WW、forever的博客 2410

图神经网络实战——利用节点回归预测网络流量

在机器学习中,回归指的是对连续值的预测。通常与分类形成鲜明对比,分类的目标是找到正确的类别(即离散值,而非连续值)。在图数据中,分类和回归分别对应于节点分类和节点回归。在本节中,我们将尝试预测每个节点的连续值,而非分类变量。

盼小辉丶的博客 1万+

Java实战:Spring Boot接口重试机制实现

本文将详细介绍如何在Spring Boot应用程序中实现接口重试机制。我们将探讨重试机制的基本概念,以及如何使用Spring Boot和第三方库来实现接口的重试功能。

oandy0的博客 1989

剪映自动化工具来了:AI帮你自动剪辑成片

🎬分享一个剪映自动化剪辑工具!AI 自动帮你完成从写文案、配音、加字幕、选音乐、上特效到最终导出的整套流程🎈

XiaoqiangClub的博客 861

Springboot 基于@Retryable实现重试机制

首先,添加依赖配置: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> <dependency> <g...

码瘾的空间 1998

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

上一篇: SpringBoot实现接口防刷的5种实现方案
下一篇: Springboot消息堆积如何破局,如何实现高吞吐零失误
程序员职业指南
博客等级 码龄4年 2140粉丝 960原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值