SpringBoot 交互 RabbitMQ 消息队列

开篇词

该指南将引导你完成设置 RabbitMQ AMQP 服务器以发布/订阅消息，并创建一个 Spring Boot 应用与该 RabbitMQ 服务器进行交互。
 

你将创建的应用

我们将创建一个应用，该应用使用 Spring AMQP 的 RabbitTemplate 发布消息，并使用 MessageListenerAdapter 在 POJO 上订阅消息。
 

你将需要的工具

• 大概 15 分钟左右；
• 你最喜欢的文本编辑器或集成开发环境（IDE）
• JDK 1.8 或更高版本；
• Gradle 4+ 或 Maven 3.2+
• 你还可以将代码直接导入到 IDE 中：
  • Spring Too Suite (STS)
  • IntelliJ IDEA
    • 设置 RabbitMQ 服务器。参看搭建 RabbitMQ 代理。
       

如何完成这个指南

像大多数的 Spring 入门指南一样，你可以从头开始并完成每个步骤，也可以绕过你已经熟悉的基本设置步骤。如论哪种方式，你最终都有可以工作的代码。

• 要从头开始，移步至从 Spring Initializr 开始；
• 要跳过基础，执行以下操作：
  • 下载并解压缩该指南将用到的源代码，或借助 Git 来对其进行克隆操作：git clone https://github.com/spring-guides/gs-messaging-rabbitmq.git
  • 切换至 gs-messaging-rabbitmq/initial 目录；
  • 或跳转至该指南的从 Spring Initializr 开始。

待一切就绪后，可以检查一下 gs-messaging-rabbitmq/complete 目录中的代码。
 

搭建 RabbitMQ 代理

在构建消息传递应用之前，需要搭建服务器以处理接收和发送消息。
RabbitMQ 是 AMQP 服务器。该服务器可从 https://www.rabbitmq.com/download.html 免费获得。我们可以手动下载它，或者，如果我们使用一个带有 Homebrew 的 Mac 系统，则可以在终端窗口中运行以下命令来下载它：

brew install rabbitmq

通过在终端窗口中运行以下命令来打开服务器包并使用默认配置将其启动：

rabbitmq-server

我们应该看到类似于以下输出的内容：

            RabbitMQ 3.1.3. Copyright (C) 2007-2013 VMware, Inc.
##  ##      Licensed under the MPL.  See https://www.rabbitmq.com/
##  ##
##########  Logs: /usr/local/var/log/rabbitmq/[email protected]
######  ##        /usr/local/var/log/rabbitmq/[email protected]
##########
            Starting broker... completed with 6 plugins.

如果你在本地运行 Docker，也可以使用 Docker Compose 来快速启动 RabbitMQ 服务器。Github 中 complete 项目的根目录中有一个 docker-compose.yml。很简单，如以下清单所示：

rabbitmq:
  image: rabbitmq:management
  ports:
    - "5672:5672"
    - "15672:15672"

使用当前目录中的该文件，我们可以运行 docker-compose 来使 RabbitMQ 在容器中运行。
 

从 Spring Initializr 开始

对于所有的 Spring 应用来说，你应该从 Spring Initializr 开始。Initializr 提供了一种快速的方法来提取应用程序所需的依赖，并为你完成许多设置。该示例只需要 Spring 的 RabbitMQ 依赖。下图显示了此示例项目的 Initializr 设置：

上图显示了选择 Maven 作为构建工具的 Initializr。你也可以使用 Gradle。它还将 com.example 和 messaging-rabbitmq 的值分别显示为 Group 和 Artifact。在本示例的其余部分，将用到这些值。

以下清单显示了选择 Maven 时创建的 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.2.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>messaging-rabbitmq</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>messaging-rabbitmq</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<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>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

以下清单显示了在选择 Gradle 时创建的 build.gradle 文件：

plugins {
	id 'org.springframework.boot' version '2.2.0.RELEASE'
	id 'io.spring.dependency-management' version '1.0.8.RELEASE'
	id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-amqp'
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
	testImplementation 'org.springframework.amqp:spring-rabbit-test'
}

