1、什么是mq?
消息队列(Message Queue,简称MQ):是在消息的传输过程中保存消息的容器。用于分布式系统之间进行通信。
2、什么是RabbitMQ?
AMQP,即 Advanced Message Queuing Protocol(高级消息队列协议),是一个网络协议,是应用层协议的一个开放标准,为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息,并不受客户端/中间件不同产品,不同的开发语言等条件的限制。2006年,AMQP规范发布。类比HTTP。
connection:连接rabbitmq的通道
channel:轻量级的connection
exchange:交换机,只负责分发消息, 若没有queue绑定到交换机则消息会丢失。
queue:存储消息的容器
routeKey:更加灵活的发消息
3、为什么要使用RabbitMQ?
解耦
传统模式:系统间耦合性太强
中间件模式:将消息写入消息队列,需要消息的系统自己从消息队列中订阅,从而系统A不需要做任何修改。
异步
传统模式: 一些非必要的业务逻辑以同步的方式运行,太耗费时间
中间件模式: 将消息写入消息队列,非必要的业务逻辑以异步的方式运行,加快响应速度
削峰
传统模式:并发量大的时候,所有的请求直接怼到数据库,造成数据库连接异常
中间件模式: 系统A慢慢的按照数据库能处理的并发量,从消息队列中慢慢拉取消息
4、RabbitMQ安装
安装Erlang
1)rpm -ivh esl-erlang-17.3-1.x86_64.rpm --force --nodeps
2)rpm -ivh esl-erlang_17.3-1~centos~6_amd64.rpm --force --nodeps
3)rpm -ivh esl-erlang-compat-R14B-1.el6.noarch.rpm --force --nodeps
安装RabbitMQ
rpm -ivh rabbitmq-server-3.4.1-1.noarch.rpm
启动、停止
service rabbitmq-server start
service rabbitmq-server stop
service rabbitmq-server restart
service rabbitmq-server status
开启启动
chkconfig rabbitmq-server on
添加用户
创建Virtual Hosts,设置权限
虚拟主机:类似于mysql中的database。他们都是以“/”开头
5、物种消息模型
依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
</dependencies>
创建连接工具类代码
public class ConnectionUtil {
/**
* 发送方,接收方,获取连接
*/
public static Connection getConnection() throws IOException, TimeoutException {
//定义连接工厂
ConnectionFactory factory = new ConnectionFactory();
//ip
factory.setHost("192.168.80.138");
//port
factory.setPort(5672);
//username,password
factory.setUsername("admin");
factory.setPassword("1111");
//Virtual Hosts仓库
factory.setVirtualHost("/");
//由工厂返回连接
return factory.newConnection();
}
}
Simple-简单模型
发送方代码
public class Sender {
public static void main(String[] args) throws IOException, TimeoutException {
//获取连接,连接rabbitmq的通道
Connection connection = ConnectionUtil.getConnection();
//信道channel:轻量级的connection,是connection的复用,是完成大量api的对象
Channel channel = connection.createChannel();
//声明队列 Declare:声明
// 声明(创建)队列,必须声明队列才能够发送消息,我们可以把消息发送到队列中。
// 声明一个队列是幂等的 - 只有当它不存在时才会被创建
String QUEUE_NAME = "simple_queue";
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
//发送消息 Publish:发行,出版,发表
String message = "世界你好";
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("Sent :'" + message + "'");
channel.close();
connection.close();
}
}
消息确认机制(ACK)
//当autoask自动确认设为false,队列中的消息不会自动清除,确认后才会清除
//- 如果消息不太重要,丢失也没有影响,那么自动ACK会比较方便
//- 如果消息非常重要,不容丢失。那么最好在消费完成后手动ACK,否则接收消息后就自动ACK,RabbitMQ就会把消息从队列中删除。
//如果此时消费者宕机,那么消息就丢失了。
channel.basicConsume(QUEUE_NAME, true, consumer);
自动ack存在的问题
运行消费者,程序抛出异常。但是消息依然被消费:
怎么进行手动ack?
try {
String s = new String(body);
System.out.println(s);
//模拟业务处理失败
int a = 6 / 0;
//手动进行ack
//long deliveryTag:当前消息的索引
//boolean multiple:是否确认多条消息,true则把收到的所有消息都确认了
channel.basicAck(envelope.getDeliveryTag(), false);
} catch (Exception e) {
e.printStackTrace();
}
channel.basicConsume(QUEUE_NAME, false, consumer);
总结:
producer----》|queue|-----》consumer
手动ack:
好处:保证消费者把消息成功消费(理论)
Work-工作模型
工作队列,又称任务队列。主要思想就是避免执行资源密集型任务时,必须等待它执行完成。相反我们稍后完成任务,我们将任务封装为消息并将其发送到队列。 在后台运行的工作进程将获取任务并最终执行作业。当你运行许多消费者时,任务将在他们之间共享,但是一个消息只能被一个消费者获取。
发送者
public class Sender {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
String QUEUE_NAME = "work_queue";
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
for (int i = 0; i < 50; i++) {
String message = "世界你好"+i;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println("Sent :'" + message + "'");
}
channel.close();
connection.close();
}
}
能者多劳
关键:
每次只处理一条消息
channel.basicQos(1);
消费者1
public class Receive1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
String QUEUE_NAME = "work_queue";
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
//每次只处理一条消息
channel.basicQos(1);
DefaultConsumer consumer = new DefaultConsumer(channel) {
//匿名类
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
try {
String s = new String(body);
System.out.println("Receive1:" + s);
channel.basicAck(envelope.getDeliveryTag(), false);
} catch (Exception e) {
e.printStackTrace();
}
}
};
channel.basicConsume(QUEUE_NAME, false, consumer);
}
}
消费者2
public class Receive2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
String QUEUE_NAME = "work_queue";
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
//每次只处理一条消息
channel.basicQos(1);
DefaultConsumer consumer = new DefaultConsumer(channel) {
//匿名类
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
try {
String s = new String(body);
System.out.println(s);
channel.basicAck(envelope.getDeliveryTag(), false);
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
};
channel.basicConsume(QUEUE_NAME, false, consumer);
}
}
总结:
provider–》queue—》多sumer
能者多劳
每次只处理一条消息
channel.basicQos(1);
好处:防止消息堆积
面试题:避免消息堆积?(多个consumer能者多劳)
1)采用workqueue,多个消费者监听同一队列。能者多劳,每次处理一个消息
2)接收到消息以后,而是通过线程池,异步消费。
Simple模型和Work模型一个消息只能有一个接收者接收到,而Fanout广播模型,Direct定向模型,Topic主题模型一个消息可以有多个接收者接收到。
Fanout-广播模型
Fanout,也称为广播。
在广播模式下,消息发送流程是这样的:
- 1) 可以有多个消费者
- 2) 每个消费者有自己的queue(队列)
- 3) 每个队列都要绑定到Exchange(交换机)
- 4) 生产者发送的消息,只能发送到交换机,交换机来决定要发给哪个队列,生产者无法决定。
- 5) 交换机把消息发送给绑定过的所有队列
- 6) 队列的消费者都能拿到消息。实现一条消息被多个消费者消费
sender
public class Sender {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
//声明交换器
String EXCHANGE_NAME = "fanout_exchange";
channel.exchangeDeclare(EXCHANGE_NAME, ExchangeTypes.FANOUT);
String message = "世界你好";
channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
System.out.println("Sent :'" + message + "'");
channel.close();
connection.close();
}
}
consumer1
/**
* @author ⭐⭐
* @date 2022/11/7 23:51
*/
public class Receive1 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
String QUEUE_NAME = "fanout_queue1";
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
//把队列绑定到exchange
String EXCHANGE_NAME = "fanout_exchange";
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
//每次只处理一条消息
channel.basicQos(1);
DefaultConsumer consumer = new DefaultConsumer(channel) {
//匿名类
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
try {
String s = new String(body);
System.out.println("Receive1:" + s);
channel.basicAck(envelope.getDeliveryTag(), false);
} catch (Exception e) {
e.printStackTrace();
}
}
};
channel.basicConsume(QUEUE_NAME, false, consumer);
}
}
consumer2
/**
* @author ⭐⭐
* @date 2022/11/7 23:51
*/
public class Receive2 {
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtil.getConnection();
Channel channel = connection.createChannel();
String QUEUE_NAME = "fanout_queue2";
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
//把队列绑定到exchange
String EXCHANGE_NAME = "fanout_exchange";
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
//每次只处理一条消息
channel.basicQos(1);
DefaultConsumer consumer = new DefaultConsumer(channel) {
//匿名类
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String s = new String(body);
System.out.println("Receive2:" + s);
channel.basicAck(envelope.getDeliveryTag(), false);
}
};
channel.basicConsume(QUEUE_NAME, false, consumer);
}
}
总结:
producer---》exchange----》多queue-----》多consumer
exchange只负责分发消息,若没有queue绑定到交换器上则会把消息丢失
Direct-定向模型
有选择性的接收消息
在订阅模式中,生产者发布消息,所有消费者都可以获取所有消息。
在路由模式中,我们将添加一个功能 - 我们将只能订阅一部分消息。 例如,我们只能将重要的错误消息引导到日志文件(以节省磁盘空间),同时仍然能够在控制台上打印所有日志消息。
但是,在某些场景下,我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。
在Direct模型下,队列与交换机的绑定,不能是任意绑定了,而是要指定一个RoutingKey(路由key)
消息的发送方在向Exchange发送消息时,也必须指定消息的routing key。
P:生产者,向Exchange发送消息,发送消息时,会指定一个routing key。
X:Exchange(交换机),接收生产者的消息,然后把消息递交给 与routing key完全匹配的队列
C1:消费者,其所在队列指定了需要routing key 为 error 的消息
C2:消费者,其所在队列指定了需要routing key 为 info、error、warning 的消息
总结:
producer—》exchange—》routingKey------》多queue-----》多consumer
比fanout多了一个routekey,灵活控制exchange把消息分发到哪个queue。
发送给指定的routekey,灵活分发消息
topic-定向模型
Topic
类型的Exchange
与Direct
相比,都是可以根据RoutingKey
把消息路由到不同的队列。只不过Topic
类型Exchange
可以让队列在绑定Routing key
的时候使用通配符!
Routingkey
一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如: item.insert
通配符规则:
`#`:匹配一个或多个词
`*`:匹配不多不少恰好1个词
总结:
producer—》exchange—》*.routingKey------》多queue-----》多consumer
比fanout多了一个routekey,灵活控制exchange把消息分发到哪个queue。
发送给指定的routekey,灵活分发消息
#
:匹配一个或多个词
*
:匹配不多不少恰好1个词
也可以使用work消息模型的功能
RabbbitMQ持久化
如何避免消息丢失?
1) 消费者的手动ACK机制。可以防止业务处理失败。
2) 但是,如果在消费者消费之前,MQ就宕机了,消息就没了。
是可以将消息进行持久化呢?
要将消息持久化,前提是:队列、Exchange都持久化
持久化
1.exchange
第三个参数代表交换机持久化
channel.exchangeDeclare(EXCHANGE_NAME, ExchangeTypes.TOPIC,true);
2.queue
第二个参数代表队列持久化
channel.queueDeclare(QUEUE_NAME, true, false, false, null);
3.消息
MessageProperties.PERSISTENT_TEXT_PLAIN是消息持久化
channel.basicPublish(EXCHANGE_NAME, “item.delete”, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
Srpignboot整合RabbbitMQ
接收者Recever代码
@Component
public class Receive {
/**
* 接收消息 三要素
* 1.queue
* 2.exchange
* 3.routingKey
*/
@RabbitListener(bindings = {
@QueueBinding(
value = @Queue(value = "springboot_queue", durable = "true"),
exchange = @Exchange(value = "springboot_exchange", type = ExchangeTypes.TOPIC),
key = {"item.*"}
)})
public void receiveMsg(String msg, Channel channel, Message message) {
try {
System.out.println("receive:" + msg);
// int i = 1 / 0;
//手动ack
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
} catch (Exception e) {
e.printStackTrace();
}
}
}
发送者sender代码
public class RabbitMqTest {
@Autowired
private AmqpTemplate amqpTemplate;
@Test
public void testSendMsg() throws InterruptedException {
String msg = "师姐你好";
amqpTemplate.convertAndSend("springboot_exchange", "item.delete", msg);
Thread.sleep(10000);
}
}
springboot设置手动ack
spring:
rabbitmq:
host: 192.168.80.138
port: 5672
username: admin
password: 1111
virtual-host: /
listener: #手动ack消息确认
simple:
acknowledge-mode: manual #不自动ack 一对一的那两个,简单模型,work模型
direct:
acknowledge-mode: manual #不自动ack 多对多的那几个,后三中,广播,定向,主题
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //直接在容器中拿channel,message
如何保证消费者把消息成功消费?(理论)(保证消息不会丢失)
1.ack:把自动确认消息,改为手动确认消息,但当服务器出现故障,则这种方法不起作用。
2.持久化,持久化队列, 持久化交换机,持久化消息,在创建时把durable改为true
面试题:避免消息堆积?(多个consumer能者多劳)
1)采用workqueue,多个消费者监听同一队列。能者多劳,每次处理一个消息
2)接收到消息以后,而是通过线程池,异步消费。