Go 实现Rabbitmq 简单模式

rabbitmq.go文件代码如下

package RabbitMQ

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

const MQURL = "amqp://lyc:[email protected]:5672/imooc"

type RabbitMQ struct {
   conn    *amqp.Connection
   channel *amqp.Channel
   //队列名称
   QueueName string
   //交换机
   Exchange string
   //key
   Key string
   //连接信息
   Mqurl string
}

// NewRabbitMQ 创建结构体实例
func NewRabbitMQ(queueName string, exchange string, key string) *RabbitMQ {
   rabbitmq := &RabbitMQ{
      QueueName: queueName,
      Exchange:  exchange,
      Key:       key,
      Mqurl:     MQURL,
   }
   var err error
   //创建rabbitmq连接
   rabbitmq.conn, err = amqp.Dial(rabbitmq.Mqurl)
   rabbitmq.failOnError(err, "创建连接错误")
   rabbitmq.channel, err = rabbitmq.conn.Channel()
   rabbitmq.failOnError(err, "获取Channel失败")
   return rabbitmq
}

// Destory 断开channel和Connection
func (r *RabbitMQ) Destory() {
   r.channel.Close()
   r.conn.Close()
}

// failOnError 错误处理函数
func (r *RabbitMQ) failOnError(err error, message string) {
   if err != nil {
      log.Fatalf("%s:%s", message, err)
      panic(fmt.Sprintf("%s:%s", message, err))
   }
}

// NewRabbitMQSimple   创建简单模式下RabbitMQ实例
func NewRabbitMQSimple(queueName string) *RabbitMQ {
   return NewRabbitMQ(queueName, "", "")
}

//PublishSimple 2简单模式Step:简单模式下生产代码
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,
      //如果为true，会根据exchange和routkey规则，如果无法以找到符合条件的
      //条件的人列那么会把发送的消息返回给发送者
      false,
      //如果为true,当exchange发送消息到队列后发现队列上没有绑定消费者，则
      //会把消息发还给发送者
      false,
      amqp.Publishing{
         ContentType: "text/plain",
         Body:        []byte(message),
      })
}

func (r *RabbitMQ) ConsumeSimple() {
   //1.申请队列，如果队列不存在会自动创建，如果存在则跳过创建
   //保证队列存在，消息能发送到队列中
   _, 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中发送的消息传递给
      //这个的connect消费者
      false,
      //队列是否阻塞
      false,
      nil,
   )
   if err != nil {
      fmt.Println(err)
   }
   forever := make(chan bool)
   //启用协程处理消息
   go func() {
      for d := range msgs {
         //实现我们要处理的逻辑函数
         log.Printf("Receive a massage:%s", d.Body)
      }
   }()
   log.Printf("[*] waiting for message, To exit press CTRL+C")
   <-forever
}

服务端代码：

package main

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

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

package main

import "go-rabbitmq/RabbitMQ"

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