SpringCloud系列 （十） Spring Cloud Stream消息驱动组件

草帽浪人
672 阅读9分钟

Spring Cloud Stream消息驱动组件

Spring Cloud Stream 消息驱动组件帮助我们更快速，更⽅便，更友好的去构建消息驱动微服务，spring.io/projects/sp…

消息驱动,基于消息机制做⼀些事情,比如消息队列、消息中间件、消息代理。市面上产品有很多，ActiveMQ、 RabbitMQ、RocketMQ、Kafka

1、Stream解决的痛点问题

MQ消息中间件⼴泛应⽤在应⽤解耦合、异步消息处理、流量削峰等场景中

不同的MQ消息中间件内部机制包括使⽤⽅式都会有所不同，⽐如：

  • RabbitMQ中有Exchange（交换机/交换器）这⼀概念
  • kafka有Topic、Partition分区这些概念

MQ消息中间件的差异性不利于我们上层的开发应⽤，当我们的系统希望从原有的RabbitMQ切换到Kafka时，我们会发现⽐较困难，很多要操作可能重来（因为应⽤程序和具体的某⼀款MQ消息中间件耦合在⼀起了）。

Spring Cloud Stream进⾏了很好的上层抽象，可以让我们与具体消息中间件解耦合，屏蔽掉了底层具体MQ消息中间件的细节差异，就像Hibernate屏蔽掉了具体数据库（Mysql/Oracle⼀样）。如此⼀来，我们学习、开发、维护MQ都会变得轻松。⽬前Spring Cloud Stream⽀持RabbitMQ和Kafka。

本质：屏蔽掉了底层不同MQ消息中间件之间的差异，统⼀了MQ的编程模型，降低 了学习、开发、维护MQ的成本

2、Stream重要概念

Spring Cloud Stream 是⼀个构建消息驱动微服务的框架。应⽤程序通过inputs（相当于消息消费者consumer）或者outputs（相当于消息⽣产者producer）来与Spring Cloud Stream中的binder对象交互，⽽Binder对象是⽤来屏蔽底层MQ细节的，它负责与具体的消息中间件交互。

对于我们来说，只需要知道如何使⽤Spring Cloud Stream与Binder对象交互即可

  • Application Code 这部分就是我们的应用程序代码，里面包含了消费者逻辑代码，生产者逻辑代码

  • Inputs outputs （又称为 Binddings） 首先解释一点，这里的input,output是针对于应用程序来说的，output就是应用程序往消息队列中发送消息，对应的是生产者，input就是从消息队列中获取数据，对应的应用程序就是消费者

  • Binder绑定器 Binder绑定器是Spring Cloud Stream 中⾮常核⼼的概念，就是通过它来屏蔽底层不同MQ消息中间件的细节差异，当需要更换为其他消息中间件时，我们需要做的就是更换对应的Binder绑定器⽽不需要修改任何应⽤逻辑,我们针对的是抽象对象编程，所以这里只需要换成不同的实现即可

  • MiddleWare 各种中间件RabbitMQ,Kafka,RocketMQ等

3、传统MQ模型与Stream消息驱动模型

传统MQ模型

在传统的模型中，我们必须知道每款MQ产品的实现细节，然后才能进行开发，产品的细节都包含在代码里面了，如果需要让不同的MQ产品都相互配合起来使用，那将会是一件很麻烦的事情，各种实现细节都不一样，代码耦合度就高了

Stream消息驱动模型

使用Stream消息驱动，我们的注意力就可以放在业务上面了，不需分过多的精力去处理兼容性问题，Stream都帮我们做好了。api变得统一，后续有新的MQ产品进来后，也不需要过多的改动，大家都在一个框架下玩

4、Stream消息通信⽅式及编程模型

4.1 Stream消息通信⽅式

Stream中的消息通信⽅式遵循了发布—订阅模式。

在Spring Cloud Stream中的消息通信⽅式遵循了发布-订阅模式，当⼀条消息被投递到消息中间件之后，它会通过共享的 Topic 主题进⾏⼴播，消息消费者在订阅的主题中收到它并触发⾃身的业务逻辑处理。

