rabbitMQ高级特性

最新推荐文章于 2024-08-15 14:40:49 发布
最新推荐文章于 2024-08-15 14:40:49 发布
阅读量206 收藏 1
点赞数
文章标签： rabbitmq 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54517901/article/details/115982743
版权 
	1.消息可靠性投递
	2.Consumer ACK
	3.消费端限流
	4. TTL
	5. 死信队列
	6. 延迟队列
	7. 消息的幂等性
消息可靠性传递
在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。

消息投递步骤：

生产者(channel)---->交换机------>队列中
保证消息的可靠性：
1. 保证消息从发送者到交换机的可靠性： 使用Confirm确认机制。
2. 保证消息从交换机到队列的可靠性; 使用return回退机制。
3. 消息在队列中的可靠性。  设置队列和消息的持久化。
4. 保证消息从队列到消费者的可靠性。  使用消费端的手动确认机制。

为了确保消息的可靠性投递，提供了如下两种方式：

confirm 确认模式
return  退回模式
product的confirm模式

（1）在配置文件中开启rabbitmq生产方式

spring:
  rabbitmq:
    host: 192.168.31.243
    #开启rabbitMQ的生产方确认模式
    #correlated ：发布消息成功到交换机后触发回调方法
    #none:禁用发布确认模式（默认）
    publisher-confirm-type: correlated

(2) 代码实现

@SpringBootTest
public class RabbitLevel {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void productConfirm(){
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            /*设置rabbitTemplate的确认回调函数。如果消息到达交换机则返回true,如果消息没有到达交换机则返回一个false*/
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack){ //消息到达交换机
                    System.out.println("成功-->"+ack);
                }else {//消息未到达交换机
                    System.out.println("失败-->"+cause+","+ack);
                }
            }
        });
        //发送消息
        rabbitTemplate.convertAndSend("exchange1","","hello confirm");
    }
}

在这里插入图片描述

product的退回模式(returns)

（1）在配置文件中开启rabbitmq生产方式

 #开启发布者退回模式
    publisher-returns: true

（2）代码实现

@Test
    public void returnConfirm(){
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            //只要交换机到队列失败时才会触发该方法
            //可以继续发送也可以取消相应的业务功能
            public void returnedMessage(ReturnedMessage returned) {
                System.out.println("消息从交换机到队列发生了失败,错误是--->"+returned.getReplyText());
            }
        });
        // 发送消息                                                        //错误的路由
        rabbitTemplate.convertAndSend("exchangeDirct","qwertasdf","hello returns");
    }

在这里插入图片描述

Consumer ACK
表示消费端收到消息后的确认方式。
其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息队列中移除。但是在实际业务处理中，很可	能	消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。

（1）消费端配置手动开启确认模式

server:
  port: 8081
spring:
  rabbitmq:
    host: 192.168.31.243
    listener:
      simple:
        #manual:用户必须通过具有频道意识的侦听器进行确认
        #none:自动提交 默认为ture
        #auto:容器将根据侦听器是否正常返回或引发异常来发出确认
        acknowledge-mode: manual

代码实现

@Component
public class ListenerConsumer {


    @RabbitListener(queues = "queue_Dirct02")
    public void consumerAck(Message message,Channel channel) throws Exception{

        //获取信息的唯一标识
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        //消费的消息
        byte[] body = message.getBody();
        String str = new String(body);
        System.out.println(str);

        try{
//            int c = 10/0;
            System.out.println("处理业务逻辑"); //此时如果这里出现一个异常,消息接收到，业务处理出现异常，那么该消息就会丢失
            // long deliveryTag, 表示的标识
            // boolean multiple:是否允许多确认
            channel.basicAck(deliveryTag,true);//处理完业务再消费掉
        }catch (Exception e){
            // long deliveryTag, 表示的标识
            // boolean multiple:是否允许多确认
            // requeue: 是否让队列再次发送该消息
            channel.basicNack(deliveryTag,true,true);
        }
    }
}
消费端限流

(1) 在配置文件中配置读取个数

 #prefetch:每个使用者可以处理的未确认消息的最大数量
        prefetch:5

(2)代码实现

