通过Nacos配置刷新进行RabbitMQ消费者在线启停

最新推荐文章于 2024-07-06 21:10:16 发布
最新推荐文章于 2024-07-06 21:10:16 发布
阅读量674 收藏 3
点赞数
文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2312/article/details/129024010
版权

前提

公司在做一些金融相关业务，某些时候由于数据提供商定期维护或者特殊原因需要暂停某些服务的消费者。之前选用的消息队列技术栈是RabbitMQ，用于微服务之间的消息投递，对于这类需要暂停消费者的场景是选用注释掉消费者Bean中的相应Spring(Boot)注解重新发布来实现，后面需要重新启动消费就是解开对应的注释再发布一次。这样的处理流程既繁琐，也显得没有技术含量，所以笔者就这个问题结合已有的配置中心Nacos集群做了一个方案，使用Nacos的配置准实时刷新功能去控制某个微服务实例的所有RabbitMQ消费者（容器）的停止和启动。

方案原理

下面探讨一下方案的原理和可行性，主要包括：

  • RabbitMQ消费者生命周期管理

  • Nacos长轮询与配置刷新

因为工作中的主要技术栈是SpringBoot + RabbitMQ，下文是探讨场景针对spring-boot-starter-amqp（下面简称amqp）展开。

使用SpringBoot版本为2.3.0.RELEASE，spring-cloud-alibaba-nacos-config的版本为2.2.0.RELEASE

RabbitMQ消费者生命周期管理

查看RabbitAnnotationDrivenConfiguration的源码：

amqp中默认启用spring.rabbitmq.listener.type=simple，使用的RabbitListenerContainerFactory（消息监听器容器工厂）实现为SimpleRabbitListenerContainerFactory，使用的MessageListenerContainer（消息监听器容器）实现为SimpleMessageListenerContainer。在amqp中，无论注解声明式或者编程式注册的消费者最终都会封装为MessageListenerContainer实例，因此消费者生命周期可以直接通过MessageListenerContainer进行管理，MessageListenerContainer的生命周期管理API会直接作用于最底层的真实消费者实现BlockingQueueConsumer。几者的关系如下：

一般声明式消费者注册方式如下：

@Slf4j@RabbitListener(id = "SingleAnnoMethodDemoConsumer", queues = "srd->srd.demo")@ComponentpublicclassSingleAnnoMethodDemoConsumer {

    @RabbitHandlerpublicvoidonMessage(Message message) {
        log.info("SingleAnnoMethodDemoConsumer.onMessage => {}", newString(message.getBody(), StandardCharsets.UTF_8));
    }
}

@RabbitListener(id = "MultiAnnoMethodDemoConsumer", queues = "srd->srd.demo")@Component@Slf4jpublicclassMultiAnnoMethodDemoConsumer {

    @RabbitHandlerpublicvoidfirstOnMessage(Message message) {
        log.info("MultiAnnoMethodDemoConsumer.firstOnMessage => {}", newString(message.getBody(), StandardCharsets.UTF_8));
    }

    @RabbitHandlerpublicvoidsecondOnMessage(Message message) {
        log.info("MultiAnnoMethodDemoConsumer.secondOnMessage => {}", newString(message.getBody(), StandardCharsets.UTF_8));
    }
}

@Component@Slf4jpublicclassMultiAnnoInstanceDemoConsumer {

    @RabbitListener(id = "MultiAnnoInstanceDemoConsumer-firstOnInstanceMessage", queues = "srd->srd.demo")publicvoidfirstOnInstanceMessage(Message message) {
        log.info("MultiAnnoInstanceDemoConsumer.firstOnInstanceMessage => {}", newString(message.getBody(), StandardCharsets.UTF_8));
    }

    @RabbitListener(id = "MultiAnnoInstanceDemoConsumer-secondOnInstanceMessage", queues = "srd->srd.sec")publicvoidsecondOnInstanceMessage(Message message) {
        log.info("MultiAnnoInstanceDemoConsumer.secondOnInstanceMessage => {}", newString(message.getBody(), StandardCharsets.UTF_8));
    }
}
复制代码