test {
	useJUnitPlatform()
}

创建 RabbitMQ 消息接收器

对于任何基于消息传递的应用，我们需要创建一个响应已发布消息的接收器。以下清单（来自 src/main/java/com.example.messagingrabbitmq/Receiver.java）显示了如何执行该操作：

package com.example.messagingrabbitmq;

import java.util.concurrent.CountDownLatch;
import org.springframework.stereotype.Component;

@Component
public class Receiver {

  private CountDownLatch latch = new CountDownLatch(1);

  public void receiveMessage(String message) {
    System.out.println("Received <" + message + ">");
    latch.countDown();
  }

  public CountDownLatch getLatch() {
    return latch;
  }

}

接收器是一个 POJO，它定义了一种接收消息的方法。当我们注册它来接收消息时，可以随意命名。

为了方便起见，该 POJO 还有 CountDownLatch。这使其发出已收到消息的信号。这是我们不太可能在生产应用中实现的东西。

注册监听器并发送消息

Spring AMQP 的 RabbitTemplate 提供了使用 RabbitMQ 发送和接收消息所需的一切。但我们需要：

• 配置消息监听器容器；
• 声明它们之间的队列、交换以及绑定；
• 配置组件以发送一些消息以测试监听器。

Spring Boot 自动创建一个连接工厂和一个 RabbitTemplate，从而减少了我们必须编写的代码量。

我们将使用 RabbitTemplate 发送消息，并在消息监听器容器中注册一个 Receiver 来接收消息。连接工厂驱动两个驱动器，使其连接到 RabbitMQ 服务器。以下清单（来自 src/main/java/com.example.messagingrabbitmq/MessagingRabbitApplication.java）显示了如何创建应用类：

package com.example.messagingrabbitmq;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class MessagingRabbitmqApplication {

	static final String topicExchangeName = "spring-boot-exchange";

	static final String queueName = "spring-boot";

	@Bean
	Queue queue() {
		return new Queue(queueName, false);
	}

	@Bean
	TopicExchange exchange() {
		return new TopicExchange(topicExchangeName);
	}

	@Bean
	Binding binding(Queue queue, TopicExchange exchange) {
		return BindingBuilder.bind(queue).to(exchange).with("foo.bar.#");
	}

	@Bean
	SimpleMessageListenerContainer container(ConnectionFactory connectionFactory,
			MessageListenerAdapter listenerAdapter) {
		SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
		container.setConnectionFactory(connectionFactory);
		container.setQueueNames(queueName);
		container.setMessageListener(listenerAdapter);
		return container;
	}

	@Bean
	MessageListenerAdapter listenerAdapter(Receiver receiver) {
		return new MessageListenerAdapter(receiver, "receiveMessage");
	}

	public static void main(String[] args) throws InterruptedException {
		SpringApplication.run(MessagingRabbitmqApplication.class, args).close();
	}

}

@SpringBootApplication 是一个便利的注解，它添加了以下所有内容：

• @Configuration：将类标记为应用上下文 Bean 定义的源；
• @EnableAutoConfiguration：告诉 Spring Boot 根据类路径配置、其他 bean 以及各种属性的配置来添加 bean。
• @ComponentScan：告知 Spring 在 com/example 包中寻找他组件、配置以及服务。

main() 方法使用 Spring Boot 的 SpringApplication.run() 方法启动应用。

在 listenerAdapter() 方法中定义的 bean 在容器（在 container() 中定义）中注册为消息监听器。它在 spring-boot 队列上监听消息。由于 Receiver 类是 POJO，因此需要将其包装在 MessageListenerAdapter 中，在该容器中我们可以指定它调用 receiveMessage。

JMS 队列和 AMQP 队列具有不同的语义。例如，JMS 仅将排队的消息发送给一个使用者。尽管 AMQP 队列执行相同的操作，但 AMQP 生产者不会将消息直接发送到队列。而是将消息发送到交换机，该交换机可以转到单个队列，也可以扇出至多个队列，以模拟 JMS 主题的概念。

我们所需要的就是消息监听器容器和接收者 Bean。要发送消息，我们还需要一个 Rabbit 模版。

