Golang学习笔记_RabbitMQ的原理架构和使用

最新推荐文章于 2024-08-07 16:20:51 发布
最新推荐文章于 2024-08-07 16:20:51 发布
阅读量1.2k 收藏 9
点赞数 21
文章标签： golang 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HideonHacker/article/details/137835799
版权

RabbitMQ 简介

  1. 实现了高级消息队列协议（Advanced Message Queuing Protcol）AMQP
  2. 消息队列中间件的作用（Redis实现MQ里面有写过，这里简单带过）
    1. 解耦
    2. 削峰
    3. 异步处理
    4. 缓存
    5. 消息通信
    6. 提高扩展性

RabbitMQ 架构理解

channel
binding
channel
channel
channel
Producer 生产者
Exchange交换机
Queue消息队列
Consumer消费者
Consumer消费者
Consumer消费者
  1. binding(绑定)：交换机将消息路由给Queue所遵循的规则，可以定义一个路由键，用于交换机筛选特定的Queue
    1. Routing_Key(路由键)：Producer 和 Consumer 协商一致的 key 策略。主要在交换机的 direct(直连)和 topic(主题) 模式下使用，fanout(广播)模式下不使用Routing_Key
  2. Exchange(交换机)：主要功能是分发消息给特定的Queue，只负责转发，不具备存储消息的功能。Exchange有以下四种模式：
    1. direct(直连模式)，根据携带的Routing_Key来筛选特定的Queue进行消息投递。是RabbitMQ的默认类型，可以不指定Routing_Key，在创建时会默认生成与Queue重名。
    2. hander(头模式)，使用场景不多，消息路由涉及多个属性的时候，交换机使用多属性来代替Routing_key建立路由规则，还可以定义匹配单词的个数，例如any为有一个单词满足条件就匹配成功。all为所有单词都满足条件才匹配成功。
    3. fanout(广播模式)，不看Routing_Key。只根据Exchange和Queue的binding情况来分发信息。所有与之binding的queue都将接收到同一条消息。
    4. topic(主题模式)，相当于模糊查询。topic的routing_key是使用 . 来进行隔断的。有两种匹配方法：
      1. " * " 匹配一个单词，例子如下
      2. " # " 匹配0个~多个单词，例子如下
rabbitMQ.* == rabbitMQ.topic != rabbitMQ.topic.topic
rabbitMQ.# == rabbit.topic == rabbit.topic.topic
  1. Queue（消息队列的存储数据结构）：
    1. 存储方式：
      • 持久化，在Server本地硬盘存储一份
      • 临时队列，重启后丢失数据
      • 自动删除，不存在用户连接则删除queue
    2. 队列对ACK请求的不同情况
      • consumer 接收并 ack，queue 删除数据并向 consumer 发送新消息
      • consumer 接收但是未 ack 就断开了连接，queue 会认为消息并未传送成功，consumer 再次连接时会重新发送消息
      • 如果consumer 接收消息成功 ，但是忘记 ack 则 queue 不会重复发送消息
      • 如果 consumer 拒收消息，则 queue 会向另外满足条件的 consumer 继续发送这条消息

RabbitMQ 工作流程

Producer方向
  1. Producer 与 RabbitMQ Broker 建立连接，开启一个信道 channel
  2. 声明交换机并设置属性（交换机类型、持久化等）
  3. 声明Queue并设置属性（持久化，自动删除等）
  4. 通过Routing_key来binding交换机和Queue
  5. 发送信息给交换，交换机根据Routing_key来确认投递的queue
  6. 查找成功后将消息存到queue
  7. 查找失败将消息丢弃或抛回给生产者
  8. 关闭channel
Consumer方向
  1. 与 queue 建立连接，开启channel
  2. 向queue请求队列中的msg
  3. 等待queue回应，开始接收消息
  4. 消息处理完成后 返回回调确认ack
  5. queue 将确认的消息从队列中删除
  6. 关闭channel

RabbitMQ的两种部署方式

Meta Data ： 元数据（描述数据的数据）

  • vhost meta data : 为Queue、Exchange、Binding提供命名空间级别的隔离
  • exchange meta data：记录路由的名称类型和属性
  • binding mate data：映射 routing_key和queue之间的绑定关系
  • queue mate data：表队列名称和属性
普通模式

