RabbitMQ | SpringBoot集成多个RabbitMQ

已于 2022-08-16 17:56:12 修改
阅读量1.8k 收藏 10
点赞数 1
分类专栏： MQ消息队列 SpringBoot 文章标签： java-rabbitmq rabbitmq spring boot
于 2022-07-22 17:43:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq825478739/article/details/125349200
版权

SpringBoot集成多个RabbitMQ

一、前言

在开发过程中需要对接多个系统的RabbitMQ 连接，所以需要自己创建RabbitMQ连接, 以下demo 项目中用两个RabbitMQ 做了演示, 项目中包含了 五种模式的 消息发送以及消息接收

代码有点多 如果看不下去可以直接将项目拉下来参考

RabbitMQ 简介: https://blog.csdn.net/qq825478739/article/details/125932427

Demo项目gitee地址: https://gitee.com/yijiecaomin/springboot-rabbitmq-demo.git

二、 Demo项目

1. 项目整体

![在这里插入图片描述](https://img-blog.csdnimg.cn/43373d041655482ba0c7903229f508f2.png

2. 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/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.example</groupId>
        <artifactId>rabbitmq-demo-parent</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>com.rabbit.many</groupId>
    <artifactId>rabbitmq-many</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rabbitmq-many</name>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

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

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3. application.properties

####自定义默认MQ 连接
spring.rabbitmq.default-host=192.168.8.101
spring.rabbitmq.default-port=5672
spring.rabbitmq.default-username=user1
spring.rabbitmq.default-password=user1
## 自定义MQ2 配置
spring.rabbitmq.two-host=192.168.8.105
spring.rabbitmq.two-port=5672
spring.rabbitmq.two-username=zhkj
spring.rabbitmq.two-password=zhkj

4. MQProperties 自定义配置属性

@Data
@Configuration
@ConfigurationProperties(prefix = "spring.rabbitmq")
public class MQProperties {

    /**
     * 默认MQip
     */
    private String defaultHost;

    /**
     * 默认MQ端口
     */
    private Integer defaultPort;

    /**
     * 默认MQ用户名
     */
    private String defaultUsername;

    /**
     * 默认MQ密码
     */
    private String defaultPassword;

    /**
     * MQ2 ip
     */
    private String twoHost;

    /**
     * MQ2 端口
     */
    private Integer twoPort;

    /**
     * MQ2 用户名
     */
    private String twoUsername;

    /**
     * MQ2 密码
     */
    private String twoPassword;

}

5. MQFactoryConfig 配置 这里是核心哦

/**
 * MQ 工厂配置类
 *
 * @Author su
 * @Date 2022/7/22 11:36
 */
@Configuration
public class MQFactoryConfig {

    @Autowired
    private MQProperties rabbitMqProperties;

    //线程数量:根据实际的服务器性能进行配置即可
    public static final int DEFAULT_CONCURRENT = 10;
    //最大线程数
    public static final int MAX_CONCURRENT = 48;

    /**
     * 默认连接工厂
     *
     * @return
     */
    @Primary
    @Bean(name = "defaultConnectionFactory")
    public ConnectionFactory defaultConnectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(rabbitMqProperties.getDefaultHost());
        connectionFactory.setPort(rabbitMqProperties.getDefaultPort());
        connectionFactory.setUsername(rabbitMqProperties.getDefaultUsername());
        connectionFactory.setPassword(rabbitMqProperties.getDefaultPassword());
        return connectionFactory;
    }


    /**
     * 默认容器工厂
     *
     * @param configurer
     * @param connectionFactory
     * @return
     */
    @Primary
    @Bean(name = "defaultFactory")
    public SimpleRabbitListenerContainerFactory defaultFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer, @Qualifier("defaultConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        // 指定要创建的并发消费者数量   默认值为1
        factory.setConcurrentConsumers(DEFAULT_CONCURRENT);
        // 设置消费者数量的上限
        factory.setMaxConcurrentConsumers(MAX_CONCURRENT);
        // 自动应答
        // factory.setAcknowledgeMode(AcknowledgeMode.AUTO);
        //消息转换器
        //factory.setMessageConverter(new Jackson2JsonMessageConverter());
        //启动事务模式
        //factory.setChannelTransacted(true);
        //设置重试
        factory.setAdviceChain(createRetry());
        configurer.configure(factory, connectionFactory);
        return factory;
    }

    /**
     * 创建重试
     *
     * @return
     */
    private RetryOperationsInterceptor createRetry() {
        RetryTemplate retryTemplate = new RetryTemplate();

        ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
        backOffPolicy.setInitialInterval(3000); // 重试间隔
        backOffPolicy.setMaxInterval(6000); // 重试最大间隔
        //backOffPolicy.setMultiplier(2000);// 重试间隔乘法策略
        retryTemplate.setBackOffPolicy(backOffPolicy);

        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
        retryPolicy.setMaxAttempts(3);
        retryTemplate.setRetryPolicy(retryPolicy);
        return RetryInterceptorBuilder.stateless().retryOperations(retryTemplate).recoverer(new RejectAndDontRequeueRecoverer()).build();
    }

    /**
     * 默认RabbitTemplate操作类
     *
     * @param connectionFactory
     * @return
     */
    @Primary
    @Bean(name = "defaultTemplate")
    public RabbitTemplate defaultTemplate(@Qualifier("defaultConnectionFactory") ConnectionFactory connectionFactory) {
        return new RabbitTemplate(connectionFactory);
    }

    @Primary//这个注解一定要加 Rabbitmq需要一个默认的 工厂
    @Bean(name = "defaultRabbitAdmin")
    public RabbitAdmin defaultRabbitAdmin(@Qualifier("defaultConnectionFactory") ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }

    /**
     * MQ 2 连接工厂
     *
     * @return
     */
    @Bean(name = "twoConnectionFactory")
    public ConnectionFactory MergeConnectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(rabbitMqProperties.getTwoHost());
        connectionFactory.setPort(rabbitMqProperties.getTwoPort());
        connectionFactory.setUsername(rabbitMqProperties.getTwoUsername());
        connectionFactory.setPassword(rabbitMqProperties.getTwoPassword());
        return connectionFactory;
    }

    /**
     * MQ 2 容器工厂
     *
     * @param configurer
     * @param connectionFactory
     * @return
     */
    @Bean(name = "twoFactory")
    public SimpleRabbitListenerContainerFactory LocalFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer, @Qualifier("twoConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        //设置线程数量
        factory.setConcurrentConsumers(DEFAULT_CONCURRENT);
        factory.setMaxConcurrentConsumers(MAX_CONCURRENT);
        configurer.configure(factory, connectionFactory);
        return factory;
    }

    /**
     * MQ 2 操作类
     *
     * @param connectionFactory
     * @return
     */
    @Bean(name = "twoTemplate")
    public RabbitTemplate TwoTemplate(@Qualifier("twoConnectionFactory") ConnectionFactory connectionFactory) {
        return new RabbitTemplate(connectionFactory);
    }

    @Bean(name = "twoRabbitAdmin")
    public RabbitAdmin twoRabbitAdmin(@Qualifier("twoConnectionFactory") ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }
}

