栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

RabbitMQ消息队列---常用队列以及测试

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

RabbitMQ消息队列---常用队列以及测试

1 死信队列 1.1 什么是死信队列

       死信队列主要是指因某种原因无法被消费者消费的信息,这些信息要么在队列中造成阻塞要么被直接删除掉从而造成消息丢失。比如:按照正常的逻辑来说,生产者生产消息发送到RabbitMQ的broke中,然后消费者从队列中获取消息进行消费,这是正常的消息队列运行状况。但如果由于特定的原因导致队列中的消息无法被消费,这些消息就变成了死信消息,而死信队列则是用来存储这些死信消息的。

       死信消息的来源一般有三种,分别是:消息TTL过期,队列长度已满和消息被拒绝且没有重新入队

1.2 死信代码架构


       死信队列处理流程一般为:当消息生产者生产出消息时,会将消息发送到broke的交换机上,交换机会根据路由key将消息转发到相对应的队列中给消费者消费,但如果消息者在消费消息过程中出现消息设置时间过期了,或者队列的长度已经满了和消息被拒绝且无法入队时,这些出现问题的消息就会变成死信消息,死信消息会被发送到死信交换机,死信交换机会将死信发送到相对应的死信队列中,让消费者02做相关的处理操作。

1.3 Web界面演示

1.设置交换机: 设置两个交换机,一个绑定正常队列,另一个绑定死信队列,交换机的类型可以随意选择,但要注意交换机类型的特点,比如说:direct类型要设置路由key等等

2.设置队列: 设置一个正常队列,并绑定direct交换机和设置死信交换机和消息过期时间,再设置一个普通队列绑定死信交换机作为死信队列

3.测试: 在direct交换机中发送一条消息,首先会发送到ttl_queue,10秒后消息过期进入死信队列

1.4 整合SpringBoot测试

1.创建生产者: 创建生产者,配置好Rabbit配置类和测试消息

package com.example.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

@Configuration
public class RabbitConfig {
    //声明交换机
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("ttl_exchange");
    }

    //声明死信交换机
    @Bean
    public FanoutExchange deadExchange(){
        return new FanoutExchange("dead_exchange");
    }

    //声明队列
    @Bean
    public Queue queue(){
        HashMap args = new HashMap<>();
        args.put("x-message-ttl",10000);
        args.put("x-dead-letter-exchange","dead_exchange");
        //args.put("x-dead-letter-routing-key","");
        return new Queue("ttl_queue",true,false,false,args);
    }

    @Bean
    public Queue queue01(){
        return new Queue("dead_queue",true);
    }

    //交换机绑定队列
    @Bean
    public BindingBuilder.TopicExchangeRoutingKeyConfigurer binding01(){
        return BindingBuilder.bind(queue()).to(topicExchange());
    }

    @Bean
    public Binding binding02(){
        return BindingBuilder.bind(queue01()).to(deadExchange());
    }
}
@Service
public class orderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    
    public void MakeOrder(String userId, String productID, int num) {
            String message = "我是使用springboot来测试死信队列的";
            //订单生成成功,发送消息到消息队列
            String fanoutExchange = "ttl_exchange";
            rabbitTemplate.convertAndSend(fanoutExchange, message);
    }
}

2.创建消费者: 这里只创建一个消费者来绑定死信队列,而正常队列则是没有消费者,模拟消息超时

@Service
//绑定队列
@RabbitListener(queues = "dead_queue")
public class consumerService {
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("接收到了死信信息,该信息是:" + message);
    }
}

3.测试: 发送消息,等过10秒后,绑定死信的消费者则输出死信队列

2 延迟队列 2.1 什么是延迟队列

       延迟队列主要是用来存储那些需要在指定的时间内被消费的消息的队列,就是说,这条消息要在指定的时间前或者指定的时间后执行,存放这些消息的队列就被称为延迟队列,可以理解为死信队列的一种,和死信队列中的TTL时间过期很类似。

       在设置延迟消息的时间时,要注意队列的先进先出特性,即使消息的TTL已经到期了,但如果前面还有消息的话,要等前面的消息消费完才执行延迟消息。

       常见的延迟队列实现方式有:基于死信队列,基于RabbitMQ延迟队列插件,基于Java的DelayQueue和基于KafKa的时间轮等,在RabbitMQ中,如果使用死信队列来作为延迟队列的话,会出现队列先进先出的问题,这时候我们可以下载插件来解决。

       常用的应用场景为:订单在规定的时间内支付,否则就取消等等。

2.2 整合SpringBoot测试


1.创建消息生产者: 配置好队列和交换机信息,编写测试类

package com.example.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

@Configuration
public class RabbitConfig {

    private static final String QA = "QA";
    private static final String QB = "QB";
    private static final String QD = "QD";
    private static final String X = "X";
    private static final String Y = "Y";

    //声明交换机
    @Bean("X")
    public DirectExchange X(){
        return new DirectExchange(X);
    }

    //声明死信交换机
    @Bean("Y")
    public DirectExchange Y(){
        return new DirectExchange(Y);
    }

