RabbitMQ快速入门
- 前言
- 一、RabbitMQ快速入门
- 二、为什么使用RabbitMQ
- 三.快速入门-简单入门案例
- 1.添加依赖
- 2.编写生成者
- 3.编写消费者
- 4.生产者流转过程
- 1.客户端与代理服务器Broker建立连接。会调用newConnection() 方法,这个方法会进一步封装Protocol Header 0-9-1 的报文头发送给Broker ,以此通知Broker 本次交互采用的是AMQPO-9-1 协议,紧接着Broker 返回Connection.Start 来建立连接,在连接的过程中涉及Connection.Start/.Start-OK 、Connection.Tune/.Tune-Ok ,Connection.Open/ .Open-Ok 这6 个命令的交互。
- 2.客户端调用connection.createChannel方法。此方法开启信道,其包装的channel.open命令发送给Broker,等待channel.basicPublish方法,对应的AMQP命令为Basic.Publish,这个命令包含了content Header 和content Body()。content Header 包含了消息体的属性,例如:投递模式,优先级等,content Body 包含了消息体本身。
- 3.客户端发送完消息需要关闭资源时,涉及到Channel.Close和Channl.Close-Ok 与Connetion.Close和Connection.Close-Ok的命令交互。
- 5.消费者流转过程
- 1. 消费者客户端与代理服务器Broker建立连接。会调用newConnection() 方法,这个方法会进一步封装Protocol Header 0-9-1 的报文头发送给Broker ,以此通知Broker 本次交互采用的是AMQPO-9-1 协议,紧接着Broker 返回Connection.Start 来建立连接,在连接的过程中涉及Connection.Start/.Start-OK 、Connection.Tune/.Tune-Ok ,Connection.Open/ .Open-Ok 这6 个命令的交互。
- 2.消费者客户端调用connection.createChannel方法。和生产者客户端一样,协议涉及Channel . Open/Open-Ok命令。
- 3. 在真正消费之前,消费者客户端需要向Broker 发送Basic.Consume 命令(即调用channel.basicConsume 方法〉将Channel 置为接收模式,之后Broker 回执Basic . Consume - Ok 以告诉消费者客户端准备好消费消息。
- 4. Broker 向消费者客户端推送(Push) 消息,即Basic.Deliver 命令,这个命令和Basic.Publish 命令一样会携带Content Header 和Content Body。
- 5.消费者接收到消息并正确消费之后,向Broker 发送确认,即Basic.Ack 命令。
- 6. 客户端发送完消息需要关闭资源时,涉及到Channel.Close和Channl.Close-Ok 与Connetion.Close和Connection.Close-Ok的命令交互。
- 四.RabbitMQ工作模式
前言
RabbitMQ快速入门系列。
一、RabbitMQ快速入门
1.MQ定义
1.大致流程:
消费者(consumer)监听队列内容,当生产者(product)向队列中发布新消息,消费者监听到有新消息需要进行消费的消息,执行对应的逻辑.
2.消息队列模型
2.1 模型讲解
.Broker:标识消息队列服务器实体
.Virtual Host:虚拟主机。标识一批交换机、消息队列和相关对象
.Exchange:交换器,用来接收生产者发送的消息并将这些消息路由给服务器中的队列。
.Queue:消息队列,用来保存消息直到发送给消费者。它是消息的容器,也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面,等待消费者连接到这个队列将其取走。
.Banding:绑定,用于消息队列和交换机之间的关联。
.Channel:信道,多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟链接,AMQP命令都是通过信道发出去的,不管是发布消息、订阅队列还是接收消息,这些动作都是通过信道完成。因为对于操作系统来说,建立和销毁TCP都是非常昂贵的开销,所以引入了信道的概念,以复用一条TCP连接。
.Connection:网络连接,比如一个TCP连接。
.Publisher:消息的生产者,也是一个向交换器发布消息的客户端应用程序。
.Consumer:消息的消费者,表示一个从一个消息队列中取得消息的客户端应用程序。
二、为什么使用RabbitMQ
1.使用RabbitMQ的好处
1.1可将一些不需要立即返回接口的业务放到MQ中进行异步处理,这样做可以增加服务器阈值的量,不用怕服务器被瞬间的并发量而冲垮.
使用场景
任务异步处理:将需要大量处理时间的任务放到队列中去执行,减少用户等待时间,只需要执行完成等待结果就可以.
应用程序解耦合:生产者与消费者将不直接耦合,生产者与消费者将依赖MQ进行互相通讯.
削峰填谷:如有并发超过每秒1000的时候时候,就会超到单mysql的阈值,造成数据库宕机,造成整个服务的不可用,如将消息都放到MQ中,根据mysql的阈值进行消费,这样就可以预防mysql宏机,将巅峰时候的并发量积压在MQ中,根据消费能力进行消费,直到积压的消息执行完成,这样就完成填谷.
2.AMQP 和 JMS
AMQP
AMQP是一种协议,更准确来说是一种binary wire-level protocol(链接协议)。这是其和JMS的本质区别,AMQP不从API层进行限定,而是直接定义网络交换的数据格式。
AMQP是一个二进制协议,拥有一些现代化特点:多信道、协商式,异步,安全,扩平台,中立,高效。
JMS
JMS即Java消息服务(JavaMessage Service)应用程序接口,是一个Java平台中关于面向消息中间件(MOM)的API,用于在两个应用程序之间,或分布式系统中发送消息,进行异步通信。
AMQP和JMS的区别
目前市面上流行的MQ
三.快速入门-简单入门案例
1.添加依赖
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.6.0</version>
</dependency>
2.编写生成者
public class Producer {
static final String QUEUE_NAME = "simple_queue";
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接工厂
Connection connection = ConnectionUtil.getConnection();
//创建信道
Channel channel = connection.createChannel();
// 声明(创建)队列
channel.queueDeclare(QUEUE_NAME,true,false,false,null);
//要发送的信息
String message = "Hello World";
channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
System.out.println("已发送消息:"+message);
//关闭资源
channel.close();
connection.close();
}
}
注:在执行上述的消息发送之后;可以登录rabbitMQ的管理控制台
3.编写消费者
public class Consumer {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
//创建频道
Channel channel = connection.createChannel();
// 声明(创建)队列
channel.queueDeclare(Producer.QUEUE_NAME,true,false,false,null);
//创建消费者:并设置消息处理
DefaultConsumer consumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:"+envelope.getRoutingKey());
//交换机
System.out.println("交换机为:"+envelope.getExchange());
//消息id
System.out.println("消息id为:"+envelope.getDeliveryTag());
//收到的消息
System.out.println("接收到的消息为:"+new String(body));
}
};
//监听消息
channel.basicConsume(Producer.QUEUE_NAME,true,consumer);
//不关闭资源,一直监听
}
}
上述代码模型
流程解释
4.生产者流转过程
1.客户端与代理服务器Broker建立连接。会调用newConnection() 方法,这个方法会进一步封装Protocol Header 0-9-1 的报文头发送给Broker ,以此通知Broker 本次交互采用的是AMQPO-9-1 协议,紧接着Broker 返回Connection.Start 来建立连接,在连接的过程中涉及Connection.Start/.Start-OK 、Connection.Tune/.Tune-Ok ,Connection.Open/ .Open-Ok 这6 个命令的交互。
2.客户端调用connection.createChannel方法。此方法开启信道,其包装的channel.open命令发送给Broker,等待channel.basicPublish方法,对应的AMQP命令为Basic.Publish,这个命令包含了content Header 和content Body()。content Header 包含了消息体的属性,例如:投递模式,优先级等,content Body 包含了消息体本身。
3.客户端发送完消息需要关闭资源时,涉及到Channel.Close和Channl.Close-Ok 与Connetion.Close和Connection.Close-Ok的命令交互。
5.消费者流转过程
1. 消费者客户端与代理服务器Broker建立连接。会调用newConnection() 方法,这个方法会进一步封装Protocol Header 0-9-1 的报文头发送给Broker ,以此通知Broker 本次交互采用的是AMQPO-9-1 协议,紧接着Broker 返回Connection.Start 来建立连接,在连接的过程中涉及Connection.Start/.Start-OK 、Connection.Tune/.Tune-Ok ,Connection.Open/ .Open-Ok 这6 个命令的交互。
2.消费者客户端调用connection.createChannel方法。和生产者客户端一样,协议涉及Channel . Open/Open-Ok命令。
3. 在真正消费之前,消费者客户端需要向Broker 发送Basic.Consume 命令(即调用channel.basicConsume 方法〉将Channel 置为接收模式,之后Broker 回执Basic . Consume - Ok 以告诉消费者客户端准备好消费消息。
4. Broker 向消费者客户端推送(Push) 消息,即Basic.Deliver 命令,这个命令和Basic.Publish 命令一样会携带Content Header 和Content Body。
5.消费者接收到消息并正确消费之后,向Broker 发送确认,即Basic.Ack 命令。
6. 客户端发送完消息需要关闭资源时,涉及到Channel.Close和Channl.Close-Ok 与Connetion.Close和Connection.Close-Ok的命令交互。
四.RabbitMQ工作模式
1.Work queues工作队列模式
Work Queues与入门程序的简单模式相比,多了一个或一些消费端,多个消费端共同消费同一个队列中的消息。
应用场景:对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
1.1代码示例
生产者
public class Producer {
static final String QUEUE_NAME = "work_queue";
public static void main(String[] args) throws IOException, TimeoutException {
//本人将获取连接封装成工具类,你们可以把入门案例的连接代码复制过来
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
// 声明(创建)队列
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
for (int i = 1; i <= 30; i++) {
// 发送信息
String message = "work模式--" + i;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("已发送消息:" + message);
}
// 关闭资源
channel.close();
connection.close();
}
}
消费者
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
// 创建频道
final Channel channel = connection.createChannel();
// 声明(创建)队列
channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);
//一次只能接收并处理一个消息
channel.basicQos(1);
//创建消费者:并设置消息处理
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
try {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
Thread.sleep(1000);//单纯增强实验效果
//确认信息
channel.basicAck(envelope.getDeliveryTag(),false);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//监听消息
channel.basicConsume(Producer.QUEUE_NAME,false,defaultConsumer);
}
}
测试结果
可以从输出的结果看出两台消费者是竞争关系
2.Publish/Subscribe 发布订阅模式
模式简介
每个消费者监听自己的队列
生产者将消息发给broker,由交换机将消息转发到绑定此交换机的队列,每个绑定交换机的队列都将接收到消息
p(浅蓝):为生产者,不是直接讲消息发送到队列中,而是先将消息发送到x交换机中,由交换机分配消息放到对应的队列中
x(深蓝): 交换机,不具备存储消息的能力,会将
C1(C2):消费者,等待处理消息。
Queue(红色方块):接收并处理消息,不具备储存消息的功能,如果没有队列与其绑定,或者没有符合路由规则的队列,消息就会丢失(gg)…
常见的交换机有如下3种:
■Fanout:广播型,将消息发送给所有绑定交换机的队列
■Direct :定向型,把消息发送给指定路由key的队列
■Topic :通配符,个人理解就是在路由模式(下面会讲到)的队列
代码示例
生产者
/**
* 发布与订阅使用的交换机类型为:fanout
*/
public class Producer {
//交换机名称
static final String FANOUT_EXCHAGE = "fanout_exchange";
//队列名称
static final String FANOUT_QUEUE_1 = "fanout_queue_1";
//队列名称
static final String FANOUT_QUEUE_2 = "fanout_queue_2";
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接
Connection connection = ConnectionUtil.getConnection();
// 创建信道
Channel channel = connection.createChannel();
channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
//创建队列
channel.queueDeclare(FANOUT_QUEUE_1,true,false,false,null);
channel.queueDeclare(FANOUT_QUEUE_2,true,false,false,null);
//队列绑定交换机
channel.queueBind(FANOUT_QUEUE_1,FANOUT_EXCHAGE,"");
channel.queueBind(FANOUT_QUEUE_2,FANOUT_EXCHAGE,"");
for (int i = 1; i <= 10; i++) {
// 发送信息
String message = "岳某人 发布订阅模式--" + i;
channel.basicPublish(FANOUT_EXCHAGE,"",null,message.getBytes());
System.out.println("已发送信息:"+message);
}
// 关闭资源
channel.close();
connection.close();
}
}
消费者
public class Consumer1 {
public static void main(String[] args) throws Exception {
Connection connection = ConnectionUtil.getConnection();
// 创建频道
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
// 声明(创建)队列
channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null);
//队列绑定交换机
channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHAGE, "");
//创建消费者;并设置消息处理
DefaultConsumer consumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
}
};
//监听消息
channel.basicConsume(Producer.FANOUT_QUEUE_1, true, consumer);
}
}
测试结构
3.Routing路由模式
模式介绍
发送方向交换机发送消息时,必须指定消息的RoutingKey
交换机不再把消息交给每一个绑定的队列,而是根据消息的RoutingKey判断筛选,只有队列的RoutingKey与消息的RoutingKey一致,才会接收到消息
■生产者
/**
* 路由模式的交换机类型为:direct
*/
public class Producer {
//交换机名称
static final String DIRECT_EXCHAGE = "direct_exchange";
//队列名称
static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
//队列名称
static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接
Connection connection = ConnectionUtil.getConnection();
// 创建频道
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
//声明队列
channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);
//与队列绑定交换机
channel.queueBind(DIRECT_QUEUE_INSERT,DIRECT_EXCHAGE,"insert");
channel.queueBind(DIRECT_QUEUE_UPDATE,DIRECT_EXCHAGE,"update");
//发送信息
String message = "cxk 路由模式;routing key 为 insert";
channel.basicPublish(DIRECT_EXCHAGE, "insert", null, message.getBytes());
System.out.println("已发送信息:" + message);
//发送信息
message = "Chicken you are too beautiful 路由模式;routing key 为 update";
channel.basicPublish(DIRECT_EXCHAGE,"update",null,message.getBytes());
System.out.println("已发送信息:" + message);
// 关闭资源
channel.close();
connection.close();
}
}
■消费者
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
// 创建频道
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
//声明队列
channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);
//队列绑定交换机
channel.queueBind(Producer.DIRECT_QUEUE_INSERT,Producer.DIRECT_EXCHAGE,"insert");
//创建消费者,并设置消息处理
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
}
};
//监听消息
channel.basicConsume(Producer.DIRECT_QUEUE_INSERT,true,defaultConsumer);
}
}
测试结果
1.消费者
2.消费者
4.Topics通配符模式
模式介绍
个人理解:和Routing模式很类似,只不过Routing模式的路由键是固定的,Topic类型的交换机可以模糊匹配路由键(非固定)
开发中路由键一般都是多个单词拼凑的,中间用.连接,例如:ys.add
通配符规则:
‘#’:匹配一个或多个词
‘*’:只能匹配一个词
代码示例
■生产者
public class Producer {
//交换机名称
static final String TOPIC_EXCHAGE = "topic_exchange";
//队列名称
static final String TOPIC_QUEUE_1 = "topic_queue_1";
//队列名称
static final String TOPIC_QUEUE_2 = "topic_queue_2";
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接
Connection connection = ConnectionUtil.getConnection();
// 创建频道
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
//发送消息
String message = "新增了商品。Topic模式;routing key 为 item.insert " ;
channel.basicPublish(TOPIC_EXCHAGE,"item.insert",null,message.getBytes());
// 发送信息
message = "修改了商品。Topic模式;routing key 为 item.update" ;
channel.basicPublish(TOPIC_EXCHAGE, "item.update", null, message.getBytes());
System.out.println("已发送消息:" + message);
// 发送信息
message = "删除了商品。Topic模式;routing key 为 item.delete" ;
channel.basicPublish(TOPIC_EXCHAGE, "item.delete", null, message.getBytes());
System.out.println("已发送消息:" + message);
// 关闭资源
channel.close();
connection.close();
}
}
■消费者
public class Consumer1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
// 创建频道
Channel channel = connection.createChannel();
//声明交换机
channel.exchangeDeclare(Producer.TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
//声明队列
channel.queueDeclare(Producer.TOPIC_QUEUE_1,true,false,false,null);
//队列绑定交换机
channel.queueBind(Producer.TOPIC_QUEUE_1,Producer.TOPIC_EXCHAGE,"item.update");
channel.queueBind(Producer.TOPIC_QUEUE_1,Producer.TOPIC_EXCHAGE,"item.delete");
//创建消费者
DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
//路由key
System.out.println("路由key为:" + envelope.getRoutingKey());
//交换机
System.out.println("交换机为:" + envelope.getExchange());
//消息id
System.out.println("消息id为:" + envelope.getDeliveryTag());
//收到的消息
System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
}
};
//监听消息
channel.basicConsume(Producer.TOPIC_QUEUE_1,true,defaultConsumer);
}
}
测试结构
1.消费者1
2.消费者2