SpringCloud学习笔记(八)----消息驱动Stream、链路追踪Sleuth

Spring Cloud Stream 消息驱动

概述

为什么需要SpringCloud Stream

现在一个大项目可能分为三部分: 前端—>后端---->大数据。如果后端开发使用消息中间件RabbitMQ，而大数据开发使用Kafka，那么一个项目中就存在多个消息中间件，对于程序员来说，不好进行切换、维护 、开发。

SpringCloud Stream这时候就出现了，让我们不再关注具体MQ的细节，我们只需要用一种适配绑定的方式，自动的给我们在各种MQ内切换。

SpringCloud Stream就类似jpa，屏幕底层消息中间件的差异，降级切换版本，统一消息的编程模型。程序员只需要操作SpringCloud Stream即可，不需要管底层是kafka还是rabbitMq。

什么是SpringCloudStream

官方定义SpringCloud Stream是一个构建消息驱动微服务的框架。

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

通过使用Spring Integration来连接消息代理中间件以实现消息事件驱动。

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

目前仅支持RabbitMQ、Kafka。

设计思想

标准MQ

• 生产者/消费者之间靠消息(Message)媒介传递消息内容
• 消息必须走特定的通道(消息通道MessageChannel)
• 消息通过MessageChannel的子接口SubscribableChannel，由MessageHandler消息处理器订阅。

为什么用CloudStream

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

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

Stream 是怎么屏蔽底层差异的

在没有绑定器这个概念的情况下，我们的SpringBoot应用要直接与消息中间件进行信息交互的时候，由于各消息中间件构建的初衷不同，它们的实现细节上会有较大的差异性。

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

通过向应用程序暴露统一的Channel通道，使得应用程序不需要再考虑各种不同的消息中间件实现。

Binder是什么

通过定义绑定器作为中间层，完美地实现了应用程序与消息中间件细节之间的隔离。Stream对消息中间件的进一步封装，可以做到代码层面对中间件的无感知，甚至于动态的切换中间件(RabbitMQ切换为kafka)，使得微服务开发的高度解耦，服务可以关注更多自己的业务流程。

INPUT对应于消费者、OUTPUT对应于生产者。

Stream中的消息通信方式遵循了发布-订阅模式，Topic主题进行广播。

• 在RabbitMQ就是Exchange
• 在kafka中就是Topic

SpringCloud Stream标准流程

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

编码API和常用注解

案例说明

工程中新建三个子模块

• cloud-stream-rabbitmq-provider8801,作为生产者进行发消息模块
• cloud-stream-rabbitmq-consumer8802,作为消息接收模块
• cloud-stream-rabbitmq-consumer8803,作为消息接收模块

消息驱动之生产者

1.新建Module cloud-stream-rabbitmq-provider8801
2.POM.xml

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${
     project.version}</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-devtools -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

3.application.yml

server:
  port: 8801

spring:
  application:
    name: cloud-stream-provider
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息；
        #注意:这个defaultRabbit是我们自定义的一个名字。
        defaultRabbit: # 表示定义的名称，用于于binding整合
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: 172.16.114.135
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
        output: # 这个名字是一个通道的名称
          destination: studyExchange # 表示要使用的Exchange名称定义
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
          binder: defaultRabbit  # 设置要绑定的消息服务的具体设置

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）
    lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）
    instance-id: send-8801.com  # 在信息列表时显示主机名称
    prefer-ip-address: true     # 访问的路径变为IP地址

4.主启动类

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

5.业务类
5.1定义发送消息的接口

public interface IMessageProvider {
     
    public  String send();
}

5.2发送消息接口实现类

//表示当前这个类是source，负责生产消息，并且发送给channel
@EnableBinding(Source.class) //定义消息的推送管道
public class MessageProviderImpl implements IMessageProvider
{
     
    @Resource  //channel 我们将消息发送给channel
    private MessageChannel output; // 消息发送管道

