Spring Boot RabbitMQ 延迟消息实现完整版

概述


曾经去网易面试的时候，面试官问了我一个问题，说

下完订单后，如果用户未支付，需要取消订单，可以怎么做

我当时的回答是，用定时任务扫描DB表即可。面试官不是很满意，提出：

用定时任务无法做到准实时通知，有没有其他办法？

我当时的回答是：

可以用队列，订单下完后，发送一个消息到队列里，并指定过期时间，时间一到，执行回调接口。

面试官听完后，就不再问了。其实我当时的思路是对的，只不过讲的不是很专业而已。专业说法是利用延迟消息。

其实用定时任务，确实有点问题，原本业务系统希望10分钟后，如果订单未支付，就马上取消订单，并释放商品库存。但是一旦数据量大的话，就会加长获取未支付订单数据的时间，部分订单就做不到10分钟后取消了，可能是15分钟，20分钟之类的。这样的话，库存就无法及时得到释放，也就会影响成单数。而利用延迟消息，则理论上是可以做到按照设定的时间，进行订单取消操作的。

目前网上关于使用RabbitMQ实现延迟消息的文章，大多都是讲如何利用RabbitMQ的死信队列来实现，实现方案看起来都很繁琐复杂,并且还是使用原始的RabbitMQ Client API来实现的，更加显得啰嗦。

Spring Boot 已经对RabbitMQ Client API进行了包装，使用起来简洁很多，下面详细介绍一下如何利用rabbitmq_delayed_message_exchange 插件和Spring Boot来实现延迟消息。

软件准备

erlang

请参考Win10下安装erlang

本文使用的版本是:

Erlang 20.3

RabbitMQ

请参考win10下安装rabbitmq

本文使用的是window版本的RabbitMQ，版本号是:

3.7.4

rabbitmq_delayed_message_exchange插件

插件下载地址：

http://www.rabbitmq.com/community-plugins.html

打开网址后，ctrl + f，搜索rabbitmq_delayed_message_exchange。 

千万记住，一定选好版本号，由于我使用的是RabbitMQ 3.7.4,因此对应的rabbitmq_delayed_message_exchange插件也必须选择3.7.x的。

如果没有选对版本，在使用延迟消息的时候，会遇到各种各样的奇葩问题，而且网上还找不到解决方案。我因为这个问题，折腾了整整一个晚上。请牢记，要选对插件版本。

下载完插件后，将其放置到RabbitMQ安装目录下的plugins目录下，并使用如下命令启动这个插件：

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

如果启动成功会出现如下信息：

The following plugins have been enabled: 
rabbitmq_delayed_message_exchange

启动插件成功后，记得重启一下RabbitMQ，让其生效。

集成RabbitMQ


这个就非常简单了,直接在maven工程的pom.xml文件中加入

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  • 1
  • 2
  • 3
  • 4

Spring Boot的版本我使用的是2.0.1.RELEASE.

接下来在application.properties文件中加入redis配置：

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
  • 1
  • 2
  • 3
  • 4

定义ConnectionFactory和RabbitTemplate


也很简单，代码如下：

package com.mq.rabbitmq;

