golang之消息队列rabbitmq

之前我写过一篇关于rocketmq的文章，因为rabbitmq的使用更广泛，所以写一篇关于rabbitmq，及go如何操作rabbitmq的笔记。消息队列的作用：异步，将同步的消息变为异步解耦，将单体服务拆分多个微服务，实现了分布式部署，单个服务的修改、增加或删除，不影响其他服务，不需要全部服务关闭重启抗压，由于是异步，解耦的，高并发请求到来时，我们不直接发送给服务，而是发给MQ，让服务决定什么时

中二的灰太狼

6067人浏览 · 2021-10-19 21:07:24

中二的灰太狼 · 2021-10-19 21:07:24 发布

消息队列的作用：

异步，将同步的消息变为异步，例如我们可以使用rpc调用另一个服务，但是我们必须等待返回（同步），用mq可以变异步
解耦，将单体服务拆分多个微服务，实现了分布式部署，单个服务的修改、增加或删除，不影响其他服务，不需要全部服务关闭重启
抗压，由于是异步，解耦的，高并发请求到来时，我们不直接发送给服务，而是发给MQ，让服务决定什么时候接收消息，提供服务，这样就缓解了服务的压力
图示：
用户注册后发邮件和虚拟币：
异步解耦图：

抗压图：

收发流程

生产者发送消息的流程

生产者连接RabbitMQ，建立TCP连接( Connection)，开启信道（Channel）
生产者声明一个Exchange（交换器），并设置相关属性，比如交换器类型、是否持久化等
生产者声明一个队列井设置相关属性，比如是否排他、是否持久化、是否自动删除等
生产者通过 routingKey （路由Key）将交换器和队列绑定（ binding ）起来
生产者发送消息至RabbitMQ Broker，其中包含 routingKey （路由键）、交换器等信息
相应的交换器根据接收到的 routingKey 查找相匹配的队列。
如果找到，则将从生产者发送过来的消息存入相应的队列中。
如果没有找到，则根据生产者配置的属性选择丢弃还是回退给生产者
关闭信道。
关闭连接

消费者接收消息的过程

消费者连接到RabbitMQ Broker ，建立一个连接(Connection ) ，开启一个信道(Channel) 。
消费者向RabbitMQ Broker 请求消费相应队列中的消息，可能会设置相应的回调函数，以及
做一些准备工作
等待RabbitMQ Broker 回应并投递相应队列中的消息，消费者接收消息。
消费者确认( ack) 接收到的消息。
RabbitMQ 从队列中删除相应己经被确认的消息。
关闭信道。
关闭连接。

docker安装

拉取image:

docker pull rabbitmq:3.8-management-alpine

启动容器：
5672进行通信，15672 ，web管理工具

docker run -d --name rmq \
-e RABBITMQ_DEFAULT_USER=用户名 \
-e RABBITMQ_DEFAULT_PASS=密码 \
-p 15672:15672 \
-p 5672:5672 \
rabbitmq:3.8-management-alpine

官方文档

消息收发模式

