【RabbitMQ】3. Spring Boot整合RabbitMQ

ricochet
1,067 阅读7分钟

应用场景

1. 异步处理

场景：用户注册完成后，需要发注册成功的邮件和短信，传统的做法有两种：

  • 串行的方式：将注册信息写入数据库后，发送注册成功的邮件，邮件发送成功后，再发送注册成功的短信。以上三个任务全部完成后才将注册成功的信息返回给客户端。

    存在的问题是：邮件和短信并不是必须的，它只是一个通知，串行的方式会让客户端等待没有必要等待的时间。

    20210830020120.png

  • 并行的方式：将注册信息写入数据库后，同时发送注册成功的邮件和短信。以上三个任务全部完成后才将注册成功的信息返回给客户端。并行的方式能相应的提高处理的时间。

    20210830020104.png

  • 消息队列（Publish/Subscribe）的方式：将注册信息写入数据库后直接将注册成功的信息返回给客户端。然后将发送注册成功的邮件的消息和发送注册成功的短信的消息发送到Exchange中，Exchange再将消息分发给两个队列，由两个队列异步地通知对应的消费者进行消费。

    20210830020049.png

2. 应用解耦

场景：双11是购物狂节，在用户下单时，订单系统需要通知库存系统，传统的做法就是订单系统调用库存系统的接口。

20210828013538.png

这种做法有一个缺点：当库存系统出现故障时，订单系统的调用就会失败，进而导致整个请求失败。订单系统和库存系统之间高耦合。

引入消息队列（"Hello World!"）后：

20210828013600.png

  • 订单系统：用户下单后，订单系统完成持久化处理，再将消息写入消息队列，返回用户订单下单成功。
  • 库存系统：消息队列将消息发送给库存系统，库存系统进行相应操作。就算库存系统出现故障，消息队列也能保证消息的可靠投递，不会导致消息丢失。

3. 流量削峰

场景：在秒杀活动中，如果用户直接访问应用，那么一般会因为流量过大，导致应用挂掉。为了解决这个问题，一般在应用前端加入消息队列。

加入消息队列（"Hello World!"）作用是：

  • 可以控制活动人数，如果订单信息的数量超过MQ规定的阈值，新的订单信息直接丢弃。
  • 可以缓解短时间的高流量压垮应用，系统只和MQ对接，因此系统只会依次消费MQ发送的一条条消息，不会出现多个请求同时访问系统的场景，最终导致系统崩溃。

20210828014309.png

具体实现流程为：

  1. 服务器收到用户请求之后，首先写入MQ。如果写入MQ中的消息数量超过预先设置的MQ最大值，则直接抛弃用户请求或跳转到错误页面。
  2. 秒杀系统根据消息队列发送的消息，进行依次的业务处理。

Spring Boot整合RabbitMQ

Spring Boot整合RabbitMQ操作起来非常方便，因为Spring Boot本身对RabbitMQ进行了进一步的封装，而Spring框架又天然支持RabbitMQ的AMQP协议，所以Spring Boot对RabbitMQ提供了非常友好的支持。

1. 基础环境搭建

  1. Spring Boot版本：2.2.5.RELEASE

  2. 在pom.xml中引入依赖

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

  3. 创建虚拟主机

    一个RabbitMQ Server中可以创建多个Virtual host，建议一个系统或者一个服务创建一个对应的Virtual host，Virtual host命名与系统相对应，类似于数据库中Database的概念（一个系统创建一个Database）。生产者和消费者如果要想通过RabbitMQ Server进行通信，必须绑定相同的Virtual host，然后再与该Virtual host进行连接才能够进行消息的生产和消费。

    20210825194319.png

    刚创建的Virtual host只能由guest访问，因为guest是来宾用户，有着最高权限，可以访问所有的Virtual host，包括根Virtual host（ / ）。

  4. 创建用户

    建议一个系统创建一个对应的User，User命名与系统相对应。

    之所以一个系统对应一个Virtual host，对应一个User，是为了让系统与系统之间相互独立，互不干扰。

    20210825195116.png

    注意：Exchange和Message Queue不需要在RabbitMQ控制台中手动创建，在程序中代码创建即可。

  5. 用户绑定虚拟主机

    刚创建的User的权限是No access，无法访问任何Virtual host。

    20210825195322.png

    点击表格中需要绑定的用户名

    20210825200126.png

  6. 配置application.yml

    spring:
  ...
  # RabbitMQ配置
  rabbitmq:
    # IP
    host: localhost
    # 端口
    port: 5672
    # 用户名
    username: postilhub
    # 密码
    password: 123456
    # 虚拟主机
    virtual-host: /postilhub

  7. 注入RabbitTemplate

    在与RabbitMQ Server建立连接后，Spring会自动实例化一个RabbitTemplate对象，使用时注入即可。

    @Autowired
private RabbitTemplate rabbitTemplate;

2. "Hello World!"模型

生产者开发

