rabbitmq搭建及使用、延时队列、死信队列

最新推荐文章于 2024-05-27 20:23:49 发布
最新推荐文章于 2024-05-27 20:23:49 发布
阅读量631 收藏 1
点赞数
文章标签： java rabbitmq spring boot 中间件 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49686768/article/details/121662228
版权

一、安装Erlang

1.安装erlang环境，erlang环境必须要与rabbitmq对应，需要去官网版本对照！
我的版本较新,可以跟我的对应:
erlang:otp_src_23.2.tar.gz
rabbitmq:rabbitmq-server-generic-unix-3.9.1.tar
附上资源：
链接：https://pan.baidu.com/s/1_URgCFI9eIjhNyqctxtsCw
提取码：b6n4

2.erlang准备环境

yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel

3.进入目录后cd otp_src_23.2

./configure --prefix=/usr/local/erlang --with-ssl --enable-threads --enable-smp-support --enable-kernel-poll --enable-hipe --without-javac

4.安装

make && make install

5.配置环境变量vim /etc/profile

export ERLANG_HOME=/usr/local/erlang
export PATH=${ERLANG_HOME}/bin:${PATH}

6.使配置生效 source /etc/profile

7.检验是否成功 erl
在这里插入图片描述

二、安装rabbitmq

1.解压后 配置环境vim /etc/profile

export RABBITMQ_HOME=/root/rabbitmq_server-3.9.1
export PATH=${RABBITMQ_HOME}/sbin:${PATH}

