SpringBoot 整合 RabbitMQ讲解

最新推荐文章于 2025-04-10 09:57:20 发布
最新推荐文章于 2025-04-10 09:57:20 发布
阅读量300 收藏 1
点赞数
文章标签： rabbitmq java spring cloud spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34374473/article/details/120370644
版权

RabbitMQ指令

# 服务启动相关
systemctl start|restart|stop|status rabbitmq-server

# 管理命令行，用来不使用web管理界面情况下命令操作RabbitMQ
rabbitmqctl help #可以查看更多命令

# 插件管理命令行
rabbitmq-plugins enable|list|disable
# disable 禁用  enable 启用

RabbitMQ生产和消费消息

第一种模型（直连）

一个生产者对应一个消费者

RabbitMQ生产消息
// 创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("8.142.28.95");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/ems");
connectionFactory.setUsername("wupan");
connectionFactory.setPassword("wupan");

// 获取连接对象
Connection connection = connectionFactory.newConnection();

// 获取连接通道
Channel channel = connection.createChannel();

// 通道和队列要绑定
// 参数1：队列名称，不存在自动创建
// 参数2：用来定义队列特性是否要持久化，true 持久化队列，false：不持久化
// 参数3：是否独占队列 true 独占队列；false：不独占
// 参数4 是否在消费完成自动删除队列；true：自动删除；false 不自动删除
// 参数5：额外附件参数
channel.queueDeclare("newhello",true,false,false,null);

// 参数1： 交换机名称
// 参数2：队列名称
// 参数3：传递消息额外设置
// 参数4：消息的具体内容
channel.basicPublish("","newhello",MessageProperties.PERSISTENT_TEXT_PLAIN,"服务重启，消息是否丢失".getBytes());

// 关闭通道
channel.close();
// 关闭连接
connection.close();
RabbitMQ消费消息
// 创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("8.142.28.95");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/ems");
connectionFactory.setUsername("wupan");
connectionFactory.setPassword("wupan");

// 获取连接对象
Connection connection = connectionFactory.newConnection();
// 获取连接通道
Channel channel = connection.createChannel();

// 通道绑定队列
// * 消费消息队列要和生产消息队列参数保持一致
channel.queueDeclare("newhello",true,false,false,null);

// 消费消息
// 参数1：消费队列名称
// 参数2：开启消息的自动确认机制
// 参数3：消费消息时，回调接口
channel.basicConsume("newhello", true, new DefaultConsumer(channel){
         @Override // 参数1：标签
           // 参数2 ： 信封
           // 参数4：消息队列中取出的消息
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("new String(body)=" + new String(body));
   	}
});
第二种模型（work queue）

默认情况下，work queue消费者消费消息时，进行循环消费

生产消息
// 获取连接
Connection connection = RabbitMQUtils.getConnection();
// 获取通道
Channel channel = connection.createChannel();

// 通过通道声明队列
channel.queueDeclare("work",true,false,false,null);

// 生产消息
for (int i = 0; i < 10; i++) {
  channel.basicPublish("","work",null,(i + "hello work queue").getBytes());
 }

RabbitMQUtils.closeConnectionAndChanel(channel,connection);
消费消息
// 消费者1
Connection connection = RabbitMQUtils.getConnection();

Channel channel = connection.createChannel();

channel.queueDeclare("work",true,false,false,null);

channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-1：" + new String(body));
            }
        });

// 消费者2
Connection connection = RabbitMQUtils.getConnection();

Channel channel = connection.createChannel();

channel.queueDeclare("work",true,false,false,null);

channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者-1：" + new String(body));
            }
});
消息确认机制，能者多劳，保证消息的消费的原子性和正确性
Connection connection = RabbitMQUtils.getConnection();

Channel channel = connection.createChannel();

channel.queueDeclare("work",true,false,false,null);

// 每次通道中只能放入一条消息
channel.basicQos(1);
// 参数2：true：自动确认；false：手动确认
channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者-1：" + new String(body));
                // 参数1：队列中消息的标识；参数2：true：批量确认；false：单个确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
});
第三种模型（fanout）
生产消息

fanout类型，直接发送消息给交换机

// 获取连接
Connection connection = RabbitMQUtils.getConnection();
Channel channel = connection.createChannel();