对于基于@RabbitListener进行声明式注册的消费者，每个被@RabbitListener修饰的Bean或者方法最终都会单独生成一个SimpleMessageListenerContainer实例，这些SimpleMessageListenerContainer实例的唯一标识由@RabbitListener的id属性指定，缺省值为org.springframework.amqp.rabbit.RabbitListenerEndpointContainer#N，建议在使用时候通过规范约束必须定义此id属性。分析源码可以得知这类型的消费者通过RabbitListenerAnnotationBeanPostProcessor进行发现和自动注册，并且在RabbitListenerEndpointRegistry缓存了注册信息，因此可以通过RabbitListenerEndpointRegistry直接获取这些声明式的消费者容器实例：

RabbitListenerEndpointRegistryendpointRegistry= configurableListableBeanFactory.getBean(
                RabbitListenerConfigUtils.RABBIT_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME,
                RabbitListenerEndpointRegistry.class);
Set<String> listenerContainerIds = endpointRegistry.getListenerContainerIds();
for (String containerId : listenerContainerIds) {
    MessageListenerContainermessageListenerContainer= endpointRegistry.getListenerContainer(containerId);
    // do something with messageListenerContainer
}
复制代码

一般编程式消费者注册方式如下：

// MessageListenerDemoConsumer@Component@Slf4jpublicclassMessageListenerDemoConsumerimplementsMessageListener {

    @OverridepublicvoidonMessage(Message message) {
        log.info("MessageListenerDemoConsumer.onMessage => {}", newString(message.getBody(), StandardCharsets.UTF_8));
    }
}

// CustomMethodDemoConsumer@Component@Slf4jpublicclassCustomMethodDemoConsumer {

    publicvoidcustomOnMessage(Message message) {
        log.info("CustomMethodDemoConsumer.customOnMessage => {}", newString(message.getBody(), StandardCharsets.UTF_8));
    }
}

// configuration class// 通过现存的MessageListener实例进行消费@Beanpublic SimpleMessageListenerContainer messageListenerDemoConsumerContainer(
        ConnectionFactory connectionFactory,
        @Qualifier("messageListenerDemoConsumer") MessageListener messageListener) {
    SimpleMessageListenerContainercontainer=newSimpleMessageListenerContainer();
    container.setListenerId("MessageListenerDemoConsumer");
    container.setConnectionFactory(connectionFactory);
    container.setConcurrentConsumers(1);
    container.setMaxConcurrentConsumers(1);
    container.setQueueNames("srd->srd.demo");
    container.setAcknowledgeMode(AcknowledgeMode.AUTO);
    container.setPrefetchCount(10);
    container.setAutoStartup(true);
    container.setMessageListener(messageListener);
    return container;
}

// 通过IOC容器中某个Bean的具体方法进行消费@Beanpublic SimpleMessageListenerContainer customMethodDemoConsumerContainer(
        ConnectionFactory connectionFactory,
        CustomMethodDemoConsumer customMethodDemoConsumer) {
    SimpleMessageListenerContainercontainer=newSimpleMessageListenerContainer();
    container.setListenerId("CustomMethodDemoConsumer");
    container.setConnectionFactory(connectionFactory);
    container.setConcurrentConsumers(1);
    container.setMaxConcurrentConsumers(1);
    container.setQueueNames("srd->srd.demo");
    container.setAcknowledgeMode(AcknowledgeMode.AUTO);
    container.setPrefetchCount(10);
    container.setAutoStartup(true);
    MessageListenerAdaptermessageListenerAdapter=newMessageListenerAdapter();
    messageListenerAdapter.setDelegate(customMethodDemoConsumer);
    messageListenerAdapter.setDefaultListenerMethod("customOnMessage");
    container.setMessageListener(messageListenerAdapter);
    return container;
}
复制代码

编程式注册的SimpleMessageListenerContainer可以直接从IOC容器中获取：

Map<String, MessageListenerContainer> messageListenerContainerBeans
        = configurableListableBeanFactory.getBeansOfType(MessageListenerContainer.class);