在这里插入图片描述
保存退出后 source /etc/profile`

进入rabbitmq解压路径

./rabbitmq-plugins enable rabbitmq_management --启动web管理插件
./rabbitmqctl add_user user password  --添加用户，密码
./rabbitmqctl set_user_tags user administrator --设置user为administrator权限
./rabbitmq-server -deched  --后台启动服务
./rabbitmqctl start_app  --启动服务
./rabbitmqctl stop_app  --关闭服务

添加一个新用户的好处就是外部访问的时候可以直接登录，默认root的那个账户只能在linux访问

netstat -anp |grep 5672

在这里插入图片描述这样就启动成功了

在这里插入图片描述

三、springboot基础使用mq

1.springboot的yml配置
在这里插入图片描述
2.rabbitmq交换机、队列、路由配置

@Configuration
public class RabbitMQConfig {
    //购物车交换机
    public static final String SHOPCAR_EXCHANGE = "SHOPCAR_EXCHANGE";
    //购物车队列
    public static final String SHOPCAR_QUEUE = "SHOPCAR_QUEUE";
    //购物车路由键
    public static final String SHOPCAR_ROUTING_KEY = "SHOPCAR_ROUTING_KEY";



    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();

        /**
         AcknowledgeMode.NONE：不确认
         AcknowledgeMode.AUTO：自动确认
         AcknowledgeMode.MANUAL：手动确认
         */
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        return factory;
    }

    //创建购物车交换机
    @Bean
    public Exchange getStoryExchange() {
        return ExchangeBuilder.directExchange(STORY_EXCHANGE).durable(true).build();
    }
    //创建库存队列
    @Bean
    public Queue getStoryQueue() {
        return new Queue(STORY_QUEUE);
    }
    //购物车交换机和购物车队列绑定
    @Bean
    public Binding bindStory() {
        return BindingBuilder.bind(getStoryQueue()).to(getStoryExchange()).with(STORY_ROUTING_KEY).noargs();
    }
}

3.消费者配置：

@Component
@Slf4j
public class ShopCarListener {



    @Autowired
    private ShopCarMapper shopCarMapper;

    /**
     * 监听队列中的消息，如果redis中修改了商品的数量，将修改信息发送到该队列中，然后再将消息同步到数据库中
     *
     * @param
     */
    @RabbitListener(queues = SHOPCAR_QUEUE)
    public void handler(Channel channel, Message message) {
        String msgContent = null;
        try {
            if (message != null) {
                //信息格式处理
                msgContent = new String(message.getBody(), "utf-8");
                ProductDto dto = JSON.parseObject(msgContent, ProductDto.class);
                log.info(msgContent);
				channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);//配置的是手动确认，这里是消息确认

                }
              } catch (IOException e) {
	            e.printStackTrace();
	            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);//配置的是手动确认，这里是消息确认

            }
            }

4.生产者发送消息

@Autowired
private RabbitTemplate rabbitTemplate;
rabbitTemplate.convertAndSend(SHOPCAR_EXCHANGE, SHOPCAR_ROUTING_KEY, JSON.toJSONString(dto));

四、延时队列搭配死信队列(更贴近业务)

1.要在linux的rabbitmq中添加x-delayed-type插件，步骤很简单，首先下载插件，然后把插件放到rabbitmq的plugins目录下，重启rabbitmq，输入命令rabbitmq-plugins enable rabbitmq_delayed_message_exchange

2.延时队列config配置

@Configuration
public class RabbitMQDelayedConfig {

    /**
     * 跑腿订单
     * 延迟消息交换机
     */
    public final static String HELP_DELAY_EXCHANGE = "HELP_DELAY_EXCHANGE";
    /**
     * 跑腿订单
     * 队列
     */
    public final static String HELP_DELAY_QUEUE = "HELP_DELAY_QUEUE";
    /**
     * 跑腿订单
     * 路由Key
     */
    public final static String HELP_DELAY_ROUTING_KEY = "HELP_DELAY_ROUTING_KEY";

    /**
     * 死信队列
     */
    public final static String HELP_DEAD_EXCHANGE="HELP_DEAD_EXCHANGE";
    public final static String HELP_DEAD_QUEUE="HELP_DEAD_QUEUE";
    public final static String HELP_DEAD_ROUTING_KEY="HELP_DEAD_ROUTING_KEY";





    /**
     * 服务订单延迟队列
     */
    @Bean
    public CustomExchange delayMessageExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        //自定义交换机
        return new CustomExchange(HELP_DELAY_EXCHANGE, "x-delayed-message", false, false, args);
    }
    @Bean
    public Queue delayMessageQueue() {
        Map<String, Object> arguments = new HashMap<>(2);
        // 绑定死信交换机
        arguments.put("x-dead-letter-exchange", HELP_DEAD_EXCHANGE);
        // 绑定死信的路由key
        arguments.put("x-dead-letter-routing-key", HELP_DEAD_ROUTING_KEY);
        return new Queue(HELP_DELAY_QUEUE, true, false, false, arguments);
    }
    @Bean
    public Binding bindingDelayExchangeAndQueue() {
        return BindingBuilder.bind(delayMessageQueue()).to(delayMessageExchange()).with(HELP_DELAY_ROUTING_KEY).noargs();
    }



    /**
     * 死信队列和交换器
     */
    @Bean
    public Queue deadHeLpLetterQueue() {
        return new Queue(HELP_DEAD_QUEUE);
    }
    @Bean
    TopicExchange deadHeLpLetterExchange() {
        return new TopicExchange(HELP_DEAD_EXCHANGE);
    }
    @Bean
    Binding bindingDeadHeLpLetterQueue() {
        return BindingBuilder.bind(deadHeLpLetterQueue()).to(deadHeLpLetterExchange()).with(HELP_DEAD_ROUTING_KEY);
    }
}

3.生产者发送延时消息

Integer ttl = 30 * 60 * 1000;//毫秒  30分钟
rabbitTemplate.convertAndSend(RabbitMQDelayedConfig.HELP_DELAY_EXCHANGE, RabbitMQDelayedConfig.HELP_DELAY_ROUTING_KEY, JSON.toJSONString(order), message -> {
                // 设置过期时间
                message.getMessageProperties().setDelay(ttl);
                return message;
            });

4.消费者监听队列以及死信队列监听：

@Component
@Slf4j
public class HelpDealyListener {
    @Autowired
    private OrderDao orderDao;

    @RabbitListener(queues = {RabbitMQDelayedConfig.HELP_DELAY_QUEUE})
//    @RabbitHandler
    public void receiveMessage(Channel channel, Message message) throws IOException {
        String msgContent = null;
        OrderEntity dto = null;
        log.info("收到消息:" + message.getBody());
        try {
            msgContent = new String(message.getBody(), "utf-8");
            //手动异常进入死信队列
  			int k=2/0;          
            dto = JSON.parseObject(msgContent, OrderEntity.class);
            OrderEntity orderEntityNow = orderDao.queryById(dto.getId());
            if (orderEntityNow.getOrderStatus() == 1) {//如果是待付款，则取消
                orderEntityNow.setOrderStatus(0);//设置取消
                int result = orderDao.updateOrderStatus(dto.getId());
                if (result > 0) {
                    log.info("[跑腿订单延时消息] - [取消待付款订单，已取消 消费时间] - [{}] - [{}]", LocalDateTime.now(), dto.getCreateTime() + ",dtoId:" + dto.getId());
                } else {
                    log.info("[跑腿订单延时消息] - [取消待付款订单，已付款 消费时间] - [{}] - [{}]", LocalDateTime.now(), dto.getCreateTime() + ",dtoId:" + dto.getId());
                }
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);//配置的是手动确认，这里是消息确认
            }

        } catch (Exception e) {
            e.printStackTrace();
            log.info("[跑腿订单延时消息] - [消费出错 消费时间] - [{}] - [{}]", LocalDateTime.now(), dto.getCreateTime() + ",dtoId:" + dto.getId());

            //异常，ture 重新入队,或者false,进入死信队列
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, false);
//            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);//配置的是手动确认，这里是消息确认

        }
    }

    /**
     * 死信消费者，自动签收开启状态下，超过重试次数，或者手动签收，reject或者Nack
     *
     * @param message
     */
    @RabbitListener(queues = HELP_DEAD_QUEUE)
    public void handleDeadLetterMessage(Message message, Channel channel, @Headers Map<String, Object> headers) throws IOException {

        //可以考虑数据库记录，每次进来查数量，达到一定的数量，进行预警，人工介入处理
        log.info("接收到跑腿订单死信消息:---{}---消息ID---{}", new String(message.getBody()), headers.get("spring_returned_message_correlation"));
        //回复ack
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

到这里rabbitmq大致的用法已经差不多了。

5.我们可以使用 @RabbitListener 和@RabblitHandler组合来监听队列，当然@RabbitListener 也可以加在方法上。可以创建两个方法用来监听同一个队列，具体调用哪个方法是通过匹配方法的入参来决定的，自定义类型的消息需要标注@Payload，类要实现序列化接口。

@Component
public class MQReceiver {

    @RabbitHandler
    public void onMessage(Message message, Channel channel) throws IOException {

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        //手工ack
        channel.basicAck(deliveryTag,true);
        System.out.println("receive--1: " + new String(message.getBody()));
    }

//这里是自定义类型消息，所以需要添加@Payload注解
   @RabbitHandler
    public void onUserMessage(@Payload User user, Channel channel, @Headers Map<String,Object> headers) throws IOException {

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long deliveryTag = (Long)headers.get(AmqpHeaders.DELIVERY_TAG);
        //手工ack
        channel.basicAck(deliveryTag,true);
        System.out.println("receive--11: " + user.toString());
    }
}

6.交换机确认回调方法,就是发送消息到队列是否成功的confrim模式和消息发送失败的回退模式

首先 yml配置文件添加

spring.rabbitmq.publisher-confirm-type: correlated   #开启发送消息确认
spring.rabbitmq.publisher-returns: true  #开启消息发送失败后回退

@Component
@Slf4j
public class RabbitMqConfirmCallback implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback{

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void initialize(){
        rabbitTemplate.setConfirmCallback(this);
    }


    /**
     * 交换机确认回调方法
     * 1、发消息 交换机成功接收
     * 2、发消息 交换机接收失败
     * @param correlationData 回调消息的id以及相关信息
     * @param ack 是否收到消息
     * @param cause 失败原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        String id = correlationData != null ? correlationData.getId() : "";
        if (ack){ //成功接收
            log.info("成功接收id为：{}",id);
        }else {
            log.info("接收消息失败id为：{},原因：{}",id,cause);
        }
    }

    /**
     * 消息回退
     * 只有消息不可达目的地的时候，才进行回退。
     * @param returnedMessage
     */
    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
        log.info("交换机：{}，消息被退回：{},退回原因：{}",
                returnedMessage.getExchange(),returnedMessage.getMessage().getBody(),returnedMessage.getReplyText());
        }



}

番外：如果mq想带全局唯一id，则在发送消息的时候就带上

 CorrelationData correlationData = new CorrelationData("1234567890"+new Date());
 rabbitTemplate.convertAndSend(STORY_EXCHANGE, STORY_ROUTING_KEY,JSON.toJSONString(orderDtoList),correlationData);
捋捋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot RabbitMq源码解析之配置类
翻身已碰头的博客
12-07 2977
1. RabbitAutoConfiguration类 RabbitAutoConfiguration类是springboot的自动配置类。 @Configuration @ConditionalOnClass({ RabbitTemplate.class, Channel.class }) @EnableConfigurationProperties(RabbitProperties.class...
SpringBoot 官方文档示例：(74)整合RabbitMQ时使用自定义的SimpleRabbitListenerContainerFactory
amadeus_liu2的博客
02-08 1348
boot
Spring Boot 中的 @RabbitListenerContainerFactory 注解
u013749113的博客
07-01 1877
如果我们需要自定义监听器容器，可以使用注解来创建自定义的监听器容器工厂。} }在这个示例中，我们使用注解来创建一个名为myFactory的自定义监听器容器工厂。我们在myFactory中设置了一些监听器容器的属性，例如线程池大小、消息确认机制等。接着，我们使用@Bean注解来创建一个名为myListener的消息监听器，并将其设置到中。最后，我们使用@Bean注解来创建一个名为的自定义监听器容器，将其绑定到myQueue队列上，并使用myListener作为消息监听器。
RabbitMQ 之 死信队列
最新发布
weixin_73616913的博客
05-27 886
但是发生了上面所说的三种情况中的一种，成为了死信，然后被转换到死信交换机中，这个死信交换机也是 direct 类型，它们之间的 routingKey 是 "lisi",然后就进入了死信队列，死信队列由 C2 消费。生产者正常情况下走的是普通的交换机，这个交换机的类型是 direct ，它和普通队列之间的关系是一个叫 "zhangsan" 的路由 key， 正常情况下会被 C1 消费。应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息。，字面意思可以这样理。
RabbitMQ实现延迟队列的两种方式
hit、run
09-27 1741
RabbitMQ实现延迟队列的两种方式
RabbitMq死信队列
qq_28227405的博客
01-25 1410
死信队列是指消息被投递到队列后，由于各种原因导致队列中的消息无法被消费掉，这样的消息如果没有后续处理就变成了死信，有死信自然就有了死信队列。 如果是固定的过期时间则可以通过队列设置过期时间的方式实现。当过期时间不固定且有很多的过期时间且不希望有过多的过期队列时则可以使用插件的方式（rabbitmq_delayed_message_exchange插件）实现延迟队列的效果。一定不能通过设置生产者的过期时间来实现消息的任意过期时间的目的，否则就会出现我们示例中的问题。
SpringBoot下RabbitMQ的实战应用：动态创建和动态监控队列、死信、备份交换机
土味儿
01-07 3873
每个用户对应一个普通队列；当用户过多时，相应的队列也会很多，并且队列是持久化的，会占用较多的系统资源；交换机收到消息，但无法投递时，转发至备份交换机，再广播至对应队列。缓存操作不是本文的重点，用模型类代替；缓存中未得到确认的消息，由定时器重新发送；用户登录后，动态切换要监控的队列；未发送成功的消息，由缓存保存，定时重发。如果用户退出后，也要更新监控列表；是接收不到的，消息会存储在相应对列中。发消息，消息应该不会被消费，存在。项目要足够稳健，消息不能丢失。交换机、队列、消息持久化。，这时再向上一个登录用户。
rabbitMq+erlang+延时队列插件完整安装包.7z
04-07
RabbitMQ是一款开源的消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议，...在实际应用中，确保对Erlang和RabbitMQ有深入理解，以及正确地使用延时队列插件，能够极大地优化业务流程，降低复杂性。
SpringBoot使用RabbitMQ延时队列(小白必备)
08-25
Spring Boot 使用 RabbitMQ 延时队列 Spring Boot 使用 RabbitMQ 延时队列是指在 Spring Boot 应用程序中使用 RabbitMQ 实现延时队列的功能。延时队列是指消息队列中的一种特殊类型，它可以在指定的时间点触发消息...
Linux 安装 RabbitMQ 应用 / RabbitMQ 延时队列
11-16
Linux 安装 RabbitMQ 应用 / RabbitMQ 延时队列
RabbitMQ之延迟队列
凉茶铺的博客
12-01 2655
介绍了RabbitMQ的延迟队列
SpringBoot集成RabbitMq多rabbitTemplate管理,多SimpleRabbitListenerContainerFactory管理
weixin_44929059的博客
04-30 8315
SpringBoot集成RabbitMq多rabbitTemplate管理,多SimpleRabbitListenerContainerFactory管理 使用RabbitMq,发送消息确认,需要使用rabbitTemplate的ConfimCallback方法和ReturnCallback方法,网上大多配置为全局修改,如果需要对单个生产者进行配置,则需要将rabbitTemplate设置为多例,在需要单独配置的生产者使用@PostConstruct注解进行设置rabbitTemplate的ConfimC
rabbitMq延迟队列的使用
sora33的博客
07-05 3475
主要介绍rabbitmq延迟队列的使用
RabbitMQ自学之路（九）——RabbitMQ实现延时队列的两种方式
gb4215287的博客
10-14 963
一、什么是延时队列 延时队列顾名思义，即放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。 二、延时队列应用于什么场景 场景一：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行一场处理。这是就可以使用延时队列将订单信息发送到延时队列。 场景二：用户希望通过手机远程遥控家里的智能设备在指定的时间进行工作。这时候就可以将用户指令发送到延时队列，当指令设定的时间到了再将指令推送到智能设备。 Rabbitmq实现延时队列一般而言
rabbitmq添加延时通道时报错
u011649691的博客
07-12 3145
rabbitmq
RabbitMQ——延迟队列
风间琉璃の博客
03-10 2658
1. 延迟队列 1.1 概念 延迟队列内部是有序的，其中的元素是希望在指定时间到了之后取出或者处理，总之就是用来存放需要在指定时间被处理的元素的队列。 1.2 使用场景 用来在一定时间间隔内对相应的事件做出提醒或者操作。 1.3 整合SpringBoot 正常新建SpringBoot项目即可。SpringBoot版本为2.5.6，如果版本过高与Swagger2版本相差过大就会抛出异常。 添加依赖： <dependencies> <dependency>
RabbitMQ实现延时消息的两种方法
lan_kang的博客
12-17 5413
文章目录RabbitMQ实现延时消息的两种方法1、死信队列1.1消息什么时候变为死信(dead-letter)1.2死信队列的原理1.3 代码实现1.4死信队列的一个小坑2 、延时插件2.1如何实现 RabbitMQ实现延时消息的两种方法 1、死信队列 1.1消息什么时候变为死信(dead-letter) 消息被否定接收，消费者使用basic.reject 或者 basic.nack并且requeue 重回队列属性设为false。 消息在队列里得时间超过了该消息设置的过期时间（TTL）。 消息队列到达了它
05 RabbitMQ面试题
Java是世界上最好的语言
12-26 1218
目录 Pt1 消息队列的作用与使用场景？ Pt2 RabbitMQ有哪些特性？ Pt3 Channel和VHost的作用是什么？ Pt4 多个项目公用MQ服务器时，如何实现权限隔离？ Pt5 RabbitMQ的消息有哪些路由方式？适合在什么业务场景使用？ Pt6 交换机与队列、队列与消费者是如何绑定的？ Pt7 无法被路由的消息去了哪里？ Pt8 消息在什么时候会进入死信队列？ Pt9 如果一个项目要从多个服务器接收消息如何处理？ Pt10 如果一个项目要发送消息到多个服务器如何处理？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值