文章目录
RabbitMQ
1.RabbitMQ介绍
MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开 发中应用非常广泛。RabbitMQ官方地址
开发中消息队列通常有如下应用场景：
1、任务异步处理。 将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。
2、应用程序解耦合 MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。
市场上还有哪些消息队列？
ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ、Redis。
为什么使用RabbitMQ呢？
1、使得简单，功能强大。
2、基于AMQP协议。
3、社区活跃，文档完善。
4、高并发性能好，这主要得益于Erlang语言。
5、Spring Boot默认已集成RabbitMQ
2.其它相关知识
AMQP是什么？
总结：AMQP是一套公开的消息队列协议，最早在2003年被提出，它旨在从协议层定义消息通信数据的标准格式， 为的就是解决MQ市场上协议不统一的问题。RabbitMQ就是遵循AMQP标准协议开发的MQ服务。
官方地址
JMS是什么？
总结：
JMS是java提供的一套消息服务API标准，其目的是为所有的java应用程序提供统一的消息通信的标准，类似java的 jdbc，只要遵循jms标准的应用程序之间都可以进行消息通信。它和AMQP有什么 不同，jms是java语言专属的消 息服务标准，它是在api层定义标准，并且只能用于java应用；而AMQP是在协议层定义的标准，是跨语言的 。
快速入门
1.RabbitMQ的工作原理
下图是RabbitMQ的基本结构：
组成部分说明如下：
Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue。
Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑。
Queue：消息队列，存储消息的队列，消息到达队列并转发给指定的消费方。
Producer：消息生产者，即生产方客户端，生产方客户端将消息发送到MQ。
Consumer：消息消费者，即消费方客户端，接收MQ转发的消息。
消息发布接收流程：
-----发送消息-----
1、生产者和Broker建立TCP连接。
2、生产者和Broker建立通道。
3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。
4、Exchange将消息转发到指定的Queue（队列）
----接收消息-----
1、消费者和Broker建立TCP连接
2、消费者和Broker建立通道
3、消费者监听指定的Queue（队列）
4、当有消息到达Queue时Broker默认将消息推送给消费者。
5、消费者接收到消息。
2.下载安装
1.下载安装
RabbitMQ由Erlang语言开发，Erlang语言用于并发及分布式系统的开发，在电信领域应用广泛，OTP（Open Telecom Platform）作为Erlang语言的一部分，包含了很多基于Erlang开发的中间件及工具库，安装RabbitMQ需 要安装Erlang/OTP，并保持版本匹配，如下图：
RabbitMQ的下载地址
本次使用Erlang/OTP 20.3版本和RabbitMQ3.7.3版本。
1）下载erlang
地址如下：
http://erlang.org/download/otp_win64_20.3.exe，以管理员方式运行此文件，安装。
erlang安装完成需要配置erlang环境变量： ERLANG_HOME=D:\Program Files\erl9.3 在path中添加%ERLANG_HOME%\bin。
2）安装RabbitMQ
https://github.com/rabbitmq/rabbitmq-server/releases/tag/v3.7.3，以管理员方式运行此文件，安装。
2.启动
安装成功后会自动创建RabbitMQ服务并且启动。
1）从开始菜单启动RabbitMQ
完成在开始菜单找到RabbitMQ的菜单：
RabbitMQ Service-install :安装服务
RabbitMQ Service-remove 删除服务
RabbitMQ Service-start 启动
RabbitMQ Service-stop 启动
2）如果没有开始菜单则进入安装目录下sbin目录手动启动：
1）安装并运行服务
rabbitmq-service.bat install 安装服务 rabbitmq-service.bat stop 停止服务 rabbitmq-service.bat start 启动服务
2）安装管理插件
安装rabbitMQ的管理插件，方便在浏览器端管理RabbitMQ
管理员身份运行 rabbitmq-plugins.bat enable rabbitmq_management
3、启动成功 登录RabbitMQ
进入浏览器，输入：http://localhost:15672
初始账号和密码：guest/guest
3.注意事项
1、安装erlang和rabbitMQ以管理员身份运行。
2、当卸载重新安装时会出现RabbitMQ服务注册失败，此时需要进入注册表清理erlang 搜索RabbitMQ、ErlSrv，将对应的项全部删除。
3.Hello World
按照官方教程(http://www.rabbitmq.com/getstarted.html)测试hello world：
1.搭建环境
1）java client
生产者和消费者都属于客户端，rabbitMQ的java客户端如下：
我们先用 rabbitMQ官方提供的java client测试，目的是对RabbitMQ的交互过程有个清晰的认识。
参考 ：https://github.com/rabbitmq/rabbitmq-java-client/
2）创建maven工程
创建生产者工程和消费者工程，分别加入RabbitMQ java client的依赖。
test-rabbitmq-producer：生产者工程
test-rabbitmq-consumer：消费者工程
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp‐client</artifactId>
<version>4.0.3</version><!‐‐此版本与spring boot 1.5.9版本匹配‐‐>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>
2.生产者
在生产者工程下的test中创建测试类如下：
public class Producer01 {
//队列名称
private static final String QUEUE = "helloworld";
public static void main(String[] args) {
Connection conn =null;
Channel channel =null;
try {
ConnectionFactory cf = new ConnectionFactory();
cf.setHost("localhost");
cf.setPort(5672);
cf.setUsername("guest");
cf.setPassword("guest");
//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
cf.setVirtualHost("/");
//创建与RabbitMQ服务的TCP连接
conn = cf.newConnection();
//创建与Exchange通道，每个连接可以创建多个通道，每个通道代表一个会话任务。
channel = conn.createChannel();
/***
* 声明队列，如果Rabbit中没有此队列将自动创建
* param1：队列名称
* param2：是否持久化
* param3：队列是否独占此连接
* param4：队列不再使用时是否自动删除此队列
* param5：队列参数
*/
channel.queueDeclare(QUEUE, true, false, false, null);
String message = "helloworld小明：" + System.currentTimeMillis();
/***
* 消息发布方法
* param1：Exchange的名称，如果没有指定，则使用Default Exchange
* param2：routingKey,消息的路由Key，是用于Exchange（交换机）将消息转发到指定的消息队列
* param3：消息包含的属性
* param4：消息体
*/
/***
* 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显 示绑定或解除绑定
* 默认的交换机，routingKey等于队列名称
*/
channel.basicPublish("", QUEUE, null, message.getBytes());
System.out.println("Send message is"+message);
}catch (Exception e){
e.printStackTrace();
}finally {
if(channel!=null){
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3.消费者
在消费者工程下的test中创建测试类如下：
public class Consumer01 {
//队列名称
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws IOException, TimeoutException {
ConnectionFactory cf = null;
Channel channel = null;
try {
cf = new ConnectionFactory();
cf.setHost("localhost");
cf.setPort(5672);
cf.setUsername("guest");
cf.setPassword("guest");
//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器
cf.setVirtualHost("/");
//创建与RabbitMQ服务的TCP连接
Connection conn = cf.newConnection();
//创建与Exchange通道，每个连接可以创建多个通道，每个通道代表一个会话任务。
channel = conn.createChannel();
//声明队列
channel.queueDeclare(QUEUE, true, false, false, null);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/***
* 消费者接收消息调用此方法
* @param consumerTag 消费者的标签，在channel.basicConsume()去指定
* @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志 (收到消息失败后是否需要重新发送)
* @param properties
* @param body
* @throws IOException
*/
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//路由key
String routingKey = envelope.getRoutingKey();
//消息id
long deliveryTag = envelope.getDeliveryTag();
//消息内容
String message = new String(body, "UTF-8");
System.out.println(message);
}
};
/***
* 监听队列String queue, boolean autoAck,Consumer callback *
* 参数明细
* 1、队列名称
* 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动回复
* 3、消费消息的方法，消费者接收到消息后调用此方法
*/
channel.basicConsume(QUEUE, true, consumer);
} catch (Exception ec) {
ec.printStackTrace();
} finally {
if (channel != null) {
channel.close();
}
if (cf != null) {
cf.clone();
}
}
}
}
4.总结
1、发送端操作流程
1）创建连接
2）创建通道
3）声明队列
4）发送消息
2、接收端
1）创建连接
2）创建通道
3）声明队列
4）监听队列
5）接收消息
6）ack回复
4.工作模式
RabbitMQ有以下几种工作模式 ：
1、Work queues
2、Publish/Subscribe
3、Routing
4、Topics
5、Header
6、RPC
1.Work queues
work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。
应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
测试：
1、使用入门程序，启动多个消费者。
2、生产者发送多个消息。
结果：
1、一条消息只会被一个消费者接收。
2、rabbit采用轮询的方式将消息是平均发送给消费者的。
3、消费者在处理完某条消息后，才会收到下一条消息。
2.Publish/subscribe
1.工作模式
发布订阅模式：
1、每个消费者监听自己的队列。
2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息。
2.代码
案例：
用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法 。
1、生产者
声明Exchange_fanout_inform交换机。
声明两个队列并且绑定到此交换机，绑定时不需要指定routingkey。
发送消息时不需要指定routingkey。
public class Producer02_Publish {
private static final String QUEUE_INFOR_EMAIL = "queue_inform_email";
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_FANOUT_INFOR = "exchange_fanout_infor";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
Connection conn = null;
Channel channel = null;
try {
//创建一个与rabbitmq的TCP连接
conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_FANOUT_INFOR, BuiltinExchangeType.FANOUT);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_EMAIL, true, false, false, null);
channel.queueDeclare(QUEUE_INFOR_SMS, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
* /
channel.queueBind(QUEUE_INFOR_EMAIL, EXCHANGE_FANOUT_INFOR, "");
channel.queueBind(QUEUE_INFOR_SMS, EXCHANGE_FANOUT_INFOR, "");
//发送消息
//参数：String exchange, String routingKey, BasicProperties props, byte[] body
/**
* 参数明细：
* 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
* 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
* 3、props，消息的属性
* 4、body，消息内容
*/
for (int i = 0; i < 5; i++) {
String message = "send inform message to user";
channel.basicPublish(EXCHANGE_FANOUT_INFOR, "", null, message.getBytes());
System.out.println("send to mq " + message);
}
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
} finally {
if (channel != null) {
channel.close();
}
if (conn != null) {
conn.close();
}
}
}
}
2、邮件发送消费者
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//创建一个与rabbitmq的TCP连接
Connection conn = factory.newConnection();
//创建一个通道,一个连接可以有多个通道,一个通道就是一个独立的会话
Channel channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_FANOUT_INFOR, BuiltinExchangeType.FANOUT);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_EMAIL, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
*/
channel.queueBind(QUEUE_INFOR_EMAIL, EXCHANGE_FANOUT_INFOR, "");
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/**
* 当接收到消息后此方法将被调用
* @param consumerTag 消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
* @param envelope 信封，通过envelope
* @param properties 消息属性
* @param body 消息内容
* @throws IOException
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
String message = new String(body, "UTF-8");
System.out.println("receive message：" + message);
}
};
//监听队列
//参数：String queue, boolean autoAck, Consumer callback
/**
* 参数明细：
* 1、queue 队列名称
* 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
* 3、callback 消费方法，当消费者接收到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFOR_EMAIL, true, consumer);
}
}
3、短信发送消费者
public class Consumer02_Subscribe_Sms {
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_FANOUT_INFOR = "exchange_fanout_infor";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//创建一个与rabbitmq的TCP连接
Connection conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_FANOUT_INFOR, BuiltinExchangeType.FANOUT);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_SMS, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
*/
channel.queueBind(QUEUE_INFOR_SMS, EXCHANGE_FANOUT_INFOR, "");
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
/**
* 当接收到消息后此方法将被调用
* @param consumerTag 消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
* @param envelope 信封，通过envelope
* @param properties 消息属性
* @param body 消息内容
* @throws IOException
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//获取交换机
String exchange = envelope.getExchange();
String routingKey = envelope.getRoutingKey();
//消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//接收消息
String message = new String(body, "UTF-8");
System.out.println("receive message：" + message);
}
};
//监听队列
//参数：String queue, boolean autoAck, Consumer callback
/**
* 参数明细：
* 1、queue 队列名称
* 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
* 3、callback 消费方法，当消费者接收到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFOR_SMS, true, consumer);
}
}
3.测试
打开RabbitMQ的管理界面，观察交换机绑定情况：
使用生产者发送若干条消息，每条消息都转发到各各队列，每消费者都接收到了消息。
4.思考
1、publish/subscribe与work queues有什么区别。
区别：
1）work queues不用定义交换机，而publish/subscribe需要定义交换机。
2）publish/subscribe的生产方是面向交换机发送消息，work queues的生产方是面向队列发送消息(底层使用默认 交换机)。
3）publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑 定到默认的交换机 。
相同点：
所以两者实现的发布/订阅的效果是一样的，多个消费端监听同一个队列不会重复消费消息。
2、实质工作用什么 publish/subscribe还是work queues。
建议使用 publish/subscribe，发布订阅模式比工作队列模式更强大，并且发布订阅模式可以指定自己专用的交换 机。
3.Routing
1.工作模式
路由模式：
1、每个消费者监听自己的队列，并且设置routingkey。
2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。
2.代码
1、生产者
声明exchange_routing_inform交换机。
声明两个队列并且绑定到此交换机，绑定时需要指定routingkey
发送消息时需要指定routingkey
public class Producer03_Routing {
private static final String QUEUE_INFOR_EMAIL = "queue_inform_email";
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_ROUTING_INFOR = "exchange_routing_infor";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
Connection conn = null;
Channel channel = null;
try {
//创建一个与rabbitmq的TCP连接
conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_ROUTING_INFOR, BuiltinExchangeType.DIRECT);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_EMAIL, true, false, false, null);
channel.queueDeclare(QUEUE_INFOR_SMS, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
*/
channel.queueBind(QUEUE_INFOR_EMAIL, EXCHANGE_ROUTING_INFOR, QUEUE_INFOR_EMAIL);
channel.queueBind(QUEUE_INFOR_SMS, EXCHANGE_ROUTING_INFOR, QUEUE_INFOR_SMS);
//发送邮件消息
//参数：String exchange, String routingKey, BasicProperties props, byte[] body
/**
* 参数明细：
* 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
* 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
* 3、props，消息的属性
* 4、body，消息内容
*/
for (int i = 0; i < 5; i++) {
String message = "email to user";
channel.basicPublish(EXCHANGE_ROUTING_INFOR, QUEUE_INFOR_EMAIL, null, message.getBytes());
System.out.println("send is:" + message);
}
//发送短信消息
for (int i = 0; i < 5; i++) {
//发送消息的时候指定routingKey
String message = "sms to user";
channel.basicPublish(EXCHANGE_ROUTING_INFOR, QUEUE_INFOR_SMS, null, message.getBytes());
System.out.println("send is:" + message);
}
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
} finally {
if (channel != null) {
channel.close();
}
if (conn != null) {
conn.close();
}
}
}
}
2、邮件发送消费者
public class Consumer03_Routing_Email {
private static final String QUEUE_INFOR_EMAIL = "queue_inform_email";
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_ROUTING_INFOR = "exchange_routing_infor";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//创建一个与rabbitmq的TCP连接
Connection conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_ROUTING_INFOR, BuiltinExchangeType.DIRECT);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_EMAIL,true ,false ,false ,null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
*/
channel.queueBind(QUEUE_INFOR_EMAIL, EXCHANGE_ROUTING_INFOR, QUEUE_INFOR_EMAIL);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 当接收到消息后此方法将被调用
* @param consumerTag 消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
* @param envelope 信封，通过envelope
* @param properties 消息属性
* @param body 消息内容
* @throws IOException
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//接收消息
String message = new String(body, "UTF-8");
System.out.println("receive message：" + message);
}
};
//监听队列
//参数：String queue, boolean autoAck, Consumer callback
/**
* 参数明细：
* 1、queue 队列名称
* 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
* 3、callback 消费方法，当消费者接收到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFOR_EMAIL, true, consumer);
}
}
3、短信发送消费者2、邮件发送消费者
public class Consumer03_Routing_Sms {
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_ROUTING_INFOR = "exchange_routing_infor";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//创建一个与rabbitmq的TCP连接
Connection conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_ROUTING_INFOR, BuiltinExchangeType.DIRECT);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_SMS,true ,false ,false ,null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
*/
channel.queueBind(QUEUE_INFOR_SMS, EXCHANGE_ROUTING_INFOR, QUEUE_INFOR_SMS);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 当接收到消息后此方法将被调用
* @param consumerTag 消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
* @param envelope 信封，通过envelope
* @param properties 消息属性
* @param body 消息内容
* @throws IOException
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//接收消息
String message = new String(body, "UTF-8");
System.out.println("receive message：" + message);
}
};
//监听队列
//参数：String queue, boolean autoAck, Consumer callback
/**
* 参数明细：
* 1、queue 队列名称
* 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
* 3、callback 消费方法，当消费者接收到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFOR_SMS, true, consumer);
}
}
3.测试
打开RabbitMQ的管理界面，观察交换机绑定情况：
使用生产者发送若干条消息，交换机根据routingkey转发消息到指定的队列。
4.思考
1、Routing模式和Publish/subscibe有啥区别？
Routing模式要求队列在绑定交换机时要指定routingkey，消息会转发到符合routingkey的队列。
4. Topics
1.工作模式
路由模式：
1、每个消费者监听自己的队列，并且设置带统配符的routingkey。
2、生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。
2.代码
案例：
根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种 通知类型都接收的则两种通知都有效。
1、生产者
声明交换机，指定topic类型：
public class Producer04_Topics {
//队列名称
private static final String QUEUE_INFOR_EMAIL = "queue_inform_email";
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFOR = "exchange_topics_infor";
private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
private static final String ROUTINGKEY_SMS = "inform.#.sms.#";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
Connection conn = null;
Channel channel = null;
try {
//创建一个与rabbitmq的TCP连接
conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFOR, BuiltinExchangeType.TOPIC);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_EMAIL, true, false, false, null);
channel.queueDeclare(QUEUE_INFOR_SMS, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
*/
channel.queueBind(QUEUE_INFOR_EMAIL, EXCHANGE_TOPICS_INFOR, ROUTINGKEY_EMAIL);
channel.queueBind(QUEUE_INFOR_SMS, EXCHANGE_TOPICS_INFOR, ROUTINGKEY_SMS);
//发送邮件消息
//参数：String exchange, String routingKey, BasicProperties props, byte[] body
/**
* 参数明细：
* 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
* 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
* 3、props，消息的属性
* 4、body，消息内容
*/
for (int i = 0; i < 5; i++) {
//发送消息的时候指定routingKey
String message = "email to user";
channel.basicPublish(EXCHANGE_TOPICS_INFOR, "inform.email", null, message.getBytes());
System.out.println("send is:" + message);
}
//发送短信消息
for (int i = 0; i < 5; i++) {
//发送消息的时候指定routingKey
String message = "sms to user";
channel.basicPublish(EXCHANGE_TOPICS_INFOR, "inform.sms", null, message.getBytes());
System.out.println("send is:" + message);
}
//发送邮件短信消息
for (int i = 0; i < 5; i++) {
//发送消息的时候指定routingKey
String message = "email and sms to user";
channel.basicPublish(EXCHANGE_TOPICS_INFOR, "inform.sms.email", null, message.getBytes());
System.out.println("send is:" + message);
}
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
} finally {
if (channel != null) {
channel.close();
}
if (conn != null) {
conn.close();
}
}
}
}
2、邮件发送消费者
public class Consumer04_Topics_Email {
/**
* 其实我有一个疑问就是消费端不是只用监听队列就可以了吗?
* 消费端其实不用声明交换机队列以及交换机和队列进行绑定，直接监听队列，经过测试也可以消费。
* 当然声明也没什么问题，就是有一个好处，如果先启动消费端不会报错。
*/
private static final String QUEUE_INFOR_EMAIL = "queue_inform_email";
private static final String EXCHANGE_TOPICS_INFOR = "exchange_topics_infor";
private static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//创建一个与rabbitmq的TCP连接
Connection conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
//channel.exchangeDeclare(EXCHANGE_TOPICS_INFOR, BuiltinExchangeType.TOPIC);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
//channel.queueDeclare(QUEUE_INFOR_EMAIL, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
*/
//channel.queueBind(QUEUE_INFOR_EMAIL, EXCHANGE_TOPICS_INFOR,ROUTINGKEY_EMAIL);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 当接收到消息后此方法将被调用
* @param consumerTag 消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
* @param envelope 信封，通过envelope
* @param properties 消息属性
* @param body 消息内容
* @throws IOException
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//接收消息
String message = new String(body, "UTF-8");
System.out.println("receive message：" + message);
}
};
//监听队列
//参数：String queue, boolean autoAck, Consumer callback
/**
* 参数明细：
* 1、queue 队列名称
* 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
* 3、callback 消费方法，当消费者接收到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFOR_EMAIL, true, consumer);
};
}
3、短信发送消费者
public class Consumer04_Topics_Sms {
/**
* 其实我有一个疑问就是消费端不是只用监听队列就可以了吗?
* 消费端其实不用声明交换机队列以及交换机和队列进行绑定，直接监听队列，经过测试也可以消费。
* 当然声明也没什么问题，就是有一个好处，如果先启动消费端不会报错。
*/
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFOR = "exchange_topics_infor";
private static final String ROUTINGKEY_SMS = "inform.#.sms.#";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//创建一个与rabbitmq的TCP连接
Connection conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
//channel.exchangeDeclare(EXCHANGE_TOPICS_INFOR, BuiltinExchangeType.TOPIC);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
//channel.queueDeclare(QUEUE_INFOR_SMS, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
*/
//channel.queueBind(QUEUE_INFOR_SMS,EXCHANGE_TOPICS_INFOR , ROUTINGKEY_SMS);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel){
/**
* 当接收到消息后此方法将被调用
* @param consumerTag 消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
* @param envelope 信封，通过envelope
* @param properties 消息属性
* @param body 消息内容
* @throws IOException
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
String message = new String(body, "UTF-8");
System.out.println("receive message：" + message);
}
};
//监听队列
//参数：String queue, boolean autoAck, Consumer callback
/**
* 参数明细：
* 1、queue 队列名称
* 2、autoAck 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为tru表示会自动回复mq，如果设置为false要通过编程实现回复
* 3、callback 消费方法，当消费者接收到消息要执行的方法
*/
channel.basicConsume(QUEUE_INFOR_SMS, true, consumer);
}
}
3.测试
使用生产者发送若干条消息，交换机根据routingkey统配符匹配并转发消息到指定的队列。
4.思考
1、本案例的需求使用Routing工作模式能否实现？
使用Routing模式也可以实现本案例，共设置三个 routingkey，分别是email、sms、all，email队列绑定email和 all，sms队列绑定sms和all，这样就可以实现上边案例的功能，实现过程比topics复杂。
Topic模式更多加强大，它可以实现Routing、publish/subscirbe模式的功能。
5.Header模式
header模式与routing不同的地方在于，header模式取消routingkey，使用header中的 key/value（键值对）匹配 队列。
案例： 根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种 通知类型都接收的则两种通知都有效。
1.代码
1、生产者
队列与交换机绑定的代码与之前不同，如下：
public class Producer05_Header {
//队列名称
private static final String QUEUE_INFOR_EMAIL = "queue_inform_email";
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFOR = "exchange_topics_infor";
public static void main(String[] args) {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
Connection conn = null;
Channel channel = null;
try {
//创建一个与rabbitmq的TCP连接
conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFOR, BuiltinExchangeType.HEADERS);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_EMAIL, true, false, false, null);
channel.queueDeclare(QUEUE_INFOR_SMS, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
* 4、arguments 其他属性（绑定属性）其实和路由key作用一样，换了一个匹配方式而已
*/
HashMap<String, Object> header_email = new HashMap<>();
header_email.put("inform_email", "inform_email");//匹配email通知消费者绑定的header
HashMap<String, Object> header_sms = new HashMap<>();
header_sms.put("inform_sms", "inform_sms");//匹配sms通知消费者绑定的header
channel.queueBind(QUEUE_INFOR_EMAIL, EXCHANGE_TOPICS_INFOR, "", header_email);
channel.queueBind(QUEUE_INFOR_SMS, EXCHANGE_TOPICS_INFOR, "", header_sms);
//发送消息
String message1 = "email and sms to user";
HashMap<String, Object> headers = new HashMap<>();
headers.put("inform_email", "inform_email");
headers.put("inform_sms", "inform_sms");
AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties().builder();
properties.headers(headers);
channel.basicPublish(EXCHANGE_TOPICS_INFOR, "",properties.build(),message1.getBytes() );
System.out.println("send is:" + message1);
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
}
2、发送邮件消费者
public class Consumer05_Header_Email {
/**
* 其实我有一个疑问就是消费端不是只用监听队列就可以了吗?
* 消费端其实不用声明交换机队列以及交换机和队列进行绑定，直接监听队列，经过测试也可以消费。
* 当然声明也没什么问题，就是有一个好处，如果先启动消费端不会报错。
*/
//队列名称
private static final String QUEUE_INFOR_EMAIL = "queue_inform_email";
private static final String EXCHANGE_TOPICS_INFOR = "exchange_topics_infor";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//创建一个与rabbitmq的TCP连接
Connection conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFOR, BuiltinExchangeType.HEADERS);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_EMAIL, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
* 4、arguments 其他属性（绑定属性）其实和路由key作用一样，换了一个匹配方式而已
*/
HashMap<String, Object> header_email = new HashMap<>();
header_email.put("inform_email", "inform_email");//匹配email通知消费者绑定的header
channel.queueBind(QUEUE_INFOR_EMAIL, EXCHANGE_TOPICS_INFOR, "", header_email);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//接收消息
String message = new String(body, "UTF-8");
System.out.println("receive message：" + message);
}
};
//监听队列
channel.basicConsume(QUEUE_INFOR_EMAIL, true, consumer);
}
}
3、短信发送消费者
public class Consumer05_Header_Sms {
/**
* 其实我有一个疑问就是消费端不是只用监听队列就可以了吗?
* 消费端其实不用声明交换机队列以及交换机和队列进行绑定，直接监听队列，经过测试也可以消费。
* 当然声明也没什么问题，就是有一个好处，如果先启动消费端不会报错。
*/
//队列名称
private static final String QUEUE_INFOR_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFOR = "exchange_topics_infor";
public static void main(String[] args) throws IOException, TimeoutException {
//通过连接工厂创建新的连接和mq建立连接
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setPort(5672);
factory.setUsername("guest");
factory.setPassword("guest");
//设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
factory.setVirtualHost("/");
//创建一个与rabbitmq的TCP连接
Connection conn = factory.newConnection();
//创建会话通道,生产者和mq服务所有通信都在channel通道中完成
Channel channel = conn.createChannel();
//声明一个交换机
//参数：String exchange, String type
/**
* 参数明细：
* 1、交换机的名称
* 2、交换机的类型
* fanout：对应的rabbitmq的工作模式是 publish/subscribe
* direct：对应的Routing 工作模式
* topic：对应的Topics工作模式
* headers： 对应的headers工作模式
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFOR, BuiltinExchangeType.HEADERS);
//声明队列，如果队列在mq 中没有则要创建
//参数：String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
/**
* 参数明细
* 1、queue 队列名称
* 2、durable 是否持久化，如果持久化，mq重启后队列还在
* 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除,如果将此参数设置true可用于临时队列的创建
* 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
* 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
*/
channel.queueDeclare(QUEUE_INFOR_SMS, true, false, false, null);
//进行交换机和队列绑定
//参数：String queue, String exchange, String routingKey
/**
* 参数明细：
* 1、queue 队列名称
* 2、exchange 交换机名称
* 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
* 我对路由key的理解：路由key与交换机和队列绑定后，发送消息的时候，一定要满足这个路由key的规则，这样队列才能
* 接收到消息。
* 4、arguments 其他属性（绑定属性）其实和路由key作用一样，换了一个匹配方式而已
*/
HashMap<String, Object> header_email = new HashMap<>();
header_email.put("inform_email", "inform_email");//匹配email通知消费者绑定的header
channel.queueBind(QUEUE_INFOR_SMS, EXCHANGE_TOPICS_INFOR, "", header_email);
//定义消费方法
DefaultConsumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//交换机
String exchange = envelope.getExchange();
//消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
long deliveryTag = envelope.getDeliveryTag();
//接收消息
String message = new String(body, "UTF-8");
System.out.println("receive message：" + message);
}
};
//监听队列
channel.basicConsume(QUEUE_INFOR_SMS, true, consumer);
}
}
2.测试
6.RPC
RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：
1、客户端即是生产者就是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。
2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果
3、服务端将RPC方法 的结果发送到RPC响应队列
4、客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果。
Spring整合RibbitMQ
1.搭建SpringBoot环境
选择基于Spring-Rabbit去操作RabbitMQ
https://github.com/spring-projects/spring-amqp
使用spring-boot-starter-amqp会自动添加spring-rabbit依赖，如下：
<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>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>
3.生产端
1.配置
application.yml
server:
port: 44001
spring:
application:
name: test‐rabbitmq‐producer
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
virtualHost: /
定义RabbitConfig类，配置Exchange、Queue、及绑定交换机。
本例配置Topic交换机。
@Configuration
public class RabbitConfig {
public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
public static final String EXCHANAGE_TOPICS_INFROM = "exchange_topics_inform";
public static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
public static final String ROUTINGKEY_SMS = "inform.#.sms.#";
//声明交换机
@Bean(EXCHANAGE_TOPICS_INFROM)
public Exchange EXCHANAGE_TOPICS_INFROM() {
//durable(true)持久化，消息队列重启后交换机仍然存在
return ExchangeBuilder.topicExchange(EXCHANAGE_TOPICS_INFROM).durable(true).build();
}
//声明队列
@Bean(QUEUE_INFORM_EMAIL)
public Queue QUEUE_INFORM_EMAIL() {
Queue queue = new Queue(QUEUE_INFORM_EMAIL);
return queue;
}
//声明队列
@Bean(QUEUE_INFORM_SMS)
public Queue QUEUE_INFORM_SMS() {
Queue queue = new Queue(QUEUE_INFORM_SMS);
return queue;
}
//交换机绑定队列
@Bean
public Binding BIND_EXCHANAGE_TOPICS_INFROM(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
@Qualifier(EXCHANAGE_TOPICS_INFROM) Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with(ROUTINGKEY_EMAIL).noargs();
}
//交换机绑定队列
@Bean
public Binding BIND_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
@Qualifier(EXCHANAGE_TOPICS_INFROM) Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with(ROUTINGKEY_SMS).noargs();
}
}
2.发送消息
使用RarbbitTemplate发送消息
@SpringBootTest
@RunWith(SpringRunner.class)
public class Producer06_Topics_SpringBoot {
@Autowired
RabbitTemplate rabbitTemplate;
@Test
public void testSendEmail(){
String message = "email to user";
/**
* String exchange, String routingKey, final Object object
* 1、交换机名称
* 2、routingKey
* 2、消息内容
*/
rabbitTemplate.convertAndSend(RabbitConfig.EXCHANAGE_TOPICS_INFROM,"inform.email" ,message);
}
@Test
public void testSendSms(){
String message = "sms to user";
/**
* String exchange, String routingKey, final Object object
* 1、交换机名称
* 2、routingKey
* 2、消息内容
*/
rabbitTemplate.convertAndSend(RabbitConfig.EXCHANAGE_TOPICS_INFROM,"inform.sms" ,message);
}
}
4.消费端
1.配置
server:
port: 44002
spring:
application:
name: test‐rabbitmq‐consumer
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest
virtualHost: /
定义RabbitConfig类，配置Exchange、Queue、及绑定交换机。
本例配置Topic交换机。
@Configuration
public class RabbitConfig {
public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
public static final String EXCHANAGE_TOPICS_INFROM = "exchange_topics_inform";
public static final String ROUTINGKEY_EMAIL = "inform.#.email.#";
public static final String ROUTINGKEY_SMS = "inform.#.sms.#";
//声明定义交换机
@Bean(EXCHANAGE_TOPICS_INFROM)
public Exchange EXCHANAGE_TOPICS_INFROM(){
//durable(true)持久化，消息队列重启后交换机仍然存在
return ExchangeBuilder.topicExchange(EXCHANAGE_TOPICS_INFROM).durable(true).build();
}
//声明队列
@Bean(QUEUE_INFORM_EMAIL)
public Queue QUEUE_INFORM_EMAIL(){
Queue queue = new Queue(QUEUE_INFORM_EMAIL);
return queue;
}
//声明队列
@Bean(QUEUE_INFORM_SMS)
public Queue QUEUE_INFORM_SMS(){
Queue queue = new Queue(QUEUE_INFORM_SMS);
return queue;
}
//交换机绑定队列
@Bean
public Binding Bind_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
@Qualifier(EXCHANAGE_TOPICS_INFROM) Exchange exchange){
return BindingBuilder.bind(queue).to(exchange).with(ROUTINGKEY_EMAIL).noargs();
}
//交换机绑定队列
@Bean
public Binding Bind_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
@Qualifier(EXCHANAGE_TOPICS_INFROM) Exchange exchange){
return BindingBuilder.bind(queue).to(exchange).with(ROUTINGKEY_SMS).noargs();
}
}
2.接收消息
使用@RabbitListener注解监听队列。
@Component
public class ReciveHandler {
//监听队列
@RabbitListener(queues = {RabbitConfig.QUEUE_INFORM_EMAIL})
public void recive_email(String msg, Message message, Channel channel){
System.out.println(msg);
//System.out.println(new String(message.getBody(),"UTF-8"));
}
//监听队列
@RabbitListener(queues = RabbitConfig.QUEUE_INFORM_SMS)
public void recive_sms(String msg,Message message,Channel channel){
System.out.println(msg);
//System.out.println(new String(message.getBody(),"UTF-8"));
}
}
6304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