    //声明队列
    @Bean("QA")
    public Queue QA(){
        HashMap args = new HashMap<>();
        args.put("x-message-ttl",10000);
        args.put("x-dead-letter-exchange","Y");
        args.put("x-dead-letter-routing-key","YD");
        return new Queue(QA,true,false,false,args);
    }

    @Bean("QB")
    public Queue QB(){
        HashMap args = new HashMap<>();
        args.put("x-message-ttl",10000);
        args.put("x-dead-letter-exchange","Y");
        args.put("x-dead-letter-routing-key","YD");
        return QueueBuilder.durable(QB).withArguments(args).build();
    }

    @Bean("QD")
    public Queue QD(){
        return new Queue(QD,true,false,false);
    }

    //交换机绑定队列
    @Bean
    public BindingBuilder.DirectExchangeRoutingKeyConfigurer binding01(@Qualifier("QA") Queue QA,
                                                                       @Qualifier("X") DirectExchange X){
        return BindingBuilder.bind(QA).to(X);
    }

    @Bean
    public BindingBuilder.DirectExchangeRoutingKeyConfigurer binding02(){
        return BindingBuilder.bind(QB()).to(X());
    }

    @Bean
    public BindingBuilder.DirectExchangeRoutingKeyConfigurer binding03(){
        return BindingBuilder.bind(QD()).to(Y());
    }
}
package com.example.service;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class orderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    
    public void MakeOrder(String userId, String productID, int num) {
            String message = "我是使用springboot来测试延迟队列的";
            //订单生成成功,发送消息到消息队列
            rabbitTemplate.convertAndSend("X","XA" ,message);
        System.out.println("消息发送成功");
    }
}

2.创建消费者: 编写消费者绑定延迟队列

package com.example.service;

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

@Service
//绑定队列
@RabbitListener(queues = "QD")
public class consumerService {
    @RabbitHandler
    public void receiveMessage(String message) throws InterruptedException {
        System.out.println("接收到了订单信息,订单信息是:" + message);
    }
}

3.测试: 启动生产者发送消息,10秒后观察消费者的控制面板

3 优先队列 3.1 什么是优先级队列

       在数据结构队列中,都遵循着先进先出的规矩,而在RabbitMQ中,优先级队列则是以一种独特的方式来按照消息的优先级来进行消息的出队,这种方法就是在消息发送到队列中后,RabbitMQ根据消息的优先级来对消息进行再次排队,然后按照优先级的顺序来出队。

       注意: 在使用优先级队列时,要保证消息不要先被消费掉,就是要等消息排完队后再让消费者来消费出队。

3.2 整合SpringBoot测试

1.创建生产者: 优先级队列的设置非常简单,只需要设置x-max-priority这个参数即可,然后在发送消息时加上消息的优先级即可

package com.example.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

@Configuration
public class RabbitConfig {

    private static final String CONFIRM_EXCHANGE = "confirm_exchange";
    private static final String CONFIRM_QUEUE = "priority_queue";
    private static final String CONFIRM_KEY = "key01";


    //声明交换机
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return new DirectExchange(CONFIRM_EXCHANGE);
    }

    //声明队列,设置优先级,优先级范围0~10,最大的范围为0~255
    @Bean("confirmQueue")
    public Queue confirmQueue(){
        HashMap args = new HashMap<>();
        args.put("x-max-priority",10);
        return new Queue(CONFIRM_QUEUE,true,false,false,args);
    }

    //交换机绑定队列
    @Bean
    public Binding binding01(@Qualifier("confirmQueue") Queue confirmQueue,
                             @Qualifier("confirmExchange") DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_KEY);
    }

}
package com.example.service;

import org.springframework.amqp.core.MessageProperties;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class orderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    
    public void MakeOrder(String userId, String productID) throws InterruptedException {
        String message = "我是优先级为5的消息,我先入队";
        rabbitTemplate.convertAndSend("confirm_exchange", "key01", message,msg->{
            MessageProperties properties = msg.getMessageProperties();
            properties.setPriority(5);
            return msg;
        });

        String message01 = "我是优先级为6的消息,我后入队";
        rabbitTemplate.convertAndSend("confirm_exchange", "key01", message01,msg->{
            MessageProperties properties = msg.getMessageProperties();
            properties.setPriority(6);
            return msg;
        });
    }
}

2.创建消费者: 在消费者上,优先级队列对消费者没有什么要求,只需要消费者绑定到优先级队列即可

3.测试: 发送两条消息,然后等一下在开启消费者消费

4 懒惰队列

       懒惰队列又称为持久化队列,在其他的队列中,RabbitMQ都会将消息尽可能的存入内存中来加快消息的消费速度,即使我们在对队列做了持久化后,RabbitMQ都会将消息在内存中做了一份备份来使用的。而在懒惰队列中的话,它的消息会直接存入磁盘中,等消费者想要消费消息时才从磁盘中将消息加载进内存中来让消费者消费,这种队列又被称为懒惰队列。

       懒惰队列设计的初衷是为了防止RabbitMQ在宕机后,消息还能正常发送出去,然后存入磁盘中,而且在懒惰队列的设计中,也考虑到了可以让队列尽可能的支持更多的消息,就是扩大队列的长度。

       懒惰队列的设置方法也很简单,只需要在构建队列时,加入参数:x-queue-mode为lazy即可。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/948836.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号