    @Override
    public String send()
    {
     
        String serial = UUID.randomUUID().toString();
        //发送消息
        output.send(MessageBuilder.withPayload(serial).build()); //build方法会构建一个Message类
        System.out.println("*****serial: "+serial);
        return null;
    }
}

这里，就会调用send方法，将消息发送给channel，然后channel将消费发送给binder，然后发送到rabbitmq中。

5.3controller

@RestController
public class SendMessageController {
     
    @Autowired
    private IMessageProvider  messageProvider;

    @GetMapping(value = "/sendMessage")
    public  String sendMessage(){
     
        return  messageProvider.send();
    }
}

6.测试
启动rabbitmq，启动7001，8801。
启动8801后，会在rabbitmq中创建一个Exchange，就是我们配置文件中配置的exchange。

访问：http://localhost:8801/sendMessage。

消息驱动之消费者

1.新建Module cloud-stream-rabbitmq-consumer8802
2.POM.xml

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${
     project.version}</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-devtools -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

3.application.yml

server:
  port: 8802

spring:
  application:
    name: cloud-stream-consumer
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息；
        defaultRabbit: # 表示定义的名称，用于于binding整合
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: localhost
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
      #input 表示当前服务是一个消费者，需要消费消息。
      #destination：指定消费哪个Exchange中的消息。
        input: # 这个名字是一个通道的名称
          destination: studyExchange # 表示要使用的Exchange名称定义
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
          binder: defaultRabbit  # 设置要绑定的消息服务的具体设置

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）
    lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）
    instance-id: receive-8802.com  # 在信息列表时显示主机名称
    prefer-ip-address: true     # 访问的路径变为IP地址

4.业务类

@Component
//启用绑定，就是表示当前类是sink,负责接收channel发送过来的数据进行消费。
@EnableBinding(Sink.class)
public class ReceiveMessageListenerController {
     
    @Value("${server.port}")
    private String serverPort;

    @StreamListener(Sink.INPUT)
    //这里表示监听sink的input，而input我们在配置文件中配置了，绑定在一个指定的Exchange上获取数据
    public void input(Message<String> message) {
     
        System.out.println("消费者1号，接受："+message.getPayload()+"\t port:"+serverPort);
    }

}

生产者发送消息时，使用send方法发送，send方法发送的是一个个Message，里面封装了数据。

5.测试：
启动7001、8801、8802
此时使用生产者生产消息，可以看到，消费者已经接收到消息了。

分组消费与持久化

创建消费者2(8803)，与8802创建一模一样，创建8803主要是为了演示重复消费等问题。

重复消费问题

此时生产者生产一条消息，但是8802，8803都消费到了同一条数据。

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

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

解决办法：使用分组和持久化属性group

分组

原理：微服务应用放置于同一个group中，就能够保证消息只会被其中一个应用消费一次。不同的组是可以重复消费的，同一个组内会发生竞争关系，只有其中一个可以消费。

8802/8803都变成不同组，group两个不同。

group：dongguaA、dongguaB

8802修改YML

server:
  port: 8802

spring:
  application:
    name: cloud-stream-consumer
  cloud:
    stream:
      binders: # 在此处配置要绑定的rabbitmq的服务信息；
        defaultRabbit: # 表示定义的名称，用于于binding整合
          type: rabbit # 消息组件类型
          environment: # 设置rabbitmq的相关的环境配置
            spring:
              rabbitmq:
                host: 172.16.114.135
                port: 5672
                username: guest
                password: guest
      bindings: # 服务的整合处理
      #input 表示当前服务是一个消费者，需要消费消息。
      #destination：指定消费哪个Exchange中的消息。
        input: # 这个名字是一个通道的名称
          destination: studyExchange # 表示要使用的Exchange名称定义
          content-type: application/json # 设置消息类型，本次为json，文本则设置“text/plain”
          binder: defaultRabbit  # 设置要绑定的消息服务的具体设置
          group: dongguaA

eureka:
  client: # 客户端进行Eureka注册的配置
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）
    lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）
    instance-id: receive-8802.com  # 在信息列表时显示主机名称
    prefer-ip-address: true     # 访问的路径变为IP地址

