最新SpringCloudStream消息驱动讲解

目录

SpringCloud Stream消息驱动

1、SpringCloud Stream概述

1.1、设计思想1.2、标准的流程套路1.3、编码API和常用注解

2、消息驱动之生产者（output）

2.1、新建模块cloud-stream-rabbitmq-provider88012.2、引入pom.xml配置文件2.3、YAML配置文件2.4、生产者启动类2.5、业务实现2.6、启动测试

3、消息驱动之消费者（input）

3.1、新建cloud-stream-rabbitmq-consumer8802模块3.2、引入pom.xml依赖3.3、添加YAML配置文件3.4、添加启动类StreamMQMan88023.5、业务实现3.6、启动项目测试

4、分组消费与持久化

4.1、完整参考cloud-stream-rabbitmq-consumer8802，创建8803项目4.2、启动项目发现问题

SpringCloud Stream消息驱动


1、SpringCloud Stream概述

官方地址：https://spring.io/projects/spring-cloud-stream#overview
中文指导手册地址：https://m.wang1314.com/doc/webapp/topic/20971999.html

SpringCloud Stream 是一个构建消息驱动微服务的框架
应用程序通过 outputs 或 inputs 来与 SpringCloud Stream 中的 binder 对象交互
SpringCloud Stream 中的 binder 对象负责与消息中间件交互
通过 SpringCloud Stream 连接消息中间件，以实现消息事件驱动
什么是SpringCloudStream官方定义 Spring Cloud Stream 是一个构建消息驱动微服务的框架。
应用程序通过 inputs 或者 outputs 来与 Spring Cloud Stream中binder对象交互。通过我们配置binding(绑定) ，而 Spring Cloud Stream 的 binder对象负责与消息中间件交互。所以，我们只需要搞清楚如何与 Spring Cloud Stream 交互就可以方便使用消息驱动的方式。
通过使用Spring Integration来连接消息代理中间件以实现消息事件驱动。Spring Cloud Stream 为一些供应商的消息中间件产品提供了个性化的自动化配置实现，引用了发布-订阅、消费组、分区的三个核心概念。
目前仅支持RabbitMQ、Kafka。

1.1、设计思想

1、标注的MQ流程
生产者/消费者之间靠消息媒介传递信息内容【massage】
消息必须走特定的通道【消息通道MessageChannel】
消息通道里的消息如何被消费呢，谁负责收发处理

消息通道MessageChannel的子接口SubscribableChannel，由MessageHandler消息处理器所订阅

2、Cloud Stream的作用
比方说我们用到了RabbitMQ和Kafka，由于这两个消息中间件的架构上的不同，像RabbitMQ有exchange，kafka有Topic和Partitions分区。

这些中间件的差异性导致我们实际项目开发给我们造成了一定的困扰，我们如果用了两个消息队列的其中一种，后面的业务需求，我想往另外一种消息队列进行迁移，这时候无疑就是一个灾难性的，一大堆东西都要重新推倒重新做，因为它跟我们的系统耦合了，这时候springcloud Stream给我们提供了一种解耦合的方式。

3、什么是Binder
在没有绑定器这个概念的情况下，我们的SpringBoot应用要直接与消息中间件进行信息交互的时候，由于各消息中间件构建的初衷不同，它们的实现细节上会有较大的差异性通过定义绑定器作为中间层，完美地实现了应用程序与消息中间件细节之间的隔离。
通过向应用程序暴露统一的Channel通道，使得应用程序不需要再考虑各种不同的消息中间件实现。

Binder可以生成Binding，Binding用来绑定消息容器的生产者和消费者，它有两种类型，INPUT和OUTPUT，INPUT对应于消费者，OUTPUT对应于生产者。 4、Stream中的消息通信方式遵循了发布-订阅模式
使用Topic主题进行广播

在RabbitMQ就是Exchange在Kakfa中就是Topic

1.2、标准的流程套路