6. 消息生产者代码

6.1 简单模式 /工作模式 发布者

创建队列

/**
 * 点对点 模式 配置
 *  简单模式     work工作模式
 *
 * @Author su
 * @Date 2022/7/21 15:50
 */
@Configuration
public class SimpleWorkRabbitMQConfig {

    /**
     * 简单队列  一个发布者 ->队列 -> 一个消费者
     *
     *  一个消费者消费队列中消息
     *
     * @return
     */
    @Bean
    public Queue simpleQueue(){
        return new Queue("simple.demo",true);
    }

    /**
     * 工作队列 : 一个发布者 -> 队列 -> 多个消费者
     * 工作模式与简单模式 只是消费者的数量问题 比如说将 队列当做一个快递站  消费者是快递员 将消息分发给大家来处理
     *
     * @return
     */
    @Bean
    public Queue workQueue(){
        return new Queue("work.demo",true);
    }

}

创建消息生产服务

/**
 * 简单模式 / 工作模式 发送者
 *
 * @Author su
 * @Date 2022/7/21 15:55
 */
@Component
public class SimpleWorkMQProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 另个RabbitTemplate  需要用这个发送 就使用这个
     */
    @Resource(name = "twoTemplate")
    private RabbitTemplate twoTemplate;


    /**
     * 发送简单 MQ
     */
    public void sendSimpleMq() {
        for (int i = 1; i <= 3; i++) {
            rabbitTemplate.convertAndSend("simple.demo", "发送简单消息内容: 简单简单简单 :" + i);
        }

    }

    /**
     * 发送工作 MQ
     */
    public void sendWorkMq() {
        for (int i = 1; i <= 10; i++) {
            rabbitTemplate.convertAndSend("work.demo", "发送工作消息内容: 工作工作简单 :" + i);
        }
    }
}