if (!CollectionUtils.isEmpty(messageListenerContainerBeans)) {
    messageListenerContainerBeans.forEach((beanId, messageListenerContainer) -> {
        // do something with messageListenerContainer
    });
}
复制代码

至此，我们知道可以比较轻松地拿到服务中所有的MessageListenerContainer的实例，从而可以管理服务内所有消费者的生命周期。

Nacos长轮询与配置刷新

Nacos的客户端通过LongPolling（长轮询）的方式监听Nacos服务端集群对应dataId和group的配置数据变更，具体可以参考ClientWorker的源码实现，实现的过程大致如下：

在非Spring(Boot)体系中，可以通过ConfigService#addListener()进行配置变更监听，示例代码如下：

Propertiesproperties=newProperties();
properties.put(PropertyKeyConst.SERVER_ADDR, "127.0.0.1:8848");
properties.put(PropertyKeyConst.NAMESPACE, "LOCAL");
ConfigServiceconfigService= NacosFactory.createConfigService(properties);
Executorexecutor= Executors.newSingleThreadExecutor(runnable -> {
    Threadthread=newThread(runnable);
    thread.setDaemon(true);
    thread.setName("NacosConfigSyncWorker");
    return thread;
});
configService.addListener("application-aplha.properties", "customer-service", newListener() {
    @Overridepublic Executor getExecutor() {
        return executor;
    }

    @OverridepublicvoidreceiveConfigInfo(String configInfo) {
            // do something with 'configInfo'
    }
});
复制代码

这种LongPolling的方式目前来看可靠性是比较高，因为Nacos服务端集群一般在生产部署是大于3的奇数个实例节点，并且底层基于raft共识算法实现集群通讯，只要不是同一时间超过半数节点宕机集群还是能正常提供服务。但是从实现上来看会有一些局限性：

  • 如果注册过多的配置变更监听器有可能会对Nacos服务端造成比较大的压力，毕竟是多个客户端进行轮询

  • 配置变更是由Nacos客户端向Nacos服务端发起请求，因此监听器回调有可能不是实时的（有可能延迟到客户端下一轮的LongPolling提交）

  • Nacos客户端会缓存每次从Nacos服务端拉取的配置内容，如果要变更配置文件过大有可能导致缓存的数据占用大量内存，影响客户端所在服务的性能

关于配置变更监听其实有其他候选的方案，例如Redis的发布订阅，Zookeeper的节点路径变更监听甚至是使用消息队列进行通知，本文使用Nacos配置变更监听的原因是更好的划分不同应用配置文件的编辑查看权限方便进行管理，其他候选方案要实现分权限管理需要二次开发

使用SpringCloudAlibaba提供的spring-cloud-alibaba-nacos-config可以更加简便地使用Nacos配置刷新监听，并且会把变更的PropertySource重新绑定到对应的配置属性Bean。引入依赖：

<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-alibaba-nacos-config</artifactId></dependency><dependency><groupId>com.alibaba.nacos</groupId><artifactId>nacos-client</artifactId></dependency>复制代码

具体的配置类是NacosConfigProperties：

红圈中是需要关注的配置项，refreshEnabled是配置刷新的开关，默认是开启的。sharedConfigs和extensionConfigs虽然命名不同，但是两者实现和功能没有差异，都是类似于共享或者说扩展配置，每个共享（扩展）配置支持单独配置刷新开关。举个例子，在Nacos服务端的某个配置如下图：

为了支持配置变更和对应的实体类成员变量更新，对应客户端的配置文件是这样的：

spring.cloud.nacos.config.refresh-enabled=true
spring.cloud.nacos.config.shared-configs[0].data-id=shared.properties
spring.cloud.nacos.config.shared-configs[0].group=shared-conf
spring.cloud.nacos.config.shared-configs[0].refresh=true
复制代码

对应的配置属性Bean如下：

@Data@ConfigurationProperties(prefix = "shared")publicclassSharedProperties {

    private String foo; 
}
复制代码

只要客户端所在SpringBoot服务启动完成后，修改Nacos服务端对应dataId为shared.properties的shared.foo属性值，那边SharedProperties的foo属性就会准实时刷新。可以在SharedProperties添加一个@PostConstruct来观察这个属性更新的过程：

