SpringBoot 与 RabbitMQ 整合实践

RabbitMQ服务搭建

这里介绍三种平台的搭建方式，分别是docker平台、centos平台以及ubuntu平台。其中docker部署最为方便，只需搭建好docker平台，下载镜像，然后启动即可。其他两种平台分别用两种方式实现，一是使用各自的软件管理工具在线安装，二是下载软件包离线安装。

Docker平台

Docker环境搭建

参考：https://www.runoob.com/docker/ubuntu-docker-install.html

这里介绍的是ubuntu 16.04系统上搭建docker环境的步骤。
1、如果安装过docker旧版本，使用以下命令卸载旧版本docker。

apt-get remove docker docker-engine docker.io containerd runc

2、更新仓库。

apt-get update

3、安装依赖包。

apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common

4、添加docker GPG key，我们使用阿里云的版本。

curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | apt-key add -

5、添加repository，我们使用阿里云的版本。

add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"

6、再次更新仓库

apt-get update

7、安装最新版本的docker ce和containerd.io。

apt-get install docker-ce docker-ce-cli containerd.io

8、检查安装是否成功。

docker --version

9、设置开机自动启动并启动docker-ce。

systemctl enable docker

systemctl start docker

10、设置docker设置国内镜像源，创建或修改 /etc/docker/daemon.json 文件，修改为如下形式。

vim /etc/docker/daemon.json

# vi /etc/docker/daemon.json
{
    "registry-mirrors": ["https://registry.docker-cn.com"]
}

11、重启docker服务。

systemctl stop docker

systemctl start docker

12、查看docke配置信息。

docker info

从图中可以看到镜像源已经修改为国内源了。

安装RabbitMQ镜像

1、使用docker run命令拉取并运行RabbitMQ镜像。

docker run -d --name my-rabbitmq --hostname my-rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3-management

docker run 命令简介
-d 后台运行容器，并返回容器ID
–name 容器别名
–hostname 机器实例的名称
-p 端口映射
rabbitmq:3-management 表示包含管理工具

2、RabbitMQ镜像及容器操作
docker images 查看本地镜像列表
docker ps -a 查看容器列表，运行的或未运行的
docker start xxx 启动指定容器id或名称的容器
docker stop xxx 停止指定容器id或名称的容器

3、登录RabbitMQ管理页面
在浏览器输入 http://ip:15672 打开RabbitMQ管理页面，默认登录用户名 guest，密码也是 guest。

Ubuntu 平台

使用apt-get从安装源在线安装

首先配置国内软件源，这样可以大幅提高软件下载速度。

1、更新仓库

apt-get update

2、由于rabbitMq需要erlang语言的支持，在安装rabbitMq之前需要安装erlang，执行命令：

apt-get install erlang-nox

3、验证erlang安装结果，执行命令：

erl

顺利进入erlang命令行，表示安装成功。

4、安装RabbitMQ Server，执行命令：

apt-get install rabbitmq-server

5、验证安装结果，执行命令：

systemctl status rabbitmq-server

6、设置开机自动启动rabbitmq-server。

systemctl enable rabbitmq-server

服务控制命令介绍：
systemctl start rabbitmq-server 启动rabbitmq-server
systemctl stop rabbitmq-server 停止rabbitmq-server
systemctl restart rabbitmq-server 重启rabbitmq-server

7、启用rabbitmq的管理工具插件。

查看插件列表

rabbitmq-plugins list

启用 rabbitmq_management 插件

rabbitmq-plugins enable rabbitmq_management

重启rabbitmq-server服务

systemctl restart rabbitmq-server

在浏览器输入地址http://ip:15672可以打开管理页面。

8、创建web登录账户，并赋予管理员角色。

rabbitmq-server默认的guest用户只能本地登录，可以创建一个新用户实现远程登录web页面。

rabbitmqctl add_user admin netinfo,123

给admin用户赋予管理员权限。

rabbitmqctl set_user_tags admin administrator

这样就可以使用admin用户登录web管理页面了。

下载deb软件包离线安装

1、下载所需的deb软件包

RabbitMQ主要依赖两个组件，erlang和socat，需要下载以下三个软件包：

esl-erlang_22.3-1_ubuntuxenial_amd64.deb
rabbitmq-server_3.8.3-1_all.deb
socat_1.7.2.4-2_amd64.deb

erlang下载地址：

https://www.erlang-solutions.com/resources/download.html

选择 Ubuntu Xenial (64-bit) 版本。

socat下载地址：

https://packages.debian.org/stretch/amd64/socat/download

选择亚洲区中国的站点下载，Asia/ftp.cn.debian.org/debian

http://ftp.cn.debian.org/debian/pool/main/s/socat/socat_1.7.3.1-2+deb9u1_amd64.deb

rabbitmq-server下载地址：

https://packagecloud.io/rabbitmq/rabbitmq-server

选择 ubuntu/xenial 版本。