6.2 Fanout 广播模式 发布者

创建交换机: 发布订阅模式 发布者不需要创建队列

/**
 * 广播模式创建交换机
 *
 * @Author su
 * @Date 2022/7/21 17:43
 */
@Configuration
public class FanoutRabbitMQConfig {

    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout.exchange.demo", true, false);
    }

}

创建消息生产服务

/**
 * 广播模式发送消息
 *
 * @Author su
 * @Date 2022/7/21 17:47
 */
@Component
public class FanoutMQProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Resource(name = "twoTemplate")
    private RabbitTemplate twoTemplate;

    public void sendFanoutMq() {
        for (int i = 0; i < 5; i++) {
            rabbitTemplate.convertAndSend("fanout.exchange.demo", null, "Fanout 消息来了 :" + i);
        }
    }
}

6.3 Routing 路由模式 发布者

创建交换机: 发布订阅模式 发布者不需要创建队列

/**
 * 路由 配置类
 * 1.创建交换机
 * 2.绑定路由
 *
 * @Author su
 * @Date 2022/7/21 18:03
 */
@Configuration
public class RoutingRabbitMQConfig {

    /**
     * 交换机
     *
     * @return
     */
    @Bean
    public DirectExchange getDirectExchange() {
        //return new DirectExchange("routing.rabbit.demo",true,false);
        return ExchangeBuilder.directExchange("routing.exchange.demo").durable(true).build();
    }

}

创建消息生产服务

/**
 * 广播模式发送消息
 *
 * @Author su
 * @Date 2022/7/21 17:47
 */
@Component
public class RoutingMQProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Resource(name = "twoTemplate")
    private RabbitTemplate twoTemplate;

    public void sendRoutingMq() {
        for (int i = 0; i < 5; i++) {
            if (i % 2 == 0) {
                rabbitTemplate.convertAndSend("routing.exchange.demo", "routing.msg.2", "Routing 消息来了 :" + i);
            } else {
                rabbitTemplate.convertAndSend("routing.exchange.demo", "routing.msg.1", "Routing 消息来了 :" + i);
            }
        }
    }
}

6.4 Topic 主题模式 发布者

创建交换机: 发布订阅模式 发布者不需要创建队列

/**
 * topic 模式
 *
 * @Author su
 * @Date 2022/7/22 10:01
 */
@Configuration
public class TopicRabbitMQConfig {

    /**
     * topic 交换机
     *
     * @return
     */
    @Bean
    public TopicExchange getTopicExchange() {
        return ExchangeBuilder.topicExchange("topic.exchange.demo").durable(true).build();
    }
}

创建消息生产服务

/**
 * 广播模式发送消息
 *
 * @Author su
 * @Date 2022/7/21 17:47
 */
@Component
public class TopicMQProducer {

    @Resource(name = "defaultTemplate")
    private RabbitTemplate rabbitTemplate;

    @Resource(name = "twoTemplate")
    private RabbitTemplate twoTemplate;