明确连个概念，exchange(路由) queue(队列）
工作模式：
在这里插入图片描述
以下用p 代指生产者，用 c 代指消费者，用 x 代指 exchange

1.简单模式

p发给队列，单个c消费，这里用的默认exchange，收发模式是direct
在这里插入图片描述

2.工作队列模式

p发给队列，多个c消费，这里用的默认exchange，收发模式是direct
在这里插入图片描述

3.发布订阅模式（扇出模式）

fandout模式：p将消息发给x，x将同一个消息发给所有q，c 按 1，2方式消费q的消息
在这里插入图片描述

4.direct(路由)模式：

p 按照路由Routing Key将消息发给q，（一个消息可能发给多个q），c 按 1，2方式消费q的消息

5.topic模式

p 按照路由Routing Key将消息发给q，（一个消息可能发给多个q），c 按 1，2方式消费q的消息，与4的区别是topic可以有通配符匹配

用go操作rabbitmq

写代码的思路

在初始化中完成

声明exchange
声明queue
将queue与key、exchange绑定

然后用conn.Channel()和rabbitmq交互

go get github.com/rabbitmq/amqp091-go

收发模式2示例：

package main

import (
	"fmt"
	"github.com/streadway/amqp"
	"time"
)

func main() {
	conn, err := amqp.Dial("amqp://用户名:密码@IP:端口/")
	if err != nil {
		panic(err)
	}

	ch, err := conn.Channel()
	if err != nil {
		panic(err)
	}
	//durable 服务器重启还有queue  autoDelete 自动删除 exclusive 独占连接,这个q别人连不上 noWait 是否等待返回的一些状态结果
	//关于queue的一些设置
	q, err := ch.QueueDeclare("go_q1", true, false, false, false, nil)
	if err != nil {
		panic(err)
	}

	// 开启消费者
	go consume("c1",conn, q.Name)
	go consume("c2",conn, q.Name)

	i := 0
	for {
		i++
		err := ch.Publish("", q.Name, false, false, amqp.Publishing{
			Body: []byte(fmt.Sprintf("message %d", i)),
		})
		if err != nil {
			panic(err)
		}
		time.Sleep(200 * time.Millisecond)
	}
}

func consume(name string,conn *amqp.Connection, q string)  {
	ch, err :=  conn.Channel()
	if err != nil {
		panic(err)
	}
	msgs, err := ch.Consume(q,name,true, false,false,false,nil)
	if err != nil {
		panic(err)
	}

	for msg := range msgs {
		fmt.Printf("%s:%s\n",name,msg.Body)
	}
}

fanout模式示例：

package main

import (
	"fmt"
	"github.com/streadway/amqp"
	"time"
)

func main() {
	conn, err := amqp.Dial("amqp://用户名:密码@IP:端口/")
	if err != nil {
		panic(err)
	}

	ch, err := conn.Channel()
	if err != nil {
		panic(err)
	}

	err = ch.ExchangeDeclare("ex","fanout",true,false,false,false,nil)
	if err != nil {
		panic(err)
	}

	go subscribe(conn,"ex")
	go subscribe(conn,"ex")

	i := 0
	for {
		i++
		err := ch.Publish("ex", "", false, false, amqp.Publishing{
			Body: []byte(fmt.Sprintf("message %d", i)),
		})
		if err != nil {
			panic(err)
		}
		time.Sleep(200 * time.Millisecond)
	}
}

func subscribe(conn *amqp.Connection, ex string) {
	ch, err :=  conn.Channel()
	if err != nil {
		panic(err)
	}
	defer ch.Close()

	q, err := ch.QueueDeclare("", false, true, false, false, nil)
	if err != nil {
		panic(err)
	}
	defer ch.QueueDelete(q.Name, false,false,false)
	err = ch.QueueBind(q.Name,"",ex,false,nil)
	if err != nil {
		panic(err)
	}
	consume("c3",ch,q.Name)

}

func consume(name string,ch *amqp.Channel, q string)  {
	msgs, err := ch.Consume(q,name,true, false,false,false,nil)
	if err != nil {
		panic(err)
	}

	for msg := range msgs {
		fmt.Printf("%s:%s\n",name,msg.Body)
	}
}

写代码的时候注意，收发消息，一定要在不同的channel进行，大家可以把channel认为是一个tcp连接的分割。建立exchang的channel可以进行发消息，不可以进行收消息
可以看到有一个exchange，对应2个queue。对应一条tcp连接（分成3个channel，1个向exchange发，2个从queue收)
在这里插入图片描述

routing(路由)模式示例

package main

import (
	"fmt"
	"github.com/streadway/amqp"
	"strconv"
	"time"
)

const (
	exchangeName = "ex_routing"
	key1     = "key1"
	key2     = "key2"
	queueBindKey1 = "queue1"
	queueBindKey2 = "queue2"
)

