简单模拟RabbitMq死信队列完成订单过期业务

文章目录

• Maven
• 创建队列和交换机
• 生产者方法
• Controller层

Maven

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

创建队列和交换机

package com.erligang.framework.mq;

import com.erligang.common.utils.StringUtils;
import com.erligang.project.test.RabbitMqOrderTest;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * li
 *
 * @Author: li
 */
@Component
@Slf4j
public class StatusDeadLetterQueueConsumer {
    //队列
    public static final String FORMAL_QUEUE = "formal_queue";
    public static final String DEAD_QUEUE = "dead_queue";

    //交换机
    public static final String FORMAL_EXCHANGE = "formal_exchange";
    public static final String DEAD_EXCHANGE = "dead_exchaneg";

    //路由key
    public static final String FORMAL_ROUNTE_KEY = "formal_rounte_key";
    public static final String DEAD_ROUNTE_KEY = "dead_route_key";

    /**
     * 普通队列交换机声明
     * 交换机类型：topic：处理路由键，按模式匹配，向符合规则的队列投递消息
     * name 交换机名称
     * durable 是否持久化
     * autoDelete 是否删除
     * arguments 用于设置其他参数
     *
     * @return
     */
    @Bean
    public Exchange getFormalExchange() {
        return new TopicExchange(FORMAL_EXCHANGE, true, false, null);
    }

    /*
     * 声明普通队列，并设置与死信队列联系
     * name 队列名称
     * durable 是否持久化
     * exclusive 是否排外 如果是排外的，该队列 仅对首次声明它的连接（Connection）可见，是该Connection私有的，
     * 类似于加锁，并在连接断开connection.close()时自动删除
     * autoDelete 是否删除
     * arguments 用于设置其他参数
     *
     * @return
     */
    @Bean
    public Queue getFormalQueue() {
        Map<String, Object> map = new HashMap<>();
        //设置死信队列交换机
        map.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //设置死信队列路由key
        map.put("x-dead-letter-routing-key", DEAD_ROUNTE_KEY);
        return new Queue(FORMAL_QUEUE, true, false, false, map);
    }

    /*
     * 将普通队列和交换机绑定
     * destination：目标队列或交换器
     * destinationType：DesdinationType指出目标是交换器还是对列
     * exchange：交换机
     * routingKey：路由key
     * arguments：参数设置
     *
     * @return
     */
    @Bean
    public Binding bingFormalQueue() {
        return new Binding(FORMAL_QUEUE, Binding.DestinationType.QUEUE, FORMAL_EXCHANGE, FORMAL_ROUNTE_KEY, null);
    }


    /**
     * 声明死信队列交换机
     *
     * @return
     */
    @Bean
    public Exchange getDeadExchange() {
        return new TopicExchange(DEAD_EXCHANGE, true, false, null);
    }


    /**
     * 声明死信队列
     *
     * @return
     */
    @Bean
    public Queue getDeadQueue() {
        return new Queue(DEAD_QUEUE, true, false, false, null);
    }

    /**
     * 将死信队列和交换机绑定
     *
     * @return
     */
    @Bean
    public Binding bingDeadQueue() {
        return new Binding(DEAD_QUEUE, Binding.DestinationType.QUEUE, DEAD_EXCHANGE, DEAD_ROUNTE_KEY, null);
    }


    /**
     * 监听死信队列
     */
    @RabbitListener(queues = StatusDeadLetterQueueConsumer.DEAD_QUEUE)
    public void listenDeadQueueFirst(Long msg) {
        log.info("接收到死信队列消息一:{}", msg);
        Map<Long, String> orderInfo = RabbitMqOrderTest.orderInfo;
        String s1 = orderInfo.get(msg);
        if("已支付".equals(s1)){
            log.info("订单号:{}已支付",msg);
            return;
        }
        Map<Long, String> orderPayInfo = RabbitMqOrderTest.orderPayInfo;
        String s = orderPayInfo.get(msg);
        if(StringUtils.isNull(s) || !"已支付".equals(s)){
            orderInfo.put(msg,"已过期");
        }else {
            log.info("订单号:{}已支付",msg);
        }
    }

