您现在的位置是:首页 > 正文

RabbitMQ之消息模式1

2024-01-30 21:03:48阅读 0

1、消息如何保证100%的投递?

第一步:保障消息的成功发出
第二步:保障MQ节点的成功接收
第三步:发送端收到MQ节点(Broker)确认应答
第四步:完善的消息进行补偿机制

BAT/TMD互联网大厂的解决方案:

方法一:消息落库,对消息状态进行打标
方法二:消息的延迟投递,做二次确认,回调检查

在这里插入图片描述
流程步骤:
第1步:将订单入库,创建一条MSG(状态为0) 入MSG DB库
第2步:将消息发出去
第3步:监听消息应答(来自Broker)
第4步:修改消息的状态为1(成功)
第5步:分布式定时任务抓取状态为0的消息
第6步:将状态为0的消息重发
第7步:如果尝试了3次(可按实际情况修改)以上则将状态置为2(消息投递失败状态)

在这里插入图片描述

第1步:首先业务数据落库,成功才后第一次消息发送
第2步:紧着着发送第2条消息(可以用于寻找第1条消息),用于延迟(可能 2,3分钟后才发送)消息投递检查
第3步:Broker端收到消息后,消费端进行消息处理
第4步:处理成功后,发送confirm消息
第5步:收到confirm消息后,将消息进行持久化存储
第6步:收到了delay消息,检查DB数据库,若对应的第1条消息已处理完成,则不做任何事情;若收到了delay消息,检查DB数据库,发现对应的第 1条消息处理失败(或无记录),则发送重传命令到上游服务,循环第1步

2、幂等性概念

幂等性是什么?

1.我们可以借鉴数据库的乐观锁机制
2.比如我们执行一条更新库存的SQL语句
3.Update t_repository set count = count -1,version = version + 1 where version = 1
4.Elasticsearch也是严格遵循幂等性概念,每次数据更新,version+1(博主博客前面有提到)

消费端-幂等性保障

在海量订单产生的业务高峰期,如何避免消息的重复消费问题?
消费实现幂等性,就意味着,我们的消息永远不会消费多次,即使我们收到了多条一样的消息

业界主流的幂等性操作

唯一ID+指纹码机制,利用数据库主键去重
利用Redis的原子性去实现

唯一ID+指纹码 机制
唯一ID+指纹码机制,利用数据库主键去重
Select count(1) from T_order where ID=唯一ID+指纹码
好处:实现简单
坏处:高并发下有数据库写入的性能瓶颈
解决方案:根据ID进行分库分表进行算法路由

利用Redis的原子性去实现

使用Redis进行幂等,需要考虑的问题
第一:我们是否要进行数据落库,如果落库的话,关键解决的问题是数据库和缓存如何做到原子性?
第二:如果不进行落库,那么都存储到缓存中,如何设置定时同步策略?

3、Confirm确认消息

理解Confirm消息确认机制

消息的确认,是指生产者投递消息后,如果Broker收到消息,则会给我们生产者 一个应答。
生产者进行接收应答,用来确定这条消息是否正常的发送到Broker,这种方式也是消息的可靠性投递的核心保障
在这里插入图片描述

如何实现Confirm确认消息?

第一步:在Channel上开启确认模式:channel.confirmSelect()
第二步:在channel上添加监听:addConfirmListener,监听成功和失败的返回结果,根据具体的结果对消息进行重新发送、或记录日志等后续处理!
生产端代码:

package com.wr.rabbitmqapi.confirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;

public class Producer {
    public static void main(String[] args) throws Exception {
        //1 创建ConnectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.180.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2 获取C    onnection
        Connection connection = connectionFactory.newConnection();

        //3 通过Connection创建一个新的Channel
        Channel channel = connection.createChannel();


        //4 指定我们的消息投递模式: 消息的确认模式
        channel.confirmSelect();

        String exchangeName = "test_confirm_exchange";
        String routingKey = "confirm.save1";

        //5 发送一条消息
        String msg = "Hello RabbitMQ Send confirm message!";
        channel.basicPublish(exchangeName, routingKey, null, msg.getBytes());

        //6 添加一个确认监听
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.err.println("-------no ack!-----------");
            }

            @Override
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.err.println("--支付微服务接收了---ack!-----------");
            }
        });
    }
}

消费端代码:

package com.wr.rabbitmqapi.confirm;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;


