做网店的网站,杭州小型网站建设服务,万表网,在北京做网站seo多少钱1、为什么需要Mq
例如在用户注册业务中#xff0c;用户注册成功后
需要发注册邮件和注册短信#xff0c;传统的做法有两种
1.串行的方式#xff1b;2.并行的方式 #xff1b; 假设三个业务节点分别使用50ms#xff0c;串行方式使用时间150ms#xff0c;并行使用时间10…1、为什么需要Mq
例如在用户注册业务中用户注册成功后
需要发注册邮件和注册短信传统的做法有两种
1.串行的方式2.并行的方式 假设三个业务节点分别使用50ms串行方式使用时间150ms并行使用时间100ms。虽然并性已经提高的处理时间但是前面说过邮件和短信对我正常的使用网站没有任何影响客户端没有必要等着其发送完成才显示注册成功应该是写入数据库后就返回。 2、Mq的优缺点 优点
1、应用解耦 每个服务都可以灵活插拔可替换服务没有直接调用不存在级联失败问题
2、流量削峰不管发布事件的流量波动多大都由Broker接收订阅者可以按照自己的速度去处理事件
用户的请求服务器收到之后首先写入消息队列加入消息队列长度超过最大值则直接抛弃用户请求或跳转到错误页面。
秒杀业务根据消息队列中的请求信息再做后续处理
3、吞吐量提升无需等待订阅者处理完成响应更快速 缺点 架构复杂了业务没有明显的流程线不好管理 需要依赖于Broker的可靠、安全、性能
3、常用的Mq对比
ActiveMQ RabbitMQ RocketMQ Kafka
1、ActiveMQ性能不是很好因此在高并发的场景下直接被pass掉了。它的Api很完善在中小型互联网公司可以去使用。 2、kafka主要强调高性能如果对业务需要可靠性消息的投递的时候。那么就不能够选择kafka了。但是如果做一些日志收集呢kafka还是很好的。因为kafka的性能是十分好的。 3、RocketMQ它的特点非常好。它高性能、满足可靠性、分布式事物、支持水平扩展、上亿级别的消息堆积、主从之间的切换等等。MQ的所有优点它基本都满足。但是它最大的缺点商业版收费。因此它有许多功能是不对外提供的。
4、RabbitMQ安装
mac 可参考Mac RabbitMQ安装_mac安装rabbitmq-CSDN博客
其他版本也可搜索后按步骤安装或者使用docker镜像安装 5、基础概念 RabbitMQ中的一些角色
publisher生产者consumer消费者exchange个交换机负责消息路由queue队列存储消息virtualHost虚拟主机隔离不同租户的exchange、queue、消息的隔离
生产者发送消息流程 1、生产者和Broker建立TCP连接。 2、生产者和Broker建立通道。 3、生产者通过通道消息发送给Broker由Exchange将消息进行转发。 4、Exchange将消息转发到指定的Queue队列
消费者接收消息流程 1、消费者和Broker建立TCP连接 2、消费者和Broker建立通道 3、消费者监听指定的Queue队列 4、当有消息到达Queue时Broker默认将消息推送给消费者。 5、消费者接收到消息。 6、ack回复
6、代码实现
官方的API实现消息接收和发送比较繁琐SpringAMQP则是基于RabbitMQ封装的一套模板并且利用SpringBoot对其实现了自动装配使用起来非常方便。
1、导入依赖发送方和接收方都导入
!--AMQP依赖包含RabbitMQ--
dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-amqp/artifactId
/dependency2、配置MQ地址在publisher和consumer服务的application.yml中添加配置
spring:rabbitmq:host: 192.168.150.101 # 主机名port: 5672 # 端口virtual-host: / # 虚拟主机username: itcast # 用户名password: 123321 # 密码3、发送方使用RabbitTemplate发送 消息
package cn.itcast.mq.spring;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;RunWith(SpringRunner.class)
SpringBootTest
public class SpringAmqpTest {Autowiredprivate RabbitTemplate rabbitTemplate;Testpublic void testSimpleQueue() {// 队列名称String queueName simple.queue;// 消息String message hello, spring amqp!;// 发送消息rabbitTemplate.convertAndSend(queueName, message);}
}4、接收方使用RabbitListener注解接收消息
package cn.itcast.mq.listener;import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;Component
public class SpringRabbitListener {// 表明需要监听的队列名称可自动装配下述参数msgRabbitListener(queues simple.queue)public void listenSimpleQueueMessage(String msg) throws InterruptedException {System.out.println(spring 消费者接收到消息【 msg 】);}
}说明消息一旦被消费就会从队列中删除(只能读取一次)RabbitMQ没有消息回溯功能。 7、WorkQueue工作队列
Work queues任务模型。简单来说就是让多个消费者绑定到一个队列共同消费队列中的消息提高处理速度。
我们已经知道消息读取后即会从队列中删除当消息处理比较耗时的时候可能生产消息的速度会远远大于消息的消费速度。长此以往消息就会堆积越来越多无法及时处理。
此时就可以使用work 模型多个消费者共同处理消息处理速度就能大大提高了。
/*** workQueue* 向队列中不停发送消息模拟消息堆积。*/
Test
public void testWorkQueue() throws InterruptedException {// 队列名称String queueName simple.queue;// 消息String message hello, message_;for (int i 0; i 50; i) {// 发送消息rabbitTemplate.convertAndSend(queueName, message i);// 控制1s发送50条消息Thread.sleep(20);}
}// 两个消费者绑定到同一个队列
RabbitListener(queues simple.queue)
public void listenWorkQueue1(String msg) throws InterruptedException {System.out.println(消费者1接收到消息【 msg 】 LocalTime.now());// 模拟不同消费者处理能力差异Thread.sleep(20);
}// 两个消费者绑定到同一个队列
RabbitListener(queues simple.queue)
public void listenWorkQueue2(String msg) throws InterruptedException {System.err.println(消费者2........接收到消息【 msg 】 LocalTime.now());// 模拟不同消费者处理能力差异Thread.sleep(200);
}默认情况下消息会被平均分配给了每个消费者并没有考虑到消费者的处理能力
由于RabbitMQ采取的是消息预取机制当有消息发送过来时会将消息都投递给消费者。
我们可以修改consumer服务的application.yml文件设置preFetch参数控制预取消息的上限
spring:rabbitmq:listener:simple:prefetch: 1 # 每次只能获取一条消息处理完成才能获取下一个消息8、发布订阅模式
发布订阅模式与之前案例的区别就是允许将同一消息发送给多个消费者。 可以看到在订阅模型中多了一个exchange角色而且过程略有变化 Publisher生产者也就是要发送消息的程序但是不再发送到队列中而是发给交换机 Exchange交换机。一方面接收生产者发送的消息。另一方面知道如何处理消息例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作取决于Exchange的类型。Exchange有以下3种类型 Fanout广播将消息交给所有绑定到交换机的队列 Direct定向把消息交给符合指定routing key 的队列 Topic通配符把消息交给符合routing pattern路由模式 的队列 Consumer消费者与以前一样订阅队列没有变化 Queue消息队列也与以前一样接收消息、缓存消息。
Exchange交换机只负责转发消息不具备存储消息的能力因此如果没有任何队列与Exchange绑定或者没有符合路由规则的队列那么消息会丢失
1、Fanout广播
在广播模式下消息发送流程是这样的
可以有多个队列每个队列都要绑定到Exchange交换机生产者发送的消息只能发送到交换机交换机来决定要发给哪个队列生产者无法决定交换机把消息发送给绑定过的所有队列订阅队列的消费者都能拿到消息
声明2个交换机和队列然后绑定
package cn.itcast.mq.config;import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;Configuration
public class FanoutConfig {/*** 声明交换机* return Fanout类型交换机*/Beanpublic FanoutExchange fanoutExchange(){return new FanoutExchange(itcast.fanout);}/*** 第1个队列*/Beanpublic Queue fanoutQueue1(){return new Queue(fanout.queue1);}/*** 绑定队列和交换机* 注意参数名fanoutQueue1spring会自动装配*/Beanpublic Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);}/*** 第2个队列*/Beanpublic Queue fanoutQueue2(){return new Queue(fanout.queue2);}/*** 绑定队列和交换机* 注意参数名fanoutQueue2spring会自动装配*/Beanpublic Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);}
}发送方指明交换机
Test
public void testFanoutExchange() {// 队列名称String exchangeName itcast.fanout;// 消息String message hello, everyone!;// 中间参数后期有用暂时不用写rabbitTemplate.convertAndSend(exchangeName, , message);
}接收方
// 绑定队列
RabbitListener(queues fanout.queue1)
public void listenFanoutQueue1(String msg) {System.out.println(消费者1接收到Fanout消息【 msg 】);
}// 绑定队列
RabbitListener(queues fanout.queue2)
public void listenFanoutQueue2(String msg) {System.out.println(消费者2接收到Fanout消息【 msg 】);
}2、Direct路由
在Fanout模式中一条消息会被所有订阅的队列都消费。但是在某些场景下我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。 在Direct模型下 队列与交换机的绑定不能是任意绑定了而是要指定一个RoutingKey路由key 消息的发送方在向 Exchange发送消息时也必须指定消息的 RoutingKey。 Exchange不再把消息交给每一个绑定的队列而是根据消息的Routing Key进行判断只有队列的Routingkey与消息的 Routing key完全一致才会接收到消息
消息发送方指明交换机和routing key
Test
public void testSendDirectExchange() {// 交换机名称String exchangeName itcast.direct;// 消息String message hello red;// 发送消息通过中间参数指定key值rabbitTemplate.convertAndSend(exchangeName, red, message);
}基于Bean的方式声明队列和交换机比较麻烦需要声明多个Spring还提供了基于注解方式来声明。
在consumer的SpringRabbitListener中添加两个消费者同时基于注解来声明队列和交换机
RabbitListener(bindings QueueBinding(value Queue(name direct.queue1),exchange Exchange(name itcast.direct, type ExchangeTypes.DIRECT),key {red, blue}
))
public void listenDirectQueue1(String msg){System.out.println(消费者接收到direct.queue1的消息【 msg 】);
}RabbitListener(bindings QueueBinding(value Queue(name direct.queue2),exchange Exchange(name itcast.direct, type ExchangeTypes.DIRECT),key {red, yellow}
))
public void listenDirectQueue2(String msg){System.out.println(消费者接收到direct.queue2的消息【 msg 】);
}bindings QueueBinding():声明并绑定关系value Queue():队列名称exchange Exchange():交换机名称发布订阅模式key {}:指定路由key
只有绑定了对应key的才能接收到消息
3、Topic主题
Topic类型的Exchange与Direct相比都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符
Routingkey 一般都是有一个或多个单词组成多个单词之间以”.”分割例如 item.insert
通配符规则
#匹配一个或多个词
*匹配不多不少恰好1个词
举例
china.#能够匹配china.spu.nb 或者 item.spu
china.*只能匹配china.spu 发送方
/*** topicExchange*/
Test
public void testSendTopicExchange() {// 交换机名称String exchangeName itcast.topic;// 消息String message 喜报孙悟空大战哥斯拉胜!;// 发送消息rabbitTemplate.convertAndSend(exchangeName, china.news, message);
}接收方
RabbitListener(bindings QueueBinding(value Queue(name topic.queue1),exchange Exchange(name itcast.topic, type ExchangeTypes.TOPIC),key china.#
))
public void listenTopicQueue1(String msg){System.out.println(消费者接收到topic.queue1的消息【 msg 】);
}RabbitListener(bindings QueueBinding(value Queue(name topic.queue2),exchange Exchange(name itcast.topic, type ExchangeTypes.TOPIC),key #.news
))
public void listenTopicQueue2(String msg){System.out.println(消费者接收到topic.queue2的消息【 msg 】);
}9、消息转换器
在SpringAMQP的发送消息中发送接收消息的类型是Object,也就是说我们可以发送任意对象类型的消息SpringAMQP会帮我们序列化为字节后发送接收消息的时候还会把字节反序列化为Java对象。
默认情况下Spring采用的序列化方式是JDK序列化
JDK序列化存在下列问题
数据体积过大有安全漏洞可读性差
可以使用JSON方式来做序列化和反序列化
引入jackson依赖
dependencygroupIdcom.fasterxml.jackson.dataformat/groupIdartifactIdjackson-dataformat-xml/artifactIdversion2.9.10/version
/dependency在配置类或启动类中声明一个序列化转换类
Bean
public MessageConverter jsonMessageConverter(){return new Jackson2JsonMessageConverter();
}10、消息确认
就是发送方确认消息发送成功接收方接收成功后可以执行回调函数
配置文件开启回调
rabbitmq:host: 127.0.0.1port: 5672username: rootpassword: root#虚拟host 可以不设置,使用server默认hostvirtual-host: JCcccHost#消息确认配置项#确认消息已发送到交换机(Exchange)publisher-confirms: true#确认消息已发送到队列(Queue)publisher-returns: true设置回调函数
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;Configuration
public class RabbitConfig {Beanpublic RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory){RabbitTemplate rabbitTemplate new RabbitTemplate();rabbitTemplate.setConnectionFactory(connectionFactory);//设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数rabbitTemplate.setMandatory(true);rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {Overridepublic void confirm(CorrelationData correlationData, boolean ack, String cause) {System.out.println(ConfirmCallback: 相关数据correlationData);System.out.println(ConfirmCallback: 确认情况ack);System.out.println(ConfirmCallback: 原因cause);}});rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {Overridepublic void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {System.out.println(ReturnCallback: 消息message);System.out.println(ReturnCallback: 回应码replyCode);System.out.println(ReturnCallback: 回应信息replyText);System.out.println(ReturnCallback: 交换机exchange);System.out.println(ReturnCallback: 路由键routingKey);}});return rabbitTemplate;}
}消费方消息确认
和生产者的消息确认机制不同因为消息接收本来就是在监听消息符合条件的消息就会消费下来。
所以消息接收的确认机制主要存在三种模式 1、自动确认 这也是默认的消息确认情况。 AcknowledgeMode.NONE RabbitMQ成功将消息发出即将消息成功写入TCP Socket中立即认为本次投递已经被正确处理不管消费者端是否成功处理本次投递。 所以这种情况如果消费端消费逻辑抛出异常也就是消费端没有处理成功这条消息那么就相当于丢失了消息。 一般这种情况我们都是使用try catch捕捉异常后打印日志用于追踪数据这样找出对应数据再做后续处理。
2、根据情况确认 这个不做介绍
3、手动确认 这个比较关键也是我们配置接收消息确认机制时多数选择的模式。 消费者收到消息后手动调用basic.ack/basic.nack/basic.reject后RabbitMQ收到这些消息后才认为本次投递成功。 basic.ack用于肯定确认 basic.nack用于否定确认注意这是AMQP 0-9-1的RabbitMQ扩展 basic.reject用于否定确认但与basic.nack相比有一个限制一次只能拒绝单条消息
消费者端以上的3个方法都表示消息已经被正确投递但是basic.ack表示消息已经被正确处理。 而basic.nack,basic.reject表示没有被正确处理
着重讲下reject因为有时候一些场景是需要重新入列的。
channel.basicReject(deliveryTag, true); 拒绝消费当前消息如果第二参数传入true就是将数据重新丢回队列里那么下次还会消费这消息。设置false就是告诉服务器我已经知道这条消息数据了因为一些原因拒绝它而且服务器把这个消息丢掉就行下次不想再消费这条消息了。
使用拒绝后重新入列这个确认模式要谨慎因为一般都是出现异常的时候catch异常再拒绝入列选择是否重入列。
但是如果使用不当会导致一些每次都被你重入列的消息一直消费-入列-消费-入列这样循环会导致消息积压。
nack这个也是相当于设置不消费某条消息。
channel.basicNack(deliveryTag, false, true);
第一个参数依然是当前消息到的数据的唯一id; 第二个参数是指是否针对多条消息如果是true也就是说一次性针对当前通道的消息的tagID小于当前这条消息的都拒绝确认。 第三个参数是指是否重新入列也就是指不确认的消息是否重新丢回到队列里面去。
同样使用不确认后重新入列这个确认模式要谨慎因为这里也可能因为考虑不周出现消息一直被重新丢回去的情况导致积压。 import com.elegant.rabbitmqconsumer.receiver.MyAckReceiver;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;Configuration
public class MessageListenerConfig {Autowiredprivate CachingConnectionFactory connectionFactory;Autowiredprivate MyAckReceiver myAckReceiver;//消息接收处理类Beanpublic SimpleMessageListenerContainer simpleMessageListenerContainer() {SimpleMessageListenerContainer container new SimpleMessageListenerContainer(connectionFactory);container.setConcurrentConsumers(1);container.setMaxConcurrentConsumers(1);// RabbitMQ默认是自动确认这里改为手动确认消息container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置一个队列container.setQueueNames(TestDirectQueue);//如果同时设置多个如下 前提是队列都是必须已经创建存在的// container.setQueueNames(TestDirectQueue,TestDirectQueue2,TestDirectQueue3);//另一种设置队列的方法,如果使用这种情况,那么要设置多个,就使用addQueues//container.setQueues(new Queue(TestDirectQueue,true));//container.addQueues(new Queue(TestDirectQueue2,true));//container.addQueues(new Queue(TestDirectQueue3,true));container.setMessageListener(myAckReceiver);return container;}
}import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;Componentpublic class MyAckReceiver implements ChannelAwareMessageListener {Overridepublic void onMessage(Message message, Channel channel) throws Exception {long deliveryTag message.getMessageProperties().getDeliveryTag();try {//因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理String msg message.toString();String[] msgArray msg.split();//可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据MapString, String msgMap mapStringToMap(msgArray[1].trim(),3);String messageIdmsgMap.get(messageId);String messageDatamsgMap.get(messageData);String createTimemsgMap.get(createTime);System.out.println( MyAckReceiver messageId:messageId messageData:messageData createTime:createTime);System.out.println(消费的主题消息来自message.getMessageProperties().getConsumerQueue());channel.basicAck(deliveryTag, true); //第二个参数手动确认可以被批处理当该参数为 true 时则可以一次性确认 delivery_tag 小于等于传入值的所有消息
// channel.basicReject(deliveryTag, true);//第二个参数true会重新放回队列所以需要自己根据业务逻辑判断什么时候使用拒绝} catch (Exception e) {channel.basicReject(deliveryTag, false);e.printStackTrace();}}//{keyvalue,keyvalue,keyvalue} 格式转换成mapprivate MapString, String mapStringToMap(String str,int entryNum ) {str str.substring(1, str.length() - 1);String[] strs str.split(,,entryNum);MapString, String map new HashMapString, String();for (String string : strs) {String key string.split()[0].trim();String value string.split()[1];map.put(key, value);}return map;}
}RabbitMQ详解用心看完这一篇就够了【重点】-CSDN博客
【微服务】RabbitMQSpringAMQP消息队列_springamqp rabbitmq实现动态发送指定人-CSDN博客