func main() {
	dsn := fmt.Sprintf("amqp://%s:%s@%s:%d/", "xxxxx", "xxxxx", "xxxxx", "xxxxx")
	conn, err := amqp.Dial(dsn)
	if err != nil {
		panic(err)
	}

	ch, err := conn.Channel()
	if err != nil {
		panic(err)
	}
	InitMQ(ch,queueBindKey1,key1,exchangeName)
	InitMQ(ch,queueBindKey2,key2,exchangeName)

	go subscribe(conn, key1,queueBindKey1)
	go subscribe(conn, key2,queueBindKey2)

	i := 0
	for {
		i++
		sendMessage(ch,exchangeName,key1,strconv.Itoa(i))
		sendMessage(ch,exchangeName,key2,strconv.Itoa(i))
		time.Sleep(500 * time.Millisecond)
	}
}

func InitMQ(ch *amqp.Channel, queue,key,exchange string) {
	// 声明 exchange
	err := ch.ExchangeDeclare(exchangeName, "direct", true, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 声明 queue
	_, err = ch.QueueDeclare(queue, false, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 将 queue 与 exchange 和 key 绑定
	err = ch.QueueBind(queue, key, exchange, false, nil)
	if err != nil {
		panic(err)
	}

}

func sendMessage(ch *amqp.Channel, exchange string, key string,message string) {
	err := ch.Publish(exchange, key, false, false, amqp.Publishing{
		Body: []byte(fmt.Sprintf("send to %s, message: %v", key,message)),
	})
	if err != nil {
		panic(err)
	}

}

func subscribe(conn *amqp.Connection, key string,queue string) {
	ch, err := conn.Channel()
	if err != nil {
		panic(err)
	}
	defer ch.Close()
	key = fmt.Sprintf("%s haha",key)
	consume(key, ch, queue)
}

func consume(name string, ch *amqp.Channel, queue string) {
	msgs, err := ch.Consume(queue, name, true, false, false, false, nil)

	if err != nil {
		panic(err)
	}

	for msg := range msgs {
		fmt.Printf("%s:%s\n", name, msg.Body)
	}
}

绑定图：
在这里插入图片描述

topic模式

是rabbitmq最高级模式了，没啥说的，重点就是，*匹配1个，#匹配0或多个
在这里插入图片描述

package main

import (
	"fmt"
	"github.com/streadway/amqp"
	"log"
	"time"
)

const (
	TopicExchange = "topicExchange"
	BindingKey1   = "*.*.red"
	BindingKey2   = "*.error.*"
	BindingKey3   = "shanghai.*.*"
	Queue1        = "queue1"
	Queue2        = "queue2"
	Queue3        = "queue3"
	RoutingKey1   = "beijing.error"
	RoutingKey2   = "shanghai.fatal.red"
)

func main() {
	dsn := fmt.Sprintf("amqp://%s:%s@%s:%d/", "用户名", "密码", "ip", port)
	conn, err := amqp.Dial(dsn)
	if err != nil {
		panic(err)
	}

	ch, err := conn.Channel()
	if err != nil {
		panic(err)
	}
	InitMQ(ch, Queue1, BindingKey1, TopicExchange)
	InitMQ(ch, Queue2, BindingKey2, TopicExchange)
	InitMQ(ch, Queue3, BindingKey3, TopicExchange)
	ch2 := GenChannel(conn)
	go subscribe(ch2, BindingKey1, Queue1, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue1,BindingKey1,string(msg.Body))
		}
	})
	go subscribe(ch2, BindingKey2, Queue2, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue2,BindingKey2,string(msg.Body))
		}
	})
	go subscribe(ch2, BindingKey3, Queue3, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue3,BindingKey3,string(msg.Body))
		}
	})
	for {
		sendMessage(ch, TopicExchange, RoutingKey1, "beijing.error")
		sendMessage(ch, TopicExchange, RoutingKey2, "shanghai.fatal.red")
		time.Sleep(500 * time.Millisecond)
	}
}

