springboot 集成 rabbitmq队列、广播、主题模式，消费者手动提交

最新推荐文章于 2023-12-15 19:57:03 发布
最新推荐文章于 2023-12-15 19:57:03 发布
阅读量976 收藏 6
点赞数 1
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36239599/article/details/107467745
版权

1.rabbitmq安装

rabbitmq docker安装，包括集群

2.springboot 集成 rabbitmq

2.1创建springboot项目

略

2.2引入依赖

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

2.3application.yml配置

  1. 生产者
spring:
	rabbitmq:
		#rabbitmq ip地址
	    host: 192.168.20.105
	    #rabbitmq 端口
	    port: 5672
	    #rabbitmq 用户名
	    username: admin
	    #rabbitmq 密码
	    password: admin
	    #确认消息已发送到交换机(Exchange)
	    publisher-confirms: true
	    #确认消息已发送到队列(Queue)
	    publisher-returns: true
  1. 消费者
spring:
	rabbitmq:
	    host: 192.168.20.105
	    port: 5672
	    username: admin
	    password: admin
	    #配置消费者一次接收一条数据，多劳多得
	    listener:
	      simple:
	        prefetch: 1
	        acknowledge-mode: manual
	      direct:
	        prefetch: 1
	        acknowledge-mode: manual

2.4队列模式

顾名思义就是，exchange和queue进行一对一绑定
队列示意图

2.4.1生产者

  1. 配置DirectRabbitConfig，让exchange和queue进行绑定
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DirectRabbitConfig {
	// 队列 起名：TestDirectQueue
	@Bean
	public Queue TestDirectQueue() {
		// durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
		// exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
		// autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
		// 一般设置一下队列的持久化就好,其余两个就是默认false
		return new Queue("TestDirectQueue", true);
	}

	// Direct交换机 起名：TestDirectExchange
	@Bean
	public DirectExchange TestDirectExchange() {
		// return new DirectExchange("TestDirectExchange",true,true);
		return new DirectExchange("TestDirectExchange", true, false);
	}

	// 绑定 将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
	// Binding binding = BindingBuilder.bind(queue).to(exchange).with(routing_key)
	@Bean
	public Binding bindingDirect() {
		return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
	}
}
  1. 给rabbitmq发送数据
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 消息队列
 *
 * @author Administrator
 */
@RestController
public class SendControllerWork {

    @Autowired
    RabbitTemplate rabbitTemplate; 

    @GetMapping("/send")
    public String sendDirectMessage() {
        String messageId = UUID.randomUUID().toString();
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        // 将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";
    }

}

2.4.2消费者

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class TestDirectReceiver {

    @RabbitListener(bindings = @QueueBinding(value = @Queue(name = "TestDirectQueue", durable = "true"),
            exchange = @Exchange(name = "TestDirectRouting", ignoreDeclarationExceptions = "true")))
    public void process(Map testMessage) {
        System.out.println("DirectReceiver消费者收到消息  : " + testMessage.toString());
    }

}

2.5广播模式

顾名思义就是，exchange和一堆queue进行绑定
广播模式示意图

2.5.1生产者

  1. 配置FanoutRabbitConfig，把exchange和queueA、queueB、queueC绑定
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutRabbitConfig {

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

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

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

	@Bean
	public FanoutExchange Fanoutchange() {
		return new FanoutExchange("FanoutExchange", true, false);
	}

	@Bean
	public Binding bindingFanoutA() {
		return BindingBuilder.bind(FanoutQueueA()).to(Fanoutchange());
	}

	@Bean
	public Binding bindingFanoutB() {
		return BindingBuilder.bind(FanoutQueueB()).to(Fanoutchange());
	}

	@Bean
	public Binding bindingFanoutC() {
		return BindingBuilder.bind(FanoutQueueC()).to(Fanoutchange());
	}
}
  1. 给rabbitmq发送数据
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SendControllerFanout {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("sendFanout")
    public String send() {
        rabbitTemplate.convertAndSend("FanoutExchange", "", "这是一个fanout广播模式");
        return "ok";
    }
}

