RabbitMQ消息队列在Golang中的简单使用

最新推荐文章于 2024-08-14 22:20:29 发布
最新推荐文章于 2024-08-14 22:20:29 发布
阅读量1.4k 收藏 2
点赞数 1
分类专栏： GO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44746132/article/details/113815122
版权
本文介绍了如何在macOS上安装RabbitMQ，包括使用Homebrew安装Erlang和RabbitMQ，以及启用RabbitMQ管理插件。接着，详细阐述了在Go语言中使用streadway/amqp库实现RabbitMQ的Simple、Work、订阅（Pub/Sub）和Routing四种模式，展示了如何创建连接、发布和消费消息。
摘要由CSDN通过智能技术生成
  • AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。
    AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。
  • RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。

macOS中安装RabbitMQ:

  1. 安装Erlang环境

brew install erlang

  1. 安装rabbitmq

brew install rabbitmq

  1. 安装RabbitMQ可视化监控工具：

cd /usr/local/Celler/rabbitmq/3.8.11
sudo sbin/rabbitmq-plugins enable rabbitmq_management

  1. 配置环境变量

open ~/.zshrc
// 添加以下两行
export RABBIT_HOME = /usr/local/Celler/3.8.11
export PATH = $PATH:RABBIT_HOME/sbin
source ~/.zshrc

  1. 后台启动rabbitmq

sudo rabbitmq-server -detached

  1. 停止rabbitMQ

rabbitmqctl stop

在golang中尝试RabbitMQ的几种模式：
i: 安装amqp库

go get github.com/streadway/amqp

ii: 定义url

// url格式：amqp://账号：密码@rabbitmq服务地址/vhost
const MQURL = "amqp://chensir:chensir@127.0.0.1:5672/chen"

iii: 定义RabbitMQ对象结构体

type RabbitMQ struct {
	conn *amqp.Connection
	channel *amqp.Channel
	// 队列名称
	QueueName string
	// 交换机
	Exchange string
	// key
	Key string
	// 链接信息
	Mqurl string
}
1. Simple模式

i: 创建RabbitMQ结构体实例

func NewRabbitMQ(queueName string, exchange string, key string) *RabbitMQ {
	rabbitmq := &RabbitMQ{
		QueueName: queueName,
		Exchange: exchange,
		Key: key,
		Mqurl: MQURL,
	}
	var err error
	// 创建rabbitmq链接
	rabbitmq.conn, err = amqp.Dial(rabbitmq.Mqurl)
	rabbitmq.failOnError(err, "创建链接错误")
	rabbitmq.channel, err = rabbitmq.conn.Channel()
	rabbitmq.failOnError(err, "获取channel失败")
	return rabbitmq
}

ii: Simple模式下生产者

func (r *RabbitMQ) PublishSimple(message string){
	// 1. 申请队列，如果队列不存在，自动创建；如果存在则跳过创建，保证消息能发送到队列中
	_, err := r.channel.QueueDeclare(
		r.QueueName,
		//控制是否持久化
		false,
		// 是否自动删除
		false,
		// 是否具有排他性
		false,
		// 是否阻塞
		false,
		// 额外属性
		nil)
	if err != nil {
		fmt.Println(err)
	}
	// 发送消息到队列中
	r.channel.Publish(
		r.Exchange,
		r.QueueName,
		// 如果为true和exchage类型和routKey规则，如果无法找到符合条件的队列，那么会把消息返回给发送者
		false,
		// 如果为true, 当exchange发送消息到队列后发现队列上没有绑定消费者，则会把消息还给发送者
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body: []byte(message),
		})
}

iii: Simple模式下消费者

func (r *RabbitMQ) ConsumeSimple(){
	// 尝试申请队列
	_, err := r.channel.QueueDeclare(
		r.QueueName,
		//控制是否持久化
		false,
		// 是否自动删除
		false,
		// 是否具有排他性
		false,
		// 是否阻塞
		false,
		// 额外属性
		nil)
	if err != nil {
		fmt.Println(err)
	}
	// 接收消息
	msgs, err := r.channel.Consume(
		r.QueueName,
		// 用来区分多个消费者的key
		"",
		// 是否自动应到
		true,
		// 是否具有排他性
		false,
		// 如果设置为true，表示不能将同一个connection中发送的消息传递给这个connection中的消费者
		false,
		// 队列消费是否为阻塞
		false,
		nil)
	if err != nil {
		fmt.Println(err)
	}

	// 消费消息
	forever := make(chan bool)
	go func(){
		for d := range msgs {
			log.Printf("Receive a message: %s", d.Body)
		}
	}()
	log.Println("[*] waiting for message, To exit press Ctrl + c")
	<-forever
}
2. Work模式：
  • Work模式的生产消费和Simple模式相同，只是在Simple模式下，可以创建多个消费者对消息队列进行消费。在Work模式下，消息只能被一个消费者消费掉