@RabbitListener(queues = "queue_Dirct02")
    public void consumerAck(Message message,Channel channel) throws Exception{

        //获取信息的唯一标识
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        //消费的消息
        byte[] body = message.getBody();
        String str = new String(body);
        System.out.println(str);

        try{
//            int c = 10/0;
            System.out.println("处理业务逻辑"); //此时如果这里出现一个异常,消息接收到，业务处理出现异常，那么该消息就会丢失
            // long deliveryTag, 表示的标识
            // boolean multiple:是否允许多确认
//            channel.basicAck(deliveryTag,true);//处理完业务再消费掉
        }catch (Exception e){
            // long deliveryTag, 表示的标识
            // boolean multiple:是否允许多确认
            // requeue: 是否让队列再次发送该消息
            channel.basicNack(deliveryTag,true,true);
        }
    }
TTL 设置过期时间

(1) 设置消息的过期；该消息必须在队列的头部时才会被移除
(2) 代码实现

 @Test
    public void setTTl(){

        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //设置消息过期时间
                message.getMessageProperties().setExpiration("20000");
                return message;
            }
        };
        //exchange:交换机
        //routingKey:路由 key
        //message:发消息
        //messagePostProcessor :消息后处理器
        rabbitTemplate.convertAndSend("myexchange","","hello returns",messagePostProcessor);

    }

增加

通过代码创建队列和交换机以及绑定

(1) 代码实现

@Configuration
public class RabbitConfig {
    private final String exchange_name="myExchange";
    private final String queue_name="myQueue";

    //交换机
    @Bean
    public Exchange exchange(){
        return new FanoutExchange(exchange_name,true,false);
    }

    //队列
    @Bean
    public Queue queue(){
                                                            //队列消息 过期时间
        return QueueBuilder.durable(queue_name).withArgument("x-message-ttl",20000).build();
    }

    //绑定
    @Bean
    public Binding binding(Exchange exchange,Queue queue){
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }
}
死信队列
死信队列，英文缩写：DLX  。Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以
被重新发送到另一个交换机，这个交换机就是DLX。

在这里插入图片描述
消息成为死信的三种情况：

	1. 队列消息长度到达限制；
	2. 消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；
	3. 原队列存在消息过期设置，消息到达超时时间未被消费；

队列绑定死信交换机：

给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key

在这里插入图片描述（1）创建队列\交换机和死信队列和死信交换机

@Configuration
public class RabbitConfiguration {

    private final String EXCHANGE="exchange";
    private final String DEAD_EXCHANGE="dead_exchange";
    private final String QUEUE="queue";
    private final String DEAD_QUEUE="dead_queue";

    //交换机
    @Bean
    public Exchange exchange(){
        return ExchangeBuilder.directExchange(EXCHANGE).build();
    }
    //死信交换机
    @Bean
    public Exchange deadExchange(){
        return ExchangeBuilder.directExchange(DEAD_EXCHANGE).build();
    }

    //队列
    @Bean
    public Queue queue(){
        return QueueBuilder.durable(QUEUE)
                .withArgument("x-message-ttl",10000) //设置队列消息超时时间
                .withArgument("x-max-length",10)  //队列最大长度
                .withArgument("x-dead-letter-exchange",DEAD_EXCHANGE) //队列连接的死信交换机
                .withArgument("x-dead-letter-routing-key","error") //与私信交换机的路由key
                .build();
    }

    //死信队列
    @Bean
    public Queue deadQueue(){
        return QueueBuilder.durable(DEAD_QUEUE).build();
    }

    //绑定
    @Bean
    public Binding binding(Exchange exchange,Queue queue){
        return BindingBuilder.bind(queue).to(exchange).with("error").noargs();
    }

