rabbitmq的三种队列以及使用方式（go）

已于 2022-12-02 16:23:21 修改
阅读量1k 收藏
点赞数 1
文章标签： rabbitmq golang
于 2022-12-02 16:22:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CHen___MO/article/details/128149196
版权

rabbitmq的三种队列以及使用方式（beego）

提示：最上面右调用的统一调用，最下面有消费的代码注：消费需根据条件修改并另起一个mian.go

前言

面试官问这个问题，肯定是想知道你们公司有一个什么场景需要使用到这个Mq，这个场景有一个什么技术挑战导致必须要用这个mq，用了这个mq之后有什么好处。mq经典的使用场景有解耦，异步，削锋。
而rabbitmq是如何进行使用的他的使用发放是什么呢？

提示：先是统一的引入跟实例化

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

type Callback func(str1 string)

//Connect RabbitMQ连接函数
func Connect() (conn *amqp.Connection, err error) {
	//连接mq
	conn, err = amqp.Dial("amqp://guest:guest@127.0.0.1:5672/")
	return conn, err
}


func BytesToString(b *[]byte) *string {
	s := bytes.NewBuffer(*b)
	r := s.String()
	return &r
}

一、rabbitmq的普通队列（路由模式）

1.生成者

示例：这是最普通的rabbitmq的生成者


//Publish 发送端函数
//exchange交换机名称
//queueName队列名称
//body发送内容
func Publish(exchange string, queueName string, body string) error {
	//建立连接
	conn, err := Connect()
	if err != nil {
		return err
	}
	defer conn.Close()

	//创建通道channel
	channel, err := conn.Channel()
	if err != nil {
		return err
	}
	defer channel.Close()

	//创建队列
	q, err := channel.QueueDeclare(
		queueName, //队列名称
		true,      //持久化
		false,
		false,
		false,
		nil,
	)
	if err != nil {
		return err
	}
	//发送消息
	err = channel.Publish(exchange, q.Name, false, false, amqp.Publishing{
		DeliveryMode: amqp.Persistent,
		ContentType:  "text/plain",
		Body:         []byte(body),
	})
	return err
}

2.消费者

实例：这是普通队列的消费


