Go秒杀系统——RabbitMQ核心概念与工作模式

前言💬

Windows 上的 RabbitMQ 被我卸载了，在 macOS 上再安装一下，采用 brew install 还是挺方便的。
很好奇微软的程序员写代码用的是 Windows 操作系统吗？感觉有点不方便，但用 macOS 岂不是太丢撵了。

一、macOS 安装 Go 和 RabbitMQ

brew install go
brew install erlang  // 若未安装，需要安装
brew install rabbitmq

是不是很方便💥！！此外根据 go 的奇怪特性，建议所有的项目都在 GOPATH 下的 src 目录中开发。

go env
mkdir -p GOPATH/{src,pkg,bin}

通过 go env 查到 GOPATH，在 GOPATH 下新建三个目录，在 src 目录中存放自己的代码。

二、RabbitMQ 核心概念

2.1 服务器启动与关闭

启动 RabbitMQ，首先要找到 brew 将其安装在哪，然后运行相应的可执行文件。

cd /usr/local/cellar/rabbitmq/3.10.7
./sbin/rabbitmq-server

启动成功后，查看 127.0.0.1:15672，15672是管理界面的默认端口，但5672是数据默认端口，开发时应连接5672端口。

通过以下命令关闭服务器。

rabbitmqctl stop

2.2 六个核心概念

• VirtualHost，虚拟主机，可以用作逻辑隔离，如测试环境和开发环境。
• Connection，建立满足 AMQP 协议的连接。
• Exchange，交换机，基于规则存储-转发消息，类似于计算机网络中的交换机。
• Queue，消息队列，两端可以视为广义的生产者和消费者。
• Channel，信道，它是生产者、消费者与RabbitMQ 通信的渠道。
• Binding，建立交换机与消息队列的绑定。

三、工作模式

所谓工作模式就是生产者与消费者间以何种规则进行生产、消费，RabbitMQ 官网对七种工作模式详解，总结如下：

工作模式	特点
Simple	消费者监听MQ，一旦有消息就消费掉，且该消息从队列中删除
Work	一个消息只能被一个消费者获取（如抢红包场景）
Publish-Subscribe	一个消息可以被多个消费者获取（如群聊天）
Routing
Topic
RPC
Publisher Confirms

3.1 工具函数和工具结构体定义

（1）除了默认虚拟主机 “/”，在 RabbitMQ 的管理页面创建一个新的 Virtual Host，取名为 imooc。

（2）然后除了默认用户 guest（密码 guest），创建新用户 imoocuser，密码也设为 imoocuser，为管理员且只能访问 imooc 虚拟主机。

/* rabbitmq.go */
package RabbitMQ

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

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

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 {
	return &RabbitMQ{QueueName: queueName, Exchange: exchange, Key: key, Mqurl: MQURL}
}

// 断开 channel 和 connection，r 是接收者变量
func (r *RabbitMQ) Destory() {
	r.channel.Close()
	r.conn.Close()
}

// 打印错误信息
func (r *RabbitMQ) failOnErr(err error, message string) {
	if err != nil {
		log.Fatalf("%s:%s", message, err)
		panic(fmt.Sprintf("%s:%s", message, err))
	}
}

3.2 实现 Simple 模式的生产者-消费者模型

Simple 模式的示意图如下，是最简单的一种消息队列，在其基础上无需太多代码修改即可实现 Work 工作模式。

该模式存在的隐患是，可能消费者未对消息进行正确处理，但该消息已经从队列中消失了。

/* rabbitmq.go */
/* ============= simple 模式下的生产消费 ============= */

// 创建 simple 模式的 rabbitmq 实例，传入参数仅为 queueName
func NewRabbitMQSimple(queueName string) *RabbitMQ {
	rabbitmq := NewRabbitMQ(queueName, "", "")
	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
}

// 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)
	}
	// 2. 发送消息到队列中
	r.channel.Publish(
		r.Exchange,
		r.QueueName,
		false, // 若为true，根据exchange类型和routekey规则，若无法找到符合条件的队列，则把发送的消息返回给发送者
		false, // 若为true，当exchange发送消息到队列后发现队列上没有绑定消费者，则把消息返回给发送者
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

// simple 模式下的消费者代码
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, // 是否有排他性
		false, // 若设置为true，表示不能将同一个connection中发送的消息传递给该connection中的消费者
		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.Printf("[*] Waiting for messages, To exit press CTRL+C")
	<-forever
}

