学成网 第5天 讲义-消息队列 RabbitMQ GridFS

最新推荐文章于 2022-10-26 13:14:09 发布
最新推荐文章于 2022-10-26 13:14:09 发布
阅读量357 收藏 1
点赞数
分类专栏： java 项目 学成在线 cms
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kai46385076/article/details/90105768
版权
java 同时被 3 个专栏收录
272 篇文章 31 订阅
订阅专栏
项目
58 篇文章 1 订阅
订阅专栏
学成在线
23 篇文章 5 订阅
订阅专栏

1页面发布

1.1需求分析

在这里插入图片描述
业务流程如下：
1、管理员进入管理界面点击“页面发布”，前端请求cms页面发布接口。
2、cms页面发布接口执行页面静态化，并将静态化页面(html文件)存储至GridFS中。
3、静态化成功后，向消息队列发送页面发布的消息。页面发布的最终目标是将页面发布到服务器。
通过消息队列将页面发布的消息发送给各各服务器。
3、消息队列负责将消息发送给各各服务器上部署的Cms Client(Cms客户端)。在服务器上部署Cms Client(Cms客户端)，客户端接收消息队列的通知。
4、每个接收到页面发布消息的Cms Client从GridFS获取Html页面文件，并将Html文件存储在本地服务器。
CmsClient根据页面发布消息的内容请求GridFS获取页面文件，存储在本地服务器。

1.2RabbitMQ研究

要实现上边页面发布的功能，有一个重要的环节就是由消息队列将页面发布的消息通知给各各服务器。 本节的教学目标是对MQ的研究：
1、理解MQ的应用场景
2、理解MQ常用的工作模式

1.3RabbitMQ

MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq.com/
开发中消息队列通常有如下应用场景：
1、任务异步处理。
将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。
2、应用程序解耦合
MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。

市场上还有哪些消息队列？
ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ、Redis。

为什么使用RabbitMQ呢？
1、使得简单，功能强大。
2、基于AMQP协议。
3、社区活跃，文档完善。
4、高并发性能好，这主要得益于Erlang语言。 5、Spring Boot默认已集成RabbitMQ

1.4其它相关知识

AMQP是什么 ？
在这里插入图片描述
结：AMQP是一套公开的消息队列协议，最早在2003年被提出，它旨在从协议层定义消息通信数据的标准格式， 为的就是解决MQ市场上协议不统一的问题。RabbitMQ就是遵循AMQP标准协议开发的MQ服务。
官方：http://www.amqp.org/
JMS是什么 ？
在这里插入图片描述
总结：
JMS是java提供的一套消息服务API标准，其目的是为所有的java应用程序提供统一的消息通信的标准，类似java的 jdbc，只要遵循jms标准的应用程序之间都可以进行消息通信。它和AMQP有什么 不同，jms是java语言专属的消息服务标准，它是在api层定义标准，并且只能用于java应用；而AMQP是在协议层定义的标准，是跨语言的 。

2快速入门

2.1RabbitMQ的工作原理

下图是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.2下载安装

2.2.1下载安装
RabbitMQ由Erlang语言开发，Erlang语言用于并发及分布式系统的开发，在电信领域应用广泛，OTP（Open Telecom Platform）作为Erlang语言的一部分，包含了很多基于Erlang开发的中间件及工具库，安装RabbitMQ需要安装Erlang/OTP，并保持版本匹配，如下图：
RabbitMQ的下载地址：http://www.rabbitmq.com/download.html
在这里插入图片描述
本项目使用Erlang/OTP 20.3版本和RabbitMQ3.7.3版本。

1）下载erlang
地址如下：
http://erlang.org/download/otp_win64_20.3.exe
或去老师提供的软件包中找到 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
或去老师提供的软件包中找到 rabbitmq-server-3.7.3.exe，以管理员方式运行此文件，安装。

2.2.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
在这里插入图片描述

2.2.3注意事项
1、安装erlang和rabbitMQ以管理员身份运行。
2、当卸载重新安装时会出现RabbitMQ服务注册失败，此时需要进入注册表清理erlang
搜索RabbitMQ、ErlSrv，将对应的项全部删除。

2.2Hello World

