什么是消息队列

我们可以简单理解消息队列就是将需要传输的数据存放在队列中。 消息队列（Message Queue，简称MQ），从字面意思上看，本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已。 其主要用途：不同进程Process线程Thread之间通信。 不同进程（process）之间传递消息时，为了实现标准化，将消息的格式规范化了，并且，某一个进程接受的消息太多，一下子无法处理完，并且也有先后顺序，必须对收到的消息进行排队，因此诞生了事实上的消息队列；

目前市面上的消息队列有很多，例如：Kafka、RabbitMQ、ActiveMQ、RocketMQ、ZeroMQ等。

不同MQ的特点

RabbitMQ

RabbitMQ的简介

AMQP

AMQP是消息队列的一个协议。

生产者将消息发送到服务的的虚拟主机内的交换机 交换机将消息通过特定规则放入特定的消息队列 消息队列再将消息发送给消费者 (Kafka是消费者去消息队列去读取消息)

RabbitMQ支持的消息模型

RabbitMQ整和SpringBoot

引入依赖

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency>

配置连接信息

#rabbitmq
spring.rabbitmq.addresses=172.28.5.134
spring.rabbitmq.port=5674
spring.rabbitmq.username=ems
spring.rabbitmq.password=123
spring.rabbitmq.virtual-host=/test

生产者 生产消息

@SpringBootTest(classes = RabbitMqSpringbootApplication.class)
@RunWith(SpringRunner.class)
public class TestRabbitMQ {

    // 注入RabbitMQTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    // helloWorld
    @Test
    public void testHello(){
        rabbitTemplate.convertAndSend("hello","hello world");
    }

    // worker
    @Test
    public void  testWorker(){
        rabbitTemplate.convertAndSend("work","work模型");
    }

    // fanout 广播
    @Test
    public void testFanout(){
        rabbitTemplate.convertAndSend("logs","","fanout消息模型");
    }

    // router
    @Test
    public void testRouter(){
        rabbitTemplate.convertAndSend("directs","info","发送direct信息");
    }

    // topic
    @Test
    public void testTopic(){
        rabbitTemplate.convertAndSend("topictip","user.save","发送topic信息");
    }


}

消费者消费消息

hello模型

@RabbitListener(queuesToDeclare = @Queue("hello"))
public class Consumer {
    @RabbitHandler
    public void  receiver(String message){
        System.out.println(message);
    }
}

fanout模型

public class FanoutConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, // 创建临时队列
                    exchange = @Exchange(value = "logs",type = "fanout")// 指定交换机和类型
            )
    })
    public void receiver1(String message){
        System.out.println("consumer1===>"+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "logs",type = "fanout")
            )
    })
    public void receiver2(String message){
        System.out.println("consumer2===>"+message);
    }
}

topic模型

public class TopicConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, // 创建临时队列
                    exchange = @Exchange(name = "topictip",type = "topic"),  // 指定交换机和类型
                    key = {"*.save"}
            )
    })
    public void receiver1(String message){
        System.out.println("consumer1===>"+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, // 创建临时队列
                    exchange = @Exchange(name = "topictip",type = "topic"),  // 指定交换机和类型
                    key = {"user.*","user.save"}
            )
    })
    public void receiver2(String message){
        System.out.println("consumer2===>"+message);
    }
}

router模型

public class RouterConsumer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, // 创建临时队列
                    exchange = @Exchange(value = "directs",type = "direct"),  // 指定交换机和类型
                    key = {"info","error","warn"}
            )
    })
    public void receiver1(String message){
        System.out.println("consumer1===>"+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue, // 创建临时队列
                    exchange = @Exchange(value = "directs",type = "direct"),  // 指定交换机和类型
                    key = {"info"}
            )
    })
    public void receiver2(String message){
        System.out.println("consumer2===>"+message);
    }
}

具体Demo请参考github.com/huangrw/Rab…