然后定义两个 main 函数分别启动生产端和消费端。

/* mainSimplePublish.go */
package main

import (
	"fmt"
	"imooc-rabbitmq/RabbitMQ"
)

func main() {
	rabbitmq := RabbitMQ.NewRabbitMQSimple("imoocSimple")
	rabbitmq.PublishSimple("Hello imooc!")
	fmt.Println("send success!")
}

/* mainSimpleReceive.go */
package main

import "imooc-rabbitmq/RabbitMQ"

func main() {
	rabbitmq := RabbitMQ.NewRabbitMQSimple("imoocSimple")
	rabbitmq.ConsumeSimple()
}

// 先启动消费端，再启动生产端
% go run mainSimpleReceive.go
% go run mainSimplePublish.go

3.3 实现 Work 模式的生产者-消费者模型

所谓 Work 模式就是资源的竞争，一条消息只能被一个消费者获取并消费。

代码和 Simple 模式类似，只是 Publisher 需要发布多条消息，需要启动两（多）个消费者程序。

/* mainWorkPublish.go */
package main

import (
	"fmt"
	"imooc-rabbitmq/RabbitMQ"
	"strconv"
	"time"
)

func main() {
	rabbitmq := RabbitMQ.NewRabbitMQSimple("" + "imoocSimple")

	for i := 0; i <= 100; i++ {
		rabbitmq.PublishSimple("Hello imooc!" + strconv.Itoa(i))
		time.Sleep(1 * time.Second)
		fmt.Println(i)
	}
}

/* mainWorkReceive1.go 和 mainWorkReceive2.go 代码相同 */
package main

import "imooc-rabbitmq/RabbitMQ"

func main() {
	rabbitmq := RabbitMQ.NewRabbitMQSimple("" + "imoocSimple")
	rabbitmq.ConsumeSimple()
}

3.4 实现 PubSub（订阅）模式的生产者-消费者模型

下面示意图中的 X 指交换机，生产者将消息发送给交换机，消费者尝试创建队列并与交换机绑定，从而实现一个消息可以被多个消费者获取。交换机的类型应声明为 fanout，即广播类型，以转发消息给每个绑定到该交换机的队列。

/* rabbitmq.go */
/* ============= PubSub 模式下的生产消费 ============== */

// PubSub 模式下的 rabbitmq 实例，传入参数仅为 exchangeName
func NewRabbitMQPubSub(exchangeName string) *RabbitMQ {
	rabbitmq := NewRabbitMQ("", exchangeName, "")
	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
}

// 订阅模式下的生产者代码
func (r *RabbitMQ) PublishPub(message string) {
	// 1. 申请交换机，若交换机不存在，创建；若存在，不创建
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"fanout", // 广播类型
		true,     // 数据持久化
		false,
		false, // true 表示该exchange不可以被client用于推送消息，仅用于exchange间的绑定
		false,
		nil,
	)
	r.failOnErr(err, "Failed to declare an exchange")

	// 2. 发送消息到交换机中
	r.channel.Publish(
		r.Exchange,
		"",
		false,
		false,
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

// 订阅模式下的消费者代码
func (r *RabbitMQ) ReceiveSub() {
	// 1. 申请交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"fanout", // 广播类型
		true,     // 数据持久化
		false,
		false, // true 表示该exchange不可以被client用于推送消息，仅用于exchange间的绑定
		false,
		nil,
	)
	r.failOnErr(err, "Failed to 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,
		"",
		r.Exchange,
		false,
		nil,
	)
	r.failOnErr(err, "Failed to bind a queue")

	// 4. 消费消息
	msgs, err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil,
	)
	r.failOnErr(err, "Failed to consume messages")

	forever := make(chan bool)
	go func() {
		for d := range msgs {
			log.Printf("[*] Received a message: %s", d.Body)
		}
	}()
	fmt.Println("退出请按 CTRL + C\n")
	<-forever
}