对于该模式的两个节点，消息只会存在其中一个节点，另一个节点只保存mate data，当consumer 连接节点2访问节点1的数据信息时，消息会在两个节点中传递。
该模式下p和c应尽量连接每个节点，这样起到线性拓展的作用。
但存在一个问题，如果节点上还有未消费的消息，但是节点挂了。如果节点设置了持久化，则需要在节点重启的时候消息才会恢复。如果未设置持久化，则消息会丢失。

镜像模式

消息存在多个节点中，消息会在节点与节点之间同步，可实现高可用（当一个节点挂了，另一个节点可以接替其位置，继续工作）但会降低性能，因为大量消息进入和同步，会占用大量带宽，但是为了保证高可靠性需要取舍。

面试题

  • Q：如何保证消息不被重复消费？
    • A：MQ通过确认机制ACK，进行确认。确认后消息从queue中删除，保证消息不被重复消费的。如果因为网络原因ack没有成功发出，导致消息重新投递。可以使用全局唯一消息id来避免。
    1. 消息发送者发送消息时携带一个全局唯一的消息id
    2. 消费者监听到消息后，根据id在redis或者db中查询是否存在消费记录
    3. 如果没有消费就正常消费，消费完毕后，写入redis或者db
    4. 如果消息消费过则直接丢弃
  • Q：如何保证消息的消费顺序？
    • A：RabbitMQ中存在一个设置，叫独占队列。即在同一时间只有一个消费者会消费消息。从而制止了异步操作，保证消费顺序。或者一个Producer对一个Consumer
  • Q：如何保证数据一致性？
    • A：因为MQ的使用场景多为分布式系统，所以一般不追求强一致性。而保证最终一致性就可以。
    • 而保证数据最终一致性，可以采用消息补偿机制。即消息在消费者处理完之后调用生产者的API修改数据状态。如未调用API则判断为消息处理失败或出错。此时间隔一段时间后重新投递消息进行再次操作。
    • 消费者收到消息，处理完毕后，发送一条响应消息给生产者也是消息补偿机制，本意是确认消费者成功消费消息。ACK也是处理方法

RabbitMQ的使用（Golang使用amqp包）

代码部分参考 upup小亮的博客

代码只是简单的操作，主要是熟悉流程。对于如何创建Queue和绑定Exchange之类的操作有个了解。

Simple（简单收发模式，只有一个Queue）

Simple运行机制与WorkQueue相似，只是一个Consumer与多个Consumer的区别。多个Consumer之间存在竞争关系，所以工作队列是创建多个Consumer，多个竞争只有一个可以获取消息消费。消费成功后ack消息删除。
演示代码放到一起了：

WorkQueue 工作队列

生产者

// simple and work queue
func main2() {
	// 连接到 rabbitMQ
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil {
		log.Fatalf("无法创建连接:%s", err)
		return
	}
	// 默认关闭
	defer conn.Close()

	// 创建通道Channel
	ch, err := conn.Channel()
	if err != nil {
		log.Fatalf("无法创建channel:%s", err)
		return
	}
	// 通道关闭
	defer ch.Close()

	// 创建存储队列
	queue, err := ch.QueueDeclare(
		"hello", // 队列名称
		false, // 持久化设置，可以为true根据需求选择
		false, // 自动删除，没有用户连接删除queue一般不选用
		false, //独占
		false, //等待服务器确认
		nil)   //参数
	if err != nil {
		fmt.Println(err)
		log.Fatalf("无法声明队列:%s", err)
		return
	}

	var body string
	// 发送信息
	for i := 0; i < 10; i++ {
		fmt.Println(i)
		body = "Hello RabbitMQ" + string(i)
		err = ch.Publish(
			"",
			queue.Name,
			false, // 必须发送到消息队列
			false, // 不等待服务器确认
			amqp.Publishing{
				ContentType: "text/plain",
				Body:        []byte(body),
			})
		if err != nil {
			log.Fatalf("消息生产失败:%s", err)
			continue
		}
	}
}