    // /**
    //  * 监听死信队列
    //  */
    // @RabbitListener(queues = StatusDeadLetterQueueConsumer.DEAD_QUEUE)
    // public void listenDeadQueueSecond(int msg) {
    //     log.info("接收到死信队列消息二:{}", msg);
    // }
    //
    // /**
    //  * 监听死信队列
    //  */
    // @RabbitListener(queues = StatusDeadLetterQueueConsumer.DEAD_QUEUE)
    // public void listenDeadQueueThree(int msg) {
    //     log.info("接收到死信队列消息三:{}", msg);
    // }
    //
    // /**
    //  * 监听死信队列
    //  */
    // @RabbitListener(queues = StatusDeadLetterQueueConsumer.DEAD_QUEUE)
    // public void listenDeadQueueFour(int msg) {
    //     log.info("接收到死信队列消息四:{}", msg);
    // }
}

生产者方法

package com.erligang.framework.mq;

import com.erligang.common.utils.DateUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Date;

/**
 * li
 *
 * @Author: li
 */
@Component
@Slf4j
public class RabbitMqSendClient {
    @Autowired
    private RabbitTemplate rabbitTemplate;


    /**
     * @param exchange       交换机
     * @param rounteKey      路由key
     * @param message        发送的消息
     * @param milliseconds  过期时间-毫秒
     * @return
     * @description 死信队列发送
     */
    public void sendDeadLetterQueue(String exchange, String rounteKey, Object message, long milliseconds) {
        log.info("死信队列已发送:{}秒后执行:内容:{}", milliseconds / 1000, message);
        rabbitTemplate.convertAndSend(exchange, rounteKey, message,
            // 设置消息过期时间： 单位：毫秒
            res -> {
                res.getMessageProperties().setExpiration(String.valueOf(milliseconds));// 过期时间
                res.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT); // 持久化
                // 返回消息对象
                return res;
            });
    }

}

Controller层

package com.erligang.project.test;

import com.erligang.common.utils.DateUtils;
import com.erligang.framework.mq.RabbitMqSendClient;
import com.erligang.framework.mq.StatusDeadLetterQueueConsumer;
import com.erligang.framework.web.domain.AjaxResult;
import com.erligang.project.utils.LambdaUtils;
import com.google.common.collect.Maps;
import lombok.Data;
import org.apache.commons.compress.utils.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 方式一 单个订单发送
 * @Author: li
 */
@RestController
@RequestMapping("/pre/mq")
public class RabbitMqOrderTest {
    @Autowired
    private RabbitMqSendClient rabbitMqSendClient;

    private static final Logger log = LoggerFactory.getLogger(RabbitMqOrderTest.class);
    // 模拟订单
    public static Map<Long, String> orderInfo = Maps.newHashMap();
    // 模拟支付信息
    public static Map<Long, String> orderPayInfo = Maps.newHashMap();

    // 创建订单
    @GetMapping("/createOrder")
    public AjaxResult createOrder(Long orderId) {
        orderInfo.put(orderId, "待支付");
        rabbitMqSendClient.sendDeadLetterQueue(StatusDeadLetterQueueConsumer.FORMAL_EXCHANGE, StatusDeadLetterQueueConsumer.FORMAL_ROUNTE_KEY, orderId, 30000);
        return AjaxResult.success("创建成功");
    }
    
    // 模拟支付订单
    @GetMapping("/payOrder")
    public AjaxResult payOrder(Long orderId) {
        orderInfo.put(orderId, "已支付");
        orderPayInfo.put(orderId, "已支付");
        return AjaxResult.success("支付成功");

    }
    
    // 获取订单状态
    @GetMapping("/getOrder")
    public AjaxResult getOrder(Long orderId) {
        String s = orderInfo.get(orderId);
        return AjaxResult.success("订单号:" + orderId + " 订单状态:" + s);
    }
}