    @Bean
    public Binding deadBinding(Exchange deadExchange,Queue deadQueue){
        return BindingBuilder.bind(deadQueue).to(deadExchange).with("error").noargs();
    }


}
第一种 超时未处理到达死信队列(测试)
@SpringBootTest
public class TestDead {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testDead(){
       for (int i = 0; i < 10; i++) {
            //发送消息                    //此时 因为未消费 加上队列有设置超时时间  所以 在10s之后进入到死信队列中
            rabbitTemplate.convertAndSend("exchange","error","hello 超市未消费滴");
        }
}

在这里插入图片描述过了10s钟

在这里插入图片描述用视图化界面读取一下
在这里插入图片描述

第二种 队列消息长度到达限制

(1.) 发送消息

@SpringBootTest
public class TestDead {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testDead(){
        //这里循环了15次  设置的最大长度为10  所以超出的5个会到死信队列里
        for (int i = 0; i < 15; i++) {
            //发送消息                    //此时 因为未消费 加上队列有设置超时时间  所以 在10s之后进入到死信队列中
            rabbitTemplate.convertAndSend("exchange","error","hello 超市未消费滴");
        }
    }
}

在这里插入图片描述

第三种 消费者拒接消费消息
basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；

(1) 配置文件中配置手动接收

listener:
      simple:
        #设置手动接收
        acknowledge-mode: manual

(2) producer发送消息

@SpringBootTest
public class TestDead {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testDead(){
        //这里循环了15次  设置的最大长度为10  所以超出的5个会到死信队列里
        for (int i = 0; i < 20; i++) {
            //发送消息                    //此时 因为未消费 加上队列有设置超时时间  所以 在10s之后进入到死信队列中
            rabbitTemplate.convertAndSend("exchange","error","hello 超市未消费滴");
        }
    }
}

（2）消费者代码

@Component
public class ConsumerL {

