devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringCloud 微服务实战5 - Stream消息驱动、Sleuth 分布式请求链路跟踪_服务跟踪sleuth

作者：我家小花儿 | 2024-07-17 15:47:42

赞

踩

服务跟踪sleuth

一、SpringCloud Stream消息驱动

1、消息驱动概述

Spring Cloud Stream

SpringCloud Stream 是什么？

屏蔽底层消息中间件的差异，降低切换成本，统一消息的编程模型。

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

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

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

Spring Cloud Stream Reference Documentation

Spring Cloud Stream中文指导手册_书上有云的博客-CSDN博客

SpringCloud Stream设计思想

a.标准MQ

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

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

消息通道里的消息如何被处理呢?谁负责收发处理。

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

b.为什么用 Cloud Stream

 比方说我们用到了 RabbitMQ 和 Kafka，由于这两个消息中间件的架构上不同，我们需要做不同的处理。例如 RabbitMQ 有 exchange，Kafka有Topic和Partitions 分区。

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

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

Binder中 INPUT对应于消费者，OUTPUT 对应于生成者。

c.Stream 中的消息通信方式遵循了发布-订阅模式

使用topic主题进行广播

  • RabbitMQ 使用 exchange
  • Kafka 使用Topic

SpringCloud Stream标准流程套路

 Binder：很方便的连接中间件，屏蔽差异。

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

Source和Sink：简单的可理解为输入和输出。从Stream发布消息就是输出，接收Stream的消息就是输入。

SpringCloud Stream编码API和常用注解

MiddleWare：中间件，目前只支持RabbitMQ和Kafka。

Binder：Binder是应用与消息中间件之间的封装，目前实现了Kafka和RabbitMQ的Binder，通过Binder可以很方便的连接中间件，可以动态的改变消息类型（对应于Kafka的topic，RabbitMQ的exchange），这些都可以通过配置文件来实现。

@Input：注解标识输入通道，通过该输入通道接收到的消息进入应用程序。

@Output：注解标识输出通道，发布的消息将通过该通道离开应用程序。

@StreamListener：监听队列，用于消费者的队列的消息接收。

@EnableBinding：指信道channel和exchange绑定在一起。

2、案例说明

RabbitMQ环境已经OK

新建3个子模块：

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

3、消息驱动之生产者

新建Moudle ：cloud-stream-rabbitmq-provider8801

POM

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>cloud-study</artifactId>
  7.         <groupId>com.cloud.study</groupId>
  8.         <version>1.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.  
  12.     <artifactId>cloud-stream-rabbitmq-provider8801</artifactId>
  13.  
  14.     <dependencies>
  15.         <!-- stream-rabbit -->
  16.         <dependency>
  17.             <groupId>org.springframework.cloud</groupId>
  18.             <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
  19.         </dependency>
  20.  
  21.         <!-- Eureka client -->
  22.         <dependency>
  23.             <groupId>org.springframework.cloud</groupId>
  24.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  25.         </dependency>
  26.         <!-- 引入自己的 cloud-api-commons 模块-->
  27.         <dependency>
  28.             <groupId>com.cloud.study</groupId>
  29.             <artifactId>cloud-api-commons</artifactId>
  30.             <version>${project.version}</version>
  31.         </dependency>
  32.  
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-web</artifactId>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-actuator</artifactId>
  40.         </dependency>
  41.  
  42.         <!--开启热部署-->
  43.         <dependency>
  44.             <groupId>org.springframework.boot</groupId>
  45.             <artifactId>spring-boot-devtools</artifactId>
  46.             <scope>runtime</scope>
  47.             <optional>true</optional>
  48.         </dependency>
  49.         <!-- lombok -->
  50.         <dependency>
  51.             <groupId>org.projectlombok</groupId>
  52.             <artifactId>lombok</artifactId>
  53.             <optional>true</optional>
  54.         </dependency>
  55.         <!-- test -->
  56.         <dependency>
  57.             <groupId>org.springframework.boot</groupId>
  58.             <artifactId>spring-boot-starter-test</artifactId>
  59.             <scope>test</scope>
  60.         </dependency>
  61.     </dependencies>
  62. </project>

