程序封裝
package rabbitmq
import (
"fmt"
"github.com/streadway/amqp"
"time"
)
// 定義全局變量,指針類型
var mqConn *amqp.Connection
var mqChan *amqp.Channel
// 定義生產者接口
type Producer interface {
MsgContent() string
}
// 定義接收者接口
type Receiver interface {
Consumer([]byte) error
}
// 定義RabbitMQ對象
type RabbitMQ struct {
connection *amqp.Connection
channel *amqp.Channel
queueName string // 隊列名稱
routingKey string // key名稱
exchangeName string // 交換機名稱
exchangeType string // 交換機類型
producerList []Producer
receiverList []Receiver
}
// 定義隊列交換機對象
type QueueExchange struct {
QuName string // 隊列名稱
RtKey string // key值
ExName string // 交換機名稱
ExType string // 交換機類型
}
// 鏈接rabbitMQ
func (r *RabbitMQ)mqConnect() {
var err error
RabbitUrl := fmt.Sprintf("amqp://%s:%s@%s:%d/", "guest", "guest", "******", 5673)
mqConn, err = amqp.Dial(RabbitUrl)
r.connection = mqConn // 賦值給RabbitMQ對象
if err != nil {
fmt.Printf("MQ打開鏈接失敗:%s \n", err)
}
mqChan, err = mqConn.Channel()
r.channel = mqChan // 賦值給RabbitMQ對象
if err != nil {
fmt.Printf("MQ打開管道失敗:%s \n", err)
}
}
// 關閉RabbitMQ連接
func (r *RabbitMQ)mqClose() {
// 先關閉管道,再關閉鏈接
err := r.channel.Close()
if err != nil {
fmt.Printf("MQ管道關閉失敗:%s \n", err)
}
err = r.connection.Close()
if err != nil {
fmt.Printf("MQ鏈接關閉失敗:%s \n", err)
}
}
// 創建一個新的操作對象
func New(q *QueueExchange) *RabbitMQ {
return &RabbitMQ{
queueName:q.QuName,
routingKey:q.RtKey,
exchangeName: q.ExName,
exchangeType: q.ExType,
}
}
// 啓動RabbitMQ客戶端,並初始化
func (r *RabbitMQ) Start() {
// 開啓監聽生產者發送任務
for _, producer := range r.producerList {
go r.listenProducer(producer)
}
// 開啓監聽接收者接收任務
for _, receiver := range r.receiverList {
go r.listenReceiver(receiver)
}
time.Sleep(1*time.Second)
}
// 註冊發送指定隊列指定路由的生產者
func (r *RabbitMQ) RegisterProducer(producer Producer) {
r.producerList = append(r.producerList, producer)
}
// 發送任務
func (r *RabbitMQ) listenProducer(producer Producer) {
// 驗證鏈接是否正常,否則重新鏈接
if r.channel == nil {
r.mqConnect()
}
// 用於檢查隊列是否存在,已經存在不需要重複聲明
_, err := r.channel.QueueDeclarePassive(r.queueName, true,false,false,true,nil)
if err != nil{
// 隊列不存在,聲明隊列
// name:隊列名稱;durable:是否持久化,隊列存盤,true服務重啓後信息不會丟失,影響性能;autoDelete:是否自動刪除;noWait:是否非阻塞,
// true爲是,不等待RMQ返回信息;args:參數,傳nil即可;exclusive:是否設置排他
_, err = r.channel.QueueDeclare(r.queueName, true, false, false, true, nil)
if err != nil {
fmt.Printf("MQ註冊隊列失敗:%s \n", err)
return
}
}
// 隊列綁定
err = r.channel.QueueBind(r.queueName, r.routingKey, r.exchangeName, true,nil)
if err != nil {
fmt.Printf("MQ綁定隊列失敗:%s \n", err)
return
}
// 用於檢查交換機是否存在,已經存在不需要重複聲明
err = r.channel.ExchangeDeclarePassive(r.exchangeName, r.exchangeType, true, false, false, true, nil)
if err != nil{
// 註冊交換機
// name:交換機名稱,kind:交換機類型,durable:是否持久化,隊列存盤,true服務重啓後信息不會丟失,影響性能;autoDelete:是否自動刪除;
// noWait:是否非阻塞, true爲是,不等待RMQ返回信息;args:參數,傳nil即可; internal:是否爲內部
err = r.channel.ExchangeDeclare(r.exchangeName, r.exchangeType, true, false, false, true, nil)
if err != nil {
fmt.Printf("MQ註冊交換機失敗:%s \n", err)
return
}
}
// 發送任務消息
err = r.channel.Publish(r.exchangeName, r.routingKey, false, false, amqp.Publishing{
ContentType: "text/plain",
Body: []byte(producer.MsgContent()),
})
if err != nil {
fmt.Printf("MQ任務發送失敗:%s \n", err)
return
}
}
// 註冊接收指定隊列指定路由的數據接收者
func (r *RabbitMQ) RegisterReceiver(receiver Receiver) {
r.receiverList = append(r.receiverList, receiver)
}
// 監聽接收者接收任務
func (r *RabbitMQ) listenReceiver(receiver Receiver) {
// 處理結束關閉鏈接
defer r.mqClose()
// 驗證鏈接是否正常
if r.channel == nil {
r.mqConnect()
}
// 用於檢查隊列是否存在,已經存在不需要重複聲明
_, err := r.channel.QueueDeclarePassive(r.queueName, true,false,false,true,nil)
if err != nil{
// 隊列不存在,聲明隊列
// name:隊列名稱;durable:是否持久化,隊列存盤,true服務重啓後信息不會丟失,影響性能;autoDelete:是否自動刪除;noWait:是否非阻塞,
// true爲是,不等待RMQ返回信息;args:參數,傳nil即可;exclusive:是否設置排他
_, err = r.channel.QueueDeclare(r.queueName, true, false, false, true, nil)
if err != nil {
fmt.Printf("MQ註冊隊列失敗:%s \n", err)
return
}
}
// 綁定任務
err = r.channel.QueueBind(r.queueName, r.routingKey, r.exchangeName, true, nil)
if err != nil {
fmt.Printf("綁定隊列失敗:%s \n", err)
return
}
// 獲取消費通道,確保rabbitMQ一個一個發送消息
err = r.channel.Qos(1, 0, true)
msgList, err := r.channel.Consume(r.queueName, "", false, false, false, false, nil)
if err != nil {
fmt.Printf("獲取消費通道異常:%s \n", err)
return
}
for msg := range msgList {
// 處理數據
err := receiver.Consumer(msg.Body)
if err!=nil {
err = msg.Ack(true)
if err != nil {
fmt.Printf("確認消息未完成異常:%s \n", err)
return
}
}else {
// 確認消息,必須爲false
err = msg.Ack(false)
if err != nil {
fmt.Printf("確認消息完成異常:%s \n", err)
return
}
return
}
}
}
使用方法
package main
import (
"fmt"
"test/rabbitmq"
)
type TestPro struct {
msgContent string
}
// 實現發送者
func (t *TestPro) MsgContent() string {
return t.msgContent
}
// 實現接收者
func (t *TestPro) Consumer(dataByte []byte) error {
fmt.Println(string(dataByte))
return nil
}
func main() {
msg := fmt.Sprintf("這是測試任務")
t := &TestPro{
msg,
}
queueExchange := &rabbitmq.QueueExchange{
"test.rabbit",
"rabbit.key",
"test.rabbit.mq",
"direct",
}
mq := rabbitmq.New(queueExchange)
mq.RegisterProducer(t)
mq.RegisterReceiver(t)
mq.Start()
}