SpringCloud——消息驱动 SpringCloud Stream

1. 概述

1.1 是什么

Spring Cloud Stream 是一个构建消息驱动微服务的框架。

应用程序通过 inputs 或者 outputs 与 Spring Cloud Stream 中 binder 对象交互。通过配置来 binding(绑定)，而 Spring Cloud Stream 的 binder 对象负责与消息中间件交互。所以，只需要搞清楚如何与 Spring Cloud Stream 交互就可以方便使用消息驱动的方式。通过使用Spring Integration来连接消息代理中间件以实现消息事件驱动。

Spring Cloud Stream为一些消息中间件产品提供了自动化配置实现，引用了发布订阅、消费组、分区的三个核心概念。

目前仅支持 RabbitMQ、Kafka.

官网：https://spring.io/projects/spring-cloud-stream#overview

https://cloud.spring.io/spring-cloud-static/spring-cloud-stream/3.0.1.RELEASE/reference/html/

中文指导手册：https://m.wang1314.com/doc/webapp/topic/20971999.html

1.2 设计思想

1.2.1 标准MQ

生产者/消费者之间靠消息媒介传递信息内容 （Message）

消息必须走特定的消息通道（MessageChannel）

由MessageHandler消息处理器订阅

1.2.2 为什么用 Cloud Stream

在没有绑定器的情况下，SpringBoot 应用要直接与消息中间件进行信息交互。由于各消息中间件实现细节上有较大的差异性，通过定义绑定器作为中间层，完美地实现了应用程序与消息中间件细节之间的隔离。通过向应用程序暴露统一的 Channel 通道， 使得应用程序不需要再考虑各种不同的消息中间件实现。

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

 Stream 中的消息通信方式遵循了发布-订阅模式。以 Topic 主题进行广播。在 RabbitMQ 就是 Exchange，在 kafka 中就是 Topic。

1.3 Spring Cloud Stream 标准流程

Binder：连接中间件，用于屏蔽差异。

Channel：通道，是队列 Queue 的一种抽象，在消息通讯系统中实现存储和转发的媒介。

Source和Sink：从Stream发布消息就是输出，接受消息就是输入

1.4 常用注解

注解	说明
@Input	标识输入通道，通过该输入通道消息进入应用程序
@Output	标识输出通道，发布的消息通过输出通道离开应用程序
@StreamListener	监听队列，用于消费者的消息接收
@EnableBinding	将信道 channel 和exchange 绑定在一起

2. 案例实现

2.1 消息驱动之生产者

pom:

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

yml:

server:
  port: 8801

spring:
  application:
    name: cloud-stream-provider
  cloud:
    stream:
      binders:
        defaultRabbit:
          type: rabbit
          environment:
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings:     # 服务的整合处理
        output:     # 通道的名称
          destination: TestExchange
          content-type: application/json

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka

发送消息：

import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.MessageBuilder;

import javax.annotation.Resource;
import java.util.UUID;


@EnableBinding(Source.class)
public class MessageProviderImpl {

    @Resource
    private MessageChannel output;

    public String sendFromChannel() {
        String serial = UUID.randomUUID().toString();
        output.send(MessageBuilder.withPayload(serial).build());
        System.out.println("serial: "+serial);
        return null;
    }
}

2.2 消息驱动之消费者

pom 同2.1

yml:

server:
  port: 8802

spring:
  application:
    name: cloud-stream-consumer
  cloud:
    stream:
      binders: # 绑定 rabbitmq 服务信息；
        defaultRabbit:
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
        input: # 通道的名称
          destination: TestExchange
          content-type: application/json

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka

接收消息：

@RestController
@EnableBinding(Sink.class)
public class ReceiveMessageListenerController {
    @Value("${server.port}")
    private String serverPort;

    @StreamListener(Sink.INPUT)
    public void input(Message<String> message) {
        System.out.println("消费者接收："+message.getPayload()+"\t port:"+serverPort);
    }
}

 

3. 实现多通道

3.1 消息驱动之生产者

pom 同2.1

yml:

server:
  port: 8801

spring:
  application:
    name: cloud-stream-provider
  cloud:
    stream:
      binders:
        defaultRabbit:
          type: rabbit
          environment:
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings:     # 服务的整合处理
        output1:     # 通道的名称
          destination: Exchange1
          content-type: application/json
        output2:
          destination: Exchange2
          content-type: application/json

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka

自定义输出通道：

@Component
public interface MySource {
    String OUTPUT1 = "output1";
    String OUTPUT2 = "output2";

    @Output(OUTPUT1)
    MessageChannel output1();
    @Output(OUTPUT2)
    MessageChannel output2();

}

消息生产者通过不同的输出通道产生不同的消息：

@EnableBinding(MySource.class)
public class MessageProviderImpl {

    @Autowired
    private MySource mySource;

    public String sendFromChannel1() {
        String serial = UUID.randomUUID().toString();
        mySource.output1().send(MessageBuilder.withPayload(serial).build());
        System.out.println("send From Channel1 serial: "+serial);
        return null;
    }

    public String sendFromChannel2() {
        String serial = UUID.randomUUID().toString();
        mySource.output2().send(MessageBuilder.withPayload(serial).build());
        System.out.println("send From Channel2 serial: "+serial);
        return null;
    }
}

 

3.2 消息驱动之消费者

pom 同2.1

yml:

server:
  port: 8802

spring:
  application:
    name: cloud-stream-consumer
  cloud:
    stream:
      binders: # 绑定 rabbitmq 服务信息；
        defaultRabbit:
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
        input1: # 通道的名称
          destination: Exchange1
          content-type: application/json
        input2:
          destination: Exchange2
          content-type: application/json

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka

定义多个输入通道

@Component
public interface MySink {
    String INPUT1 = "input1";
    String INPUT2 = "input2";

    @Input(INPUT1)
    SubscribableChannel input1();

    @Input(INPUT2)
    SubscribableChannel input2();

}

消费者注册使用不同的消息通道

@RestController
@EnableBinding(MySink.class)
public class ReceiveMessageListenerController {
    @Value("${server.port}")
    private String serverPort;

    @StreamListener(MySink.INPUT1)
    public void input(Message<String> message) {
        System.out.println("消费者1号，channel1 接受："+message.getPayload()+"\t port:"+serverPort);
    }

    @StreamListener(MySink.INPUT2)
    public void input2(Message<String> message) {
        System.out.println("消费者1号，channel2 接受："+message.getPayload()+"\t port:"+serverPort);
    }
}

4. 分组消费与持久化

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

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

新建一个 消费者，同 3.2 ，只是将端口改为  8803。

这时候生产者发一个消息：

两个消费者同时收到消息。

修改两个消费者YML:

spring:
  application:
    name: cloud-stream-consumer
  cloud:
    stream:
      binders: # 绑定 rabbitmq 服务信息；
        defaultRabbit:
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
        input: # 通道的名称
          destination: TestExchange
          content-type: application/json
          group: group1

添加 group: group1，将两个实例放进一个组中。

测试：

生产者发送两条消息：

两个消费者每个收到其中一条：