2.5.2消费者

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class FanoutRece {

	@RabbitListener(bindings = @QueueBinding(value = @Queue(value = "FanoutQueueA", durable = "true"), 
		exchange = @Exchange(value = "FanoutExchange", ignoreDeclarationExceptions = "true", type = ExchangeTypes.FANOUT)))
	public void listen1(String msg) {
		System.out.println("订阅模式A 接收到消息：" + msg);
	}

	@RabbitListener(bindings = @QueueBinding(value = @Queue(value = "FanoutQueueB", durable = "true"), 
		exchange = @Exchange(value = "FanoutExchange", ignoreDeclarationExceptions = "true", type = ExchangeTypes.FANOUT)))
	public void listen2(String msg) {
		System.out.println("订阅模式B 接收到消息：" + msg);
	}

	@RabbitListener(bindings = @QueueBinding(value = @Queue(value = "FanoutQueueC", durable = "true"), 
		exchange = @Exchange(value = "FanoutExchange", ignoreDeclarationExceptions = "true", type = ExchangeTypes.FANOUT)))
	public void listen3(String msg) {
		System.out.println("订阅模式C 接收到消息：" + msg);
	}
}

2.6主题模式

顾名思义就是，exchange和一堆queue，根据规则进行绑定，规则基本基于routingKey名称

routingKeyBindingBuilder
topic.#topic.xxxx , topic.xxxx.xxxx
topic.*topic.xxxx
topic..topic.xxxx.xxx

主题示意图

2.6.1生产者

  1. 配置TopicRabbitConfig
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TopicRabbitConfig {

	@Bean
	public Queue queueA() {
		return new Queue("topic.queueA",true);
	}

	@Bean
	public Queue queueB() {
		return new Queue("topic.queueB",true);
	}

	@Bean
	public TopicExchange exchange(){
		return new TopicExchange("topicExChange");
	}
	
	@Bean
	public Binding bindExchangeMessage(){
		return BindingBuilder.bind(queueA()).to(exchange()).with("topic.queueA");
	}
	
	@Bean
	public Binding bindExchangeMessage2(){
		return BindingBuilder.bind(queueB()).to(exchange()).with("topic.#");
	}
	
}
  1. 发送消息给rabbitmq
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 消息队列
 * 
 * @author Administrator
 *
 */
@RestController
public class SendControllerTopic {

	@Autowired
	private RabbitTemplate rabbitTemplate;

	@GetMapping("/sendTopicMessage1")
	public String sendTopicMessage1() {
		String messageId = String.valueOf(UUID.randomUUID());
		String messageData = "message: M A N ";
		String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
		Map<String, Object> manMap = new HashMap<>();
		manMap.put("messageId", messageId);
		manMap.put("messageData", messageData);
		manMap.put("createTime", createTime);
		rabbitTemplate.convertAndSend("topicExchange", "topic.queueA", manMap);
		return "ok";
	}

	@GetMapping("/sendTopicMessage2")
	public String sendTopicMessage2() {
		String messageId = String.valueOf(UUID.randomUUID());
		String messageData = "message: woman is all ";
		String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
		Map<String, Object> womanMap = new HashMap<>();
		womanMap.put("messageId", messageId);
		womanMap.put("messageData", messageData);
		womanMap.put("createTime", createTime);
		rabbitTemplate.convertAndSend("topicExchange", "topic.queueB", womanMap);
		return "ok";
	}
}

2.6.2消费者

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

@Component
public class TopicReceiver {

	@RabbitListener(queues="topic.queueA")
	public void rece(Map msg){
		System.out.println("TopicTotalReceiver1消费者收到消息  : " + msg.toString());
	}
	@RabbitListener(queues="topic.queueB")
	public void rece2(Map msg){
		System.out.println("TopicTotalReceiver2消费者收到消息  : " + msg.toString());
	}
}

3.复杂行为

身为一个资深的程序员，仅仅是会推送接收，这样是谈不上会用rabbitmq的，在生产环境我们需要考虑数据丢失，服务器停机的问题…

需要解决的问题

  1. 数据是否真的发送给rabbitmq
  2. 消费者在消费过程中出现了异常是否会造成数据丢失

