RabbitMQ03高级篇(消息可靠性投递,Consumer ACK,消费端限流,TTL, 通过代码创建队列和交换机以及绑定)

最新推荐文章于 2024-07-24 12:14:21 发布

疯狂小公举

最新推荐文章于 2024-07-24 12:14:21 发布

阅读量423

点赞数 1

分类专栏： rabbitmq 文章标签： rabbitmq

本文链接：https://blog.csdn.net/weixin_45861581/article/details/115969805

版权

rabbitmq 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

RabbitMQ03高级篇(消息可靠性投递,Consumer ACK,消费端限流,TTL, 通过代码创建队列和交换机以及绑定

消息可靠性投递
confirm 确认模式
- 配置application.yml
- 测试代码
return 退回模式
- 配置application.yml
- 测试代码
Consumer ACK
- 配置application.yml
- 测试代码
如何保证消息可靠性
消费端限流
- 配置application.yml
- 消费者限流代码
TTL设置队列过期
代码
通过代码创建队列和交换机以及绑定

在这里插入图片描述

消息可靠性投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式confirm确认模式和return 退回模式 用来控制消息的投递可靠性模式。
消息投递步骤：
1.生产者(channel)---->交换机------>队列中。
为了确保消息的可靠性投递，提供了如下两种方式
confirm 确认模式
return 退回模式
在这里插入图片描述

创建一个springboot项目，加入web，rabbitMQ依赖
在这里插入图片描述
创建生产者模块

confirm 确认模式

确认回调函数，保证发送方到交换机的可靠性。
1.开启confirm模式，publisher-confirm-type: correlated开启确认模式
2.设置rabbitTemplate的确认回调函数。如果消息到达交换机则返回true,如果消息没有到达交换机则返回一个false

配置application.yml

server:
  port: 8080
spring:
  rabbitmq:
    host: 192.168.31.214
    #rabbitMq的用户名和密码，默认都是guest
    username: admin
    password: admin
    # correlated:开启确认模式
    # none:禁用确认模式
    #开启rabbitMQ的confirm 确认模式
    publisher-confirm-type: correlated

测试代码

设置rabbitTemplate的确认回调函数，如果消息到达交换机则返回true,如果消息没有到达交换机则返回一个false，才会执行回调函数重写后的方法。

  @Autowired
  private RabbitTemplate rabbitTemplate;
  @Test
    public void confirm(){
    rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
//         消息没有到达交换机
            if (ack==false){
                System.out.println("继续发送信息");
            }
        }
    });
//    发送消息   
        rabbitTemplate.convertAndSend("testexchange1","","现在是10:25");
    }

return 退回模式

回退机制
1、开启退回模式
2、设置rabbitTemplate退回回调函数

配置application.yml

server:
  port: 8080
spring:
  rabbitmq:
    host: 192.168.31.214
    #rabbitMq的用户名和密码，默认都是guest
    username: admin
    password: admin
  	# correlated:开启确认模式
    # none:禁用确认模式
    #开启rabbitMQ的confirm 确认模式 发布确认 开启confirm 回调 Producer 
    publisher-confirm-type: correlated
  # 开启发布者退回模式，默认为false 发布返回 开启returnedMessage回调 Exchange 
    publisher-returns: true

测试代码

只要交换机到队列失败时才会触发rabbitTemplate的回调函数中的方法

   /**
     * 回退机制
     * 1、开启退回模式
     * 2、设置rabbitTemplate退回回调函数
     */
    @Test
    public void testReturn(){
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returned) {
//只要交换机到队列失败时才会触发该方法，可以继续发送也可以取消相应的业务功能。
                System.out.println("消息从交换机到队列失败"+returned.getReplyText());
            }
        });
//        发送消息   direct模式路由模式
        rabbitTemplate.convertAndSend("exchange_direc","error2","牛牛牛牛牛");
    }

Consumer ACK

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

配置application.yml

server:
  port: 8081
spring:
  rabbitmq:
    host: 192.168.213.214
    username: admin
    password: admin
    listener:
      simple:
#        表示手动确认
        acknowledge-mode: manual
        #表示自动确认模式
#        acknowledge-mode: none
        #表示根据异常情况确认模式  不常用
#        acknowledge-mode: auto

测试代码

注意：如果try中有异常，并且把认证方法注释掉，就会一直执行catch中的方法**

package com.comfig;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;


/**
 * @author ： 小峥
 * @date ： 2021/4/22 11:02
 * @description：
 */