public class Consumer {
    public static void main(String[] args) throws Exception {
        //1 创建ConnectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.180.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        //2 获取C    onnection
        Connection connection = connectionFactory.newConnection();

        //3 通过Connection创建一个新的Channel
        Channel channel = connection.createChannel();

        String exchangeName = "test_confirm_exchange";
        String routingKey = "confirm.#";
        String queueName = "test_confirm_queue";

        //4 声明交换机和队列 然后进行绑定设置, 最后制定路由Key
        channel.exchangeDeclare(exchangeName, "topic", true);
        channel.queueDeclare(queueName, true, false, false, null);
        channel.queueBind(queueName, exchangeName, routingKey);

        //5 创建消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        channel.basicConsume(queueName, true, queueingConsumer);

        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());

            System.err.println("消费端: " + msg);
        }


    }
}

最后启动消费者,然后再启动生产者,效果如下:
生产者投递消息后,Broker收到消息,就给生产者 一个应答。(这个也就是监听成功返回的结果)
在这里插入图片描述
生产者给消费者发出的消息
在这里插入图片描述

4、Return返回消息

Return Listener用于处理一些不可路由的消息!

正常情况:我们的消息生产者,通过指定一个Exchange和RoutingKey,把消息送达到某一个队列中去,然后我们的消费者监听队列,进行消费处理操作!
异常情况:在某些情况下,如果我们在发送消息的时候,当前的Exchange不存在或者指定的路由key路由不到,这个时候如果我们需要监听这种不可达的消息,就需要使用Return Listener!

在基础API中有一个关键的配置项
Mandatory:如果为true,则监听器会接收到路由不可达的消息,然后进行后续处理,如果为false,那么Broker端自动删除该消息!
在这里插入图片描述
消费者代码:

package com.wr.rabbitmqapi.returnlistener;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

public class Consumer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.180.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "test_return_exchange";
        String routingKey = "return.#";
        String queueName = "test_return_queue";

        channel.exchangeDeclare(exchangeName, "topic", true, false, null);
        channel.queueDeclare(queueName, true, false, false, null);
        channel.queueBind(queueName, exchangeName, routingKey);

        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);

        channel.basicConsume(queueName, true, queueingConsumer);

        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.err.println("消费者: " + msg);
        }

    }
}

生产者代码:

package com.wr.rabbitmqapi.returnlistener;

import com.rabbitmq.client.*;

import java.io.IOException;


public class Producer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.180.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exchange = "test_return_exchange";
        //一个正确的routingkey
        String routingKey = "return.save";
        //一个错误的routingkey
        String routingKeyError = "abc.save";

        String msg = "Hello RabbitMQ Return Message";


        channel.addReturnListener(new ReturnListener() {
            @Override
            public void handleReturn(int replyCode, String replyText, String exchange,
                                     String routingKey, AMQP.BasicProperties properties, byte[] body) throws IOException {

                System.err.println("---------handle  return----------");
                System.err.println("replyCode: " + replyCode);
                System.err.println("replyText: " + replyText);
                System.err.println("exchange: " + exchange);
                System.err.println("routingKey: " + routingKey);
                System.err.println("properties: " + properties);
                System.err.println("body: " + new String(body));
            }
        });

        //消息投递成功,会被消费者所消费
//        channel.basicPublish(exchange, routingKey, true, null, msg.getBytes());
        //消息不可达,将触发ReturnListener
         channel.basicPublish(exchange, routingKeyError, true, null, msg.getBytes());
    }
}

先启动消费者,再启动生产者
消费者的routingkey规则是String routingKey = "return.#";
如果生产端是正确的routingkey: String routingKey = "return.save";,执行结果如下:
消费者可以接受到生产者的消息
在这里插入图片描述
在这里插入图片描述
如果生产端是错误的routingkey: String routingKeyError = "abc.save";,执行结果如下:
消费端接收不到生产端发送的消息
在这里插入图片描述
生产端返回的异常
在这里插入图片描述

5、自定义消费者

我们一般就是在代码中编写while循环,进行consumer.nextDelivery方法进行获取下一条消息,然后进行消费处理!
但是我们使用自定义的Consumer更加的方便,解耦性更加的强,也是实际工作中最常用的使用方式!

自定义消费端代码:

package com.wr.rabbitmqapi.consumer;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;


public class MyConsumer extends DefaultConsumer {


    public MyConsumer(Channel channel) {
        super(channel);
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.err.println("-----------consume message----------");
        System.err.println("consumerTag: " + consumerTag);
        System.err.println("envelope: " + envelope);
        System.err.println("properties: " + properties);
        System.err.println("body: " + new String(body));
    }
}

消费端调用:

