RabbitMq介绍及实战

最新推荐文章于 2022-04-19 09:34:14 发布
置顶 最新推荐文章于 2022-04-19 09:34:14 发布
阅读量251 收藏 1
点赞数
分类专栏： Java 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41460198/article/details/105656611
版权

为什么使用消息队列

优点比较核心的有 3 个：解耦、异步、削峰。
缺点有以下几个：

  1. 系统可用性降低
    系统引入的外部依赖越多，越容易挂掉。
  2. 系统复杂度提高
    硬生生加个 MQ 进来，如何保证消息的传递及消费成功
  3. 一致性问题
    A 系统处理完了直接返回成功了，人都以为你这个请求就成功了；但是问题是，要是 BCD 三个系统那里，BD 两个系统写库成功了，结果 C 系统写库失败了，这数据就不一致了。

所以消息队列实际是一种非常复杂的架构，你引入它有很多好处，但是也得针对它带来的坏处做各种额外的技术方案和架构来规避掉。

如何保证高可用

RabbitMQ 的高可用性
RabbitMQ 有三种模式：单机模式、普通集群模式、镜像集群模式。
镜像集群模式（高可用性）可用集群搭建篇
这种模式，才是所谓的 RabbitMQ 的高可用模式。跟普通集群模式不一样的是，在镜像集群模式下，你创建的 queue，无论元数据还是 queue 里的消息都会存在于多个实例上，就是说，每个 RabbitMQ 节点都有这个 queue 的一个完整镜像，包含 queue 的全部数据的意思。然后每次你写消息到 queue 的时候，都会自动把消息同步到多个实例的 queue 上。

如何保证消息的传递和成功消费

，需要考虑：

  1. 消息发送确认机制

  2. 消费确认机制

  3. 消息的重新投递

  4. 消费幂等性, 等等

幂等性概念

来源http://www.javaxl.com/blog/articles/380

幂等性是什么？

我们可以借鉴数据库的乐观锁机制

比如我们执行一条更新库存的SQL语句

Update t_repository set count = count -1,version = version + 1 where
version = 1

Elasticsearch也是严格遵循幂等性概念，每次数据更新，version+1（博主博客前面有提到）

消费端-幂等性保障

在海量订单产生的业务高峰期，如何避免消息的重复消费问题？

消费实现幂等性，就意味着，我们的消息永远不会消费多次，即使我们收到了多条一样的消息

业界主流的幂等性操作

唯一ID+指纹码机制，利用数据库主键去重

利用Redis的原子性去实现

唯一ID+指纹码 机制

唯一ID+指纹码机制，利用数据库主键去重

Select count(1) from T_order where ID=唯一ID+指纹码

好处：实现简单

坏处：高并发下有数据库写入的性能瓶颈

解决方案：根据ID进行分库分表进行算法路由

利用Redis的原子性去实现

使用Redis进行幂等，需要考虑的问题

第一：我们是否要进行数据落库，如果落库的话，关键解决的问题是数据库和缓存如何做到原子性？

第二：如果不进行落库，那么都存储到缓存中，如何设置定时同步策略？

springboot+rabbitmq实战

目录结构
在这里插入图片描述

  1. rabbitmq搭建搭建篇
  2. springboot配置
spring:
    rabbitmq:
        addresses: 49.233.89.188::5672,49.233.89.188:5673,49.233.89.188:5674
        password: ''
        username: ''
        virtual-host: /
  1. config
/**
 * @Description: rabbitmq配置信息
 */
@Configuration
@Slf4j
@AllArgsConstructor
public class RabbitmqConfig {
    private final RedisService redisService;

