rabbitMQ在springboot中的使用

最新推荐文章于 2025-06-09 10:46:13 发布
最新推荐文章于 2025-06-09 10:46:13 发布
阅读量1k 收藏 3
点赞数 3
CC 4.0 BY-SA版权
分类专栏： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wangyunzhao007/article/details/103945071
本文详细介绍如何在SpringBoot项目中整合RabbitMQ，包括项目搭建、配置文件编写、消费者和生产者代码实现，以及实体类和测试类的创建。

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

1.建立springboot项目，并引入依赖

打开idea，点击File-New-Project，选择下图红色框中的

点击Next，出现下图，可以改名，也可以不改，我的是改了名字的

然后点击下一步，在搜索框输入rabbit

选择红色框中的选项，然后在选择右侧的Messageing，将Spring for RabbitMQ打上对勾。这样springboot会把rabbitmq的依赖自动导入

最后生成的依赖项是对的，但是我没有在test文件夹下的测试类中，是在src的路径写的测试，还需要一些其他依赖。pom文件全部依赖如下

 <dependencies>

        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
        </dependency>

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

2.编写配置文件

#ip地址和端口号
spring.rabbitmq.addresses=192.168.157.129:5672
#登录rabbit的账号和密码
spring.rabbitmq.username=zhao
spring.rabbitmq.password=123
#虚拟机器名称
spring.rabbitmq.virtual-host=/
spring.rabbitmq.connection-timeout=15000

#监听这设置
spring.rabbitmq.listener.simple.acknowledge-mode=manual
spring.rabbitmq.listener.simple.concurrency=5
spring.rabbitmq.listener.simple.max-concurrency=10

#队列交换机设置
spring.rabbitmq.listener.order.queue.name = queue-2
spring.rabbitmq.listener.order.queue.durable=true
spring.rabbitmq.listener.order.exchange.name=exchange-2
spring.rabbitmq.listener.order.exchange.durable=true
spring.rabbitmq.listener.order.exchange.type=topic
spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions=true
spring.rabbitmq.listener.order.key=springboot.*

例子概图

3.消费者

package com.example.demo.consumer;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.Message;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;

import java.util.Map;


@Component
public class RabbitRecever {

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "queue-1", declare = "true"),
            exchange = @Exchange(value = "exchange-1",
                    declare = "true",
                    durable = "true", type = "topic",
                    ignoreDeclarationExceptions = "true"),
            key = "springboot.*"
    )
    )
    @RabbitHandler
    public void onMessage(Message message, Channel channel) throws Exception {
        System.out.println("-----------------------------------------");
        System.out.println("消费端Payload：" + message.getPayload());
        long deliveryTag = (Long) message.getHeaders().get(AmqpHeaders.DELIVERY_TAG);

        //手工ack
        channel.basicAck(deliveryTag, false);
    }


//    spring.rabbitmq.listener.order.queue.name = queue-1
//    spring.rabbitmq.listener.order.queue.durable=true
//    spring.rabbitmq.listener.order.exchange.name=exchange-1
//    spring.rabbitmq.listener.order.exchange.durable=true
//    spring.rabbitmq.listener.order.exchange.type=topic
//    spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions=true
//    spring.rabbitmq.listener.order.key=springboot.*

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "${spring.rabbitmq.listener.order.queue.name}",
                    declare = "${spring.rabbitmq.listener.order.queue.durable}"),
            exchange = @Exchange(value = "${spring.rabbitmq.listener.order.exchange.name}",
                    durable = "${spring.rabbitmq.listener.order.exchange.durable}",
                    type = "${spring.rabbitmq.listener.order.exchange.type}",
                    ignoreDeclarationExceptions = "${spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions}"),
            key = "${spring.rabbitmq.listener.order.key}"
    )
    )
    @RabbitHandler
    public void onOrderMessage(@Payload com.example.demo.entity.Order order, Channel channel,
                               @Headers Map<String, Object> headers) throws Exception {
        System.out.println("-----------------------------------------");
        System.out.println("消费端order：" + order.getId());
        long deliveryTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);

        //手工ack
        channel.basicAck(deliveryTag, false);
    }
}

4.生产者

package com.example.demo;

import com.example.demo.entity.Order;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback;
import org.springframework.amqp.rabbit.core.RabbitTemplate.ReturnCallback;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

import java.util.Map;


@Component
public class RabbitSender {

