【译】Spring官方教程:Spring Boot整合消息中间件RabbitMQ

原文:Messaging with RabbitMQ 译者:chenzhijun 校对:程序猿DD

本篇指南会告诉您如何使用构建一个基于 AMQP协议的 RabbitMQ 服务,并且教您如何实现发布和订阅消息。

你会得到什么?

你会创建一个应用,它能够使用 Spring AMQP 的 RabbitTemplate发布消息,并且通过使用 MessageListenerAdapter包装一个 POJO 来接受消息。

你需要准备什么?

  • 大概15分钟时间
  • 一个喜欢的文本编辑器或者IDE
  • JDK 1.8 or 更高版本 *Gradle 2.3+ or Maven 3.0+
  • 你可以直接导入 RabbitMQ 服务的代码到 IDE : Spring Tool Suite (STS) 或者 IntelliJ IDEA (点击进入安装步骤)

怎样完成指南?

像大多数 Spring 教程指南一样,你可以选择从最基础开始,一步步的完成 Demo ,或者你也可以绕过你熟悉的步骤再开始。不管哪种方式,你最后都会得到一份可执行的代码。

如果从基础开始,你可以往下查看怎样使用 Gradle 构建项目。

如果已经熟悉一些基本步骤,你可以:

  • 下载并解压源码库 ,或者通过 Git 工具克隆一份代码:了解Git : git clone[https://github.com/spring-guides/gs-messaging-rabbitmq.git]
  • cd into gs-messaging-rabbitmq/initial
  • 往下看 创建RabbitMQ 消息接收者

当你完成之后,你可以在 gs-messaging-rabbitmq/complete检查下结果。

使用 Gradle 构建项目

首先你需要编写基础构建脚本。在构建 Spring 应用的时候,你可以使用任何你喜欢的系统来构建,这里提供一份你可能需要用 Gradle 或者 Maven 构建的代码。如果你对两者都不是很熟悉,你可以先去看下如何使用 Gradle 构建 Java 项目或者如何使用 Maven 构建 Java 项目。

创建 Gradle 目录结构

在你的项目根目录,创建如下的子目录结构;例如,如果你使用的是 *nix系统,你可以使用 mkdir-p src/main/java/hello

└── src
    └── main
        └── java
            └── hello

创建 Gradle 构建文件

下面是一份初始化Gradle构建文件

build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.7.RELEASE")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'org.springframework.boot'

jar {
    baseName = 'gs-spring-boot'
    version =  '0.1.0'
}

repositories {
    mavenCentral()
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

dependencies {
    // tag::jetty[]
    compile("org.springframework.boot:spring-boot-starter-web") {
        exclude module: "spring-boot-starter-tomcat"
    }
    compile("org.springframework.boot:spring-boot-starter-jetty")
    // end::jetty[]
    // tag::actuator[]
    compile("org.springframework.boot:spring-boot-starter-actuator")
    // end::actuator[]
    testCompile("junit:junit")
}

Spring Boot gradle 插件提供了非常多方便的功能:

  • 将 classpath 里面所有用到的 jar 包构建成一个可执行的 JAR 文件,使得运行和发布你的服务变得更加便捷
  • 搜索 publicstaticvoidmain()方法并且将它标记为可执行类
  • 提供了将内部依赖的版本都去匹配 Spring Boot 依赖的版本,你可以根据你的需要来重写版本,但是它默认提供给了 Spring Boot 依赖的版本

使用 Maven 构建项目

首先你需要编写基础构建脚本。在构建 Spring 应用的时候,你可以使用任何你喜欢的系统来构建,这里提供一份你可能需要用 Maven 构建的代码。如果你对 Maven 还不是很熟悉,你可以先去看下如何使用 Maven 构建 Java 项目.

创建 Maven 目录结构

在你的项目根目录,创建如下的子目录结构;例如,如果你使用的是 *nix系统,你可以使用 mkdir-p src/main/java/hello

└── src
    └── main
        └── java
            └── hello

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.springframework</groupId>
    <artifactId>gs-messaging-rabbitmq</artifactId>
    <version>0.1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
    </parent>

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

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

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

</project>

Spring Boot Maven 插件 提供了非常多方便的功能:

  • 将 classpath 里面所有用到的 jar 包构建成一个可执行的 JAR 文件,使得运行和发布你的服务变得更加便捷
  • 搜索 publicstaticvoidmain()方法并且将它标记为可执行类
  • 提供了将内部依赖的版本都去匹配 Spring Boot 依赖的版本.你可以根据你的需要来重写版本,但是它默认提供给了 Spring Boot 依赖的版本。

使用你的 IDE 进行构建

  • 如何在Spring Tool Suite中构建.
  • 如何在IntelliJ IDEA中构建.

安装 RabbitMQ

在构建消息应用之前,需要先安装 RabbitMQ 消息中间件服务,中间件服务器会处理发送和接受消息。

RabbitMQ 是一个基于 AMQP协议的消息中间件。它完全开源,你可以在这里http://www.rabbitmq.com/download.html去下载它,如果你使用的是 Mac 电脑,你可以使用 homebrew 来安装:

brew install rabbitmq

解压下载文件,并且使用默认配置启动服务.

rabbitmq-server

启动后,你可以看到下面的提示:

RabbitMQ 3.1.3\. Copyright (C) 2007-2013 VMware, Inc.
##  ##      Licensed under the MPL.  See http://www.rabbitmq.com/
##  ##
##########  Logs: /usr/local/var/log/rabbitmq/rabbit@localhost.log
######  ##        /usr/local/var/log/rabbitmq/rabbit@localhost-sasl.log
##########
            Starting broker... completed with 6 plugins.

如果你本地安装了 Docker,你也可以通过 Docker Compose 的方式来快速启动一个 RabbitMQ 服务。下面是 Github 上面一个建立 RabbitMQ 服务的 docker-compse.yml,它非常简单:

docker-compose.yml

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

将这个文件放到你当前的目录,并且使用 docker-compose命令,就可以有一个运行 RabbitMQ 的容器了。

创建 RabbitMQ 消息接收者

对于一些使用消息的应用,你通常都需要创建一个消息接收者来响应已经发布的消息

src/main/java/hello/Receiver.java

package hello;

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 自动创建了一个连接工厂(译者注:RabbitMQ中的Connection Factory)和一个 RabbitTemplate 用来减少你需要写的大量代码。

你会使用 RabbitTemplate来发送消息,并且你会注册一个消息监听器的接收者来接收消息。连接工厂已经在底层做了一些实现,来允许他们连接到 RabbitMQ 服务器。

src/main/java/hello/Application.java

package hello;

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 Application {

    final static String queueName = "spring-boot";

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

    @Bean
    TopicExchange exchange() {
        return new TopicExchange("spring-boot-exchange");
    }

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

    @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(Application.class, args);
    }

}

@SpringBootApplication 是一个非常方便的注解,它增加了以下注解的所有功能

  • @Configuration 标记这个类是应用上下文 Bean 的源定义
  • @EnableAutoConfiguration 告诉 SpringBoot 启动的时候在 classpath 设置、其它已经装载的 Bean 以及其它配置文件的基础上自动进行配置 Bean
  • 通常你会在SpringMVC应用上使用 @EnableMvc,但是Spring Boot 在看到spring-webmvc 在它的classpath目录下的时候,它会自动加载该注解。这个注解标记了这个应用是一个web应用,并且会激活一些关键功能,比如说加载 DispatcherServlet
  • @ComponetScan 告诉 Spring 在 hello 包下扫描其它的注解,如组件(componets),配置(configurations),或者服务(services),Spring 也会通过它找到控制器(controllers)

main() 方法里面通过调用 Spring Boot 的 SpringApplication.run()方法来启动应用。你有没有注意到到现在还没有写过一行 XML ?甚至也没有 web.xml文件。这个 web 应用完全 100% 都是使用的 Java,并且你还不需要对任何应用的基础设置进行配置。

通过 listenerAdapter()来定义的 Bean,用来在 container()方法里面注册称为一个消息监听器。它会监听来自"spring-boot"队列的消息。因为接受者类是一个 POJO,它需要在 MessageListenAdapter里面进行一层包装,然后在这里我们再调用它的 receiveMessage方法。

基于 JMS 的队列和 基于 AMQP 的队列有些不同。比如,JMS 只发送消息给一个消费者,而 AMQP 也可以做到同样的事,并且 AMQP 的生产者不是直接发送消息给队列,它将消息发送一个交换机,交换机可以将消息发送给一个队列,也可以发送给多个队列,就像 JMS 的 topics。了解更多AMQP

消息监听容器和接收消息的 Bean ,你都应该监听。如果要发送消息,你需要使用 RabbitTemplate

queue()方法创建了一个AMQP队列。 exchange()方法创建了一个 topic交换机。当 RabbitTemplate 发布消息到一个交换机的时候, binding()方法将队列和交换机两者进行了绑定。

Spring AMQP 要求 Queue, TopicExchange, Binding被声明成了 Spring 的高级 Beans,之后才能正确的执行。

发送文本消息

文本消息通过一个 CommandLineRunner类来发送,它会等待接收方锁并且关闭应用的上下文:

src/main/java/hello/Runner.java

package hello;

import java.util.concurrent.TimeUnit;

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

@Component
public class Runner implements CommandLineRunner {

    private final RabbitTemplate rabbitTemplate;
    private final Receiver receiver;
    private final ConfigurableApplicationContext context;

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

    @Override
    public void run(String... args) throws Exception {
        System.out.println("Sending message...");
        rabbitTemplate.convertAndSend(Application.queueName, "Hello from RabbitMQ!");
        receiver.getLatch().await(10000, TimeUnit.MILLISECONDS);
        context.close();
    }

}

在测试中runner会被mock掉,目的是为了接受者能够在隔离的环境下测试。

运行应用

main()方法通过创建一个 Spring 应用上下文来启动了程序。它会启动消息监听者容器,容器启动后会监听消息。这里自动执行了一个 Runner类:它会从应用上下文中检查 RabbitTemplate,之后会在"spring-boot"队列上发送"Hello from RabbitMQ"消息。最后它会关闭 Spring 应用上下文,然后程序就停止了。

构建一个可执行的JAR

你可以通过使用 Gradle 或者 Maven 命令行来运行一个应用。或者你可以先构建一个包含了所有依赖、类、和配置的可执行 JAR 文件,然后运行它。这使得在整个开发生命周期中,以及在不同的环境中,都很容易将应用程序进行部署、版本控制和服务发布。

如果你使用 Gradle ,你可以使用 ./gradlew来启动应用,或者你可以使用 ./gradlew build来构建一个 JAR 文件。之后,你可以通过运行 JAR 文件:

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

如果你使用 Maven ,你可以使用 ./mvnw spring-boot:run来运行应用。或者你可以使用 ./mvnw cleanpackage来构建一个 JAR 包。之后你可以运行JAR文件:

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

上面的过程是创建一个可以运行的JAR,如果你需要构建成一个WAR:[怎样构建WAR文件][2]

你应该可以看到下面的输出:

Sending message...
Received

总结

恭喜!你已经使用 Spring 和 RabbitMQ 开发了一个简单的 发布-订阅应用。你也可以使用 Spring 和 RabbitMQ 来做更多的操作,上面的例子只是一个好的开始。

了解更多

下面的指南也非常有帮助:

  • Messaging with Redis
  • Messaging with JMS
  • 使用Spring Boot构建应用

原文发布于微信公众号 - 程序猿DD(didispace)

原文发表时间:2017-11-01

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏后台及大数据开发

docker:(4)利用WebHook实现持续集成

在项目调试测试阶段,可能经常需要重复上面的步骤,以便将最新代码部署到特定环境供测试人员或其他人员使用

1101
来自专栏Java技术栈

干货|基于 Spring Cloud 的微服务落地

6423
来自专栏bboysoul

体验一键php/java环境安装工具oneinstack

这个东西其实我很早之前就听说了,但是一直没有去尝试使用,我一直使用的是lnmp一键安装包,但是lnmp一键安装包是安装java环境的,oneinstack更强大...

2152
来自专栏恰同学骚年

.NET Core微服务之基于Steeltoe使用Spring Cloud Config统一管理配置

  在分布式系统中,每一个功能模块都能拆分成一个独立的服务,一次请求的完成,可能会调用很多个服务协调来完成,为了方便服务配置文件统一管理,更易于部署、维护,所以...

1914
来自专栏CodeSheep的技术分享

从SpringBoot到SpringMVC

用久了SpringBoot,深受其约定大于配置的便利性毒害之后,我想回归到SpringMVC时代,看看SpringMVC开发模式中用户是如何参与的。本文就来体验...

1678
来自专栏battcn

一起来学SpringBoot | 第十二篇:初探RabbitMQ消息队列

MQ全称(MessageQueue)又名消息队列,是一种异步通讯的中间件。可以将它理解成邮局,发送者将消息传递到邮局,然后由邮局帮我们发送给具体的消息接收者(消...

1081
来自专栏Android 研究

Android JNI学习(二)——实战JNI之“hello world”

首先在Android Studio创建一个Android项目,包名为gebilaolitou.ndkdemo

2484
来自专栏散尽浮华

Centos6.9下RocketMQ3.4.6高可用集群部署记录(双主双从+Nameserver+Console)

之前的文章已对RocketMQ做了详细介绍,这里就不再赘述了,下面是本人在测试和生产环境下RocketMQ3.4.6高可用集群的部署手册,在此分享下:

2353
来自专栏Android源码框架分析

听说你Binder机制学的不错,来面试下这几个问题(一)

6685
来自专栏程序猿DD

SpringBoot快速入门

简介 在您第1次接触和学习Spring框架的时候,是否因为其繁杂的配置而退却了?在你第n次使用Spring框架的时候,是否觉得一堆反复黏贴的配置有一些厌烦?那么...

1988

扫码关注云+社区

领取腾讯云代金券