    private final static Long EXPIRE_TIME_ONE_DAY = 60 * 60 * 24L;

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        //设置confirm模式 消息发送失败 记录redis重发
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            log.info("【mq应答:{},correlationData:{},cause:{}】",ack,correlationData,cause);
            if (ack){
                // 如果应答，说明消息已发送至server 将redis中的mq消息移除
                redisService.hmRemove(RedisConstants.MQ_SEND_QUEUE,correlationData.getId());
            }else{
                Object obj = redisService.hmGet(RedisConstants.MQ_SEND_QUEUE, correlationData.getId());
                if (obj != null){
                    MqMessage mqMessage = JSONObject.parseObject(obj.toString(),MqMessage.class);
                    if(mqMessage!=null){
                        mqMessage.setReSendCount(mqMessage.getReSendCount() + 1);
                        // 缓存队列1天
                        redisService.hmSet(RedisConstants.MQ_SEND_QUEUE, correlationData.getId().toString(), mqMessage,
                                EXPIRE_TIME_ONE_DAY);
                    }
                }
            }
        });
        // 同时设置，找不到exchange或者queue的时候回调
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            log.error("text:{},code:{},exchange:{},routingKey:{}",message,replyCode,replyText,routingKey);
        });
        return rabbitTemplate;
    }

    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMaxConcurrentConsumers(20);
        //自动应答模式
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        return factory;
    }

    /**
     * 人脸识别队列
     * @return  Queue
     **/
    @Bean
    public Queue faceIdentifyQueue(){
        Queue queue = new Queue(MqConstant.FACE_IDENTIFY_QUEUE);
        return queue;
    }
  }
  1. 拦截器
 */
@Component
@Aspect
@Slf4j
@AllArgsConstructor
public class MqRejectInterceptor {

    private final MqCommonCheckService mqCommonCheckService;
    private final SendMsgService sendMsgService;

    @Around(value = "execution(* com.xxx.xxx.rabbitmq.consumer.*.*(..)) && @annotation(rabbitListener)")
    public Object aroundService(ProceedingJoinPoint joinPoint, RabbitListener rabbitListener) throws Throwable {
        Object object = null;
        String classname = joinPoint.getTarget().getClass().getName();
        String method = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        log.info(classname + ":" + method);
        if (args.length == 3) {
            Message message = (Message) args[0];
            Channel channel = (Channel) args[1];
            MqMessage mqMessage = (MqMessage) args[2];
            String msg = JSON.toJSONString(mqMessage);
            log.info(classname + ":" + method + ";mqMessage=" + msg);
            //MqMessage mqMessage = JSONObject.parseObject(msg.toJSONString(),MqMessage.class);

            // 拒绝重复消费
            boolean checkFlag = mqCommonCheckService.receiveCheck(mqMessage, rabbitListener.queues()[0]);
            String queueName = rabbitListener.queues()[0];
            if (checkFlag) {
                log.info("消息已经处理了，queue={};msg:{}", queueName, msg);

                // 若消息已处理，告知Mq拒绝消费此消息
                channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
            } else {
                boolean resendCheck = mqCommonCheckService.resendCheck(mqMessage, channel, message);
                if(resendCheck){
                    try {
                        object = joinPoint.proceed();

                        // 已收到消息 需要告知MQ从队列中删除此消息
                        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
                    } catch (Exception ex) {
                        log.error("接收处理消息失败，classname={}, queue={};msg={}", classname, queueName,msg, ex);

                        // 消息消费失败 需要移除已处理的标识
                        mqCommonCheckService.removeReceiveCheck(mqMessage, rabbitListener.queues()[0]);

                        // 已收到消息 需要告知MQ从队列中删除此消息
                        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);

                        // 将处理失败的消息放入redis重发队列
                        sendMsgService.saveToResendQueue(mqMessage);
                        log.info("消息处理失败，重新放入重发队列：{}, method:{},;msg={}", classname, method, msg);
                    }
                }else{
                    // 重发次数上限 直接拒绝消费
                    channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
                }
            }
        } else {
            object = joinPoint.proceed();
        }
        return object;
    }
}
  1. 生产者
