个人学习Java
large picture of the cover

RabbitMQ Docker Compose 部署与 Spring Boot 对接教程

RabbitMQ Docker Compose 部署与 Spring Boot 对接教程

本教程将引导你完成以下步骤：

  1. 使用 Docker Compose 部署 RabbitMQ 服务（包含管理插件）。
  2. 创建一个简单的 Spring Boot 应用。
  3. 在 Spring Boot 应用中配置 RabbitMQ 连接。
  4. 实现一个消息生产者和一个消息消费者。
  5. 测试消息的发送与接收。

1. 部署 RabbitMQ 使用 Docker Compose

首先，在你的项目根目录或一个你选择的文件夹中创建一个名为 docker-compose.yml 的文件。

version: '3.8'

services:
  rabbitmq:
    image: rabbitmq:3.13-management # 使用带有管理插件的镜像 (推荐检查最新稳定版)
    container_name: my-rabbitmq
    hostname: rabbitmq-host # 可选，容器内部的主机名
    ports:
      - "5672:5672"  # AMQP 协议端口 (客户端连接)
      - "15672:15672" # RabbitMQ 管理界面端口
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq/ # 持久化数据
    environment:
      RABBITMQ_DEFAULT_USER: admin        # 自定义用户名
      RABBITMQ_DEFAULT_PASS: agriPlant@2004    # 自定义密码
    networks:
      - rabbitmq_network

volumes:
  rabbitmq_data: # 定义一个数据卷，用于持久化

networks:
  rabbitmq_network:
    driver: bridge

说明:

  • image: rabbitmq:3.13-management: 指定了 RabbitMQ 的镜像版本，并包含了管理插件。你可以去 Docker Hub 查看最新的 rabbitmq:<version>-management 标签。
  • container_name: my-rabbitmq: 为容器指定一个易于识别的名称。
  • ports:
    • 5672:5672: 将主机的 5672 端口映射到容器的 5672 端口（RabbitMQ 服务端口）。
    • 15672:15672: 将主机的 15672 端口映射到容器的 15672 端口（RabbitMQ 管理界面端口）。
  • volumes:
    • rabbitmq_data:/var/lib/rabbitmq/: 将 RabbitMQ 的数据目录挂载到宿主机的 Docker volume rabbitmq_data，这样即使容器被删除，数据（如队列、消息）也能保留。
  • environment:
    • RABBITMQ_DEFAULT_USER: user: 设置 RabbitMQ 的默认用户名。
    • RABBITMQ_DEFAULT_PASS: password: 设置 RabbitMQ 的默认密码。请在生产环境中使用更安全的密码！
  • networks: 创建一个自定义桥接网络，使服务通信更清晰（虽然在此简单示例中非必需，但良好实践）。

启动 RabbitMQ 服务:

在包含 docker-compose.yml 文件的目录下，打开终端并运行：

docker-compose up -d

-d 参数表示在后台运行。

验证 RabbitMQ 服务:

  1. 查看容器状态: docker ps，应该能看到 my-rabbitmq 容器正在运行。
  2. 访问管理界面: 在浏览器中打开 http://localhost:15672。
    • 使用你设置的用户名 (user) 和密码 (password) 登录。
    • 你应该能看到 RabbitMQ 的管理控制台。

2. 创建 Spring Boot 应用

使用 Spring Initializr (https://start.spring.io/) 创建一个新的 Spring Boot 项目，包含以下依赖：

  • Spring Web: (可选，用于创建简单的 REST API 来触发消息发送)
  • Spring for RabbitMQ: (核心依赖)

或者，如果你使用 Maven，在 pom.xml 中添加：

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

3. 配置 Spring Boot 连接 RabbitMQ

打开 src/main/resources/application.properties (或 application.yml) 文件，添加 RabbitMQ 的连接配置：

# RabbitMQ Connection Properties
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=user     # 与 docker-compose.yml 中设置的用户名一致
spring.rabbitmq.password=password # 与 docker-compose.yml 中设置的密码一致
# spring.rabbitmq.virtual-host=/  # 默认虚拟主机是 /

# Define a queue and exchange for our example (optional, can be done via Java config)
# spring.rabbitmq.queue.name=myQueue
# spring.rabbitmq.exchange.name=myExchange

这里我们使用了 docker-compose.yml 中设置的 user 和 password。

4. 定义 RabbitMQ 组件 (队列、交换机、绑定)

为了让生产者和消费者能工作，我们需要定义一个队列 (Queue)，一个交换机 (Exchange)，并将它们绑定 (Binding) 在一起。这可以通过 Java 配置类完成。

创建一个配置类 RabbitMQConfig.java:

package com.example.rabbitmqdemo; // 根据你的包名修改

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange; // 或 DirectExchange, FanoutExchange
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    public static final String QUEUE_NAME = "myQueue";
    public static final String EXCHANGE_NAME = "myExchange";
    public static final String ROUTING_KEY = "myRoutingKey";

    @Bean
    Queue queue() {
        // durable: true 表示队列持久化
        return new Queue(QUEUE_NAME, true);
    }

    @Bean
    TopicExchange exchange() {
        // durable: true 表示交换机持久化
        return new TopicExchange(EXCHANGE_NAME, true, false);
    }

    @Bean
    Binding binding(Queue queue, TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY);
    }
}
  • Queue: 定义一个名为 myQueue 的持久化队列。
  • TopicExchange: 定义一个名为 myExchange 的持久化主题交换机 (你也可以选择 DirectExchange 或 FanoutExchange，根据需求调整)。
  • Binding: 将队列 myQueue 绑定到交换机 myExchange，并使用路由键 myRoutingKey。

