RabbitMQ高级特性

最新推荐文章于 2024-04-17 17:29:01 发布

爱上编程2705

最新推荐文章于 2024-04-17 17:29:01 发布

阅读量414

点赞数 1

分类专栏： spring-boot框架基础配置 spring-cloud基础架构

本文链接：https://blog.csdn.net/L1569850979/article/details/117568057

版权

spring-cloud基础架构同时被 2 个专栏收录

21 篇文章 1 订阅

订阅专栏

spring-boot框架基础配置

17 篇文章 0 订阅

订阅专栏

RabbitMQ高级特性

1.rabbitmq整个消息投递的路径为：
producer–>rabbitmq broker —>exchange—>queue---->consumer
RabbitMq为我们提供了两种方式用来控制消息的投递可靠性
yml配置

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    #确认消息已发送到交换机(Exchange)
    publisher-confirm-type: correlated
    #确认消息已发送到队列(Queue)
    publisher-returns: true

confirm 确认模式
消息从producer到exchange则会返回一个confirmCallback.
1.代码示例

 /**
     *  路由发送消息
     * @param message
     * @return
     */
    public Boolean setMessage(String message) {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = message;
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            Map<String, Object> map = new HashMap<>();
            map.put("messageId", messageId);
            map.put("messageData", messageData);
            map.put("createTime", createTime);
        /**
         * 确认模式的开启：
         *     步骤：
         *     1.确认模式开启：connection中开启 publish-confirms="true" 或者开启  publisher-confirm-type: correlated
         *     2.在rabbitTemplate定义confirmCallback回调函数
         */
        //定义回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             *
             * @param correlationData 相关配置信息
             * @param ack exchange交换机 是否成功收到了消息。true成功，false代表失败
             * @param cause 失败原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("消息执行："+cause);
                if(ack){
                    System.out.println("接收成功消息"+cause);
                }else {
                    System.out.println("接收失败消息"+cause);
                    //将消息进行一些处理
                }
            }
        });
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return true;

    }

return 退回模式
消息从exchange->queue投递失败则会返回一个returnCallback.
1.代码示例

  /**
     * 消息发送开启回退模式
     *
     * @param message
     * @return
     */
    public Boolean setMessageNext(String message) {
        rabbitTemplate.setMandatory(true);
        /**
         * 回退模式：当消息发送给exchange后，exchange路由到Queue失败时，才会执行returncallback
         * 步骤 ：
         *   1：开启回退模式 publisher-returns: true
         *   2：设置returncallback
         *   3：设置exchange处理消息的模式：
         *         如果消息没有路由到queue,则丢弃消息（默认）
         *         如果消息没有路由到queue，返回给消息发送方returncallbac
         */


                rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
                    /**
                     *
                     * @param returnedMessage :  Message message;   消息对象
                     *      int replyCode; 错误码
                     *      String replyText; 错误信息
                     *      String exchange; 交换机
                     *      String routingKey; 路由键
                     */
                    @Override
                    public void returnedMessage(ReturnedMessage returnedMessage) {
                        System.out.println("return 执行了。。。。。。。。。。");
                        System.out.println(returnedMessage.toString());
                    }
                });
        //将消息携带绑定键值：TestDirectRouting12(错误路由键) 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting12", message);
        return true;
    }

测试结果
在这里插入图片描述
以上配置可以测试确认和退回模式但是不能实际运用到项目中
多次发送请求会报错误
Only one ConfirmCallback is supported by each RabbitTemplate

如果需要集成到spring boot中则需要添加一个配置类
RabbitConfig

package com.example.demo.MqConfig;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {


    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);
        //设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
        rabbitTemplate.setMandatory(true);

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("ConfirmCallback:     "+"相关数据："+correlationData);
                System.out.println("ConfirmCallback:     "+"确认情况："+ack);
                System.out.println("ConfirmCallback:     "+"原因："+cause);
            }
        });

        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returnedMessage) {
                System.out.println("ReturnCallback:     "+"消息："+returnedMessage.getMessage());
                System.out.println("ReturnCallback:     "+"回应码："+returnedMessage.getReplyCode());
                System.out.println("ReturnCallback:     "+"回应信息："+returnedMessage.getReplyText());
                System.out.println("ReturnCallback:     "+"交换机："+returnedMessage.getExchange());
                System.out.println("ReturnCallback:     "+"路由键："+rabbitTemplate.getRoutingKey());
            }
        });

        return rabbitTemplate;
    }

}

先从总体的情况分析，推送消息存在四种情况：
1消息推送到server，但是在server里找不到交换机
2.消息推送到server，找到交换机了，但是没找到队列
3.消息推送到sever，交换机和队列啥都没找到
4.消息推送成功
1.测试1

  @GetMapping("/TestMessageAck")
    @ApiOperation(value = "测试ConfirmCallback 回调函数")
    public Result<String> TestMessageAck() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: non-existent-exchange test message ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //未生成non-existent-exchange的交换机
        rabbitTemplate.convertAndSend("non-existent-exchange", "TestDirectRouting", map);
        return new Result<>("ok");
    }

测试1结果示例
在这里插入图片描述
测试2

   @GetMapping("/TestMessageAck2")
    @ApiOperation(value = "这种情况触发的是 ConfirmCallback和RetrunCallback两个回调函数")
    public Result<String> TestMessageAck2() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: lonelyDirectExchange test message ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //这里新生成的交换机没有绑定队列
        rabbitTemplate.convertAndSend("lonelyDirectExchange", "TestDirectRouting", map);
        return  new Result<>("ok");
    }