    @RabbitListener(queues = "queue")
    public void send(Message message , Channel channel){
        //唯一标识
        long tag = message.getMessageProperties().getDeliveryTag();
        //获取消息
        byte[] body = message.getBody();
        String s = new String(body);
        System.out.println(s);

        try {
            //拒绝接收消息
            channel.basicNack(tag,false,false);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
延迟队列
虽然rabbitmq未提供延迟队列功能，但可以使用TTL+死信队列完成

在这里插入图片描述

@SpringBootTest
public class TestDead {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testDead(){
            //发送消息                    //此时 因为未消费 加上队列有设置超时时间  所以 在10s之后进入到死信队列中
            rabbitTemplate.convertAndSend("exchange","error","下单成功");
    }
}

在这里插入图片描述
过三十分钟后(比喻)
在这里插入图片描述

消息幂等性保障
幂等性：用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用

让每个消息携带一个全局的唯一ID，即可保证消息的幂等性，具体消费过程为：

1.消费者获取到消息后先根据id去查询redis/db是否存在该消息
2.如果不存在，则正常消费，消费完毕后写入redis/db
3.如果存在，则证明消息被消费过，直接丢弃。

在这里插入图片描述
使用redis的缓存

<dependency> 
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

代码实现

@Component
public class ConsumerL {

    @Autowired
    private RedisTemplate redisTemplate;

    @RabbitListener(queues = "dead_queue")
    public void send(Message message , Channel channel){
        //得到信息的唯一标识
        long id = message.getMessageProperties().getDeliveryTag();
        //获取是否有id
        Object o = redisTemplate.opsForValue().get(id);
        //判断是否为空
        if (o==null){
            System.out.println("处理业务,完成业务功能");
            redisTemplate.opsForValue().set(id,"obj"); //设置到缓存 设置后 确认返回队列出现异常，再次消费时，已经有唯一id 则让队列直接删除
            try {
                channel.basicAck(id,true);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else {
            try {
                channel.basicAck(id,true);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}
依依y6
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ高级特性 - 事务消息
CYK_byte的博客
08-03 735
RabbitMQ 的 AMQP 协议实现了事务机制，允许开发者保证消息的发送和接收时原子性的，也就是说，要么消息全都发送成功，要么全都发送失败（只与发送方有关）.
RabbitMQ高级特性 - 消费者消息确认机制
CYK_byte的博客
08-04 1172
为了保证消息从 队列 到 消费者正确消费，那么就引入了消费者消息确认机制.a）消费者在订阅队列时，可以指定 autoAck 参数，根据这个参数设置，消息确认机制分为以下两种（以下讲到的方法和参数来自于 RabbitMQ 原生的 SDK，非 Spring 提供）.自动确认：当 autoAck = true 时，RabbitMQ 会自动把发送出去的消息置为确认，然后不管消费者是否真正的消费这些消息，都会从内存中删除.（适合对消息可靠性要求不高的场景）.
（三）rabbitmq的消息确认机制ack
y13g14m的博客
05-13 2870
接上一篇文章，在application配置文件中添加如下配置：## 消息手动确认 spring.rabbitmq.listener.simple.acknowledge-mode=manual这样就开启了消息手动确认，然后再消费者端代码中加上如下代码进行业务处理完后的消息确认删除消息：package com.example.demo.consumer; import com.rabbitmq.c...
rabbitmq保证消息丢失，这篇文章慢慢读完 应该可以懂
qq_39184915的博客
04-03 1976
rabbitmq保证消息丢失，这篇文章慢慢读完 应该可以懂
RabbitMQ(四)：RabbitMQ高级特性
m0_53142956的博客
11-15 6264
说明：因为在yml配置文件中定义消息路由失败时的策略为true，所以当消息从交换机路由到队列失败时，会调用ReturnCallback每个RabbitTemplate只能配置一个ReturnCallback，因此需要在项目加载时添加配置：修改publisher服务，添加一个【配置类】：位置：config/commic配置类。
RabbitMQ 消息丢失解决 （高级发布确认、消息回退与重发、备份交换机）
weixin_52536274的博客
11-17 1824
一、发布确认SpringBoot版本首先发布消息后进行备份在缓存里，如果消息成功发布确认到交换机，则从缓存里删除该消息，如果没有成功发布，则设置一个定时任务，重新从缓存里获取消息发布到交换机，直到成功发布到交换机。确认机制图例：代码实战：一个交换机：confirm.exchange，一个队列：confirm.queue，一个消费者：confirm.consumer其中交换机类型时 direct，与队列关联的 routingKey 是 key1代码架构图：1.1交换机的发布确认。
RabbitMQ----消息可靠性传递
未来的博客
04-22 248
RabbitMQ的高级特性   在开始之前，先想想几个问题，我们采用了生产者(channel)---->交换机------>队列中，那么如果其中生产者在向交换机发送信息是能一定发送成功吗？，该如何确认信息的状态，或者说交换机在向队列发送信息的时候发送失败，那么该如何解决。   举个例子：你购买了一件商品，商品要通过快递到你手里，就可以理解成你就是队列， 商品要到快递站，此时你的快递就有可能出现丢失的情况(这里可以理解成生产者(channel)---->交换机)，快递丢了，是不是就要告诉一下
rabbitmq(三)发布确认+集群+其他高级
bocli的博客
12-25 1233
8.发布确认 8.1. 发布确认 springboot 版本 8.1.1. 确认机制方案 8.1.2. 代码架构图 8.1.3. 配置文件 在配置文件当中需要添加 spring.rabbitmq.publisher-confirm-type=correlated NONE:禁用发布确认模式，是默认值 CORRELATED:发布消息成功到交换器后会触发回调方法 SIMPLE 经测试有两种效果，其一效果和 CORRELATED 值一样会触发回调方法，其二在发布消息成功后使用 rabbitTemplate
RabbitMQ高级特性
weixin_42763504的博客
08-12 1718
一.消息如何保证100%的投递成功 1. 生产端的可靠性投递 (1)保障消息的成功发出 (2)保障MQ节点的成功接收 (3)发送端收到MQ节点确认应答 (4)完善的消息进行补偿机制 2. 解决方案 (1)消息落库，对消息状态进行打标 （多次操作数据库，不适合高并发场景) (2)消息的延迟投递，做二次确认，回调检查 (保证99%，保证性能) 二.幂等性 1. 类似数据库的...
RabbitMQ的高级特性
qq_34518487的博客
10-15 187
RabbitMQ的高级特性 在项目中,有一些无需即时返回且耗时的操作,我们可以将其提取出来,做异步处理,从而节省服务器的请求响应时间，从而提高系统的吞吐量。这就需要使用到MQ，而常见的RabbitMQ就是重中之重，之前说了他的几个常见的用处： 异步 解耦 削峰填谷 今天给大家介绍几个RabbitMQ的高级特性： 1.消息可靠性投递 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm
rabbitmq高级特性
08-15
RabbitMQ具有一些高级特性，使其在消息队列系统中具有更强大的功能和灵活性。以下是一些常见的高级特性： 1. 死信队列（Dead Letter Exchange）：RabbitMQ允许将无法被消费或处理的消息路由到特定的死信队列中。这...
RabbitMQ发布确认高级部分
怕什么真理无穷，进一寸有一寸的欢喜。即使开了一辆老掉牙的破车，只要在前行就好，偶尔吹点小风，这就是幸
06-10 398
首先复习一下我们前面学习的发布确认，生产者将信道设置成 confirm 模式，这样就可以确定消息是否被队列接收，这样就可以在回调中进行相应的处理了。在生产环境中由于一些不明原因，导致 rabbitmq 重启，在 RabbitMQ 重启期间生产者消息投递失败， 导致消息丢失，需要手动处理和恢复。于是，我们开始思考，如何才能进行 RabbitMQ 的消息可靠投递呢？ 特别是在这样比较极端的情况，RabbitMQ 集群不可用的时候，无法投递的消息该如何处理呢:编写配置类 编写生产者 编写消费者 上面的环境已经搭建
RabbitMQ-消息的可靠性投递
qq_62939743的博客
03-05 1246
消息的可靠性投递，通过confirm机制、return机制、ack机制保证消息能从生产者顺利到达消费者。
Rabbitmq入门与应用(六)-rabbitmq的消息确认机制
qq_36115196的博客
02-19 1592
讲解如何在项目中保证rabbitmq消息传输中的数据一致性问题
SpringBoot整合RabbitMQ高级特性
weixin_45962477的博客
02-16 908
持久化exchange要持久化queue要持久化message要持久化生产方确认Confirm消费方确认AckBroker高可用RabbitMQ默认日志存放路径： /var/log/rabbitmq/没有权限在命令前面加上sudo日志包含了RabbitMQ的版本号、Erlang的版本号、RabbitMQ服务节点名称、cookie的hash值、RabbitMQ配置文件地址、内存限制、磁盘限制、默认账户guest的创建以及权限配置等等。
RabbitMQ养成记 （8. 消费者接受消息可靠性 consumer Ack）
陆续将以前写过的技术博客统一搬运到csdn
05-16 873
而不使用注解的情况下，需要显式实现MessageListener接口并重写onMessage方法，是一种传统的方式来定义 RabbitMQ 的消息监听器。而使用@RabbitListener注解的方式，是Spring AMQP提供的一种更简化和方便的方式，用于声明消息监听器的方法。使用@RabbitListener注解的方法不需要显式实现MessageListener接口，是因为框架会自动处理消息的转换，并将消息内容作为方法的参数传递进去。然后我们把原来的代码扩充一下 在这里实现 手动的ack。
【SpringBoot MQ 系列】RabbitListener 消费基本使用姿势介绍
程序员高级码农的博客
01-08 2420
【MQ 系列】RabbitListener 消费基本使用姿势介绍之前介绍了 rabbitmq 的消息发送姿势，既然有发送，当然就得有消费者，在 SpringBoot 环境下，消费可以说比较简单了，借助注解，基本上可以满足你 90%以上的业务开发需求下面我们来看一下的最最常用使用姿势。
RabbitMQ的消息确认机制Ack Mode
最新发布
qq_60638478的博客
08-15 835
消费者需要告诉 RabbitMQ 某条消息已经被成功处理，这样 RabbitMQ 才会将其从内存中移除。如果消费者没有发送确认信号，RabbitMQ 会保留该消息，直到收到确认或者发生特定的超时情况。在自动确认模式下，RabbitMQ 通常不会等待当前消息被处理完毕再发送下一条消息给同一个消费者。在手动确认模式下，RabbitMQ 会等待当前消息被处理完毕再发送下一条消息给同一个消费者。ackMode ="MANUAL"，此时为手动确认模式，ackMode ="NONE"，此时为自动确认模式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值