按照官方教程(http://www.rabbitmq.com/getstarted.html)测试hello world:
在这里插入图片描述

2.2.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.2.2生产者
在生产者工程下的test中创建测试类如下：


public class Producer01 {
//队列名称
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws IOException, TimeoutException { Connection connection = null;
Channel channel = null; try
{
ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost");
factory.setPort(5672); factory.setUsername("guest"); factory.setPassword("guest");
factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务
器
//创建与RabbitMQ服务的TCP连接
connection = factory.newConnection();
//创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务channel = connection.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 ex)
{
ex.printStackTrace();
}
finally
{
if(channel != null)
{
channel.close();
}
if(connection != null)
{
connection.close();
}
}
}
}

*/

2.2.3消费者
在消费者工程下的test中创建测试类如下：


public class Consumer01 {
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws IOException, TimeoutException { ConnectionFactory factory = new ConnectionFactory();
//设置MabbitMQ所在服务器的ip和端口
factory.setHost("127.0.0.1"); factory.setPort(5672);
Connection connection = factory.newConnection(); Channel channel = connection.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 msg = new String(body,"utf‐8"); System.out.println("receive message.." + msg);
}
};
/**
*监听队列String queue, boolean autoAck,Consumer callback
*参数明细
*1、队列名称
*2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置   为false则需要手动回复
*3、消费消息的方法，消费者接收到消息后调用此方法
*/
channel.basicConsume(QUEUE, true, consumer);

}
}

２.2.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

4.1Work queues

在这里插入图片描述
work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
测试：
1、使用入门程序，启动多个消费者。
2、生产者发送多个消息。结果：
1、一条消息只会被一个消费者接收；
2、rabbit采用轮询的方式将消息是平均发送给消费者的；
3、消费者在处理完某条消息后，才会收到下一条消息。

4.2Publish/subscribe

4.2.1工作模式
在这里插入图片描述
发布订阅模式：
1、每个消费者监听自己的队列。
2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收 到消息

4.2.2代码
案例：
用户通知，当用户充值成功或转账完成系统通知用户，通知方式有短信、邮件多种方法 。

1、生产者
声明Exchange_fanout_inform交换机。
声明两个队列并且绑定到此交换机，绑定时不需要指定routingkey 发送消息时不需要指定routingkey

package com.xuecheng.test.rabbitmq;
import com.rabbitmq.client.*; import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Producer02_publish {

//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email"; private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform"; public static void main(String[] args) {
Connection connection = null; Channel channel = null;
try {
//创建一个与MQ的连接
ConnectionFactory factory = new ConnectionFactory(); factory.setHost("127.0.0.1");
factory.setPort(5672); factory.setUsername("guest"); factory.setPassword("guest");
factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务
器

//创建一个连接
connection = factory.newConnection();
//创建与交换机的通道，每个通道代表一个会话channel = connection.createChannel();
//声明交换机 String exchange, BuiltinExchangeType type
/**
*参数明细
*1、交换机名称
*2、交换机类型，fanout、topic、direct、headers
*/
channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
//声明队列
//	(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
/**
*参数明细：
*1、队列名称
*2、是否持久化
*3、是否独占此队列
*4、队列不用是否自动删除
*5、参数
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null); channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
//交换机和队列绑定String queue, String exchange, String routingKey
/**
*参数明细
*1、队列名称
*2、交换机名称
*3、路由key
*/ channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");
//发送消息
for (int i=0;i<10;i++){
String message = "inform to user"+i;

//向交换机发送消息 String exchange, String routingKey, BasicProperties props,
byte[] body





息将发到此队列



}



/**
*参数明细
*1、交换机名称，不指令使用默认交换机名称 Default Exchange
*2、routingKey（路由key），根据key名称将消息转发到具体的队列，这里填写队列名称表示消

*3、消息属性
*4、消息内容
*/
channel.basicPublish(EXCHANGE_FANOUT_INFORM, "", null, message.getBytes()); System.out.println("Send Message is:'" + message + "'");


} catch (IOException e) { e.printStackTrace();
} catch (TimeoutException e) { e.printStackTrace();
}finally{
if(channel!=null){ try {
channel.close();
} catch (IOException e) { e.printStackTrace();
} catch (TimeoutException e) { e.printStackTrace();
}
}
if(connection!=null){ try {
connection.close();
} catch (IOException e) { e.printStackTrace();
}
}

}


}
}

2、邮件发送消费者