解决方案

  1. 生产者消息发送确认，在生产者加入如下配置，发送消息不管成功与否都会执行回调函数
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {

    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);
        // 设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
        rabbitTemplate.setMandatory(true);

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (!ack) {
                    //出现异常
                    System.out.println("ConfirmCallback:     " + "相关数据：" + correlationData);
                    System.out.println("ConfirmCallback:     " + "确认情况：" + ack);
                    System.out.println("ConfirmCallback:     " + "原因：" + cause);
                }
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("ReturnCallback:     " + "消息：" + message);
                System.out.println("ReturnCallback:     " + "回应码：" + replyCode);
                System.out.println("ReturnCallback:     " + "回应信息：" + replyText);
                System.out.println("ReturnCallback:     " + "交换机：" + exchange);
                System.out.println("ReturnCallback:     " + "路由键：" + routingKey);
            }
        });

        return rabbitTemplate;
    }
}
  1. 消费者手动确认收到消息
    以DirectReceiver为例子，修改为一下代码
import java.io.IOException;
import java.util.Map;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;
import com.rabbitmq.client.Channel;

@Component
public class DirectReceiver {

    //	basicAck(deliveryTag, false);  #id=deliveryTag会被确定后删除
    //	basicAck(deliveryTag, true);  #id<=deliveryTag会被确定后删除
    //	basicNack(deliveryTag, false); #消息会直接丢失，支持批量
    //	basicNack(deliveryTag, true);  #消息会再次发送回队列，支持批量
    //	basicReject(deliveryTag, false) #消息会直接丢失，不支持批量
    //	basicReject(deliveryTag, true) #消息会再次发送回队列，不支持批量
    @RabbitListener(bindings = @QueueBinding(value = @Queue(name = "TestDirectQueue", durable = "true"),
            exchange = @Exchange(name = "TestDirectRouting", durable = "true", ignoreDeclarationExceptions = "true")))
    public void process1(@Payload Map msg, Channel channel, Message message) throws IOException {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        System.out.println(msg.toString());
        try {
            // throw new Exception("手动异常");
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            e.printStackTrace();
            channel.basicReject(deliveryTag, false);
        }
    }

}

4.参考资料

全网最全RabbitMQ总结，别再说你不会RabbitMQ