消费者

	// create conn
	// 如果同时运行两个这样的consumer代码，就是工作队列。只有一个consumer就是simple
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil {
		log.Fatalf("无法创建连接:%s", err)
		return
	}
	defer conn.Close()

	// create channel
	ch, err := conn.Channel()
	if err != nil {
		log.Fatalf("无法创建channel:%s", err)
		return
	}
	defer ch.Close()
	// create queue
	queue, err := ch.QueueDeclare(
		"hello",
		false,
		false,
		false,
		false,
		nil)
	if err != nil {
		log.Fatalf("无法创建queue:%s", err)
		return
	}
	
	// 消费信息

	msgs, err := ch.Consume(
		queue.Name,
		"",
		true,
		false,
		false,
		false,
		nil)
	if err != nil {
		log.Fatalf("无法消费信息:%s", err)
		return
	}
	for msg := range msgs {
		log.Println(string(msg.Body))
	}
	return

pub/sub 发布订阅模式

发布订阅模式可以创建两个Queue，绑定到同一个Exchange中
生产者这边只需要跟交换机对接，而交换机类型为fanout：

func main() {
	// 连接到 rabbitMQ
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil {
		log.Fatalf("无法创建连接:%s", err)
	}
	// 默认关闭
	defer conn.Close()

	// 创建通道Channel
	ch, err := conn.Channel()
	if err != nil {
		log.Fatalf("无法创建channel:%s", err)
	}
	defer ch.Close()

	// create exchange
	ex := ch.ExchangeDeclare(
		"exchange1", // 交换机名称
		"fanout",    // 交换机类型
		true,        // 是否持久化
		false,       // 是否自动删除
		false,       // 是否内部使用
		false,       // 是否等待服务器响应
		nil,         // 其他属性
	)
	fmt.Println(ex)

	body := "Hello RabbitMQ for Pub/Sub"
	err = ch.Publish(
		"exchange1",
		"", // routing key 可以为空，因为fanout不看routing key
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		})
	if err != nil {
		log.Fatalf("err %s:", err)
	}
	log.Println(body)
}

消费者：创建交换机，类型为fanout，创建队列，绑定交换机（创建多个consumer绑定同一个queue和同一个交换机。这样发送一个消息，所有的consumer都能收到。== 发布订阅模型）

	// Pub/Sub
	// Create conn
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil{
		log.Fatalf(err)
	}
	defer conn.Close()

	// channel create
	ch, err := conn.Channel()
	if err != nil{
		log.Fatalf(err)
	}
	defer ch.Close()

	// exchange create
	ex := ch.ExchangeDeclare(
		"exchange1",
		"fanout",
		true,
		false,
		false,
		false,
		nil)

	fmt.Println(ex)

	// queue create
	queue, err := ch.QueueDeclare(
		"hello",
		false,
		false,
		false,
		false,
		nil)
	if err != nil{
		log.Fatalf(err)
	}
	err = ch.QueueBind(
		queue.Name,
		"",
		"exchange1",
		false,
		nil)
	if err != nil{
		log.Fatalf(err)
	}

	msgs, err := ch.Consume(
		queue.Name,
		"",
		true,
		false,
		false,
		false,
		nil)
	if err != nil{
		log.Fatalf(err)
	}
	go func() {
		for d := range msgs {
			log.Printf("Received a message: %s", d.Body)
		}
	}()

	log.Printf("Waiting for messages. To exit press CTRL+C")
	<-make(chan struct{}) // 阻塞主goroutine
}

Routing 模式（对特定的队列投递消息）

生产者

func main() {
	// 连接到 rabbitMQ
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil {
		log.Fatalf("无法创建连接:%s", err)
	}
	// 默认关闭
	defer conn.Close()

	// 创建通道Channel
	ch, err := conn.Channel()
	if err != nil {
		log.Fatalf("无法创建channel:%s", err)
	}
	defer ch.Close()

	// create exchange
	ex := ch.ExchangeDeclare(
		"exchange1", // 交换机名称
		"direct",    // 交换机类型
		true,        // 是否持久化
		false,       // 是否自动删除
		false,       // 是否内部使用
		false,       // 是否等待服务器响应
		nil,         // 其他属性
	)
	fmt.Println(ex)
	body := "Hello RabbitMQ for direct routing"
		// 发布消息到交换机，并指定路由键
	err = ch.Publish(
		"logs_direct", // 交换机名称
		"routing_key", // 路由键
		false,         // 是否等待服务器响应
		false,         // 是否立即将消息写入磁盘
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
		},
	)
	if err != nil{
		log.Fatalf("无法创建send msg:%s", err)
	}
	log.Printf("Sent message: %s", message)

消费者