	//自动注入RabbitTemplate模板类
	@Autowired
	private RabbitTemplate rabbitTemplate;  
	
	//回调函数: confirm确认
	final ConfirmCallback confirmCallback = new ConfirmCallback() {
		@Override
		public void confirm(CorrelationData correlationData, boolean ack, String cause) {
			System.err.println("correlationData: " + correlationData);
			System.err.println("ack: " + ack);
			if(!ack){
				System.err.println("异常处理....");
			}
		}
	};

	//回调函数: return返回
	final ReturnCallback returnCallback = new ReturnCallback() {
		@Override
		public void returnedMessage(org.springframework.amqp.core.Message message, int replyCode, String replyText,
				String exchange, String routingKey) {
			System.err.println("return exchange: " + exchange + ", routingKey: " 
				+ routingKey + ", replyCode: " + replyCode + ", replyText: " + replyText);
		}
	};
	
	//发送消息方法调用: 构建Message消息
	public void send(Object message, Map<String, Object> properties) throws Exception {
		MessageHeaders mhs = new MessageHeaders(properties);
		Message msg = MessageBuilder.createMessage(message, mhs);
		rabbitTemplate.setConfirmCallback(confirmCallback);
		rabbitTemplate.setReturnCallback(returnCallback);
		//id + 时间戳 全局唯一 
		CorrelationData correlationData = new CorrelationData("1234567890");
		rabbitTemplate.convertAndSend("exchange-1", "springboot.abc", msg, correlationData);
		System.out.println("发送了！");
	}
	
	//发送消息方法调用: 构建自定义对象消息
	public void sendOrder(Order order) throws Exception {
		rabbitTemplate.setConfirmCallback(confirmCallback);
		rabbitTemplate.setReturnCallback(returnCallback);
		//id + 时间戳 全局唯一 
		CorrelationData correlationData = new CorrelationData("0987654321");
		rabbitTemplate.convertAndSend("exchange-2", "springboot.def", order, correlationData);
	}
	
}

5.实体

package com.example.demo.entity;

import java.io.Serializable;

public class Order implements Serializable {

	private String id;
	private String name;
	