package com.xuecheng.test.rabbitmq; import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
*@author Administrator
*@version 1.0
* @create 2018‐06‐14 10:32
**/
public class Consumer02_subscribe_email {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "inform_queue_email"; private static final String EXCHANGE_FANOUT_INFORM="inform_exchange_fanout";

public static void main(String[] args) throws IOException, TimeoutException {
//创建一个与MQ的连接
ConnectionFactory factory = new ConnectionFactory(); factory.setHost("127.0.0.1");
factory.setPort(5672); factory.setUsername("guest"); factory.setPassword("guest");
factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器

//创建一个连接
Connection connection = factory.newConnection();
//创建与交换机的通道，每个通道代表一个会话Channel channel = connection.createChannel();
//声明交换机 String exchange, BuiltinExchangeType type
/**
*参数明细
*1、交换机名称
*2、交换机类型，fanout、topic、direct、headers
*/
channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
//声明队列
//	channel.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
/**
*参数明细：
*1、队列名称
*2、是否持久化
*3、是否独占此队列
*4、队列不用是否自动删除
*5、参数
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
//交换机和队列绑定String queue, String exchange, String routingKey
/**
*参数明细
*1、队列名称
*2、交换机名称
*3、路由key
*/ channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
//定义消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel) { @Override
public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body) throws IOException { long deliveryTag = envelope.getDeliveryTag(); String exchange = envelope.getExchange();
//消息内容
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_INFORM_EMAIL, true, defaultConsumer);
}
}

按照上边的代码，编写邮件通知的消费代码。
3、短信发送消费者
参考上边的邮件发送消费者代码编写。
4.2.3测试
打开RabbitMQ的管理界面，观察交换机绑定情况：
在这里插入图片描述

使用生产者发送若干条消息，每条消息都转发到各各队列，每消费者都接收到了消息。

4.2.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，发布订阅模式比工作队列模式更强大，并且发布订阅模式可以指定自己专用的交换机。

4.3Routing

4.3.1工作模式
在这里插入图片描述
路由模式：
1、每个消费者监听自己的队列，并且设置routingkey。
2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。

4.3.2代码
1、生产者
声明exchange_routing_inform交换机。
声明两个队列并且绑定到此交换机，绑定时需要指定routingkey 发送消息时需要指定routingkey

package com.xuecheng.test.rabbitmq;

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 Producer03_routing {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email"; private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform"; public static void main(String[] args) {
Connection connection = null; Channel channel = null;
try {
//创建一个与MQ的连接
ConnectionFactory factory = new ConnectionFactory();

factory.setHost("127.0.0.1");
factory.setPort(5672); factory.setUsername("guest"); factory.setPassword("guest");
factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务
器

//创建一个连接
connection = factory.newConnection();
//创建与交换机的通道，每个通道代表一个会话channel = connection.createChannel();
//声明交换机 String exchange, BuiltinExchangeType type
/**
*参数明细
*1、交换机名称
*2、交换机类型，fanout、topic、direct、headers
*/
channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
//声明队列
//	channel.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
/**
*参数明细：
*1、队列名称
*2、是否持久化
*3、是否独占此队列
*4、队列不用是否自动删除
*5、参数
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null); channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
//交换机和队列绑定String queue, String exchange, String routingKey
/**
*参数明细
*1、队列名称
*2、交换机名称
*3、路由key
*/ channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,QUEUE_INFORM_EMAIL); channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,QUEUE_INFORM_SMS);
//发送邮件消息
for (int i=0;i<10;i++){
String message = "email inform to user"+i;
//向交换机发送消息 String exchange, String routingKey, BasicProperties props,

byte[] body





息将发到此队列


/**
*参数明细
*1、交换机名称，不指令使用默认交换机名称 Default Exchange
*2、routingKey（路由key），根据key名称将消息转发到具体的队列，这里填写队列名称表示消

*3、消息属性
*4、消息内容
*/

channel.basicPublish(EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_EMAIL, null,
message.getBytes());
System.out.println("Send Message is:'" + message + "'");







byte[] body

}
//发送短信消息
for (int i=0;i<10;i++){
String message = "sms inform to user"+i;
//向交换机发送消息 String exchange, String routingKey, BasicProperties props,

channel.basicPublish(EXCHANGE_ROUTING_INFORM, QUEUE_INFORM_SMS, null,

message.getBytes());
System.out.println("Send Message is:'" + message + "'");
}

} catch (IOException e) { e.printStackTrace();
} catch (TimeoutException e) { e.printStackTrace();
}finally{
if(channel!=null){ try {
channel.close();
} catch (IOException e) { e.printStackTrace();
} catch (TimeoutException e) { e.printStackTrace();
}
}
if(connection!=null){ try {
connection.close();
} catch (IOException e) { e.printStackTrace();
}
}

}


}
}