YAML

  1. server:
  2.   port: 8801
  3.  
  4. spring:
  5.   application:
  6.     name: cloud-stream-provider
  7.   cloud:
  8.     stream:
  9.       binders:
  10.         defaultRabbit: #在此处配置要绑定的rabbitMQ的服务信息
  11.           type: rabbit #消息组件类型
  12.           environment:  #s设置 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 #设置要绑定的消息服务的具体设置
  24.  
  25. eureka:
  26.   client:
  27.     register-with-eureka: true #表示是否将自己注册进EurekaServer，默认为true
  28.     fetch-registry: true #是否从 EurekaServer 抓取自己有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
  29.     service-url:
  30.       #设置与 Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
  31.       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/ #集群 Eureka 配置
  32.   instance:
  33.     instance-id: ${spring.application.name} #微服务名
  34.     prefer-ip-address: true #显示IP

主启动 StreamMQMain8801

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

业务类

  • 发送消息接口
  1. public interface IMessageProvider {
  2.     boolean send(String msg);
  3. }
  • 发送消息接口实现类
  1. @Slf4j
  2. @EnableBinding(Source.class) //定义消息的推送管道  org.springframework.cloud.stream.messaging.Source
  3. public class MessageProviderImpl implements IMessageProvider {
  4.     @Resource
  5.     private MessageChannel output; //消息发送管道
  6.  
  7.     @Override
  8.     public boolean send(String msg) {
  9.         boolean r = output.send(MessageBuilder.withPayload(msg).build()); //org.springframework.messaging.support.MessageBuilder
  10.         log.info("******** sendMsg: "+ msg);
  11.         return r;
  12.     }
  13. }
  • controller
  1. @RestController
  2. @Slf4j
  3. public class SendMessageController {
  4.     @Resource
  5.     private IMessageProvider messageProvider;
  6.  
  7.     @GetMapping(value = "sendMessage")
  8.     public String sendMessage(@RequestParam("msg") String msg){
  9.         boolean r = messageProvider.send(msg);
  10.         return (r ? "消息发送成功" : "消息发送失败") + " ,msg:"+msg;
  11.     }
  12. }

测试

  • 启动 7001/7002
  • 启动 8801
  • 访问 http://localhost:8801/sendMessage?msg=12 ,后查看rabbitMq面板（http://localhost:15672/）能看到波动就说明发送成功了

4、消息驱动之消费者

新建模块 cloud-stream-rabbitmq-consumer8802

POM文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>cloud-study</artifactId>
  7.         <groupId>com.cloud.study</groupId>
  8.         <version>1.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.  
  12.     <artifactId>cloud-stream-rabbitmq-consumer8802</artifactId>
  13.  
  14.     <dependencies>
  15.         <!-- stream-rabbit -->
  16.         <dependency>
  17.             <groupId>org.springframework.cloud</groupId>
  18.             <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
  19.         </dependency>
  20.  
  21.         <!-- Eureka client -->
  22.         <dependency>
  23.             <groupId>org.springframework.cloud</groupId>
  24.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  25.         </dependency>
  26.         <!-- 引入自己的 cloud-api-commons 模块-->
  27.         <dependency>
  28.             <groupId>com.cloud.study</groupId>
  29.             <artifactId>cloud-api-commons</artifactId>
  30.             <version>${project.version}</version>
  31.         </dependency>
  32.  
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-web</artifactId>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-actuator</artifactId>
  40.         </dependency>
  41.  
  42.         <!--开启热部署-->
  43.         <dependency>
  44.             <groupId>org.springframework.boot</groupId>
  45.             <artifactId>spring-boot-devtools</artifactId>
  46.             <scope>runtime</scope>
  47.             <optional>true</optional>
  48.         </dependency>
  49.         <!-- lombok -->
  50.         <dependency>
  51.             <groupId>org.projectlombok</groupId>
  52.             <artifactId>lombok</artifactId>
  53.             <optional>true</optional>
  54.         </dependency>
  55.         <!-- test -->
  56.         <dependency>
  57.             <groupId>org.springframework.boot</groupId>
  58.             <artifactId>spring-boot-starter-test</artifactId>
  59.             <scope>test</scope>
  60.         </dependency>
  61.     </dependencies>
  62. </project>

