golang实现rabbitmq消息队列

最新推荐文章于 2024-05-11 03:41:16 发布
最新推荐文章于 2024-05-11 03:41:16 发布
阅读量3.2k 收藏 12
点赞数 2
分类专栏： golang 文章标签： go rabbitmq 消息队列 golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38151401/article/details/105688928
版权

 

目录

一、前期准备

二、具体实现过程

1、通用方法定义

2、Simple模式

3、工作模式

4、Publish订阅模式

5、Routing路由模式

6、Topic话题模式

三、完整代码

一、前期准备

1、安装rabbitmq（docker）：https://blog.csdn.net/qq_38151401/article/details/103327339

2、熟悉了解rabbitmq消息队列：https://blog.csdn.net/qq_38151401/article/details/103443191

3、如果熟悉Java语言的可参考我的另一篇博客的具体实现：https://blog.csdn.net/qq_38151401/article/details/103445332

4、go语言基础：http://c.biancheng.net/golang/

5、go-amqp库函数手册：https://godoc.org/github.com/streadway/amqp

二、具体实现过程

1、通用方法定义

（1）添加Virtual Hosts

  • 在RabbitMq管理界面里面添加Virtual Hosts【imooc】

  • 添加用户Users【账号：imoocuser  密码：imoocuser】

  • set permission

  • 结果如下图所示

（2）设置rabbitmq的url

//url格式 amqp://账号:密码@rabbitmq服务器地址:端口号/vhost
const MQURL = "amqp://imoocuser:imoocuser@192.168.1.109:5672/imooc"

（3）定义RabbitMQ结构体

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

（4）创建RabbitMQ结构体实例

//创建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.failOnErr(err, "创建连接错误")
	rabbitMQ.channel, err = rabbitMQ.conn.Channel()
	rabbitMQ.failOnErr(err, "获取Channel失败")
	return rabbitMQ
}

（5）断开channel和connection

//断开channel和connection
func (r *RabbitMQ) Destoryy() {
	r.channel.Close()
	r.conn.Close()
}

（6）错误处理函数

//错误处理函数
func (r *RabbitMQ) failOnErr(err error, message string) {
   if err != nil {
      log.Fatalf("%s:%s\n", message, err)
      panic(fmt.Sprintf("%s:%s", message, err))
   }
}

2、Simple模式

（1)创建简单模式下RabbitMQ实例

//简单模式Step：1、创建简单模式下RabbitMQ实例
func NewRabbitMQSimple(queueName string) *RabbitMQ {
	return NewRabbitMQ(queueName, "", "")
}

（2）简单模式下生产代码