// 将通道申明指定的交换机
// 参数1： 交换机名称；参数2：交换机类型 fanout：广播类型
channel.exchangeDeclare("logs","fanout");

// 发送消息
channel.basicPublish("logs","",null,"fanout type message111".getBytes());

RabbitMQUtils.closeConnectionAndChanel(channel,connection);
消费消息

绑定交换机，创建临时队列，然后再通道中绑定交换机和队列，再从队列中取出消息

// 获取连接
Connection connection = RabbitMQUtils.getConnection();
// 获取通道对象
Channel channel = connection.createChannel();

// 通道绑定交换机
channel.exchangeDeclare("logs","fanout");
//临时队列
String queue = channel.queueDeclare().getQueue();

// 绑定交换机和队列
channel.queueBind(queue,"logs","");

channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1：" + new String(body));
            }
        });
第四种模型（drict）

生产者发送消息时，将交换机和路由key进行绑定，消费者消费消息时，要满足对应的key才能消费

第五种模型（topic）

生产者发送消息时，将交换机和路由key进行绑定，消费者消费消息时，可以通过动态路由key的方式进行消费

路由key必须是 user.add 的形式

消费者可以通过 user.* or user.# 的动态路由key进行消费

user.* 只能匹配 user.add，表示只能匹配一个单词

user.# 可以匹配 user，user.add，user.add.success等等，后面可以一直拼接，表示可以匹配0个或者多个单词

SpringBoot整合RabbitMQ模型
helloWorld模型

生产者

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringRunner.class)
class DemoApplicationTests {

    // 注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test () {
        // convertAndSend 发送消息
        // 参数1：队列名称；参数2： 消息内容
        rabbitTemplate.convertAndSend("hello_test","hello world");
    }
}

消费者

package com.example.demo;

import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class HelloCustomer {
	
    // RabbitListener监听队列名称：【hello_test】
    // RabbitListener可以注释在类上，也可以注释在方法上
    @RabbitListener(queuesToDeclare = @Queue("hello_test"))
    // RabbitHandler声明回调方法，方法名可以是任意的
    @RabbitHandler
    public void receiver (String message) {
        System.out.println("message = " + message);
    }

}
工作队列模型

生产者

package com.example.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringRunner.class)
public class DemoApplicationTests {

    // 注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testWork () {
        rabbitTemplate.convertAndSend("word","work模型");
    }
}

消费者

package com.example.demo.work;

import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class WorkConsumer {

    // 一个消费者
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receiver1 (String message){
        System.out.println("message1 = " + message);
    }

    // 一个消费者
    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receiver2 (String message){
        System.out.println("message2 = " + message);
    }
}
Fanout广播模式

生产者

package com.example.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringRunner.class)
public class DemoApplicationTests {

    // 注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    // fanout
    @Test
    public void testFanout() {
        rabbitTemplate.convertAndSend("exchange_logs","","springboot整合rabbitmq，发送fanout消息");
    }
}

消费者

package com.example.demo.fanout;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class HelloFanout {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,// 不指定名称，表示生成临时队列
                    exchange = @Exchange(value = "exchange_logs", type = "fanout") // value 交换机名称，type：发送消息类型
            )
    })
    public void receiver1(String message) {
        System.out.println("message1：" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,// 不指定名称，表示生成临时队列
                    exchange = @Exchange(value = "exchange_logs", type = "fanout") // value 交换机名称，type：发送消息类型
            )
    })
    public void receiver2(String message) {
        System.out.println("message2：" + message);
    }
}
Router路由模式

生产者

package com.example.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringRunner.class)
public class DemoApplicationTests {

    // 注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    // router
    @Test
    public void testRouter () {
        rabbitTemplate.convertAndSend("router_los","info","springboot整合rabbitmq，发送router消息【info】");
        rabbitTemplate.convertAndSend("router_los","error","springboot整合rabbitmq，发送router消息【error】");
    }
}

消费者

package com.example.demo.router;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class HelloRouter {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "router_los", type = "direct"),
                	// key可以指定要生产者发送要的对应的key的消息
                    key = {"info","warn","debugger"}
            )
    })
    public void receiver1 (String message) {
        System.out.println("message1：" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, // 不指定队列名称，表示生成临时队列
                    exchange = @Exchange(value = "router_los", type = "direct"),
                    key = {"error"}
            )
    })
    public void receiver2 (String message) {
        System.out.println("message2：" + message);
    }

}
Topic模式（动态路由）模式

