RabbitMQ断链重连的配置

最新推荐文章于 2025-04-22 21:10:39 发布

懵懂

最新推荐文章于 2025-04-22 21:10:39 发布

阅读量6k

点赞数

分类专栏： java 文章标签： rabbitmq java

本文链接：https://blog.youkuaiyun.com/mengdong_zy/article/details/120200224

版权

java 专栏收录该内容

10 篇文章

订阅专栏

本文介绍如何在RabbitMQ中为生产者消费者连接和RabbitAdmin连接设置不同策略，确保网络恢复后自动创建并绑定队列。通过实例展示了在CalcRabbitMQConfig中创建两个连接工厂，一个用于RabbitAdmin，一个用于实际通信，从而解决自动创建队列的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

- 问题描述：

自动删除的队列在网络断开恢复后不能自动创建并绑定关系。

- 解决办法：

在RabbitMQConfig中分别声明两个连接工厂类，其中一个用于RabbitAdmin声明的连接，另一个用于生产者和消费者的连接。其中用于RabbitAdmin声明的连接不设置连接、通道、恢复的事件监听，用于生产者和消费者的连接需要设置连接、通道、恢复的事件监听，并且在通道监听事件“onCreate(Channel channel, boolean b)”方法中调用声明队列和绑定关系。

- 参考示例：

CalcRabbitMQConfig

package com.cdjdgm.calc.config.rabbitmq;

import com.cdjdgm.calc.component.rabbitmq.CalcRabbitEventListener;

import com.cdjdgm.calc.component.rabbitmq.CalcRabbitMessageConverter;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.amqp.rabbit.annotation.EnableRabbit;

import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;

import org.springframework.amqp.rabbit.connection.ConnectionFactory;

import org.springframework.amqp.rabbit.core.RabbitAdmin;

import org.springframework.amqp.rabbit.core.RabbitTemplate;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Primary;

import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import java.util.concurrent.atomic.AtomicInteger;

/**

* RabbitMQ配置类

* @author ZhaoYong

@Configuration

@EnableRabbit

@ConditionalOnBean(name = "calcRabbitMQProperties")

public class CalcRabbitMQConfig {

private final Logger logger = LoggerFactory.getLogger(getClass());

private final String prefix = "calc";

private final AtomicInteger connectionNameStrategyCounter1 = new AtomicInteger();

private final AtomicInteger connectionNameStrategyCounter2 = new AtomicInteger();

@Primary

@Bean(name = "calcRabbitConnectionFactory")

public CachingConnectionFactory calcRabbitConnectionFactory(CalcRabbitMQProperties calcRabbitMQProperties,//

CalcRabbitEventListener calcRabbitEventListener) {

CachingConnectionFactory connectionFactory = new CachingConnectionFactory();

if (calcRabbitMQProperties.getHost().contains(":")) {

connectionFactory.setAddresses(calcRabbitMQProperties.getHost());

} else {

connectionFactory.setHost(calcRabbitMQProperties.getHost());

connectionFactory.setPort(calcRabbitMQProperties.getPort());

}

connectionFactory.setUsername(calcRabbitMQProperties.getUsername());

connectionFactory.setPassword(calcRabbitMQProperties.getPassword());

connectionFactory.setVirtualHost(calcRabbitMQProperties.getVirtualHost());

connectionFactory.setPublisherReturns(calcRabbitMQProperties.getPublisherReturns());

connectionFactory.setPublisherConfirmType(calcRabbitMQProperties.getPublisherConfirmType());

connectionFactory.getRabbitConnectionFactory().setAutomaticRecoveryEnabled(true);

connectionFactory.getRabbitConnectionFactory().setTopologyRecoveryEnabled(true);

connectionFactory.getRabbitConnectionFactory().setNetworkRecoveryInterval(5000L);

connectionFactory.setConnectionThreadFactory(new CustomizableThreadFactory("calc-rabbitmq-"));

connectionFactory.addConnectionListener(calcRabbitEventListener);

connectionFactory.addChannelListener(calcRabbitEventListener);

connectionFactory.setRecoveryListener(calcRabbitEventListener);

connectionFactory.setConnectionNameStrategy(connectionFactory1 -> "[" + prefix + "]ConnectionFactory" + //

":" + connectionNameStrategyCounter1.getAndIncrement());

return connectionFactory;

}

@Bean(name = "calcRabbitConnectionFactoryAdmin")

public CachingConnectionFactory calcRabbitConnectionFactoryAdmin(CalcRabbitMQProperties calcRabbitMQProperties) {