	public Order() {
	}
	public Order(String id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
}

6.测试类

package com.example.demo;

import com.example.demo.entity.Order;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {

    @Test
    public void contextLoads(){

    }

    @Autowired
    private RabbitSender rabbitSender;
    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    @Test
    public void testSender1() throws Exception{
        Map<String ,Object> properties = new HashMap<>();
        properties.put("number","12345");
        properties.put("send_time",simpleDateFormat.format(new Date()));
        rabbitSender.send("你好！",properties);
        System.out.println("成功了！");
    }

    @Test
    public void testSender2() throws Exception{
        Order order = new Order("001","你好，哈哈！");
        rabbitSender.sendOrder(order);
        System.out.println("成功了！");
    }
}

建立晚上后，运行测试类中的方法即可。

Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 50万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
RabbitMQ在SpringBoot中的使用详解
最新发布
weixin_51040479的博客
07-07 963
RabbitMQ在SpringBoot中的应用指南 本文全面介绍了RabbitMQ消息中间件在SpringBoot中的集成与应用。内容涵盖RabbitMQ核心概念（队列、交换机、绑定）、环境搭建（Docker推荐）、SpringBoot集成步骤以及五种常用消息模式（简单队列、工作队列、发布订阅、路由、主题）的详细实现。特别强调了消息确认机制（生产者/消费者确认）、实际项目应用案例（订单系统、延迟队列）以及常见问题解决方案（消息丢失、重复消费、性能优化）。文章还提供了监控配置建议和最佳实践指导，帮助开发者构建
【RabbitMQ笔记（三）】之RabbitMQ的工作模式以及实例
开发小鸽
11-05 246
一． Rabbitmq的工作模式 （一） Work queues工作队列模式        与简单模式不同，工作队列模式多了一个或者一些消费端，多个消费端共同消费同一个队列中的消息。这种模式常常应用于任务过多的情况，可以提高任务处理的速度。消费者之间对于同一个消息的关系是竞争的关系。 （二） Pub/Sub 订阅模式 1. 流程介绍        订阅模式中，多了交换机的转发过程。生产者将消息发送给交换机，交换机决
为什么要使用MQ消息中间件
bless295的博客
10-20 576
为什么要使用MQ消息中间件 1.应用场景 1.1 异步处理 场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种1.串行的方式;2.并行的方式 (1)串行方式:将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西. (2)并行方式:将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间。 假设
RabbitMQ 与 Spring Boot 集成指南：构建可靠异步消息系统
随便写写
06-09 956
摘要： 本文详细介绍了Spring Boot与RabbitMQ的集成实践。RabbitMQ作为开源消息代理，通过生产者-消费者模型实现服务解耦、异步处理和流量削峰。文章涵盖六大核心模块：1) RabbitMQ基础概念图解；2) 技术选型优势分析；3) 具体集成步骤（依赖配置、队列声明、消息收发实现）；4) 高级特性如死信队列和消息TTL；5) 持久化/ACK等最佳实践；6) 常见问题排查指南。典型场景下，RabbitMQ可支持毫秒级延迟的万级消息吞吐，是构建可靠消息系统的理想选择。
ActiveMQ的helloword(简单使用)
sober
10-14 329
1、 准备工作 1、在我们的linux虚拟机中安装好我们的ActiveMQ，并启动服务，这里我们不详细介绍。 2、关闭防火墙，使得我们能在我们的windows服务器上访问到我们的linux的ActiveMQ，在浏览器中输入127.0.0.1:8161，默认的初始用户名和密码都是admin，访问成功后看到控制台： 注意：ActiveMQ采用61616端口提供JMS服务，采用8161提供管理控制台服务。 3、创建一个Maven工程，POM.xml导入我们的依赖： <!-- https://mvnrepo
rabbitMQ结合springboot使用
竹林幽深
06-19 179
springboot+rabbitmq
RabbitMQ配合springboot基本使用
weixin_43960044的博客
04-07 2172
RabbitMQ几种模式 一、普通模式（一个发送一个接收） 配置类 @Configuration public class RabbitMQConfigFanout { public static final String TEST_QUEUE = "test_queue"; /** * Bean注解放到方法上，1、自动执行当前方法，将方法返回值放到ioc容器中 * 2、方法中有参数会在ioc容器中寻找同类型的参数注入到方法中 * <p>
SpringBoot中如何使用RabbitMq
shenzhenNBA的专栏
07-22 1095
RabbitMQ 是一个开源的消息中间件，基于 AMQP（高级消息队列协议）实现。 它由 Erlang 语言开发，并且支持多种编程语言，包括 Java、Python、Ruby、PHP 和 C# 等，
【RabbitMQ】SpringBoot整合RabbitMQ
p_fly的博客
08-16 708
对于RabbitMQ的开发,Spring方法提供了更为方便的操作.Spring官网介绍: Spring AMQPRabbitMQ官网介绍: RabbitMQ tutorial - "Hello World!"
rabbitmq在springboot中的简单应用
07-03
本项目是使用Springboot的amqp依赖，简单测试rabbitmq在Java项目开发中如何发布消息以及采用不同的方式接收消息的功能展示。项目代码使用时需要在comsumer和publisher中修改rabbitmq的连接地址信息。
RabbitMQ结合springboot的使用详解
zhangruijie的博客
09-16 272
RabbitMQ 即消息队列，实现应用程序之间的异步与解耦。同时起到消息的缓冲与分发的作用。 解耦： 中间件的标准用法是：生产者生产消息到消息队列，消费者从消息队列拿取消息并处理。生产者不用关心谁来消费消息，消费者不用关系谁来生产消息。从而达到解耦目的。小伙伴对这一概念理解没有？ 目的： RabbitMQ是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，而消费者无法快速消费消息，这是需要一个中间层，保存这些数据。 RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多
Spring Boot整合RabbitMQ
哟，你又在偷偷写bug！
03-03 3094
// 创建队列 @Bean public Queue queue() {/*** @param name 队列名字* @param durable 声明一个持久队列(该队列将在服务器重启后继续存在)，则为true} // 创建交换机（Direct类型） @Bean public DirectExchange exchange() {} // 绑定队列到交换机 @Bean public Binding binding() {} }
SpringBoot 使用 RabbitMQ
2302_82270778的博客
08-06 3388
RabbitListener(queues = "order.create") 可以加在类上，也可以加在方法上，加在类上，如果消息是 String 类型就会执行 String 类型的方法，如果是对象类型，就会执行对象类型的方法。@RabbitListener 是 Spring 框架中用于监听 RabbitMQ 队列的注解，通过使用这个注解，可以定义一个方法，以便从 RabbitMQ 队列中接收消息，该注解支持多种参数类型。声明两个队列和一个交换机，然后绑定队列和交换机。声明队列和交换机，并绑定。
Spring Boot 中使用 RabbitMQ
good7ob的博客
07-31 2188
通过本文的介绍，你已经学习了如何在 Spring Boot 中使用 RabbitMQ 实现异步消息的发送和接收。你了解了如何配置 RabbitMQ 连接信息，并使用 Spring Boot 提供的和注解进行消息的发送和接收。通过实际的案例，我们展示了如何使用 RabbitMQ 实现任务队列，以邮件发送服务为例。你学习了如何创建消息发送者和消息接收者，并使用队列来实现任务的异步处理。使用 RabbitMQ 可以帮助我们实现解耦和异步处理，提高系统的可靠性和性能。
Springboot中使用RabbitMQ
weixin_44727769的博客
05-17 360
追求可用性：Kafka、 RocketMQ 、RabbitMQ追求可靠性：RabbitMQ、RocketMQ追求吞吐能力：RocketMQ、Kafka追求消息低延迟：RabbitMQ、Kafka。
SpringBoot学习之路---使用RabbitTemplate操作RabbitMq
热门推荐
LeslieLau的博客
04-28 2万+
在学习了RabbitMq之后，我们知道当打开RabbitMq服务时，访问15672端口可以进入web管理界面，并且可以在里面操作，如发送消息，从某个队列中接受消息。但是我们平时在程序实际运行中，不可能一直手动地来完成这些操作(因为我们不知道什么时候需要发送接受消息，而且这样效率很低)。在基于消息队列的程序中，我们需要编写程序来完成从消息队列自动收发消息的操作，这一篇就来记录怎么使用java来完成这...
Spring boot整合RabbitMQ
一个还在上学的程序缘
11-30 5529
目录： 一、RabbitMQ简介   RabbitMQ安装不必我多说，linux和windows环境下都可以安装，我是在windows环境下进行安装的，安装RabbitMQ之前需要先安装Erlang，因为Rabbit MQ 是建立在Erlang OTP平台上，而且安装Erlang 时要注意安装的RabbityMQ 所依赖的Erlang版本。   RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而且支持跨平台。
Spring Boot 中 RabbitMQ 的使用
2301_76161469的博客
12-05 6904
在本篇文章中，我们就来在Spring Boot 中实现常见的工作模式，进而学习在 Spring Boot 中如何使用 RabbitMQ
springboot rabbitmq使用 springboot rabbitmq使用 springboot集成rabbitmq一对多
07-09
Spring Boot集成RabbitMQ可以通过以下步骤完成： 1. 添加Maven依赖：在pom.xml文件中添加RabbitMQ的Spring Boot Starter依赖。 ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 配置RabbitMQ连接信息：在application.properties（或application.yml）文件中配置RabbitMQ的连接信息。 ```properties spring.rabbitmq.host=your_rabbitmq_host spring.rabbitmq.port=your_rabbitmq_port spring.rabbitmq.username=your_rabbitmq_username spring.rabbitmq.password=your_rabbitmq_password ``` 3. 创建RabbitMQ发送者：创建一个发送消息的类，使用`RabbitTemplate`发送消息到指定的交换机和队列。 ```java import org.springframework.amqp.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class RabbitMQSender { @Autowired private RabbitTemplate rabbitTemplate; public void sendMessage(String exchange, String routingKey, Object message) { rabbitTemplate.convertAndSend(exchange, routingKey, message); } } ``` 4. 创建RabbitMQ接收者：创建一个接收消息的类，使用`@RabbitListener`注解监听指定的队列，处理接收到的消息。 ```java import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class RabbitMQReceiver { @RabbitListener(queues = "your_queue_name") public void receiveMessage(Object message) { // 处理接收到的消息 System.out.println("Received message: " + message.toString()); } } ``` 5. 发送和接收消息：在需要发送或接收消息的地方调用对应的方法。 ```java @Autowired private RabbitMQSender rabbitMQSender; public void sendMessage() { rabbitMQSender.sendMessage("your_exchange_name", "your_routing_key", "Hello, RabbitMQ!"); } ``` 以上是基本的使用方式，你可以根据实际需求进行扩展和配置。注意，你还需要安装并启动RabbitMQ服务。 希望对你有所帮助！如果有任何疑问，请随时提问。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值