2、将软件包复制到Ubuntu服务器上，这里放在了/opt目录下。

3、安装软件包。

安装erlang：

dpkg -i esl-erlang_22.3-1~ubuntu~xenial_amd64.deb

这一步有可能报缺少libwxbase依赖的错误，按照提示安装好依赖，输入命令：

apt-get update

apt-get install libwxbase3.0-0v5

又会报一个错误，提示使用 apt-get -f install 命令，根据提示输入命令：

apt-get -f install

等待一会，正在安装依赖包。

验证erlang安装结果，执行命令：

erl

安装socat：

dpkg -i socat_1.7.2.4-2_amd64.deb

安装rabbitmq-server：

dpkg -i rabbitmq-server_3.8.3-1_all.deb

安装完成。

接下来服务启动、开机启动、启用管理插件、创建web登录账户等操作与前文相同，此处不再重复。

CentOS平台

这里CentOS系统的版本是CentOS7。

使用yum包管理工具在线安装

首先配置国内软件源，这样可以大幅提高软件下载速度。

1、安装依赖：

yum -y install gcc glibc-devel make ncurses-devel openssl-devel xmlto perl wget gtk2-devel binutils-devel

2、安装erlang：

curl -s https://packagecloud.io/install/repositories/rabbitmq/erlang/script.rpm.sh | sudo bash

yum install erlang

3、安装rabbitmq-server：

curl -s https://packagecloud.io/install/repositories/rabbitmq/rabbitmq-server/script.rpm.sh | sudo bash

yum install rabbitmq-server

安装完成。

接下来服务启动、开机启动、启用管理插件、创建web登录账户等操作与前文相同，此处不再重复。

使用rpm软件包离线安装

安装RabbitMQ需要以下三个软件包：

erlang-22.3-1.el7.x86_64.rpm
rabbitmq-server-3.8.3-1.el7.noarch.rpm
socat-1.7.3.2-2.el7.x86_64.rpm

1、下载rpm软件包。

下载 erlang：

https://packagecloud.io/rabbitmq/erlang

选择 el/7 版本。

下载socat：

http://www.rpmfind.net/linux/rpm2html/search.php?query=socat(x86-64)

选择 el/7 x86_64 版本，即：socat-1.7.3.2-2.el7.x86_64.rpm。

下载rabbitmq-server：

https://packagecloud.io/rabbitmq/rabbitmq-server

选择 el/7 版本。

2、将rmp软件包复制到服务器上，本例放在了/opt 目录下。

3、安装rpm软件包。

安装erlang：

rpm -ivh erlang-22.3-1.el7.x86_64.rpm

安装socat：

rpm -ivh socat-1.7.3.2-2.el7.x86_64.rpm

安装rabbitmq-server：

rpm -ivh rabbitmq-server-3.8.3-1.el7.noarch.rpm

安装完成。

接下来服务启动、开机启动、启用管理插件、创建web登录账户等操作与前文相同，此处不再重复。

SpringBoot 集成RabbitMQ

这里通过一个简单的实例介绍SpringBoot集成RabbitMQ的一般步骤。实例包括两个项目，分别作为消息生产者（RabbitMQ Producer）和消费者（RabbitMQ Consumer），项目结构如下图所示：

项目配置

1、添加依赖。

>
    >org.springframework.boot>
    >spring-boot-starter-amqp>
>
>
    >org.springframework.boot>
    >spring-boot-starter-web>
>

2、配置RabbitMQ服务连接信息。

在application.properties配置文件中添加以下配置：

spring.rabbitmq.host=192.168.1.20
spring.rabbitmq.port=5672
spring.rabbitmq.username=rabbit
spring.rabbitmq.password=rabbit

简单队列

P：消息的生产者
C：消息的消费者
红色：队列
生产者将消息发送到队列，消费者从队列中获取消息。

消息生产者

1、添加DirectRabbitConfig

@Configuration
public class DirectRabbitConfig {

    @Bean
    public Queue TestDirectQueue() {
        return new Queue("TestDirectQueue", true);
    }

    @Bean
    public DirectExchange TestDirectExchange() {
        return new DirectExchange("TestDirectExchange");
    }

    @Bean
    public Binding bindingDirect() {
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }

}

2、添加测试Controller

@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RequestMapping(value = "/send_direct_msg", method = RequestMethod.POST)
    public String sendDirectMessage(@RequestParam("msg") String msg) {
        String msgId = String.valueOf(UUID.randomUUID());
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        String msgData = "Direct message.\t" + msg;
        Map<String, Object> map = new HashMap<>();
        map.put("msg_id", msgId);
        map.put("msg_data", msgData);
        map.put("create_time", createTime);
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";
    }

}

3、启动项目，启动Rest Client测试消息发送

消息消费者

1、添加DirectRabbitConfig

内容与消息生产者一样，也可以不添加这个配置。

2、添加DirectReceiver