package com.wr.rabbitmqapi.consumer;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Consumer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.180.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();


        String exchangeName = "test_consumer_exchange";
        String routingKey = "consumer.#";
        String queueName = "test_consumer_queue";

        channel.exchangeDeclare(exchangeName, "topic", true, false, null);
        channel.queueDeclare(queueName, true, false, false, null);
        channel.queueBind(queueName, exchangeName, routingKey);

        channel.basicConsume(queueName, true, new MyConsumer(channel));


    }
}

生产端调用:

package com.wr.rabbitmqapi.consumer;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;


public class Producer {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.180.133");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

        String exchange = "test_consumer_exchange";
        String routingKey = "consumer.save";

        String msg = "Hello RabbitMQ Consumer Message";

        for(int i =0; i<5; i ++){
            channel.basicPublish(exchange, routingKey, true, null, msg.getBytes());
        }

    }
}

先运行消费端consumer,再运行producer,结果如下:
在这里插入图片描述
以上就是一个简单的介绍

网站文章

  • C++重载

    目录重载覆盖隐藏重载运算符重载是C++新增的机制,将语义和功能相似的函数用同一个名字表示,提高函数的通用性。重载特征:(1)相同范围(2)函数名相同(3)参数不同(4)virtual可有可无全局函数和...

    2024-01-30 21:03:19
  • ORACLE数据库 —— PL/SQL知识点2

    ORACLE数据库 —— PL/SQL知识点2

    ORACLE数据库 —— PL/SQL知识点2 内置函数 游标

    2024-01-30 21:03:14
  • security的一个过滤器——SecurityContextPersistenceFilter

    security的一个过滤器——SecurityContextPersistenceFilter1、关于security的用户信息获取a、SecurityContextHolder.getContex...

    2024-01-30 21:03:07
  • 聊聊ctrl+c和ctrl+z的区别

    一句话总结:ctrl+c是强制中断程序,ctrl+c是暂停程序。 Ctrl+C Ctrl+Z Ctrl+D bg fg jobs 强制中断程序,进程终止 暂停程序,挂起 退出shell 将一个在后台暂停的命令,变成继续执行 将后台中的命令调至前台继续运行 查看

    2024-01-30 21:02:36
  • 【蓝桥杯】100个数相乘末尾有几个零

    【蓝桥杯】100个数相乘末尾有几个零

    蓝桥杯-简单计算与模拟部分

    2024-01-30 21:02:23
  • 云时代架构读后感(十二)

    途牛订单的服务化演进 原文地址: https://mp.weixin.qq.com/s?__biz=MzI3MzEzMDI1OQ==&amp;mid=2651814702&amp;idx=1&amp;sn=cafc4aa95db9cfdbd0373d00c633a8fb&amp;scene=21#wechat_redirect 一个系统无论视同开发还是运行时的资源,都无法满足业务的需求...

    2024-01-30 21:02:16
  • 数字图像处理_傅里叶变换_输出矩阵的物理含义分析总结

    考虑二维傅里叶变换。傅里叶变换实现了将图像从空间域到频率域(也叫变换域)的转换,这种转换让我们得到了一个关于原图像灰度信息的频谱图,这个频谱图可以看做是图像梯度的分布图(图像梯度是两个点像素灰度的差值...

    2024-01-30 21:01:46
  • BZOJ2127Happiness

    题目描述高一一班的座位表是个n*m的矩阵,经过一个学期的相处,每个同学和前后左右相邻的同学互相成为了好朋友。这学期要分文理科了,每个同学对于选择文科与理科有着自己的喜悦值,而一对好朋友如果能同时选文科或者理科,那么他们又将收获一些喜悦值。作为计算机竞赛教练的scp大老板,想知道如何分配可以使得全班的喜悦值总和最大。题解这道题相当于给了我们一堆二元关系。容易想到用二元关系最小割来解决。我们设...

    2024-01-30 21:01:39
  • appsettings.json reloadOnChange事件处理

    appsettings.json reloadOnChange事件处理 写作一直是我比较头疼的事,从事10多年软件开发工作,基本上没写过什么文章,.net core的出现让我终于看到了.net平台的曙光,很希望广大.net开发者共同努力让.net core尽...

    2024-01-30 21:01:31
  • 【CCNP】第六章 流量控制 最新发布

    【CCNP】第六章 流量控制 最新发布

    R4(config)# access-list 1 permit 192.168.1.0 0.0.0.255 # 此处的permit不搭配接口下策略使用,不再是允许/放行的意思,而代表抓取。假设该公司...

    2024-01-30 21:01:03