RabbitMq路由模式

路由模式

路由模式下创建RabbitMq实例需要传入交换机exchange和routingkey

func NewRabbitMqRouting(exchange, routingKey string) *RabbitMq {
	//创建rabbitmq实例
	rabbitmq := NewRabbitMq("", exchange, routingKey)
	return rabbitmq
}

生产者：

1、尝试创建交换机，kind为direct模式

2、发送消息channel.Publish, 传入交换机，routingkey

func (r *RabbitMq) PublishRouting(message string) {
	//1. 尝试创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"direct",
		//是否持久化
		false,
		//
		false,
		false,
		false,
		nil)
	r.failOnErr(err, "failed to declare an exchange")

	//2. 发送消息
	r.channel.Publish(
		//交换机
		r.Exchange, 
		r.Key,
		false,
		false,
		//发送的信息
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(message),
		})
}

消费者

1、尝试创建交换机 参数为exchange, 模式为direct

2、申请队列，队列名称为空

3、绑定队列到交换机中，传入队列名称q.Name, r.Exchange, r.Key

4、channel.Consume消费消息，消费消息只需要传入队列名称即可，所有模式都一样

func(r *RabbitMq)RecieveRouting(){
	//尝试创建交换机
	err := r.channel.ExchangeDeclare(
		r.Exchange,
		"direct",
		//是否持久化
		false,
		//
		false,
		false,
		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 an queue")

	//3 绑定队列到exchange中
	err = r.channel.QueueBind(
		q.Name,
		r.Key,
		r.Exchange,
		false,
		nil)

	//消费消息
	msgs, err := r.channel.Consume(
		q.Name,
		"",
		true,
		false,
		false,
		false,
		nil)

	if err != nil {
		fmt.Printf("channel.Consume failed, error:%+v\n", err)
		return
	}

	forever := make(chan bool)
	go func() {
		for d := range msgs {
			//实现我们要处理的逻辑函数
			log.Printf("Received a message:%s", d.Body)
		}
	}()
	log.Printf("[*] Waiting for message, exit to  press CTRL + C")
	<-forever


}

使用案例

生产者

package main

import (
	"rabbitmq/RabbitMq"
	"strconv"
	"time"
)

func main() {

	imoocOne := RabbitMq.NewRabbitMqRouting("exImooc", "imooc_one")
	imoocTwo := RabbitMq.NewRabbitMqRouting("exImooc", "imooc_two")
	for i := 0; i < 10; i++ {
		imoocOne.PublishRouting("imooc one " + strconv.Itoa(i))
		imoocTwo.PublishRouting("imooc two " + strconv.Itoa(i))
		time.Sleep(10 * time.Millisecond)
	}
}

消费者

package main

import "rabbitmq/RabbitMq"

func main(){

	rabbitmq := RabbitMq.NewRabbitMqRouting("exImooc", "imooc_one")
	rabbitmq.RecieveRouting()
}

===============================================================
package main

import (
	"rabbitmq/RabbitMq"
)

func main(){
	rabbitmq := RabbitMq.NewRabbitMqRouting("exImooc", "imooc_two")
	rabbitmq.RecieveRouting()
}

分析：

生产者生产交换机为exImooc,routingKey为:imooc_one 和 imooc_two的生产者

两个消费者分别创建imooc_one 和 imooc_two的两个rabbitmq实例，进行消费

消费者1只能获取到imooc_one的消息

消费者2只能获取到imooc_two的消息

输出结果

消费者1

2019/07/04 11:55:02 [*] Waiting for message, exit to  press CTRL + C
2019/07/04 11:55:16 Received a message:imooc one 0
2019/07/04 11:55:16 Received a message:imooc one 1
2019/07/04 11:55:16 Received a message:imooc one 2
2019/07/04 11:55:16 Received a message:imooc one 3
2019/07/04 11:55:16 Received a message:imooc one 4
2019/07/04 11:55:16 Received a message:imooc one 5
2019/07/04 11:55:16 Received a message:imooc one 6
2019/07/04 11:55:16 Received a message:imooc one 7
2019/07/04 11:55:16 Received a message:imooc one 8
2019/07/04 11:55:16 Received a message:imooc one 9

消费者2

2019/07/04 11:55:06 [*] Waiting for message, exit to  press CTRL + C
2019/07/04 11:55:16 Received a message:imooc two 0
2019/07/04 11:55:16 Received a message:imooc two 1
2019/07/04 11:55:16 Received a message:imooc two 2
2019/07/04 11:55:16 Received a message:imooc two 3
2019/07/04 11:55:16 Received a message:imooc two 4
2019/07/04 11:55:16 Received a message:imooc two 5
2019/07/04 11:55:16 Received a message:imooc two 6
2019/07/04 11:55:16 Received a message:imooc two 7
2019/07/04 11:55:16 Received a message:imooc two 8
2019/07/04 11:55:16 Received a message:imooc two 9