文章

玩转SpringCloud Stream

背景及痛点

现如今消息中间件(MQ)在互联网项目中被广泛的应用，特别是大数据行业应用的特别的多，现在市面上也流行这多个消息中间件框架，比如ActiveMQ、RabbitMQ、RocketMQ、Kafka等，这些消息中间件各有各的优劣，但是想要解决的问题都基本相同。由于每个框架都有它自己的使用方式，这无疑是增加了开发者的学习成本以及添加相同的业务复杂度。框架的变更或者多个中间件的混合使用使得业务逻辑代码中中间件的切换、项目的维护和开发都会变得更加繁琐。

有没有一种技术让我们不再需要关注具体MQ的使用细节，我们只需要专注业务逻辑的开发，让程序根据实际项目的使用自己去适配绑定，自动在各种MQ内切换呢？springcloud stream便为此而生。

关于stream

我们用一句话来描述stream就是:屏蔽底层消息中间件的差异，降低切换版本，统一消息的编程模型

官方定义SpringCloud Stream是一个构建消息驱动微服务的框架，应用通过inputs或者outputs来与SpringCloud Stream中的binder对象交互，我们通过配置来绑定消息中间件，而SpringCloud Stream的binder对象负责与消息中间件交互，所以我们只需要搞清楚如何与SpringCloud Stream交互即可方便的使用消息中间件。

SpringCloud Stream通过Spring Integration来连接消息代理中间件以实现消息事件驱动，它提供了个性化的自动化配置，引用了发布订阅、消费组、分区的三个核心概念，但是目前仅支持RabbitMQ和Kafka

设计思想
在此之前

以前的架构

生产者和消费者通过消息媒介(queue等)传递信息内容(Message)，消息必须通过特定的通道（MessageChannel），通过消息的发布与订阅来决定消息的发送和消费（publish/subscrib）。

引入中间件

现在假如我们用到了RabbitMQ和Kafka，由于这两个消息中间件的架构上的不同，像RabbitMQ有Exchange，而Kafka有topiche和Partitions分区

引入中间件之后

（binder中，input对于消费者，output对应生产者。）

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

屏蔽底层差异

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

通过定义绑定器Binder作为中间层，实现了应用程序与消息中间件细节之间的隔离。

处理架构

Stream对消息中间件的进一步封装可以做到代码层面对中间件的无感知，甚至于动态的切换中间件(rabbitmq切换为kafka),使得微服务开发的高度解耦，服务可以关注更多自己的业务流程。

处理架构

其遵循了发布-订阅模式，主要使用的就是Topic主题进行广播，RabbitMQ就是Exchange，在Kafka中就是Topic

通过定义绑定器Binder作为中间层，实现了应用程序与消息中间件细节之间的隔离。

stream流程

stream流程

  • Binder：很方便的连接中间件，屏蔽差异
  • Channel：通道是队列Queue的一种抽象，在消息通讯系统中就是实现存储和转发的媒介，通过对Channel对队列进行配置
  • Source和Sink：简单的可理解为参照对象是Spring Cloud Stream自身，从Stream发布消息就是输出，接受消息就是输入

常用api和注解

常用api和注解

使用示例
基本环境

  • 注册中心：Eureka，可以是其他。

  • 消息中间件：RabbitMQ

    1. rabbitmq:
    2.   host: localhost
    3.   port: 5672
    4.   username: guest
    5.   password: guest

生产端
依赖 

  1.  
  3.   org.springframework.cloud
  4.   spring-cloud-starter-stream-rabbit
  8.   org.springframework.cloud
  9.   spring-cloud-starter-netflix-eureka-client
  12.   org.springframework.boot
  13.   spring-boot-starter-web
  16.   org.springframework.boot
  17.   spring-boot-starter-actuator

