RabbitMQ放弃

最新推荐文章于 2024-04-29 15:06:21 发布
最新推荐文章于 2024-04-29 15:06:21 发布
阅读量456 收藏
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48161661/article/details/126942240
版权

发布确认

用于消息发布到broker之后，broker确认有没有收到，这样做可以防止rabbitMQ突然崩溃，消息还没有持久化，从而导致的消息丢失问题


package main

import (
	"context"
	"fmt"
	"log"
	"strconv"
	"sync"
	"time"

	amqp "github.com/rabbitmq/amqp091-go"
)

func main() {
	// This example acts as a bridge, shoveling all messages sent from the source
	// exchange "log" to destination exchange "log".

	// Confirming publishes can help from overproduction and ensure every message
	// is delivered.

	// Setup the source of the store and forward
	source, err := amqp.Dial("amqp://guest:guest@192.168.31.110:5672/")
	if err != nil {
		log.Fatalf("connection.open source: %s", err)
	}
	defer source.Close()

	ch, err := source.Channel()
	if err != nil {
		log.Fatalf("channel.open source: %s", err)
	}
	//信道开启发布确认模式
	if err := ch.Confirm(false); err != nil {
		log.Fatalf("confirm.select destination: %s", err)
	}

	q, err := ch.QueueDeclare("", true, true, false, false, nil)
	if err != nil {
		log.Fatalf("queue.declare source: %s", err)
	}

	//确认的消息将返回这个chan中以
	confirms := ch.NotifyPublish(make(chan amqp.Confirmation, 1))

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	dict := sync.Map{}

	go func() {
		for confirm := range confirms {
			//确认成功的话就删除map中保存的数据
			if confirm.Ack{
				dict.Delete(confirm.DeliveryTag)
			}
		}
	}()

	for i := 0; i < 1000; i++ {
		dict.Store(ch.GetNextPublishSeqNo(), "message "+strconv.Itoa(i))
		err = ch.PublishWithContext(
			ctx,
			"",
			q.Name,
			false,
			false,
			amqp.Publishing{
				// Copy all the properties
				ContentType: "text/plain",
				Body:        []byte("message " + strconv.Itoa(i)),
			})
	}
	time.Sleep(1 * time.Second)
	dict.Range(walk)
	var forever chan struct{}
	<-forever

}

func walk(key, value interface{}) bool {
	fmt.Println("Key =", key, "Value =", value)
	return true
}

死信队列

当消费者无法正常消费消息、消息发生异常时，为了保证数据不丢失，将异常的消息置为死信，放入死信队列。在死信队列中的消息，将启动单独的消费程序特殊处理。
成为死信消息的三种原因：

  • 消息被拒（Reject /Nack) 且 requeue = false。
  • 消息 TTL 过期。
  • 队列满了，无法再添加。
    在这里插入图片描述

producer.go

package main

import (
	"context"
	amqp "github.com/rabbitmq/amqp091-go"
	"log"
	"os"
	"strings"
	"time"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	// # ========== 1.创建连接 ==========
	conn, err := amqp.Dial("amqp://guest:guest@192.168.31.110:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	// # ========== 2.设置队列（队列、交换机、绑定） ==========
	// 声明队列
	_, err = ch.QueueDeclare("normal-queue", true, false, false, false, amqp.Table{
		"x-message-ttl":             5000,            // 消息过期时间,毫秒
		"x-dead-letter-exchange":    "dead-exchange", // 指定死信交换机
		"x-dead-letter-routing-key": "dead-key",      // 指定死信routing-key
		"x-max-length":              6,               //指定队列最大长度，如果超过，消息也会变成死信
	})
	failOnError(err, "创建normal队列失败")

	// 声明交换机
	err = ch.ExchangeDeclare("normal-exchange", amqp.ExchangeDirect, true, false, false, false, nil)
	failOnError(err, "创建normal交换机失败")

	// 队列绑定（将队列、routing-key、交换机三者绑定到一起）
	err = ch.QueueBind("normal-queue", "normal-key", "normal-exchange", false, nil)
	failOnError(err, "normal：队列、交换机、routing-key 绑定失败")

	// # ========== 3.设置死信队列（队列、交换机、绑定） ==========
	// 声明死信队列
	// args 为 nil。切记不要给死信队列设置消息过期时间,否则失效的消息进入死信队列后会再次过期。
	_, err = ch.QueueDeclare("dead-queue", true, false, false, false, nil)
	failOnError(err, "创建dead队列失败")

	// 声明交换机
	err = ch.ExchangeDeclare("dead-exchange", amqp.ExchangeDirect, true, false, false, false, nil)
	failOnError(err, "创建dead队列失败")

	// 队列绑定（将队列、routing-key、交换机三者绑定到一起）
	err = ch.QueueBind("dead-queue", "dead-key", "dead-exchange", false, nil)
	failOnError(err, "dead：队列、交换机、routing-key 绑定失败")

	// # ========== 4.发布消息 ==========
	body := bodyFrom(os.Args)

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	// 发布消息
	err = ch.PublishWithContext(ctx, "normal-exchange", "normal-key", false, false, amqp.Publishing{
		ContentType: "text/plain",
		Body:        []byte(body),
		//Expiration:  "5000", //也可以在消息里设置TTL，更加灵活
	})
	failOnError(err, "消息发布失败")
}

func bodyFrom(args []string) string {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "hello"
	} else {
		s = strings.Join(args[1:], " ")
	}
	return s
}

