simple模式下rabbitmq的代码

simple模式代码

package RabbitMQ

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

const MQURL = "amqp://guest:guest@127.0.0.1:5672/imooc"

//创建rabbitmq结构体实例
type RabbitMQ struct {
    conn      *amqp.Connection
    channel   *amqp.Channel
    QueueName string
    Exchange  string
    Key       string
    Mqurl     string
}

func NewRabbitMQ(queueName string, Exchange string, key string) *RabbitMQ {
    rabbitmq := &RabbitMQ{QueueName: queueName, Exchange: Exchange, Key: key, Mqurl: MQURL}
    var err error
    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) Destroy() {
    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模式step1: rabbitmq的实例
func NewRabbitMQSimple(queueName string) *RabbitMQ {
    return NewRabbitMQ(queueName, "", "")
}

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

func (r *RabbitMQ) ConsumeSimple() {
    _, err := r.channel.QueueDeclare(
        r.QueueName,
        //是否持久化
        false,
        //是否为自动删除
        false,
        //是否具有排他性
        false,
        //是否阻塞
        false,
        //额外属性
        nil,
    )
    if err != nil {
        fmt.Println(err)
    }
    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)
    //启用协程处理消息
    go func() {
        for d := range msgs {
            //实现我们要处理的逻辑函数
            log.Printf("Received a message:%s")
            fmt.Println(string(d.Body))
        }
    }()
    log.Printf("[*] waiting for messages,to exit press CTRL+C")
    <-forever
}

simple模式消费者代码

package main

import "immoc-rabbitmq/RabbitMQ"

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

simple模式生产者代码

package main

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

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

来自为知笔记(Wiz)