一、实验目的

  1. 掌握 Spring Boot 与 RabbitMQ 4.x 的整合方法
  2. 理解 Spring AMQP 与 RabbitMQ 的交互机制
  3. 熟悉 Spring Boot 中 RabbitMQ 的基本配置与使用
  4. 掌握消息发送、接收、确认等核心操作
  5. 通过实践掌握 Spring Boot 整合 RabbitMQ 的开发流程

二、实验环境

组件

版本要求

说明

操作系统

CentOS 7/8、Ubuntu 20.04/22.04、OpenEuler 22.03

已安装 RabbitMQ 4.0.x（参考实验1）

JDK

JDK 1.8+

推荐 JDK 11

Spring Boot

2.7.x

与 RabbitMQ 4.x 兼容

RabbitMQ

4.0.x

通过 Docker 安装，含管理插件

Maven

3.6+

用于管理项目依赖

三、Spring Boot 整合 RabbitMQ 基本原理

Spring Boot 通过 Spring AMQP (Advanced Message Queuing Protocol) 提供了对 RabbitMQ 的集成支持，主要包含以下组件：

  1. RabbitTemplate：用于消息的发送和接收
  2. RabbitListener：用于消息的监听和消费
  3. ConnectionFactory：用于创建与 RabbitMQ 的连接
  4. Exchange、Queue、Binding：RabbitMQ 的核心概念

Spring Boot 2.7.x 与 RabbitMQ 4.0.x 的整合是官方推荐的组合，提供了稳定、高效的集成方案。

四、系统目录结构

springboot-rabbitmq-demo
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── rabbitmq
│   │   │               ├── config
│   │   │               │   └── RabbitMQConfig.java
│   │   │               ├── controller
│   │   │               │   └── RabbitMQController.java
│   │   │               ├── service
│   │   │               │   ├── RabbitMQService.java
│   │   │               │   └── RabbitMQServiceImpl.java
│   │   │               └── RabbitMQApplication.java
│   │   └── resources
│   │       ├── application.properties
│   │       └── static
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── rabbitmq
│                       └── RabbitMQApplicationTests.java
├── pom.xml
└── README.md

五、快速搭建 Spring Boot 项目

5.1 通过 Spring Initializr 快速创建项目

5.1.1 使用 IDEA 创建项目
  1. 打开 IDEA，点击 "File" -> "New" -> "Project"
  2. 选择 "Spring Initializr"，点击 "Next"
  3. 填写项目基本信息：
    • Group: com.example
    • Artifact: springboot-rabbitmq-demo
    • Name: springboot-rabbitmq-demo
    • Description: Spring Boot RabbitMQ Demo
    • Package name: com.example.rabbitmq
    • Java version: 11 (推荐)
  4. 点击 "Next"
  5. 在 Dependencies 中选择以下依赖：
    • Spring Web
    • RabbitMQ
    • Lombok (可选，用于简化代码)
  6. 点击 "Finish"，等待 IDEA 自动下载依赖并创建项目
5.1.2 使用 Spring Boot 官方网站创建
  1. 访问 Spring Initializr
  2. 填写项目信息：
    • Project: Maven
    • Language: Java
    • Spring Boot: 2.7.x
    • Group: com.example
    • Artifact: springboot-rabbitmq-demo
    • Name: springboot-rabbitmq-demo
    • Description: Spring Boot RabbitMQ Demo
    • Package name: com.example.rabbitmq
    • Java: 11
  3. 点击 "Generate" 下载项目压缩包
  4. 解压后导入 IDEA

5.2 修改 pom.xml 文件

确保 pom.xml 包含以下依赖：

<?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.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.22</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot-rabbitmq-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-rabbitmq-demo</name>
    <description>Demo project for Spring Boot RabbitMQ</description>
    
    <properties>
        <java.version>11</java.version>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
    
</project>

六、Spring Boot 配置 RabbitMQ

6.1 application.properties 配置

在 src/main/resources/application.properties 中添加 RabbitMQ 连接配置：

# RabbitMQ 连接配置
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=123456
spring.rabbitmq.virtual-host=/