@Slf4j@Data@ConfigurationProperties(prefix = "shared")publicclassSharedProperties {

    privatefinalAtomicBooleanfirstInit=newAtomicBoolean();

    private String foo;

    @PostConstructpublicvoidpostConstruct() {
        if (!firstInit.compareAndSet(false, true)) {
            log.info("SharedProperties refresh...");
        } else {
            log.info("SharedProperties first init...");
        }
    }
}
复制代码

方案实施

整个方案实施包括下面几步：

  • 配置变更通知与配置类刷新

  • 发现所有消费者容器

  • 管理消费者容器生命周期

初始化一个Maven项目，引入下面的依赖：

  • org.projectlombok:lombok:1.18.12

  • org.springframework.boot:spring-boot-starter-web:2.3.0.RELEASE

  • org.springframework.boot:spring-boot-starter-amqp:2.3.0.RELEASE

  • com.alibaba.cloud:spring-cloud-alibaba-nacos-config:2.2.0.RELEASE

  • com.alibaba.nacos:nacos-client:1.4.4

下载Nacos服务并且启动一个单机实例（当前2023-02的最新稳定版为2.2.0），新建命名空间LOCAL并且添加四份配置文件：

可以使用1.x的Nacos客户端去连接2.x的Nacos服务端，这个是Nacos做的向下兼容，反过来不行

前文提到的Nacos客户端中，ConfigService是通过dataId和group定位到具体的配置文件，一般dataId按照配置文件的内容命名，对于SpringBoot的应用配置文件一般命名为application-${profile}.[properties,yml]，group是配置文件的分组，对于SpringBoot的应用配置文件一般命名为${spring.application.name}。笔者在在这份SpringBoot的应用配置文件中只添加了RabbitMQ的配置：

确保本地或者远程有一个可用的RabbitMQ服务，接下来往下开始实施方案。

配置变更通知与配置类刷新

前面已经提到过SpringBoot结合Nacos进行配置属性Bean的成员变量刷新，在项目的Classpath（resources文件夹）添加bootstrap.properties文件，内容如下：

spring.application.name=rabbitmq-rocketmq-demo
spring.profiles.active=default
# nacos配置
spring.cloud.nacos.config.enabled=true
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=LOCAL
spring.cloud.nacos.config.group=rabbitmq-rocketmq-demo
spring.cloud.nacos.config.prefix=application
spring.cloud.nacos.config.file-extension=properties
spring.cloud.nacos.config.refresh-enabled=true
spring.cloud.nacos.config.shared-configs[0].data-id=shared.properties
spring.cloud.nacos.config.shared-configs[0].group=shared-conf
spring.cloud.nacos.config.shared-configs[0].refresh=true
spring.cloud.nacos.config.extension-configs[0].data-id=extension.properties
spring.cloud.nacos.config.extension-configs[0].group=extension-conf
spring.cloud.nacos.config.extension-configs[0].refresh=true
spring.cloud.nacos.config.extension-configs[1].data-id=rabbitmq-toggle.properties
spring.cloud.nacos.config.extension-configs[1].group=rabbitmq-rocketmq-demo
spring.cloud.nacos.config.extension-configs[1].refresh=true
复制代码

这里profile定义为default也就是会关联到Nacos中dataId = 'application.properties', group = 'rabbitmq-rocketmq-demo'那份配置文件，主要是用于定义amqp需要的配置属性。对于RabbitMQ消费者的开关，定义在dataId = 'rabbitmq-toggle.properties', group = 'rabbitmq-rocketmq-demo'的文件中。添加RabbitmqToggleProperties：

// RabbitmqToggleProperties@Slf4j@Data@ConfigurationProperties(prefix = "rabbitmq.toggle")publicclassRabbitmqToggleProperties {

    privatefinalAtomicBooleanfirstInit=newAtomicBoolean();

    private List<RabbitmqConsumer> consumers;

    @PostConstructpublicvoidpostConstruct() {
        if (!firstInit.compareAndSet(false, true)) {
            StaticEventPublisher.publishEvent(newRabbitmqToggleRefreshEvent(this));
            log.info("RabbitmqToggleProperties refresh, publish RabbitmqToggleRefreshEvent...");
        } else {
            log.info("RabbitmqToggleProperties first init...");
        }
    }

    @DatapublicstaticclassRabbitmqConsumer {

        private String listenerId;

        private Integer concurrentConsumers;

        private Integer maxConcurrentConsumers;

        private Boolean enable;
    }
}