生产者

package com.example.demo;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest(classes = DemoApplication.class)
@RunWith(SpringRunner.class)
public class DemoApplicationTests {

    // 注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    // topic
    @Test
    public void testTopic () {
        rabbitTemplate.convertAndSend("topic_logs","user.add.save","springboot整合rabbitmq，发送topic消息【user.add.save】");
    }
}

消费者

package com.example.demo.topic;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class HelloTopic {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "topic_logs", type = "topic"),
                	// #可以匹配多个
                    key = {"user.#"}
            )
    })
    public void receiver1 (String message) {
        System.out.println("message1：" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "topic_logs", type = "topic"),
                	// * 只能匹配到一个
                    key = {"user.*"}
            )
    })
    public void receiver2 (String message) {
        System.out.println("message2：" + message);
    }
}

RabbitMQ的应用场景

异步处理
应用解耦
流量削峰
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot整合RabbitMQ实现数据同步
m0_67595943的博客
05-09 968
[](()场景介绍 ================================================================== 假设某个电商系统中有商品服务负责MySQL中商品的增删改查，同时还有搜索服务负责Elasticsearch实现商品的搜索，Elasticsearch中的数据需要和MySQL中的数据进行同步。 这就需要两个服务之间进行通信，使用RabbitMQ可以实现。 业务流程： 商品服务对MySQL中的商品进行增删改 商品服务修改MySQL后，将修改商品的ID
【RabbitMQ笔记（四）】之Spring,SpringBoot整合RabbitMQ
开发小鸽
11-05 584
一． Spring整合RabbitMQ （一） 概述        所谓的用Spring来整合Rabbitmq，就是Rabbitmq所需要的一些配置先在配置文件中设置好，在代码中需要使用时直接注入到Spring容器中，这样就可以大大地减少代码量。 （二） Spring整合Rabbitmq生产者类 1. 导入依赖坐标        导入Spring的坐标，以及rabbitmq整合的相关坐标。 <dependen
springboot rabbitmq 自定义连接工厂
SevenLitile的博客
04-29 3430
springboot 使用 rabbitmq 1：使用默认的连接工厂，只需要在配置文件中配置全局参数即可 如 yml 文件的配置 spring: profiles: active: dev ########################## rabbitMq 配置 ################ rabbitmq: host: 127.0.0.1 post: 5672 username: guest password: guest .
SpringBoot配置Rabbitmq
最新发布
wste3567的博客
04-10 212
AcknowledgeMode.NONE：不确认，默认情况下消息消费者是NONE模式，默认所有消息消费成功。confirm机制：是当发送端的消息没有到达rabbitmq的交换机(exchange)时，会触发。return机制：当消息到达了交换机，但是又没有到达队列，那么就会触发。AcknowledgeMode.AUTO：自动确认，有客户端自动发送。AcknowledgeMode.MANUAL：手动确认。confirm机制和return机制。
RabbitMQ基础概念详细介绍
woailuohui的专栏
08-14 9318
RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务器端用Erl...
SpringBoot + RabbitMQ自定义ConnectionFacotry后，配置发送确认回调无效
雨潇的专栏
05-30 4669
问题现象 由于项目需要连接到多个RabbitMQ实例或者一个实例的多个vhost上，需要自定义配置多个ConnectionFactory来区分连接，以达到可以消费或者向多个RabbitMQ实例/多个vhost发送消息。手动配置ConnectionFactory后，发现原来配置的发送确认回调无效了，ConnectionFactory的配置如下， /** * 自定义RabbitMQ不同实例/不同vhost的ConnectionFactory * @param rabbitProperties 配置文件中ra
Spring Boot整合RabbitMQ
chinaherolts2008的博客
07-29 109
写在开头 最近在搭一套基于SpringBoot的项目，用到了ssm+mysql+rabbitmq+redis。除了rabbitmq之外，其他几个都很快整合好了，唯独rabbitmq找了不少资料，才最终整合好，达到了预期。特此将过程记录下来，供参考。 整合流程 整合流程中的代码都为整合的关键配置及其使用。至于SpringBoot的基本配置，请参考Spring Boot Quick Start。 配置文件 pom.xml <!-- rabbit-mq --> <dependency
Springboot整合RabbitMQ简单demo
01-22
本文将详细讲解如何在Spring Boot项目中整合RabbitMQ，并通过一个简单的示例来展示其实现过程。 首先，我们需要了解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理和队列服务器，遵循AMQP（Advanced Message ...
Spring Cloud商城项目专栏 034 RabbitMQ简介 安装 SpringBoot整合RabbitMQ框架搭建
10-24
为了更好地与Spring Boot应用集成，专栏还指导了如何配置Spring Boot与RabbitMQ的连接，展示了如何在Spring Boot项目中整合RabbitMQ框架，从而实现消息的生产与消费。 整合Spring Boot与RabbitMQ的过程涉及到Spring...
SpringBoot整合RabbitMQ实现数据同步，mysql数据库sql语句面试题
m0_64204730的博客
11-19 609
前言 ================================================================ 这篇文章主要介绍Rabbitmq的一个应用场景，以及如何使用SpringBoot进行整合。 场景介绍 ================================================================== 假设某个电商系统中有商品服务负责MySQL中商品的增删改查，同时还有搜索服务负责Elasticsearch实现商品的搜索，Elastics.
SpringBoot整合RabbitMQ
baobao的博客
07-08 842
本文从本人博客搬运，原文格式更加美观，可以移步原文阅读：SpringBoot整合RabbitMQ 基本整合 引入maven依赖 <!--amqp依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 全局配置文件
Spring Boot中集成 RabbitMQ
Dong滴个Dong的博客
01-20 222
SpringBoot 集成 RabbitMQ <!-- 在 pom 文件中添加 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId>...
Spring Boot整合RabbitMQ-RabbitMQ
抽象的螺旋
11-09 1893
概述 消息中间件的应用场景主要有：异步处理、应用解耦、流量削峰等。 参考 Spring Boot整合RabbitMQ详细教程
Springboot中使用RabbitMQ
Jessie
06-24 259
RabbitAdmin主要用于对队列进行管理，用于创建，绑定，删除队列与交换机，发送消息等。 1.RabbitMq配置类，配置连接工厂和对象
Springboot整合一之Springboot整合RabbitMQ
热门推荐
朱哲的博客
05-25 2万+
目前，springboot已然成为了最热的java开发整合框架，主要是因其简单的配置，并且本身提供了很多与第三方框架的整合，甚至可以让我们在短短的几分钟里就可以搭建一个完整的项目架构。所以，博主打算近期写一些springboot整合案例，也不知道先写哪个，那就从最近的写起吧，   言归正传。。。...
SpringBoot 系列 | 第十篇：使用RabbitMQ收发消息
wangjianfengnb
03-02 1万+
SpringBoot 系列 | 第十篇：使用RabbitMQ收发消息 本篇文章参考了官方文档:Messaging with RabbitMQ Spring Boot中使用RabbitQM需要机器安装好RabbitMQ。没有了解RabbitMQ的可以参考一下文章： RabbitMq使用 | 第一篇：安装和Hello World RabbitMq使用 | 第二篇：消息队列和确认 Rab...
Spring Boot集成RabbitMQ以及RabbitMQ的工作原理
weixin_43548310的博客
03-18 489
RabbitMQ的工作原理 RabbitMQ介绍 ： MQ全称为Message Queue，即消息队列；RabbitMQ由erlang语言开发，基于AMQP协议实现的消息队列； ：RabbitMQ的官网 常见的其它消息队列 ： ActiveMQ,ZeroMQ，Kafka，MetaMQ，RocketMQ、Redis(也可做消息队列) RabbitMQ优点介绍 ： 使用简单，功能强大（SpringBoot默认集成） 基于AMQP协议 社区活跃，文档完善 基于erlang语言，高并发性能好 RabbitMQ工
SpringBoot与RabbitMQ整合实践教程
首先会介绍如何将RabbitMQ软件上传至Linux服务器，接着详细阐述RabbitMQ的入门知识和工作模式，然后深入讲解Spring Boot整合RabbitMQ的步骤。本文还将探讨如何让Spring Boot应用中的RabbitMQ交换机与多个队列绑定，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值