3. 订阅模式：

i: 订阅模式下创建RabbitMQ实例

func NewRabbitMQPubSub(exchangeName string) *RabbitMQ {
	// 指定交换机名称， 而队列名称则为空即可
	rabbitmq := NewRabbitMQ("", exchangeName, "")
	var err error
	rabbitmq.conn, err = amqp.Dial(rabbitmq.Mqurl)
	rabbitmq.failOnError(err, "failed to connect rabbitmq")
	// 获取channel
	rabbitmq.channel, err = rabbitmq.conn.Channel()
	rabbitmq.failOnError(err, "failed to open a channel")
	return rabbitmq
}

ii: 订阅模式下生产信息

func (r *RabbitMQ) PublishPub(message string){
	// 尝试创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		// 交换机类型为广播类型
		"fanout",
		true,
		false,
		false,
		false,
		nil)
	r.failOnError(err, "failed to declare an exchange")
	// 发送消息
	err = r.channel.Publish(
		r.Exchange,
		"",
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body: []byte(message),
		})
	r.failOnError(err, "failed to send a message")
}

iii: 订阅模式下接收消息

func (r *RabbitMQ) ReceiveSub(){
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"fanout",
		true,
		false,
		// YES表示这个exchange不可以被client用来推送消息，仅用来进行exchange和exchange之间的绑定
		false,
		false,
		nil)
	r.failOnError(err, "failed to declare an exchange")
	// 创建队列
	q, err := r.channel.QueueDeclare(
		"",  // 随机生产队列名称
		false,
		false,
		true,
		false,
		nil)
	// 绑定队列到exchange中
	r.failOnError(err, "failed to declare a queue")
	err = r.channel.QueueBind(
		q.Name,
		// 在Pub/Sub模式下，这里的key要为空
		"",
		r.Exchange,
		false,
		nil)

	// 消费消息
	message, err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil)
	forever := make(chan bool)
	go func(){
		for d := range message {
			log.Printf("Receive a message: %s", d.Body)
		}
	}()
	log.Println("退出请按： Ctrl + c")
	<-forever
}
  • 订阅模式下，是通过交换机将生产的消息广播到绑定到交换机上的多个队列中，需要指定创建的交换机类型为“fanout”类型
4. Routing模式：
  • Routing模式和订阅模式的代码也类似，不同指出在与：
  1. 创建RabbitMQ实例时需要指定RoutingKey
func NewRabbitMQRouting(exchangeName string, routingKey string) *RabbitMQ {
   rabbitmq := NewRabbitMQ("", exchangeName, routingKey)
   var err error
   rabbitmq.conn, err = amqp.Dial(rabbitmq.Mqurl)
   rabbitmq.failOnError(err, "failed to connect rabbitmq")
   // 获取channel
   rabbitmq.channel, err = rabbitmq.conn.Channel()
   rabbitmq.failOnError(err, "failed to open a channel")
   return rabbitmq
}
  1. 在生产消息和消费消息时创建交换机的过程中都需要指定交换机类型为“direct"
  2. 在发送消息时，需要指定消费队列的key， 这个key需要和相应的消费队列一一对应
  • Routing模式就是在订阅模式的基础上，明确指定消息的消费队列。

-------本文结束