@Component
@AllArgsConstructor
public class FaceIdentifyProvide {
    private final SendMsgService sendMsgService;

    /**
     * 发送消息
     * @Param object
     * @return void
     **/
    public void sendMessage(Object object){
        sendMsgService.sendMsg(new MqMessage(MqConstant.DIRECT_EXCHANGE,MqConstant.FACE_IDENTIFY_KEY,object));
    }
}


 */
@Service
@AllArgsConstructor
@Slf4j
public class SendMsgServiceImpl implements SendMsgService {
    private final static Long EXPIRE_TIME_ONE_DAY = 60 * 60 * 24L;// 1day
    private final RedisService cache;
    private final RabbitTemplate rabbitTemplate;

    @Override
    public void sendMsg(MqMessage mqMessage) {
        //final JSONObject jsonMessage = (JSONObject) JSON.toJSON(mqMessage);
        final String exchangeName = mqMessage.getExchange();
        final String message = objToString(mqMessage);
        cache.hmSet(RedisConstants.MQ_SEND_QUEUE, mqMessage.getId().toString(), mqMessage,
                EXPIRE_TIME_ONE_DAY);// 缓存队列1天
        try {
            log.info("发送MQ：" + message);
            rabbitTemplate.convertAndSend(mqMessage.getExchange(), mqMessage.getRoutingKey(),
                    mqMessage, new CorrelationData(mqMessage.getId()));
        } catch (RuntimeException e) {
            log.error("发送MQ失败，exchangeName=" + exchangeName + ";message=" + message, e);
            saveToResendQueue(mqMessage);
            try {
                // retry
                rabbitTemplate.convertAndSend(mqMessage.getExchange(), mqMessage.getRoutingKey(),
                        mqMessage, new CorrelationData(mqMessage.getId()));
            } catch (RuntimeException ex) {
                log.error("发送MQ失败，exchangeName=" + exchangeName + ";message=" + message, ex);
                saveToResendQueue(mqMessage);
            }
        }
    }

    @Override
    public void saveToResendQueue(MqMessage mqMessage) {
        mqMessage.setReSendCount(mqMessage.getReSendCount() + 1);
        cache.hmSet(RedisConstants.MQ_SEND_QUEUE, mqMessage.getId().toString(), (JSONObject) JSON.toJSON(mqMessage),
                EXPIRE_TIME_ONE_DAY);// 缓存队列1天
    }

    private String objToString(Object obj) {
        if (obj == null) {
            return null;
        } else if (obj instanceof String) {
            return (String) obj;
        } else {
            return JSON.toJSONString(obj);
        }
    }


}
  1. 消费者
   * 消息接受  并发消费
     */
    @RabbitHandler
    @RabbitListener(queues = MqConstant.FACE_IDENTIFY_QUEUE)
    public void receive(Message message, Channel channel, MqMessage mqMessage) throws IOException {
        log.info("queueName:{}, message:{}" ,MqConstant.FACE_IDENTIFY_QUEUE, mqMessage);
        try{
            // 保存人脸识别日志
            BsIdentifyRecord bsIdentifyRecord = bsIdentifyRecordService.saveIdentifyRecord(mqMessage.getObj());
            // 考勤打卡
            pushAttendance(bsIdentifyRecord);
            // 记录部门负责人办公轨迹
            bsDeptHeadEventService.updateDeptHeadEventByIdentify(bsIdentifyRecord.getDeviceNo(), bsIdentifyRecord.getGuid());
        }catch (Exception e){
            log.error("人脸识别消费失败:",e);
        }

    }