yaml

  1. server:
  2.   port: 8802
  3.  
  4. spring:
  5.   application:
  6.     name: cloud-stream-provider
  7.   cloud:
  8.     stream:
  9.       binders:
  10.         defaultRabbit: #在此处配置要绑定的rabbitMQ的服务信息
  11.           type: rabbit #消息组件类型
  12.           environment:  #s设置 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 #设置要绑定的消息服务的具体设置
  24.  
  25. eureka:
  26.   client:
  27.     register-with-eureka: true #表示是否将自己注册进EurekaServer，默认为true
  28.     fetch-registry: true #是否从 EurekaServer 抓取自己有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
  29.     service-url:
  30.       #设置与 Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
  31.       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/ #集群 Eureka 配置
  32.   instance:
  33.     instance-id: ${spring.application.name} #微服务名
  34.     prefer-ip-address: true #显示IP

 主启动类

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

业务类：消息监听

  1. @Slf4j
  2. @Component
  3. @EnableBinding({Sink.class}) //org.springframework.cloud.stream.messaging.Sink
  4. public class ReceiverMessageListener {
  5.     @Value("${server.port}")
  6.     private String serverPort;
  7.  
  8.     @StreamListener(Sink.INPUT)
  9.     public void input(Message<String> message){ //org.springframework.messaging.Message;
  10.         log.info("消费者1号 ----->接收到消息： "+ message.getPayload() + "\t port:"+serverPort);
  11.     }
  12. }

测试

  • 启动 7001/7002 
  • 启动 8001
  • 启动 8002
  • 多访问几次 http://localhost:8801/sendMessage?msg=12 ，发现8002的控制台输出log，表明收到消息。

5、分组消费与持久化

按照上面的步骤创建  cloud-stream-rabbitmq-consumer8803 模块

启动项目：

  • 启动 7001/7002 
  • 启动 8801
  • 启动 8802/8803

访问 http://localhost:8801/sendMessage?msg=12 ，发现 8002/8003 都收到了消息，此时就存在重复消费的问题。

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

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

使用 分组和持久化属性 group 解决重复消费问题。

5.1 8802/8803 自定义定义不同的group

8002 为 testA，yaml中加入 group配置

  1. spring:
  2.   application:
  3.     name: cloud-stream-provider
  4.   cloud:
  5.     stream:
  6.       binders:
  7.         defaultRabbit: #在此处配置要绑定的rabbitMQ的服务信息
  8.           type: rabbit #消息组件类型
  9.           environment:  #s设置 rabbitmq的相关的配置环境
  10.             spring:
  11.               rabbitmq:
  12.                 host: localhost
  13.                 port: 5672
  14.                 username: guest
  15.                 password: guest
  16.       bindings:   #服务的整合处理
  17.         input:   #这个名字是一个通道的名称, 接收消息
  18.           destination: studyExchange  #表示要使用的 Exchange 名称定义
  19.           content-type: application/json  #设置消息类型，本次为json，文本则设置 text/plain
  20.           binder: defaultRabbit #设置要绑定的消息服务的具体设置
  21.           group: testA #定义分组的名称为 testA

8002 为 testB，yaml中加入 group配置

  1. spring:
  2.   application:
  3.     name: cloud-stream-provider
  4.   cloud:
  5.     stream:
  6.       binders:
  7.         defaultRabbit: #在此处配置要绑定的rabbitMQ的服务信息
  8.           type: rabbit #消息组件类型
  9.           environment:  #s设置 rabbitmq的相关的配置环境
  10.             spring:
  11.               rabbitmq:
  12.                 host: localhost
  13.                 port: 5672
  14.                 username: guest
  15.                 password: guest
  16.       bindings:   #服务的整合处理
  17.         input:   #这个名字是一个通道的名称, 接收消息
  18.           destination: studyExchange  #表示要使用的 Exchange 名称定义
  19.           content-type: application/json  #设置消息类型，本次为json，文本则设置 text/plain
  20.           binder: defaultRabbit #设置要绑定的消息服务的具体设置
  21.           group: testB #定义分组的名称为 testB

重启8802/8803 ，在 RabbitMQ 管理后台的 Exchanges 的Binder ，如下：

此时他们属于不同的分组，发送消息后，8802/8803都收到了消息。

5.2 8802/8803 自定义定义相同的group

修改 8803 的yaml，将 group 改成 testA，此时发送消息，只能被其中的一个微服务收到。