func GenChannel(conn *amqp.Connection) *amqp.Channel {
	ch, err := conn.Channel()
	if err != nil {
		log.Fatal(err)
	}
	return ch
}

func InitMQ(ch *amqp.Channel, queue, key, exchange string) {
	// 声明 exchange
	err := ch.ExchangeDeclare(exchange, "topic", true, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 声明 queue
	_, err = ch.QueueDeclare(queue, false, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 将 queue 与 exchange 和 key 绑定
	err = ch.QueueBind(queue, key, exchange, false, nil)
	if err != nil {
		panic(err)
	}

}

func sendMessage(ch *amqp.Channel, exchange string, key string, message string) {
	err := ch.Publish(exchange, key, false, false, amqp.Publishing{
		Body: []byte(fmt.Sprintf("send to %s, message: %v", key, message)),
	})
	if err != nil {
		panic(err)
	}

}

func subscribe(ch *amqp.Channel, key string, queue string, callback func(<-chan amqp.Delivery, string)) {
	msgs, err := ch.Consume(queue, key, true, false, false, false, nil)

	if err != nil {
		panic(err)
	}
	callback(msgs, key)
}

高级操作

消费者确认模式：

将消费消息，设置为手动确认：
在这里插入图片描述
成功时确认：msg.Ack(false)
失败时消息处理方式：

不进行确认，会进入unacked，当消费者重启后，或者同一队列的其他消费者可以消费
重新入列

msg.Reject(true)

丢弃

msg.Reject(false)

package main

import (
	"fmt"
	"github.com/streadway/amqp"
	"log"
	"time"
)

const (
	TopicExchange = "topicExchange"
	BindingKey1   = "*.*.red"
	BindingKey2   = "*.error.*"
	BindingKey3   = "shanghai.*.*"
	Queue1        = "queue1"
	Queue2        = "queue2"
	Queue3        = "queue3"
	RoutingKey1   = "beijing.error"
	RoutingKey2   = "shanghai.fatal.red"
)

func main() {
	dsn := fmt.Sprintf("amqp://%s:%s@%s:%d/", "xxxxx", "xxxxx", "xxxxx", "xxxxx")
	conn, err := amqp.Dial(dsn)
	if err != nil {
		panic(err)
	}

	ch, err := conn.Channel()
	if err != nil {
		panic(err)
	}
	InitMQ(ch, Queue1, BindingKey1, TopicExchange)
	InitMQ(ch, Queue2, BindingKey2, TopicExchange)
	InitMQ(ch, Queue3, BindingKey3, TopicExchange)
	ch2 := GenChannel(conn)
	go subscribe(ch2, BindingKey1, Queue1, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue1,BindingKey1,string(msg.Body))
			// false 拒绝重新入列，即丢弃
			//msg.Reject(false)
			// true 重新入列
			msg.Reject(true)
		}
	})
	go subscribe(ch2, BindingKey2, Queue2, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue2,BindingKey2,string(msg.Body))
			msg.Ack(false)
		}
	})
	go subscribe(ch2, BindingKey3, Queue3, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue3,BindingKey3,string(msg.Body))
			msg.Ack(false)
		}
	})
	cycleCount := 1
	for i:=0;i<cycleCount;i++ {
		sendMessage(ch, TopicExchange, RoutingKey1, "beijing.error")
		sendMessage(ch, TopicExchange, RoutingKey2, "shanghai.fatal.red")
		time.Sleep(500 * time.Millisecond)
	}
	select {}
}

func GenChannel(conn *amqp.Connection) *amqp.Channel {
	ch, err := conn.Channel()
	if err != nil {
		log.Fatal(err)
	}
	return ch
}