@Test
public void produce() {
    //  发送单条消息 第一个参数为队列名 第二个参数为消息内容
    rabbitTemplate.convertAndSend("queue", "Hello World!");
}

注意：上述代码中，生产者虽然指定了队列，但是如果该队列不存在，那么不会因为生产者指定了该队列该队列就创建。生产者是不能创建队列的，因为如果一个队列没有消费者消费消息，则没有任何存在的意义。所以只有在消费者存在，并对该队列进行监听时，如果该队列不存在，才会创建。

消费者开发

@Component
@RabbitListener(queuesToDeclare = @Queue(value = "queue", durable = "false", autoDelete = "true"))
public class Consumer {

    /**
     * @param message 参数message为消息的内容
     */
    @RabbitHandler
    public void consume(String message) {
        System.out.println(message);
    }
    
}

  • @RabbitListener：表示该类 / 方法是一个消费者，同时指定该消费者监听的队列，如果该队列不存在，则创建队列。同时还可以设置队列的特性durable，autoDelete，exclusive等，true表示开启，false表示关闭。在默认情况下创建的队列，durable为true，autoDelete和exclusive都为false。

  • @RabbitHandler：表示MQ发送给消费者时，消费者的回调方法。

3. Work queues模型

生产者开发

@Test
public void produce() {
    // 循环发布多条消息
    for (int i = 0; i < 10; i++) {
        rabbitTemplate.convertAndSend("queue", "Work Model" + i);
    }
}

消费者开发

@Component
public class Consumer {

    // 消费者1
    @RabbitListener(queuesToDeclare = @Queue("queue"))
    public void consume1(String message) {
        System.out.println("consumer1:" + message);
    }

    // 消费者2
    @RabbitListener(queuesToDeclare = @Queue("queue"))
    public void consume2(String message) {
        System.out.println("consumer2:" + message);
    }

}

注意：当在方法上使用了@RabbitListener时，就不需要再使用@RabbitHandler了。

4. Publish/Subscribe模型

生产者开发

@Test
public void produce() {
    // 第一个参数为交换机名 第二个参数为队列名（""表示队列随机名称，用来创建临时队列） 第三个参数为消息内容
    rabbitTemplate.convertAndSend("fanout", "", "Publish/Subscribe Model");
}

注意：上述代码中，生产者虽然指定了交换机，但是交换机也不能创建，原理和队列相同，交换机的创建也取决于消费者。

消费者开发

@Component
public class Consumer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    // 创建临时队列,并监听
                    value = @Queue,
                    // 临时队列绑定交换机 第一个参数为交换机名 第二个参数为交换机类型
                    exchange = @Exchange(value = "fanout", type = "fanout")
            )
    })
    public void consume1(String message) {
        System.out.println("consumer1:" + message);
    }

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

}

临时队列的队列名由RabbitMQ随机生成，将所有消息发送给消费者后自动删除。

5. Routing模型

生产者开发

@Test
public void produce() {
    // 第一个参数为交换机名 第二个参数为交换机RoutingKey 第三个参数为消息内容
    rabbitTemplate.convertAndSend("direct", "rabbit.info", "Routing Model");
}

消费者开发

@Component
public class Consumer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    // 创建临时队列,并监听
                    value = @Queue,
                    // 临时队列绑定交换机（交换机默认类型为direct，可以不用设置）
                    exchange = @Exchange(value = "direct", type = "direct"),
                    // 临时队列的RoutingKey 可以设置多个
                    key = {"rabbit.info", "rabbit.error"}
            )
    })
    public void consume1(String message) {
        System.out.println("consumer1:" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "direct"),
                    key = {"rabbit.info"}
            )
    })
    public void consume2(String message) {
        System.out.println("consumer2:" + message);
    }

}

6. Topics模型

1. 生产者开发

@Test
public void produce() {
    // 第一个参数为交换机名 第二个参数为交换机RoutingKey 第三个参数为消息内容
    rabbitTemplate.convertAndSend("topic", "rabbit.info", "Topic Model");
}

2. 消费者开发

@Component
public class Consumer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    // 创建临时队列,并监听
                    value = @Queue,
                    // 临时队列绑定交换机（name和value一样）
                    exchange = @Exchange(name = "topic", type = "topic"),
                    // 临时队列的RoutingKey 可以设置多个 可以使用通配符
                    key = {"rabbit.#", "rabbit.*"}
            )
    })
    public void consume1(String message) {
        System.out.println("consumer1:" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "topic", type = "topic"),
                    key = {"rabbit.*"}
            )
    })
    public void consume2(String message) {
        System.out.println("consumer2:" + message);
    }

}
avatar
文章
阅读
粉丝
相关推荐
RabbitmqMQ
366阅读
 · 
1点赞
RabbitMQ基础复习
3.4k阅读
 · 
36点赞
何时使用Kafka而不是RabbitMQ
21k阅读
 · 
118点赞
SpringBoot整合RabbitMq
1.1k阅读
 · 
1点赞
springboot整合rabbitmq实现延迟队列
1.1k阅读
 · 
10点赞