Windows 上的 RabbitMQ 被我卸载了,在 macOS 上再安装一下,采用 brew install 还是挺方便的。
很好奇微软的程序员写代码用的是 Windows 操作系统吗?感觉有点不方便,但用 macOS 岂不是太丢撵了。
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,首先要找到 brew 将其安装在哪,然后运行相应的可执行文件。
cd /usr/local/cellar/rabbitmq/3.10.7
./sbin/rabbitmq-server
启动成功后,查看 127.0.0.1:15672,15672是管理界面的默认端口,但5672是数据默认端口,开发时应连接5672端口。
通过以下命令关闭服务器。
rabbitmqctl stop
所谓工作模式就是生产者与消费者间以何种规则进行生产、消费,RabbitMQ 官网对七种工作模式详解,总结如下:
工作模式 | 特点 |
---|---|
Simple | 消费者监听MQ,一旦有消息就消费掉,且该消息从队列中删除 |
Work | 一个消息只能被一个消费者获取(如抢红包场景) |
Publish-Subscribe | 一个消息可以被多个消费者获取(如群聊天) |
Routing | |
Topic | |
RPC | |
Publisher Confirms |
(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:[email protected]: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))
}
}
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
所谓 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()
}
下面示意图中的 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
}