1、Binder：很方便的连接中间件，屏蔽不同的差异
2、Channel

通道，是队列Queue的一种抽象，在消息通讯系统中就是实现存储和转发的媒介，通过Channel对队列进行配置

3、Source和Sink

简单的可理解为参照对象是Spring Cloud Stream自身，从Stream发布消息就是输出，接受消息就是输入。

1.3、编码API和常用注解

组成和注解	描述
Middleware	中间件，目前只支持RabbitM和Kafka
Binder	Binder是应用与消息中间的封装，目前实现了Kafka和RabbitMQ的Binder，通过Binder可以很方便的连接中间件，可以动态的改变消息类型（对应Kafka的topic，RabbitMQ的exchange），这些都可以通过配置文件来实现
@Input	注解标识输入通道，通过该输入通道接收到的消息进入应用程序
@Output	注解标识输出通道，发布的消息将通过通道离开应用程序
@StreamListener	监听队列，用户消费者的队列的消息接收
@EnableBinding	指通道channel和exchange绑定在一起

2、消息驱动之生产者（output）


2.1、新建模块cloud-stream-rabbitmq-provider8801


2.2、引入pom.xml配置文件

如果是需要Stream整合的就将依赖改为spring-cloud-starter-stream-kafka

1. <dependencies>
2.     <!--stream整合rabbit依赖-->
3.     <dependency>
4.         <groupId>org.springframework.cloud</groupId>
5.         <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
6.     </dependency>
7.     <dependency>
8.         <groupId>org.springframework.cloud</groupId>
9.         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
10.     </dependency>
11.     <dependency>
12.         <groupId>org.springframework.boot</groupId>
13.         <artifactId>spring-boot-starter-web</artifactId>
14.     </dependency>
15.     <dependency>
16.         <groupId>org.springframework.boot</groupId>
17.         <artifactId>spring-boot-starter-actuator</artifactId>
18.     </dependency>
19.     <!--基础配置-->
20.     <dependency>
21.         <groupId>org.springframework.boot</groupId>
22.         <artifactId>spring-boot-devtools</artifactId>
23.         <scope>runtime</scope>
24.         <optional>true</optional>
25.     </dependency>
26.     <dependency>
27.         <groupId>org.projectlombok</groupId>
28.         <artifactId>lombok</artifactId>
29.         <optional>true</optional>
30.     </dependency>
31.     <dependency>
32.         <groupId>org.springframework.boot</groupId>
33.         <artifactId>spring-boot-starter-test</artifactId>
34.         <scope>test</scope>
35.     </dependency>
36. </dependencies>

复制代码

2.3、YAML配置文件

1. server:
2.   port: 8801
4. spring:
5.   application:
6.     name: cloud-stream-provider
7.   cloud:
8.     stream:
9.       binders: # 在此处配置要绑定的rabbitmq的服务信息；
10.         defaultRabbit: # 表示定义的名称，用于于binding整合
11.           type: rabbit # 消息组件类型
12.           environment: # 设置rabbitmq的相关的环境配置
13.             spring:
14.               rabbitmq:
15.                 host: localhost
16.                 port: 5672
17.                 username: guest
18.                 password: guest
19.       bindings: # 服务的整合处理
20.         output: # 这个名字是一个通道的名称，消息生产者
21.           destination: studyExchange # 表示要使用的Exchange名称定义【自定义】
22.           content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
23.           binder: defaultRabbit # 设置要绑定的消息服务的具体设置【上面的配置】
25. eureka:
26.   client: # 客户端进行Eureka注册的配置
27.     service-url:
28.       defaultZone: http://localhost:7001/eureka

复制代码

2.4、生产者启动类

1. package com.zcl.springcloud;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. /**
7. * 描述：消息生产者启动类
8. *
9. * @author zhong
10. * @date 2022-09-22 12:19
11. */
12. @SpringBootApplication
13. public class StreamMQMain8801 {
14.     public static void main(String[] args) {
15.         SpringApplication.run(StreamMQMain8801.class, args);
16.     }
17. }