配置文件 

  1. server:
  2.   port: 8801
  4. spring:
  5.   application:
  6.     name: cloud-stream-provider
  7.   cloud:
  8.     # stream 配置
  9.     stream:
  10.       binders: # 配置绑定的消息中间件的服务信息
  11.         defaultRabbit: # 自定义的一个名称，用来下面 bindings 绑定
  12.           type: rabbit  # 消息组件的类型
  13.           environment:  #相关环境配置，设置rabbitmq的环境
  14.             spring:
  15.               rabbitmq:
  16.                 host: localhost
  17.                 port: 5672
  18.                 username: guest
  19.                 password: guest
  20.       bindings: # 服务的整合处理
  21.         output:  # 通道名称
  22.           destination: testExchange # 定义要使用的Exchange的名称
  23.           content-type: application/json  # 设置消息类型，对象为json，文本是text/plain
  24.           binder: defaultRabbit # 设置要绑定的服务的具体设置，就是我们上面配置的defaultRabbit
  26. eureka:
  27.   client:
  28.     #表示是否将自己注册进EurekaServer默认为true
  29.     register-with-eureka: true
  30.     #是否从EurekaServer抓取已有的注册消息，默认为true，单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
  31.     fetch-registry: true
  32.     service-url:
  33.       #单机版
  34.       defaultZone: http://localhost:8080/eureka/
  35.   instance:
  36.     prefer-ip-address: true
  37.     instance-id: sender01

定义接口

这里需要定义一个接口并实现它，方便其他业务调用。

  1. public interface IMessageProvider {
  2.     /**
  3.      * 发送接口
  4.      * @param msg
  5.      * @return
  6.      */
  7.     public String send(String msg);
  8. }

接口实现

接口实现中需要添加@EnableBinding注解，并引入Source.class,为什么引入Source.class呢？因为它是生产者，我们参考stream流程图就可以知道

  1. import com.martain.study.service.IMessageProvider;
  2. import org.springframework.cloud.stream.annotation.EnableBinding;
  3. import org.springframework.cloud.stream.messaging.Source;
  4. import org.springframework.messaging.MessageChannel;
  5. import org.springframework.messaging.support.MessageBuilder; 
  6. import javax.annotation.Resource;
  8. @EnableBinding(Source.class)
  9. public class MessageProvider implements IMessageProvider {
  10.     /**
  11.      * 注入消息发送管道
  12.      */
  13.     @Resource
  14.     private MessageChannel output;
  16.     @Override
  17.     public String send(String msg) {
  18.         output.send(MessageBuilder.withPayload(msg).build());
  19.         System.out.println("******send message:"+msg);
  20.         return msg;
  21.     }
  22. }

定义测试controller 

  2. @RestController
  3. public class TestController {
  5.     @Autowired
  6.     IMessageProvider messageProvider;
  8.     @GetMapping("/sendMsg")
  9.     public String sendMsg(){
  10.         String msg = UUID.randomUUID().toString();
  11.         return messageProvider.send(msg);
  12.     }
  13.  
  14. }

启动类 

  1. @SpringBootApplication
  2. public class StreamProviderApplication8801 {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(StreamProviderApplication8801.class,args);
  5.     }
  6. }

服务启动之后，多次请求/sendMsg，发送了多条消息。

生产服务生产消息

消费端
依赖 

  1.    
  2.         
  3.             org.springframework.cloud
  4.             spring-cloud-starter-stream-rabbit
  5.         
  6.         
  7.         
  8.             org.springframework.cloud
  9.             spring-cloud-starter-netflix-eureka-client
  10.         
  11.         
  12.             org.springframework.boot
  13.             spring-boot-starter-web
  14.         
  15.         
  16.             org.springframework.boot
  17.             spring-boot-starter-actuator
  18.

配置文件

与生产者类似，只是bindings中的output改成了input

  1. server:
  2.   port: 8802
  3. spring:
  4.   application:
  5.     name: cloud-stream-consume
  6.   cloud:
  7.     # stream 配置
  8.     stream:
  9.       binders: # 配置绑定的消息中间件的服务信息
  10.         defaultRabbit: # 自定义的一个名称，用来下面 bindings 绑定
  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: testExchange # 定义要使用的Exchange的名称
  22.           content-type: application/json  # 设置消息类型，对象为json，文本是text/plain
  23.           binder: defaultRabbit # 设置要绑定的服务的具体设置，就是我们上面配置的defaultRabbit
  25. eureka:
  26.   client:
  27.     #表示是否将自己注册进EurekaServer默认为true
  28.     register-with-eureka: true
  29.     #是否从EurekaServer抓取已有的注册消息，默认为true，单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
  30.     fetch-registry: true
  31.     service-url:
  32.       #单机版
  33.       defaultZone: http://localhost:8080/eureka/
  34.   instance:
  35.     prefer-ip-address: true
  36.     instance-id: recover01

接收服务