@Component
public class RabbitConfig {
//    rabbit监听消费者的队列
    @RabbitListener(queues = "myqueue")
    public void listener(Message message, Channel channel)throws Exception{
//        获得消息的标识
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        byte[] body = message.getBody();
        String msg = new String(body);
        try {
            System.out.println("处理业务逻辑");
            int i=10/0;
            /**
             * channel.basicAck里面的参数
             *
             * long deliveryTag 表示的标识
             * oolean multiple 表示是否允许多确认
             */

            //        消费者手动确认消息
//            channel.basicAck(deliveryTag,true);

        }catch (Exception e){
//         是否让队列再次发送该消息
            /**
             * channel.basicNack里面的参数
             *
             * long deliveryTag 表示的标识
             * oolean multiple 表示是否允许多确认
             * boolean requeue: 是否让队列再次发送该消息。
             */
//                                           异常就让队列再次发送消息，
            channel.basicNack(deliveryTag,true,true);
        }

    }
}

如何保证消息可靠性

保证消息从发送者到交换机的可靠性：使用Confirm确认机制。
保证消息从交换机到队列的可靠性; 使用return回退机制。
消息在队列中的可靠性。设置队列和消息的持久化。
保证消息从队列到消费者的可靠性。使用消费端的手动确认机制。

消费端限流

两个要求：

必须为手动确认模式。
必须配置限流的个数

配置application.yml

server:
  port: 8081
spring:
  rabbitmq:
    host: 192.168.31.214
    username: admin
    password: admin
    listener:
      simple:
#        表示手动确认
        acknowledge-mode: manual
        #表示自动确认模式  
#        acknowledge-mode: none 
#        设置每次消费的个数 看个人电脑配置设置
        prefetch: 3

消费者限流代码

@Component
public class MyListener {
    @RabbitListener(queues = "myqueue")
    public void listener(Message message, Channel channel) throws Exception {
//        得到消息的标识
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        byte[] body = message.getBody();
        String msg = new String(body);
        System.out.println(msg);
//        System.out.println("处理业务逻辑");
//        消费端手动确认消息
//     long deliveryTag,表示的标识
//     boolean multiple:是否允许多确认
        try {
//            int c=10/0;
            channel.basicAck(deliveryTag, true);//从队列中删除该信息
        } catch (Exception e) {
//            第三个参数表示是否让队列再次发送该消息
//              如果异常，就让队列再次发送该消息 true
            channel.basicNack(deliveryTag, true, true);
        }
//抛异常执行catch中的

    }
}

TTL设置队列过期

1.设置队列过期。为队列设置过期时间相当于该队列里面的消息都有过期时间
2.设置消息的过期；该消息必须在队列的头部时才会被移除。
设置消息的过期时间如果由设置了队列的过期时间也设置了消息的过期时间谁的过期时间短以谁为准。

代码

设置队列过期时间：
message.getMessageProperties().setExpiration(“15000”);

 //为队列设置过期时间，相当于该队列里面的消息都有过期时间
    @Test
    public void testSend() {
        rabbitTemplate.convertAndSend("myttlexchange", "", "1sisisisvd");
    }

    //    设置消息的过期时间，如果由设置了队列的过期时间 也设置了消息的过期时间 谁的时间短 以谁为准
//    该消息必须在头部才能从队列中移除
    @Test
    public void testsend02() {
        for (int i = 0; i < 10; i++) {
//            该消息必须在头部才能从队列中移除   ,此时消息移除不了
            if (i == 3) {
                MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                    //给消息设置过期时间15秒
                        message.getMessageProperties().setExpiration("15000");
                        return message;
                    }
                };

                rabbitTemplate.convertAndSend("ban129_fanout", "", "11111111dsadsad"+i,messagePostProcessor);
//                myttlexchange
            }else {
                rabbitTemplate.convertAndSend("ban129_fanout","","11111111dsadsad"+i);
            }
        }
    }

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

package com.config;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {
    private final String exchange_name="exchange01";
    private final String queue_name="myqueue";
//    创建交换机
    @Bean
    public Exchange exchange(){
      Exchange exchange = ExchangeBuilder.fanoutExchange(exchange_name).durable(true).build();
        return exchange;
    }

//    创建队列
    @Bean(value = "queue")
    public Queue queue(){
        Queue build = QueueBuilder.durable(queue_name).withArgument("x-message-ttl", 20000).build();
        return build;
    }

//    绑定交换机和队列
    @Bean
    public Binding binding(Queue queue, Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();

    }
}

疯狂小公举

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ03高级篇(消息可靠性投递,Consumer ACK,消费端限流,TTL, 通过代码创建队列和交换机以及绑定)

RabbitMQ高级篇消息可靠性投递消息可靠性投递在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式confirm确认模式和return 退回模式用来控制消息的投递可靠性模式。消息投递步骤：1.生产者(channel)---->交换机------>队列中。为了确保消息的可靠性投递，提供了如下两种方式confirm 确认模式return 退回模式...
复制链接

扫一扫

专栏目录