RabbitMQ | SpringBoot集成RabbitMQ

一介草民丶

已于 2022-08-16 17:55:55 修改

阅读量479

点赞数

分类专栏： MQ消息队列 SpringBoot 文章标签： java-rabbitmq rabbitmq spring boot

于 2022-07-22 18:01:46 首次发布

本文链接：https://blog.csdn.net/qq825478739/article/details/125349211

版权

SpringBoot 同时被 2 个专栏收录

16 篇文章 3 订阅

订阅专栏

MQ消息队列

3 篇文章 0 订阅

订阅专栏

SpringBoot集成RabbitMQ

一、前言
二、项目
三、启动测试
四、有总结的不对的地方/或者问题请指正, 我在努力中

一、前言

该文章中主要对SpringBoot 集成RabbitMQ 主要是 application.properties 与 pom坐标就算集成完成，剩下的就是一些消费者 / 发布者的操作了详细的请看项目代码。

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

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

SpringBoot集成多个RabbitMQ: https://blog.csdn.net/qq825478739/article/details/125349200

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

二、项目

1. 项目结构

在这里插入图片描述

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.single</groupId>
    <artifactId>rabbitmq-single</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rabbitmq-single</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>
    </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.host=192.168.8.101
spring.rabbitmq.port=5672
spring.rabbitmq.username=user1
spring.rabbitmq.password=user1

# 最大重试次数（默认无数次）
spring.rabbitmq.listener.simple.retry.max-attempts=3
# 开启消费者重试（默认开启）
spring.rabbitmq.listener.simple.retry.enabled=true
# 重试间隔次数
spring.rabbitmq.listener.simple.retry.initial-interval=3000

4. 消息生产者

4.1 简单/work工作模式

队列创建

/**
 * 点对点 模式 配置
 *  简单模式     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;

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

    }

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

4.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;

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

4.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;

    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);
            }
        }
    }
}

4.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 {

    @Autowired
    private RabbitTemplate rabbitTemplate;

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

5. 消息消费者

5.1 简单/work工作模式

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

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

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

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

5.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)))
    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)))
    public void fanoutMsg2(String msg) {
        System.out.println("广播模式 2号 接收到消息 :" + msg);
    }
}

5.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"))
    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"))
    public void fanoutMsg2(String msg) {
        System.out.println("路由模式 2号 接收到消息 :" + msg);
    }
}

5.4 topic主题模式

/**
 * 工作模式 /简单模式 消费者
 * <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.#"))
    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.*"))
    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"))
    public void simpleMsg3(String msg) {
        System.out.println("topic模式 topic 接收到消息 :" + msg);
        //int i = 1 / 0;
        //消费者消费消息的时候，发生异常情况，导致消息未确认，该消息会被重复消费(默认没有重复次数，即无限循环消费)，但可以通过设置重试次数以及达到重试次数之后的消息处理
    }

}

6. 启动测试代码

/**
 * 启动 发送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();

    }
}

三、启动测试

在这里插入图片描述

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

一介草民丶

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
RabbitMQ | SpringBoot集成RabbitMQ

该文章中主要对SpringBoot集成RabbitMQ主要是application.properties与pom坐标就算集成完成，剩下的就是一些消费者/发布者的操作了详细的请看项目代码。代码有点多如果看不下去可以直接将项目拉下来参考RabbitMQ简介httpsSpringBoot集成多个RabbitMQhttpsDemo项目gitee地址httpshttpshttps。......
复制链接

扫一扫