normalConsumer.go

此程序不允许，可以导致消息因为TTL和长度限制而成为死信，运行可以通过拒绝消息让消息成为死信

package main

import (
	amqp "github.com/rabbitmq/amqp091-go"
	"log"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	// # ========== 1.创建连接 ==========
	conn, err := amqp.Dial("amqp://guest:guest@192.168.31.110:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	// # ========== 2.消费消息 ==========
	msgsCh, err := ch.Consume("normal-queue", "", false, false, false, false, nil)
	failOnError(err, "消费normal队列失败")

	forever := make(chan struct{})
	go func() {
		for d := range msgsCh {
			// 要实现的逻辑
			log.Printf("接收的消息: %s", d.Body)

			// 手动应答
			//d.Ack(false)
			d.Reject(false)
		}
	}()
	log.Printf("[*] Waiting for message, To exit press CTRL+C")
	<-forever
}

deadConsumer.go

package main

import (
	amqp "github.com/rabbitmq/amqp091-go"
	"log"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	// # ========== 1.创建连接 ==========
	conn, err := amqp.Dial("amqp://guest:guest@192.168.31.110:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	// # ========== 2.消费消息 ==========
	msgsCh, err := ch.Consume("dead-queue", "", false, false, false, false, nil)
	failOnError(err, "消费normal队列失败")

	forever := make(chan struct{})
	go func() {
		for d := range msgsCh {
			// 要实现的逻辑
			log.Printf("接收的消息: %s", d.Body)

			// 手动应答
			d.Ack(false)
			//d.Reject(false)
		}
	}()
	log.Printf("[*] Waiting for message, To exit press CTRL+C")
	<-forever
}

延迟队列

通过死信队列的介绍，我们可以很容易的实现一个延迟队列。

  • 将正常队列的消费者取消；
  • 发消息时设置TTL；

通过上面两点，正常队列的消息始终不会被消费，而是等待消息TTL到期，进入死信队列，让死信消费者进行消费，从而达到延迟队列的效果。

上面看上去似乎没什么问题，实测一下就会发现消息不会“如期死亡”。

当先生产一个TTL为60s的消息，再生产一个TTL为5s的消息，第二个消息并不会再5s后过期进入死信队列，而是需要等到第一个消息TTL到期后，与第一个消息一同进入死信队列。这是因为RabbitMQ 只会判断队列中的第一个消息是否过期。

对于上文的问题，自然有解决方法，那就是通过 RabbitMQ 的 rabbitmq_delayed_message_exchange 插件来解决
docker版安装教程：
https://blog.csdn.net/m0_67393827/article/details/126643162

生产者实现的关键点：

1.在声明交换机时不在是direct类型，而是x-delayed-message类型，这是由插件提供的类型；

2.交换机要增加"x-delayed-type": "direct"参数设置；

3.发布消息时，要在 Headers 中设置x-delay参数，来控制消息从交换机过期时间；

4.只需要一个队列即可

producer.go

package main

import (
	"context"
	amqp "github.com/rabbitmq/amqp091-go"
	"log"
	"os"
	"strings"
	"time"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	// # ========== 1.创建连接 ==========
	conn, err := amqp.Dial("amqp://guest:guest@192.168.31.110:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	// # ========== 2.设置队列（队列、交换机、绑定） ==========
	// 声明队列
	_, err = ch.QueueDeclare("delay-queue", true, false, false, false, amqp.Table{})
	failOnError(err, "创建normal队列失败")

	// 声明交换机
	err = ch.ExchangeDeclare("delay-exchange", "x-delayed-message", true, false, false, false, amqp.Table{
		"x-delayed-type": "direct",
	})
	failOnError(err, "创建normal交换机失败")

	// 队列绑定（将队列、routing-key、交换机三者绑定到一起）
	err = ch.QueueBind("delay-queue", "delay-key", "delay-exchange", false, nil)
	failOnError(err, "normal：队列、交换机、routing-key 绑定失败")

	// # ========== 3.发布消息 ==========
	body := bodyFrom(os.Args)

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	// 发布消息
	err = ch.PublishWithContext(ctx, "delay-exchange", "delay-key", false, false, amqp.Publishing{
		ContentType: "text/plain",
		Body:        []byte(body),
		//Expiration:  "5000",
		Headers: map[string]interface{}{
			"x-delay": "5000", // 消息从交换机过期时间,毫秒（x-dead-message插件提供）
		},
	})
	failOnError(err, "消息发布失败")
}

func bodyFrom(args []string) string {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "hello"
	} else {
		s = strings.Join(args[1:], " ")
	}
	return s
}

consumer.go


package main

import (
	amqp "github.com/rabbitmq/amqp091-go"
	"log"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Panicf("%s: %s", msg, err)
	}
}

func main() {
	// # ========== 1.创建连接 ==========
	conn, err := amqp.Dial("amqp://guest:guest@192.168.31.110:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	// # ========== 2.消费消息 ==========
	msgsCh, err := ch.Consume("delay-queue", "", false, false, false, false, nil)
	failOnError(err, "消费normal队列失败")

	forever := make(chan struct{})
	go func() {
		for d := range msgsCh {
			// 要实现的逻辑
			log.Printf("接收的消息: %s", d.Body)
			// 手动应答
			d.Ack(false)
			//d.Reject(false)
		}
	}()
	log.Printf("[*] Waiting for message, To exit press CTRL+C")
	<-forever
}
离异脖士孙亚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
用于支持自动重新连接的staway / amqp的RabbitMQ包装器-Golang开发
05-26
用于支持自动重新连接兔子的steadway / amqp的RabbitMQ包装器RabbitMQ包装器lib在streadway / amqp周围带有一些铃铛。 支持自动重新连接支持上下文（即取消/超时）？？？ 动机我们（批次）大量使用RabbitMQ-我们将其用作促进服务间通信的主要方法。 因此，所有服务都使用RabbitMQ，并且既是发布者又是消费者。 我们编写此库是为了确保我们所有的服务都以一致，可预测的方式使用Rabbit，并且能够
rabbitmq开发规范
07-04
1：rabbitmq的命名规范 2：rabbitmq生产者开发规范 3：rabbitmq消费者开发规范
golang大厂面试2
niwoxiangyu的博客
07-04 1116
一开始一个项目数据比较多，后来需要分库分表，有什么思路在不停服务的情况下做到平滑切换？wss是基于tcp的，tcp有个半连接队列，有没有遇到发了信令但是服务器没收到的情况？实现一个函数，有两个参数分别是升序的整数数组a和b，返回合并后的升序整数数组。理解不理解这些树的构造，是要解决什么问题？处理日志的时候如果发现突然量变大，该如何扩容让以前堆积的日志可以消耗掉？命令的时间差如何保证，命令混乱了怎么办（时间戳记录在服务器可以吗？题拍拍主要做拍搜服务的，题拍拍主要做增长，后面会做微服务架构k8s等。
Web 后端开发4—消息队列（后端示例：Go）
风不归的乐园
12-14 1145
消息队列的概念，常见消息队列系统，Kafka，消息模式，异步任务处理，消息队列与微服务架构，消息队列的性能优化，监控消息队列，消息队列的安全性，常见安全威胁与防范
GO 操作RabbitMQ
weixin_42562106的博客
01-06 1734
docker快速安装mq docker run -d --hostname my-rabbit --name some-rabbit -e RABBITMQ_DEFAULT_USER=admins -e RABBITMQ_DEFAULT_PASS=123qwe123 -p15672:15672 -p5672:5672 rabbitmq:management-alpine go 需要安装 go get github.com/streadway/amqp 生产者代码send.go package main
分享一个极好的go练手小项目，可以综合应用高并发服务的许多知识点。
ckw1988的专栏
04-20 282
客户端在发送请求前，注册一个随机名称的队列，用以接收计算结果的返回值（以下简称回应队列），该队列名会在发送计算请求到“rpc_queue”时附带在请求信息的“ReplyTo”属性中，而服务端在计算完毕后向该队列名发送计算结果即可。接下来找到客户端代码的fibonacciRPC方法的定义位置，该方法即rpc方法的本体，方法中包含了发送请求到rpc服务、阻塞线程以等待返回、获取返回结果后return给方法调用者等三个步骤，对外表现即为一个同步调用方法。我自己完成的demo再稍做修饰，过会儿上传。
rabbiMQ可能需要注意的地方
C573751767的博客
11-03 1281
rabbitMQ的exclusive属性
Go RabbitMQ简介 使用
Lamb的博客
11-09 867
RabbitMQ 是一个广泛使用的开源消息队列系统，它实现了高级消息队列协议（AMQP）标准，为分布式应用程序提供了强大的消息传递功能。RabbitMQ 是 Erlang 语言编写的，具有高度的可扩展性和可靠性，因此被广泛用于构建分布式、异步的消息通信系统。在发送和接收消息之前，您需要定义一个队列。如果队列不存在，它将被创建。queueName, // 队列名称false, // 是否持久化false, // 是否自动删除false, // 是否排他false, // 是否阻塞。
golang之消息队列rabbitmq
weixin_50134791的博客
10-19 5884
之前我写过一篇关于rocketmq的文章，因为rabbitmq的使用更广泛，所以写一篇关于rabbitmq，及go如何操作rabbitmq的笔记。 消息队列的作用： 异步，将同步的消息变为异步 解耦，将单体服务拆分多个微服务，实现了分布式部署，单个服务的修改、增加或删除，不影响其他服务，不需要全部服务关闭重启 抗压，由于是异步，解耦的，高并发请求到来时，我们不直接发送给服务，而是发给MQ，让服务决定什么时候接收消息，提供服务，这样就缓解了服务的压力 图示： 用户注册后发邮件和虚拟币： 异步解耦图： 抗压
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
tp6使用rabbitmq
09-22
tp6使用rabbitmq
RabbitMQ从入门到放弃
01-19
RabbitMQ从入门到放弃
rabbitmq 3.9.3 配置文件
10-07
rabbitmq 3.9.3 配置文件
RabbitMQ（高级）笔记
程序员碎像的博客
04-26 364
（2）生产者确认 引入日志依赖 二、MQ持久化 （1）持久化介绍 发送100万条消息给队列，需要先在application.yml中取消生产者确认 没有持久化的测试用例，会出行阻塞的状态： 改为持久化后的测试用例： 使用auto自动模式 注意：创建的simple.queue需要Add Dead letter exchange，其他都跟之前创建的操作差不多 监听 测试用例 （3）取消订单
异步线程与RabbitMQ应该如何选择？
weixin_53390884的博客
04-23 352
异步线程是一种编程技术，它允许程序在执行长时间操作（如I/O操作、网络请求等）时，不阻塞主执行线程。这可以通过多线程或使用语言特性（如Python的。
RabbitMq总结
weixin_70202553的博客
04-26 382
消息的可靠性需要保证开启消息持久化，不然宕机消息就丢失了，首先是生产者发送消息的可靠性，mq要保证每一条消息都进行ack应答，而客户端收到了ack应答才继续发送，否则超时重试，当然需要设计接口的幂等性，对于消费者，要消费消息之后进行反馈，当mq收到反馈之后才删除消息。将消息发送到一个单独的事务队列，再从事务队列发送到消费者可消费的队列，若出现问题则回滚，若没有问题则删除事务队列中的消息。rabbitmq由消费者，生产者，交换机，队列，bindingkey组成，交换机存在三种，分别对应广播，单播，多播。
RabbitMQ Transport indicated EOF 总结
最新发布
jacke121的专栏
04-29 363
RabbitMQ Transport indicated EOF
RabbitMQ中的交换机类型
qq_64064246的博客
04-26 559
另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！不过队列一定要与交换机绑定。消息的发送方在 向 Exchange发送消息时，也必须指定消息的。Exchange不再把消息交给每一个绑定的队列，而是根据消息的。队列与交换机的绑定，不能是任意绑定了，而是要指定一个。
什么是RabbitMQ，RabbitMQ基本概念，RabbitMQ的使用场景
小小鱼儿小小林的博客
04-25 439
RabbitMQ是一个开源的消息代理软件（也称为消息队列），它实现了高级消息队列协议（AMQP）。RabbitMQ提供了一种应用程序对应用程序之间的通信方法，基于消费-生产者模型，允许分布式系统中的组件进行异步通信。
rabbitmq to rabbitmq
03-27
RabbitMQ是一个开源的消息中间件，它实现了高级消息队列协议（AMQP）并提供可靠的消息传递机制。它允许应用程序之间进行异步通信，并支持多种消息模式，如点对点、发布/订阅和工作队列。 当我们提到"RabbitMQ to ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值