// RabbitmqToggleRefreshEvent@GetterpublicclassRabbitmqToggleRefreshEventextendsApplicationEvent {

    privatefinal RabbitmqToggleProperties rabbitmqToggleProperties;

    publicRabbitmqToggleRefreshEvent(RabbitmqToggleProperties rabbitmqToggleProperties) {
        super("RabbitmqToggleRefreshEvent");
        this.rabbitmqToggleProperties = rabbitmqToggleProperties;
    }
}

// StaticEventPublisherpublicclassStaticEventPublisher {

    privatestaticApplicationEventPublisherPUBLISHER=null;

    publicstaticvoidpublishEvent(ApplicationEvent applicationEvent) {
        if (Objects.nonNull(PUBLISHER)) {
            PUBLISHER.publishEvent(applicationEvent);
        }
    }

    publicstaticvoidattachApplicationEventPublisher(ApplicationEventPublisher publisher) {
        PUBLISHER = publisher;
    }
}
复制代码

这里prefix定义为rabbitmq.toggle，为了和rabbitmq-toggle.properties的属性一一绑定，该文件中的配置Key必须以rabbitmq.toggle为前缀。RabbitmqToggleProperties首次回调@PostConstruct方法只打印初始化日志，再次回调@PostConstruct方法则发布RabbitmqToggleRefreshEvent事件，用于后面通知对应的消费者容器Bean进行启停。

发现所有消费者容器

为了统一管理服务中所有消费者容器Bean，需要定义一个类似于消费者容器注册或者缓存中心类，缓存Key可以考虑使用listenerId，Value就直接使用MessageListenerContainer实例即可：

privatefinal ConcurrentMap<String, MessageListenerContainer> containerCache = Maps.newConcurrentMap();
复制代码
这里既然选定了listenerId作为缓存的Key，那么必须定义好规范，要求无论注解声明式定义的消费者还是编程式定义的消费者，必须明确指定具体意义的listenerId，否则到时候存在Key的格式为org.springframework.amqp.rabbit.RabbitListenerEndpointContainer#N会比较混乱

接下来发现和缓存所有消费者容器：

private ConfigurableListableBeanFactory configurableListableBeanFactory;

private ApplicationEventPublisher applicationEventPublisher;

// ----------------------------------------------------------------------// 获取声明式消费者容器RabbitListenerEndpointRegistryendpointRegistry= configurableListableBeanFactory.getBean(
        RabbitListenerConfigUtils.RABBIT_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME,
        RabbitListenerEndpointRegistry.class);
Set<String> listenerContainerIds = endpointRegistry.getListenerContainerIds();
for (String containerId : listenerContainerIds) {
    MessageListenerContainermessageListenerContainer= endpointRegistry.getListenerContainer(containerId);
    containerCache.putIfAbsent(containerId, messageListenerContainer);
}
// 获取编程式消费者容器
Map<String, MessageListenerContainer> messageListenerContainerBeans
        = configurableListableBeanFactory.getBeansOfType(MessageListenerContainer.class);
if (!CollectionUtils.isEmpty(messageListenerContainerBeans)) {
    messageListenerContainerBeans.forEach((beanId, bean) -> {
        if (bean instanceof AbstractMessageListenerContainer) {
            AbstractMessageListenerContainerabstractMessageListenerContainer= (AbstractMessageListenerContainer) bean;
            StringlistenerId= abstractMessageListenerContainer.getListenerId();
            if (StringUtils.hasLength(listenerId)) {
                containerCache.putIfAbsent(listenerId, abstractMessageListenerContainer);
            } else {
                containerCache.putIfAbsent(beanId, bean);
            }
        } else {
            containerCache.putIfAbsent(beanId, bean);
        }
    });
}
Set<String> listenerIds = containerCache.keySet();
listenerIds.forEach(listenerId -> log.info("Cache message listener container => {}", listenerId));
// 所有消费者容器Bean发现完成后才接收刷新事件
StaticEventPublisher.attachApplicationEventPublisher(this.applicationEventPublisher);
复制代码

