MQ

同步和异步通讯

同步通讯

之前学习的Feign调用就属于同步方式，虽然调用可以实时得到结果，但存在下面的问题：

同步调用也不是没有优点：时效性较强，可以立即得到结果。

异步通讯

异步调用的常见实现是事件驱动模式。

为了解除事件发布者与订阅者之间的耦合，两者并不是直接通信，而是有一个中间人（Broker）。发布者发布事件到Broker，不关心谁来订阅事件。订阅者从Broker订阅事件，不关心谁发来的消息。

好处：

• 吞吐量提升：无需等待订阅者处理完成，响应更快速。
• 故障隔离：服务没有直接调用，不存在级联失败问题。
• 调用间没有阻塞，不会造成无效的资源占用。
• 耦合度极低，每个服务都可以灵活插拔，可替换。
• 流量削峰：不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件。

缺点：

• 架构复杂了，业务没有明显的流程线，不好管理。
• 需要依赖于Broker的可靠、安全、性能。

MQ技术对比

MQ，中文是消息队列（MessageQueue），字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

几种常见MQ的对比：

	RabbitMQ	ActiveMQ	RocketMQ	Kafka
公司/社区	Rabbit	Apache	阿里	Apache
开发语言	Erlang	Java	Java	Scala&Java
协议支持	AMQP，XMPP，SMTP，STOMP	OpenWire,STOMP，REST，XMPP，AMQP	自定义协议	自定义协议
可用性	高	一般	高	高
单机吞吐量	一般	差	高	非常高
消息延迟	微秒级	毫秒级	毫秒级	毫秒以内
消息可靠性	高	一般	高	一般

RabbitMQ

基本结构

RabbitMQ中的一些角色：

• channel：操作MQ的工具

• publisher：生产者
• consumer：消费者
• exchange：交换机，负责消息路由
• queue：队列，存储消息
• virtualHost：虚拟主机，隔离不同User的exchange、queue、消息

常见消息模型

RabbitMQ官方提供了多个消息模型，5个常用的消息模型如下：

• 基本消息队列（BasicQueue）

• 工作消息队列（WorkQueue）

  

  只有三个角色，使用的是默认交换机。

• 发布订阅（Publish、Subscribe）,根据交换机类型的不同分为三种：

  • Fanout Exchange：广播

  • Direct Exchange：路由

  • Topic Exchange：主题

    

BasicQueue入门

BasicQueue的模型图：

消息发送流程：

1. 建立connection
2. 创建channel
3. 利用channel声明队列
4. 利用channel向队列发送消息

基本消息队列的消息接收流程：

1. 建立connection

2. 创建channel

3. 利用channel声明队列

4. 定义consumer的消费行为handleDelivery()（回调函数）

   回调函数指的是A把自己的方法传给B，让B在合适的时机（同步或异步）来调用，在Java中用接口来实现回调函数。

5. 利用channel将消费者与队列绑定

SpringAMQP

AMQP：规范网络交换的数据格式，与语言无关，具有跨平台性。

SpringAMQP是基于RabbitMQ封装的一套模板，spring-rabbit是底层的默认实现，并且还利用SpringBoot对其实现了自动装配，使用起来十分方便。

SpringAMQP提供了三个功能：

• 自动声明队列、交换机及其绑定关系。
• 基于注解的监听器模式，异步接收消息。
• 封装了RabbitTemplate工具，用于发送消息。

BasicQueue入门

消息发送：

1. 引入spring-boot-starter-amqp的依赖，spring-rabbit是底层的默认实现。

2. 配置文件替代原本繁琐的代码：

    spring:
      rabbitmq:
        host: 192.168.20.100
        port: 5672 #端口
        username: root
        password: 123456
        virtual-host: /  #虚拟主机
   

3. 消息发送：

    @Resource
    private RabbitTemplate rabbitTemplate;
    @Test
    public void testSendMessage2SimpleQueue() {
        String queueName = "simple.queue";
        String message = "hello, spring amqp!";
        rabbitTemplate.convertAndSend(queueName, message);
    }
   

---

消息接收：

1. 引入spring-boot-starter-amqp的依赖。

2. 配置。

3. 在消费者中新建一个类：

    @Component
    public class SpringRabbitListener {
        @RabbitListener(queues = "simple.queue") //监听哪个队列
        public void listenSimpleQueueMessage(String msg) throws InterruptedException {
            System.out.println("spring 消费者接收到消息：" + msg );
        }
    }
   

消息一旦消费就会从队列删除，RabbitMQ没有消息回溯功能。

WorkQueue入门

Work queues，也被称为（Task queues），任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息，同一条消息只会被一个消费者处理。

1. 循环发送，模拟大量消息堆积现象:

    @Test
    public void testWorkQueue() throws InterruptedException {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, message_";
        for (int i = 0; i < 50; i++) {
            // 发送消息
            rabbitTemplate.convertAndSend(queueName, message + i);
            Thread.sleep(20);
        }
    }
   

