RabbitMQ的六种消息模式（golang实现）

于 2024-09-06 12:07:37 发布
阅读量1.1k 收藏 16
点赞数 28
分类专栏： golang 文章标签： rabbitmq golang 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46337064/article/details/141956201
版权

RabbitMQ 的主要作用

  1. 消息传递：

    • RabbitMQ 充当消息中介，将消息从生产者传递到消费者。它可以确保消息的可靠传输，即使接收者临时不可用，消息也能被妥善保存，等待消费。

  2. 异步处理：

    • 通过 RabbitMQ，应用程序可以将任务放入队列中，随后由一个或多个消费者异步处理。这种机制非常适合耗时较长的操作，如数据处理、文件转换等。

  3. 系统解耦：

    • RabbitMQ 使得生产者和消费者之间可以解耦。生产者只负责发送消息，而不关心消息的处理逻辑，消费者则可以独立地处理这些消息。

  4. 负载均衡：

    • RabbitMQ 支持多消费者的负载均衡模式，即同一个队列中的消息可以被多个消费者处理，从而实现任务的并行处理和系统的负载均衡。

  5. 消息路由：

    • RabbitMQ 提供了多种路由机制，通过不同类型的交换机（如 direct、fanout、topic、headers）将消息路由到合适的队列中，满足复杂的消息分发需求。

RabbitMQ 的优势

  1. 高可用性和可靠性：

    • RabbitMQ 支持持久化、镜像队列等机制，确保消息在系统故障或崩溃时不丢失，增强了消息传递的可靠性。

  2. 丰富的功能和灵活性：

    • RabbitMQ 提供了多种消息传递模式和高级特性，如消息确认、延迟队列、死信队列等，可以满足各种应用场景的需求。

  3. 可扩展性：

    • RabbitMQ 可以通过集群、分片和高可用性配置扩展其处理能力，支持从单节点到分布式集群的灵活部署，以满足不同规模的应用需求。

  4. 多语言支持：

    • RabbitMQ 支持多种编程语言，如 Go、Java、Python、Ruby、C# 等，使得它能够轻松集成到各种技术栈中。

  5. 社区支持和插件系统：

    • 作为一个成熟的开源项目，RabbitMQ 拥有活跃的社区支持，并提供丰富的插件来扩展其功能，如集成监控、管理 UI、流量控制等。

  6. 跨平台支持：

    • RabbitMQ 可以部署在各种操作系统上，如 Linux、Windows、macOS，同时支持在云环境中运行，如 AWS、Azure、Google Cloud 等。

典型使用场景

  • 异步任务处理：如电子邮件发送、图像处理、视频转换等后台任务。
  • 微服务间通信：在微服务架构中，RabbitMQ 可用于不同服务之间的事件通知和数据传输。
  • 事件驱动架构：通过 RabbitMQ，可以实现复杂的事件驱动系统，支持事件的广播和处理。
  • 日志收集：集中收集和处理分布式系统中的日志信息。
  • 实时消息传递：如即时消息应用、在线交易系统中的订单处理。

六种消息模式

Simple Work Queue（简单工作队列）

  • 这是最基本的模式，生产者将消息直接发送到队列，消费者从队列中取出消息进行处理
  • 适用于单一消费者的简单场景

Work Queue（工作队列）

  • 在此模式下，多个消费者从同一个队列中获取消息，实现任务的发布和负载均衡
  • 适用于需要多个消费者处理同一类型任务的场景

Publish/Subscribe（发布/订阅模式）

  • 生产者将消息发送到交换机，交换机将消息广播到与之绑定的所有队列，所有订阅的消费者都能收到消息
  • 适用于广播类型的消息，如通知或更新

Routing（路由模式）

  • 消息生产者将消息发送到交换机，并为消息指定一个路由键。交换机根据路由键将消息发送到与路由键匹配的队列
  • 适用于消息需要根据条件选择性地发送到不同场景

Topic（主题模式）

  • 与路由模式类似，但路由键可以是模糊匹配（如使用通配符）。交换机将消息发送到符合匹配规则的队列
  • 适用于消息需要更灵活的路由规则的场景，如日志分发系统

Remote Procedure Call（RPC模式）

  • 使用RabbitMQ来实现远程过程调用（RPC）。生产者发送请求消息，消费者处理请求并将结果发送回生产者
  • 适用于需要同步调用和返回结果场景

四种交换机（Exchange）

direct （直连交换机）

  • 将队列绑定到交换机，消息的 routeKey 需要与队列绑定的 routeKey 相同

Fanout（扇形交换机）

  • 不处理 routeKey ，直接把消息转发到与其绑定的所有队列中