一拳一个嘤嘤嘤
关注
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
SpringBoot整合RabbitMQ之广播模式
陌影的博客
05-29 5101
广播模式的简单描述 通过对RabbitMQ的学习，可以发现，消息都是通过交换器发送至队列的，一条消息只能被一个消费者处理，实际开发中还会有一种情况，就是一条消息需要被多个消费者处理，就是广播的形式；广播的模式需要使用到FanoutExchange（散列交换器），FanoutExchange 会将消息发送至每一个与之绑定的队列中。 具体使用： 1. 引入Rabbit MQ依赖 <!-- Rabbit Mq依赖 --> <dependency> <groupId>org
springboot2.3.1整合RabbitMQ多种工作模式 发送确认，手动应答
热门推荐
胖虎儿的博客
07-15 1万+
springboot2.3.1整合RabbitMQ多种工作模式 发送确认，手动应答
RabbitMQ——队列消息数
hncscwc的博客
07-09 3388
背景在实际使用过程，会遇到这么些情况：生产者发送的消息数量与消费者接收的消息数量不一致。例如生产者向rabbitmq投递了100条消息，消费者只从队列中接收到了80条消息，并且当前队列中...
RabbitMQ之交换器的三种模式
盛小伟的博客
05-29 2443
交换器(exchange)的最大作用一方面在于接收生产者的信息,另一方面在于发送消息到不同的队列,RabbitMQ中交换器被分为三类:fanout,topic,director 1.广播模式(fanout) 广播模式:生产的每一条消息,由所有消费者进行处理操作 图片参考自网络 消费者程序 生产者交换器核心代码 //信道绑定交换器 channel.exchangeDeclare(EXCH...
rabbitmq 手动提交_SpringBoot整合RabbitMQ,常用操作
weixin_31916125的博客
01-15 1175
本文介绍三种常用操作,基于spring-boot-starter-amqp依赖手动ackwork模式(能者多劳)消息格式转换手动ack消息确认模式在amqp协议中消息确认有两种模式自动确认模式(automatic acknowledgement model)当消息代理将消息发送给应用后立即删除显式确认模式(explicit acknowledgement model)待应用发送一个确认回执后再删除...
springboot集成rabbitMQ之对象传输的方法
08-28
本文将详细介绍 Spring Boot 集成 RabbitMQ 之对象传输的方法，从 RabbitMQ 的安装、依赖配置、生产者配置、消费者配置等方面进行讲解，并结合实例代码进行说明。 一、RabbitMQ 的安装 RabbitMQ 的安装方法网上有...
SpringBoot-RabbitMQ生产者和消费者.7z
07-14
这个名为"SpringBoot-RabbitMQ生产者和消费者.7z"的压缩包包含两个关键部分：`rabbitmq-consumer`（消费者）和`rabbitmq-provider`（生产者），它们演示了如何在SpringBoot应用中集成并利用RabbitMQ进行数据交换。...
SpringBoot集成RabbitMQ实现用户注册的示例代码
08-25
SpringBoot提供了集成RabbitMQ的starter，名为spring-boot-starter-amqp，可以轻松地将RabbitMQ集成到SpringBoot应用程序中。只需要在pom.xml文件中添加依赖项： <groupId>org.springframework.boot <artifactId>...
RabbitMQ高级之如何保证消息可靠性？
Java笔记虾
09-08 671
本文来源：http://r6f.cn/aTWx楔子本篇是消息队列RabbitMQ的第四弹。RabbitMQ我已经写了三篇了，基础的收发消息和基础的概念我都已经写了，学任何东西都是这样，先...
SpringBoot整合RabbitMQ 消息可靠投递、手动ack、延迟队列、死信队列、消息幂等性保障、消息积压
CodingAnHour
07-03 2235
在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。rabbitmq 整个消息投递的路径为：producer—>rabbitmq broker—>exchange—>queue—>consumer消息从 producer 到 exchange 则会返回一个 confirmCallback 。消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。将利用这两个 callb
rabbitmq 手动提交_rabbitmq生产者重发机制
weixin_39628271的博客
12-21 775
说明重发机制是在mq中很重要的一部分，消费者可以通过ack或者nack就可以很轻松实现消息重新入队列，然后进行重发，但是生产者也有可能在网络动荡的情况下，投递不成功，这个时候就需要消息重发。虽然rabbitmq提供了事务功能，但是如果开启事务，就太影响性能了。本文参考littersmall的博文,利用spring-boot的定时功能，在本地缓存，从而实现对失败的消息进行重发。完整的项目代码请参考本...
spring boot集成rabbitmq实现事务控制+手动确认
qq_43960768的博客
08-05 1926
spring boot集成rabbitmq实现事务控制+手动确认
rabbitmq 手动提交_springboot集成rabbitmq并手动注册容器实现单个queue的ack模式
weixin_35736086的博客
12-30 446
进入正题，本文会介绍两种实现rabbitmq的ack模式的方法，分别为：一、通过配置文件配置。二、通过手动注册 SimpleMessageListenerContainer容器实现。先介绍方法一：通过配置文件配置。此类实现起来较为方便，通过springboot的配置文件以及注解的形式即可完成。1.首先引入依赖：org.springframework.bootspring-boot-starter-...
SpringBoot整合 RabbitMQ
我的博客
09-08 958
SpringBoot整合 RabbitMQ 建springboot项目时导入springboot整合rabbitmq依赖包 1,生产者 application.yml配置文件 spring: rabbitmq: port: 5672 password: root username: root virtual-host: /pms host: localhost template: mandatory: true #没有投递到队列，强
Rabbitmq消费手动提交basicNack时结合Redis实现消费重试次数
weixin_41927235的博客
04-28 6519
实习遇到一个场景： 在rabbitmq消息确认设置为手动提交的时候，消息怎么在重试一定次数的情况下才放入死信队列。 rabbitmq的配置：消费端手动应答 在手动确认的条件下这些参数不太好使 原以为使用如上配置消息在重试三次之后，就会放入死信队列，事实上手动提交的时候，basicNack的最后一个参数requeue = true时，消息会被无限次的放入消费队列重新消费，直至回送ACK。 ch...
springboot rabbitmq 发布订阅 广播模式
最新发布
wangjun5159的专栏
12-15 1236
实现发布订阅（广播模式）的关键在于对exchange类型的理解，可参考amqp协议、rabbitmq入门、springboot集成rabbitmq，源码中的类型有如下几种/***//*** routing key和binding key完全匹配*//*** binding key可使用通配符来匹配routing key*//*** 会忽略routing key、binding key，消息发送到绑定exchange的全部queue*//**
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值