RabbitMQ学习教程
MQ考察重点:
1、了解过哪些MQ?不同MQ之间有什么区别?
2、使用MQ的目的是什么?(削峰、异步和解耦)
2、RabbitMQ在项目里什么场景下使用的?以及如何使用的?
3、RabbitMQ的延迟队列、死信队列有了解和使用过吗?
4、如何保证消息的可靠性投递?
5、如何避免消息的重复消费?
6、MQ的集群私下里有搭建过吗?
参考文章:
https://file.xdclass.net/note/2021/rabbitmq/%E5%B0%8F%E6%BB%B4%E8%AF%BE%E5%A0%82-RabbitMQ%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0.html
一、MQ的应用场景
核心应用:
1、解耦:用户注册后直接将注册成功返回给前端,发送MQ去处理其它(发送优惠劵、验证合法性等)业务。
2、异步:邮件异步通知(解耦也相当于异步)。
3、削峰:某一个接口单位时间内的并发量过高,可以通过MQ慢慢消费(秒杀)。
其它应用:
1、两个服务或项目是跨语言或跨平台的,可以通过MQ来解决。
2、分布式事务(最终一致性)(只要保证数据最终是一致的即可,可以有时间上的延迟,也即牺牲时间换空间):MQ延迟+死信队列实现。
二、什么是JMS、AMQP、MQTT(引申)
1、JMS:(定义:由Sun公司早期提出的消息标准,是一个Java平台中关于面向消息中间件(MOM)的API,旨在为java应用提供统一的消息操作)->类似于JDBC数据库API连接规范,JMS相当于消息通信API规范(只不过只针对Java语言)
2、AMQP:(定义:在2003年时被提出,最早用于解决金融领不同平台之间的消息传递交互问题,是一种协议)->
(1)AMQP只是一种协议,不是从API层进行限定,而是直接定义网络交换的数据格式。这就使得只要实现了AMQP协议的生产/消费者那就是跨平台的,兼容JMS。
(2)意味着我们可以使用Java的AMQP的provider,同时使用一个python的consumer。
(3)AMQP就好比http,不关心实现的语言,只要大家都按照相应的数据格式去发送报文请求,不同语言的client均可以和不同语言的server链接。
3、MQTT:(定义:消息队列遥测传输)->
(1)计算性能不高的设备不能适应AMQP上的复杂操作,MQTT它是专门为小设备设计的。
(2)MQTT主要是是物联网(IOT)中大量的使用。
(3)简单用户名和密码、不支持安全连接、消息不透明。
三、不同消息队列之间的对别
业界主流的消息队列:Apache ActiveMQ、Kafka、RabbitMQ、RocketMQ
ActiveMQ:http://activemq.apache.org/
Apache出品,历史悠久,支持多种语言的客户端和协议,支持多种语言Java, .NET, C++ 等
基于JMS Provider的实现
缺点:吞吐量不高,多队列的时候性能下降,存在消息丢失的情况,比较少大规模使用
【主要:吞吐量不高、性能低、问题多 政府老项目用的多】
Kafka:http://kafka.apache.org/
是由Apache软件基金会开发的一个开源流处理平台,由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统,它可以处理大规模的网站中的所有动作流数据(网页浏览,搜索和其他用户的行动),副本集机制,实现数据冗余,保障数据尽量不丢失;支持多个生产者和消费者
类似MQ,功能较为简单,主要支持简单的MQ功能
缺点:不支持批量和广播消息,运维难度大,文档比较少, 需要掌握Scala
【主要:高吞吐量、海量数据处理、日志采集】
RocketMQ:http://rocketmq.apache.org/
阿里开源的一款的消息中间件, 纯Java开发,具有高吞吐量、高可用性、适合大规模分布式系统应用的特点, 性能强劲(零拷贝技术),支持海量堆积, 支持指定次数和时间间隔的失败消息重发,支持consumer端tag过滤、延迟消息等,在阿里内部进行大规模使用,适合在电商,互联网金融等领域
基于JMS Provider的实现
缺点:社区相对不活跃,更新比较快,纯java支持
【主要:背靠阿里、性能牛掰、稳定性高、支持业务上的消息重发和延迟消息,java开发 不跨平台的情况下首选!!!】
RabbitMQ:http://www.rabbitmq.com/
是一个开源的AMQP实现,服务器端用Erlang语言编写,支持多种客户端,如:Python、Ruby、.NET、Java、C、用于在分布式系统中存储转发消息,在易用性、扩展性、高可用性等方面表现不错
缺点:使用Erlang开发,阅读和修改源码难度大
【主要:重点 跨平台支持多种客户端、扩展性强、行走在业务层面的MQ,涉及到物联网项目常用】
四 、Docker安装RabbitMQ命令
1、原始安装命令:
docker run -d --name shop_rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 --restart=always rabbitmq:3.8.15-management
15672端口:客户端(网页)访问端口
5672端口:服务端通信端口
2、RabbitMQ-Stomp安装命令:
docker exec -it MQ容器id /bin/bash
#执行指令开启web stomp插件
rabbitmq-plugins enable rabbitmq_management rabbitmq_web_stomp rabbitmq_stomp rabbitmq_web_stomp_examples
#查看安装的插件
rabbitmq-plugins list
exit
#将开启了插件的容器提交为基础镜像供后续备用
docker commit 容器ID rabbitmq:stomp
#查看生成的新的镜像
docker images
#删除原来的容器
docker rm -f MQ容器id
docker run -d --name=shop_rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 -p 61613:61613 --restart=always rabbitmq:stomp
1、RabbitMQ整合stomp协议:https://www.cnblogs.com/freewsf/p/16493631.html
2、SpringBoot整合stomp协议:https://blog.csdn.net/qq_30285985/article/details/117822255
3、RabbitMQ访问地址:
http://152.136.126.29:15672/
五、RabbitMQ消息队列和核心概念介绍
说明:
1、部署一个MQ服务节点就是一个【Broker】。
2、一个【Broker】中可以有多个【Virtual host】虚拟主机:存在的目的是对不同“项目”之间的MQ应用隔离。
3、在一个【Virtual host】虚拟主机中包含
【生产者】、【消费者】:生产消息、消费消息。
【交换机】、【队列】:通过【BindingKey】(绑定key)进行绑定,【队列】才是存放消息的地方。
【RoutingKey】路由键:当BindingKey和RoutingKey相匹配时,消息会被打到对应的队列中。
【Connection】连接:是RabbitMQ的socket链接,一个连接上可以有多个channel进行通信。
【Channel】信道:一条支持多路复用的通道,独立的双向数据流通道,就是发布、订阅、接收消息的具体管道。
六、RabbitMQ的多种工作模式
-
对照官网回顾总结
- https://www.rabbitmq.com/getstarted.html
-
简单模式(生产者->队列->消费者)
- 一个生产、一个消费,不用指定交换机,【使用默认交换机】
//生产者 public class Send { private final static String QUEUE_NAME = "simple_queue"; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("10.211.55.13"); factory.setUsername("admin"); factory.setPassword("password"); factory.setVirtualHost("/dev"); factory.setPort(5672); try ( //JDK7语法 自动关闭 connnection和channel //创建连接 Connection connection = factory.newConnection(); //创建信道 Channel channel = connection.createChannel()) { /** * 队列名称 * 持久化配置:mq重启后还在 * 是否独占:只能有一个消费者监听队列;当connection关闭是否删除队列,一般是false,发布订阅是独占 * 自动删除: 当没有消费者的时候,自动删除掉,一般是false * 其他参数 * * 队列不存在则会自动创建,如果存在则不会覆盖,所以此时的时候需要注意属性 */ channel.queueDeclare(QUEUE_NAME, false, false, false, null); String message = "Hello World!"; /** * 参数说明: * 交换机名称:不写则是默认的交换机,那【路由健需要和队列名称一样才可以被路由】 * 路由健名称 * 配置信息 * 发送的消息数据:字节数组 */ channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8)); System.out.println(" [x] Sent '" + message + "'"); } } }
//消费者 public class Recv { private final static String QUEUE_NAME = "simple_queue"; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("10.211.55.13"); factory.setUsername("admin"); factory.setPassword("password"); factory.setVirtualHost("/xdclass1"); factory.setPort(5672); //消费者一般不增加自动关闭 Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); channel.queueDeclare(QUEUE_NAME, false, false, false, null); System.out.println(" [*] Waiting for messages. To exit press CTRL+C"); //回调方法,下面两种都行 Consumer consumer = new DefaultConsumer(channel){ @Override public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException { // consumerTag 是固定的 可以做此会话的名字, deliveryTag 每次接收消息+1 System.out.println("consumerTag消息标识="+consumerTag); //可以获取交换机,路由健等 System.out.println("envelope元数据="+envelope); System.out.println("properties配置信息="+properties); System.out.println("body="+new String(body,"utf-8")); } }; channel.basicConsume(QUEUE_NAME,true,consumer); // DeliverCallback deliverCallback = (consumerTag, envelop, delivery,properties, msg) -> { // String message = new String(msg, "UTF-8"); // System.out.println(" [x] Received '" + message + "'"); // }; //自动确认消息 //channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { }); } }
- 一个生产、一个消费,不用指定交换机,【使用默认交换机】
-
工作队列模式
- 一个生产,多个消费,可以有轮训和公平策略,不用指定交换机,【使用默认交换机】
//生产者 public class Send { private final static String QUEUE_NAME = "work_queue"; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("10.211.55.13"); factory.setUsername("admin"); factory.setPassword("password"); factory.setVirtualHost("/dev"); factory.setPort(5672); try ( //创建连接 Connection connection = factory.newConnection(); //创建信道 Channel channel = connection.createChannel()) { /** * 队列名称 * 持久化配置 * 排他配置 * 自动删除 * 其他参数 */ channel.queueDeclare(QUEUE_NAME, false, false, false, null); //轮训发送 10个 for(int i=0;i<10;i++){ String message = "Hello World!"+i; channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8)); System.out.println(" [x] Sent '" + message + "'"); } } } }
//消费者(可以再创建一个相同的类,模拟消费者2) public class Recv1 { private final static String QUEUE_NAME = "work_queue"; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("10.211.55.13"); factory.setUsername("admin"); factory.setPassword("password"); factory.setVirtualHost("/xdclass1"); factory.setPort(5672); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); channel.queueDeclare(QUEUE_NAME, false, false, false, null); System.out.println(" [*]Waiting for messages. To exit press CTRL+C"); DeliverCallback deliverCallback = (consumerTag, delivery) -> { //模拟消费缓慢 try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } String message = new String(delivery.getBody(), "UTF-8"); System.out.println("[x] Received '" + message + "'"); //手工确认消息消费,不是多条确认 channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); }; //关闭自动确认消息 channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { }); } }
- 一个生产,多个消费,可以有轮训和公平策略,不用指定交换机,【使用默认交换机】
-
发布订阅模式【不使用默认交换机,则根据交换机类型区分】
- fanout类型交换机,通过交换机和队列绑定,不用指定绑定的路由健,生产者发送消息到交换机,fanout交换机直接进行转发,消息不用指定routingkey路由健
//生产者 public class Send { private final static String EXCHANGE_NAME = "exchange_fanout"; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("10.211.55.13"); factory.setUsername("admin"); factory.setPassword("password"); factory.setVirtualHost("/dev"); factory.setPort(5672); /** * 消息生产者不用过多操作,只需要和交换机绑定即可 */ try ( //创建连接 Connection connection = factory.newConnection(); //创建信道 Channel channel = connection.createChannel()) { //绑定交换机,fanout扇形,即广播类型 channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.FANOUT); String message = "Hello World pub !"; channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes(StandardCharsets.UTF_8)); System.out.println(" [x] Sent '" + message + "'"); } } }
//消费端(两个节点) public class Recv1 { private final static String EXCHANGE_NAME = "exchange_fanout"; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("10.211.55.13"); factory.setUsername("admin"); factory.setPassword("password"); factory.setVirtualHost("/dev"); factory.setPort(5672); //消费者一般不增加自动关闭 Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); //绑定交换机,fanout扇形,即广播类型 channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.FANOUT); //获取队列(排它队列) String queueName = channel.queueDeclare().getQueue(); //绑定队列和交换机,fanout交换机不用指定routingkey channel.queueBind(queueName,EXCHANGE_NAME,""); DeliverCallback deliverCallback = (consumerTag, delivery) -> { String message = new String(delivery.getBody(), "UTF-8"); System.out.println(" [x] Received '" + message + "'"); }; //自动确认消息 channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { }); } }
- fanout类型交换机,通过交换机和队列绑定,不用指定绑定的路由健,生产者发送消息到交换机,fanout交换机直接进行转发,消息不用指定routingkey路由健
-
路由模式【不使用默认交换机,则根据交换机类型区分】
- direct类型交换机,通过交换机和队列绑定,指定【绑定的路由健】,生产者发送消息到交换机,交换机根据消息的【路由key】进行转发到对应的队列,消息要指定【routingkey路由健】
- 例子:日志采集系统 ELK
- 一个队列收集error信息-》告警
- 一个队列收集全部信息-》日常使用
public class Send { private final static String EXCHANGE_NAME = "exchange_direct"; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("10.211.55.13"); factory.setUsername("admin"); factory.setPassword("password"); factory.setVirtualHost("/xdclass1"); factory.setPort(5672); /** * 消息生产者不用过多操作,只需要和交换机绑定即可 */ try ( //创建连接 Connection connection = factory.newConnection(); //创建信道 Channel channel = connection.createChannel()) { //绑定交换机,直连交换机 channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT); String error = "我是错误日志"; String info = "我是info日志"; String debug = "我是debug日志"; channel.basicPublish(EXCHANGE_NAME, "errorRoutingKey", null, error.getBytes(StandardCharsets.UTF_8)); channel.basicPublish(EXCHANGE_NAME, "infoRoutingKey", null, info.getBytes(StandardCharsets.UTF_8)); channel.basicPublish(EXCHANGE_NAME, "debugRoutingKey", null, debug.getBytes(StandardCharsets.UTF_8)); System.out.println("消息发送成功"); } } }
//消息消费者(两个节点) public class Recv1 { private final static String EXCHANGE_NAME = "exchange_direct"; public static void main(String[] argv) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("10.211.55.13"); factory.setUsername("admin"); factory.setPassword("password"); factory.setVirtualHost("/xdclass1"); factory.setPort(5672); //消费者一般不增加自动关闭 Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); //绑定交换机,DIRECT类型 channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT); //获取队列 String queueName = channel.queueDeclare().getQueue(); //绑定队列和交换机,另外一个节点只绑定一个 errorRoutingKey channel.queueBind(queueName,EXCHANGE_NAME,"errorRoutingKey"); channel.queueBind(queueName,EXCHANGE_NAME,"infoRoutingKey"); channel.queueBind(queueName,EXCHANGE_NAME,"debugRoutingKey"); DeliverCallback deliverCallback = (consumerTag, delivery) -> { String message = new String(delivery.getBody(), "UTF-8"); System.out.println(" [x] Received '" + message + "'"); }; //自动确认消息 channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { }); } }
- direct类型交换机,通过交换机和队列绑定,指定【绑定的路由健】,生产者发送消息到交换机,交换机根据消息的【路由key】进行转发到对应的队列,消息要指定【routingkey路由健】
-
通配符模式【不使用默认交换机,则根据交换机类型区分】
- topic交换机,通过交换机和队列绑定,指定绑定的【通配符路由健】,生产者发送消息到交换机,交换机根据消息的路由key进行转发到对应的队列,消息要指定routingkey路由健
- 例子:日志采集系统
- 一个队列收集订单系统的error日志信息,order.log.error
- 一个队列收集全部系统的全部级别日志信息, * .log. *
public class Send {
private final static String EXCHANGE_NAME = "exchange_topic";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("10.211.55.13");
factory.setUsername("admin");
factory.setPassword("password");
factory.setVirtualHost("/dev");
factory.setPort(5672);
/**
* 消息生产者不用过多操作,只需要和交换机绑定即可
*/
try (
//创建连接
Connection connection = factory.newConnection();
//创建信道
Channel channel = connection.createChannel()) {
//绑定交换机,直连交换机
channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.TOPIC);
String error = "我是订单错误日志";
String info = "我是订单info日志";
String debug = "我是商品debug日志";
channel.basicPublish(EXCHANGE_NAME, "order.log.error", null, error.getBytes(StandardCharsets.UTF_8));
channel.basicPublish(EXCHANGE_NAME, "order.log.info", null, info.getBytes(StandardCharsets.UTF_8));
channel.basicPublish(EXCHANGE_NAME, "product.log.debug", null, debug.getBytes(StandardCharsets.UTF_8));
System.out.println("消息发送成功");
}
}
}
//消费者1
public class Recv1 {
private final static String EXCHANGE_NAME = "exchange_topic";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("10.211.55.13");
factory.setUsername("admin");
factory.setPassword("password");
factory.setVirtualHost("/dev");
factory.setPort(5672);
//消费者一般不增加自动关闭
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.TOPIC);
//获取队列
String queueName = channel.queueDeclare().getQueue();
//绑定队列和交换机,第一个节点
channel.queueBind(queueName,EXCHANGE_NAME,"order.log.error");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println(" [x] Received '" + message + "'");
};
//自动确认消息
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
}
}
//消费者2
public class Recv2 {
private final static String EXCHANGE_NAME = "exchange_topic";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("10.211.55.13");
factory.setUsername("admin");
factory.setPassword("password");
factory.setVirtualHost("/dev");
factory.setPort(5672);
//消费者一般不增加自动关闭
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
//绑定交换机
channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.TOPIC);
//获取队列
String queueName = channel.queueDeclare().getQueue();
//绑定队列和交换机,第二个节点
channel.queueBind(queueName,EXCHANGE_NAME,"*.log.*");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println(" [x] Received '" + message + "'");
};
//自动确认消息
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
}
}
七、SpringBoot2.X+SpringAMQP整合RabbitMQ实战【真实场景】
1、spring-boot-starter-amqp 依赖添加
<!--引入AMQP-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
2、yml配置文件修改
#消息队列
spring:
rabbitmq:
host: 10.211.55.13
port: 5672
virtual-host: /dev
password: password
username: admin
3、RabbitMQConfig文件
@Configuration
public class RabbitMQConfig {
public static final String EXCHANGE_NAME = "order_exchange";
public static final String QUEUE_NAME = "order_queue";
/**
* 交换机
* @return
*/
@Bean
public Exchange orderExchange() {
return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
//return new TopicExchange(EXCHANGE_NAME, true, false);
}
/**
* 队列
* @return
*/
@Bean
public Queue orderQueue() {
return QueueBuilder.durable(QUEUE_NAME).build();
//return new Queue(QUEUE_NAME, true, false, false, null);
}
/**
* 交换机和队列绑定关系
*/
@Bean
public Binding orderBinding(Queue queue, Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("order.#").noargs();
//return new Binding(QUEUE_NAME, Binding.DestinationType.QUEUE, EXCHANGE_NAME, "order.#", null);
}
}
4、消息生产者-测试类
@SpringBootTest
class DemoApplicationTests {
@Autowired
private RabbitTemplate template;
@Test
void send() {
template.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"order.new","新订单来啦1");
}
}
5、消息消费者
@Component
@RabbitListener(queues = "order_queue")
public class OrderMQListener {
/**
* RabbitHandler 会自动匹配 消息类型(消息自动确认)
* @param msg
* @param message
* @throws IOException
*/
@RabbitHandler
public void releaseCouponRecord(String msg, Message message) throws IOException {
long msgTag = message.getMessageProperties().getDeliveryTag();
System.out.println("msgTag="+msgTag);
System.out.println("message="+message.toString());
System.out.println("监听到消息:消息内容:"+message.getBody());
}
}