import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "spring.rabbitmq")
public class RabbitMqConfig {
    private String host;
    private int port;
    private String userName;
    private String password;

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(host,port);
        cachingConnectionFactory.setUsername(userName);
        cachingConnectionFactory.setPassword(password);
        cachingConnectionFactory.setVirtualHost("www.baohuayule.com/");
        cachingConnectionFactory.setPublisherConfirms(true);
        return cachingConnectionFactory;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(www.hjha178.com/) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory());
        return rabbitTemplate;
    }

    public String getHost(www.taohuayuan178.com) {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort(www.thd178.com/) {
        return port;
    }

    public void setPort(int port) {
        this.port = www.baohuayule.net port;
    }

    public String getUserName(www.leyouzaixan.cn) {
        return userName;
    }

    public void setUserName(www.micheng178.com String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return www.wanmeiyuele.cn password;
    }

    public void setPassword(String password) {
        this.password = password;

Exchange和Queue配置

package com.mq.rabbitmq;

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

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

@Configuration
public class QueueConfig {

    @Bean
    public CustomExchange delayExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange("test_exchange", "x-delayed-message",true, false,args);
    }

    @Bean
    public Queue queue() {
        Queue queue = new Queue("test_queue_1", true);
        return queue;
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(delayExchange()).with("test_queue_1").noargs();

这里要特别注意的是，使用的是CustomExchange,不是DirectExchange，另外CustomExchange的类型必须是x-delayed-message。

实现消息发送

package com.mq.rabbitmq;

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

import java.text.SimpleDateFormat;
import java.util.Date;

@Service
public class MessageServiceImpl {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMsg(String queueName,String msg) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("消息发送时间:"+sdf.format(new Date()));
        rabbitTemplate.convertAndSend("test_exchange", queueName, msg, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setHeader("x-delay",3000);
                return message;

注意在发送的时候，必须加上一个header

x-delay

在这里我设置的延迟时间是3秒。

消息消费者

package com.mq.rabbitmq;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

@Component
public class MessageReceiver {

    @RabbitListener(queues = "test_queue_1")
    public void receive(String msg) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("消息接收时间:"+sdf.format(new Date()));
        System.out.println("接收到的消息:"+msg);

运行Spring Boot程序和发送消息


直接在main方法里运行Spring Boot程序,Spring Boot会自动解析MessageReceiver类的。

接下来只需要用Junit运行一下发送消息的接口即可。

package com.mq.rabbitmq;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitmqApplicationTests {

    @Autowired
    private MessageServiceImpl messageService;

    @Test
    public void send() {
        messageService.sendMsg("test_queue_1","hello i am delay msg");
    }

运行完后，可以看到如下信息：

原文地址：https://www.cnblogs.com/qwangxiao/p/8997571.html

时间： 2024-10-30 10:15:11

Spring Boot RabbitMQ 延迟消息实现完整版的相关文章

spring boot Rabbitmq集成,延时消息队列实现

本篇主要记录Spring boot 集成Rabbitmq,分为两部分, 第一部分为创建普通消息队列, 第二部分为延时消息队列实现: spring boot提供对mq消息队列支持amqp相关包,引入即可: [html] view plain copy <!-- rabbit mq --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-

spring boot rabbitMQ 的 hello world

今天公司有一个需求,是实现多个服务器中的运维信息的集中管理.由于需要实现运维信息的收集不影响各服务器上服务的开销,并且能快速开发,所以选择了消息队列这种技术方式. 消息队列有一个好处,是可以将消息异步传递,不对主服务造成开销,运维信息,是可以异步的在运维服务器中处理,并不影响到主服务. 现在java中,使用spring boot开发,方便高效,所以,选择了spring boot支持的rabbit MQ. 搞开发,学技术,最好的方式是从最简单的例子出发,就是常说的hello world,所以有了以

spring boot下WebSocket消息推送

WebSocket协议 WebSocket是一种在单个TCP连接上进行全双工通讯的协议.WebSocket通信协议于2011年被IETF定为标准RFC 6455,并由RFC7936补充规范.WebSocket API也被W3C定为标准. WebSocket使得客户端和服务器之间的数据交换变得更加简单,允许服务端主动向客户端推送数据.在WebSocket API中,浏览器和服务器只需要完成一次握手,两者之间就直接可以创建持久性的连接,并进行双向数据传输 STOMP协议 STOMP是面向文本的消息传

Spring Kafka和Spring Boot整合实现消息发送与消费简单案例

本文主要分享下Spring Boot和Spring Kafka如何配置整合,实现发送和接收来自Spring Kafka的消息. 先前我已经分享了Kafka的基本介绍与集群环境搭建方法.关于Kafka的介绍请阅读Apache Kafka简介与安装(一),关于Kafka安装请阅读Apache Kafka安装,关于Kafka集群环境搭建请阅读Apache Kafka集群环境搭建 .这里关于服务器环境搭建不在赘述. Spring Kafka整合Spring Boot创建生产者客户端案例 创建一个kafk

Spring Boot+STOMP解决消息乱序问题

当我们使用Spring Boot+websocket进行前后端进行通信时,我们需要注意:服务器可以随时向客户端发送消息.默认的情况下,不保证:服务器发送的消息与到达客户端的消息的顺序是一致的.可能先发送的消息后到,后发送的消息先到.(注意:两个消息发送的时间差不多,不能相差太多,不然就是顺序的了.一般一秒以下都会造成乱序). 如果你的需求需要服务器向客户端发送的消息是按照顺序的.请你往下看,如果你的需求不要求服务器向客户端发送的消息是顺序的.就没有必要看了. 我们先说以下造成的原因:就是webs

详细介绍Spring Boot + RabbitMQ实现延迟队列

https://www.jianshu.com/p/2716fb975720 https://blog.csdn.net/skiof007/article/details/80914318 原文地址:https://www.cnblogs.com/maohuidong/p/11741908.html

模拟消息对话框完整版

CSS: ul,li{list-style: none;padding: 0;margin: 0;} .cont{ width: 527px; height: 600px; margin:30px auto; overflow: hidden; border: 1px solid #ccc; } #div1{ width:527px; height: 499px; border-bottom: 1px solid #ccc; position: relative; overflow-y:scro

spring boot rabbitmq集成

rabbitmq在centos 6/7下的安装请参考:https://www.cnblogs.com/zhjh256/p/10469732.html 由于rabbitmq不支持区分消费者组和消费者,因此建议使用kafka. 原文地址:https://www.cnblogs.com/zhjh256/p/10469754.html

Spring Boot 实现 RabbitMQ 延迟消费和延迟重试队列

本文主要摘录自:详细介绍Spring Boot + RabbitMQ实现延迟队列 并增加了自己的一些理解,记录下来,以便日后查阅. 项目源码: spring-boot-rabbitmq-delay-queue 实现 stream-rabbitmq-delay-queue 实现 背景 何为延迟队列? 顾名思义,延迟队列就是进入该队列的消息会被延迟消费的队列.而一般的队列,消息一旦入队了之后就会被消费者马上消费. 延迟队列能做什么?延迟队列多用于需要延迟工作的场景.最常见的是以下两种场景: 延迟消费