xgc_java
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
rabbitmq学习+实战
07-03
rabbitmq学习+实战
Rabbitmq消息队列——NWU_LK
NWU_LK的博客
08-22 302
Rabbitmq消息队列 消息队列简介 消息队列（Message Queue）别名消息中间件，是经典的生产者消费者模型。生产者不断向消息队列发送消息，消费者从消息队列消费消息，因此消息的生产和消费都是异步的。 目前消息中间件主要的几种有：RabbitMQ、ActiveMQ、Kafka、RocketMQ等。 ActiveMQ Apache出品的产品，行业中最流行、能力最强的消息中间件，提供丰富的API，在中小型企业很受欢迎。缺点就是吞吐量小，性能相对较弱。 Kafka 高吞吐量，设计的初衷用在大数据中，但是
RabbitMQ-使用@RabbitListener注解消费消息
诚的博客
03-26 1万+
@RabbitListener注解指定目标方法来作为消费消息的方法，通过注解参数指定所监听的队列或者Binding。使用@RabbitListener可以设置一个自己明确默认值的RabbitListenerContainerFactory对象。 可以在配置文件中设置RabbitListenerAnnotationBeanPostProcessor并通过<rabbit:annotation-driven/>来设置@RabbitListener的执行，当然也可以通过@EnableRabbit注解来.
rabbitmq-管理控制台简介（一）
qq_35981356的博客
10-20 1633
转载自：https://www.jianshu.com/p/7b6e575fd451 1. 简介 rabbitmq-management是RabbitMq web管理端，用的是erlang的cowboy框架进行开发。web页面包括Overview(概述)、Connections(连接)、Channels(通道)、Exchanges(交换器)、Queues(队列)、Admin(用户管理)。 2. Overiview-概述 2.1 overview->totals ![在这里插入图片描述](https:
SpringBoot集成RabbitMq多rabbitTemplate管理,多SimpleRabbitListenerContainerFactory管理
weixin_44929059的博客
04-30 8343
SpringBoot集成RabbitMq多rabbitTemplate管理,多SimpleRabbitListenerContainerFactory管理 使用RabbitMq,发送消息确认,需要使用rabbitTemplate的ConfimCallback方法和ReturnCallback方法,网上大多配置为全局修改,如果需要对单个生产者进行配置,则需要将rabbitTemplate设置为多例,在需要单独配置的生产者使用@PostConstruct注解进行设置rabbitTemplate的ConfimC
【RabbitMQ】消息队列中间件学习之RabbitMQ（11）
小哲的博客
02-11 574
RabbitMQ高阶RabbitMQ存储机制1.1 队列的结构1.3 惰性队列内存及磁盘告警2.1 内存告警2.2 磁盘告警流控（Flow Control）3.1 流控的原理3.2 案例：打破队列的瓶颈镜像队列镜像队列的结构补充要点 RabbitMQ存储机制 持久化的消息在到达队列时就被写到磁盘，如果可以，则会在内存中保存一份备份以提高性能，当内存吃紧时会从内存中清除；非持久化消息一般只保存在内存中，内存吃紧时会保存到磁盘中以节省内存空间；两种消息类型都是在RabbitMQ的“持久层”中完成。 持久层是逻辑
springboot与rabbitmq结合的实战、实例项目
04-15
2. **RabbitMQ介绍** RabbitMQ是一个开源的消息代理和队列服务器，基于AMQP（Advanced Message Queuing Protocol）协议。它允许应用程序之间发送和接收消息，确保了消息的可靠传输，尤其适合处理高并发和低延迟的...
RabbitMQ实战视频.zip
03-19
在此，我精心录制的这一套视频教程将几乎手把手指导大家入门学习RabbitMQ并将所学的知识要点实战到实际的业务场景中，特别是在第二阶段的学习，将采用SpringBoot整合RabbitMQ的方式来实战实际的业务场景，并用来解决...
分布式事务之rabbitmq肉身实战
01-27
本篇文章主要探讨了三种分布式事务的解决方案，并结合RabbitMQ进行了实战讲解。 首先，文章提到了**二阶段事务（2PC）**，这是一种经典的分布式事务模型。2PC分为准备阶段和提交阶段。在准备阶段，协调者询问所有...
RabbitMQ实战资源
最新发布
11-13
**RabbitMQ实战资源详解** RabbitMQ是一种广泛使用的开源消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议实现，适用于多种编程语言，如Java、Python、Ruby、C#等。本资源集合包含了...
深入浅出消息队列---6、RabbitMQ高可用
u014526891的博客
04-19 9763
RabbitMQ高可用 Rabbitmq常见的部署模式：单机，普通集群，镜像集群 RabbitMQ普通集群 集群原理 这里先思考两个问题： 搭建集群的好处？ 提供整体消息队列服务的可靠性 可以通过水平扩容提高整体服务的吞吐量 有了集群以后是否可以保证消息不丢失？ 不可以 基于存储空间和性能的考虑，在Rabbitmq集群中创建队列，集群只会在单个节点而不是在所有节点上创建队列的进程并包含完整的队列消息（元数据，状态，内容）。 这样只有队列的宿主节点，即所有者节点知道队列的所有信息，所有其他非所
RabbitMQ 详解(五)------SpringBoot集成RabbitMQ
zhouhuahao的博客
03-02 234
1.基本概念 Spring AMQP 是对Spring 基于AMQP的消息收发解决方案，它是一个抽象层，不依赖于特定的 AMQP Broker 实现和客户端的抽象。 Sping封装RabbitMq的时候，主要做了两件事情：1.管理对象（队列、交换机、绑定）2.封装方法（发送消息、接收消息） <dependency> <groupId>org.springframework.amqp</groupId> <artifactId>spring-ra..
SpringBoot_消息_RabbitMQ
Running_lemon的博客
06-29 287
SpringBootRabbitMQ简介：核心概念:RabbitMQ运行机制：AMQP 中的消息路由：Exchange 类型：RabbitMQ整合： RabbitMQ简介： RabbitMQ是一个由erlang开发的AMQP(Advanved Message Queue Protocol) 的开源实现。 核心概念: 概念： 说明： Message-消息： 消息是不具名的，它由 消息头 和 消息体 组成；消息体是不透明的；消息头则由一系列的可选属性组成，这些属性包括routing-key（路由
RabbitMQ （二）工作队列
weixin_30396699的博客
07-10 340
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/37620057 本系列教程主要来自于官网入门教程的翻译，然后自己进行了部分的修改与实验，内容仅供参考。 上一篇博客中我们写了通过一个命名的队列发送和接收消息，如果你还不了解请点击：RabbitMQ 入门 Helloworld。这篇中我们将会创建一个工作队列用来在工作...
RabbitMQ监控（三）：监控队列状态
chimi5302的博客
05-04 3626
#RabbitMQ 监控（三） 　　验证RabbitMQ健康运行只是确保消息通信架构可靠性的一部分，同时，你也需要确保消息通信结构配置没有遭受意外修改，从而避免应用消息丢失。 　　 　　RabbitMQ Management HTTP API提供了一个方法允许你查看任何vhost上的任何队列：...
查看rabbitmq服务器消息,rabbitmqctl 服务状态查询
weixin_31748999的博客
07-31 8184
服务状态查询语句，用于询问服务，并将返回tab分隔的一组列项结果。一些查询语句(例如 list_queues, list_exchanges, list_bindings, list_consumers)接受一个可选的vhost参数。该参数(如果存在)，必须在查询之后立即指定。一、队列状态查询rabbitmqctl list_queues [-p vhost] [[--offline] | [--...
启动rabbitmq，提示ERROR: node with name "rabbit" already running on "U57..."
热门推荐
卖克的专栏
11-18 2万+
环境： erl7.2.1 rabbitmq_server-3.3.4 安装完毕后，访问localhost:15672，显示无法访问，本地启动是出现下面的提示 开始还以为是我配置的问题呢，找半天，在任务管理器中，看到了rabbitMQ的进程，它已经启动了。。。 结果很无语，把进程停止了，在再sbin命令，rabbitmq-server start，就一切好了
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值