消息接收会按照客户端负载均衡原则，将不同的消息发布到同组的不同的微服务上。

比如，发送了消息A、B、C

  • 8802会先接受到 A
  • 8803再接收到 B
  • 最后，8802接收到C

5.3 持久化

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

在 yaml 里面配置了 group ，则就会将消息持久化。因此 group 分组信息强烈建议配置。

先按照如下步骤操作 

  •  停止 8802/8803 ，并去除 8802 的分组 group: testA 
  • 8801 先发送4条消息到 rabbitMq
  • 先启动 8802 ，无分组属性配置，后台没有打出来消息
  • 再启动 8803， 有分组属性配置，后台打出来了 RabbitMQ 上的消息

二、SpringCloud Sleuth 分布式请求链路跟踪

1、概述

1.1 SpringCloud Sleuth为什么会出现，要解决哪些问题？

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

1.2 SpringCloud Sleuth 是什么

https://github.com/spring-cloud/spring-cloud-sleuthicon-default.png?t=N7T8https://github.com/spring-cloud/spring-cloud-sleuthSpringCloud Sleuth 提供了一套完整的服务跟踪的解决方案。

在分布式系统中提供追踪解决方案并兼容支持了 zipkin。

2、搭建链路监控步骤

2.1 zipkin

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

下载地址： Central Repository: io/zipkin/zipkin-server 

我们下载最新的 2.23.4 中的  zipkin-server-2.23.4-exec.jar 

进入 jar 包所在目录，输入如下命令即可启动 zipkin

java -jar zipkin-server-2.23.4-exec.jar 

出现如下页面说明启动成功

访问 http://localhost:9411/ 

完整的调用链路：表示请求链路，一条链路通过 Trace Id 唯一标识，Span 标识发起的请求信息，各Span 通过 parent id 关联起来。

我们精简一下上图调用过程

整个链路的依赖关系如下：

名词解释：

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

2.2 服务提供者

新建 Module ：cloud-provider-sleuth-payment8001

pom 

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>cloud-study</artifactId>
  7.         <groupId>com.cloud.study</groupId>
  8.         <version>1.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.  
  12.     <artifactId>cloud-provider-sleuth-payment8001</artifactId>
  13.  
  14.     <dependencies>
  15.         <!-- sleuth+zipkin 依赖 -->
  16.         <dependency>
  17.             <groupId>org.springframework.cloud</groupId>
  18.             <artifactId>spring-cloud-starter-zipkin</artifactId>
  19.         </dependency>
  20.         <!-- Eureka client -->
  21.         <dependency>
  22.             <groupId>org.springframework.cloud</groupId>
  23.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  24.         </dependency>
  25.         <!-- 引入自己的 cloud-api-commons 模块-->
  26.         <dependency>
  27.             <groupId>com.cloud.study</groupId>
  28.             <artifactId>cloud-api-commons</artifactId>
  29.             <version>${project.version}</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-web</artifactId>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-starter-actuator</artifactId>
  38.         </dependency>
  39.         <!--开启热部署-->
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-devtools</artifactId>
  43.             <scope>runtime</scope>
  44.             <optional>true</optional>
  45.         </dependency>
  46.         <!-- lombok -->
  47.         <dependency>
  48.             <groupId>org.projectlombok</groupId>
  49.             <artifactId>lombok</artifactId>
  50.             <optional>true</optional>
  51.         </dependency>
  52.         <!-- test -->
  53.         <dependency>
  54.             <groupId>org.springframework.boot</groupId>
  55.             <artifactId>spring-boot-starter-test</artifactId>
  56.             <scope>test</scope>
  57.         </dependency>
  58.     </dependencies>
  59. </project>

yaml 

  1. server:
  2.   port: 8001
  3. spring:
  4.   application:
  5.     name: cloud-payment-sleuth-service
  6.   zipkin:
  7.     base-url: http://localhost:9411/ #zipkin服务地址
  8.     sleuth:
  9.       sampler:
  10.         probability: 1 #采样率，0~1 ，1表示全部采集，一般使用 0.5
  11.  
  12. eureka:
  13.   client:
  14.     register-with-eureka: true #表示是否将自己注册进EurekaServer，默认为true
  15.     fetch-registry: true #是否从 EurekaServer 抓取自己有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
  16.     service-url:
  17.       #设置与 Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
  18.       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/ #集群 Eureka 配置
  19.   instance:
  20.     instance-id: ${spring.application.name}
  21.     prefer-ip-address: true #显示IP

