RabbitMQ实战详解
1. MQ 的基本概念
1.1. MQ概述
- MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。
小结
- MQ，消息队列，存储消息的中间件
- 分布式系统通信两种方式：直接远程调用 和 借助第三方 完成间接通信
- 发送方称为生产者，接收方称为消费者
1.2 MQ 的优势和劣势
优势：
- 应用解耦
- 异步提速
- 削峰填古
劣势：
- 系统可用性降低
- 系统复杂性提高
- 一致性问题
1.3 MQ 的优势
1. 应用解耦
没有使用MQ：
- 系统的耦合性越高，容错性就越低，可维护性就越低。
使用MQ：
- 使用 MQ 使得应用间解耦，提升容错性和可维护性。
2. 异步提速
没有使用MQ：
- 一个下单操作耗时：20 + 300 + 300 + 300 = 920ms
- 用户点击完下单按钮后，需要等待920ms才能得到下单响应，太慢！
使用MQ：
- 用户点击完下单按钮后，只需等待25ms就能得到下单响应 (20 + 5 = 25ms)。
- 提升用户体验和系统吞吐量（单位时间内处理请求的数目）。
3. 削峰填谷
没有使用MQ：
使用MQ：
- 使用了 MQ 之后，限制消费消息的速度为1000，这样一来，高峰期产生的数据势必会被积压在 MQ
中，高峰就被“削”掉了，但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000，直到消费完积压的消息，这就叫做填谷。 - 使用MQ后，可以提高系统稳定性。
小结：
- 应用解耦：提高系统容错性和可维护性
- 异步提速：提升用户体验和系统吞吐量
- 削峰填谷：提高系统稳定性
1.4 MQ 的劣势
- 系统可用性降低
系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用？
- 系统复杂度提高
MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。如何保证消息没有被重复消费？怎么处理消息丢失情况？那么保证消息传递的顺序性？
- 一致性问题
A 系统处理完业务，通过 MQ 给B、C、D三个系统发消息数据，如果 B 系统、C 系统处理成功，D 系统处理失败。如何保证消息数据处理的一致性？
小结
既然 MQ 有优势也有劣势，那么使用 MQ 需要满足什么条件呢？
- 生产者不需要从消费者处获得反馈。引入消息队列之前的直接调用，其接口的返回值应该为空，这才让明明下层的动作还没做，上层却当成动作做完了继续往后走，即所谓异步成为了可能。
- 容许短暂的不一致性。
- 确实是用了有效果。即解耦、提速、削峰这些方面的收益，超过加入MQ，管理MQ这些成本。
1.5 常见的 MQ 产品
- 目前业界有很多的 MQ 产品，例如RabbitMQ、RocketMQ、ActiveMQ、Kafka、ZeroMQ、MetaMq等，也有直接使用 Redis充当消息队列的案例，而这些消息队列产品，各有侧重，在实际选型时，需要结合自身需求及 MQ 产品特征，综合考虑。
1.6 RabbitMQ 简介
- AMQP，即 Advanced Message Queuing Protocol（高级消息队列协议），是一个网络协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。2006年，AMQP
规范发布。类比HTTP。
2007年，Rabbit 技术公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。Erlang 语言由 Ericson 设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。
RabbitMQ 基础架构如下图：
RabbitMQ 中的相关概念：
- Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker
- Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost创建 exchange／queue 等
- Connection：publisher／consumer 和 broker 之间的 TCP 连接
- Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection的开销将是巨大的，效率也较低。Channel 是在 connection内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，AMQP method包含了channel id 帮助客户端和message broker 识别 channel，所以 channel之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销
- Exchange：message 到达 broker 的第一站**，根据分发规则，匹配查询表中的 routing key，分发消息到queue中去。**常用的类型有：direct (point-to-point), topic (publish-subscribe) and
fanout (multicast) - Queue：消息最终被送到这里等待 consumer 取走
- Binding：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding
信息被保存到 exchange 中的查询表中，用于 message 的分发依据
RabbitMQ 提供了 6 种工作模式：简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式（远程调用，不太算 MQ；暂不作介绍）。
官网对应模式介绍：https://www.rabbitmq.com/getstarted.html
1.7 JMS
- JMS 即 Java 消息服务（JavaMessage Service）应用程序接口，是一个 Java 平台中关于面向消息中间件的API
- JMS 是 JavaEE 规范中的一种，类比JDBC
- 很多消息中间件都实现了JMS规范，例如：ActiveMQ。RabbitMQ 官方没有提供 JMS 的实现包，但是开源社区有
小结
- RabbitMQ 是基于 AMQP 协议使用 Erlang 语言开发的一款消息队列产品。
- RabbitMQ提供了6种工作模式，我们学习5种。这是今天的重点。
- AMQP 是协议，类比HTTP。
- JMS 是 API 规范接口，类比 JDBC。
2. RabbitMQ 的安装和配置
- RabbitMQ 官方地址：http://www.rabbitmq.com/
- 安装文档：资料/软件/安装 RabbitMQ.md
上传文件：
1. 安装依赖环境
在线安装依赖环境：
yum install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz
2. 安装Erlang
# 安装
rpm -ivh erlang-18.3-1.el7.centos.x86_64.rpm
如果出现如下错误
说明gblic 版本太低。我们可以查看当前机器的gblic 版本
shell strings /lib64/libc.so.6 | grep GLIBC
当前最高版本2.12，需要2.15.所以需要升级glibc
-
使用yum更新安装依赖
sudo yum install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc make -y -
下载rpm包
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-utils-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-static-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-common-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-devel-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-headers-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/nscd-2.17-55.el6.x86_64.rpm &
-
安装rpm包
sudo rpm -Uvh *-2.17-55.el6.x86_64.rpm --force --nodeps -
安装完毕后再查看glibc版本,发现glibc版本已经到2.17了
strings /lib64/libc.so.6 | grep GLIBC
3. 安装RabbitMQ
# 安装
rpm -ivh socat-1.7.3.2-1.1.el7.x86_64.rpm --force --nodeps
# 安装
rpm -ivh rabbitmq-server-3.6.5-1.noarch.rpm
启动rabbitMQ
4. 开启管理界面及配置
# 开启管理界面
rabbitmq-plugins enable rabbitmq_management
# 修改默认配置信息
vi /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app
# 比如修改密码、配置等等，例如：loopback_users 中的 <<"guest">>,只保留guest
5. 启动
service rabbitmq-server start # 启动服务
service rabbitmq-server stop # 停止服务
service rabbitmq-server restart # 重启服务
6.访问
192.168.101.22是本机虚拟机ip地址
登录
输入用户名：guest 密码：guest
安装成功后显示如下
6. 配置虚拟主机及用户
6.1. 用户角色
RabbitMQ在安装好后，可以访问http://ip地址:15672 ；其自带了guest/guest的用户名和密码；如果需要创建自定义用户；那么也可以登录管理界面后，如下操作：
创建用户heima 密码也是heima
角色说明：
1、 超级管理员(administrator)
可登陆管理控制台，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
2、 监控者(monitoring)
可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
3、 策略制定者(policymaker)
可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)。
4、 普通管理者(management)
仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。
5、 其他
无法登陆管理控制台，通常就是普通的生产者和消费者。
6.2. Virtual Hosts配置
像mysql拥有数据库的概念并且可以指定用户对库和表等操作的权限。RabbitMQ也有类似的权限管理；在RabbitMQ中可以虚拟消息服务器Virtual Host，每个Virtual Hosts相当于一个相对独立的RabbitMQ服务器，每个VirtualHost之间是相互隔离的。exchange、queue、message不能互通。 相当于mysql的db。Virtual Name一般以/开头。
6.2.1. 创建Virtual Hosts
6.2.2. 设置Virtual Hosts权限
没有配置config文件
- 设置配置文件
cd /usr/share/doc/rabbitmq-server-3.6.5/
cp rabbitmq.config.example /etc/rabbitmq/rabbitmq.config
service rabbitmq-server restart
节点已配置
3. RabbitMQ 快速入门
3.1 入门程序
需求：使用简单模式完成消息传递
步骤：
1. 创建工程
目录如下：
2.分别添加依赖
pom.xml (这里生产者和消费者的依赖是一样的）
<!--rabbitmq java客户端依赖-->
<dependencies>
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.6.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
3.编写生产者发送消息
package com.itheima.producer;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
//简单模式
//发送消息
public class Producer_HelloWorld {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建队列Queue 暂时不用交换机
/*
String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments)
1.queue 队列名称
2.durable 是否持久化，当mq重启之后，还在
3.exclusive：
*是否独占：只能有一个消费者监听队列
*当connection关闭时，是否删除队列
4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
5.arguments: 参数
*/
//如果没有一个名字为hello_world的队列，则会创建队列，如果有则不会创建
channel.queueDeclare("hello_world",true,false,false,null);
//6.发送消息
/*
String exchange, String routingKey, boolean mandatory, byte[] body
参数：
1. exchange：交换机名称，简单模式下交换机会使用默认的 ""
2. routingKey: 路由名称
3. props: 配置信息
4. body: 发送消息数据
*/
String body="hello rabbitmq----";
channel.basicPublish("","hello_world",null,body.getBytes());
//7.释放资源
/*channel.close();
connection.close();*/
}
}
4.编写消费者接收消息
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_HelloWorld {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建队列Queue 暂时不用交换机
/*
String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments)
1.queue 队列名称
2.durable 是否持久化，当mq重启之后，还在
3.exclusive：
*是否独占：只能有一个消费者监听队列
*当connection关闭时，是否删除队列
4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
5.arguments: 参数
*/
//如果没有一个名字为hello_world的队列，则会创建队列，如果有则不会创建
channel.queueDeclare("hello_world",true,false,false,null);
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);
System.out.println("body:"+new String(body));//byte数组转string字符串
}
};
channel.basicConsume("hello_world",true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
效果如下：
消费者控制台成功收到消息
3.2 小结
上述的入门案例中其实使用的是如下的简单模式：
在上图的模型中，有以下概念：
- P：生产者，也就是要发送消息的程序
- C：消费者：消息的接收者，会一直等待消息到来
- queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息
4. RabbitMQ 的工作模式
4.1 Work queues 工作队列模式
1. 模式说明
- Work Queues：与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。（队列存在竞争关系，可以理解为抢红包）
- 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
2. 代码编写
Work Queues 与入门程序的简单模式的代码几乎是一样的。可以完全复制，并多复制一个消费者进行多个消费者同时对消费消息的测试。
Producer_WorkQueues
package com.itheima.producer;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
//简单模式
//发送消息
public class Producer_WorkQueues {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建队列Queue 暂时不用交换机
/*
String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments)
1.queue 队列名称
2.durable 是否持久化，当mq重启之后，还在
3.exclusive：
*是否独占：只能有一个消费者监听队列
*当connection关闭时，是否删除队列
4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
5.arguments: 参数
*/
//如果没有一个名字为hello_world的队列，则会创建队列，如果有则不会创建
channel.queueDeclare("work_queues",true,false,false,null);
//6.发送消息
/*
String exchange, String routingKey, boolean mandatory, byte[] body
参数：
1. exchange：交换机名称，简单模式下交换机会使用默认的 ""
2. routingKey: 路由名称
3. props: 配置信息
4. body: 发送消息数据
*/
for (int i = 1; i <=10; i++) {
String body=i+"hello rabbitmq----";
channel.basicPublish("","work_queues",null,body.getBytes());
}
//7.释放资源
/*channel.close();
connection.close();*/
}
}
Consumer_WorkQueues1
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_WorkQueues1 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建队列Queue 暂时不用交换机
/*
String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments)
1.queue 队列名称
2.durable 是否持久化，当mq重启之后，还在
3.exclusive：
*是否独占：只能有一个消费者监听队列
*当connection关闭时，是否删除队列
4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
5.arguments: 参数
*/
//如果没有一个名字为hello_world的队列，则会创建队列，如果有则不会创建
channel.queueDeclare("work_queues",true,false,false,null);
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);*/
System.out.println("body:"+new String(body));//byte数组转string字符串
}
};
channel.basicConsume("work_queues",true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
Consumer_WorkQueues2
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_WorkQueues2 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建队列Queue 暂时不用交换机
/*
String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments)
1.queue 队列名称
2.durable 是否持久化，当mq重启之后，还在
3.exclusive：
*是否独占：只能有一个消费者监听队列
*当connection关闭时，是否删除队列
4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
5.arguments: 参数
*/
//如果没有一个名字为hello_world的队列，则会创建队列，如果有则不会创建
channel.queueDeclare("work_queues",true,false,false,null);
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);*/
System.out.println("body:"+new String(body));//byte数组转string字符串
}
};
channel.basicConsume("work_queues",true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
3. 测试
注意：先运行消费者1和消费者2，再运行生产者
结果如下：消费者1消费消息序号 1,3,5,7,9
消费者2消费消息序号 2,4,6,8,10
4. 小结
- 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。
- Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。
4.2 Pub/Sub 订阅模式
1. 模式说明
在订阅模型中，多了一个 Exchange 角色，而且过程略有变化：
- P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
- C：消费者，消息的接收者，会一直等待消息到来
- Queue：消息队列，接收消息、缓存消息
- Exchange：交换机（X）。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
- Fanout：广播，将消息交给所有绑定到交换机的队列
- Direct：定向，把消息交给符合指定routing key 的队列
- Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列
Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息会丢失！
2. 代码编写
生产者Producer_PubSub
package com.itheima.producer;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
//发布订阅模式
//发送消息
public class Producer_PubSub {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建交换机
/*
exchangeDeclare
(String exchange, 交换机名称
BuiltinExchangeType type, 交换机类型 枚举类型
DIRECT("direct"), ：定向
FANOUT("fanout"), ：扇形（广播），发送消息到每一个与之绑定的队列
TOPIC("topic"),：通配符方式
HEADERS("headers");参数匹配
boolean durable, 是否持久化
boolean autoDelete, 是否自动删除
boolean internal, 内部使用一般false
Map<String, Object> arguments) 参数列表
*/
String exchangeName="test_fanout";
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
//6.创建两个队列
String queue1Name="test_fanout_queue1";
String queue2Name="test_fanout_queue2";
/*
String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments)
1.queue 队列名称
2.durable 是否持久化，当mq重启之后，还在
3.exclusive：
*是否独占：只能有一个消费者监听队列
*当connection关闭时，是否删除队列
4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
5.arguments: 参数
*/
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7，绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1.queue: 队列名称
2.exchange：交换机
3.routingKey：路由键：绑定规则
如果交换机的类型为fanout，routingKey设置为""
*/
channel.queueBind(queue1Name,exchangeName,"");
channel.queueBind(queue2Name,exchangeName,"");
//8.发送消息
String body="日志信息：张三调用了findAll方法...日志级别：info";
channel.basicPublish(exchangeName,"",null,body.getBytes());
//9.释放资源
channel.close();
connection.close();
}
}
Consumer_PubSub1
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_PubSub1 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.队列已经声明一次了，这里不用再声明队列
String queue1Name="test_fanout_queue1";
String queue2Name="test_fanout_queue2";
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);*/
System.out.println("body:"+new String(body));//byte数组转string字符串
System.out.println("将日志信息打印到控制台");
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
Consumer_PubSub2
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_PubSub2 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.队列已经声明一次了，这里不用再声明队列
String queue1Name="test_fanout_queue1";
String queue2Name="test_fanout_queue2";
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);*/
System.out.println("body:"+new String(body));//byte数组转string字符串
System.out.println("将日志信息保存数据库");
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
运行结果：
3. 小结
-
交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。
-
发布订阅模式与工作队列模式的区别：
工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机
发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)
发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑 定到默认的交换机
4.3 Routing 路由模式
1. 模式说明：
- 队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey（路由key）
- 消息的发送方在向 Exchange 发送消息时，也必须指定消息的 RoutingKey
- Exchange 不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的Routingkey 与消息的 Routing key 完全一致，才会接收到消息
图解：
- P：生产者，向 Exchange 发送消息，发送消息时，会指定一个routing key
- X：Exchange（交换机），接收生产者的消息，然后把消息递交给与 routing key 完全匹配的队列
- C1：消费者，其所在队列指定了需要 routing key 为 error 的消息
- C2：消费者，其所在队列指定了需要 routing key 为 info、error、warning 的消息
2. 代码编写
Producer_Routing
package com.itheima.producer;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
//Routing
//发送消息
public class Producer_Routing {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建交换机
/*
exchangeDeclare
(String exchange, 交换机名称
BuiltinExchangeType type, 交换机类型 枚举类型
DIRECT("direct"), ：定向
FANOUT("fanout"), ：扇形（广播），发送消息到每一个与之绑定的队列
TOPIC("topic"),：通配符方式
HEADERS("headers");参数匹配
boolean durable, 是否持久化
boolean autoDelete, 是否自动删除
boolean internal, 内部使用一般false
Map<String, Object> arguments) 参数列表
*/
String exchangeName="test_direct";
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,false,null);
//6.创建两个队列
String queue1Name="test_direct_queue1";
String queue2Name="test_direct_queue2";
/*
String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments)
1.queue 队列名称
2.durable 是否持久化，当mq重启之后，还在
3.exclusive：
*是否独占：只能有一个消费者监听队列
*当connection关闭时，是否删除队列
4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
5.arguments: 参数
*/
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7，绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1.queue: 队列名称
2.exchange：交换机
3.routingKey：路由键：绑定规则
如果交换机的类型为fanout，routingKey设置为""
*/
//队列1的绑定 error
channel.queueBind(queue1Name,exchangeName,"error");
//队列2的绑定 info，error，warning
channel.queueBind(queue2Name,exchangeName,"info");
channel.queueBind(queue2Name,exchangeName,"error");
channel.queueBind(queue2Name,exchangeName,"warning");
//8.发送消息
String body="日志信息：张三调用了delete方法出错误了...日志级别：error";
channel.basicPublish(exchangeName,"error",null,body.getBytes());
//9.释放资源
channel.close();
connection.close();
}
}
Consumer_Routing1
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_Routing1 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.队列已经声明一次了，这里不用再声明队列
String queue1Name="test_direct_queue1";
String queue2Name="test_direct_queue2";
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);*/
System.out.println("body:"+new String(body));//byte数组转string字符串
System.out.println("将日志信息打印到控制台");
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
Consumer_Routing2
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_Routing2 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.队列已经声明一次了，这里不用再声明队列
String queue1Name="test_direct_queue1";
String queue2Name="test_direct_queue2";
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);*/
System.out.println("body:"+new String(body));//byte数组转string字符串
System.out.println("将日志信息存储到数据库");
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
运行结果
3. 小结
- Routing 模式：要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列。
4.4 Topics 通配符模式
1. 模式说明
- Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic
类型Exchange 可以让队列在绑定 Routing key 的时候使用通配符！ - Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
- 通配符规则：# 匹配一个或多个词，* 匹配不多不少恰好1个词，例如：item.# 能够匹配 item.insert.abc 或者
- item.insert，item.* 只能匹配 item.insert
图解：
- 红色 Queue：绑定的是 usa.# ，因此凡是以 usa. 开头的 routing key 都会被匹配到
- 黄色 Queue：绑定的是 #.news ，因此凡是以 .news 结尾的 routing key 都会被匹配
- *代表一个单词，#代表0个或者多个单词
2.代码实现
Producer_Topics
package com.itheima.producer;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
//发送消息
public class Producer_Topics {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.创建交换机
/*
exchangeDeclare
(String exchange, 交换机名称
BuiltinExchangeType type, 交换机类型 枚举类型
DIRECT("direct"), ：定向
FANOUT("fanout"), ：扇形（广播），发送消息到每一个与之绑定的队列
TOPIC("topic"),：通配符方式
HEADERS("headers");参数匹配
boolean durable, 是否持久化
boolean autoDelete, 是否自动删除
boolean internal, 内部使用一般false
Map<String, Object> arguments) 参数列表
*/
String exchangeName="test_topic";
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
//6.创建两个队列
String queue1Name="test_topic_queue1";
String queue2Name="test_topic_queue2";
/*
String queue, boolean durable, boolean exclusive, boolean autoDelete,
Map<String, Object> arguments)
1.queue 队列名称
2.durable 是否持久化，当mq重启之后，还在
3.exclusive：
*是否独占：只能有一个消费者监听队列
*当connection关闭时，是否删除队列
4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
5.arguments: 参数
*/
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7，绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1.queue: 队列名称
2.exchange：交换机
3.routingKey：路由键：绑定规则
如果交换机的类型为fanout，routingKey设置为""
*/
//routing key：系统的名称，日志级别
//--需求：所有error级别的日志存入数据库，所有order系统的日志存入数据库
channel.queueBind(queue1Name,exchangeName,"#.error");
channel.queueBind(queue1Name,exchangeName,"order.*");
channel.queueBind(queue2Name,exchangeName,"*.*");
//8.发送消息
String body="日志信息：张三调用了findAll方法...日志级别：info";
channel.basicPublish(exchangeName,"order.info",null,body.getBytes());
//9.释放资源
channel.close();
connection.close();
}
}
Consumer_Topic1
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_Topic1 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.队列已经声明一次了，这里不用再声明队列
String queue1Name="test_topic_queue1";
String queue2Name="test_topic_queue2";
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);*/
System.out.println("body:"+new String(body));//byte数组转string字符串
System.out.println("将日志信息存入数据库");
}
};
channel.basicConsume(queue1Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
Consumer_Topic2
package com.itheima.consumer;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer_Topic2 {
public static void main(String[] args) throws IOException, TimeoutException {
//1.创建连接工厂
ConnectionFactory factory=new ConnectionFactory();
//2.设置参数
factory.setHost("192.168.101.22");//ip地址 默认localhost
factory.setPort(5672);//端口 默认值5672
factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
factory.setUsername("heima");//用户名 默认guest
factory.setPassword("heima");//密码 默认guest
//3.创建连接 connection
Connection connection = factory.newConnection();
//4.创建channel
Channel channel = connection.createChannel();
//5.队列已经声明一次了，这里不用再声明队列
String queue1Name="test_topic_queue1";
String queue2Name="test_topic_queue2";
//6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck: 是否自动确认
3. callback: 回调对象
*/
Consumer consumer=new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1.consumerTag：标识
2.envelope：获取一些信息。交换机，路由key...
3.properties: 配置信息
4.body: 数据
*/
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
/* System.out.println("consumerTag:"+consumerTag);
System.out.println("exchange:"+envelope.getExchange());
System.out.println("RoutingKey:"+envelope.getRoutingKey());
System.out.println("properties:"+properties);*/
System.out.println("body:"+new String(body));//byte数组转string字符串
System.out.println("将日志信息打印到控制台");
}
};
channel.basicConsume(queue2Name,true,consumer);
//关闭资源？不要，因为消费者要监听
}
}
3.测试
4. 小结
- Topic 主题模式可以实现 Pub/Sub 发布与订阅模式和 Routing 路由模式的功能，只是 Topic 在配置routing key 的时候可以使用通配符，显得更加灵活。
4.5 工作模式总结
5. Spring 整合RabbitMQ
5.1 Spring 整合 RabbitMQ
需求：使用 Spring 整合 RabbitMQ
生产者
pom.xml 生产者跟消费者的pom依赖是一样的
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>2.1.8.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.7.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
rabbitmq.properties
rabbitmq.host=192.168.101.22
rabbitmq.port=5672
rabbitmq.username=heima
rabbitmq.password=heima
rabbitmq.virtual-host=/itcast
spring-rabbitmq-producer.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:rabbit="http://www.springframework.org/schema/rabbit"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/rabbit
http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
<!--加载配置文件-->
<context:property-placeholder location="classpath:rabbitmq.properties"/>
<!-- 定义rabbitmq connectionFactory -->
<rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
port="${rabbitmq.port}"
username="${rabbitmq.username}"
password="${rabbitmq.password}"
virtual-host="${rabbitmq.virtual-host}"/>
<!--定义管理交换机、队列-->
<rabbit:admin connection-factory="connectionFactory"/>
<!--定义持久化队列，不存在则自动创建；不绑定到交换机则绑定到默认交换机
默认交换机类型为direct，名字为：""，路由键为队列的名称
-->
<rabbit:queue id="spring_queue" name="spring_queue" auto-declare="true"/>
<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~广播；所有队列都能收到消息~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<!--定义广播交换机中的持久化队列，不存在则自动创建-->
<rabbit:queue id="spring_fanout_queue_1" name="spring_fanout_queue_1" auto-declare="true"/>
<!--定义广播交换机中的持久化队列，不存在则自动创建-->
<rabbit:queue id="spring_fanout_queue_2" name="spring_fanout_queue_2" auto-declare="true"/>
<!--定义广播类型交换机；并绑定上述两个队列-->
<rabbit:fanout-exchange id="spring_fanout_exchange" name="spring_fanout_exchange" auto-declare="true">
<rabbit:bindings>
<rabbit:binding queue="spring_fanout_queue_1"/>
<rabbit:binding queue="spring_fanout_queue_2"/>
</rabbit:bindings>
</rabbit:fanout-exchange>
<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~通配符；*匹配一个单词，#匹配多个单词 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<!--定义广播交换机中的持久化队列，不存在则自动创建-->
<rabbit:queue id="spring_topic_queue_star" name="spring_topic_queue_star" auto-declare="true"/>
<!--定义广播交换机中的持久化队列，不存在则自动创建-->
<rabbit:queue id="spring_topic_queue_well" name="spring_topic_queue_well" auto-declare="true"/>
<!--定义广播交换机中的持久化队列，不存在则自动创建-->
<rabbit:queue id="spring_topic_queue_well2" name="spring_topic_queue_well2" auto-declare="true"/>
<rabbit:topic-exchange id="spring_topic_exchange" name="spring_topic_exchange" auto-declare="true">
<rabbit:bindings>
<rabbit:binding pattern="heima.*" queue="spring_topic_queue_star"/>
<rabbit:binding pattern="heima.#" queue="spring_topic_queue_well"/>
<rabbit:binding pattern="itcast.#" queue="spring_topic_queue_well2"/>
</rabbit:bindings>
</rabbit:topic-exchange>
<!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
<rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
</beans>
ProducersTest
package com.itheima;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
public class ProducersTest {
//1.注入rabbitTemplate
@Autowired
private RabbitTemplate rabbitTemplate;
//简单模式
@Test
public void testHelloWorld(){
//2.发送消息
rabbitTemplate.convertAndSend("spring_queue","hello world spring...");
}
//发送fanout消息
@Test
public void testFanout(){
//2.发送消息
rabbitTemplate.convertAndSend("spring_fanout_exchange","","spring fanout...");
}
//发送topics消息
@Test
public void testTopic(){
//2.发送消息
rabbitTemplate.convertAndSend("spring_topic_exchange","heima.hehe.haha","spring topic...");
}
}
测试：分别运行测试方法，结果如下图
消费者
pom.xml与生产者一致
rabbitmq.properties
rabbitmq.host=192.168.101.22
rabbitmq.port=5672
rabbitmq.username=heima
rabbitmq.password=heima
rabbitmq.virtual-host=/itcast
spring-rabbitmq-consumer.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:rabbit="http://www.springframework.org/schema/rabbit"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/rabbit
http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
<!--加载配置文件-->
<context:property-placeholder location="classpath:rabbitmq.properties"/>
<!-- 定义rabbitmq connectionFactory -->
<rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
port="${rabbitmq.port}"
username="${rabbitmq.username}"
password="${rabbitmq.password}"
virtual-host="${rabbitmq.virtual-host}"/>
<bean id="springQueueListener" class="com.itheima.rabbitmq.listener.SpringQueueListener"/>
<!-- <bean id="fanoutListener1" class="com.itheima.rabbitmq.listener.FanoutListener1"/>
<bean id="fanoutListener2" class="com.itheima.rabbitmq.listener.FanoutListener2"/>
<bean id="topicListenerStar" class="com.itheima.rabbitmq.listener.TopicListenerStar"/>
<bean id="topicListenerWell" class="com.itheima.rabbitmq.listener.TopicListenerWell"/>
<bean id="topicListenerWell2" class="com.itheima.rabbitmq.listener.TopicListenerWell2"/>-->
<rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
<rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
<!-- <rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"/>
<rabbit:listener ref="fanoutListener2" queue-names="spring_fanout_queue_2"/>
<rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"/>
<rabbit:listener ref="topicListenerWell" queue-names="spring_topic_queue_well"/>
<rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>-->
</rabbit:listener-container>
</beans>
SpringQueueListener
package com.itheima.rabbitmq.listener;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;
public class SpringQueueListener implements MessageListener {
@Override
public void onMessage(Message message) {
//打印消息
System.out.println(new String(message.getBody()));
}
}
ConsumerTest
package com.itheima;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-consumer.xml")
public class ConsumerTest {
@Test
public void test(){
boolean flag=true;
while(true){
}
}
}
测试：
队列参数简介
<!--
id: bean的名称
name：quque名称
auto-declare:自动创建
auto-delete: 自动删除，最后一个消费者和该队列断开连接后，自动删除队列
durable:是否持久化
exclusive:是否独占
-->
<rabbit:queue id="spring_queue" name="spring_queue" auto-declare="true"/>
direct exchange补充
5.2 小结
- 使用 Spring 整合 RabbitMQ 将组件全部使用配置方式实现，简化编码
- Spring 提供 RabbitTemplate 简化发送消息 API
- 使用监听机制简化消费者编码
6. SpringBoot 整合 RabbitMQ
生产端
- 创建生产者SpringBoot工程
- 引入start，依赖坐标
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
- 编写yml配置，基本信息配置
- 定义交换机，队列以及绑定关系的配置类
- 注入RabbitTemplate，调用方法，完成消息发送
pom.xml
<!--
父工程依赖
-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<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>
</dependency>
</dependencies>
RabbitMQConfig
package com.itheima.rabbitmq.config;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitMQConfig {
public static final String EXCHANGE_NAME="boot_topic_exchange";
public static final String QUEUE_NAME="boot_quque";
//1.交换机
@Bean("bootExchange")
public Exchange bootExchange(){
return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
}
//2.队列 Queue
@Bean("bootQueue")
public Queue bootQueue(){
return QueueBuilder.durable(QUEUE_NAME).build();
}
//3.队列和交换机的绑定关系 binding
/*
1.知道哪个队列
2.知道哪个交换机
3.routing key
*/
@Bean
public Binding bindQueueExange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
}
}
ProducerApplication
package com.itheima;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ProducerApplication {
public static void main(String[] args) {
SpringApplication.run(ProducerApplication.class);
}
}
application.yml
# 配置rabbitmq的基本信息 IP端口 username passwordspring:
spring:
rabbitmq:
host: 192.168.101.22
port: 5672
virtual-host: /itcast
username: heima
password: heima
ProducerTest
package com.itheima.test;
import com.itheima.rabbitmq.config.RabbitMQConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@SpringBootTest
@RunWith(SpringRunner.class)
public class ProducerTest {
//1.注入rabbitTemplate
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testSend(){
rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.haha","boot mq hello---");
}
}
测试：运行Junit Test
消费端
- 创建消费者SpringBoot工程
- 引入start，依赖坐标
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
- 编写yml配置，基本信息配置
- 定义监听类，使用@RabbitListener注解完成队列监听。
ConsumerSpringbootApplication
package com.itheima;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ConsumerSpringbootApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerSpringbootApplication.class, args);
}
}
RabbitMQListener
package com.itheima;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class RabbitMQListener {
@RabbitListener(queues = "boot_quque")
public void ListenerQueue(Message message){
System.out.println(new String(message.getBody()));
}
}
application.yml
# 配置rabbitmq的基本信息 IP端口 username passwordspring:
spring:
rabbitmq:
host: 192.168.101.22
port: 5672
virtual-host: /itcast
username: heima
password: heima
pom.xml
<!--
父工程依赖
-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<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>
</dependency>
</dependencies>
运行ConsumerSpringbootApplication, 消费者拿到消息
小结
- SpringBoot提供了快速整合RabbitMQ的方式
- 基本信息在yml中配置，队列交互机以及绑定关系在配置类中使用Bean的方式配置
- 生产端直接注入RabbitTemplate完成消息发送
- 消费端直接使用@RabbitListener完成消息接收
183
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