这⾥所提到的 Topic 主题是SpringCloud Stream中的⼀个抽象概念，⽤来代表发布共享消息给消 费者的地⽅。

在不同的消息中间件中， Topic 可能对应着不同的概念，⽐如：在RabbitMQ中的它对应了Exchange、在Kakfa中则对应了Kafka中的Topic。

4.2 Stream编程注解

如下的注解⽆⾮在做⼀件事，把我们结构图中那些组成部分上下关联起来，打通通道（这样的话⽣产者的message数据才能进⼊mq，mq中数据才能进⼊消费者⼯程）

接下来，我们创建三个⼯程（我们基于RabbitMQ，RabbitMQ的安装和使⽤这⾥不再说明）

  • lagou-cloud-stream-producer-9090， 作为⽣产者端发消息
  • lagou-cloud-stream-consumer-9091，作为消费者端接收消息
  • lagou-cloud-stream-consumer-9092，作为消费者端接收消息

4.3 Stream消息驱动之开发⽣产者端

（1）新建module lagou-cloud-stream-producer-9090

（2）导入依赖

<dependencies>
    <!--eureka client 客户端依赖引⼊-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!--spring cloud stream 依赖（rabbit）-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
    </dependency>
</dependencies>

（3）application.yml

这里加入了spring.cloud.stream.binders,spring.cloud.stream.bindings

server:
  port: 9090
spring:
  application:
    name: lagou-cloud-stream-producer
  cloud:
    stream:
      binders: # 绑定MQ服务信息（此处我们是RabbitMQ）
        lagouRabbitBinder: # 给Binder定义的名称，⽤于后⾯的关联
          type: rabbit # MQ类型，如果是Kafka的话，此处配置kafka
          environment: # MQ环境配置（⽤户名、密码等）
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 关联整合通道和binder对象
        output: # output是我们定义的通道名称，此处不能乱改
          destination: lagouExchange # 要使⽤的Exchange名称（消息队列主题名称）
          content-type: text/plain # application/json # 消息类型设置，⽐如json
          binder: lagouRabbitBinder # 关联MQ服务

eureka:
  client:
    serviceUrl: # eureka server的路径
      defaultZone: http://lagoucloudeurekaservera:8761/eureka/,http://lagoucloudeurekaserverb:8762/eureka/ #把 eureka 集群中的所有 url 都填写了进来，也可以只写⼀台，因为各个 eureka server 可以同步注册表
    instance:
      prefer-ip-address: true #使⽤ip注册

（4） 创建启动类StreamProducerApplication9090

@SpringBootApplication
@EnableDiscoveryClient
public class StreamProducerApplication9090 {
    public static void main(String[] args) {
        SpringApplication.run(StreamProducerApplication9090.class,args);
    }
}

（5）开发一个业务类接口，用来发送消息

 public interface IMessageProducer {
    void sendMessage(String context);
}

业务接口的实现类

package com.lagou.edu.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.messaging.support.MessageBuilder;

## ===> Source.class⾥⾯就是对输出通道的定义（这是Spring Cloud Stream内置的通道封装）
@EnableBinding(Source.class)
public class MessageProducerImpl implements IMessageProducer {

    ## ===> 将MessageChannel的封装对象Source注⼊到这⾥使⽤
    @Autowired
    private Source source;

    @Override
    public void sendMessage(String context) {
        ## ===> 向mq中发送消息（并不是直接操作mq，应该操作的是spring cloud stream）

        ## ===> 使⽤通道向外发出消息(指的是Source⾥⾯的output通道)
        source.output().send(MessageBuilder.withPayload(context).build());
    }
}


## ===> 这里绑定的是Source，也就是output的通道
public interface Source {
    String OUTPUT = "output";
    @Output("output")
    MessageChannel output();
}

（6）新建一个测试用例，测试发送消息

@SpringBootTest(classes = {StreamProducerApplication9090.class})
@RunWith(value = SpringJUnit4ClassRunner.class)
public class MessageProducerTest {