2、邮件发送消费者

package com.xuecheng.test.rabbitmq;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;



public class Consumer03_routing_email {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "inform_queue_email";
private static final String EXCHANGE_ROUTING_INFORM="inform_exchange_routing";

public static void main(String[] args) throws IOException, TimeoutException {
//创建一个与MQ的连接
ConnectionFactory factory = new ConnectionFactory(); factory.setHost("127.0.0.1");
factory.setPort(5672); factory.setUsername("guest"); factory.setPassword("guest");
factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务器

//创建一个连接
Connection connection = factory.newConnection();
//创建与交换机的通道，每个通道代表一个会话Channel channel = connection.createChannel();
//声明交换机 String exchange, BuiltinExchangeType type
/**
*参数明细
*1、交换机名称
*2、交换机类型，fanout、topic、direct、headers
*/
channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
//声明队列
//	channel.queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
/**
*参数明细：
*1、队列名称
*2、是否持久化
*3、是否独占此队列
*4、队列不用是否自动删除
*5、参数
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null);
//交换机和队列绑定String queue, String exchange, String routingKey
/**
*参数明细
*1、队列名称
*2、交换机名称
*3、路由key
*/ channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,QUEUE_INFORM_EMAIL);
//定义消费方法
DefaultConsumer defaultConsumer = new DefaultConsumer(channel) { @Override


public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body) throws IOException {
long deliveryTag = envelope.getDeliveryTag(); String exchange = envelope.getExchange();
//消息内容
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_INFORM_EMAIL, true, defaultConsumer);
}
}

3、短信发送消费者
参考邮件发送消费者的代码流程，编写短信通知的代码。

4.3.3测试
打开RabbitMQ的管理界面，观察交换机绑定情况：
在这里插入图片描述
使用生产者发送若干条消息，交换机根据routingkey转发消息到指定的队列。
4.4.4思考
1、Routing模式和Publish/subscibe有啥区别？
Routing模式要求队列在绑定交换机时要指定routingkey，消息会转发到符合routingkey的队列。

4.4Topics

4.4.1工作模式
在这里插入图片描述
路由模式：
1、每个消费者监听自己的队列，并且设置带统配符的routingkey。
2、生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。

4.4.2代码
案例：
根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种 通知类型都接收的则两种通知都有效。
1、生产者
声明交换机，指定topic类型：





/**
*声明交换机
*param1：交换机名称
*param2:交换机类型 四种交换机类型：direct、fanout、topic、headers
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//Email通知
channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.email", null, message.getBytes());
//sms通知
channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms", null, message.getBytes());
//两种都通知
channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms.email", null, message.getBytes());

完整代码：

package com.xuecheng.test.rabbitmq;

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 Producer04_topics {
//队列名称
private static final String QUEUE_INFORM_EMAIL = "queue_inform_email"; private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
private static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform"; public static void main(String[] args) {
Connection connection = null; Channel channel = null;
try {
//创建一个与MQ的连接
ConnectionFactory factory = new ConnectionFactory(); factory.setHost("127.0.0.1");
factory.setPort(5672); factory.setUsername("guest"); factory.setPassword("guest");
factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，虚拟机相当于一个独立的mq服务
器

//创建一个连接
connection = factory.newConnection();
//创建与交换机的通道，每个通道代表一个会话channel = connection.createChannel();
//声明交换机 String exchange, BuiltinExchangeType type
/**
* 参数明细
* *1、交换机名称
*2、交换机类型，fanout、topic、direct、headers
*/
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//声明队列
/**
*参数明细：
*1、队列名称
*2、是否持久化
*3、是否独占此队列
*4、队列不用是否自动删除
*5、参数
*/
channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null); channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);







byte[] body

