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

}

package main

import "immoc-rabbitmq/RabbitMQ"

func main() {

    rabbitmq := RabbitMQ.NewRabbitMQSimple("imoocSimple")

    rabbitmq.ConsumeSimple()

}

package main

import (

    "fmt"

    "immoc-rabbitmq/RabbitMQ"

)

func main() {

    rabbitmq := RabbitMQ.NewRabbitMQSimple("imoocSimple")

    rabbitmq.PublishSimple("hello imooc!")

    fmt.Println("发送成功!")

}