一树梨花
关注
专栏目录
GoLang 使用 RabbitMQ 优先级队列
JineD的博客
03-24 338
1. RabbitMQ优先级队列介绍： RabbitMQ3.5.0之后官方版本已经实现了优先级队列。数值越大则优先级越高。 创建优先级队列，需要增加x-max-priority参数，指定一个优先级的数值大小，这里最好是0～10之间，用来表示这个queue的最大优先级。（备注：因为生产者和消费者都需要对queue进行声明，所以它们都需要设置这个参数） 生产者在发送消息的时候，需要设置priority属性，最好不要超过上面指定的最大的优先级，一旦超过了这个优先级，发送设置的优先级就不再生效了。在这个范围内
Golang RabbitMQ实现的延时队列
weixin_44545838的博客
09-03 1189
之前做秒杀商城项目的时候使用到了延时队列来解决订单超时问题，本博客就总结一下Golang是如何利用RabbitMQ实现的延时队列的。
Golang之消息队列——RabbitMQ的使用
QianLiStudent的博客
01-21 6534
消息队列的使用场景 异步处理       异步是指不用一次性执行完，可以先去执行别的，等这边回应了再做处理。这里我就拿一个网上用烂的例子：用户注册。用户在正确填写信息后点击注册，这时会发起网络请求到后端去做数据合法性等的验证，一旦验证通过则会将数据写入数据库并返回注册成功类的信息。但现在很多的应用都会有短信、邮箱等其他媒介的额外通知，这些...
Golang与RabbitMQ
m0_67391521的博客
03-25 2008
文章目录 RabbitMQ 概述 RabbitMQ 特点 RabbitMQ基础概念 RabbitMQ 工作流程 Golang 操作RabbitMQ 基础队列使用 工作队列 参考资料 RabbitMQ 概述 RabbitMQ是采用Erlang编程语言实现了高级消息队列协议AMQP (Advanced Message Queuing Protocol)的开源消息代理软件（消息队列中间件） 市面上流行的消息队列中间件有很多种,而RabbitMQ只是其中比较流行的一种 我们简单
Go整合和操作RabbitMQ
最新发布
qq_45371023的博客
08-14 1070
Go整合和操作RabbitMQ
golang实现rabbitmq消息队列
qq_38151401的博客
04-22 3658
目录 一、前期准备 二、具体实现过程 1、通用方法定义 2、Simple模式 3、工作模式 4、Publish订阅模式 5、Routine路由模式 6、Topic话题模式 三、完整代码 一、前期准备 1、安装rabbitmq（docker）：https://blog.csdn.net/qq_38151401/article/details/103327339 2、熟悉了解r...
go实现消息队列
CY2333333的博客
04-29 3248
使用Golang实现一个消息队列，具体要满足以下功能： 可以向消息队列发送消息和拉取消息 可以向消息队列发送消息和拉取消息 发送的消息不能超过指定的容量 拉取消息支持拉取指定数量的消息，如果不满足指定的数量，等待超时以后返回超时时间内拉取的所有消息（不会超过指定的数量） 使用Golang中的基本数据结构和功能来实现 package main import ( "time" ) // MessageQueue define the interface for the messag
RabbitMQ（Golang版本）
qq_42649688的博客
06-11 2400
一、RabbitMQ 简介 消息队列是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是/用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。 二、使用场景 1.解耦 场景说明：用户下单后，订单系统需要通知库存系统。传统的做法是，订单系统调用库存系统的接口。 传统模式的缺点： 如
golang使用rabbitmq（二）工作队列
独自登高楼 望断天涯路
06-10 2563
在helloworld那一章讲了一个简单的一个生产者一个消费者的模型，但生产系统中很多时候是多个生产者或者多个消费者同时处理的。 生产者 body := bodyFrom(os.Args) err = ch.Publish("", q.Name, false, false, amqp.Publishing{ DeliveryMode: amqp.Persistent, ContentT...
使用golang实现的推送系统 结合rabbitmq消息队列 gin-web实现消息接收推送
02-18
golang 推送系统 单机 客户端通过websocket连接到服务端 ...服务端从rabbitmq接收消息，根据消息所属通过websocket推送到具体用户 服务端从http api接收消息，根据消息所属通过websocket推送到具体用户
Go语言版本rabbitmq消息队列库：simple、worker、Fanout 模型、Direct 模型、Topic模型
07-29
RabbitMQ 是使用Erlang编写的一个开源的消息队列，本身支持很多的协议：AMQP，XMPP, SMTP, STOMP，也正是如此，使的它变的非常重量级，更适合于企业级的开发。同时实现了一个经纪人(Broker)构架，这意味着消息在发送...
Go-GoQ在Golang中的轻量级消息队列
08-14
GoQ 在Golang中的轻量级消息队列
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使用RabbitMQ的四种工作模式
m0_52530105的博客
06-16 958
​ RabbitMQ 2007年发布，是一个在 AMQP (高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最主流的消息中间件之一。RabbitMQ是同Erlang语言开发对于一般的使用场景而言是一个非常不错的选择。
golang操作rabbitmq
qq_29744347的博客
06-16 753
golang 操作rabbitmq
windows10环境下的RabbitMQ安装步骤（图文）
weixin_37474878的博客
09-13 224
记录下本人在win10环境下安装RabbitMQ的步骤，以作备忘。 第一步：下载并安装erlang 原因：RabbitMQ服务端代码是使用并发式语言Erlang编写的，安装Rabbit MQ的前提是安装Erlang。 下载地址：http://www.erlang.org/downloads 根据本机位数选择erlang下载版本。 下载完是这么个东西： 双击，点next就可以。 ...
Golang使用RabbitMQ
懒人程序员的博客
05-21 750
安装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
Go 微服务：基于 RabbitMQ 和 AMQP 进行消息传递
weixin_34376986的博客
06-22 540
欢迎大家前往腾讯云+社区，获取更多腾讯海量技术实践干货哦~ 本文来自云+社区翻译社，由Tnecesoc编译。 介绍 微服务就是将应用程序的业务领域划分为具有明确范围的不同场景，并以分离的流程来运行这些场景，使得其中跨边界的任何持久化的关系必须依赖最终的一致性，而不是 ACID 类事务或外键约束。这些概念很多都来源于领域驱动设计（DDD），或受到了它的启发。不过 DDD 是个要花一整个博客系列来...
Golang操作Rabbitmq
名狱的博客
06-19 1866
简介 Rabbitmq就是一个消息的中间人，负责接受消息、转发消息和存储消息，并不参与消息的处理和计算。 没有固定哪一方是生产者，哪一方是消费者，谁发送消息给Rabbitmq谁就是生产者，谁接收Rabbitmq发送的消息谁就是消费者。Rabbitmq这个词是描述整个软件，而缓存消息的是这个软件内部的队列（或者说缓冲器，先进先出结构），内部可以后很多条队列，由于不参与计算，所以队列的性能只受内存和磁盘的约束。 一个生产者可以对应一个或者多个队列，一个队列可以对应一个或者多个消费者，并且传输过程中又很多处理方法
golang 调用RabbitMQ消息队列监控API
07-28
在 Golang 中调用 RabbitMQ 的消息队列监控 API 可以使用标准的 `net/http` 包来发送 HTTP 请求并处理响应。以下是一个简单的示例代码，用于获取 RabbitMQ 的队列信息： ```go package main import ( "encoding/json" "fmt" "io/ioutil" "net/http" ) type QueueInfo struct { Name string `json:"name"` Messages int `json:"messages"` Consumers int `json:"consumers"` } func main() { // RabbitMQ API URL url := "http://localhost:15672/api/queues" // 创建 HTTP 客户端 client := &http.Client{} // 创建 HTTP 请求 req, err := http.NewRequest("GET", url, nil) if err != nil { fmt.Println("创建请求失败:", err) return } // 设置 Basic Auth 认证（如果需要） req.SetBasicAuth("username", "password") // 发送请求并获取响应 resp, err := client.Do(req) if err != nil { fmt.Println("发送请求失败:", err) return } defer resp.Body.Close() // 读取响应内容 body, err := ioutil.ReadAll(resp.Body) if err != nil { fmt.Println("读取响应失败:", err) return } // 解析 JSON 响应 var queues []QueueInfo err = json.Unmarshal(body, &queues) if err != nil { fmt.Println("解析响应失败:", err) return } // 输出队列信息 for _, queue := range queues { fmt.Printf("队列名称: %s\n", queue.Name) fmt.Printf("消息数量: %d\n", queue.Messages) fmt.Printf("消费者数量: %d\n", queue.Consumers) fmt.Println("----------------------") } } ``` 请注意，上述代码中的 `url` 变量需要根据你的 RabbitMQ 配置进行相应调整。如果 RabbitMQ 设置了用户名和密码的认证，你需要使用 `SetBasicAuth` 方法设置 Basic Auth 认证信息。 该示例代码发送一个 HTTP GET 请求到 RabbitMQ 的 `/api/queues` 接口，获取所有队列的信息，并将其解析为 `QueueInfo` 结构体。然后，你可以根据需要处理和使用这些队列信息。 希望这个示例能帮助到你。如果有任何其他问题，请随时提问。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值