Topic（主题交换机）

  • 根据一定的规则，根据 routeKey 把消息转发到符合规则的队列中，其中 # 用于匹配符合一个或者多个词（范围更广）， * 用于匹配一个词

Headers（头部交换机）

  • 根据消息的 headers 转发消息而不是根据 routeKey 来转发消息, 其中 header 是一个 Map，也就意味着不仅可以匹配字符串类型，也可以匹配其他类型数据。 规则可以分为所有键值对匹配或者单一键值对匹配
消息模式交换机
简单工作队列、工作队列空交换机
发布/订阅模式fanout（扇形交换机）
路由模式direct （直连交换机）
主题模式topic（主题交换机）
RPC模式direct （直连交换机）

Simple Work Queue（简单工作队列）

生产者将消息直接发送到队列，消费者从队列中取出消息进行处理

生产者代码

package main
// 生产者代码 send.go

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

// failOnError 处理错误使用，后续不再描述
func failOnError(err error, msg string) {
	if err != nil {
        // 打印 错误日志
		log.Panicf("%s: %s", msg, err)
	}
}

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

    // 2、建立通道
	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

    // 声明一个队列
	q, err := ch.QueueDeclare(
		"hello", // name 队列名称
		false,   // durable 是否持久化
		false,   // delete when unused  队列不再使用就删除
		false,   // exclusive 队列是否仅供当前连接使用
		false,   // no-wait 声明队列时是否等待RabbitMQ确认
		nil,     // arguments 传递额外的队列参数
	)
	failOnError(err, "Failed to declare a queue")
    // 创建一个带有超时的上下文，设置超时时间为5秒。在发送消息时，如果操作超时，上下文会取消操作
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
    // 消息体
	body := "Hello World!"
    // 用于将消息发布到指定的交换机
	err = ch.PublishWithContext(ctx,
		"",     // exchange 交换机
		q.Name, // routing key 路由键
		false,  // mandatory 消息是否必须路由到队列
		false,  // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")
	log.Printf(" [x] Sent %s\n", body)
}

消费者代码