func main() {
	// 连接到RabbitMQ服务器
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil{
		log.Fatalf("无法创建send msg:%s", err)
	}
	defer conn.Close()

	// 创建一个通道
	ch, err := conn.Channel()
	if err != nil{
		log.Fatalf("无法创建send msg:%s", err)
	}
	defer ch.Close()

	// 声明一个交换机
	err = ch.ExchangeDeclare(
		"logs_direct", // 交换机名称
		"direct",      // 交换机类型
		true,          // 是否持久化
		false,         // 是否自动删除
		false,         // 是否内部使用
		false,         // 是否等待服务器响应
		nil,           // 其他属性
	)
	if err != nil{
		log.Fatalf("无法创建send msg:%s", err)
	}

	// 声明一个临时队列
	q, err := ch.QueueDeclare(
		"",    // 队列名称，留空表示由RabbitMQ自动生成,因为定义了key所以队列名可以是随意的，毕竟是依靠key来进行匹配的
		false, // 是否持久化
		false, // 是否自动删除（当没有任何消费者连接时）
		true,  // 是否排他队列（仅限于当前连接）
		false, // 是否等待服务器响应
		nil,   // 其他属性
	)
	// 将队列绑定到交换机上，并指定要接收的路由键
	err = ch.QueueBind(
		q.Name,        // 队列名称
		"routing_key",      // 路由键
		"logs_direct", // 交换机名称
		false,         // 是否等待服务器响应
		nil,           // 其他属性
	)
	if err != nil{
		log.Fatalf("无法创建send msg:%s", err)
	}

	// 订阅消息
	msgs, err := ch.Consume(
		q.Name, // 队列名称
		"",     // 消费者标识符，留空表示由RabbitMQ自动生成
		true,   // 是否自动应答
		false,  // 是否独占模式（仅限于当前连接）
		false,  // 是否等待服务器响应
		false,  // 其他属性
		nil,    // 其他属性
	)
	failOnError(err, "Failed to register a consumer")

	// 接收消息的goroutine
	go func() {
		for d := range msgs {
			log.Printf("Received a message: %s", d.Body)
		}
	}()

	log.Printf("Waiting for messages. To exit press CTRL+C")
	<-make(chan struct{}) // 阻塞主goroutine

topic

func main() {
	// 连接到RabbitMQ服务器
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil{
		log.Fatalf(err)
	}
	defer conn.Close()

	// 创建一个通道
	ch, err := conn.Channel()
	if err != nil{
		log.Fatalf(err)
	}
	defer ch.Close()

	// 声明一个交换机
	err = ch.ExchangeDeclare(
		"logs_topic", // 交换机名称
		"topic",      // 交换机类型
		true,         // 是否持久化
		false,        // 是否自动删除
		false,        // 是否内部使用
		false,        // 是否等待服务器响应
		nil,          // 其他属性
	)
	if err != nil{
		log.Fatalf(err)
	}

	// 定义要发送的消息的路由键和内容
	routingKey := "example.key.das"
	message := "Hello, RabbitMQ!"

	// 发布消息到交换机，并指定路由键
	err = ch.Publish(
		"logs_topic", // 交换机名称
		routingKey,   // 路由键
		false,        // 是否等待服务器响应
		false,        // 是否立即发送
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		},
	)
	if err != nil{
		log.Fatalf(err)
	}

	log.Printf("Sent message: %s", message)
}

消费者

