RabbitMQ消息模式

消息如何保证100%的投递

消息100%的投递

消息如何保障100%的投递成功

什么是生产端的可靠性投递

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

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

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

在这里插入图片描述
流程步骤如下:

第①步:将订单入库 创建一条MSG(状态为0)入MSG DB库
第②步:将消息发出去
第③步:监听消息应答(来自Broker)
第④步:修改消息应答为1(成功)
第⑤步:分布式定时任务抓取状态为0的消息
第⑥步:将状态为0的消息重发
第⑦步:如果尝试了三次(可按实际情况修改)以上则将状态置为2(消息投递失败状态)

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

在这里插入图片描述

幂等性概念

幂等性是什么

我们可以借鉴数据库的乐观锁机制
比如我们执行一条更新库存的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进行幂等,需要考虑的问题

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

采用延时双删策略:
①先淘汰缓存
②再写数据库(这两步和原来一样)
③休眠1(根据业务自己设定)秒 再次淘汰缓存 这么做 可以将1秒内所造成的缓存脏数据 再次删除

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

关于不落库 定时同步的策略
目前主流方案有两种:
第一种为双缓存模式,异步写入到缓存中,也可以异步写到数据库,但是最终会有一个回调函数检查,这样能保障最终一致性,不能保证100%的实时性
第二种是定时同步,比如databus同步

Confirm确认消息

理解Confirm消息确认机制

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

如何实现Confirm确认消息

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

消费端代码

package com.xwt.api.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 {
        // 创建ConnectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.16.130");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

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

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

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

        // 声明交换机和队列 然后进行绑定设置, 最后制定路由Key
        channel.exchangeDeclare(exchangeName, "topic", true);
        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.xwt.api.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 {
        // 创建ConnectionFactory
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.16.130");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

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

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

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

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

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

        // 添加一个确认监听
        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!--------");
            }
        });
    }
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

Return返回消息

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

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

在基础API中有一个关键的配置项

Mandatory:如果为true,则监听器会接收到路由不可达的消息,然后进行后续处理,如果为false,那么Broker端自动删除该消息

在这里插入图片描述
消费端代码

package com.xwt.api.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.16.130");
        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.xwt.api.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.16.130");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");

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

        String exchange = "test_return_exchange";
        String routingKey = "return.save";
        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());
    }
}

在这里插入图片描述
在这里插入图片描述
测试消息不可达 将触发ReturnListener
在这里插入图片描述
在这里插入图片描述

自定义消费者

我们一般就是在代码中编写while循环,进行consumer.nextDelivery方法进行获取下一条消息,然后进行消费处理!

但是我们使用自定义的Consumer更加的方便,解耦性更加的强,也是实际工作中最常用的使用方式

自定义消费端代码

package com.xwt.api.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.xwt.api.rabbitmqapi.consumer;

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

/**
 * 短信微服务
 */

package com.xwt.api.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.16.130");
        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.xwt.api.rabbitmqapi.returnlistener;

import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * 生产端代码
 */

package com.xwt.api.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.16.130");
        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());
        }
    }
}

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在 Spring Boot 中使用 RabbitMQ模式消费消息,需要进行以下步骤: 1. 引入 RabbitMQ 依赖: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 配置 RabbitMQ 连接信息: ```properties spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 3. 创建消息监听器: ```java @Component public class MyMessageListener { @Autowired private RabbitTemplate rabbitTemplate; @RabbitListener(queues = "my_queue") public void onMessage() { Message message = rabbitTemplate.receive("my_queue"); if (message != null) { String body = new String(message.getBody(), StandardCharsets.UTF_8); System.out.println("Received message: " + body); } } } ``` 4. 配置消息监听器容器: ```java @Configuration public class MyRabbitConfig { @Autowired private ConnectionFactory connectionFactory; @Autowired private MyMessageListener myMessageListener; @Bean public SimpleMessageListenerContainer messageListenerContainer() { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(); container.setConnectionFactory(connectionFactory); container.setQueueNames("my_queue"); container.setMessageListener(myMessageListener); return container; } } ``` 以上就是使用 RabbitMQ模式消费消息的步骤,需要注意的是,拉模式消费消息需要手动调用 `RabbitTemplate.receive()` 方法获取消息

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值