StaticEventPublisher中的ApplicationEventPublisher属性延迟到所有消费者容器缓存完成后赋值，防止过早的属性变更通知导致部分消费者容器的启停操作被忽略。

管理消费者容器生命周期

接收到RabbitmqToggleRefreshEvent事件后，然后遍历传递过来的RabbitmqToggleProperties里面的consumers，再基于已经发现的消费者容器进行处理，代码大概如下：

@EventListener(classes = RabbitmqToggleRefreshEvent.class)publicvoidonRabbitmqToggleRefreshEvent(RabbitmqToggleRefreshEvent event) {
    RabbitmqTogglePropertiesrabbitmqToggleProperties= event.getRabbitmqToggleProperties();
    List<RabbitmqToggleProperties.RabbitmqConsumer> consumers = rabbitmqToggleProperties.getConsumers();
    if (!CollectionUtils.isEmpty(consumers)) {
        consumers.forEach(consumerConf -> {
            StringlistenerId= consumerConf.getListenerId();
            if (StringUtils.hasLength(listenerId)) {
                MessageListenerContainermessageListenerContainer= containerCache.get(listenerId);
                if (Objects.nonNull(messageListenerContainer)) {
                    // running -> stopif (messageListenerContainer.isRunning() && Objects.equals(Boolean.FALSE, consumerConf.getEnable())) {
                        messageListenerContainer.stop();
                        log.info("Message listener container => {} stop successfully", listenerId);
                    }
                    // modify concurrencyif (messageListenerContainer instanceof SimpleMessageListenerContainer) {
                        SimpleMessageListenerContainersimpleMessageListenerContainer= (SimpleMessageListenerContainer) messageListenerContainer;
                        if (Objects.nonNull(consumerConf.getConcurrentConsumers())) {
                            simpleMessageListenerContainer.setConcurrentConsumers(consumerConf.getConcurrentConsumers());
                        }
                        if (Objects.nonNull(consumerConf.getMaxConcurrentConsumers())) {
                            simpleMessageListenerContainer.setMaxConcurrentConsumers(consumerConf.getMaxConcurrentConsumers());
                        }
                    }
                    // stop -> runningif (!messageListenerContainer.isRunning() && Objects.equals(Boolean.TRUE, consumerConf.getEnable())) {
                        messageListenerContainer.start();
                        log.info("Message listener container => {} start successfully", listenerId);
                    }
                }
            }
        });
    }
}
复制代码

修改Nacos服务里面的rabbitmq-toggle.properties文件，输入内容如下：

rabbitmq.toggle.consumers[0].listenerId=MultiAnnoInstanceDemoConsumer-firstOnInstanceMessage
rabbitmq.toggle.consumers[0].enable=true
rabbitmq.toggle.consumers[1].listenerId=MultiAnnoInstanceDemoConsumer-secondOnInstanceMessage
rabbitmq.toggle.consumers[1].enable=true
rabbitmq.toggle.consumers[2].listenerId=MultiAnnoMethodDemoConsumer
rabbitmq.toggle.consumers[2].enable=true
rabbitmq.toggle.consumers[3].listenerId=SingleAnnoMethodDemoConsumer
rabbitmq.toggle.consumers[3].enable=true
rabbitmq.toggle.consumers[4].listenerId=CustomMethodDemoConsumer
rabbitmq.toggle.consumers[4].enable=true
rabbitmq.toggle.consumers[5].listenerId=MessageListenerDemoConsumer
rabbitmq.toggle.consumers[5].enable=true
复制代码

启动项目，观察RabbitMQ WebUI对应的队列消费者数量：

然后随机修改rabbitmq-toggle.properties文件某个消费者容器设置为enable = 'fasle'，观察服务日志和观察RabbitMQ WebUI的变化：