package main
// 消费者代码 receive.go
import (
	"log"

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

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

func main() {
    // 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

    // 声明队列
	q, err := ch.QueueDeclare(
		"hello", // name
		false,   // durable
		false,   // delete when unused
		false,   // exclusive
		false,   // no-wait
		nil,     // arguments
	)
	failOnError(err, "Failed to declare a queue")

    // 注册消费者
	msgs, err := ch.Consume(
		q.Name, // queue 队列名称
		"",     // consumer 消费者的标签，通常用来标识不同的消费者实例
		true,   // auto-ack 表示是否自动确认消息。这里设置为 true，即消费者在接收到消息后会自动确认
		false,  // exclusive 队列是否仅供当前连接使用。这里设置为 false，即队列可以被多个消费者共享
		false,  // no-local 是否排除本地发送的消息。这里设置为 false，即本地发送的消息也会被消费者接收
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")
    // 定义一个空的通道 
	var forever chan struct{}

    // 启动一个新的协程，用于处理从队列中接收到的消息
	go func() {
		for d := range msgs {
			log.Printf("Received a message: %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for messages. To exit press CTRL+C")
	<-forever
}

执行

# 启动生产者
go run send.go
2024/08/29 14:16:55  [x] Sent Hello World, 你好!
# 启动消费者
go run receive.go
2024/08/29 14:16:50  [*] Waiting for messages. To exit press CTRL+C
2024/08/29 14:16:55 Received a message: Hello World, 你好!

Work Queue（工作队列）

通过将任务分发到多个工作者进行处理，能实现负载均衡、异步处理和容错性。它非常适合于后台任务处理、异步工作、分布式计算等场景。使用RabbitMQ或类似的消息队列系统，可以轻松地实现工作队列模式，提升系统的处理能力和效率。

img

生产者代码

package main
// 生产者代码 send.go
import (
	"context"
	"log"
	"os"
	"strings"
	"time"

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

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

func main() {
    // 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()
    // 声明队列
	q, err := ch.QueueDeclare(
		"task_queue", // name
		true,         // durable
		false,        // delete when unused
		false,        // exclusive
		false,        // no-wait
		nil,          // arguments
	)
	failOnError(err, "Failed to declare a queue")
    // 创建上下文
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
    // 获取消息体
	body := bodyFrom(os.Args)
	err = ch.PublishWithContext(ctx,
		"",           // exchange 交换机
		q.Name,       // routing key route key
		false,        // mandatory
		false,
		amqp.Publishing{
			DeliveryMode: amqp.Persistent,  // 设置消息的持久性。amqp.Persistent 表示消息是持久的
			ContentType:  "text/plain",
			Body:         []byte(body),
		})
	failOnError(err, "Failed to publish a message")
	log.Printf(" [x] Sent %s", body)
}

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
}

消费者代码

package main
//消费者代码 work.go

import (
	"bytes"
	"log"
	"time"

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

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

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	q, err := ch.QueueDeclare(
		"task_queue", // name
		true,         // durable
		false,        // delete when unused
		false,        // exclusive
		false,        // no-wait
		nil,          // arguments
	)
	failOnError(err, "Failed to declare a queue")

	err = ch.Qos(
		1,     // prefetch count 表示在消费者发送 ack 确认之前，RabbitMQ 允许同一消费者最多接收多少条未确认的消息
		0,     // prefetch size 以字节为单位，指定消费者在发送 ack 之前可以接收的消息总大小。这里设置为 0，表示没有限制
		false, // global 如果设置为 true，则 prefetch count 和 prefetch size 将对整个通道（所有消费者）生效。如果设置为 false，则仅对当前消费者生效
	)
	failOnError(err, "Failed to set QoS")

    // 注册消费者
	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		false,  // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		for d := range msgs {
			log.Printf("Received a message: %s", d.Body)
			dotCount := bytes.Count(d.Body, []byte(".")) // 统计点数
			t := time.Duration(dotCount) // 计算睡眠时间
			time.Sleep(t * time.Second)
			log.Printf("Done")
			d.Ack(false) // 确认消息，向RabbitMQ发送一个确认信号，表示该消息已被成功处理
		}
	}()

	log.Printf(" [*] Waiting for messages. To exit press CTRL+C")
	<-forever
}

执行

# shell1 启动消费者1
go run work.go
2024/08/29 14:55:53  [*] Waiting for messages. To exit press CTRL+C
2024/08/29 14:55:58 Received a message: 1
2024/08/29 14:55:58 Done
2024/08/29 14:56:03 Received a message: 3
2024/08/29 14:56:03 Done
2024/08/29 14:56:10 Received a message: 5
# shell2 启动消费者2
go run work.go 
2024/08/29 14:55:56  [*] Waiting for messages. To exit press CTRL+C
2024/08/29 14:56:00 Received a message: 2
2024/08/29 14:56:00 Done
2024/08/29 14:56:06 Received a message: 4
2024/08/29 14:56:06 Done

# shell3 启动生产者，传入不同参数
go run send.go 1
go run send.go 2
go run send.go 3
go run send.go 4
go run send.go 5

Publish/Subscribe（发布/订阅模式）

发布/订阅模式是一种非常灵活的消息传递模式，适用于需要将消息广播到多个订阅者的场景。它解耦了消息的生产者和消费者，支持多种交换机类型和路由策略，使得系统具有高扩展性和灵活性。在需要广播、事件通知或实时数据推送的应用场景中，发布/订阅模式是一种理想的选择。

发布者代码

package main
// 发布者代码 publish.go

import (
	"context"
	"log"
	"os"
	"strings"
	"time"

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

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

func main() {
	// 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	// 声明交换机
	err = ch.ExchangeDeclare(
		"logs",   // name 交换机名称
		"fanout", // type 交换机类型
		true,     // durable 持久化表示
		false,    // auto-deleted 消息自动删除
		false,    // internal
		false,    // no-wait
		nil,      // arguments
	)
	failOnError(err, "Failed to declare an exchange")

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

	body := bodyFrom(os.Args)
    // 用于将消息发布到指定的交换机
	err = ch.PublishWithContext(ctx,
		"logs", // exchange 交换机名称
		"",     // routing key
		false,  // mandatory
		false,  // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")

	log.Printf(" [x] Sent %s", body)
}

// 获取启动命令行参数
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
}

订阅者代码

package main
// 订阅者代码 subscribe.go

import (
	"log"

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

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

func main() {
	// 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	// 声明交换机
	err = ch.ExchangeDeclare(
		"logs",   // name
		"fanout", // type
		true,     // durable
		false,    // auto-deleted
		false,    // internal
		false,    // no-wait
		nil,      // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	// 建立队列
	q, err := ch.QueueDeclare(
		"",    // name
		false, // durable
		false, // delete when unused
		true,  // exclusive
		false, // no-wait
		nil,   // arguments
	)
	failOnError(err, "Failed to declare a queue")

	// 队列绑定（订阅）交换机
	err = ch.QueueBind(
		q.Name, // queue name
		"",     // routing key
		"logs", // exchange
		false,
		nil,
	)
	failOnError(err, "Failed to bind a queue")

	// 接收 消息
	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		for d := range msgs {
			log.Printf(" [x] %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for logs. To exit press CTRL+C")
	<-forever
}

执行，先执行订阅者，在执行发布者

# shell1 启动订阅者一
go run subscribe.go
2024/08/30 10:41:11  [*] Waiting for logs. To exit press CTRL+C
2024/08/30 10:42:11  [x] 震惊！拼多多大跳水
2024/08/30 10:42:41  [x] 一分钟速成
# shell2 启动订阅者二
go run subscribe.go
2024/08/30 10:41:11  [*] Waiting for logs. To exit press CTRL+C
2024/08/30 10:42:11  [x] 震惊！拼多多大跳水
2024/08/30 10:42:41  [x] 一分钟速成

#shell3 启动发布者
go run publish.go 震惊！拼多多大跳水
2024/08/30 10:42:11  [x] Sent 震惊！拼多多大跳水
go run publish.go 一分钟速成
2024/08/30 10:42:41  [x] Sent 一分钟速成

Routing（路由模式）

路由模式通过路由键和Direct Exchange实现了对消息的精确控制，允许消息定向发送到指定的队列。这种模式非常适合需要对消息进行分类处理的应用场景，如日志系统、任务分发、报警系统等。通过路由模式，可以确保每个消费者只接收和处理与其相关的消息，从而提高系统的灵活性和效率。

img

生产者代码

// 生产者代码 send.go
package main

import (
	"context"
	"log"
	"os"
	"strings"
	"time"

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

func main() {
	// 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	// 声明交换机
	err = ch.ExchangeDeclare(
		"logs_direct", // name 交换机名称
		"direct",      // type 交换机类型 直连交换机
		true,          // durable
		false,         // auto-deleted
		false,         // internal
		false,         // no-wait
		nil,           // arguments
	)
	failOnError(err, "Failed to declare an exchange")

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

	body := bodyFrom(os.Args)
	err = ch.PublishWithContext(ctx,
		"logs_direct",         // exchange
		severityFrom(os.Args), // routing key
		false,                 // mandatory
		false,                 // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")

	log.Printf(" [x] Sent %s", body)
}

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

func severityFrom(args []string) string {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "info"
	} else {
		s = os.Args[1]
	}
	return s
}

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

消费者代码

package main

// 消费者代码 work.go

import (
	"log"
	"os"

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

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

func main() {
	// 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	// 声明交换机
	err = ch.ExchangeDeclare(
		"logs_direct", // name 交换机名称
		"direct",      // type 交换机类型
		true,          // durable 持久化
		false,         // auto-deleted
		false,         // internal
		false,         // no-wait
		nil,           // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	// 声明队列
	q, err := ch.QueueDeclare(
		"",    // name 队列名称
		false, // durable 持久化
		false, // delete when unused
		true,  // exclusive
		false, // no-wait
		nil,   // arguments
	)
	failOnError(err, "Failed to declare a queue")

	if len(os.Args) < 2 {
		log.Printf("Usage: %s [info] [warning] [error]", os.Args[0])
		os.Exit(0)
	}
	for _, s := range os.Args[1:] {
		log.Printf("Binding queue %s to exchange %s with routing key %s",
			q.Name, "logs_direct", s)
		// 绑定交换机
		err = ch.QueueBind(
			q.Name,        // queue name 队列名
			s,             // routing key
			"logs_direct", // exchange
			false,
			nil)
		failOnError(err, "Failed to bind a queue")
	}

	// 接受消息
	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto ack
		false,  // exclusive
		false,  // no local
		false,  // no wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		for d := range msgs {
			log.Printf(" [x] %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for logs. To exit press CTRL+C")
	<-forever
}

执行代码

## 先启动消费者
## shell1 接受routing key 为info的消息
go run work.go info
2024/08/30 11:54:32 Binding queue amq.gen-QYGiiUUDVkpiiOwCOTcfJQ to exchange logs_direct with routing key info
2024/08/30 11:54:32  [*] Waiting for logs. To exit press CTRL+C
2024/08/30 11:56:09  [x] 你好，欢迎~

## shell2 接受routing key 为warn、error的消息
go run work.go warn error
2024/08/30 11:54:55 Binding queue amq.gen-dhxRepsx9kZY_TssKNq60Q to exchange logs_direct with routing key warn
2024/08/30 11:54:55 Binding queue amq.gen-dhxRepsx9kZY_TssKNq60Q to exchange logs_direct with routing key error
2024/08/30 11:54:55  [*] Waiting for logs. To exit press CTRL+C
2024/08/30 11:56:27  [x] 发出警告
2024/08/30 11:56:42  [x] 系统错误

## shell3 启动生产者
go run send.go info 你好，欢迎~
2024/08/30 11:56:09  [x] Sent 你好，欢迎~

go run send.go warn 发出警告
2024/08/30 11:56:27  [x] Sent 发出警告

go run send.go error 系统错误
2024/08/30 11:56:42  [x] Sent 系统错误

Topic（主题模式）

主题模式通过使用通配符和主题交换机，实现了灵活且强大的消息路由功能。它特别适合需要对消息进行复杂过滤和分类的场景，如日志系统、通知系统和事件驱动架构。在这些场景中，主题模式能够根据复杂的条件灵活地分发消息，确保消费者只接收和处理与其相关的消息。

主题模式使用通配符（‘*’ 和 '#’）进行消息路由。生产者发布的消息携带一个路由键（Routing Key），而消费者的队列通过绑定键（Binding Key）订阅与其匹配的消息。通配符允许绑定键匹配一组路由键，从而实现灵活的消息分发。

‘*****’：匹配单个单词。例如，绑定键为 log.* 时，可以匹配 log.info、log.error 等路由键。

‘#’：匹配零个或多个单词。例如，绑定键为 log.# 时，可以匹配 log.info、log.error、log.warn.high 等所有以 log. 开头的路由键。

img

生产者代码

package main

// 生产者 send.go
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() {
	// 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	// 声明交换机
	err = ch.ExchangeDeclare(
		"logs_topic", // name 交换机名称
		"topic",      // type 交换机类型 topic 主题模式
		true,         // durable 持久化
		false,        // auto-deleted 当所有与交换机绑定的队列都被删除时，交换机会自动删除。如果设置为 false，交换机不会自动删除。
		false,        // internal 如果设置为 true，交换机将是内部的，这意味着它不能被客户端直接使用，只能通过其他交换机进行路由。通常设置为 false
		false,        // no-wait ：如果设置为 true，表示不等待服务器返回结果。交换机声明后，立即继续执行后续代码，不等待确认。如果设置为 false，程序会等待服务器的确认，确保交换机成功声明
		nil,          // arguments
	)
	failOnError(err, "Failed to declare an exchange")

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

	body := bodyFrom(os.Args)
	err = ch.PublishWithContext(ctx,
		"logs_topic",          // exchange
		severityFrom(os.Args), // routing key
		false,                 // mandatory 如果设置为 true，则表示如果消息无法路由到任何队列，RabbitMQ 将返回该消息给发布者。如果设置为 false，消息将被丢弃
		false,                 // immediate 如果设置为 true，表示如果消息发送时，队列中没有消费者，消息将不会入队列，并返回给发布者。一般情况下，这个选项很少使用，通常设置为 false
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	failOnError(err, "Failed to publish a message")

	log.Printf(" [x] Sent %s", body)
}

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

func severityFrom(args []string) string {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "anonymous.info"
	} else {
		s = os.Args[1]
	}
	return s
}

消费者代码

package main

// 消费者 work.go

import (
	"log"
	"os"

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

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

func main() {
	// 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	// 声明交换机
	err = ch.ExchangeDeclare(
		"logs_topic", // name 交换机名称
		"topic",      // type 交换机类型
		true,         // durable 持久化
		false,        // auto-deleted 当所有与交换机绑定的队列都被删除时，交换机会自动删除。如果设置为 false，交换机不会自动删除。
		false,        // internal 如果设置为 true，交换机将是内部的，这意味着它不能被客户端直接使用，只能通过其他交换机进行路由。通常设置为 false
		false,        // no-wait ：如果设置为 true，表示不等待服务器返回结果。交换机声明后，立即继续执行后续代码，不等待确认。如果设置为 false，程序会等待服务器的确认，确保交换机成功声明
		nil,          // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	// 声明队列
	q, err := ch.QueueDeclare(
		"",    // name 队列名称 mq 自动生成
		false, // durable 持久化
		false, // delete when unused
		true,  // exclusive
		false, // no-wait
		nil,   // arguments
	)
	failOnError(err, "Failed to declare a queue")

	if len(os.Args) < 2 {
		log.Printf("Usage: %s [binding_key]...", os.Args[0])
		os.Exit(0)
	}
	for _, s := range os.Args[1:] {
		log.Printf("Binding queue %s to exchange %s with routing key %s",
			q.Name, "logs_topic", s)
		// 交换机绑定队列
		err = ch.QueueBind(
			q.Name,       // queue name 队列名
			s,            // routing key
			"logs_topic", // exchange
			false,
			nil)
		failOnError(err, "Failed to bind a queue")
	}

	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto ack
		false,  // exclusive
		false,  // no local
		false,  // no wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		for d := range msgs {
			log.Printf(" [x] %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for logs. To exit press CTRL+C")
	<-forever
}

执行

## 先启动消费者
## shell1 '#'表示接收所有消息
go run work.go #
2024/08/30 14:07:26 Binding queue amq.gen--Qe9R8VFRrL5ZPwP-9MwRg to exchange logs_topic with routing key #
2024/08/30 14:07:26  [*] Waiting for logs. To exit press CTRL+C
2024/08/30 14:07:30  [x] 欢迎来到本系统
2024/08/30 14:07:50  [x] 存在一个警告！
2024/08/30 14:08:28  [x] 发生了一个错误！！！
2024/08/30 14:08:59  [x] 错误解除了~

## shell2 接受warn开头或者error结尾的消息
go run work.go warn.* *.error
2024/08/30 14:07:22 Binding queue amq.gen-bZoWyLRq4GL9KD-Ecl_60w to exchange logs_topic with routing key warn.*
2024/08/30 14:07:22 Binding queue amq.gen-bZoWyLRq4GL9KD-Ecl_60w to exchange logs_topic with routing key *.error
2024/08/30 14:07:22  [*] Waiting for logs. To exit press CTRL+C
2024/08/30 14:07:50  [x] 存在一个警告！
2024/08/30 14:08:28  [x] 发生了一个错误！！！

## 启动生产者
## shell3 发送消息
go run send.go info.qwe 欢迎来到本系统
2024/08/30 14:07:30  [x] Sent 欢迎来到本系统
go run send.go warn.system 存在一个警告！
2024/08/30 14:07:50  [x] Sent 存在一个警告！
go run send.go gateway.error 发生了一个错误！！！
2024/08/30 14:08:28  [x] Sent 发生了一个错误！！！
go run send.go info.info 错误解除了~
2024/08/30 14:08:59  [x] Sent 错误解除了~

Remote Procedure Call（RPC模式）

RPC 模式通过模拟本地方法调用，实现了远程服务之间的高效通信。在分布式系统、微服务架构和跨语言调用等场景中，RPC 模式极大地简化了服务之间的交互，同时确保了请求和响应的匹配和处理。RabbitMQ 提供了可靠的消息传递机制，使得 RPC 模式更加健壮和可扩展。

客户端-服务器模型， 在 RPC 模式中，客户端发出请求，服务器端执行相应的操作并返回结果。这种模式模拟了本地函数调用的方式，使得远程服务调用看起来像是本地调用

请求/响应机制， 客户端发送请求消息，服务器处理后返回响应消息。每个请求都期望一个对应的响应，这种一对一的消息模式确保了客户端能够收到并处理来自服务器的返回值。

唯一的Correlation ID，每个请求都带有一个唯一的 Correlation ID，服务器处理完成后将该 ID 返回给客户端。客户端通过 Correlation ID 来匹配请求和响应，从而确保多个并发请求的结果不会混淆。

客户端代码

package main

// 客户端代码 client.go
import (
	"context"
	"log"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"time"

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

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

// randomString 获取随机字符串
func randomString(l int) string {
	bytes := make([]byte, l)
	for i := 0; i < l; i++ {
		bytes[i] = byte(randInt(65, 90))
	}
	return string(bytes)
}

// 获取随机数
func randInt(min int, max int) int {
	return min + rand.Intn(max-min)
}

// 调用服务请求结果
func fibonacciRPC(n int) (res int, err error) {
	// 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	// 声明队列
	q, err := ch.QueueDeclare(
		"",    // name
		false, // durable
		false, // delete when unused
		true,  // exclusive
		false, // noWait
		nil,   // arguments
	)
	failOnError(err, "Failed to declare a queue")

	// 接收消息
	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	// 唯一的Correlation ID
	corrId := randomString(32)

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

	// 发送消息
	err = ch.PublishWithContext(ctx,
		"",          // exchange
		"rpc_queue", // routing key
		false,       // mandatory
		false,       // immediate
		amqp.Publishing{
			ContentType:   "text/plain",
			CorrelationId: corrId,
			ReplyTo:       q.Name,
			Body:          []byte(strconv.Itoa(n)),
		})
	failOnError(err, "Failed to publish a message")

	for d := range msgs {
		if corrId == d.CorrelationId {
			// 解析结果
			res, err = strconv.Atoi(string(d.Body))
			failOnError(err, "Failed to convert body to integer")
			break
		}
	}

	return
}

func main() {
	// 随机序列
	rand.Seed(time.Now().UTC().UnixNano())

	n := bodyFrom(os.Args)

	log.Printf(" [x] Requesting fib(%d)", n)
	res, err := fibonacciRPC(n)
	failOnError(err, "Failed to handle RPC request")

	log.Printf(" [.] Got %d", res)
}

func bodyFrom(args []string) int {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "30"
	} else {
		s = strings.Join(args[1:], " ")
	}
	n, err := strconv.Atoi(s)
	failOnError(err, "Failed to convert arg to integer")
	return n
}

服务端代码

package main

// 服务端代码 server.go
import (
	"context"
	amqp "github.com/rabbitmq/amqp091-go"
	"log"
	"strconv"
	"time"
)

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

// fib 求斐波拉契
func fib(n int) int {
	if n == 0 {
		return 0
	} else if n == 1 {
		return 1
	} else {
		return fib(n-1) + fib(n-2)
	}
}

func main() {
	// 建立连接
	conn, err := amqp.Dial("amqp://guest:guest@localhost: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()

	// 声明队列
	q, err := ch.QueueDeclare(
		"rpc_queue", // name
		false,       // durable
		false,       // delete when unused
		false,       // exclusive
		false,       // no-wait
		nil,         // arguments
	)
	failOnError(err, "Failed to declare a queue")

	err = ch.Qos(
		1,     // prefetch count 表示在消费者发送 ack 确认之前，RabbitMQ 允许同一消费者最多接收多少条未确认的消息
		0,     // prefetch size 以字节为单位，指定消费者在发送 ack 之前可以接收的消息总大小。这里设置为 0，表示没有限制
		false, // global 如果设置为 true，则 prefetch count 和 prefetch size 将对整个通道（所有消费者）生效。如果设置为 false，则仅对当前消费者生效
	)
	failOnError(err, "Failed to set QoS")

	// 接收消息
	msgs, err := ch.Consume(
		q.Name, // queue
		"",     // consumer
		false,  // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	var forever chan struct{}

	go func() {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		for d := range msgs {
			// 获取消息
			n, err := strconv.Atoi(string(d.Body))
			failOnError(err, "Failed to convert body to integer")

			log.Printf(" [.] fib(%d)", n)
			// 计算结果
			response := fib(n)

			// 发送消息
			err = ch.PublishWithContext(ctx,
				"",        // exchange
				d.ReplyTo, // routing key
				false,     // mandatory
				false,     // immediate
				amqp.Publishing{
					ContentType:   "text/plain",
					CorrelationId: d.CorrelationId,
					Body:          []byte(strconv.Itoa(response)),
				})
			failOnError(err, "Failed to publish a message")
			// 确认消息已被成功使用
			d.Ack(false)
		}
	}()

	log.Printf(" [*] Awaiting RPC requests")
	<-forever
}

执行

## 先启动服务端，在启动客户端
# shell1 
go run client.go
2024/08/30 14:41:53  [x] Requesting fib(30)
2024/08/30 14:41:54  [.] Got 832040
# shell2
go run server.go
2024/08/30 14:41:48  [*] Awaiting RPC requests
2024/08/30 14:41:54  [.] fib(30)

点击获取本篇文章源码

小镇cxy
关注
专栏目录
RabbitMQ的消息模式
大人的博客
03-11 1171
1.简单模式 简单模式是最简单的消息模式，它包含一个生产者、一个消费者和一个队列。生产者向队列里发送消息，消费者从队列中获取消息并消费。 2.工作模式 工作模式是指向多个互相竞争的消费者发送消息的模式，它包含一个生产者、两个消费者和一个队列。两个消费者同时绑定到一个队列上去，当消费者获取消息处理耗时任务时，空闲的消费者从队列中获取并消费消息。 ...
RabbitMQ之消息模式(一)
qq_44847231的博客
12-06 216
文章目录消息100%的投递幂等性概念Confirm确认消息Return返回消息自定义消费者 消息100%的投递 消息如何保障100%的投递成功？ 什么是生产端的可靠性投递？ 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行补偿机制 BAT/TMD互联网大厂的解决方案： 消息落库，对消息状态进行打标 消息的延迟投递，做二次确认，回调检查 ...
RabbitMQ 从原理到实战—golang版本
最新发布
小张编程旅途的博客
08-22 1385
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。特点：基于AMQP协议来实现。主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。可靠性：采用一系列机制来确保消息的可靠性，如持久化、传输确认和发布确认等方法。
RabbitMQ消息模式(二)
what_to的博客
12-07 342
@TOC 1、消费端限流 什么是消费端的限流？ 假设一个场景，首先，我们RabbitMQ服务器有上万条未处理的消息，我们随便打开一个消费者客户端，会出现下面情况： 巨量的消息瞬间全部推送过来，但是我们单个客户端无法同时处理这么多数据！ 消费端限流RabbitMQ提供的解决方案 RabbitMQ提供了一种qos（服务质量保证）功能，即在非自动确认消息的前提下，如果一定数目的消息（通过基于Consum...
【Rabbitmq的消息模型】
m0_50116974的博客
08-06 1418
如上模型，如果是循环的分发方式，Consumer-1一次性被分到的消息为1，3，5号消息，Consumer-2一次性被分到的消息为2，4，6号消息。如果开启消息自动确认，那么一旦MQ把消息发送给消费者，那么该消息就会立即标记为删除。例如，有编号1-10的消息在MQ中，同时存在两个消费者，则消费者A分到的消息为1，3，5，7，9，消费者B分到的消息为2，4，6，8，10。的分发消息的方式，消费能力强的消费者就会被分到更多的消息，消费能力弱的消费者就会被分到更少的消息，该方式需要作额外设置。
通过golang实现RabbitMQ的五种模式
wwhl.wang
08-15 1983
撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>> 本文永久更新地址：https://my.oschina.net/bysu/blog/3092864 推荐一款免费的自购省钱，分享赚钱的平台——赚赚熊，感兴趣的，特别是家里有婆娘专职带娃的，请看文末。 0.先安装配置好RabbitMQ，参考《window10下RabbitMQ的安装及入门使用》 1.执...
RabbitMQ从原理到实战—基于Golang【万字详解】
weixin_44545838的博客
08-27 5088
最近秋招开始找工作，顺便回顾消息队列并且总结。
RabbitMQ（Golang版本）
qq_42649688的博客
06-11 2410
一、RabbitMQ 简介 消息队列是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是/用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。 二、使用场景 1.解耦 场景说明：用户下单后，订单系统需要通知库存系统。传统的做法是，订单系统调用库存系统的接口。 传统模式的缺点： 如
Golang之消息队列——RabbitMQ的使用
QianLiStudent的博客
01-21 6556
消息队列的使用场景 异步处理       异步是指不用一次性执行完，可以先去执行别的，等这边回应了再做处理。这里我就拿一个网上用烂的例子：用户注册。用户在正确填写信息后点击注册，这时会发起网络请求到后端去做数据合法性等的验证，一旦验证通过则会将数据写入数据库并返回注册成功类的信息。但现在很多的应用都会有短信、邮箱等其他媒介的额外通知，这些...
Golang操作RabbitMQ详细教程
太阳上的雨天
07-26 717
Golang操作RabbitMQ详细教程
RabbitMQ消息模式
weixin_43654482的博客
02-28 371
文章目录消息如何保证100%的投递消息100%的投递幂等性概念幂等性是什么Confirm确认消息理解Confirm消息确认机制如何实现Confirm确认消息Return返回消息自定义消费者 消息如何保证100%的投递 消息100%的投递 消息如何保障100%的投递成功 什么是生产端的可靠性投递？ 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行...
RabbitMQ消息模式一
only老K的博客 qq:1025271924
03-03 361
博客内容消息如何100%投递幂等性概念Confirm确认消息Return返回信息自定义消费 消息如何100%投递 幂等性概念 Confirm确认消息 Return返回信息 自定义消费
RabbitMQ消息模式（消息100%的投递、幂等性概念）
weixin_42687829的博客
02-15 404
1、什么是生产端的可靠性投递 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行补偿机制 2、BAT/TMD互联网大厂解决生产端的可靠性投递的方案 消息落库，对消息状态进行打标，流程图如下： 消息的延迟投递，做二次确认，回调检查，流程图如下： 3、幂等性是什么 可以参考数据库乐观锁机制，比如执行一条更新库存的 SQL 语句，在...
RabbitMQ消息模式（消费端限流 、消息的ACK与重回队列 、TTL消息 、死信队列）
wx1762813417的博客
03-03 422
文章目录1、消费端限流2、消息的ACK与重回队列3、TTL消息4、死信队列 1、消费端限流 什么是消费端的限流？ 假设一个场景，首先，我们RabbitMQ服务器有上万条未处理的消息，我们随便打开一个消费者客户端，会出现下面情况：巨量的消息瞬间全部推送过来，但是我们单个客户端无法同时处理这么多数据！ 消费端限流RabbitMQ提供的解决方案? RabbitMQ提供了一种qos（服务质量保证）功...
RabbitMQ消息模式2
xfz610614的博客
03-03 184
文章目录一、消费端限流什么是消费端的限流？消费端限流RabbitMQ提供的解决方案4示例代码二、消息的ACK与重回队列消费端手工ACK与NACK消费端的重回队列示例代码三、TTL消息TTL简介示例代码四、死信队列死信队列：DLX，Dead-Letter-Exchange消息变成死信有以下几种情况死信队列的特点死信队列设置示例代码 一、消费端限流 什么是消费端的限流？ 假设一个场景，首先，我们Rab...
RabbitMQ消息队列入门与五种应用模式详解
2. Work Queue模式：Work Queue模式是RabbitMQ的一种模式，多个consumer可以从同一个队列中消费消息，从而实现任务的并行处理。 3. Publish/Subscribe模式：Publish/Subscribe模式是一种基于主题的消息队列模式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值