SpringCloud:RabbitMQ兔子消息队列

发布时间:2024年01月14日

RabbitMQ

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

同步通讯与异步通讯

同步通讯

同步调用的优点:

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

调用的问题:

  • 耦合度高:

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

  • 性能和吞吐能力下降:

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

  • 有额外的资源消耗:

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

  • 有级联失败问题:

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

请添加图片描述

异步通讯

异步通信的优点:

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

异步通信的缺点:

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

请添加图片描述

快速入门

请添加图片描述

安装

  1. 下载镜像
docker pull rabbitmq:3-management
  1. 安装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

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. 消息发布者发布消息
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. 消息接收者接收消息
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("等待接收消息。。。。");
    }
}

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. 添加配置
spring:
  rabbitmq:
    host: 192.168.88.130 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码
  1. 消息发送者发送消息
@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. 消息接收者接收消息
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 + "】");
    }
}

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. 接收消息
@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条:

请添加图片描述

  1. 能者多劳
spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息,处理完成才能获取下一个消息
  1. 总结

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. 发送消息
@Test
public void test03(){
    String exchange = "myExchange";
    String msg = "你好";
    rabbitTemplate.convertAndSend(exchange,"",msg);
}

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. 发布消息
@Test
public void test04(){
    String exchange = "myExchange1";
    String msg = "你好";
    String key = "blue";
    rabbitTemplate.convertAndSend(exchange,key,msg);
}

Topic

Topic类型的ExchangeDirect相比,都是可以根据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. 发布消息
@Test
public void test05(){
    String exchange = "myExchange2";
    String msg = "你好Topic";
    String key = "china.n";
    rabbitTemplate.convertAndSend(exchange,key,msg);
}

消息转换器

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. 在启动类中添加转换器
@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}
文章来源:https://blog.csdn.net/weixin_74144099/article/details/135489488
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。