    public void sendTopicMq() {
        for (int i = 0; i < 5; i++) {
            rabbitTemplate.convertAndSend("topic.exchange.demo", "topic.demo", "Topic 消息来了 :" + i);
        }
    }
}

7.消费者代码

7.1 简单模式 /工作模式 消费者

/**
 * 工作模式 /简单模式 消费者
 * <p>
 * 需要注意 :消费者消费消息的时候，发生异常情况，导致消息未确认，该消息会被重复消费(默认没有重复次数，即无限循环消费)，但可以通过设置重试次数以及达到重试次数之后的消息处理
 *
 * @Author su
 * @Date 2022/7/21 16:06
 */
@Component
public class SimpleWorkMQConsumer {

    /**
     * 简单模式 消费者
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(queues = "simple.demo",containerFactory = "defaultFactory")
    public void simpleMsg(String msg) {
        System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()) +" 简单模式 接收到消息 :" + msg);
          //int i = 1 / 0;
        //消费者消费消息的时候，发生异常情况，导致消息未确认，该消息会被重复消费(默认没有重复次数，即无限循环消费)，但可以通过设置重试次数以及达到重试次数之后的消息处理
    }

    /**
     * 工作模式 消费者1号
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(queues = "work.demo",containerFactory = "defaultFactory")
    public void workMsg1(String msg) {
        System.out.println("工作模式 1号工作者接收到消息 :" + msg);
    }

    /**
     * 工作模式 消费者2号
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(queues = "work.demo",containerFactory = "defaultFactory")
    public void workMsg2(String msg) {
        System.out.println("工作模式 2号工作者接收到消息 :" + msg);
    }
}

7.2 Fanout 广播模式 消费者

/**
 * 广播模式 消费者
 *
 * @Author su
 * @Date 2022/7/21 17:52
 */
@Component
public class FanoutMQConsumer {

    /**
     * 广播模式 消费者1号
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(value = @Queue(value = "fanout.queue.demo"), exchange = @Exchange(value = "fanout.exchange.demo", type = ExchangeTypes.FANOUT)),containerFactory = "defaultFactory")
    public void fanoutMsg(String msg) {
        System.out.println("广播模式 1号 接收到消息 :" + msg);
    }

    /**
     * 广播模式 消费者2号
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(value = @Queue(value = "fanout.queue.demo2"), exchange = @Exchange(value = "fanout.exchange.demo", type = ExchangeTypes.FANOUT)),containerFactory = "defaultFactory")
    public void fanoutMsg2(String msg) {
        System.out.println("广播模式 2号 接收到消息 :" + msg);
    }
}

7.3 Routing 路由模式 消费者

/**
 * 路由模式 消费者
 *
 * @Author su
 * @Date 2022/7/21 17:52
 */
@Component
public class RoutingMQConsumer {

    /**
     * 广播模式 消费者1号
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(value = @Queue(value = "routing.queue.demo"), exchange = @Exchange(value = "routing.exchange.demo", type = ExchangeTypes.DIRECT),key = "routing.msg.1"),containerFactory = "defaultFactory")
    public void fanoutMsg(String msg) {
        System.out.println("路由模式 1号 接收到消息 :" + msg);
    }

    /**
     * 广播模式 消费者2号
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(value = @Queue(value = "routing.queue.demo2"), exchange = @Exchange(value = "routing.exchange.demo", type = ExchangeTypes.DIRECT),key = "routing.msg.2"),containerFactory = "defaultFactory")
    public void fanoutMsg2(String msg) {
        System.out.println("路由模式 2号 接收到消息 :" + msg);
    }
}

7.4 Topic 主题模式 消费者

/**
 * 工作模式 /简单模式 消费者  containerFactory指向那个工厂
 * <p>
 * 需要注意 :消费者消费消息的时候，发生异常情况，导致消息未确认，该消息会被重复消费(默认没有重复次数，即无限循环消费)，但可以通过设置重试次数以及达到重试次数之后的消息处理
 *
 * @Author su
 * @Date 2022/7/21 16:06
 */
@Component
public class TopicMQConsumer {

