springboot和rabbitmq整合实现普通任务和延时任务

最新推荐文章于 2024-08-13 19:06:38 发布
最新推荐文章于 2024-08-13 19:06:38 发布
阅读量2.2k 收藏 8
点赞数 1
分类专栏： 消息中间件 springboot 文章标签： springboot rabbitmq 延时任务 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzzgd_666/article/details/82227612
版权

前言

在之前的文章中,

rabbitmq的延时任务和普通任务

已经介绍过了普通的方式使用rabbitmq来实现普通任务和延时任务的调度,不过现在基本都会用springboot,所以这里还是来写一篇springboot使用rabbitmq的

一 普通任务

安装erlang,安装rabbitmq,这里就省略了

概念:queue,生产者,消费者,exchange,routeKey

生产者是消息发送者,消费者是消息接收者.这两者中间有exchange和queue.消费者需要标注queue来获取queue中的消息,exchange也就是相当于交换机,到底把哪个生产者的消息发给哪个消费者,这需要exchange根据routekey来定,比如routeKey=”key.a”和queue=”queue_a”绑定了,那么生产者必须在参数里面携带”key.a”才能发送到”queue_a”中去.

Routing key是以小数点隔开的字符串, TopicExchange模式下, 它有,#两个通配符可以用,其中代表一个单词,#代表0个或多个, 比如routeKey=”key.*”,那么生产者带的参数为”key.a”,”key.b”都可以发到”queue_a”

二 搭建springboot工程