可见RabbitMQ WebUI中队列消费者数量减少，服务日志也提示listenerId = 'MessageListenerDemoConsumer'的消费者容器被停止了。

一些思考

为了更精确控制有消费者容器的启停，可以考虑在配置文件中定义关闭消费者容器的自动启动开关：

spring.rabbitmq.listener.simple.auto-startup=false
复制代码

可以考虑在RabbitmqToggleProperties首次回调@PostConstruct方法时候发布RabbitmqToggleInitEvent事件，然后监听此事件启动所有已经发现的消费者容器。这样就能做到应用内部的消费者的启停行为总是以Nacos的开关配置文件为准，并且可以实现在线启停和动态调整最小最大消费者数量。

另外，如果细心的话能够观察到服务日志中，每当监听到Nacos配置变动会打印Started application in N seconds (JVM running for M)的日志，这个并不是服务重启了，而是启动了一个Spring子容器用于构建一个全新的StandardEnvironment（见文末Demo项目中的EnvironmentCaptureApplicationRunner）用来承载刷新后的配置文件内容，然后再拷贝或者覆盖到当前的Spring容器中的PropertySources，这个过程的代码实现类似这样：

小结

本文探讨了一种通过Nacos配置刷新方式管理SpringBoot服务中RabbitMQ消费者生命周期管理的方案，目前只是提供了完整的思路和一些Demo级别代码，后续应该会完善方案和具体的工程级别编码实现。

本文Demo项目仓库：