测试结果
在这里插入图片描述
3.消息推送到sever，交换机和队列啥都没找到
这种情况其实一看就觉得跟3很像，没错，3和1情况回调是一致的，所以不做结果说明了。
结论： 3这种情况触发的是 ConfirmCallback 回调函数。

4.正常测试

  @GetMapping("/TestMessageAck")
    @ApiOperation(value = "测试ConfirmCallback 回调函数")
    public Result<String> TestMessageAck() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: non-existent-exchange test message ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //未生成non-existent-exchange的交换机
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return new Result<>("ok");
    }

结果示例
在这里插入图片描述
Consumer Ack

ack值Acknowledge ，确认。表示消费端收到消息的确认方式。

有三种确认方式：

自动确认：acknowledge =“none”
手动确认：acknowledge=“manual”
根据异常情况确认：acknowledge=“auto”

自动确认是指，生产者将消息发送到消费者，消费者一旦接受到了消息，则会自动确认收到，并将相应message从RabbitMQ的消息缓存中移除。但是在实际处理业务中，业务处理出现了异常，那么消息就丢失了。如果设置手动确认，则需要在业务处理成功后，调用channel.basicAck（）方法，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。

进行配置
1新建一个监听配置 MessageListenerConfig

package com.example.demo.MqConfig;

import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MessageListenerConfig {

    @Autowired
    private CachingConnectionFactory connectionFactory;
    @Autowired
    private MyAckReceiver myAckReceiver;//消息接收处理类

    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // RabbitMQ默认是自动确认，这里改为手动确认消息
        //设置多个队列
        container.setQueueNames("TestDirectQueue","TestDirectQueue2");
        //如果同时设置多个如下： 前提是队列都是必须已经创建存在的
        //  container.setQueueNames("TestDirectQueue","TestDirectQueue2","TestDirectQueue3");


        //另一种设置队列的方法,如果使用这种情况,那么要设置多个,就使用addQueues
        //container.setQueues(new Queue("TestDirectQueue",true));
        //container.addQueues(new Queue("TestDirectQueue2",true));
        //container.addQueues(new Queue("TestDirectQueue3",true));
        container.setMessageListener(myAckReceiver);

        return container;
    }
}

2.手动处理业务逻辑类MyAckReceiver

package com.example.demo.MqConfig;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class MyAckReceiver implements ChannelAwareMessageListener {




    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
            String msg = message.toString();
            String[] msgArray = msg.split("'");//可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
            Map<String, String> msgMap = mapStringToMap(msgArray[1].trim(),3);
            String messageId=msgMap.get("messageId");
            String messageData=msgMap.get("messageData");
            String createTime=msgMap.get("createTime");
            if ("TestDirectQueue".equals(message.getMessageProperties().getConsumerQueue())){
                System.out.println("消费的消息来自的队列名为："+message.getMessageProperties().getConsumerQueue());
                System.out.println("消息成功消费到  messageId:"+messageId+"  messageData:"+messageData+"  createTime:"+createTime);
                System.out.println("执行TestDirectQueue中的消息的业务处理流程......");

            }

            if ("TestDirectQueue2".equals(message.getMessageProperties().getConsumerQueue())){
                System.out.println("消费的消息来自的队列名为："+message.getMessageProperties().getConsumerQueue());
                System.out.println("消息成功消费到  messageId:"+messageId+"  messageData:"+messageData+"  createTime:"+createTime);
                System.out.println("执行TestDirectQueue2中的消息的业务处理流程......");

            }
            channel.basicAck(deliveryTag, true); //第二个参数，手动确认可以被批处理，当该参数为 true 时，则可以一次性确认 delivery_tag 小于等于传入值的所有消息
//			channel.basicReject(deliveryTag, true);//第二个参数，true会重新放回队列，所以需要自己根据业务逻辑判断什么时候使用拒绝
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
            System.out.println("消息没能处理");
        }
    }

    //{key=value,key=value,key=value} 格式转换成map
    private Map<String, String> mapStringToMap(String str,int entryNum ) {
        str = str.substring(1, str.length() - 1);
        String[] strs = str.split(",",entryNum);
        Map<String, String> map = new HashMap<String, String>();
        for (String string : strs) {
            String key = string.split("=")[0].trim();
            String value = string.split("=")[1];
            map.put(key, value);
        }
        return map;
    }


}

3.请求示例
注释：前提TestDirectExchange（交换机）同时通过TestDirectRouting（路由键）绑定了队列TestDirectQueue和队列TestDirectQueue2

 @GetMapping("/TestMessageAck")
    @ApiOperation(value = "测试ConfirmCallback 回调函数")
    public Result<String> TestMessageAck() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: non-existent-exchange test message ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //未生成non-existent-exchange的交换机
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return new Result<>("ok");
    }

结果示例
在这里插入图片描述
手动确认模式和监听模式不要混合使用：例如同一个交换机同时通过相同路由键绑定了两个不同的队列。会出现以下情况

消息消费混乱！

消费端限流

当消息过多A系统处理不过来的时候可以进行消费端限流
在这里插入图片描述
代码说明

在这里插入图片描述

爱上编程2705

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
3
评论
RabbitMQ高级特性

RabbitMQ高级特性1.rabbitmq整个消息投递的路径为：producer–>rabbitmq broker —>exchange—>queue---->consumerRabbitMq为我们提供了两种方式用来控制消息的投递可靠性confirm 确认模式消息从producer到exchange则会返回一个confirmCallback.1.代码示例 /** * 路由发送消息 * @param message * @return
复制链接

扫一扫