复制代码

2.5、业务实现

2.5.1、服务接口实现类

自己创建一个实现的接口以及里面的方法
注意：在这个服务实现类里面不是使用@Service注解了，因为不是web应用，而是Stream消息驱动，是与中间件进行打交道的不是与数据库

1. package com.zcl.springcloud.service.Impl;
3. import com.zcl.springcloud.service.IMessageProvider;
4. import lombok.extern.slf4j.Slf4j;
5. import org.springframework.cloud.stream.annotation.EnableBinding;
6. import org.springframework.cloud.stream.messaging.Source;
7. import org.springframework.messaging.MessageChannel;
8. import org.springframework.messaging.support.MessageBuilder;
10. import javax.annotation.Resource;
11. import java.util.UUID;
13. /**
14. * 描述：发送接口实现类
15. * 必须使用@EnableBinding(Source.class)注解开启消息推送管道
16. *
17. * @author zhong
18. * @date 2022-09-22 12:24
19. */
20. @Slf4j
21. @EnableBinding(Source.class)
22. public class IMessageProviderImpl implements IMessageProvider {
24.     /**
25.      * 消息发送管道
26.      */
27.     @Resource
28.     private MessageChannel output;
30.     /**
31.      * 发送消息
32.      * @return
33.      */
34.     @Override
35.     public String send() {
36.         // 定义消息
37.         String serial = UUID.randomUUID().toString();
38.         // 构建并发送消息
39.         this.output.send(MessageBuilder.withPayload(serial).build());
40.         log.info("-------------- " + serial + " ----------------");
41.         return serial;
42.     }
43. }

复制代码

2.5.2、控制器实现

1. package com.zcl.springcloud.controller;
3. import com.zcl.springcloud.service.IMessageProvider;
4. import org.springframework.web.bind.annotation.GetMapping;
5. import org.springframework.web.bind.annotation.RestController;
7. import javax.annotation.Resource;
9. /**
10. * 描述：消息发送控制器
11. *
12. * @author zhong
13. * @date 2022-09-22 12:37
14. */
15. @RestController
16. public class SendMessageController {
18.     /**
19.      * 注入消息发送管道接口
20.      */
21.     @Resource
22.     private IMessageProvider messageProvider;
24.     /**
25.      * 每调用一次接口发送一次消息
26.      * @return
27.      */
28.     @GetMapping(value = "/sendMessage")
29.     public String sendMessage()
30.     {
31.         return messageProvider.send();
32.     }
33. }

复制代码

2.6、启动测试

启动7001Eureka访问中心启动8801消息发送者，启动成功以及观察RabbitMQ的管理界面

3.访问接口发送消息，查看MQ的管理页面波峰情况

3、消息驱动之消费者（input）

同样的参考如下流程图

3.1、新建cloud-stream-rabbitmq-consumer8802模块


3.2、引入pom.xml依赖

与8801一样

3.3、添加YAML配置文件

配置文件与消息生产的区别在于：

1. output: # 这个名字是一个通道的名称
2.         destination: studyExchange # 表示要使用的Exchange名称定义

复制代码

1. server:
2.   port: 8802
4. spring:
5.   application:
6.     name: cloud-stream-consumer
7.   cloud:
8.     stream:
9.       binders: # 在此处配置要绑定的rabbitmq的服务信息；
10.         defaultRabbit: # 表示定义的名称，用于于binding整合
11.           type: rabbit # 消息组件类型
12.           environment: # 设置rabbitmq的相关的环境配置
13.             spring:
14.               rabbitmq:
15.                 host: localhost
16.                 port: 5672
17.                 username: guest
18.                 password: guest
19.       bindings: # 服务的整合处理
20.         input: # 这个名字是一个通道的名称
21.           destination: studyExchange # 表示要使用的Exchange名称定义
22.           content-type: application/json # 设置消息类型，本次为对象json，如果是文本则设置“text/plain”
23.           binder: defaultRabbit # 设置要绑定的消息服务的具体设置
25. eureka:
26.   client: # 客户端进行Eureka注册的配置
27.     service-url:
28.       defaultZone: http://localhost:7001/eureka