8803修改YML

group: dongguaB

分布式微服务应用为了实现高可用和负载均衡，实际上都会部署多个实例，本例启动了两个消费微服务(8802/8803)。
多数情况，生产者发送消息给某个具体微服务时只希望被消费一次，按照上面我们启动两个应用的例子，虽然它们同属一个应用，但是这个消息出现了被重复消费两次的情况。为了解决这个问题，在SpringCloud Stream中提供了消费组的概念。

8802/8803都变成相同组，group两个相同。

group：dongguaA

8802/8803修改配置

group: dongguaA

8802/8803实现了轮询分组，每次只有一个消费者 8801模块的发的消息只能被8802或8803其中一个接收到，这样避免了重复消费。

可以看到，每个服务只消费了一条信息，并且没有重复消费。

持久化问题

就是当服务挂了，如何消费未消费的数据。

这里，先停止8802/8803，并去除8802的分组group:dongguaA,8803的分区dongguaA没有去掉。

此时8801先发送4条信息到rabbitmq。

这时候启动8802/8803，可以看到，当8802退出dongguaA组后，它就获取不到在它宕机的时间段内的数据。
但是8803重启后，直接获取到了宕机期间它没有消费的数据，并且消费了。

总结:

• 也就是，当我们没有配置分组时，如果服务发生宕机，会出现消息没有消费的问题。
• 而配置分组后，宕机后重启服务，可以自动获取未消费的数据，并且在进行消费。

SpringCloud Sleuth分布式请求链路追踪

概述

sleuth要解决的问题：

在微服务框架中，一个由客户端发起的请求在后端系统中会经过多个不同的服务节点调用来协同产生最后的请求结果，每一个请求都会形成一条复杂的分布式服务调用链路，链路中的任何一环出现高延时或错误都会引起整个请求最后的失败。

sleuth就是用于追踪每个请求的整体链路。

Spring Cloud Sleuth提供了一套完整的服务跟踪的解决方案，在分布式系统中提供追踪解决方案并且兼容支持了zipkin(图形化展示链路调用流程)

安装zipkin

SpringCloud从F版起已不需要自己构建Zipkin server了，只需要调用jar包即可

1.去官方下载zipkin jar包
zipkin下载

2.运行jar
java -jar zipkin-server-2.12.9-exec.jar

3.访问zipkin的web界面，默认zipkin监听的端口是9411

http://localhost:9411/zipkin/

一条链路完整图片

精简版链路

名词解释：

• Trace：类似于树结构的Span集合，表示一条调用链路，存在唯一标识。
• span：表示调用链路来源，通俗的理解span就是一次请求信息。

搭建链路监控

服务提供者

cloud-provider-payment8001
1.在POM中添加依赖

<!--包含了sleuth+zipkin-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

2.修改配置文件

spring:
  application:
    name: cloud-order-service
  zipkin:
    base-url: http://localhost:9411
  sleuth:
    sampler:
    probability: 1

3.controller中添加一个方法

@GetMapping("/payment/zipkin")
    public String paymentZipkin()
    {
     
        return "hi ,i'am paymentzipkin server fall back，welcome to atguigu，O(∩_∩)O哈哈~";
    }

服务消费者(调用方)

cloud-consumer-order80
1.在POM中添加依赖

<!--包含了sleuth+zipkin-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

2.修改配置文件

spring:
  application:
    name: cloud-order-service
  zipkin:
    base-url: http://localhost:9411
  sleuth:
    sampler:
    probability: 1

3.controller中添加一个方法

 // ====================> zipkin+sleuth
    @GetMapping("/consumer/payment/zipkin")
    public String paymentZipkin()
    {
     
        String result = restTemplate.getForObject("http://localhost:8001"+"/payment/zipkin/", String.class);
        return result;
    }

测试：依次启动eureka7001/8001/80
打开浏览器访问:http:localhost:9411