//简单模式Step：2、简单模式下生产代码
func (r *RabbitMQ) PublishSimple(message string) {
	//1、申请消息队列，如果队列不存在会自动创建，如果存在则跳过创建
	//好处：宝成队列存在，消息能发送到队列中
	_, err := r.channel.QueueDeclare(
		r.QueueName,
		//是否持久化
		false,
		//是否为自动删除
		false,
		//是否具有排他性
		false,
		//是否阻塞
		false,
		//额外属性
		nil,
	)
	if err != nil {
		fmt.Println(err)
	}
	//2、发送消息到队列中
	r.channel.Publish(
		r.Exchange,
		r.QueueName,
		//如果为true，根据exchange类型和routkey规则，如果无法找到符合条件的队列，那么会把发送的消息返回给发送者
		false,
		//如果为true，当exchange发送消息到队列侯发现队列上没有绑定消费者，则会把消息发还给发送者
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

（3）简单模式下消费代码

//简单模式Step：3、消费
func (r *RabbitMQ) ConsumeSimple() {
	//1、申请队列
	_, err := r.channel.QueueDeclare(r.QueueName, false, false, false, false, nil)
	if err != nil {
		fmt.Println(err)
	}
	//2、接收消息
	msgs, err := r.channel.Consume(
		r.QueueName,
		//用来区分多个消费者
		"",
		//是否自动应答
		true,
		//是否具有排他性
		false,
		//如果设置为true，表示不能将同一个connection中发送的消息传递给这个connection中的消费者
		false,
		//消息队列是否阻塞
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
	}
	
	forever := make(chan bool)
	
	//3、启动协程处理消息
	go func() {
		for d := range msgs {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message : %s", d.Body)
		}
	}()
	
	log.Printf("[*] Waiting for messagees,To exit press CTRL+C")
	
	<-forever
}

（4）简单模式下生产者主函数

package main

import (
	"./RabbitMQ"
	"fmt"
)

func main()  {
	rabbitmq := RabbitMQ.NewRabbitMQSimple("imoocSimple")
	rabbitmq.PublishSimple("Hello imooc!")
	fmt.Println("发送成功！")
}

（5）简单模式下消费者主函数

package main

import (
	"./RabbitMQ"
	"fmt"
)

func main()  {
	rabbitmq := RabbitMQ.NewRabbitMQSimple("imoocSimple")
	rabbitmq.ConsumeSimple()
	fmt.Println("消费成功！")
}

（6）测试

先运行消费则，再运行生产者。可看到如下图所示：

3、工作模式

一个消息只能被一个消费者获取

与简单模式代码一样，只是工作模式会有多个消费者，能够起到负载均衡的作用

（1）生产者主函数

（2）消费者主函数

4、Publish订阅模式

一个消息可以同时被多个消费者消费

（1）订阅模式生产者消费者代码

//订阅模式Step：1、创建订阅模式下RabbitMQ实例
func NewRabbitMQPubSub(exchangeName string)*RabbitMQ  {
	//创建RabbitMq实例
	return NewRabbitMQ("",exchangeName,"")
}

//订阅模式Step：2、订阅模式下生产代码
func (r *RabbitMQ) PublishgPub(message string)  {
	//1、强制创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"fanout",//广播类型
		true,
		false,
		//true表示这个exchange不可以被client用来推送消息，仅用来进行exchange和exchange之间的绑定
		false,
		false,
		nil,
		)
	r.failOnErr(err,"Failed t declare an exchange")
	
	//2、发送消息
	err = r.channel.Publish(
		r.Exchange,
		"",
		false,
		false,
		amqp.Publishing{
			ContentType:     "text/plain",
			Body:            []byte(message),
		})
}

//订阅模式Step：3、订阅模式下消费代码
func (r *RabbitMQ) ReceiveSub() {
	//1、试探性创建交换机
	err :=  r.channel.ExchangeDeclare(
		r.Exchange,
		//交换机类型
		"fanout",
		true,
		false,
		false,
		false,
		nil,
		)
	r.failOnErr(err,"Failed t declare an exchange")
	
	//2、试探性创建队列，这里注意队列名称不要写
	q, err := r.channel.QueueDeclare(
		"",//随机生产队列名称
		false,
		false,
		true,
		false,
		nil,
	)
	r.failOnErr(err,"Failed to declare a queue")
	
	//3、绑定队列到exchange中
	err = r.channel.QueueBind(
		q.Name,
		//在Pub/Sub模式下，这里的key要为空
		"",
		r.Exchange,
		false,
		nil,
		)
	
	//4、消费信息
	message,err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil,
		)
	
	forever := make(chan bool)
	
	//5、启动协程处理消息
	go func() {
		for d := range message {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message : %s", d.Body)
		}
	}()
	
	log.Printf("[*] Waiting for messagees,To exit press CTRL+C")
	
	<-forever
}

（2）测试

5、Routing路由模式

//路由模式Step：1、创建路由模式下RabbitMQ实例
func NewRabbitMQRouting(exchangeName string, routingKey string) *RabbitMQ {
	//创建RabbitMq实例
	return NewRabbitMQ("", exchangeName, routingKey)
}