2. 消息接收：

    @RabbitListener(queues = "simple.queue")
    public void listenWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
        Thread.sleep(20); //模拟快的消费者
    }
    ​
    @RabbitListener(queues = "simple.queue")
    public void listenWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
        Thread.sleep(200); //模拟慢的消费者
    }
   

测试发现消费者1很快完成了自己的25条消息。消费者2却在缓慢的处理自己的25条消息，也就是说消息是平均分配给每个消费者，并没有考虑到消费者的处理能力，解决：

 spring:
   rabbitmq:
     listener:
       simple:
         prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

设置prefetch控制消费者预取的消费数量。

发布 / 订阅

发布订阅模式和之前两个案例的区别是允许将同一消息发送给多个消费者，实现方式是加入了exchange（交换机）。

发布订阅的模型如图：

常见Exchange类型包括：

• Fanout：广播
• Direct：路由
• Topic：话题

Exchange只负责转发消息，不具备存储消息的能力。

Fanout

Fanout Exchange 会将接收到的消息路由到每一个跟其绑定的queue。

在广播模式下，消息发送流程是这样的：

• 可以有多个队列

• 每个队列都要绑定到Exchange
• 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
• 交换机把消息发送给绑定过的所有队列
• 订阅队列的消费者都能拿到消息

---

案例：

• 创建一个交换机 itcast.fanout，类型是Fanout
• 创建两个队列fanout.queue1和fanout.queue2，绑定到交换机itcast.fanout

1. 声明队列和交换机，并把他们进行绑定：

    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }
    ​
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }
    ​
    //绑定队列1到交换机
    @Bean
    public Binding fanoutBinding1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }
    //绑定队列2到交换机
    @Bean
    public Binding fanoutBinding2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
   

2. 消费者监听：

    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1(String msg) {
        log.error("----------------------接收到fanout.queue1" + msg);
    }
    ​
    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutQueue2(String msg) {
        log.error("----------------------接收到fanout.queue2" + msg);
    }
   

3. 发送消息：

    @Test
    public void testSendFanoutExchange() {
        //交换机名称
        String exchange = "itcast.fanout";
        //消息名称
        String message = "hello ,every one";
        //发送消息到交换机
        rabbitTemplate.convertAndSend(exchange,"", message);
    }
   

从而实现两个队列都接收到消息。

Direct

Direct Exchange会将接收到的消息根据规则路由到指定的Queue，因此称为路由模式（routes）。

在Direct模型下：

• 声明队列与交换机的绑定时，需要指定一个BindingKey
• 发布者发送消息时，也必须定消息的 RoutingKey
• Exchange将消息路由到RoutingKey和BindingKey一致的队列

可以模拟Fanout，更加灵活。

---

demo：

1. 用@RabbitListener声明Exchange、Queue、RoutingKey（无需额外声明Bean）,在两个消费者方法中分别监听direct.queue1和direct.queue2

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),
            exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT), //默认DIRECT
            key = {"red", "blue"} //bindingkey
    ))
    public void listenDirectQueue1(String msg){
        log.error("----------------------接收到direct.queue1" + msg);
    }
    ​
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
            key = {"red", "yellow"}
    ))
    public void listenDirectQueue2(String msg){
        log.error("----------------------接收到direct.queue2" + msg);
    }
   

2. 发送消息

    @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchange = "itcast.direct";
        //消息名称
        String message = "hello red";
        //发送消息
        rabbitTemplate.convertAndSend(exchange,"red", message); //第二个参数即RoutingKey
    }
   

Topic

与Direct Exchange类似，区别在于routingKey必须是多个单词的组合，并且用 . 分割。

指定bindingKey时可以使用通配符：

• #：代表0个或多个单词.
• *：代表一个单词。

demo：

1. 用@RabbitListener声明Exchange、Queue、RoutingKey（不用额外声明bean）,在两个消费者方法中分别监听topic.queue1和topic.queue2

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
            key = {"china.#"}
    ))
    public void listenTopicQueue1(String msg){
        log.error("----------------------接收到topic.queue1" + msg);
    }
    ​
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
            key = {"#.news"}
    ))
    public void listenTopicQueue2(String msg){
        log.error("----------------------接收到topic.queue2" + msg);
    }
   

2. 发送消息

    @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchange = "itcast.topic";
        //消息名称
        String message = "======";
        //发送消息
        rabbitTemplate.convertAndSend(exchange,"china.weather", message); //只有队列1能收到
    }
   

消息转换器

默认转换器

Spring的对消息对象的处理是由org.springframework.amqp.support.converter.MessageConverter来处理的。而默认实现是SimpleMessageConverter，基于JDK的ObjectOutputStream完成序列化。

JDK序列化缺点：体积大、可读性差、不安全。

配置JSON转换器

1. 引入jackson-dataformat-xml的依赖。

2. 配置类中添加Bean：

    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
   

发送方和接收方必须使用相同的MessageConverter。