复制代码

3.4、添加启动类StreamMQMain8802

与消息生产者一样

3.5、业务实现

必须要有@Component注解注入到Spring容器中

1. package com.zcl.springcloud.controller;
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.beans.factory.annotation.Value;
5. import org.springframework.cloud.stream.annotation.EnableBinding;
6. import org.springframework.cloud.stream.annotation.StreamListener;
7. import org.springframework.cloud.stream.messaging.Sink;
8. import org.springframework.messaging.Message;
9. import org.springframework.stereotype.Component;
11. /**
12. * 描述：消息消费者控制器
13. *
14. * @author zhong
15. * @date 2022-09-22 13:18
16. */
17. @Slf4j
18. @Component
19. @EnableBinding(Sink.class)
20. public class ReceiveMessageListener {
22.     /**
23.      * 注入消费者的端口号
24.      */
25.     @Value("${server.port}")
26.     private String port;
28.     /**
29.      * 监听消息
30.      * @param message
31.      * @return
32.      */
33.     @StreamListener(Sink.INPUT)
34.     public void input(Message<String> message){
35.         log.info("消费者1号接收到的消息 ----- " + message.getPayload() + " -----，port： " + port);
36.     }
37. }

复制代码

3.6、启动项目测试

启动7001启动8801，消息发送者启动8802，消息消费者8801发送消息，8802消费消息，并查看具体的MQ波峰图

控制器输出

4、分组消费与持久化


4.1、完整参考cloud-stream-rabbitmq-consumer8802，创建8803项目

除了启动的端口号不一样之外其他的配置都一样

4.2、启动项目发现问题

启动7001（Eureka服务中心）启动8801（生产）、8802（消费）、8803（消费）测试发送消失是否两个消费者都可以接收到

4.2.1、重复消费

目前是8802/8803同时都收到了，存在重复消费问题
解决方案：分组和持久化属性group

常见案例
比如在如下场景中，订单系统我们做集群部署，都会从RabbitMQ中获取订单信息，那如果一个订单同时被两个服务获取到，那么就会造成数据错误，我们得避免这种情况。这时我们就可以使用Stream中的消息分组来解决

注意在Stream中处于同一个group中的多个消费者是竞争关系，就能够保证消息只会被其中一个应用消费一次。
不同组是可以全面消费的(重复消费)，同一组内会发生竞争关系，只有其中一个可以消费。
4.2.2、分组

自定义配置分组，自定义分为同一个组，解决重复消费问题

配置文件分组

分别给8801、8802进行分组【orderA】

重启项目查看MQ管理

orderB是历史记录，上面的配置以及都分为了ordeerA组，进入orderA组可以查看实际的消费者数量
同一组内会发生竞争关系，只有其中一个可以消费，启动项目测试是否为真

4.2.3、持久化

通过上述，解决了重复消费问题，再看看持久化

停止8802/8803并去除掉8802的分组group: atguiguA,8803保留
8801先发送7条消息到rabbitmq

3.先启动8802，无分组属性配置，后台没有打出来消息

8802因为取消了groupA的分组所以获取不到持久化的数据（如果重启mq也会消失）

4.再启动8803，有分组属性配置，后台打出来了MQ上的消息

8803保存groupA的分组所以在启动的时候就会将持久化的数据消费

到此这篇关于SpringCloud Stream消息驱动的文章就介绍到这了,更多相关SpringCloud Stream消息驱动内容请搜索中国红客联盟以前的文章或继续浏览下面的相关文章希望大家以后多多支持中国红客联盟！