主启动

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

 业务类

  1. @RestController
  2. @Slf4j
  3. public class PaymentController {
  4.  
  5.     @GetMapping("/payment/zipkin")
  6.     public String paymentZipkin() {
  7.         return "你好，我是服务提供者";
  8.     }
  9. }

2.3 服务消费者（调用方）

新建 Module：cloud-consumer-sleuth-order80

POM

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>cloud-study</artifactId>
  7.         <groupId>com.cloud.study</groupId>
  8.         <version>1.0</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.  
  12.     <artifactId>cloud-consumer-sleuth-order80</artifactId>
  13.  
  14.     <dependencies>
  15.         <!-- sleuth+zipkin 依赖 -->
  16.         <dependency>
  17.             <groupId>org.springframework.cloud</groupId>
  18.             <artifactId>spring-cloud-starter-zipkin</artifactId>
  19.         </dependency>
  20.         <!-- Eureka client -->
  21.         <dependency>
  22.             <groupId>org.springframework.cloud</groupId>
  23.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  24.         </dependency>
  25.         <!-- 引入自己的 cloud-api-commons 模块-->
  26.         <dependency>
  27.             <groupId>com.cloud.study</groupId>
  28.             <artifactId>cloud-api-commons</artifactId>
  29.             <version>${project.version}</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-web</artifactId>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-starter-actuator</artifactId>
  38.         </dependency>
  39.         <!--开启热部署-->
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             <artifactId>spring-boot-devtools</artifactId>
  43.             <scope>runtime</scope>
  44.             <optional>true</optional>
  45.         </dependency>
  46.         <!-- lombok -->
  47.         <dependency>
  48.             <groupId>org.projectlombok</groupId>
  49.             <artifactId>lombok</artifactId>
  50.             <optional>true</optional>
  51.         </dependency>
  52.         <!-- test -->
  53.         <dependency>
  54.             <groupId>org.springframework.boot</groupId>
  55.             <artifactId>spring-boot-starter-test</artifactId>
  56.             <scope>test</scope>
  57.         </dependency>
  58.     </dependencies>
  59. </project>

yaml

  1. server:
  2.   port: 80
  3.  
  4. spring:
  5.   application:
  6.     name: cloud-consume-sleuth-order
  7.   zipkin:
  8.     base-url: http://localhost:9411/ #zipkin服务地址
  9.     sleuth:
  10.       sampler:
  11.         probability: 1 #采样率，0~1 ，1表示全部采集，一般使用 0.5
  12.  
  13. eureka:
  14.   client:
  15.     register-with-eureka: true #表示是否将自己注册进EurekaServer，默认为true
  16.     fetch-registry: true #是否从 EurekaServer 抓取自己有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
  17.     service-url:
  18.       #设置与 Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
  19.       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/ #集群 Eureka 配置
  20.   instance:
  21.     instance-id: ${spring.application.name}
  22.     prefer-ip-address: true #显示IP

主启动

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

配置类

  1. @Configuration
  2. public class ApplicationConfig {
  3.     @Bean
  4.     @LoadBalanced //赋予RestTemplate负载均衡的能力
  5.     public RestTemplate getRestTemplate() {
  6.         return new RestTemplate();
  7.     }
  8. }

业务类

  1. @Slf4j
  2. @RestController
  3. public class OrderController {
  4.     private static final String PAYMENT_URL = "http://cloud-payment-sleuth-service";//要写微服务的注册名称，即服务提供者的 spring.application.name
  5.  
  6.     @Autowired
  7.     private RestTemplate restTemplate;
  8.  
  9.     @GetMapping("/consumer/payment/zipkin")
  10.     public String paymentZipkin() {
  11.         return restTemplate.getForObject(PAYMENT_URL+"/payment/zipkin", String.class);
  12.     }
  13. }

2.4 测试

分别启动 7001/7002 ，8001,80

多访问几次 http://localhost/consumer/payment/zipkin

打开 http://localhost:9411/  的依赖面板，可以看到链路调用。可以自行研究各个按钮的具体功能。

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号