queue() 方法创建一个 AMQP 队列。exchange() 方法创建一个主题交换。bingding() 方法将这两者绑定在一起，定义了 RabbitTemplate 发布到交换时发生的行为。

Spring AMQP 要求将 Queue、TopicExchange 以及 Binding 声明为顶级 Spring bean，以进行恰当的配置。

在这种情况下，我们使用主题交换，并且队列由 foo.bar.# 的路由键绑定，这意味着任何以 foo.bar 开头的路由键发送的消息将被路由到队列。
 

发送测试消息

在该示例中，测试消息由 CommandLineRunner 发送，其需要等待接收器中的闩锁并关闭应用上下文。以下清单（来自 src/main/java/com.example.messagingrabbitmq/Runner.java）显示了它的工作方式：

package com.example.messagingrabbitmq;

import java.util.concurrent.TimeUnit;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class Runner implements CommandLineRunner {

  private final RabbitTemplate rabbitTemplate;
  private final Receiver receiver;

  public Runner(Receiver receiver, RabbitTemplate rabbitTemplate) {
    this.receiver = receiver;
    this.rabbitTemplate = rabbitTemplate;
  }

  @Override
  public void run(String... args) throws Exception {
    System.out.println("Sending message...");
    rabbitTemplate.convertAndSend(MessagingRabbitmqApplication.topicExchangeName, "foo.bar.baz", "Hello from RabbitMQ!");
    receiver.getLatch().await(10000, TimeUnit.MILLISECONDS);
  }

}

需要注意的是，模版使用匹配绑定的路由键 foo.bar.baz 将消息路由到交换器。

在测试中，我们可以模拟运行器，以便可以单独测试接收器。
 

运行应用

main() 方法通过创建 Spring 应用上下文来启动该过程。这会启动消息监听器容器，该容器开始监听消息。有一个 Runner bean，它将自动运行。它从应用上下文中检索 RabbitTemplate 并在 spring-boot 队列上发送一条 Hello from RabbitMQ! 消息。最后，它关闭 Spring 应用上下文，然后应用结束。
 

构建可执行 JAR

我们可以结合 Gradle 或 Maven 来从命令行运行该应用。我们还可以构建一个包含所有必须依赖项、类以及资源的可执行 JAR 文件，然后运行该文件。在整个开发生命周期中，跨环境等等情况下，构建可执行 JAR 可以轻松地将服务作为应用进行发布、版本化以及部署。

如果使用 Gradle，则可以借助 ./gradlew bootRun 来运行应用。或通过借助 ./gradlew build 来构建 JAR 文件，然后运行 JAR 文件，如下所示：

java -jar build/libs/gs-messaging-rabbitmq-0.1.0.jar

由官网提供的以上这条命令的执行结果与我本地的不一样，我需要这样才能运行：java -jar build/libs/messaging-rabbitmq-0.0.1-SNAPSHOT.jar。

如果使用 Maven，则可以借助 ./mvnw spring-boot:run 来运行该用。或可以借助 ./mvnw clean package 来构建 JAR 文件，然后运行 JAR 文件，如下所示：

java -jar target/gs-messaging-rabbitmq-0.1.0.jar

由官网提供的以上这条命令的执行结果与我本地的不一样，我需要这样才能运行：java -jar target/messaging-rabbitmq-0.0.1-SNAPSHOT.jar。

我们还可以构建一个经典的 WAR 文件。

我们应该看到以下输出：

    Sending message...
    Received <Hello from RabbitMQ!>

概述

恭喜你！我们刚刚使用 Spring 和 RabbitMQ 开发了一个简单的发布/订阅应用。借助 Spring 和 RabbitMQ 可以做的事情比这里介绍的要多，但是该指南应该是一个好的起点。
 

参见

以下指南也可能会有所帮助：

• 与 Redis 通讯
• 使用 JMS 进行消息传递（尽请期待～）
• 使用 Spring Boot 构建应用（尽请期待～）

想看指南的其他内容？请访问该指南的所属专栏：《Spring 官方指南》