    @Autowired
    private IMessageProducer messageProducer;

    @Test
    public void testMessage(){
        messageProducer.sendMessage("hello world ");
    }
}

4.4 Stream消息驱动之开发消费者端

（1）新建module lagou-cloud-stream-consumer-9091 （2）pom文件

<dependencies>
    <!--eureka client 客户端依赖引⼊-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!--spring cloud stream 依赖（rabbit）-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
    </dependency>
</dependencies>

（3）application.yml文件

（4）新建启动类

@EnableDiscoveryClient
@SpringBootApplication
public class StreamConsumerApplication9091 {
    public static void main(String[] args) {
        SpringApplication.run(StreamConsumerApplication9091.class,args);
    }
}

（5）新建一个监听者类，使用注解 @EnableBinding 绑定的是Sink.class,就是一个消息输入通道

package com.lagou.edu.service;

import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.messaging.Message;

@EnableBinding(Sink.class)
public class MessageConsumerService {

    @StreamListener(Sink.INPUT)
    public void recevieMessages(Message<String> message) {
        System.out.println("=========接收到的消息：" + message);
    }
}


## ===> 这里的Sink
public interface Sink {
    String INPUT = "input";

    @Input("input")
    SubscribableChannel input();
}

4.5 演示

（1）首先启动消费者监听的服务 lagou-cloud-stream-consumer-9091

（2）运行生产者 lagou-cloud-stream-producer-9090的测试用例

（3）消费者收到消息

（4）RabbitMq自动创建了一个 lagouExchange

5、Stream⾼级之⾃定义消息通道

Stream 内置了两种接⼝Source和Sink分别定义了 binding 为 “input” 的输⼊流和“output” 的输出流，我们也可以⾃定义各种输⼊输出流（通道），但实际我们可以在我们的服务中使⽤多个binder、多个输⼊通道和输出通道，然⽽默认就带了⼀个input的输⼊通道和⼀个output的输出通道，怎么办？

其实这个问题可以这么描述，就是RabbitMq和Kafka之间要进行消息传递，如何做呢？

我们是可以⾃定义消息通道的，学着Source和Sink的样⼦，给你的通道定义个⾃⼰的名字，多个输⼊通道和输出通道是可以写在⼀个类中的。

（1）定义接口

interface CustomChannel {
  String INPUT_LOG = "inputLog";
  String OUTPUT_LOG = "outputLog";
  
  @Input(INPUT_LOG)
  SubscribableChannel inputLog();
  
  @Output(OUTPUT_LOG)
  MessageChannel outputLog();
}

（2）配置application.yml文件

bindings:
 inputLog:
  destination: lagouExchange
 outputLog:
  destination: eduExchange

（2）在 @EnableBinding 注解中，绑定⾃定义的接⼝ （3）使⽤ @StreamListener 做监听的时候，需要指定 CustomChannel.INPUT_LOG

6、Stream⾼级之消息分组

6.1、重复消费情况

当我们按照现有的配置，再重复创建一个消费者，现在就是两个消费者，一个生产者的情形。

  • lagou-cloud-stream-consumer-9091 消费者1
  • lagou-cloud-stream-consumer-9092 消费者2
  • lagou-cloud-stream-producer-9090 生产者1 当我们生产者发送一条消息之后，两个消费者会同时获取得到这条消息，这明显是不对的

6.2、解决重复消费情况

解决方案其实很简单，我们仅仅需要在服务消费者端设置 spring.cloud.stream.bindings.input.group 属性，多个消费者实例配置为同⼀个group名称（在同⼀个group中的多个消费者只有⼀个可以获取到消息并消费）

6.3、消费分组后，消息持久化问题

  • 没有给消费者配置分组名称之前，生产者发送消息没有被持久化，当发送消息的时候，如果当前没有消费者监听被消费的话，这条数据就会丢失
  • 当给消费者配置了分组名称之后，生产者发送消息被持久化了，即使当前发送消息时，没有消费者存在，但是一旦消费者启动了，就会去队列里面去获取消息，
avatar
文章
阅读
粉丝