SpringCloud：RabbitMQ兔子消息队列_springcloud rabbit

RabbitMQ

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

同步通讯与异步通讯

同步通讯

同步调用的优点：

• 时效性较强，可以立即得到结果同步

调用的问题：

• 耦合度高：

  每次加入新的需求，都要修改原来的代码

• 性能和吞吐能力下降：

  调用者需要等待服务提供者响应，如果调用链过长则响应时间等于每次调用的时间之和。

• 有额外的资源消耗：

  调用链中的每个服务在等待响应过程中，不能释放请求占用的资源，高并发场景下会极度浪费系统资源

• 有级联失败问题：

  如果服务提供者出现问题，所有调用方都会跟着出问题，如同多米诺骨牌一样，迅速导致整个微服务群故障

异步通讯

异步通信的优点：

• 耦合度低
• 吞吐量提升
• 故障隔离
• 流量削峰

异步通信的缺点：

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

快速入门

安装

1. 下载镜像

docker pull rabbitmq:3-management
1

2. 安装MQ

执行下面的命令来运行MQ容器：

docker run \
 -e RABBITMQ_DEFAULT_USER=itcast \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 --name mq \
 --hostname mq1 \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3-management
1
2
3
4
5
6
7
8
9

RabbitMQ概述

RabbitMQ中的几个概念：

• channel：操作MQ的工具
• exchange：路由消息到队列中
• queue：缓存消息
• virtual host：虚拟主机，是对queue、exchange等资源的逻辑分组

常见的消息模型：

• 基本消息队列（BasicQueue）
• 工作消息队列（WorkQueue）

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

• Fanout Exchange：广播
• Direct Exchange：路由
• Topic Exchange：主题

基本消息队列的消息发送流程：

• 建立connection
• 创建channel
• 利用channel声明队列
• 利用channel向队列发送消息

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

• 建立connection
• 创建channel
• 利用channel声明队列
• 定义consumer的消费行为handleDelivery()
• 利用channel将消费者与队列绑定

HelloWorld案例

1. 导入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<!--单元测试-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10

2. 消息发布者发布消息

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.jupiter.api.Test;


import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.88.130");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

3. 消息接收者接收消息

package com.lhs;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.88.130");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

SpringAMQP

SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。

SpringAMQP提供了三个功能：

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

Basic Queue 简单队列模型

1. 导入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
1
2
3
4
5

2. 添加配置

spring:
  rabbitmq:
    host: 192.168.88.130 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码
1
2
3
4
5
6
7

3. 消息发送者发送消息

@SpringBootTest
public class SpringamqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test01(){
        String queueName = "simple.queue";
        String msg = "hello world123 !";
        rabbitTemplate.convertAndSend(queueName, msg);
        System.out.println("发送消息完成！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4. 消息接收者接收消息

package com.lhs.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class SpringRabbitListener {
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

WorkQueue

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

1. 发送50条消息

@Test
public void test02(){
    String queueName = "simple.queue";
    String msg = "hello world!";
    for (int i = 1; i <= 50; i++) {
        rabbitTemplate.convertAndSend(queueName, msg + i);
    }

    System.out.println("发送消息完成！");
}
1
2
3
4
5
6
7
8
9
10

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
2
3
4
5
6
7
8
9
10
11

3. 测试结果

两个消费者各处理25条：

4. 能者多劳

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

5. 总结

Work模型的使用：

• 多个消费者绑定到一个队列，同一条消息只会被一个消费者处理
• 通过设置prefetch来控制消费者预取的消息数量

发布/订阅

可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化：

• Publisher：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
• Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有以下3种类型：
  • Fanout：广播，将消息交给所有绑定到交换机的队列
  • Direct：定向，把消息交给符合指定routing key 的队列
  • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列
• Consumer：消费者，与以前一样，订阅队列，没有变化
• Queue：消息队列也与以前一样，接收消息、缓存消息。

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

Fanout

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

• 1） 可以有多个队列
• 2） 每个队列都要绑定到Exchange（交换机）
• 3） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
• 4） 交换机把消息发送给绑定过的所有队列
• 5） 订阅队列的消费者都能拿到消息

1. .基于注解声明队列和交换机

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "lhs.queue"),
        exchange = @Exchange(name = "myExchange",type = ExchangeTypes.FANOUT)
))
public void listenFanoutExchangeMessage1(String msg) throws InterruptedException {
    System.out.println("消费者3........接收到消息：【" + msg + "】" + LocalTime.now());
}
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "lhs.queue"),
        exchange = @Exchange(name = "myExchange",type = ExchangeTypes.FANOUT)
))
public void listenFanoutExchangeMessage2(String msg) throws InterruptedException {
    System.out.println("消费者4........接收到消息：【" + msg + "】" + LocalTime.now());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 发送消息

@Test
public void test03(){
    String exchange = "myExchange";
    String msg = "你好";
    rabbitTemplate.convertAndSend(exchange,"",msg);
}
1
2
3
4
5
6

Direct

在Direct模型下：

• 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
• 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
• Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

1. 基于注解声明队列和交换机

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "lhs1.queue1"),
        exchange = @Exchange(name = "myExchange1",type = ExchangeTypes.DIRECT),
        key = {"red","yellow"}
))
public void listenDirectExchangeMessage3(String msg) throws InterruptedException {
    System.out.println("消费者5........接收到消息：【" + msg + "】" + LocalTime.now());
}

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "lhs1.queue2"),
        exchange = @Exchange(name = "myExchange1",type = ExchangeTypes.DIRECT),
        key = {"red","blue"}
))
public void listenDirectExchangeMessage4(String msg) throws InterruptedException {
    System.out.println("消费者6........接收到消息：【" + msg + "】" + LocalTime.now());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. 发布消息

@Test
public void test04(){
    String exchange = "myExchange1";
    String msg = "你好";
    String key = "blue";
    rabbitTemplate.convertAndSend(exchange,key,msg);
}
1
2
3
4
5
6
7

Topic

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

1. 基于注解声明队列和交换机

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "lhs2.queue1"),
        exchange = @Exchange(name = "myExchange2",type = ExchangeTypes.TOPIC),
        key = "china.#"
))
public void listenTopicExchangeMessage1(String msg) throws InterruptedException {
    System.out.println("消费者7........接收到消息：【" + msg + "】" + LocalTime.now());
}

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "lhs2.queue2"),
        exchange = @Exchange(name = "myExchange2",type = ExchangeTypes.TOPIC),
        key = "#.news"
))
public void listenTopicExchangeMessage2(String msg) throws InterruptedException {
    System.out.println("消费者8........接收到消息：【" + msg + "】" + LocalTime.now());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. 发布消息

@Test
public void test05(){
    String exchange = "myExchange2";
    String msg = "你好Topic";
    String key = "china.n";
    rabbitTemplate.convertAndSend(exchange,key,msg);
}
1
2
3
4
5
6
7

消息转换器

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

众所周知，JDK序列化存在下列问题：

• 数据体积过大
• 有安全漏洞
• 可读性差

1. 配置json转换器

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>
1
2
3
4
5

2. 在启动类中添加转换器

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}
1
2
3
4