@Component
@RabbitListener(queues = "TestDirectQueue")
public class DirectReceiver {

    @RabbitHandler
    public void process(Map msgMap) {
        System.out.println("DirectReceiver消费者收到消息  : " + msgMap.toString());
    }

}

3、启动项目，查看日志

可见，消息已经接收到。

订阅模式

解读：
1、1个生产者，多个消费者
2、每一个消费者都有自己的一个队列
3、生产者没有将消息直接发送到队列，而是发送到了交换机
4、每个队列都要绑定到交换机
5、生产者发送的消息，经过交换机，到达队列，实现，一个消息被多个消费者获取的目的
注意：一个消费者队列可以有多个消费者实例，只有其中一个消费者实例会消费

消息生产者

1、添加TopicRabbitConfig

@Configuration
public class TopicRabbitConfig {
    public static final String MAN = "topic.man";
    public static final String WOMAN = "topic.woman";

    @Bean
    public Queue firstQueue() {
        return new Queue(MAN);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue(WOMAN);
    }

    @Bean
    public TopicExchange exchange() {
        return new TopicExchange("topicExchange");
    }

    @Bean
    public Binding bindingExchangeMessage() {
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(MAN);
    }


    @Bean
    public Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }
}

2、添加测试Controller

@RequestMapping(value = "/send_topic_msg_1", method = RequestMethod.POST)
public String sendTopicMessage1(@RequestParam("msg") String msg) {
    String msgId = String.valueOf(UUID.randomUUID());
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    String msgData = "Topic message 1.\t" + msg;
    Map<String, Object> map = new HashMap<>();
    map.put("msg_id", msgId);
    map.put("msg_data", msgData);
    map.put("create_time", createTime);
    rabbitTemplate.convertAndSend("topicExchange", "topic.man", map);
    return "ok";
}

@RequestMapping(value = "/send_topic_msg_2", method = RequestMethod.POST)
public String sendTopicMessage2(@RequestParam("msg") String msg) {
    String msgId = String.valueOf(UUID.randomUUID());
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    String msgData = "Topic message 2.\t" + msg;
    Map<String, Object> map = new HashMap<>();
    map.put("msg_id", msgId);
    map.put("msg_data", msgData);
    map.put("create_time", createTime);
    rabbitTemplate.convertAndSend("topicExchange", "topic.woman", map);
    return "ok";
}

3、启动项目，启动Rest Client测试消息发送

消息消费者

1、添加TopicRabbitConfig

内容与消息生产者一样。

2、添加TopicReceiver

@Component
@RabbitListener(queues = "topic.man")
public class TopicManReceiver {

    @RabbitHandler
    public void process(Map msgMap) {
        System.out.println("TopicManReceiver消费者收到消息  : " + msgMap.toString());
    }

}

@Component
@RabbitListener(queues = "topic.woman")
public class TopicTotalReceiver {

    @RabbitHandler
    public void process(Map msgMap) {
        System.out.println("TopicTotalReceiver消费者收到消息  : " + msgMap.toString());
    }
}

3、启动项目，查看日志

扇形模式

消息生产者

1、添加FanoutRabbitConfig

@Configuration
public class FanoutRabbitConfig {

    @Bean
    public Queue queueA() {
        return new Queue("fanout.A");
    }

    @Bean
    public Queue queueB() {
        return new Queue("fanout.B");
    }

    @Bean
    public Queue queueC() {
        return new Queue("fanout.C");
    }

    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    public Binding bindingExchangeA() {
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }

    @Bean
    public Binding bindingExchangeB() {
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }

    @Bean
    public Binding bindingExchangeC() {
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }

}

2、添加测试Controller

@RequestMapping(value = "/send_fanout_msg", method = RequestMethod.POST)
public String sendFanoutMessage(@RequestParam("msg") String msg) {
    String msgId = String.valueOf(UUID.randomUUID());
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    String msgData = "Fanout message.\t" + msg;
    Map<String, Object> map = new HashMap<>();
    map.put("msg_id", msgId);
    map.put("msg_data", msgData);
    map.put("create_time", createTime);
    rabbitTemplate.convertAndSend("fanoutExchange", null, map);
    return "ok";
}

3、启动项目，启动Rest Client测试消息发送

消息消费者

1、添加FanoutRabbitConfig

内容与消息生产者一样。

2、添加FanoutReceiver

@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {

    @RabbitHandler
    public void process(Map msgMap) {
        System.out.println("FanoutReceiverA消费者收到消息  : " + msgMap.toString());
    }

}

@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {

    @RabbitHandler
    public void process(Map msgMap) {
        System.out.println("FanoutReceiverB消费者收到消息  : " + msgMap.toString());
    }

}

@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {

    @RabbitHandler
    public void process(Map msgMap) {
        System.out.println("FanoutReceiverC消费者收到消息  : " + msgMap.toString());
    }

}

3、启动项目，查看日志