func InitMQ(ch *amqp.Channel, queue, key, exchange string) {
	// 声明 exchange
	err := ch.ExchangeDeclare(exchange, "topic", true, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 声明 queue
	_, err = ch.QueueDeclare(queue, false, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 将 queue 与 exchange 和 key 绑定
	err = ch.QueueBind(queue, key, exchange, false, nil)
	if err != nil {
		panic(err)
	}

}

func sendMessage(ch *amqp.Channel, exchange string, key string, message string) {
	err := ch.Publish(exchange, key, false, false, amqp.Publishing{
		Body: []byte(fmt.Sprintf("send to %s, message: %v", key, message)),
	})
	if err != nil {
		panic(err)
	}

}

func subscribe(ch *amqp.Channel, key string, queue string, callback func(<-chan amqp.Delivery, string)) {
	msgs, err := ch.Consume(queue, key, false, false, false, false, nil)

	if err != nil {
		panic(err)
	}
	callback(msgs, key)
}

消费限流

限制未ack的最多有5个,必须设置为手动ack才有效
在这里插入图片描述

示例：

package main

import (
	"fmt"
	"github.com/streadway/amqp"
	"log"
	"time"
)

const (
	TopicExchange = "topicExchange"
	BindingKey1   = "*.*.red"
	BindingKey2   = "*.error.*"
	BindingKey3   = "shanghai.*.*"
	Queue1        = "queue1"
	Queue2        = "queue2"
	Queue3        = "queue3"
	RoutingKey1   = "beijing.error"
	RoutingKey2   = "shanghai.fatal.red"
)

func main() {
	dsn := fmt.Sprintf("amqp://%s:%s@%s:%d/", "xxxx", "xxxx", "xxxx", xxxx)
	conn, err := amqp.Dial(dsn)
	if err != nil {
		panic(err)
	}

	ch, err := conn.Channel()
	if err != nil {
		panic(err)
	}
	InitMQ(ch, Queue1, BindingKey1, TopicExchange)
	InitMQ(ch, Queue2, BindingKey2, TopicExchange)
	InitMQ(ch, Queue3, BindingKey3, TopicExchange)
	ch2 := GenChannel(conn)
	// 限制未ack的最多有5个,必须设置为手动ack才有效
	ch2.Qos(5,0,false)
	go subscribe(ch2, BindingKey1, Queue1, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			go func(msg amqp.Delivery) {
				fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue1,BindingKey1,string(msg.Body))
				time.Sleep(time.Second * 5)
				msg.Ack(false)
			}(msg)
		}
	})
	go subscribe(ch2, BindingKey2, Queue2, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue2,BindingKey2,string(msg.Body))
			msg.Ack(false)
		}
	})
	go subscribe(ch2, BindingKey3, Queue3, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue3,BindingKey3,string(msg.Body))
			msg.Ack(false)
		}
	})
	cycleCount := 10
	for i:=0;i<cycleCount;i++ {
		sendMessage(ch, TopicExchange, RoutingKey1, "beijing.error")
		sendMessage(ch, TopicExchange, RoutingKey2, "shanghai.fatal.red")
		time.Sleep(500 * time.Millisecond)
	}
	select {}
}

func GenChannel(conn *amqp.Connection) *amqp.Channel {
	ch, err := conn.Channel()
	if err != nil {
		log.Fatal(err)
	}
	return ch
}