接收服务只需要再类名前添加@EnableBinding()注解，并引入Sink.class类，而实际接收的方法中需要添加@StreamListener(Sink.INPUT)注解。

  1. package com.martain.study.controller; 
  2. import org.springframework.beans.factory.annotation.Value;
  3. import org.springframework.cloud.stream.annotation.EnableBinding;
  4. import org.springframework.cloud.stream.annotation.StreamListener;
  5. import org.springframework.cloud.stream.messaging.Sink;
  6. import org.springframework.messaging.Message;
  7. import org.springframework.stereotype.Component; 
  9. @Component
  10. @EnableBinding(Sink.class)
  11. public class ReceiveMessageListenerController {
  12.     /**
  13.      * 获取本服务的端口
  14.      */
  15.     @Value("${server.port}")
  16.     private String serverPort;
  17.     /**
  18.      * 这里表示监听sink的input
  19.      * @param message
  20.      */
  21.     @StreamListener(Sink.INPUT)
  22.     public void input(Message message){
  23.         System.out.println("**** recv msg :"+message.getPayload()+"   in port "+serverPort);
  24.     }
  25. }

启动类 

  1. @SpringBootApplication
  2. public class StreamConsumerApplication8802 {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(StreamConsumerApplication8802.class,args);
  5.     }
  6. }

启动生产服务后，在启动消费服务，多次请求生产服务发送消息，我们可以发现消费者能很快的消费这些消息。

消费者消费消息

消息分组

当我们有多个消费者时,这个时候生产者生产一条消息，会发现所有的消费者都会消费这个消息。比如在一些订单系统的场景中，如果一个订单被多个处理服务一起获取到，就容易造成数据错误，那我们如何避免这种情况呢？这时我们就可以使用Stream的消息分组来解决重复消费问题。

如何实现Stream的消息分组呢？我们只要简单的在yml文件中配置spring.cloud.stream.bindings.input.group即可。示例如下：

  1. ...
  2. spring:
  3.   application:
  4.     name: cloud-stream-consume
  5.   cloud:
  6.     # stream 配置
  7.     stream:
  8.       binders: # 配置绑定的消息中间件的服务信息
  9.         defaultRabbit: # 自定义的一个名称，用来下面 bindings 绑定
  10.           type: rabbit  # 消息组件的类型
  11.           environment:  #相关环境配置，设置rabbitmq的环境
  12.             spring:
  13.               rabbitmq:
  14.                 host: localhost
  15.                 port: 5672
  16.                 username: guest
  17.                 password: guest
  18.       bindings: # 服务的整合处理
  19.         input:  # 通道名称
  20.           destination: testExchange # 定义要使用的Exchange的名称
  21.           content-type: application/json  # 设置消息类型，对象为json，文本是text/plain
  22.           binder: defaultRabbit # 设置要绑定的服务的具体设置，就是我们上面配置的defaultRabbit
  23.           group: groupA # 配置分组
  24.           
  25.             ...

如果没有设置该属性，当消费服务启动时，会有个随机的组名。

如果我们将所有的消费服务的group熟悉都设置成一致的话，这些服务就会在同一个组里面，从而能够保证消息只被应用消费一次。

同一组的消费者是竞争关系，不可以重复消费。

消息持久化

当生产者在持续生产消息，消费服务突然挂了，使得拥有许多消息并没有被消费，如果消费没有配置分组的话，消费服务重启是无法消费未消费的消息的，如果配置了分组的话，当消费服务重启之后可以自动去消费未消费的数据。

©
著作权归作者所有,转载或内容合作请联系作者

喜欢的朋友记得点赞、收藏、关注哦！！！

中间件消息
大数据

kafka常用命令和解释(kafka命令大全)

2025-3-1 23:12:26

大数据

＞＞ ＜＜ ＞＞＞ 左移，右移，逻辑右移，运算规则，Shift left, shift right,logical right shift . Bit Operator rules

2025-3-1 23:12:29

0 条回复 A文章作者 M管理员
欢迎您，新朋友，感谢参与互动！
    暂无讨论，说说你的看法吧

请输入验证码

请输入图片中的验证码
点击发送按钮获取验证码

取消
×
×
￥undefined
请打开手机使用微信扫码支付
「」
×

....支付确认中....

「」
×
支付金额

￥

undefined
×
积分支付
您当前的积分为0

检测到您未绑定微信账户，请先绑定微信

立刻绑定
确定
×

打开微信扫一扫

扫码并「关注我们的公众号」安全快捷登录

×

下载海报：