SpringCloud：RabbitMQ兔子消息队列

文章目录

RabbitMQ

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

同步通讯与异步通讯

同步通讯

同步调用的优点：

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

调用的问题：

• 耦合度高：每次加入新的需求，都要修改原来的代码
• 性能和吞吐能力下降：调用者需要等待服务提供者响应，如果调用链过长则响应时间等于每次调用的时间之和。
• 有额外的资源消耗：调用链中的每个服务在等待响应过程中，不能释放请求占用的资源，高并发场景下会极度浪费系统资源
• 有级联失败问题：如果服务提供者出现问题，所有调用方都会跟着出问题，如同多米诺骨牌一样，迅速导致整个微服务群故障

异步通讯

异步通信的优点：

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

异步通信的缺点：

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

快速入门

安装

1. 下载镜像

docker pull rabbitmq:3-management

1. 安装MQ

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

docker run \-eRABBITMQ_DEFAULT_USER=itcast \-eRABBITMQ_DEFAULT_PASS=123321\--name mq \--hostname mq1 \-p15672:15672 \-p5672: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. 消息接收者接收消息

packagecom.lhs;importcom.rabbitmq.client.*;importjava.io.IOException;importjava.util.concurrent.TimeoutException;publicclassConsumerTest{publicstaticvoidmain(String[] args)throwsIOException,TimeoutException{// 1.建立连接ConnectionFactory factory =newConnectionFactory();// 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.创建通道ChannelChannel channel = connection.createChannel();// 3.创建队列String queueName ="simple.queue";
        channel.queueDeclare(queueName,false,false,false,null);// 4.订阅消息
        channel.basicConsume(queueName,true,newDefaultConsumer(channel){@OverridepublicvoidhandleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] body)throwsIOException{// 5.处理消息String message =newString(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. 消息发送者发送消息

@SpringBootTestpublicclassSpringamqpTest{@AutowiredprivateRabbitTemplate rabbitTemplate;@Testpublicvoidtest01(){String queueName ="simple.queue";String msg ="hello world123 !";
        rabbitTemplate.convertAndSend(queueName, msg);System.out.println("发送消息完成！");}}

1. 消息接收者接收消息

packagecom.lhs.listener;importorg.springframework.amqp.rabbit.annotation.RabbitListener;importorg.springframework.stereotype.Component;@ComponentpublicclassSpringRabbitListener{@RabbitListener(queues ="simple.queue")publicvoidlistenSimpleQueueMessage(String msg)throwsInterruptedException{System.out.println("spring 消费者接收到消息：【"+ msg +"】");}}

WorkQueue

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

1. 发送50条消息

@Testpublicvoidtest02(){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")publicvoidlistenWorkQueue1(String msg)throwsInterruptedException{System.out.println("消费者1接收到消息：【"+ msg +"】"+LocalTime.now());Thread.sleep(20);}@RabbitListener(queues ="simple.queue")publicvoidlistenWorkQueue2(String msg)throwsInterruptedException{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)))publicvoidlistenFanoutExchangeMessage1(String msg)throwsInterruptedException{System.out.println("消费者3........接收到消息：【"+ msg +"】"+LocalTime.now());}@RabbitListener(bindings =@QueueBinding(
        value =@Queue(name ="lhs.queue"),
        exchange =@Exchange(name ="myExchange",type =ExchangeTypes.FANOUT)))publicvoidlistenFanoutExchangeMessage2(String msg)throwsInterruptedException{System.out.println("消费者4........接收到消息：【"+ msg +"】"+LocalTime.now());}

1. 发送消息

@Testpublicvoidtest03(){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"}))publicvoidlistenDirectExchangeMessage3(String msg)throwsInterruptedException{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"}))publicvoidlistenDirectExchangeMessage4(String msg)throwsInterruptedException{System.out.println("消费者6........接收到消息：【"+ msg +"】"+LocalTime.now());}

1. 发布消息

@Testpublicvoidtest04(){String exchange ="myExchange1";String msg ="你好";String key ="blue";
    rabbitTemplate.convertAndSend(exchange,key,msg);}

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.#"))publicvoidlistenTopicExchangeMessage1(String msg)throwsInterruptedException{System.out.println("消费者7........接收到消息：【"+ msg +"】"+LocalTime.now());}@RabbitListener(bindings =@QueueBinding(
        value =@Queue(name ="lhs2.queue2"),
        exchange =@Exchange(name ="myExchange2",type =ExchangeTypes.TOPIC),
        key ="#.news"))publicvoidlistenTopicExchangeMessage2(String msg)throwsInterruptedException{System.out.println("消费者8........接收到消息：【"+ msg +"】"+LocalTime.now());}

1. 发布消息

@Testpublicvoidtest05(){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. 在启动类中添加转换器

@BeanpublicMessageConverterjsonMessageConverter(){returnnewJackson2JsonMessageConverter();}