RabbitMQ是什么?
消息队列, 基于AMQP(高级消息队列), 使用Erlang语言编写, 收发消息使用
- 有什么用? 有什么应用场景?
1. 任务异步处理
2. 应用程序解耦
- 为什么使用RabbitMQ?
1. 使用简单
2. 基于AMQP
3. 社区活动
4, 高并发性能好(Erlang语言)
5. springboot默认集成RabbitMQ
AMQP是什么?
AMQP是什么?
AMQP，即Advanced Message Queuing Protocol，
一个提供统一消息服务的应用层标准高级消息队列协议，
是应用层协议的一个开放标准，为面向消息的中间件设计。
基于此协议的客户端与消息中间件可传递消息，
并不受客户端/中间件不同产品，不同的开发语言等条件的限制。5
1
AMQP，即Advanced Message Queuing Protocol，2
一个提供统一消息服务的应用层标准高级消息队列协议，3
是应用层协议的一个开放标准，为面向消息的中间件设计。4
基于此协议的客户端与消息中间件可传递消息，5
并不受客户端/中间件不同产品，不同的开发语言等条件的限制。- AMQP的应用场景
存储转发（多个消息发送者，单个消息接收者）。
分布式事务（多个消息发送者，多个消息接收者）。
发布订阅（多个消息发送者，多个消息接收者）。
基于内容的路由（多个消息发送者，多个消息接收者）。
文件传输队列（多个消息发送者，多个消息接收者）。
点对点连接（单个消息发送者，单个消息接收者）。
- RabbitMQ安装
Linux安装
rpm -Uvh http://www.rabbitmq.com/releases/erlang/erlang-18.1-1.el7.centos.x86_64.rpm1
1
rpm -Uvh http://www.rabbitmq.com/releases/erlang/erlang-18.1-1.el7.centos.x86_64.rpmrpm -Uvh http://www.rabbitmq.com/releases/rabbitmq-server/v3.5.6/rabbitmq-server-3.5.6-1.noarch.rpm1
1
rpm -Uvh http://www.rabbitmq.com/releases/rabbitmq-server/v3.5.6/rabbitmq-server-3.5.6-1.noarch.rpmrpm -qa|grep rabbitmq1
1
rpm -qa|grep rabbitmq$ sudo chkconfig rabbitmq-server on # 添加开机启动RabbitMQ服务
$ sudo /sbin/service rabbitmq-server start # 启动服务
$ sudo /sbin/service rabbitmq-server status # 查看服务状态
$ sudo /sbin/service rabbitmq-server stop # 停止服务
# 查看当前所有用户
$ sudo rabbitmqctl list_users
# 查看默认guest用户的权限
$ sudo rabbitmqctl list_user_permissions guest
# 由于RabbitMQ默认的账号用户名和密码都是guest。为了安全起见, 先删掉默认用户
$ sudo rabbitmqctl delete_user guest
# 添加新用户
$ sudo rabbitmqctl add_user username password
# 设置用户tag
$ sudo rabbitmqctl set_user_tags username administrator
# 赋予用户默认vhost的全部操作权限
$ sudo rabbitmqctl set_permissions -p / username ".*" ".*" ".*"
# 查看用户的权限
$ sudo rabbitmqctl list_user_permissions username
26
1
$ sudo chkconfig rabbitmq-server on # 添加开机启动RabbitMQ服务2
$ sudo /sbin/service rabbitmq-server start # 启动服务3
$ sudo /sbin/service rabbitmq-server status # 查看服务状态4
$ sudo /sbin/service rabbitmq-server stop # 停止服务5
6
# 查看当前所有用户7
$ sudo rabbitmqctl list_users8
9
# 查看默认guest用户的权限10
$ sudo rabbitmqctl list_user_permissions guest11
12
# 由于RabbitMQ默认的账号用户名和密码都是guest。为了安全起见, 先删掉默认用户13
$ sudo rabbitmqctl delete_user guest14
15
# 添加新用户16
$ sudo rabbitmqctl add_user username password17
18
# 设置用户tag19
$ sudo rabbitmqctl set_user_tags username administrator20
21
# 赋予用户默认vhost的全部操作权限22
$ sudo rabbitmqctl set_permissions -p / username ".*" ".*" ".*"23
24
# 查看用户的权限25
$ sudo rabbitmqctl list_user_permissions username26
开启web管理接口
如果只从命令行操作RabbitMQ，多少有点不方便。幸好RabbitMQ自带了web管理界面，只需要启动插件便可以使用。
$ sudo rabbitmq-plugins enable rabbitmq_management1
1
$ sudo rabbitmq-plugins enable rabbitmq_management然后通过浏览器访问
输入用户名和密码访问web管理界面了。
配置RabbitMQ
关于RabbitMQ的配置，可以下载RabbitMQ的配置文件模板到/etc/rabbitmq/rabbitmq.config, 然后按照需求更改即可。
关于每个配置项的具体作用，可以参考官方文档。
更新配置后，别忘了重启服务哦！
开启用户远程访问
默认情况下，RabbitMQ的默认的guest用户只允许本机访问， 如果想让guest用户能够远程访问的话，只需要将配置文件中的loopback_users列表置为空即可，如下：
{loopback_users, []}1
1
{loopback_users, []}另外关于新添加的用户，直接就可以从远程访问的，如果想让新添加的用户只能本地访问，可以将用户名添加到上面的列表, 如只允许admin用户本机访问。
{loopback_users, ["admin"]}1
1
{loopback_users, ["admin"]}
更新配置后，别忘了重启服务哦！
- window安装方法
1. 安装erlang
创建 ERLANG_HOME=D:Program Fileserl9.3 和 %ERLANG_HOME%/bin 环境变量
2. 安装RabbitMQ
进入rabbitMQ安装目录, 执行bat批处理文件
注意事项
怎么没HelloWorld??? 别急, 在后面
rabbitMQ消息确认
1) 生产者发送消息到消息队列后, 消费者收到消息后, 消费者将会返回一个Ack进行响应, 确认消息是否传达完毕, 但是如果消费者意外关闭了, 生产者无法收取到Ack, 则RabbitMQ将会将这个消息保留下来并传达给另外的一个目标消费者
2) 消息确认必须在相同的一个通道上
channel.basicQos(1); // accept only one unack-ed message at a time (see below)
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println(" [x] Received '" + message + "'");
try {
doWork(message);
} finally {
System.out.println(" [x] Done");
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
};
boolean autoAck = false; // 手动Ack功能开始
channel.basicConsume(TASK_QUEUE_NAME, autoAck, deliverCallback, consumerTag -> { });发现消息队列中的消息过多的话, 需要删除
window
rabbitmqctl.bat list_queues name messages_ready messages_unacknowledgedlinux
sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged
消息持久化
将消息队列中的消息持久化到磁盘中, 但是它还是有可能丢失的, 当消息在消息队列中但是又没持久化到磁盘中时, RabbitMQ如果意外关闭了, 那么这个消息将丢失, 如果需要做到消息不丢失的话, 必须使用publisher confirms
boolean durable = true;
channel.queueDeclare("task_queue", durable, false, false, null);公平调度
RabbitMQ无法知道哪个消费者是否有空, 都会按照顺序交给消费者, 如果有一个消费者太过于忙碌, RabbitMQ也不知道, 照样会发布消息给那个消费者
解决方法:
int prefetchCount = 1;
channel.basicQos(prefetchCount);prefetchCount = 1, 调用basicQos方法这个消费者就会只拿出一个消息进行操作, 其他的消息它都拒绝掉, 拒绝的消息将被滞留带消息队列中, 但是这个消息将会丢给新的消费者新的问题:
所有的消费者都忙碌了, 那么生产者产生的消息一直滞留在消息队列中, 这样消息队列会出现更多的消息, 直达消息队列爆了
下面是第一阶段学习完成的最终代码:
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
public class NewTask {
private static final String TASK_QUEUE_NAME = "task_queue";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
try (Connection connection = factory.newConnection();
Channel channel = connection.createChannel()) {
channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
String message = String.join(" ", argv);
channel.basicPublish("", TASK_QUEUE_NAME,
MessageProperties.PERSISTENT_TEXT_PLAIN,
message.getBytes("UTF-8"));
System.out.println(" [x] Sent '" + message + "'");
}
}
}import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
public class Worker {
private static final String TASK_QUEUE_NAME = "task_queue";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
final Connection connection = factory.newConnection();
final Channel channel = connection.createChannel();
channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
channel.basicQos(1);
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println(" [x] Received '" + message + "'");
try {
doWork(message);
} finally {
System.out.println(" [x] Done");
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
};
channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback, consumerTag -> { });
}
private static void doWork(String task) {
for (char ch : task.toCharArray()) {
if (ch == '.') {
try {
Thread.sleep(1000);
} catch (InterruptedException _ignored) {
Thread.currentThread().interrupt();
}
}
}
}
}第一阶段学习完成了, 现阶段, 我们总结下:
1. 消息确认
RabbitMQ 存在消息确认机制, 防止消息轻易丢失, 详细过程是:
生产者标记生产的消息需要消费者ack(应答)的消息, 将消息体发送到消息队列中, 消费者收到消息后, 发现这个消息需要手动应答的消息后, 关闭自动消息应答, 将消息应答的权利交给程序员手动调用, 应答或者拒绝, 拒绝的话, 有两种情况, 一种是拒绝并将消息丢弃或者拒绝将消息重新放入消息队列中, 如果消费者在应答的时候突然崩溃, 则生产者不会讲该消息销毁掉, 而是重新进入消息队列中, 传达给其他消费者, 如果生产者突然崩了, 则需要靠持久化来解决
2. 消息的持久化
RabbitMQ为了防止消息在消息队列中丢失, 所以使用了, 消息持久化, 但是它不是实时持久化的, 有时间间隙还是容易丢失消息, 后面有解决方案
3. 公平调度原则
RabbitMQ为了防止一些消费者过于忙碌而另一些消费者过于空闲的情况, 引入了公平调度原则, 你忙着就不给你排任务了, 将任务丢给消息队列, 让闲着的人去那任务, 但是导致了新的问题, 就是消息队列中的消息一直滞留消息队列中, 导致消息队列过于庞大, 导致RabbitMQ崩溃, 解决方案引入新的消费者或者使用TTL
至于啥是TTL???
想打人, 又是专业又简约的单词.......................... 尽给我瞎整些专业名词...................
TTL === Time-To-Live and Expiration
人话就是: 给消息/队列加上寿命
1. 如何给消息加上TTL?
* 为消息添加TTL时间的方式有两种
* (1) 为添加进入队列的每个消息都加上TTL
* (2) 在消息即将公布的时候, 给消息添加上消息的ttl
(1) 为添加进入队列的每个消息都加上TTL
Map<String, Object> arg = new HashMap<>();
arg.put("x-message-ttl", 60000);
channel.queueDeclare(QUEUE, true, false, false, arg);
(2) 在消息即将公布的时候, 给消息添加上消息的ttl
AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("600000").build();
channel.basicPublish("my-exchange", QUEUE, properties, message.getBytes());
同一个消息在不同消息队列中是否会同时寿终正寝?
发送到多个队列中的同一个消息可能在不同的时刻消失, 一个消息队列中的消息死亡不会影响其他队列中的这个消息队列, TTL的时间单位是毫秒, 且这个参数的值不能是非负数的
如何修改TTL的时间?
linux:
rabbitmqctl set_policy TTL ".*" '{"message-ttl":60000}' --apply-to queueswindow:rabbitmqctl set_policy TTL ".*" "{""message-ttl"":60000}" --apply-to queues上面的命令将是 60 秒还可以使用
Map<String, Object> args = new HashMap<String, Object>();
args.put("x-message-ttl", 60000);
channel.queueDeclare("myqueue", false, false, false, args);临时修改60秒时间需要注意:
①如果这个时候, 队列被加上TTL时间, 则不影响原本处于队列的那个消息的TTL失效时间
②如果同时给队列和消息加上TTL时间时, 则选择TTL较小的那个
- 在消息即将公布的时候, 给消息添加上ttl时间
2. 如何给队列加上TTL?
(1) 给队列加上TTL的话, 只有队列在空闲或者消费者没有连接到队列的时候才会开始使用TTL的时间
(2) 使用x-expires和expires可以设置队列的TTL
(3) 单位是毫秒
(4) 具体使用的方法
linux:
rabbitmqctl set_policy expiry ".*" '{"expires":1800000}' --apply-to queueswindow:rabbitmqctl.bat set_policy expiry ".*" "{""expires"":1800000}" --apply-to queues也可以在消息队列声明的时候为队列加上TTLMap<String, Object> args = new HashMap<String, Object>();
args.put("x-expires", 1800000);
channel.queueDeclare("myqueue", false, false, false, args);// 为添加进入队列的每个消息都加上TTL
// Map<String, Object> arg = new HashMap<>();
// arg.put("x-message-ttl", 60000);
// 为队列添加TTL , 半个小时的时间
Map<String, Object> arg = new HashMap<>();
arg.put("x-expires", 1800000);
channel.queueDeclare(QUEUE, true, false, false, arg);
String message = "Hello World";
// 在消息即将公布的时候, 给消息添加上消息的ttl
AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("600000").build();
channel.basicPublish("my-exchange", QUEUE, properties, message.getBytes());
下面是我写的第一阶段的代码, 不包含TTL
package com.xuecheng.manage_cms.rabbit;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
/**
* @author zhengwei
* @version 1.0.0
* @date 2019/12/4 20:29
* @msg
**/
public class Producer01 {
private final static String QUEUE = "helloworld";
public static void main(String[] args) throws Exception {
Connection connection = null;
Channel channel = null;
try {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
connection = factory.newConnection();
channel = connection.createChannel();
channel.queueDeclare(QUEUE, true, false, false, null);
String message = "Hello World";
// 将生产者的通道设置为持久化状态
channel.basicPublish("", QUEUE, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
System.out.println("[x] Sent'" + message + "'");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (channel != null) {
channel.close();
}
if (connection != null) {
connection.close();
}
}
}
}
package com.xuecheng.manage_cms.rabbit;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/**
* @author zhengwei
* @version 1.0.0
* @date 2019/12/4 20:50
* @msg
**/
public class Consumer01 {
private static final String QUEUE = "helloworld";
public static void main(String[] args) throws Exception {
func1();
}
public static void func1() throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE, true, false, false, null);
channel.basicQos(1);
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println("receive message..." + message);
try {
doWork(message);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(" [x] Done");
// 应答
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
};
// 开启消费者的自动 Ack 功能
boolean autoAck = false;
channel.basicConsume(QUEUE, autoAck, deliverCallback, (consumerTag) -> {
System.out.println("consumerTag: " + consumerTag);
});
}
public static void doWork(String task) throws InterruptedException {
for (char ch : task.toCharArray()) {
if (ch == '.') {
Thread.sleep(1000);
}
}
}
public static void func() throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE, true, false, false, null);
DefaultConsumer consumer = new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
String exchange = envelope.getExchange();
String routingKey = envelope.getRoutingKey();
long deliveryTag = envelope.getDeliveryTag();
String msg = new String(body, "utf-8");
System.out.println("receive message..." + msg);
channel.basicAck(envelope.getDeliveryTag(), false);
//true if the rejected message should be requeued rather than discarded/dead-lettered
// 如果拒绝的方式是 true 则这个消息不被丢弃, false的话直接丢弃消息
channel.basicReject(envelope.getDeliveryTag(), true);
}
};
channel.basicConsume(QUEUE, true, consumer);
}
}
第二阶段学习
前言, 了解学习第二阶段的目标是什么???
上面第一阶段的学习, 我们最终创建并完成了, 将一个消息通过消息队列传递给另一个消费者, 接下来, 我们将学习的目标是, 将一个消息, 传递给多个消费者, 也就是传说中的消息的发布和订阅
1. 发布和订阅
1. Exchanges交换器
(1) rabbitMQ的生产者不知道自己发送的消息是否成功, 它将自己的消息发送到exchanges交换器上, 交换器负责接收生产者的所有消息, 然后由他分配消息将传递给哪个队列并创建管道发送给消费者
(2) 列出服务器上的所有交换器
sudo rabbitmqctl list_exchanges
exchanges和Queue之间使用routingKey进行路由选取哪个队列
(3) 发布命名交换器channel.basicPublish( "logs", "", null, message.getBytes());2. Temporary queues
是什么?
临时队列就是一个非持久的、独占的、自动删除的队列,
作用
获取当前最新的消息, 而不是包括旧的信息的消息
3. Bindings
(1) 用于交换机和队列之间的绑定
(2) 如何绑定:
channel.queueBind(queueName, "logs", "");(3) 查看先有的绑定
rabbitmqctl list_bindings
4. Putting it all together
public class EmitLog {
private static final String EXCHANGE_NAME = "logs";
public static void main(String[] args) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
Connection connection = null;
Channel channel = null;
try {
connection = factory.newConnection();
channel = connection.createChannel();
// 声明一个扇形交换机, 向所有的消费者发布消息
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
String message = "zhazha Hello World";
// 指定 logs(EXCHANGE_NAME) 交换器, 将消息发布出去
channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes(StandardCharsets.UTF_8));
} catch (Exception e) {
e.printStackTrace();
} finally {
if (channel != null) {
channel.close();
}
if (connection != null) {
connection.close();
}
}
}
}
public class ReceiveLogs {
private static final String EXCHANGE_NAME = "logs";
public static void main(String[] args) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
String queueName = channel.queueDeclare().getQueue();
channel.queueBind(queueName, EXCHANGE_NAME, "");
DeliverCallback deliverCallback = (consumerTag, message) -> {
System.out.println("message = " + new String(message.getBody(), StandardCharsets.UTF_8));
};
channel.basicConsume(queueName, true, deliverCallback, (consumerTag) -> {
});
}
}
路由选择
直接交换
1. 是什么?是一个算法, 消息发送到与其binding key与消息routing key完成匹配的队列
绑定键就是图中的orange, black, green, 直接交换就是图中的 direct 就是那个 X 核心: 关注routing key, 这个就是将消息传递到这个绑定键的东西多重绑定
一个绑定键可以和多个queue进行绑定
发出日志
emmmmmmmmmmmm
订阅
绑定键 == 路由键 + 某些操作
可以说绑定键 ≈ 路由键
总结
也就是说, 路由键相当于频道, 生产者就是新闻工作者, 消费者就是观众
public class EmitLogDirect {
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] args) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
String routingKey = "info";
String message = "zhazha";
channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes(StandardCharsets.UTF_8));
System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");
}
}
public class ReceiveLogsDirect {
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] args) throws IOException, TimeoutException {
String[] argv = new String[]{"info", "warning", "error"};
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
String queueName = channel.queueDeclare().getQueue();
for (String routingKey : argv) {
channel.queueBind(queueName, EXCHANGE_NAME, routingKey);
}
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
System.out.println(" [x] Received '" + delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
};
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
});
}
}
主题 -- Topics
1. 主题交换机
主题交换的 routing_key 不能随便命名, 可以是以quick.rabbit这种 "."的方式作为routing_key
且这个routing_key还能使用 * 和 # 进行配对, * 是匹配一个单词使用, # 表示一群单词和字符匹配
设置为“ quick.orange.rabbit”的路由键的消息将被传递到两个队列。 信息“ lazy.orange.elephant”也会发给他们两个。 另一方面，“ quick.orange.fox”只会出现在第一个队列中，而“ lazy.brown.fox”只出现在第二个队列中。 “ lazy.pink.rabbit”只会被传递到第二个队列一次，即使它匹配两个绑定。 “ quick.brown.fox”不符合任何装订，所以它会被丢弃。
其他不匹配的全部丢弃