直接使用idea的骨架生产就好了,然后pom.xml依赖如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zgd.rabbitmq</groupId>
    <artifactId>springboot-rabbitmq-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>Spring Boot Blank Project (from https://github.com/making/spring-boot-blank)</name>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <start-class>com.zgd.rabbitmq.App</start-class>
        <java.version>1.8</java.version>
        <lombok.version>1.14.8</lombok.version>
        <springboot.version>2.0.4.RELEASE</springboot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${springboot.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>${springboot.version}</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>2.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
            <version>${springboot.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <dependencies>
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>springloaded</artifactId>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

</project>

这里要注意版本的一致,spring-boot-test和springboot的版本要一致

三 代码

3.1 配置类

写一个配置类,配置queue,exchange,绑定binding

在这个类中,定义了三个队列topic.queue_a,topic.queue_b,topic.queue_like,定义了一个exchangeexchange,分别绑定了三个routeKey topic.queue_a,topic.queue_b和topic.*

注意这里bindingExchange这三个方法中的入参Queue_B和exchange都是上面声明的方法名,不是变量名,且需要和方法名一致才能确定绑定的是哪个queue和exchange

而且只在Topic Exchange下,通配routeKey才生效!!!

package com.zgd.rabbitmq.config;

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

/**
 * @Author: zgd
 * @Date: 18/08/30 15:18
 * @Description: 队列配置
 */
@Configuration
public class RabbitConfig {

  final static String QUEUE_A = "topic.queue_a";

  final static String QUEUE_B = "topic.queue_b";

  //模糊队列,满足topic.*的都会发送到这个队列
  final static String QUEUE_LIKE = "topic.queue_like";


  //------------队列queue只和消费者直接对接-----------


  @Bean
  public Queue Queue_A() {
    return new Queue(QUEUE_A);
  }

  @Bean
  public Queue Queue_B() {
    return new Queue(QUEUE_B);
  }

  @Bean
  public Queue Queue_Like() {
    return new Queue(QUEUE_LIKE);
  }

  //--------------生产者通过exchange交换器来决定发送到哪个queue-------------

  @Bean
  TopicExchange exchange() {
    return new TopicExchange("exchange");
  }

  //-------------绑定exchange和queue,通过with()中的值来作为绑定key,让exchange知道生产者的消息该分配到哪条queue-----------------

  /**
   * 使用"topic.queue_a"来作为key来匹配生产者和队列,如果生产者使用这个key,就会经过exchange发到QUEUE_A队列
   * @param Queue_A
   * @param exchange
   * @return
   */
  @Bean
  //入参中的Queue_A和exchange是方法名,不是参数名
  Binding bindingExchangeA(Queue Queue_A, TopicExchange exchange) {
    return BindingBuilder.bind(Queue_A).to(exchange).with("topic.queue_a");
  }

  /**
   * 使用"topic.queue_b"来作为key来匹配生产者和队列,如果生产者使用这个key,就会经过exchange发到QUEUE_B队列
   * @param Queue_B
   * @param exchange
   * @return
   */
  @Bean
  Binding bindingExchangeB(Queue Queue_B, TopicExchange exchange) {
    return BindingBuilder.bind(Queue_B).to(exchange).with("topic.queue_b");
  }

  /**
   * 使用"topic.#"来作为key来模糊匹配,生产者使用的key是topic.开头的,都会经过exchange发到QUEUE_LIKE队列
   * @param Queue_Like
   * @param exchange
   * @return
   */
  @Bean
  Binding bindingExchangeLike(Queue Queue_Like, TopicExchange exchange) {
    return BindingBuilder.bind(Queue_Like).to(exchange).with("topic.*");
  }
}
3.2 生产者

this.rabbitTemplate.convertAndSend()三个参数,第一个是exchange名,第二个是routeKey,第三个是消息

其中sendMessageA和sendMessageB都是一对一,routeKey和queueName一样,完全匹配,sendMessageA只会向topic.queue_a队列发送,b则对应

sendMessageLike中,因为刚刚在配置类配置了routeKey topic.*,所以是一对多,所有符合topic.*的都会发到Queue_Like队列中去,包括上面的sendMessageA和sendMessageB

package com.zgd.rabbitmq.producer;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @Author: zgd
 * @Date: 18/08/30 15:21
 * @Description: 生产者
 */
@Component
public class RabbitmqProducer {

  @Autowired
  private AmqpTemplate rabbitTemplate;

  public void sendMessageA(String msg) {
    String context = "[生产者A发送消息]\t"+new Date().toLocaleString() + "\t------------> "+msg  ;
    System.out.println(context);
    this.rabbitTemplate.convertAndSend("exchange","topic.queue_a", msg);
  }

  public void sendMessageB(String msg) {
    String context = "[生产者B发送消息]\t"+new Date().toLocaleString() + "\t------------> "+msg  ;
    System.out.println(context);
    this.rabbitTemplate.convertAndSend("exchange","topic.queue_b", msg);
  }

  public void sendMessageLike(String msg) {
    String context = "[生产者like发送消息]\t"+new Date().toLocaleString() + "\t------------> "+msg  ;
    System.out.println(context);
    this.rabbitTemplate.convertAndSend("exchange","topic.aa",msg);
  }

}
3.3 消费者

使用注解@RabbitHandler和@RabbitListener来指定一个queue,监听这个queue,可以监听多个queue消费

package com.zgd.rabbitmq.consumer;

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

import java.util.Date;

/**
 * @Author: zgd
 * @Date: 18/08/30 15:22
 * @Description: 消费者
 */

@Component
public class RabbitmqConsumer {


  @RabbitHandler
  @RabbitListener(queues = "topic.queue_a")
  public void processA(String msg) {
    System.out.println("[消费者queue_a收到消息]:\t" + new Date().toLocaleString()+"\t------------> "+ msg);
  }

  @RabbitHandler
  @RabbitListener(queues = "topic.queue_b")
  public void processB(String msg) {
    System.out.println("[消费者queue_b收到消息]:\t" + new Date().toLocaleString()+"\t------------> "+ msg);
  }

  @RabbitHandler
  @RabbitListener(queues = "topic.queue_like")
  public void processLike(String msg) {
    System.out.println("[模糊匹配的消费者queue_like收到消息]:\t" + new Date().toLocaleString()+"\t------------> "+ msg);
  }
}
3.4 测试
package com.zgd.rabbitmq.test;

import com.zgd.rabbitmq.producer.DelayRabbitmqProducer;
import com.zgd.rabbitmq.producer.RabbitmqProducer;
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;

import java.util.concurrent.TimeUnit;

/**
 * @Author: zgd
 * @Date: 18/08/30 15:28
 * @Description:
 */

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

  @Autowired
  private RabbitmqProducer producer;


  @Test
  public void sendMsg() throws Exception {
    producer.sendMessageA("AAAAAAAAA");
    producer.sendMessageB("BBBBBBBBB");
    producer.sendMessageLike("********");
  }
}

这里写图片描述
可以看到模糊匹配,也就是topic模式下,队列topic.queue_like在用topic.*的routeKey与exchange绑定后,生产者发送topic.queue_a, topic.queue_b, topic.queue_like的消息都经过topic.queue_like,被processLike消费者消费了, 而processA和processB都是消费各自的消息

四 延时任务

4.1 配置类修改

增加一个样式的队列,exchange

//-----------------------延时任务--------------------------
  /**
   * 延时任务的exchange
   * @return
   */
  @Bean
  public DirectExchange  delayExchange() {
    DirectExchange directExchange = new DirectExchange("delay_exchange", true, false);
    /**只需简单一步开启延时消息，md找了好久，原来这么简单*/
    directExchange.setDelayed(true);
    return directExchange;
  }

  /**
   * 延时任务的队列
   * @return
   */
  @Bean
  public Queue delayQueue() {
    Queue queue = new Queue("queue.delay");
    return queue;
  }


  @Bean
  Binding binding(Queue delayQueue,DirectExchange delayExchange) {
    return BindingBuilder.bind(delayQueue).to(delayExchange).with("delay.abc");

  }

注意这里不是用的TopicExchange了,而是DirectExchange

4.2 生产者
package com.zgd.rabbitmq.producer;

import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.Timer;
import java.util.concurrent.TimeUnit;

/**
 * @Author: zgd
 * @Date: 18/08/30 17:46
 * @Description: 延时任务生产者
 */
@Component
public class DelayRabbitmqProducer {

  @Autowired
  private AmqpTemplate rabbitTemplate;

  /**
   * 发送延时消息
   * @param msg
   * @param millisecond
   */
  public void sendDelay(String msg, final Integer millisecond){
    String context = "[延时任务发送消息]\t"+new Date().toLocaleString() + "\t------------> "+msg  ;
    System.out.println(context);
    rabbitTemplate.convertAndSend("delay_exchange", "delay.abc", msg, new MessagePostProcessor() {
      @Override
      public Message postProcessMessage(Message message) throws AmqpException {
        message.getMessageProperties().setHeader("x-delay",millisecond);
        return message;
      }
    });
  }
}
4.3 消费者
@RabbitHandler
  @RabbitListener(queues = "queue.delay")
  public void processDelay(String msg) {
    System.out.println("[延时任务收到消息]:\t" + new Date().toLocaleString()+"\t------------> "+ msg);
  }
4.4 测试
 @Autowired
  private DelayRabbitmqProducer delayProducer;

 @Test
  public void sendDelayMsg() throws Exception {
    delayProducer.sendDelay("延时消息",10000);
    while (true){

    }
  }

这里写图片描述
测试成功

代码:
https://github.com/zzzgd/demo-rabbitmq/tree/master/springboot-rabbitmq-demo

zzzgd816
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot整合RabbitMQ实现延时队列
PGL2009的博客
12-12 2274
组件的版本 SpringBoot : V2.5.5 RabbitMQ: 3.9.9 延时队列 延时队列的典型应用场景，例如购买火车票，下单占座后20分钟内未支付的订单会被强制取消，避免在余票紧张的情况下，车票一直被占用，其他人无法购买。还有电商平台，客户下单后，订单进入购物车，如果购物车内的订单超过特定时间未支付，则会失效，回滚库存。 RabbitMQ实现延时队列 利用 RabbitMQ 做延时队列是比较常见的一种方式，而实际上RabbitMQ 自身并没有直接支持提供延迟队列功能，而是通过 RabbitMQ
springboot执行延时任务之DelayQueue的使用详解
08-25
DelayQueue是一个无界阻塞队列，只有在延迟期满时，才能从中提取元素。这篇文章主要介绍了springboot执行延时任务-DelayQueue的使用,需要的朋友可以参考下
springboot使用RabbitMQ实现延时任务
weixin_30496751的博客
05-16 146
延时队列顾名思义，即放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。那么，为什么需要延迟消费呢？我们来看以下的场景 订单业务： 在电商/点餐中，都有下单后 30 分钟内没有付款，就自动取消订单。短信通知： 下单成功后 60s 之后给用户发送短信通知。失败重试： 业务操作失败后，间隔一定的时间进行失败重试。 本文基于springboot，使用rabbitmq_delaye...
SpringBoot 整合 RabbitMQ 实现延迟消息
最新发布
白白白鲤鱼的博客
08-13 1504
SpringBoot 整合 RabbitMQ 实现延迟消息
springboot+rabbitmq实现延时任务
溯夜Alex的博客
01-28 634
springboot+rabbitmq实现延时任务rabbitmq部署springboot集成 rabbitmq部署 这里采用了docker直接部署 1、拉取镜像 docker pull rabbitmq:management 2、启动镜像 docker run -dit --name Myrabbitmq -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 rabbitmq:m
SpringBoot整合RabbitMQ实现消息延迟队列
代码蒋的博客
06-06 1394
Slf4j@Data@Builder/*** 商户订单号*//*** 支付宝订单号*/@Slf4j@Component@Autowired//为true,则交换机处理消息到路由失败，则会返回给生产者 配置文件指定，则这里不需指定//开启强制消息投递（mandatory为设置为true），但消息未被路由至任何一个queue，则回退一条消息});log.info("===============延时队列生产消息====================");
Springboot集成rabbitmq 实现延时队列
xiaoguangtouqiang的博客
06-01 5266
延时队列的需求出现在消息需要延时处理的场景。比如下单之后在30分钟内不支付，超过时间，我们应该去修改订单的状态变成已取消，收回库存；或者设置了某个事情不需要现在处理，要一定时间段后去处理，这种情况都需要用到延时队列； 延时队列的实现方式有很多中，这里只介绍rabbitmq的实现方式；之所以rabbitmq可以做为延时队列是跟他的两个特性分不开的； 1>Ti...
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码
06-29
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码。参考博客：https://blog.csdn.net/qq_29914837/article/details/94070677
SpringBoot整合RabbitMQ实现消息的发送与接收，确认消息，延时消息
m0_66557301的博客
06-12 1883
https://github.com/erlang/otp/releases/tag/OTP-25.0 https://www.rabbitmq.com/install-windows.html 打开RabbitMQ Command Prompt 进入命令行 https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases 将 ez文件拷贝到安装目录rabbitmq_server-3.10.2plugins下 这里我直接用我
SpringBoot + RabbitMQ 做延时队列
qq_44680160的博客
12-19 1030
SpringBoot + RabbitMQ 做延时队列
Spring Boot+RabbitMQ 基于死信队列和插件实现延迟队列详解
huangjhai的博客
10-07 2157
延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用 RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正 确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为 单个节点挂掉导致延时队列不可用或者消息丢失。
SpringBoot整合Rabbitmq实现延时发送消息
qq_39521532的博客
01-31 552
SpringBoot整合Rabbitmq实现延时发送消息说明正文概述导入依赖配置类生产者发送消息消费者打印消息测试 说明 参考链接：布碗RabbitMQ学习(十三) 小目标青年Springboot 整合RabbitMq 正文 概述 由mq的死信队列实现 DLX（Dead Letter Exchange），死信交换器。当队列中的消息被拒绝、或者过期会变成死信，死信可以被重新发布到另一个交换器，这个交换器就是DLX，与DLX绑定的队列称为死信队列。 通过"x-dead-letter-exchange"设置到期
RabbitMq结合springBoot实现延时任务
weixin_45441597的博客
08-30 489
rabbitMQ延时任务的实现思想：rabbitmq实现延时任务本质就是使用 "过期时间" 和 "死信队列"实现的，首先定义一个死信队列和死信队列的消费者来接收我们用来延时队列的过期消息并进行消费，在定义一个延时用的队列存储我们的信息，这个延时队列没有消费者，所以消息一直存在这个队列中，当我们设置了过期时间为24小时后，每个消息24小时候就会过期，进入到死信队列中，死信队列中有消费者，只要一过期就会被死信队列的消费者消费，就实现了延时任务。
rabbitMQ学习笔记(三) 消息确认与公平调度消费者
热门推荐
is_zhoufeng的专栏
08-17 3万+
从本节开始称Sender为生产者 ， Recv为消费者 一、消息确认 为了确保消息一定被消费者处理，rabbitMQ提供了消息确认功能，就是在消费者处理完任务之后，就给服务器一个回馈，服务器就会将该消息删除，如果消费者超时不回馈，那么服务器将就将该消息重新发送给其他消费者 默认是开启的，在消费者端通过下面的方式开启消息确认,  首先将autoAck自动确认关闭，等我们的任务执行完成之后，
Springboot集成RabbitMQ
仗剑行于江湖，执笔记江湖事。
07-17 1443
最终实现效果如下，每三秒打印消息。 首先打开IDEA,创建maven java project。 在pom.xml添加依赖，其完整源码如下。<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSc
springboot单机版延迟任务
在写bug的路上越走越远
05-09 907
在实际开发中经常能遇到一些补偿措施使用延迟任务来做，有些可以使用定时任务来实现，但是有些需要有固定的周期规律，所以需要延迟指定时间后搞些事情。 但是呢，本来开发的一个单机很low的一个项目，没有必要引用一些其他的中间件，所以就做了个简单的延迟任务小样，这个是延迟给第三方系统发送通知的业务。 使用的是jdk里面的Delayed作为任务队列，使用过期时间做排序，这里要说一下这并不是简单的链表，实际是带排序的链表。 package xxx; import lombok.Data; import jav
SpringCloud微服务项目实战 - 6.延迟任务
yuan
01-17 867
基于SpringCloud框架的微服务项目，新闻项目，,该项目是新闻头条的新闻资讯类项目; 平台涵盖 用户移动端App、媒体人发布文章的后台系统、后台管理系统； 技术栈全面，包括用户层、CDN（HTML、CSS、JSON、Video...）、LB（Nginx）、视图层（Vue、WEEX、Echarts）、网关（SpringCloud Gateway）、服务层（中间件、微服务、Nacos、云计算）、数据层（Mysql、MongoDB、Redis、中间件、OSS）
RabbitMQ小记（二）——公平调度vs循环调度
金华松软的我
03-02 833
公平调度 vs 轮询调度 默认情况下，RabbitMQ将按顺序将每个消息发送给下一个使用者。平均每个消费者将获得相同数量的消息。这种分发消息的方式称为循环。在这种模式下，调度不一定像我们希望的那样工作。例如，在两个工人（消费者）的情况下，当信息很多或很少，会出现一个工人将不断忙碌，另一个将几乎不做任何工作的情况。RabbitMQ 对此一无所知，仍然会均匀地分发消息。这是因为RabbitMQ 只是在...
SpringBoot整合RabbitMQ实现延迟队列实战
"本文将介绍如何使用SpringBoot与RabbitMQ结合实现延迟队列，包括延迟队列的概念、应用场景以及具体实现方式，涉及到RabbitMQ的Time-To-Live Extensions和Dead Letter Exchanges特性。" 在分布式系统中，延迟队列是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值