//发送邮件消息
for (int i=0;i<10;i++){
String message = "email inform to user"+i;
//向交换机发送消息 String exchange, String routingKey, BasicProperties props,

/**
*参数明细
*1、交换机名称，不指令使用默认交换机名称 Default Exchange
*2、routingKey（路由key），根据key名称将消息转发到具体的队列，这里填写队列名称表示消

息将发到此队列


*3、消息属性
*4、消息内容
*/
channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.email", null,

message.getBytes());
System.out.println("Send Message is:'" + message + "'");
}
//发送短信消息
for (int i=0;i<10;i++){
String message = "sms inform to user"+i; channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms", null,
message.getBytes());
System.out.println("Send Message is:'" + message + "'");
}
//发送短信和邮件消息
for (int i=0;i<10;i++){
String message = "sms and email inform to user"+i; channel.basicPublish(EXCHANGE_TOPICS_INFORM, "inform.sms.email", null,
message.getBytes());
System.out.println("Send Message is:'" + message + "'");
}

} catch (IOException e) { e.printStackTrace();
} catch (TimeoutException e) { e.printStackTrace();

}finally{
if(channel!=null){
try {
channel.close();
} catch (IOException e) { e.printStackTrace();
} catch (TimeoutException e) { e.printStackTrace();
}
}
if(connection!=null){ try {
connection.close();
} catch (IOException e) { e.printStackTrace();
}
}
}
}
}

2、消费端

队列绑定交换机指定通配符： 统配符规则：
中间以“.”分隔。
符号#可以匹配多个词，符号*可以匹配一个词语。

//声明队列
channel.queueDeclare(QUEUE_INFORM_EMAIL, true, false, false, null); channel.queueDeclare(QUEUE_INFORM_SMS, true, false, false, null);
//声明交换机
channel.exchangeDeclare(EXCHANGE_TOPICS_INFORM, BuiltinExchangeType.TOPIC);
//绑定email通知队列channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_TOPICS_INFORM,"inform.#.email.#");
//绑定sms通知队列
channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_TOPICS_INFORM,"inform.#.sms.#");

4.4.3测试
在这里插入图片描述
使用生产者发送若干条消息，交换机根据routingkey统配符匹配并转发消息到指定的队列。
4.4.4思考
1、本案例的需求使用Routing工作模式能否实现？
使用Routing模式也可以实现本案例，共设置三个 routingkey，分别是email、sms、all，email队列绑定email和all，sms队列绑定sms和all，这样就可以实现上边案例的功能，实现过程比topics复杂。
Topic模式更多加强大，它可以实现Routing、publish/subscirbe模式的功能。

4.5Header模式

header模式与routing不同的地方在于，header模式取消routingkey，使用header中的 key/value（键值对）匹配队列。
案例：
根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种 通知类型都接收的则两种通知都有效。
代码：
1）生产者
队列与交换机绑定的代码与之前不同，如下：





Map<String, Object> headers_email = new Hashtable<String, Object>(); headers_email.put("inform_type", "email");
Map<String, Object> headers_sms = new Hashtable<String, Object>(); headers_sms.put("inform_type", "sms"); channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email); channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_HEADERS_INFORM,"",headers_sms);

通知：

String message = "email inform to user"+i;
Map<String,Object> headers = new Hashtable<String, Object>(); headers.put("inform_type", "email");//匹配email通知消费者绑定的header
//headers.put("inform_type", "sms");//匹配sms通知消费者绑定的header
AMQP.BasicProperties.Builder properties = new AMQP.BasicProperties.Builder(); properties.headers(headers);
//Email通知
channel.basicPublish(EXCHANGE_HEADERS_INFORM, "", properties.build(), message.getBytes());

2）发送邮件消费者


channel.exchangeDeclare(EXCHANGE_HEADERS_INFORM, BuiltinExchangeType.HEADERS); Map<String, Object> headers_email = new Hashtable<String, Object>(); headers_email.put("inform_email", "email");
//交换机和队列绑定
channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_HEADERS_INFORM,"",headers_email);
//指定消费队列
channel.basicConsume(QUEUE_INFORM_EMAIL, true, consumer);

3)测试
在这里插入图片描述
4.6RPC
在这里插入图片描述
RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：
1、客户端即是生产者就是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。
2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果
3、服务端将RPC方法 的结果发送到RPC响应队列
4、客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果。

5Spring整合RibbitMQ

4.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>

4.2配置

1、配置application.yml
配置连接rabbitmq的参数