    /**
     * 简单模式 消费者  TODO 可以收到 #多个单词模糊匹配   发送者的路由是:topic.demo
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(value = @Queue("topic.queue.demo1"), exchange = @Exchange(name = "topic.exchange.demo", type = ExchangeTypes.TOPIC), key = "topic.#"), containerFactory = "defaultFactory")
    public void simpleMsg1(String msg) {
        System.out.println("topic模式 topic.# 接收到消息 :" + msg);
        //int i = 1 / 0;
        //消费者消费消息的时候，发生异常情况，导致消息未确认，该消息会被重复消费(默认没有重复次数，即无限循环消费)，但可以通过设置重试次数以及达到重试次数之后的消息处理
    }

    /**
     * 简单模式 消费者  //TODO 可以收到 单个单词 *模糊匹配   发送者的路由是:topic.demo
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(value = @Queue("topic.queue.demo2"), exchange = @Exchange(name = "topic.exchange.demo", type = ExchangeTypes.TOPIC), key = "topic.*"), containerFactory = "defaultFactory")
    public void simpleMsg2(String msg) {
        System.out.println("topic模式 topic.* 接收到消息 :" + msg);
        //int i = 1 / 0;
        //消费者消费消息的时候，发生异常情况，导致消息未确认，该消息会被重复消费(默认没有重复次数，即无限循环消费)，但可以通过设置重试次数以及达到重试次数之后的消息处理
    }

    /**
     * 简单模式 消费者  //TODO 这个路由key为 topic 是收不到消息的  发送者的路由是:topic.demo
     *
     * @param msg
     */
    @RabbitHandler
    @RabbitListener(bindings = @QueueBinding(value = @Queue("topic.queue.demo3"), exchange = @Exchange(name = "topic.exchange.demo", type = ExchangeTypes.TOPIC), key = "topic"), containerFactory = "defaultFactory")
    public void simpleMsg3(String msg) {
        System.out.println("topic模式 topic 接收到消息 :" + msg);
        //int i = 1 / 0;
        //消费者消费消息的时候，发生异常情况，导致消息未确认，该消息会被重复消费(默认没有重复次数，即无限循环消费)，但可以通过设置重试次数以及达到重试次数之后的消息处理
    }
}

8. 测试验证代码

这里写了个 SpringBoot 启动运行的方法 测试验证

/**
 * 启动 发送MQ 的类
 *
 * @Author su
 * @Date 2022/7/21 16:14
 */
@Component
public class RabbitMqDemoStarter implements ApplicationRunner {

    @Autowired
    private SimpleWorkMQProducer simpleWorkMQProducer;
    @Autowired
    private FanoutMQProducer fanoutMQProducer;
    @Autowired
    private RoutingMQProducer routingMQProducer;
    @Autowired
    private TopicMQProducer topicMQProducer;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("Simple---------------------------------");
        simpleWorkMQProducer.sendSimpleMq();

        Thread.sleep(5000);
        System.out.println("Work---------------------------------");
        simpleWorkMQProducer.sendWorkMq();

        Thread.sleep(5000);
        System.out.println("Fanout---------------------------------");
        fanoutMQProducer.sendFanoutMq();

        Thread.sleep(5000);
        System.out.println("Routing---------------------------------");
        routingMQProducer.sendRoutingMq();

        Thread.sleep(5000);
        System.out.println("Topic---------------------------------");
        topicMQProducer.sendTopicMq();
    }
}

三、启动验证

在这里插入图片描述

四、重点注意总结

有总结的不对的地方/或者问题 请指正, 我在努力中

TODO 需要重点注意

  1. 消费者消费消息的时候，发生异常情况，导致消息未确认，该消息会被重复消费(默认没有重复次数，即无限循环消费)，但可以通过设置重试次数以及达到重试次数之后的消息处理