func InitMQ(ch *amqp.Channel, queue, key, exchange string) {
	// 声明 exchange
	err := ch.ExchangeDeclare(exchange, "topic", true, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 声明 queue
	_, err = ch.QueueDeclare(queue, false, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 将 queue 与 exchange 和 key 绑定
	err = ch.QueueBind(queue, key, exchange, false, nil)
	if err != nil {
		panic(err)
	}

}

func sendMessage(ch *amqp.Channel, exchange string, key string, message string) {
	err := ch.Publish(exchange, key, false, false, amqp.Publishing{
		Body: []byte(fmt.Sprintf("send to %s, message: %v", key, message)),
	})
	if err != nil {
		panic(err)
	}

}

func subscribe(ch *amqp.Channel, key string, queue string, callback func(<-chan amqp.Delivery, string)) {
	msgs, err := ch.Consume(queue, key, false, false, false, false, nil)

	if err != nil {
		panic(err)
	}
	callback(msgs, key)
}

延迟消息

借助rabbitmq-delayed-message-exchange插件实现（需要先安装好）

package main

import (
	"fmt"
	"github.com/streadway/amqp"
	"log"
	"time"
)

const (
	TopicExchange = "topicExchange"
	DelayExchange = "delayExchange"
	BindingKey1   = "*.*.red"
	BindingKey2   = "*.error.#"
	BindingKey3   = "shanghai.*.*"
	Queue1        = "queue1"
	Queue2        = "queue2"
	Queue3        = "queue3"
	RoutingKey1   = "beijing.error"
	RoutingKey2   = "shanghai.fatal.red"
)

func main() {
	dsn := fmt.Sprintf("amqp://%s:%s@%s:%d/", "xxxx", "xxxx", "xxxx", 5672)
	conn, err := amqp.Dial(dsn)
	if err != nil {
		panic(err)
	}

	ch, err := conn.Channel()
	if err != nil {
		panic(err)
	}
	InitMQ(ch, Queue1, BindingKey1, TopicExchange)
	InitMQ(ch, Queue2, BindingKey2, TopicExchange)
	InitMQ(ch, Queue3, BindingKey3, TopicExchange)
	InitDelayMQ(ch, Queue2, "", DelayExchange)

	ch2 := GenChannel(conn)
	// 限制未ack的最多有5个,必须设置为手动ack才有效
	ch2.Qos(5, 0, false)
	go subscribe(ch2, BindingKey1, Queue1, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			go func(msg amqp.Delivery) {
				fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue1, BindingKey1, string(msg.Body))
				msg.Ack(false)
			}(msg)
		}
	})
	go subscribe(ch2, BindingKey2, Queue2, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Println(time.Now())
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue2, BindingKey2, string(msg.Body))
			isFail := true
			// 如果失败发送延迟消息给
			if isFail {
				delay,ok := msg.Headers["x-delay"].(int32)
				if ok {
					delay = delay * 2
					fmt.Println(delay)
				}else{
					delay = 1000
				}
				sendDelayMessage(ch, DelayExchange, "", string(msg.Body), int(delay))
				msg.Reject(false)
			} else {
				msg.Ack(false)
			}
		}
	})
	go subscribe(ch2, BindingKey3, Queue3, func(msgs <-chan amqp.Delivery, s string) {
		for msg := range msgs {
			fmt.Printf("%v 绑定 %v 收到消息：%v\n", Queue3, BindingKey3, string(msg.Body))
			msg.Ack(false)
		}
	})
	// 设置confirm，发送端消息确认
	//var notifyConfirm chan amqp.Confirmation
	//SetConfirm(ch, notifyConfirm)
	//go ListenConfirm(notifyConfirm)
	//var notifyReturn chan amqp.Return
	//NotifyReturn(notifyReturn,ch)
	//go ListReturn(notifyReturn)

	cycleCount := 1
	for i := 0; i < cycleCount; i++ {
		fmt.Println(i)
		//sendDelayMessage(ch, DelayExchange, "", "beijing.error-----------------",3000)
		sendMessage(ch, TopicExchange, RoutingKey1, "beijing.error")
		//sendMessage(ch, TopicExchange, RoutingKey2, "shanghai.fatal.red")
		time.Sleep(500 * time.Millisecond)
	}
	select {}
}

func GenChannel(conn *amqp.Connection) *amqp.Channel {
	ch, err := conn.Channel()
	if err != nil {
		log.Fatal(err)
	}
	return ch
}