5. 实现消息生产者

创建一个服务类 MessageProducer.java 来发送消息：

package com.example.rabbitmqdemo; // 根据你的包名修改

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

@Service
public class MessageProducer {

    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public MessageProducer(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String message) {
        // 发送消息到指定的交换机，并使用指定的路由键
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, RabbitMQConfig.ROUTING_KEY, message);
        System.out.println("Sent message: '" + message + "' to exchange '" + RabbitMQConfig.EXCHANGE_NAME + "' with routing key '" + RabbitMQConfig.ROUTING_KEY + "'");
    }
}
  • RabbitTemplate: Spring AMQP 提供的核心组件，用于发送和接收消息。
  • convertAndSend(): 方便的方法，它会自动将对象转换为消息格式（默认使用 SimpleMessageConverter 处理字符串）。

6. 实现消息消费者 (监听器)

创建一个组件 MessageConsumer.java 来接收消息：

package com.example.rabbitmqdemo; // 根据你的包名修改

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

@Component
public class MessageConsumer {

    @RabbitListener(queues = RabbitMQConfig.QUEUE_NAME)
    public void receiveMessage(String message) {
        System.out.println("Received message: '" + message + "' from queue '" + RabbitMQConfig.QUEUE_NAME + "'");
        // 在这里处理接收到的消息
    }
}
  • @RabbitListener(queues = RabbitMQConfig.QUEUE_NAME): 注解表示这个方法是一个 RabbitMQ 消息监听器，它会监听 myQueue 队列。当有消息到达该队列时，此方法会被自动调用。

7. 创建一个简单的 REST Controller 来触发消息发送 (可选)

如果你在步骤 2 中添加了 spring-boot-starter-web，可以创建一个简单的 Controller 来通过 HTTP 请求发送消息。

TestController.java:

package com.example.rabbitmqdemo; // 根据你的包名修改

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    private final MessageProducer messageProducer;

    @Autowired
    public TestController(MessageProducer messageProducer) {
        this.messageProducer = messageProducer;
    }

    @GetMapping("/send")
    public String sendMessageToQueue(@RequestParam("message") String message) {
        messageProducer.sendMessage(message);
        return "Message '" + message + "' sent to RabbitMQ!";
    }
}

8. 运行和测试

  1. 确保 RabbitMQ 容器正在运行: docker-compose up -d (如果还没运行)。

  2. 运行 Spring Boot 应用: 在你的 IDE 中运行主应用类，或者使用 Maven/Gradle:

    • Maven: mvn spring-boot:run
    • Gradle: gradle bootRun

  3. 测试:

    • 如果你创建了 TestController: 打开浏览器或使用 curl 访问: http://localhost:8080/send?message=HelloRabbitMQ
    • 如果你没有创建 Controller: 你可以在 Spring Boot 应用的启动类中注入 MessageProducer 并调用其 sendMessage 方法来测试：
package com.example.rabbitmqdemo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class RabbitmqDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(RabbitmqDemoApplication.class, args);
    }

    // 测试用，应用启动后发送一条消息
    @Bean
    CommandLineRunner runner(MessageProducer producer) {
        return args -> {
            producer.sendMessage("Hello RabbitMQ from CommandLineRunner!");
        };
    }
}

  1. 观察输出:

    • Spring Boot 应用控制台:
      • 你应该能看到生产者发送消息的日志: Sent message: 'HelloRabbitMQ' ...
      • 你也应该能看到消费者接收消息的日志: Received message: 'HelloRabbitMQ' ...
    • RabbitMQ 管理界面 (http://localhost:15672):
      • 登录后，进入 "Queues" 标签页。
      • 你应该能看到 myQueue，并且可以看到消息进出的统计。
      • 进入 "Exchanges" 标签页，可以看到 myExchange。

9. 清理 Docker 环境 (可选)

当你完成测试后，可以停止并删除 RabbitMQ 容器和网络：

docker-compose down

如果你还想删除 Docker volume（这将删除所有持久化的 RabbitMQ 数据）：

docker-compose down -v

这样，你就成功地使用 Docker Compose 部署了 RabbitMQ，并创建了一个简单的 Spring Boot 应用来与之交互，实现了消息的生产和消费！

site logo

星尘の博客

© 2025 个人学习Java