  2. 当用注解 @RabbitListener 指向非默认数据源@Primary containerFactory = “其他数据源” 注解不会自动创建新的队列,会报找不到 队列的错误,暂时我只知道手动创建的解决方案 有其他的求评论 告知一下
    手动创建方案: 请查看 OtherQueueMqConfig 这个配置手动创建
    不会自动创建的例子:@RabbitListener(bindings = @QueueBinding(value = @Queue(“新队列名”), exchange = @Exchange(name = “指定交换机”, type = ExchangeTypes.TOPIC), key = “路由”), containerFactory = “其他数据源”)

  3. 在创建工厂的时候一定要使用 @Primary 这个注解，RabbitMQ会根据类型注入所以需要一个默认的主数据源 不然会报错: required a single bean, but 2 were found

OtherQueueMqConfig

/**
 * 其他数据源队列创建配置
 *
 * @Author su
 * @Date 2022/7/28 11:52
 */
@Configuration
public class OtherQueueMqConfig {

    @Resource()
    private RabbitAdmin rabbitAdmin;

    @Bean
    void EcuOperationLogQueueDirect() {
        //新队列
        Queue queue = QueueBuilder.durable("new.test").build();
        rabbitAdmin.declareQueue(queue);
        DirectExchange directExchange = new DirectExchange("testExchange",true,false);
        rabbitAdmin.declareExchange(directExchange);
        rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(directExchange).with("testRouting"));
    }
}
一介草民丶
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解Spring Boot 配置多个RabbitMQ
08-30
本篇文章主要介绍了Spring Boot 配置多个RabbitMQ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot连接多个RabbitMQ
yuhuofei的草屋
10-03 3784
SpringBoot连接多个RabbitMQ，重写配置，重写连接工厂
SpringBoot集成RabbitMQ配置多数据源
最新发布
qq_26432153的博客
03-07 531
SpringBoot集成rabbitmq，并配置多个rabbitmq数据源，并测试
SpringBoot 集成多个rabbitmq
lisheng19870305的专栏
08-24 1095
SpringBoot 集成多个rabbitmq 在项目中经常遇到一个springboot工程要连接多个rabbitmq。如果只连接一个，springboot可以零配置连接rabbitmq，这样不需要做额外的工作。但如果连接多个rabbitmq，就得做一些配置了。 1 配置多个rabbitmq的连接地址： spring.rabbitmq.first.host=192.168.10.223 spring.rabbitmq.first.port=5672 spring.rabbitmq.first.use.
详解spring boot集成RabbitMQ
08-30
RabbitMQ作为AMQP的代表性产品，在项目中大量使用。结合现在主流的spring boot，极大简化了开发过程中所涉及到的消息通信问题。
Springboot.rar
09-20
7、集成RabbitMQ 8、SpringBoot项目linux服务器部署 9、整合Swagger2（文档生成工具） 10、整合JavaMelody（性能监控工具） 11、实用功能SpringBoot热部署 12、实用功能SpringBoot定时器 13、实用功能SpringBoot随...
SpringBootLearning_forezp.tar.gz
10-20
SpringBoot非官方教程 | 第十一篇：springboot集成swagger2，构建优雅的Restful API SpringBoot非官方教程 | 第十二篇：springboot集成apidoc 缓存篇 SpringBoot非官方教程 | 第十三篇：springboot集成spring ...
Springboot核心技术栈(附Demo源码).zip
07-03
Springboot集成RabbitMQ Springboot 定时任务 Springboot邮件发送 Springboot 集成MongoDB springboot框架本身的一个原因，现在企业中使用springboot越来越多，企业对于求职者对springboot框架的学习程度要求越来越...
SpringBoot整合多个RabbitMQ
huan的学习记录
08-06 2629
一、背景 ​ 最近项目中需要用到了RabbitMQ来监听消息队列，监听的消息队列的 虚拟主机(virtualHost)和队列名(queueName)是不一致的，但是接收到的消息格式相同的。而且可能还存在程序不停机的情况下，动态的增加新的队列(queue)的监听，因此就需要我们自己在程序中实现一种方法实现动态配置RabbitMQ。 二、需求 我们有2个RabbitMQ的配置，在程序启动的时候，动态的配置好这2个RabbitMQ，实现消息的监听。 RabbitMQ的配置信息 host port u
SpringBoot项目配置多个RabbitMQ解决方案
whereabouts_的博客
12-01 2786
目前有一个Spring Boot项目，已经接入一个RabbitMQ Broker，由于业务扩展，需要新增一个RabbitMQ Broker进行消费，由于单个Broker时通过Spring默认配置进行使用，因此需要做出修改。
springboot集成多个rabbitmq
06-28 252
springboot版本：1.5.19.RELEASE Gradle版本：4.10 Gradle的build.gradle中增加引入 Java代码 compile('org.springframework.boot:spring-boot-starter-amqp') application.yaml中增加配置 Yaml代码 buddie: rabbitmq: consume: host: 127.0.0.1 port: 5672...
SpringBoot连接多RabbitMQ源
PacosonSWJTU的博客
03-21 1582
转自： SpringBoot连接多RabbitMQ源 - 掘金在实际开发中，很多场景需要异步处理，这时就需要用到RabbitMQ，而且随着场景的增多程序可能需要连接多个RabbitMQ。SpringBoot本身提供了默认的配置可以快速配置连接RabbitMQ，但是只能连接一个RabbitMQ，当需要连接多个RabbitMQ时，默认的配置就…https://juejin.cn/post/6844904039797243917 在实际开发中，很多场景需要异步处理，这时就需要用到RabbitMQ，而且随着场景
Spring Boot 配置多源的 RabbitMQ
innerpeacez成长之路
07-19 2060
Spring Boot 配置多源的 RabbitMQ
SpringBoot实现多rabbitmq连接
Serendipity_77的博客
07-21 1145
也可放到一个类中测试消费。
SpringBoot配置多个RabbitMQ
Eddie-Wang的博客
06-04 3181
1.application.yml spring: rabbitmq: hospSync: host: localhost port: 5672 username: test password: test virtual-host: test pay: host: ...
SpringBoot配置多个RabbitMq
热门推荐
Good Luck
04-26 9万+
YML rabbitmq: first: username: ${app.appkey} password: ${app.appkey} virtual-host: ${app.appid} addresses: x.x.x.x:5672,x.x.x.x:5672 second: username: guest password: guest virtual-host: / host: 12
springboot添加rabbitmq
09-14
在Spring Boot中添加RabbitMQ的步骤如下： 1. 添加依赖：在`pom.xml`文件中，添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 配置RabbitMQ连接：在`application.properties`或`application.yml`文件中，添加以下配置信息： ```properties spring.rabbitmq.host=your_host spring.rabbitmq.port=your_port spring.rabbitmq.username=your_username spring.rabbitmq.password=your_password ``` 替换`your_host`、`your_port`、`your_username`和`your_password`为你的RabbitMQ服务器的相关信息。 3. 创建消息生产者：创建一个类来定义消息的发送。可以使用`AmqpTemplate`接口提供的方法来发送消息。 ```java import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class RabbitMQProducer { @Autowired private AmqpTemplate amqpTemplate; public void sendMessage(String exchange, String routingKey, Object message) { amqpTemplate.convertAndSend(exchange, routingKey, message); } } ``` 4. 创建消息消费者：创建一个类来处理接收到的消息。可以使用`@RabbitListener`注解来监听特定的队列，并处理接收到的消息。 ```java import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class RabbitMQConsumer { @RabbitListener(queues = "your_queue_name") public void receiveMessage(Object message) { // 处理接收到的消息 } } ``` 替换`your_queue_name`为你要监听的队列名称。 现在，你可以在其他类中使用`RabbitMQProducer`来发送消息，同时在`RabbitMQConsumer`中处理接收到的消息。 这就是在Spring Boot中添加RabbitMQ的基本步骤。你还可以进一步了解RabbitMQ的高级用法和配置，例如设置交换机、队列和绑定等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一介草民丶

谢谢老板的一分钱

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值