server:
port: 44000 spring:
application:
name: test‐rabbitmq‐producer rabbitmq:
host: 127.0.0.1
port: 5672 username: guest password: guest virtualHost: /

2、定义RabbitConfig类，配置Exchange、Queue、及绑定交换机。 本例配置Topic交换机。

package com.xuecheng.test.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 QUEUE_INFORM_EMAIL = "queue_inform_email"; 
public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
public static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";



/**
*交换机配置
*ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
*@return the exchange
*/ @Bean(EXCHANGE_TOPICS_INFORM)
public Exchange EXCHANGE_TOPICS_INFORM() {
//durable(true)持久化，消息队列重启后交换机仍然存在
	return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
}
//声明队列@Bean(QUEUE_INFORM_SMS)
public Queue QUEUE_INFORM_SMS() {
	Queue queue = new Queue(QUEUE_INFORM_SMS); return queue;
}
//声明队列@Bean(QUEUE_INFORM_EMAIL)
public Queue QUEUE_INFORM_EMAIL() {
	Queue queue = new Queue(QUEUE_INFORM_EMAIL); return queue;
}
/** channel.queueBind(INFORM_QUEUE_SMS,"inform_exchange_topic","inform.#.sms.#");
*绑定队列到交换机 .
*
*@param queue	the queue
*@param exchange the exchange
*@return the binding
*/ @Bean
public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue, @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
	return BindingBuilder.bind(queue).to(exchange).with("inform.#.sms.#").noargs();
}
@Bean
public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue, @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
	return BindingBuilder.bind(queue).to(exchange).with("inform.#.email.#").noargs();
	}
}

4.3生产端

使用RarbbitTemplate发送消息

package com.xuecheng.test.rabbitmq;

import com.xuecheng.test.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 Producer05_topics_springboot { 
@Autowired
RabbitTemplate rabbitTemplate;

@Test
public void testSendByTopics(){
	 for (int i=0;i<5;i++){
	String message = "sms email inform to user"+i;

	rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.sms.e	m	ail",message); System.out.println("Send Message is:'" + message + "'");
		}
	}
}

4.4消费端

创建消费端工程，添加依赖：





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

使用@RabbitListener注解监听队列。

package com.xuecheng.test.rabbitmq.mq;

import com.rabbitmq.client.Channel;
import com.xuecheng.test.rabbitmq.config.RabbitmqConfig; 
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ReceiveHandler {

//监听email队列
@RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})
	public void receive_email(String msg,Message message,Channel channel){ System.out.println(msg);
}

//监听sms队列
@RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_SMS})
	public void receive_sms(String msg,Message message,Channel channel){ System.out.println(msg);
	}
}

4.5测试

在这里插入图片描述