# 消息确认配置
spring.rabbitmq.publisher-confirm-type=correlated
spring.rabbitmq.publisher-returns=true

# 消息消费确认配置
spring.rabbitmq.listener.simple.acknowledge-mode=manual

重要提示：RabbitMQ 4.x 默认禁用匿名用户，需使用用户名和密码连接。默认用户名为 guest，密码为 123456（生产环境建议修改）。

6.2 RabbitMQ 配置类

创建 src/main/java/com/example/rabbitmq/config/RabbitMQConfig.java：

package com.example.rabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    // 简单模式队列
    @Bean
    public Queue simpleQueue() {
        return new Queue("simple.queue", true); // durable=true 表示队列持久化
    }

    // 工作队列模式队列
    @Bean
    public Queue workQueue() {
        return new Queue("work.queue", true);
    }

    // 发布/订阅模式队列
    @Bean
    public Queue fanoutQueue1() {
        return new Queue("fanout.queue1", true);
    }

    @Bean
    public Queue fanoutQueue2() {
        return new Queue("fanout.queue2", true);
    }

    // 发布/订阅模式交换机
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout.exchange");
    }

    // 路由模式交换机
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("direct.exchange");
    }

    // 绑定路由模式队列
    @Bean
    public Binding bindingDirect1() {
        return BindingBuilder.bind(workQueue()).to(directExchange()).with("direct.routing.key1");
    }

    @Bean
    public Binding bindingDirect2() {
        return BindingBuilder.bind(workQueue()).to(directExchange()).with("direct.routing.key2");
    }

    // 通配符模式交换机
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange("topic.exchange");
    }

    // 绑定通配符模式队列
    @Bean
    public Binding bindingTopic1() {
        return BindingBuilder.bind(workQueue()).to(topicExchange()).with("topic.#");
    }

    @Bean
    public Binding bindingTopic2() {
        return BindingBuilder.bind(workQueue()).to(topicExchange()).with("topic.*.key");
    }
}

七、实验步骤

7.1 简单模式实践

7.1.1 创建服务类

创建 src/main/java/com/example/rabbitmq/service/RabbitMQService.java：

package com.example.rabbitmq.service;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RabbitMQService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendSimpleMessage(String message) {
        rabbitTemplate.convertAndSend("simple.queue", message);
        System.out.println("消息已发送: " + message);
    }
}
7.1.2 创建控制器

创建 src/main/java/com/example/rabbitmq/controller/RabbitMQController.java：

package com.example.rabbitmq.controller;

import com.example.rabbitmq.service.RabbitMQService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RabbitMQController {

    @Autowired
    private RabbitMQService rabbitMQService;

    @GetMapping("/send/simple")
    public String sendSimpleMessage() {
        rabbitMQService.sendSimpleMessage("Hello Spring Boot RabbitMQ Simple Mode!");
        return "消息已发送";
    }
}
7.1.3 创建消费者

创建 src/main/java/com/example/rabbitmq/service/RabbitMQConsumer.java：

package com.example.rabbitmq.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

@Service
public class RabbitMQConsumer {

    private static final Logger log = LoggerFactory.getLogger(RabbitMQConsumer.class);

    @RabbitListener(queues = "simple.queue")
    public void receiveSimpleMessage(String message) {
        log.info("收到简单模式消息: {}", message);
    }
}

7.2 工作队列模式实践

7.2.1 修改 RabbitMQ 配置

在 RabbitMQConfig.java 中添加工作队列配置：

@Bean
public Queue workQueue() {
    return new Queue("work.queue", true);
}
7.2.2 创建工作队列服务

创建 src/main/java/com/example/rabbitmq/service/WorkQueueService.java：

package com.example.rabbitmq.service;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class WorkQueueService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendWorkMessage(String message) {
        rabbitTemplate.convertAndSend("work.queue", message);
        System.out.println("工作队列消息已发送: " + message);
    }
}
7.2.3 创建工作队列控制器

创建 src/main/java/com/example/rabbitmq/controller/WorkQueueController.java：

package com.example.rabbitmq.controller;