func main() {
	// 连接到RabbitMQ服务器
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil{
		log.Fatalf(err)
	}
	defer conn.Close()

	// 创建一个通道
	ch, err := conn.Channel()
	if err != nil{
		log.Fatalf(err)
	}
	defer ch.Close()

	// 声明一个交换机
	err = ch.ExchangeDeclare(
		"logs_topic", // 交换机名称
		"topic",      // 交换机类型
		true,         // 是否持久化
		false,        // 是否自动删除
		false,        // 是否内部使用
		false,        // 是否等待服务器响应
		nil,          // 其他属性
	)
	if err != nil{
		log.Fatalf(err)
	}

	// 声明一个临时队列
	q, err := ch.QueueDeclare(
		"",    // 队列名称，留空表示由RabbitMQ自动生成
		false, // 是否持久化
		false, // 是否自动删除（当没有任何消费者连接时）
		true,  // 是否排他队列（仅限于当前连接）
		false, // 是否等待服务器响应
		nil,   // 其他属性
	)
	if err != nil{
		log.Fatalf(err)
	}

	// 将队列绑定到交换机上，并指定要接收的路由键
	err = ch.QueueBind(
		q.Name,       // 队列名称
		"example.#",  // 路由键，可以使用通配符*匹配一个单词
		"logs_topic", // 交换机名称
		false,        // 是否等待服务器响应
		nil,          // 其他属性
	)
	if err != nil{
		log.Fatalf(err)
	}
	// 创建一个消费者通道
	msgs, err := ch.Consume(
		q.Name, // 队列名称
		"",     // 消费者标识符，留空表示由RabbitMQ自动生成
		true,   // 是否自动应答
		false,  // 是否排他消费者
		false,  // 是否阻塞
		false,  // 是否等待服务器响应
		nil,    // 其他属性
	)
	if err != nil{
		log.Fatalf(err)
	}
	// 接收和处理消息
	forever := make(chan bool)

	go func() {
		for d := range msgs {
			log.Printf("Received a message: %s", d.Body)
		}
	}()

	log.Printf("Waiting for messages...")
	// 阻塞
	<-forever
}
DDDerek~
关注
  • 21
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Golang操作RabbitMQ详细教程
太阳上的雨天
07-26 697
Golang操作RabbitMQ详细教程
golang操作RabbitMq的使用
qq_42011039的博客
07-02 881
官网：https://www.rabbitmq.com/getstarted.html视频：https://www.bilibili.com/video/BV15k4y1k7Ep?
GoLong的学习之路，进阶，RabbitMQ （消息队列）
Cheer_RIO的博客
11-28 2059
快有一周没有写博客了。前面几天正在做项目。正好，项目中需要MQ（消息队列），这里我就补充一下我对mq的理解。其实在学习java中的时候，自己也仿照RabbitMQ自己实现了一个单机的mq，但是mq其中一个特点也就是，分布式我在项目中没有涉及。这里我用go语言将RabbitMQ的操作进行一次整理。
golang使用rabbitmq（六）RPC
独自登高楼 望断天涯路
09-05 1235
之前的章节都是在说一方发指令，另一方执行这种情况，指令发送者不关系指令的完成情况，或者不需要阻塞去获得结果，结果异步通知。 但很多时候是需要阻塞得去获得执行结果的，比如http的请求。 在rabbitmq使用RPC的关键就是ReplyTo属性 err = ch.ExchangeDeclare("rpc_topic", amqp.ExchangeTopic, true, false, false, ...
windows10环境下的RabbitMQ安装步骤（图文）
weixin_37474878的博客
09-13 199
记录下本人在win10环境下安装RabbitMQ的步骤，以作备忘。 第一步：下载并安装erlang 原因：RabbitMQ服务端代码是使用并发式语言Erlang编写的，安装Rabbit MQ的前提是安装Erlang。 下载地址：http://www.erlang.org/downloads 根据本机位数选择erlang下载版本。 下载完是这么个东西： 双击，点next就可以。 ...
golang操作rabbitmq
qq_29744347的博客
06-16 749
golang 操作rabbitmq
RabbitMQ从原理到实战—基于Golang【万字详解】
weixin_44545838的博客
08-27 4428
最近秋招开始找工作，顺便回顾消息队列并且总结。
GoLang学习资源_学习笔记和并发编程实战
09-06
2015年的版本虽然不是最新，但其中的基本原理和实践策略至今仍然适用，对于理解Go的并发模型至关重要。 Go语言的并发模型基于CSP（Communicating Sequential Processes）理论，强调通过数据通道进行进程间通信，而...
Golang学习笔记（一）：简介
01-21
匿名函数和闭包 类型和接口 并发编程 反射 语言交互性 高性能/高效开发 安装 安装说明 地址 http://golang.org/doc/install 包下载 地址 https://code.google.com/p/go/downloads/list 确认是否安装成功 代码如下:...
golang 语言 学习笔记 书籍 曝光go语言底层原理
10-22
Go 简单易学，性能很好，且支持各类主流平台。内容覆盖了语言、运行时、性能优化、工具...下卷则对运行时源码做出深度剖析，引导读者透彻了解语言功能背后的支持环境和运行体系，诸如内存分配、垃圾回收和并发调度等。
Golang基于amqp协议实现rabbitMQ队列消费
01-07
发布消息 package main import ( github.com/streadway/amqp log ) //我们还需要一个辅助函数来检查每个amqp调用的返回值： func failOnError(err error, msg string) { if err != nil { log.Fatalf(%s: %s, msg, err) } } func mains() { //建立连接 rabbbimqConn, err := amqp.Dial(amqp://admin:admin@ip地址:5672/) failOnError(err, F
golang中文手册_golang中文手册_goapiCHM_golang中文手册.chm_
10-02
包内定义的函数和类型可以通过`import`语句引入到其他包中使用。 3. **接口（Interface）**：Go语言的接口是一种类型定义，它定义了一组方法签名。任何实现了接口所定义的所有方法的类型都被称为实现了该接口。 4....
Golang学习笔记（三）：控制流
01-21
初始化语句中定义的都是只能在block级别中使用的局部变量，不能在block之外使用 左大括号必须和条件语句在同一行(必须与if/else在同一行) go没有三元运算符 if判断语句条件不需要括号 在判断语句里卖弄允许声明一个...
RabbitMQ（Golang版本）
qq_42649688的博客
06-11 2297
一、RabbitMQ 简介 消息队列是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是/用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。 二、使用场景 1.解耦 场景说明：用户下单后，订单系统需要通知库存系统。传统的做法是，订单系统调用库存系统的接口。 传统模式的缺点： 如
rabbitmq 客户端golang实战
cheyo809775692的博客
04-26 838
rabbitmq消息模式 rabbitmq中进行消息控制的组建可以分为以下几部分： exchange：rabbitmq中的路由部件，控制消息的转发路径； queue：rabbitmq的消息队列，可以有多个消费者从队列中读取消息； consumer：消息的消费者； rabbitmq在使用过程...
【RabbitMQ】golang客户端教程1——HelloWorld
m0_53328239的博客
07-30 1770
RabbitMQ是一个消息代理：它接受并转发消息。你可以把它想象成一个邮局：当你把你想要邮寄的邮件放进一个邮箱时，你可以确定邮差先生或女士最终会把邮件送到你的收件人那里。在这个比喻中，RabbitMQ是一个邮箱、一个邮局和一个邮递员。RabbitMQ和邮局的主要区别在于它不处理纸张，而是接受、存储和转发二进制数据块——消息。RabbitMQ和一般的消息传递都使用一些术语。生产仅意味着发送。发送消息的程序是生产者：队列是位于RabbitMQ内部的邮箱的名称。
Golang-RabbitMQ-基础使用学习
Pillow_Monkey的博客
08-17 255
RabbitMQ 用于消息代理，其工作就是接收和转发消息。生产：即发布消息，发送消息的程序就是一个生产者；Producing队列：本质是一个巨大的消息缓冲区，大小只受主机内存和硬盘限制，用于存储传输而来的消息，多个生产者可以把消息发送给同一个队列，多个消费者可以从同一个队列获取消息；Queue消费：即接收信息，接收消息的程序就是一个消费者；Consuming基本关系： [|||] -> (C)">创建辅助函数用于检查每个 调用的返回值 生产（发送消息） 生产者的创建函数用于连接 RabbitMQ 服务器，链
Golang使用RabbitMQ
懒人程序员的博客
05-21 724
安装RabbitMQ RabbitMQ中文相关文档：http://rabbitmq.mr-ping.com/ docker安装参考：https://blog.csdn.net/qq_18361349/article/details/106175125 # 拉取rabbitmq镜像，management是rabbitmq的web管理界面。不使用标签拉取是不带管理界面的 docker pull rabbitmq:management # 启动rabbitmq容器，15672是web管理界面端口5672是rab
Golang 中的 EOF 与 read: connection reset by peer 错误深度剖析
最新发布
了迹奇有没
08-07 723
在 Golang 网络请求中，我们经常会遇到两种常见的错误：`EOF` 和 `read: connection reset by peer`。这两个错误虽然看似相似，但实际上有着本质的区别。这篇文章将深入探讨这两种错误的原因、区别以及如何优雅的处理它们。
GoLang学习笔记：深入理解内存布局与指针操作
"Go 学习笔记 - 探究内存布局与Spring Boot中Sharding-JDBC的读写分离示例" 本文主要探讨了两个主题：Go语言中的内存布局以及Spring Boot中整合Sharding-JDBC实现读写分离的示例。首先，我们将深入理解Go语言的内存...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值