小飞侠v科比
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ消息中间件实战(附讲义和源码)
01-13
课程简介：RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。课程内容大纲： 课程讲义：       
RabbitMQ高级 讲义
happy_de_goudan的博客
05-07 236
0. 学习目标 掌握RabbitMQ 高级特性 理解RabbitMQ 应用问题 能够搭建RabbitMQ 集群 1. RabbitMQ 高级特性 1.1 消息可靠性投递 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm 确认模式 return 退回模式 rabbitmq 整个消息投递的路径为： ​ producer —> rabbitmq broker
1.RabbitMQ讲义--基础
无
05-23 253
目录 RabbitMQ讲义--基础1. 消息中间件概述1.1. 什么是消息中间件1.2. AMQP 和 JMS1.2.1. AMQP1.2.2. JMS1.2.3. AMQP 与 JMS 区别1.3. 消息队列产品1.4. RabbitMQ2. 安装及配置RabbitMQ3. RabbitMQ入门3.1. 搭建示例工程3.1.1. 创建工程3.1.2. 添加依赖3.2. 编写生产者3.3. 编写消费者3.4. 小结4. AMQP4.1. 相关概念介绍4.2. RabbitMQ运转流程4.3. 生产者流转过
RabbitMQ 讲义
nnnnnnnnnnii的博客
11-18 254
0. 学习目标 能够说出什么是消息中间件 能够安装RabbitMQ 能够编写RabbitMQ的入门程序 能够说出RabbitMQ的5种模式特征 能够使用Springboot整合RabbitMQ 1. 消息中间件概述 1.1. 什么是消息中间件 MQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。 为什么使用MQ 在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。 开发中消息
RabbitMQ学习讲义
11-17
RabbitMQ学习讲义，可以为您讲解基础的AMQP协议。以及用Java语言如何操作RabbitMQ。
学成在线-第5天-讲义-消息中间件RabbitMQ v1.21
08-03
1、管理员进入管理界面点击“页面发布”，前端请求cms页面发布接口 2、cms页面发布接口执行页面静态化，并将静态化页面(html文件)存储至GridFS中 3
消息队列RabbitMQ学习-1
01-20
消息队列RabbitMQ学习 为什么学习RabbitMQ 每一种技术的出现，都是为了解决业务需求而产生的。通常的背景是，在某种业务场景下，出现了某种问题，怎么解决这种问题，一个新的技术产生了。下面举个单体架构的例子来...
java队列源码-rabbitmq-repository:RabbitMQ消息队列学习的源码记录
05-24
只是第一个rabbitmq的例子 => hello world 消费者不能关闭连接，需要一直轮询查看是否存在消息 rabbitmq-java-queque rabbitmq任务队列示例 rabbitmq-java-publish-receive rabbitmq发布订阅示例 rabbitmq-java-...
rabbitmq-message-deduplication:RabbitMQ插件，用于过滤消息重复项
05-02
RabbitMQ消息重复数据删除插件 一个用于过滤重复消息的插件。 将消息发布到交换机中或放入队列后，可以对消息进行重复数据删除。 正在安装 支持的RabbitMQ版本： > = 3.7.17使用标记为v3.8.x发行版 <= 3.7.16...
Spring-rabbitMQ整合消息队列RabbitMQ
11-15
Spring boot整合消息队列RabbitMQ
RabbitMQ 讲义.pdf
03-31
RabbitMQ开发讲义,适合初学者进行学习的知识点操作,在有限的日子里进行快速的学习.
rabbitMQ学习资料
05-25
rabbitMQ中间件学习资料，包含分阶段的学习的源码以及相关的文档说明，资料来源于牧马人
RabbitMQ
09-22
RabbitMQ　　消息的中间件
rabbitmq 学习资料
乔永刚的博客
01-15 612
这是一个博主写的使用笔记 https://www.zybuluo.com/dume2007/note/665734 国外论坛大佬写的一个详细demo 非常好的文章 可能需要翻墙 https://hotexamples.com/examples/phpamqplib.connection/AMQPStreamConnection/channel/php-amqpstreamconnection-...
MQ消息队列之RabbitMQ的学习
qq_38116774的博客
03-01 229
RabbitMQ简介 MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言（一种适用于高并发的语言）开发，基于AMQP（Advanced MessageQueue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开 发中应用非常广泛。 使用场景 任务异步处理。 将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方...
RabbitMq知识汇总
rongxue2599的博客
04-19 326
1.应用场景 1.其实我们在双11的时候，当我们凌晨大量的秒杀和抢购商品，然后去结算的时候，就会发现，界面会提醒我们，让我们稍等，以及一些友好的图片文字提醒。而不是像前几年的时代，动不动就页面卡死，报错等来呈现给用户。    在这业务场景中，我们就可以采用队列的机制来处理，因为同时结算就只能达到这么多。    2.在我们平时的超市中购物也是一样，当我们在结算的时候，并不会一窝蜂一样涌入收银台，而是...
3.RabbitMQ讲义--高级
无
10-26 873
3.RabbitMQ讲义--高级 7. RbbitMQ 高级 7.1. 过期时间TTL 7.1.1. 设置队列TTL 7.1.2. 设置消息TTL 7.2. 死信队列 7.2.1. 定义死信交换机 7.2.2. 队列设置死信交换机 7.2.3. 消息过期的死信队列测试 1）发送消息代码 2）在rabbitMQ管理界面中结果 3）流程 7.2.4. 消息过长的死信队列测试 1）发送消息代码 2）在rabbitMQ管理界面中结果 3）消费者接收死信队列消息 4）流程 7.3. 延迟队列 7.4. 消息确认机制
消息队列-RabbitMQ
最新发布
09-14
RabbitMQ是一个开源的消息队列系统，它实现了高效的消息传递机制。它使用AMQP（Advanced Message Queuing Protocol）作为通信协议，并提供了可靠的消息传递、灵活的路由方式和强大的消息模式支持。 通过RabbitMQ，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值