import com.example.rabbitmq.service.WorkQueueService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class WorkQueueController {

    @Autowired
    private WorkQueueService workQueueService;

    @GetMapping("/send/work")
    public String sendWorkMessage() {
        for (int i = 0; i < 10; i++) {
            workQueueService.sendWorkMessage("Work Queue Message " + i);
        }
        return "工作队列消息已发送";
    }
}
7.2.4 创建工作队列消费者

创建 src/main/java/com/example/rabbitmq/service/WorkQueueConsumer.java：

package com.example.rabbitmq.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

@Service
public class WorkQueueConsumer {

    private static final Logger log = LoggerFactory.getLogger(WorkQueueConsumer.class);

    @RabbitListener(queues = "work.queue")
    public void receiveWorkMessage(String message) {
        log.info("收到工作队列消息: {}", message);
        try {
            Thread.sleep(1000); // 模拟处理时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

八、运行与验证

8.1 启动项目

  1. 在 IDEA 中运行 RabbitMQApplication 类
  2. 项目启动后，控制台将显示 RabbitMQ 连接信息

8.2 验证简单模式

  1. 访问 http://localhost:8080/send/simple
  2. 查看控制台输出，确认消息已发送
  3. 查看消费者控制台，确认消息已被消费

8.3 验证工作队列模式

  1. 访问 http://localhost:8080/send/work
  2. 查看控制台输出，确认10条工作队列消息已发送
  3. 查看两个消费者控制台，确认消息被轮询消费

九、实验总结

  1. 通过本实验，成功实践了 Spring Boot 与 RabbitMQ 4.x 的整合
  2. 掌握了 Spring Boot 中 RabbitMQ 的基本配置与使用
  3. 理解了 Spring AMQP 与 RabbitMQ 的交互机制
  4. 通过简单模式和工作队列模式的实践，加深了对 RabbitMQ 工作模式的理解
  5. 学习了如何在 Spring Boot 项目中组织 RabbitMQ 相关代码

十、注意事项

  1. RabbitMQ 4.x 连接配置：
    • 确保 application.properties 中的连接信息正确
    • 默认用户名 guest，密码 123456，生产环境建议修改
  2. 消息确认机制：
    • 生产者端配置 spring.rabbitmq.publisher-confirm-type=correlated
    • 消费者端配置 spring.rabbitmq.listener.simple.acknowledge-mode=manual
  3. 队列持久化：
    • 创建队列时设置 durable=true，确保队列在 RabbitMQ 重启后仍存在
    • 消息持久化需设置 MessageProperties.PERSISTENT_TEXT_PLAIN
  4. 项目结构：
    • 按功能模块组织代码，便于维护和扩展
    • 配置类、服务类、控制器类分离，符合 Spring Boot 开发规范
  5. 依赖管理：
    • 使用 Spring Boot Starter AMQP 简化 RabbitMQ 集成
    • 依赖版本与 Spring Boot 2.7.x 兼容
# java-rabbitmq # spring boot # rabbitmq
Logo
亚马逊云科技技术品牌专区

更多推荐

Kiro Editor 开发实战：使用 Cargo 构建、测试与性能优化指南

欢迎来到这篇终极指南，我们将深入探索如何使用Rust构建高性能的终端文本编辑器Kiro Editor。无论你是Rust新手还是经验丰富的开发者，这篇完整教程将带你了解如何利用Cargo工具链进行高效的开发、测试和性能优化，打造一款快速、轻量且功能强大的UTF-8文本编辑器。## 什么是Kiro Editor？Kiro Editor是一款使用Rust编写的极简终端文本编辑器，它最初是著名编辑

avatar 亚马逊云科技技术品牌专区

近期零基础学量化，先按基础差异拆学习顺序

读者应明白，拆解学习顺序时要先看自己的基础缺口，再决定哪一段需要放慢。不同流程阶段都有不同检查任务，学习路线要能反映这些差异。

avatar 亚马逊云科技技术品牌专区

2026年量化工具选择，要跟着能力基础走

读者应理解，选择工具前要先判断自己的能力基础和当前任务。工具应该帮助自己补上当前最关键的缺口，而不是替代学习顺序本身。

avatar 亚马逊云科技技术品牌专区