职场面试官
关注
Springboot 实践（18）Nacos配置中心参数自动刷新测试
qq_37647812的博客
09-17 1132
Nacos配置中心，利用 @RefreshScope和@Value注解，在不重启服务的情况下，实现配置参数的自动更新
RabbitMq + Nacos整合
weixin_44404170的博客
10-29 4866
RabbitMq + Nacos整合 本文档只做简单使用整合，深入使用还需自行研究
【SpringCloud应用框架】Nacos服务消费者注册和负载均衡
最新发布
书写着,记录着,思考着,分享着,品味着,学习着。
07-06 1198
在上文中（【SpringCloud应用框架】Nacos安装和服务提供者注册）成功配置了Nacos服务提供者的注册，今天将配置服务消费者，同时来验证Nacos自带负载均衡。
window的rabbitmq在nacos的使用
weixin_40444253的博客
04-03 613
window的rabbitmq在nacos的使用
docker安装nacos，RabbitMQ
asgsmile的博客
05-31 498
docker安装nacos 下载 docker pull nacos/nacos-server 运行（使用standalone模式并开放8848端口，并映射配置文件和日志目录） docker run -d -p 8848:8848 -e MODE=standalone -v /opt/nacos/init.d:/home/nacos/init.d -v /opt/nacos/logs:/home/nacos/logs --restart always --name nacos nacos/nacos-ser
docker安装Nacos和Rabbitmq
青山猿的博客
12-24 1319
vim /mydata/nacos/init.d/custom.properties #修改配置文件。查看部署的mq容器id，在通过 docker exec -it 容器id /bin/bash。https：xx.xx.xx.xx:8848 账号：nacos 密码：nacos。首先需要拉取对应的镜像文件：（切换版本加上对应版本号即可，默认最新版）db.user=user #用户名。
Nacos配置中心原理分析
02-24
动态配置管理是Nacos的三大功能之一，通过动态配置服务，我们可以在所有环境中以集中和动态的方式管理所有应用程序或服务的配置信息。动态配置中心可以实现配置更新时无需重新部署应用程序和服务即可使相应的配置...
详解Spring Boot 配置多个RabbitMQ
08-30
通过使用 Spring Boot 的自动配置机制，我们可以轻松地配置多个 RabbitMQ 实例，并使用它们来发送和接收消息。本文详细介绍了如何在 Spring Boot 中配置多个 RabbitMQ 实例，并提供了相关的代码示例。
若依（ruoyi）导出的nacos配置文件
04-23
这使得 Ruoyi 应用能够根据 Nacos 中的配置信息进行自我调整，提高了应用的灵活性和可扩展性。导出的配置文件，如 `.metadata.yml` 和 `DEFAULT_GROUP`，包含了 Ruoyi 在运行时所需的关键配置信息，可能涉及到数据库...
rabbitMQ配置笔记
08-05
NULL 博文链接：https://xiayanghui.iteye.com/blog/2041077
nacosdemo：nacos配置演示消费者提供程序
02-14
纳科斯德莫 nacos配置演示消费者提供程序nacos注册中心生产者消费者配置动态修改nacos管理控制台编辑属性文件动态发布给业务系统 注意：nacos本地安装一个 （一）windows开发环境就单机模式启动就行，如下 startup.cmd -m standalone （二）作为配置中心过程 1约会nacos-config pom文件 2创建jdbc.properties配置nacos信息 3配置中心（nacos）增加规则 4给服务.properties中添加配置 5动态获取配置注解 @RefreshScope //动态获取并刷新配置 @Value（“ $ {配置项的名}”）
nginx代理nacos，rabbitMq
意识成长的博客
03-18 866
nginx代理nacos，rabbitMq背景解决 背景 客户生产部署，使用的是nacos，rabbitMq 这些中间件有页面维护，由于项目原因需要时常维护，问题来了，客户不给开这些 解决 部署时提出一个外网端口映射，这个端口低频 运维使用 接下来就是代理了 nacos代理 server { listen 10200; server_name localhost; #charset koi8-r; #access_log logs/host.access.log main; l
rabbitMq 直连模式实现多消费者轮询消费（一对多）
热爱技术，享受生活
07-29 2286
通过rabbitMq的直连模式（direct）来实现多个消费者对消息的轮询读取（一对多）
Spring Cloud Alibaba -3.Nacos服务消费者注册和负载均衡
飘然渡沧海的博客
04-24 769
Spring Cloud Alibaba Nacos服务消费者注册和负载均衡 创建一个消费者 pom <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org
消息队列4：rabbitmq的配置
火焰
04-18 9625
环境： centos8.2 RabbitMQ 3.8.8 Erlang 23.0 rabbitmq的安装参照： 《linux下安装rabbitmq》 本文参照：https://www.rabbitmq.com/configure.html rabbitmq的安装位置为： /usr/local/rabbitmq 一、rabbitmq的日志文件 rabbitmq的默认日志文件位置为： /usr/local/rabbitmq/var/log/rabbitmq/rabbit@*t.log，如下图所示：
Docker直接部署Nacos, RabbitMq，Redis，Nexus
zpg13579的博客
12-21 246
step1:docker pull nacos/nacos-server step2:docker run --name nacos -d -p 8848:8848 -e MODE=standalone nacos/nacos-server
使用nacos动态修改rabbitmq配置
06-13
使用Nacos动态修改RabbitMQ配置可以采用以下步骤： 1. 在Nacos上创建一个配置集和配置文件，例如命名为“rabbitmq.properties”。 2. 在配置文件中添加RabbitMQ的配置信息，例如： ``` rabbitmq.host=localhost rabbitmq.port=5672 rabbitmq.virtualHost=/ rabbitmq.username=guest rabbitmq.password=guest ``` 3. 在应用启动时，通过Nacos Config客户端加载配置文件，例如： ```java String dataId = "rabbitmq.properties"; String group = "DEFAULT_GROUP"; Properties properties = NacosConfigLoader.loadProperties(dataId, group); ``` 4. 在代码中使用RabbitMQ连接工厂，例如： ```java ConnectionFactory factory = new ConnectionFactory(); factory.setHost(properties.getProperty("rabbitmq.host")); factory.setPort(Integer.parseInt(properties.getProperty("rabbitmq.port"))); factory.setVirtualHost(properties.getProperty("rabbitmq.virtualHost")); factory.setUsername(properties.getProperty("rabbitmq.username")); factory.setPassword(properties.getProperty("rabbitmq.password")); ``` 5. 在Nacos上修改RabbitMQ的配置信息时，Nacos Config客户端会自动监听并更新配置信息，应用无需重启即可生效。 注意：使用Nacos动态修改RabbitMQ配置需要确保应用已经正确引入Nacos Config客户端，并且在应用启动时已经加载了配置文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值