//Consumer 接受方法
func Consumer(exchange string, queueName string, callback Callback) {
	//建立连接
	conn, err := Connect()
	defer conn.Close()
	if err != nil {
		fmt.Println(err)
		return
	}
	//创建通道channel
	channel, err := conn.Channel()
	defer channel.Close()

	if err != nil {
		fmt.Println(err)
		return
	}

	//创建queue
	q, err := channel.QueueDeclare(
		queueName,
		true,
		false,
		false,
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	//输出
	msgs, err := channel.Consume(
		q.Name,
		"",
		false, //手动应答
		false,
		false,
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	forever := make(chan bool)
	go func() {
		for d := range msgs {
			s := BytesToString(&(d.Body))
			callback(*s)
			d.Ack(false)
		}
	}()
	fmt.Printf("Waiting for messages")
	<-forever
}

func BytesToString(b *[]byte) *string {
	s := bytes.NewBuffer(*b)
	r := s.String()
	return &r
}
func callback(s string) {
	fmt.Printf("msg:%s", s)
	return
}

二、rabbitmq的并发队列（主题模式）

1.生产者

代码如下（示例）：

func PublishEx(exchange string, types string, routingKey string, body string) error {
	//建立连接
	conn, err := Connect()
	defer conn.Close()
	if err != nil {
		return err
	}
	//创建channel
	channel, err := conn.Channel()
	defer channel.Close()
	if err != nil {
		return err
	}

	//创建交换机
	err = channel.ExchangeDeclare(
		exchange,
		types,
		true,
		false,
		false,
		false,
		nil,
	)
	if err != nil {
		return err
	}

	err = channel.Publish(exchange, routingKey, false, false, amqp.Publishing{
		DeliveryMode: amqp.Persistent,
		ContentType:  "text/plain",
		Body:         []byte(body),
	})
	return err
}

2.消费者

代码如下（示例）：

func ConsumerEx(exchange string, types string, routingKey string, callback Callback) {
	//建立连接
	conn, err := Connect()
	defer conn.Close()
	if err != nil {
		fmt.Println(err)
		return
	}
	//创建通道channel
	channel, err := conn.Channel()
	defer channel.Close()
	if err != nil {
		fmt.Println(err)
		return
	}

	//创建交换机
	err = channel.ExchangeDeclare(
		exchange,
		types,
		true,
		false,
		false,
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	//创建队列
	q, err := channel.QueueDeclare(
		"",
		false,
		false,
		true,
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	//绑定
	err = channel.QueueBind(
		q.Name,
		routingKey,
		exchange,
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	msgs, err := channel.Consume(q.Name, "", false, false, false, false, nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	forever := make(chan bool)
	go func() {
		for d := range msgs {
			s := BytesToString(&(d.Body))
			callback(*s)
			d.Ack(false)
		}
	}()
	fmt.Printf("Waiting for messages\n")
	<-forever
}

三、rabbitmq的双队列（死信队列）

1.生产者

代码如下（示例）：

func PublishDlx(exchangeA string, body string) error {
	//建立连接
	conn, err := Connect()
	if err != nil {
		return err
	}
	defer conn.Close()

	//创建一个Channel
	channel, err := conn.Channel()
	if err != nil {
		return err
	}
	defer channel.Close()

	//消息发送到A交换机
	err = channel.Publish(exchangeA, "", false, false, amqp.Publishing{
		DeliveryMode: amqp.Persistent,
		ContentType:  "text/plain",
		Body:         []byte(body),
	})

	return err
}

2.消费者

代码如下（示例）：

func ConsumerDlx(exchangeA string, queueAName string, exchangeB string, queueBName string, ttl int, callback Callback) {
	//建立连接
	conn, err := Connect()
	if err != nil {
		fmt.Println(err)
		return
	}
	defer conn.Close()

	//创建一个Channel
	channel, err := conn.Channel()
	if err != nil {
		fmt.Println(err)
		return
	}
	defer channel.Close()

	//创建A交换机
	//创建A队列
	//A交换机和A队列绑定
	err = channel.ExchangeDeclare(
		exchangeA, // name
		"fanout",  // type
		true,      // durable
		false,     // auto-deleted
		false,     // internal
		false,     // no-wait
		nil,       // arguments
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	//创建一个queue，指定消息过期时间，并且绑定过期以后发送到那个交换机
	queueA, err := channel.QueueDeclare(
		queueAName, // name
		true,       // durable
		false,      // delete when usused
		false,      // exclusive
		false,      // no-wait
		amqp.Table{
			// 当消息过期时把消息发送到 exchangeB
			"x-dead-letter-exchange": exchangeB,
			"x-message-ttl":          ttl,
			//"x-dead-letter-queue" : queueBName,
			//"x-dead-letter-routing-key" :
		},
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	//A交换机和A队列绑定
	err = channel.QueueBind(
		queueA.Name, // queue name
		"",          // routing key
		exchangeA,   // exchange
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
		return
	}
	//创建B交换机
	//创建B队列
	//B交换机和B队列绑定
	err = channel.ExchangeDeclare(
		exchangeB, // name
		"fanout",  // type
		true,      // durable
		false,     // auto-deleted
		false,     // internal
		false,     // no-wait
		nil,       // arguments
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	//创建一个queue
	queueB, err := channel.QueueDeclare(
		queueBName, // name
		true,       // durable
		false,      // delete when usused
		false,      // exclusive
		false,      // no-wait
		nil,        // arguments
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	//B交换机和B队列绑定
	err = channel.QueueBind(
		queueB.Name, // queue name
		"",          // routing key
		exchangeB,   // exchange
		false,
		nil,
	)
	if err != nil {
		fmt.Println(err)
		return
	}

	msgs, err := channel.Consume(queueB.Name, "", false, false, false, false, nil)
	if err != nil {
		fmt.Println(err)
		return
	}

	forever := make(chan bool)
	go func() {
		for d := range msgs {
			s := BytesToString(&(d.Body))
			callback(*s)
			d.Ack(false)
		}
	}()

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

剩下的统一调用消费者模板


    package main

	import (
		"encoding/json"
		"fmt"
		"github.com/beego/beego/v2/client/orm"
		beego "github.com/beego/beego/v2/server/web"
		"github.com/garyburd/redigo/redis"
		"goApi/models"
		_ "goApi/routers"
		redisClient "goApi/services"
		"goApi/services/mq"
		"strconv"
	)
	
	func main() {
		beego.LoadAppConfig("ini", "../../conf/app.conf")
		//err := orm.RegisterDataBase("default", "mysql", "fukw:ipx4JtpXR6sCxmKt@tcp(127.0.0.1)/fukw?charset=utf8")
		err := orm.RegisterDataBase("default", "mysql", "root:root@tcp(127.0.0.1)/fukw?charset=utf8")
		if err != nil {
			fmt.Println("连接数据库失败")
		}
	
		c, err := redis.Dial("tcp", "127.0.0.1:6379")
		if err != nil {
			fmt.Println("redis连接失败")
		}
		defer c.Close()
	
		mq.Consumer("", "fyouku_top", callback)
		fmt.Printf("mian执行成功")
		beego.Run()
	}
	
	func callback(s string) {
		type Data struct {
			VideoId int
		}
		var data Data
		err := json.Unmarshal([]byte(s), &data)
		videoInfo, err := models.GetVideoInfo(data.VideoId)
		if err == nil {
			conn := redisClient.RedisConnect()
			defer conn.Close()
			//更新排行榜
			//执行的代码我这里是排行榜
			redisChannelKey := "video:top:channel:channelId:" + strconv.Itoa(videoInfo.ChannelId)
			redisTypeKey := "video:top:type:typeId:" + strconv.Itoa(videoInfo.TypeId)
			conn.Do("zincrby", redisChannelKey, 1, data.VideoId)
			conn.Do("zincrby", redisTypeKey, 1, data.VideoId)
		}
		fmt.Printf("msg is :%s\n", s)
	}

总结

这就是rabbitmq的3种队列的的书写形式

嘟嘟可故事集
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go语言版本rabbitmq消息队列库：simple、worker、Fanout 模型、Direct 模型、Topic模型
07-29
Go语言版本rabbitmq消息队列库：simple、worker、Fanout 模型、Direct 模型、Topic模型。 RabbitMQ 是使用Erlang编写的一个开源的消息队列，本身支持很多的协议：AMQP，XMPP, SMTP, STOMP，也正是如此，使的它变的...
beego环境下 rabbitmq封装以及使用
03-17
Beego是一个快速开发Go语言Web应用的框架，其设计理念是简洁、高效。在Beego中集成RabbitMQ，可以帮助我们构建能够处理大量并发请求的微服务架构。 封装RabbitMQ在Beego中的步骤通常包括以下几个部分： 1. **安装...
RabbitMq图形界面创建队列操作步骤
Thea_Li的博客
08-03 5032
RabbitMq
RabbitMq------初级+高级（一）
weixin_54406708的博客
08-02 2240
基于spring-boot-AMQP来对rabbitmq进行消息的异步发送，以及对应的队列。
Rabbitmq消息队列
最新发布
Casual_Lei的博客
06-17 539
​ MQ全称为Message Queue，即消息队列. 它也是一个队列,遵循FIFO原则。RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue Protocol高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。​ 官方地址：http://www.rabbitmq.com/在之前的模式中，我们创建了一个工作队列。工作队列背后的假设是：每个任务只被传递给一个工作人员。
SpringBoot使用RabbitMQ自动创建Exchange和Queue
cainiao1412的博客
08-18 2113
小项目，使用RabbitMQ作为消息队列，发布到不同的新环境时，由于新搭建的MQ中不存在Exchange和Queue，就会出错，还得手动去创建，比较麻烦，于是想在代码中将这些定义好后，自动控制MQ去创建。
beego RabbitMQ 简单模式 工作模式
s1095622320的博客
03-11 1986
MQ服务 package mq import ( "bytes" "fmt" "github.com/streadway/amqp" ) // 连接 func Connect() (*amqp.Connection, error) { conn, err := amqp.Dial("amqp://guest:guest@127.0.0.1:5672/") return conn, err } // 发送端函数 func Publist(exchange string, queueNa..
SpringBoot + RabbitMQ 简单实现创建队列的三种方式
热门推荐
老油条
11-20 3万+
  1、前提：安装：RabbitMQ 通过Docker方式快速安装    2、pox.xml 引入 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-cloud-starter-amqp&lt;/artifactId&gt;...
使用golang实现的推送系统 结合rabbitmq消息队列 gin-web实现消息接收推送
02-18
golang 推送系统 单机 客户端通过websocket连接到服务端 客户端发送jwt-token验证身份，确定用户是谁 服务端从rabbitmq接收消息，根据消息所属通过websocket推送到具体用户 服务端从http api接收消息，根据消息所属...
rabbitmq-dump-queue:将消息从 RabbitMQ 队列转储到文件，而不影响队列
08-05
rabbitmq-转储队列 将消息从 RabbitMQ 队列转储到文件，而不影响队列。 安装 下载一个版本 可以在页面上找到预编译的二进制包。 从源代码编译 如果您安装了 ，则可以通过运行以下命令从源代码安装 rabbitmq-dump-...
Golang基于amqp协议实现rabbitMQ队列消费
01-07
发布消息 package main import ( ... log ) //我们还需要一个辅助函数来检查每个amqp调用的返回值： func failOnError(err error, msg string) { if err != nil { log.Fatalf(%s: %s, msg, err) ...
利用消息中间件RabbitMQ创建队列以及扇出（Fanout）、订阅（Direct）、主题（Topic）交换机来完成消息的发送和监听接收（完整版）
c_xiao_dian_dian的博客
07-10 4131
5.1交换机的作用是什么？接收publisher发送的消息、将消息按照规则路由到与之绑定的队列、不能缓存消息，路由失败，消息丢失、FanoutExchange的会将消息路由到每个绑定的队列 5.2声明队列、交换机、绑定关系的Bean是什么？Queue、FanoutExchange、Binding
RabbitMQ学习（七）之 “RabbitMQ实战经验总结”
依剑行走天下的博客
12-21 412
1.资源管理 队列到底是消费者创建还是生产者创建？ 答案是：消费者创建 （谁使用谁管理，谁污染谁治理） 交换机和队列，实际上是作为资源，由运维管理员创建的。 为什么仍然需要在代码中定义？重复创建不报错吗？（重复定义不会报错） 2. 配置文件与命名规范 元数据的命名集中放在 properties 文件中，不要用硬编码。 如果有多个系统，可以配置多个 xxx_mq.properties。 命名体现元数据的类型 虚拟机命名： XXX_VHOST 交换机命名：XXX_EXCHANGE 队列命名：_QU
RabbitMQ系列（25）--RabbitMQ搭建镜像队列
m0_64284147的博客
07-08 2476
从Queues进入mirror_queue队列查看详情，可以发现当node1节点停掉后node2自动替代了node1节点的位置，node3作为镜像队列的节点，由此可见我们策略里写的ha-params：2这一参数是生效的，使得节点的个数总是保持2个，这样就算我们整个集群只剩下一台机器，在节点不断替代的情况下，消费者始终能消费队列里面的消息。(8)为ha-params指定策略作用的节点的数量为2（包含被镜像的队列，镜像和被镜像的队列数总共为2）(6)执行以下代码，在node2节点里生成消费者，尝试消费消息。
RabbitMQ队列及交换机的使用
qi341500的博客
10-21 3087
一、简单模型 1、首先控制台创建一个队列 2、父工程导入依赖 3、生产者配置文件 4、写测试类 5、消费者配置文件 6、消费者接收消息 二、WorkQueues模型 1、在控制台创建一个新的队列 2、生产者生产消息 3、创建两个消费者接收消息 4、能者多劳充分利用每一个消费者的能力 三、交换机 四、Fanout交换机 1、 声明队列 2、创建交换机 ​编辑3、绑定交换机 4、示例 五、Diect交换机 1、 声明队列 2、创建交换机 3、绑定交换机
5.RabbitMQ消息队列类型（7个）详细使用
相互学习 共同进步
05-22 2479
RabbitMQ是消息代理：接受并转发消息。可以将其视为邮局 将要发布的邮件放在邮箱中时，可以确保邮递员最终将邮件传递给收件人。以此类推，RabbitMQ是一个邮箱、一个邮局和一个邮递员 RabbitMQ与邮局之间的主要区别在于，它不处理纸张。只是做接收、存储和转发数据消息的二进制码 AMQP（Advanced Message Queuing Protocol，高级消息队列协议） 应用层协议的一个开放标准，为面向消息的中间件设计。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性
RabbitMQ控制台的基本使用
m0_74163986的博客
02-01 1396
启动RabbitMQ后，浏览器打开RabbitMQ的控制台页面后，登录默认账户guest。
RabbitMQ的基本概念和七种队列模式
Mr. David 专栏
07-05 1304
消息队列是RabbitMQ的内部对象，用于存储生产者的消息直到发送给消费者，它是消费者接收消息的地方。在通道上启用发布者确认后，RabbitMQ将异步确认发送者发布的消息，这意味着它们已在服务器端处理。只有此促销活动会接收到消息，其它促销活动不关心也不会消费此routing key的消息。将发送的电子邮件放到消息队列，然后邮件服务在队列中获取邮件并发送给收件人。消费者将队列绑定到交换机时需要指定路由key，仅消费指定路由key的消息。路由键(routing key)和路由模式匹配后，交换机才能转发消息。
RabbitMQ基础
让我思考一下
07-19 426
关于消息中间件 消息传递是分布式系统必然要面对的一个问题，消息中间件解决的就是分布式系统之间消息传递的问题。消息中间件的应用场景大致如下： 业务解耦：交易系统不需要知道短信通知服务的存在，只需要发布消息 削峰填谷：比如上游系统的吞吐能力高于下游系统，在流量洪峰时可能会冲垮下游系统，消息中间件可以在峰值时堆积消息，而在峰值过去后下游系统慢慢消费消息解决流量洪峰的问题 事件驱动：系统与系统之间可...
golang 调用RabbitMQ消息队列监控API
07-28
在 Golang 中调用 RabbitMQ 的消息队列监控 API 可以使用标准的 `net/http` 包来发送 HTTP 请求并处理响应。以下是一个简单的示例代码，用于获取 RabbitMQ 的队列信息： ```go package main import ( "encoding/...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值