func InitMQ(ch *amqp.Channel, queue, key, exchange string) {
	// 声明 exchange
	err := ch.ExchangeDeclare(exchange, "topic", true, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 声明 queue
	_, err = ch.QueueDeclare(queue, false, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 将 queue 与 exchange 和 key 绑定
	err = ch.QueueBind(queue, key, exchange, false, nil)
	if err != nil {
		panic(err)
	}

}

func InitDelayMQ(ch *amqp.Channel, queue, key, exchange string) {
	//申明交换机
	err := ch.ExchangeDeclare(exchange, "x-delayed-message",
		false, false, false, false,
		map[string]interface{}{"x-delayed-type": "direct"})
	if err != nil {
		log.Fatal(err)
	}
	// 声明 queue
	_, err = ch.QueueDeclare(queue, false, false, false, false, nil)
	if err != nil {
		panic(err)
	}
	// 将 queue 与 exchange 和 key 绑定
	err = ch.QueueBind(queue, key, exchange, false, nil)
	if err != nil {
		panic(err)
	}
}

func sendMessage(ch *amqp.Channel, exchange string, key string, message string) {
	err := ch.Publish(exchange, key, true, false, amqp.Publishing{
		Body: []byte(fmt.Sprintf("%v", message)),
	})
	if err != nil {
		panic(err)
	}

}

func sendDelayMessage(ch *amqp.Channel, exchange string, key string, message string, delay int) {
	err := ch.Publish(exchange, key, true, false, amqp.Publishing{
		Headers: map[string]interface{}{"x-delay": delay},
		Body:    []byte(fmt.Sprintf("%v", message)),
	})
	if err != nil {
		panic(err)
	}

}

func subscribe(ch *amqp.Channel, key string, queue string, callback func(<-chan amqp.Delivery, string)) {
	msgs, err := ch.Consume(queue, key, false, false, false, false, nil)

	if err != nil {
		panic(err)
	}
	callback(msgs, key)
}

func SetConfirm(ch *amqp.Channel, notifyConfirm chan amqp.Confirmation) {
	err := ch.Confirm(false)
	if err != nil {
		log.Println(err)
	}
	notifyConfirm = ch.NotifyPublish(make(chan amqp.Confirmation))
}

func ListenConfirm(notifyConfirm chan amqp.Confirmation) {
	for ret := range notifyConfirm {
		if ret.Ack {
			fmt.Println("消息发送成功")
		} else {
			fmt.Println("消息发送失败")
		}
	}
}

func NotifyReturn(notifyReturn chan amqp.Return, channel *amqp.Channel) {
	notifyReturn = channel.NotifyReturn(make(chan amqp.Return))
}
func ListReturn(notifyReturn chan amqp.Return) {
	ret := <-notifyReturn
	if string(ret.Body) != "" {
		fmt.Println("消息没有投递到队列:", string(ret.Body))
		panic("skfh")
	}
}

持久化

交换机持久化：

交换机持久化是指将交换机的属性数据存储在磁盘上，当 MQ 的服务器发生意外或关闭之后，在重启 RabbitMQ 时不需要重新手动或执行代码去创建交换机了，交换机会自动被创建，相当于一直存在。
在这里插入图片描述

队列持久化

如果不将队列设置为持久化，那么在 RabbitMQ 服务重启之后，相关队列的元数据会丢失，数据也会丢失。队列都没有了，消息也找不到地方存储了。
在这里插入图片描述

消息持久化

RabbitMQ 的消息是依附于队列存在的，所以要想消息持久化，那么前提是队列也必须设置持久化。
在创建消息的时候，添加一个持久化消息的属性（将 delivery_mode 设置为 2）。

在这里插入图片描述
设置了队列和消息的持久化，当 RabbitMQ 服务重启之后，消息依旧会存在；

仅设置队列持久化，重启之后消息会丢失；

仅设置消息持久化，重启之后队列会消失，因此消息也就丢失了，所以只设置消息持久化而不设置队列持久化是没有意义的；

将所有的消息都设置为持久化（写入磁盘的速度比写入内存的速度慢的多），可能会影响 RabbitMQ 的性能，对于可靠性不是那么高的消息可以不采用持久化来提高 RabbitMQ 的吞吐量。

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...