//路由模式Step：2、路由模式下生产代码
func (r *RabbitMQ) PublishgRouting(message string) {
	//1、尝试创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"direct", //路由类型
		true,
		false,
		//true表示这个exchange不可以被client用来推送消息，仅用来进行exchange和exchange之间的绑定
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、发送消息
	err = r.channel.Publish(
		r.Exchange,
		r.Key,
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

//路由模式Step：3、路由模式下消费代码
func (r *RabbitMQ) ReceiveRouting() {
	//1、试探性创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		//交换机类型
		"direct",
		true,
		false,
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、试探性创建队列，这里注意队列名称不要写
	q, err := r.channel.QueueDeclare(
		"", //随机生产队列名称
		false,
		false,
		true,
		false,
		nil,
	)
	r.failOnErr(err, "Failed to declare a queue")
	
	//3、绑定队列到exchange中
	err = r.channel.QueueBind(
		q.Name,
		//在Pub/Sub模式下，这里的key要为空
		r.Key,
		r.Exchange,
		false,
		nil,
	)
	
	//4、消费信息
	message, err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil,
	)
	
	forever := make(chan bool)
	
	//5、启动协程处理消息
	go func() {
		for d := range message {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message : %s", d.Body)
		}
	}()
	
	log.Printf("[*] Waiting for messagees,To exit press CTRL+C")
	
	<-forever
}

测试：

6、Topic话题模式

//话题模式Step：1、创建话题模式下RabbitMQ实例
func NewRabbitMQTopic(exchangeName string, routingKey string) *RabbitMQ {
	//创建RabbitMq实例
	return NewRabbitMQ("", exchangeName, routingKey)
}

//话题模式Step：2、话题模式下生产代码
func (r *RabbitMQ) PublishgTopic(message string) {
	//1、尝试创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"topic", //话题类型
		true,
		false,
		//true表示这个exchange不可以被client用来推送消息，仅用来进行exchange和exchange之间的绑定
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、发送消息
	err = r.channel.Publish(
		r.Exchange,
		r.Key,
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

//话题模式Step：3、话题模式下消费代码
//“*“匹配一个单词；"#"匹配多个单词（可以是0个）
//匹配imooc.*表示匹配imooc.hello，但是imooc.hello.one需要用到imooc.#才能匹配到
func (r *RabbitMQ) ReceiveTopic() {
	//1、试探性创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		//交换机类型
		"topic",
		true,
		false,
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、试探性创建队列，这里注意队列名称不要写
	q, err := r.channel.QueueDeclare(
		"", //随机生产队列名称
		false,
		false,
		true,
		false,
		nil,
	)
	r.failOnErr(err, "Failed to declare a queue")
	
	//3、绑定队列到exchange中
	err = r.channel.QueueBind(
		q.Name,
		//在Pub/Sub模式下，这里的key要为空
		r.Key,
		r.Exchange,
		false,
		nil,
	)
	
	//4、消费信息
	message, err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil,
	)
	
	forever := make(chan bool)
	
	//5、启动协程处理消息
	go func() {
		for d := range message {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message : %s", d.Body)
		}
	}()
	
	log.Printf("[*] Waiting for messagees,To exit press CTRL+C")
	
	<-forever
}

测试：

三、完整代码

package RabbitMQ

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

//url格式 amqp://账号:密码@rabbitmq服务器地址:端口号/vhost
const MQURL = "amqp://imoocuser:imoocuser@192.168.1.109:5672/imooc"

//const MQURL = "amqp://guest:guest@192.168.1.109:5672/"

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

//创建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.failOnErr(err, "创建连接错误")
	rabbitMQ.channel, err = rabbitMQ.conn.Channel()
	rabbitMQ.failOnErr(err, "获取Channel失败")
	return rabbitMQ
}

//断开channel和connection
func (r *RabbitMQ) Destoryy() {
	r.channel.Close()
	r.conn.Close()
}

//错误处理函数
func (r *RabbitMQ) failOnErr(err error, message string) {
	if err != nil {
		log.Fatalf("%s:%s\n", message, err)
		panic(fmt.Sprintf("%s:%s", message, err))
	}
}

//简单模式Step：1、创建简单模式下RabbitMQ实例
func NewRabbitMQSimple(queueName string) *RabbitMQ {
	return NewRabbitMQ(queueName, "", "")
}

//简单模式Step：2、简单模式下生产代码
func (r *RabbitMQ) PublishSimple(message string) {
	//1、申请消息队列，如果队列不存在会自动创建，如果存在则跳过创建
	//好处：宝成队列存在，消息能发送到队列中
	_, err := r.channel.QueueDeclare(
		r.QueueName,
		//是否持久化
		false,
		//是否为自动删除
		false,
		//是否具有排他性
		false,
		//是否阻塞
		false,
		//额外属性
		nil,
	)
	if err != nil {
		fmt.Println(err)
	}
	//2、发送消息到队列中
	r.channel.Publish(
		r.Exchange,
		r.QueueName,
		//如果为true，根据exchange类型和routkey规则，如果无法找到符合条件的队列，那么会把发送的消息返回给发送者
		false,
		//如果为true，当exchange发送消息到队列侯发现队列上没有绑定消费者，则会把消息发还给发送者
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

//简单模式Step：3、消费
func (r *RabbitMQ) ConsumeSimple() {
	//1、申请队列
	_, err := r.channel.QueueDeclare(r.QueueName, false, false, false, false, nil)
	if err != nil {
		fmt.Println(err)
	}
	//2、接收消息
	msgs, err := r.channel.Consume(
		r.QueueName,
		//用来区分多个消费者
		"",
		//是否自动应答
		true,
		//是否具有排他性
		false,
		//如果设置为true，表示不能将同一个connection中发送的消息传递给这个connection中的消费者
		false,
		//消息队列是否阻塞
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
	}
	
	forever := make(chan bool)
	
	//3、启动协程处理消息
	go func() {
		for d := range msgs {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message : %s", d.Body)
		}
	}()
	
	log.Printf("[*] Waiting for messagees,To exit press CTRL+C")
	
	<-forever
}

//订阅模式Step：1、创建订阅模式下RabbitMQ实例
func NewRabbitMQPubSub(exchangeName string) *RabbitMQ {
	//创建RabbitMq实例
	return NewRabbitMQ("", exchangeName, "")
}

//订阅模式Step：2、订阅模式下生产代码
func (r *RabbitMQ) PublishgPub(message string) {
	//1、尝试创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"fanout", //广播类型
		true,
		false,
		//true表示这个exchange不可以被client用来推送消息，仅用来进行exchange和exchange之间的绑定
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、发送消息
	err = r.channel.Publish(
		r.Exchange,
		"",
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

//订阅模式Step：3、订阅模式下消费代码
func (r *RabbitMQ) ReceiveSub() {
	//1、试探性创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		//交换机类型
		"fanout",
		true,
		false,
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、试探性创建队列，这里注意队列名称不要写
	q, err := r.channel.QueueDeclare(
		"", //随机生产队列名称
		false,
		false,
		true,
		false,
		nil,
	)
	r.failOnErr(err, "Failed to declare a queue")
	
	//3、绑定队列到exchange中
	err = r.channel.QueueBind(
		q.Name,
		//在Pub/Sub模式下，这里的key要为空
		"",
		r.Exchange,
		false,
		nil,
	)
	
	//4、消费信息
	message, err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil,
	)
	
	forever := make(chan bool)
	
	//5、启动协程处理消息
	go func() {
		for d := range message {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message : %s", d.Body)
		}
	}()
	
	log.Printf("[*] Waiting for messagees,To exit press CTRL+C")
	
	<-forever
}

//路由模式Step：1、创建路由模式下RabbitMQ实例
func NewRabbitMQRouting(exchangeName string, routingKey string) *RabbitMQ {
	//创建RabbitMq实例
	return NewRabbitMQ("", exchangeName, routingKey)
}

//路由模式Step：2、路由模式下生产代码
func (r *RabbitMQ) PublishgRouting(message string) {
	//1、尝试创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"direct", //路由类型
		true,
		false,
		//true表示这个exchange不可以被client用来推送消息，仅用来进行exchange和exchange之间的绑定
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、发送消息
	err = r.channel.Publish(
		r.Exchange,
		r.Key,
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

//路由模式Step：3、路由模式下消费代码
func (r *RabbitMQ) ReceiveRouting() {
	//1、试探性创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		//交换机类型
		"direct",
		true,
		false,
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、试探性创建队列，这里注意队列名称不要写
	q, err := r.channel.QueueDeclare(
		"", //随机生产队列名称
		false,
		false,
		true,
		false,
		nil,
	)
	r.failOnErr(err, "Failed to declare a queue")
	
	//3、绑定队列到exchange中
	err = r.channel.QueueBind(
		q.Name,
		//在Pub/Sub模式下，这里的key要为空
		r.Key,
		r.Exchange,
		false,
		nil,
	)
	
	//4、消费信息
	message, err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil,
	)
	
	forever := make(chan bool)
	
	//5、启动协程处理消息
	go func() {
		for d := range message {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message : %s", d.Body)
		}
	}()
	
	log.Printf("[*] Waiting for messagees,To exit press CTRL+C")
	
	<-forever
}

//话题模式Step：1、创建话题模式下RabbitMQ实例
func NewRabbitMQTopic(exchangeName string, routingKey string) *RabbitMQ {
	//创建RabbitMq实例
	return NewRabbitMQ("", exchangeName, routingKey)
}

//话题模式Step：2、话题模式下生产代码
func (r *RabbitMQ) PublishgTopic(message string) {
	//1、尝试创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"topic", //话题类型
		true,
		false,
		//true表示这个exchange不可以被client用来推送消息，仅用来进行exchange和exchange之间的绑定
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、发送消息
	err = r.channel.Publish(
		r.Exchange,
		r.Key,
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

//话题模式Step：3、话题模式下消费代码
//“*“匹配一个单词；"#"匹配多个单词（可以是0个）
//匹配imooc.*表示匹配imooc.hello，但是imooc.hello.one需要用到imooc.#才能匹配到
func (r *RabbitMQ) ReceiveTopic() {
	//1、试探性创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		//交换机类型
		"topic",
		true,
		false,
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed t declare an exchange")
	
	//2、试探性创建队列，这里注意队列名称不要写
	q, err := r.channel.QueueDeclare(
		"", //随机生产队列名称
		false,
		false,
		true,
		false,
		nil,
	)
	r.failOnErr(err, "Failed to declare a queue")
	
	//3、绑定队列到exchange中
	err = r.channel.QueueBind(
		q.Name,
		//在Pub/Sub模式下，这里的key要为空
		r.Key,
		r.Exchange,
		false,
		nil,
	)
	
	//4、消费信息
	message, err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil,
	)
	
	forever := make(chan bool)
	
	//5、启动协程处理消息
	go func() {
		for d := range message {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message : %s", d.Body)
		}
	}()
	
	log.Printf("[*] Waiting for messagees,To exit press CTRL+C")
	
	<-forever
}

 

知更鸟女孩
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang之消息队列——RabbitMQ的使用
QianLiStudent的博客
01-21 6448
消息队列的使用场景 异步处理       异步是指不用一次性执行完，可以先去执行别的，等这边回应了再做处理。这里我就拿一个网上用烂的例子：用户注册。用户在正确填写信息后点击注册，这时会发起网络请求到后端去做数据合法性等的验证，一旦验证通过则会将数据写入数据库并返回注册成功类的信息。但现在很多的应用都会有短信、邮箱等其他媒介的额外通知，这些...
golang版本的RabbitMQ消息订阅的封装,多生产者多消费者。
04-14
golang版本的RabbitMQ消息订阅的封装，可以多个生产者，多个消息订阅者，每个队列可以创建多个协程处理; 可能有些消费者需求需要分布式部署，那需要指定队列名，并且需要设置队列持久化，以及排他性QueueDeclare....
Golang使用RabbitMQ的四种工作模式
m0_52530105的博客
06-16 823
​ RabbitMQ 2007年发布，是一个在 AMQP (高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最主流的消息中间件之一。RabbitMQ是同Erlang语言开发对于一般的使用场景而言是一个非常不错的选择。
2024年Go最全Go操作RabbitMQ_go调用rabbitmq，Golang初级开发是如何一步步成为高级开发
最新发布
2401_84920027的博客
05-11 971
-mainWorkRecieve1.go // 消费者接受消息–-mainWorkRecieve2.go // 消费者接受消息。
RabbitMQ 高级：分布式事务详解案例——可靠生产（二）
祝我飞黄腾达
03-24 900
在上一篇博文中，我们讲述了分布式事务存在的问题，本文将用一个简单的demo代码演示分布式系统存在的事务问题，以及通过MQ的方式进行解决，达成数据最终一致性方案 项目架构 系统：订单服务（负责用户订单的接收）、运单中心（负责订单的配送） 使用技术：SpringBoot + SpringMVC + JdbcTemplate 项目内容：两套系统，订单系统下单，配送系统骑手接单 功能描述：订单系统创建订单，封装订单信息远程调用rpc接口（配送系统），配送服务通过订单详情进行对订单配送等追踪.
Golang操作Rabbitmq
名狱的博客
06-19 1814
简介 Rabbitmq就是一个消息的中间人，负责接受消息、转发消息和存储消息，并不参与消息的处理和计算。 没有固定哪一方是生产者，哪一方是消费者，谁发送消息给Rabbitmq谁就是生产者，谁接收Rabbitmq发送的消息谁就是消费者。Rabbitmq这个词是描述整个软件，而缓存消息的是这个软件内部的队列（或者说缓冲器，先进先出结构），内部可以后很多条队列，由于不参与计算，所以队列的性能只受内存和磁盘的约束。 一个生产者可以对应一个或者多个队列，一个队列可以对应一个或者多个消费者，并且传输过程中又很多处理方法
Go语言精髓 • 【RabbitMQ消息队列中间件】
koral的博客
04-19 381
1.定义和特征 RabbitMQ是面向消息的中间件，用于组件之间的解耦，主要体现在消息的发送者和消费者之间无强依赖关系（不用因发送和消费者的改变而额外开发）； 2.RabbitMQ特点 高可用，扩展性，多语言客户端，管理界面 3.主要使用场景 流量削峰，异步处理，应用解耦 4.安装命令【windows】 安装erlang，RabbitMQ依赖erlang 安装Rabbi...
使用golang实现的推送系统 结合rabbitmq消息队列 gin-web实现消息接收推送
02-18
golang 推送系统 单机 客户端通过websocket连接到服务端 ...服务端从rabbitmq接收消息，根据消息所属通过websocket推送到具体用户 服务端从http api接收消息，根据消息所属通过websocket推送到具体用户
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, ...
Go语言版本rabbitmq消息队列库：simple、worker、Fanout 模型、Direct 模型、Topic模型
07-29
同时实现了一个经纪人(Broker)构架，这意味着消息在发送给客户端时先在中心队列排队。对路由(Routing)，负载均衡(Load balance)或者数据持久化都有很好的支持。 RabbitMQ是一个消息代理：它接受和转发消息。 你可以...
libmq:golang中的Rabbitmq消息队列监视库可用于Openstack
04-30
libmq libmq是golang中的Rabbitmq消息队列监视库。 该库可用于监视Rabbitmq队列，例如Openstack中的那些。 可以在monitor目录中找到Openstack队列的示例监视。
基于Go实现的分布式MQ消息队列
01-03
基于Go实现的分布式MQ消息队列
rabbitmq入门（一）——创建用户以及分配vhost
Garnett_zk的博客
10-20 4247
rabbitmq,创建用户和虚拟主机
RabbitMQ学习笔记：虚拟主机（Virtual Hosts）
热门推荐
OceanSky的专栏
10-26 1万+
简介 RabbitMQ是一个多租户系统，connetions、exchange、queues、bindings、user permissions、policies和其它一些属于虚拟主机的东西； Virtual vhost 虚拟主机（vhost）提供逻辑分组和资源分离。每一个vhost本质上是一个mini版的RabbitMQ服务器，拥有自己的connection、exchange、queue、bin...
rocketmq在golang的使用
weixin_44798288的博客
06-29 5771
本文主要是演示golang操作rocketmq。go get 命令可以借助代码管理工具通过远程拉取或更新代码包及其依赖包，并自动完成编译和安装。整个过程就像安装一个 App 一样简单。这个命令在内部实际上分成了两步操作：第一步是下载源码包，第二步是执行 go install。所以我们执行如下命令进行下载安装： 执行过程如图： rocketmq客户端安装完成。后面我们才能使用rocketmq包提供的命令进行编码。其实在实际项目开发中的使用方式： 在go mod文件中添加： 编写代码 运行结果 我们运行代码
RabbitMQ消息队列在Golang中的简单使用
qq_44746132的博客
02-15 1419
AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。 RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP.
RabbitMQ常规操作（golang）
sillyyijia的博客
05-30 165
package RabbitMQ import ( "fmt" "github.com/streadway/amqp" "log" ) //url 格式 amqp://账号：密码@rabbitmq服务地址：端口号/vhost const MQURL = "amqp://imooc:imooc@127.0.0.1:5672/imooc" type RabbitMQ struct { conn *amqp.Connection channel *amqp.Channel //队列名称 Que
golang之Channel
phantom_111的博客
03-08 1599
Channel是Go中的一个核心类型，可以将其看成一个管道，通过它并发单元就可以发送或者接收数据进行通信（communication）。 Do not communicate by sharing memory; instead, share memory by communicating. channel基础知识 创建channel 使用内建函数make创建channel: u...
【Go】Go-Iris框架实战之电商秒杀系统②核心优化
王大阳的博客
08-13 964
文章目录第9章 系统分析&前端优化【核心优化方案落地9-2 秒杀分布式架构设计页面静态化的几种方式9-9 CDN原理和作用第10章 服务端性能优化之实现cookie验证后端优化思路基础架构与优化的的架构对比突破Session限制（Cookie代替）cookie与session的区别第11章 服务端性能优化之分布式验证实现11-1 分布式概念第12章 服务端性能优化解决超卖&引入消息队列第14章 课程总结 第9章 系统分析&前端优化【核心优化方案落地 9-2 秒杀分布式架构设计 页面
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` 结构体。然后，你可以根据需要处理和使用这些队列信息。 希望这个示例能帮助到你。如果有任何其他问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值