SpringCloud之链路跟踪Sleuth

最新推荐文章于 2025-03-21 16:45:29 发布
最新推荐文章于 2025-03-21 16:45:29 发布
阅读量2.6w 收藏 35
点赞数 12
分类专栏： SpringCloud 文章标签： SpringCloud Sleuth Zipkin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41402200/article/details/94865516
版权

前言

  SpringCloud 是微服务中的翘楚，最佳的落地方案。

  在一个完整的微服务架构项目中，服务之间的调用是很复杂的，当其中某一个服务出现了问题或者访问超时，很

  难直接确定是由哪个服务引起的，所以就有了 Spring Cloud Sleuth 链路跟踪。通过它，我们就可以很清楚直观

  的了解每一个服务请求经过了哪些服务，用时多久，谁依赖谁或者被谁依赖。

源码

  GitHub地址：https://github.com/intomylife/SpringCloud

环境

  • JDK 1.8.0 +
  • Maven 3.0 +
  • SpringBoot 2.0.3
  • SpringCloud Finchley.RELEASE

开发工具

  • IntelliJ IDEA

正文

commons 工程

commons 工程 - POM 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 三坐标 -->
    <groupId>com.zwc</groupId>
    <artifactId>springcloud-sleuth-commons</artifactId>
    <version>1.0</version>

    <!-- 工程名称和描述 -->
    <name>springcloud-sleuth-commons</name>
    <description>公用工程</description>

    <!-- 打包方式 -->
    <packaging>jar</packaging>

    <!-- 在 properties 下声明相应的版本信息，然后在 dependency 下引用的时候用 ${} 就可以引入该版本 jar 包了 -->
    <properties>
        <!-- 编码 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- jdk -->
        <java.version>1.8</java.version>

        <!-- SpringBoot -->
        <platform-bom.version>Cairo-SR3</platform-bom.version>

        <!-- SpringCloud -->
        <spring-cloud-dependencies.version>Finchley.RELEASE</spring-cloud-dependencies.version>
    </properties>

    <!-- 加入依赖 -->
    <dependencies>

    </dependencies>

    <!-- 依赖 jar 包版本管理的管理器 -->
    <!-- 如果 dependencies 里的 dependency 自己没有声明 version 元素，那么 maven 就此处来找版本声明。 -->
    <!-- 如果有，就会继承它；如果没有就会报错，告诉你没有版本信息 -->
    <!-- 优先级：如果 dependencies 里的 dependency 已经声明了版本信息，就不会生效此处的版本信息了 -->
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot -->
            <dependency>
                <groupId>io.spring.platform</groupId>
                <artifactId>platform-bom</artifactId>
                <version>${platform-bom.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- SpringCloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud-dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 插件依赖 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 配置一些共用依赖

commons 工程 - 项目结构

 

service 工程

  ① 此工程下有五个模块：一个注册中心，一个网关、一个 Zipkin 服务以及两个提供者

  ② 在 SpringBoot 2.x 版本后就不推荐自定义 zipkin server 了，但是下面有使用官网下载的 jar 包方式，

      也有自定义的方式

  ③ Zipkin 也分为两部分，server 端和 client 端

  ④ server 端：收集数据，并展示

  ⑤ client 端：把调用信息发送给 server 端（本博客使用的 HTTP 报文的方式发送的信息）

  ⑥ 其中使用注册中心把服务连接起来，通过访问网关调用服务工程 A，服务工程 A 中使用的 Feign 调用服务

      工程 B，最后使用 Zipkin 把所有请求数据记录下来，并展示

 

registry-service（注册中心）

registry-service - POM 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 继承父 -->
    <parent>
        <groupId>com.zwc</groupId>
        <artifactId>springcloud-sleuth-service</artifactId>
        <version>1.0</version>
    </parent>

    <!-- 三坐标 -->
    <groupId>com.zwc</groupId>
    <artifactId>springcloud-sleuth-registry-service</artifactId>
    <version>1.0</version>

    <!-- 工程名称描述 -->
    <name>springcloud-sleuth-registry-service</name>
    <description>注册中心</description>

    <!-- 打包方式 -->
    <packaging>jar</packaging>

    <!-- 在 properties下声明相应的版本信息，然后在dependency下引用的时候用 ${} 就可以引入该版本jar包了 -->
    <properties>

    </properties>

    <!-- 加入依赖 -->
    <dependencies>
        <!-- 服务注册中心 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

    <!-- 插件依赖 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 主要是加入 spring-cloud-starter-netflix-eureka-server 依赖

registry-service - application.yml 配置文件

# 端口
server:
  port: 8761

# 应用名称
spring:
  application:
    name: eureka-server

eureka:
  instance:
    # 使用 ip 代替实例名
    prefer-ip-address: true
    # 实例的主机名
    hostname: ${spring.cloud.client.ip-address}
    # 实例的 ID 规则
    instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}
  client:
    # 是否向注册中心注册自己
    registerWithEureka: false
    # 是否向注册中心获取注册信息
    fetchRegistry: false
    serviceUrl:
      # 注册中心地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  • 这里使用了默认的 8761 端口，当然也可以更改，不过在发现调用服务端的注册中心地址端口要与它一致

registry-service - 启动类

package com.zwc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class SpringcloudSleuthRegistryServiceApplication {

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

}
  • 在启动类中添加 @EnableEurekaServer 注解表示此工程是注册中心

registry-service - 启动项目

  1. 项目启动成功后访问 http://localhost:8761/ 即可看到 eureka-server 主页面

 

master-service（zipkin 服务）

方式一：下载官网 jar 包

  1. 在浏览器中访问 https://zipkin.io/quickstart.sh

  2. 选择路径下载保存到本地（我保存到了桌面）

  3. 在桌面双击打开 quickstart.sh（刚刚下载保存的文件），会自动下载一个 jar 包

  4. 等待下载结束后，打开 cmd

  5. 输入命令 cd desktop -> 进入到桌面

  6. 输入命令 java -jar zipkin.jar -> 执行 jar 包，zipkin.jar 就是上面自动下载的 jar 包

  7. 启动成功后访问：http://localhost:9411 即可看到 Zipkin Server 主页面

方式二：自定义 Zipkin Server

master-service - POM 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 继承父 -->
    <parent>
        <groupId>com.zwc</groupId>
        <artifactId>springcloud-sleuth-service</artifactId>
        <version>1.0</version>
    </parent>

    <!-- 三坐标 -->
    <groupId>com.zwc</groupId>
    <artifactId>springcloud-sleuth-master-service</artifactId>
    <version>1.0</version>

    <!-- 工程名称描述 -->
    <name>springcloud-sleuth-master-service</name>
    <description>链路跟踪</description>

    <!-- 打包方式 -->
    <packaging>jar</packaging>

    <!-- 在 properties下声明相应的版本信息，然后在dependency下引用的时候用 ${} 就可以引入该版本jar包了 -->
    <properties>
        <!-- zipkin -->
        <zipkin.version>2.11.8</zipkin.version>
    </properties>

    <!-- 加入依赖 -->
    <dependencies>
        <!-- 提供者消费者 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!-- zipkin server -->
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-server</artifactId>
            <!-- 排除依赖 -->
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-log4j2</artifactId>
                </exclusion>
            </exclusions>
            <version>${zipkin.version}</version>
        </dependency>

        <!-- zipkin ui -->
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-autoconfigure-ui</artifactId>
            <version>${zipkin.version}</version>
        </dependency>
    </dependencies>

    <!-- 插件依赖 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 加入 spring-cloud-starter-netflix-eureka-client 依赖：提供和注册服务
  • 加入 zipkin-server 依赖：Zipkin 服务
  • 加入 zipkin-autoconfigure-ui 依赖：Zipkin UI

master-service - application.yml 配置文件

# 端口
server:
  port: 9411


spring:
  application:
    # 应用名称
    name: sleuth-zipkin-server

eureka:
  instance:
    # 使用 ip 代替实例名
    prefer-ip-address: true
    # 实例的主机名
    hostname: ${spring.cloud.client.ip-address}
    # 实例的 ID 规则
    instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}
  client:
    serviceUrl:
      # 注册中心地址
      defaultZone: http://${eureka.instance.hostname}:8761/eureka/

# 关闭自动配置启用所有请求得检测
management:
  metrics:
    web:
      server:
        # 避免访问 zipkin 页面报 java.lang.IllegalArgumentException
        auto-time-requests: false
  • 这里使用了默认的 9411 端口，当然也可以更改，不过在其他服务中配置的 zipkin 服务器的地址端口要与它一致
  • 注意配置注册中心地址的端口都为 8761 也就是上面注册中心工程配置的端口
  • Zipkin Server 可以不用注册到注册中心中

master-service - 启动类

package com.zwc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import zipkin2.server.internal.EnableZipkinServer;

@SpringBootApplication
@EnableEurekaClient
@EnableZipkinServer
public class SpringcloudSleuthMasterServiceApplication {

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

}
  • 添加 @EnableEurekaClient 注解表示此工程可以向注册中心提供服务

master-service - 启动项目

  1. 启动成功后访问：http://localhost:9411 即可看到 Zipkin Server 主页面

  2. 两种方式任选其一即可

 

gateway-service（网关）

gateway-service - POM 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 继承父 -->
    <parent>
        <groupId>com.zwc</groupId>
        <artifactId>springcloud-sleuth-service</artifactId>
        <version>1.0</version>
    </parent>

    <!-- 三坐标 -->
    <groupId>com.zwc</groupId>
    <artifactId>springcloud-sleuth-gateway-service</artifactId>
    <version>1.0</version>

    <!-- 工程名称描述 -->
    <name>springcloud-sleuth-gateway-service</name>
    <description>服务网关</description>

    <!-- 打包方式 -->
    <packaging>jar</packaging>

    <!-- 在 properties下声明相应的版本信息，然后在 dependency 下引用的时候用 ${} 就可以引入该版本 jar 包了 -->
    <properties>

    </properties>

    <!-- 加入依赖 -->
    <dependencies>
        <!-- 提供者消费者 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!-- gateway -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>

        <!-- zipkin client -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
    </dependencies>

    <!-- 插件依赖 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 加入 spring-cloud-starter-netflix-eureka-client 依赖：提供和注册服务
  • 加入 spring-cloud-starter-gateway 依赖：gateway
  • 加入 spring-cloud-starter-zipkin 依赖：zipkin client

gateway-service - application.yml 配置文件

# 端口
server:
  port: 8000

spring:
  application:
    # 应用名称
    name: sleuth-gateway

  cloud:
    gateway:
      discovery:
        locator:
          # 是否和服务注册与发现组件结合，设置为 true 后可以直接使用应用名称调用服务
          enabled: true
      # 路由（routes：路由，它由唯一标识（ID）、目标服务地址（uri）、一组断言（predicates）和一组过滤器组成（filters）。filters 不是必需参数。）
      routes:
      # 路由标识（id：标识，具有唯一性）
      - id: route_simple
        # 目标服务地址（uri：地址，请求转发后的地址）
        uri: http://localhost:8090/aUseB
        # 路由条件（predicates：断言，匹配 HTTP 请求内容）
        predicates:
        ## 匹配 GET 请求
        - Method=GET

  zipkin:
      # 指定了 zipkin 服务器的地址
      base-url: http://${spring.cloud.client.ip-address}:9411
  sleuth:
    sampler:
      # 将采样比例设置为 1.0，也就是全部都需要。默认是 0.1
      probability: 1.0

eureka:
  instance:
    # 使用 ip 代替实例名
    prefer-ip-address: true
    # 实例的主机名
    hostname: ${spring.cloud.client.ip-address}
    # 实例的 ID 规则
    instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}
  client:
    serviceUrl:
      # 注册中心地址
      defaultZone: http://${eureka.instance.hostname}:8761/eureka/

logging:
  level:
    # log 级别
    org.springframework.cloud.gateway: debug
  • 注意配置注册中心地址的端口都为 8761 也就是上面注册中心工程配置的端口
  • 注意配置 zipkin 服务器地址为 9411 也就是上面 zipkin-service 工程配置的端口
  • 此处配置的路由为访问网关地址 http://localhost:8000/ 会被转发到 http://localhost:8090/aUseB

gateway-service - 启动类

package com.zwc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class SpringcloudSleuthGatewayServiceApplication {

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

}
  • 添加 @EnableEurekaClient 注解表示此工程可以向注册中心提供服务

gateway-service - 启动项目

  1. 暂不启动

 

a-service（服务工程 A）

a-service - POM 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 继承父 -->
    <parent>
        <groupId>com.zwc</groupId>
        <artifactId>springcloud-sleuth-a-service</artifactId>
        <version>1.0</version>
    </parent>

    <!-- 三坐标 -->
    <groupId>com.zwc</groupId>
    <artifactId>springcloud-sleuth-a-service-core</artifactId>
    <version>1.0</version>

    <!-- 工程名称描述 -->
    <name>springcloud-sleuth-a-service-core</name>
    <description>服务工程 - A 核心</description>

    <!-- 打包方式 -->
    <packaging>jar</packaging>

    <!-- 在 properties下声明相应的版本信息，然后在dependency下引用的时候用 ${} 就可以引入该版本jar包了 -->
    <properties>

    </properties>

    <!-- 加入依赖 -->
    <dependencies>
        <!-- commons工程 依赖 -->
        <dependency>
            <groupId>com.zwc</groupId>
            <artifactId>springcloud-sleuth-commons</artifactId>
            <version>1.0</version>
        </dependency>

        <!-- api工程 依赖 -->
        <dependency>
            <groupId>com.zwc</groupId>
            <artifactId>springcloud-sleuth-a-service-api</artifactId>
            <version>1.0</version>
        </dependency>

        <!-- springboot web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 提供者消费者 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!-- feign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <!-- zipkin client -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
    </dependencies>

    <!-- 插件依赖 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
  • 加入 spring-cloud-starter-netflix-eureka-client 依赖：提供和注册服务
  • 加入 spring-cloud-starter-openfeign 依赖：调用服务
  • 加入 spring-cloud-starter-zipkin 依赖：zipkin client

a-service - application.yml 配置文件

# 端口
server:
  port: 8090

spring:
  application:
    # 应用名称
    name: sleuth-a
  zipkin:
      # 指定了 zipkin 服务器的地址
      base-url: http://${spring.cloud.client.ip-address}:9411
  sleuth:
    sampler:
      # 将采样比例设置为 1.0，也就是全部都需要。默认是 0.1
      probability: 1.0

eureka:
  instance:
    # 使用 ip 代替实例名
    prefer-ip-address: true
    # 实例的主机名
    hostname: ${spring.cloud.client.ip-address}
    # 实例的 ID 规则
    instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}
  client:
    serviceUrl:
      # 注册中心地址
      defaultZone: http://${eureka.instance.hostname}:8761/eureka/
  • 注意配置注册中心地址的端口都为 8761 也就是上面注册中心工程配置的端口
  • 注意配置 zipkin 服务器地址为 9411 也就是上面 zipkin-service 工程配置的端口
  • spring.application.name：应用名称，被消费者调用时需要用到，它在消费的同时也可以被消费

a-service - bootstrap.yml（注意）

feign:
  hystrix:
    # 开启断路器
    enabled: true
  • 断路器要主动开启，服务调用失败时才会熔断
  • 此处有一个坑，把此配置写到 application.yml 中熔断不会生效

a-service - controller 前端控制器（提供服务）

package com.zwc.a.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/*
 * @ClassName ASayHelloController
 * @Desc TODO   Say Hello
 * @Date 2019/5/20 23:24
 * @Version 1.0
 */
@RestController
public class ASayHelloController {

    /*
     * @ClassName ASayHelloController
     * @Desc TODO   读取配置文件中的端口
     * @Date 2019/5/20 23:24
     * @Version 1.0
     */
    @Value("${server.port}")
    private String port;

    /*
     * @ClassName ASayHelloController
     * @Desc TODO   Say Hello
     * @Date 2019/5/20 23:24
     * @Version 1.0
     */
    @RequestMapping("/a")
    public String a(){
        return "Hello！I'm a. port：" + port;
    }

}
  • 提供一个服务：输出 Hello 和端口

a-service - 服务调用

package com.zwc.a.api.feign;

import com.zwc.a.api.impl.FeignApiFallBack;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;

/*
 * @ClassName FeignApi
 * @Desc TODO   使用 Feign 调用 b - 接口
 * @Date 2019/5/20 23:21
 * @Version 1.0
 */
@FeignClient(value = "sleuth-b" , fallback = FeignApiFallBack.class)
public interface FeignApi {

    /*
     * @ClassName FeignApi
     * @Desc TODO   通过 sleuth-b 服务名调用 b() 方法
     * @Date 2019/5/20 23:21
     * @Version 1.0
     */
    @RequestMapping("/b")
    String b();

}
  • 通过 @FeignClient 注解中 value = "sleuth-b" 来指定调用哪个服务
  • sleuth-b 就是提供者（服务工程 B）的 spring.application.name：应用名称
  • 通过 @FeignClient 注解中 fallback = FeignApiFallBack.class 来指定熔断时调用的方法
  • FeignApiFallBack 就是此接口（FeignApi）的实现类，对应的实现方法就是熔断时调用的方法
  • b()：此方法是 B 工程中提供的服务，在这里定义成接口
  • 注意要与提供者具有相同返回值，相同方法名以及相同参数

a-service - Fallback（FeignApiFallBack）

package com.zwc.a.api.impl;

import com.zwc.a.api.feign.FeignApi;
import org.springframework.stereotype.Component;

/*
 * @ClassName FeignApi
 * @Desc TODO   fallback
 * @Date 2019/5/20 23:21
 * @Version 1.0
 */
@Component
public class FeignApiFallBack implements FeignApi {

    /*
     * @ClassName FeignApiFallBack
     * @Desc TODO   调用 sleuth-b 服务中的 b() 方法失败时执行
     * @Date 2019/5/20 23:31
     * @Version 1.0
     */
    @Override
    public String b() {
        return "Hello！aUseB fail";
    }
}
  • 使用 @Component 注解把此类交给 Spring 管理
  • 实现了 FeignApi 接口，提供熔断时对应的方法

a-service - controller 前端控制器（消费服务）

package com.zwc.a.controller;

import com.zwc.a.api.feign.FeignApi;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/*
 * @ClassName AUseBFeignController
 * @Desc TODO   使用 Feign 调用 b - 前端控制器
 * @Date 2019/5/20 23:23
 * @Version 1.0
 */
@RestController
public class AUseBFeignController {

    @Autowired(required = false)
    private FeignApi feignApi;

    /*
     * @ClassName FeignController
     * @Desc TODO   通过 sleuth-b 服务名调用 b() 方法
     * @Date 2019/5/20 23:13
     * @Version 1.0
     */
    @RequestMapping("/aUseB")
    public String aUseB(){
        return feignApi.b();
    }

}
  • 使用 @Autowired 注解装配 Bean，通过此 Bean 中的方法调用服务
  • 此类对外暴露接口，调用的实则是提供者（服务工程 B）的服务

a-service - 启动类

package com.zwc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class SpringcloudSleuthAServiceCoreApplication {

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

}
  • 添加 @EnableEurekaClient 注解表示此工程可以向注册中心提供服务
  • 添加 @EnableFeignClients 注解表示开启 Feign 功能进行远程调用

a-service - 启动项目

  1. 暂不启动

 

b-service（服务工程 B）

  ① 此工程与服务工程 A 类似

  ② application.yml 配置文件中端口与应用名称与服务工程 A 不一致

  ③ 服务工程 B 只提供服务，所以不引入 feign

b-service - 启动项目

  1. 暂不启动

 

启动项目

  1. 启动注册中心工程（registry-service）

  2. 项目启动成功后访问：http://localhost:8761/ 即可看到 eureka-server 主页面

  3. 启动 Zipkin Server 工程（master-service）或者启动官网 zipkin.jar 包

  4. 启动成功后访问：http://localhost:9411 即可看到 Zipkin Server 主页面

  5. 启动网关工程（gateway-service）、服务工程 A（a-service）以及服务工程 B（b-service）

  6. 项目都启动成功后，首先访问：http://localhost:8090/a（调用自己的服务）

  7. 输出内容：'Hello！I'm a. port：8090'

  8. 回到 Zipkin Server 主页面，点击 Find Traces 蓝色按钮

  9. 可以看到有一条服务调用信息

 10. 点击上面的 Dependencies，查看依赖关系

 11. 发现没有任何依赖关系，是因为服务工程 A 自己调用了自己的服务

 12. 这时再访问：http://localhost:8090/aUseB（调用服务工程 B 的服务）

 13. 输出内容：'Hello！I'm b. port：8091'

 14. 回到 Zipkin Server 主页面，点击 Find Traces 蓝色按钮

 15. 发现多了一条服务调用信息

 16. 点击上面的 Dependencies，再次查看依赖关系

 17. 发现刚刚通过服务工程 A 调用的服务工程 B 的关系图就出来了

 18. 访问网关：http://localhost:8000/

 19. 输出内容：'Hello！I'm b. port：8091'

 20. 再次回到 Zipkin Server 主页面，点击 Find Traces 蓝色按钮

 21. 发现又多了一条服务调用信息

 22. 点击上面的 Dependencies，再次查看依赖关系

 23. 访问网关通过路由转发到服务工程 A，服务工程 A 又通过 Feign 调用服务工程 B

 

service 工程 - 项目结构

 

把多工程项目使用 IntelliJ IDEA 打开

  1. 把项目从 GitHub 中下载到你的本地
  2. 打开 IntelliJ IDEA 
  3. 点击 File -> Open
  4. 打开你下载到本地的项目目录
  5. springcloud-sleuth -> springcloud-sleuth-service（选择打开此工程）
  6. 打开 service 工程后
  7. 再次点击 File -> Project Structrue
  8. 选择 Modules，点击 '+' 符号
  9. 点击 Import  Module
  10. 还是打开你下载到本地的项目目录
  11. springcloud-sleuth -> springcloud-sleuth-commons -> pom.xml
  12. 点击 OK
  13. 点击 Next，Finish
  14. 点击 Apply，OK

 

 

希望能够帮助到你

over

 

 

 

七，Spring Cloud Sleuth链路追踪
weixin_42688085的博客
03-01 328
写在前面的话：本文大部分（说全部也没问题）都是抄写的，课堂的资料给的特别好。感觉耻于提笔，但不写上就影响整个博客内容了。以后会改/写出我的笔记的。 感谢你的路过，希望学生的笔记能给你一点微不足道的参考（2/100） Java基础思维导图，完整Java体系的链接 微服务部分内容链接。感谢开课吧。 大概十几个文章吧 7.1 链路追踪简介 7.1.1 为什么需要链路追踪    微服务架构是一个分布式架构，它按业务划分服务单元，一个分布式系统往往有很多个服务单元。由于服务单元数量众多，
springcloud实战：服务链路追踪Sleuth
2401_84010457的博客
04-18 518
下面我们就来分别实现服务端和客户端。以前，我们需要自己实现Zipkin服务端，但从Spring Boot 2.0以后，官方推出了Zipkin服务端，我们只需要把下载好的服务端jar包放到服务器上启动即可。具体操作如下。(1)从网络上下载Zipkin服务端的可执行jar包，下载地址: https:/repo1.maven.org/maven2/io/zipkin/java/zipkin-server/2.9.4/zipkin-server-2.9.4-exec.jar。
Spring Cloud之（十九）微服务的链路追踪
qq_50994235的博客
09-27 846
十九、微服务的链路追踪 19.1 微服务架构下的问题 在大型系统的微服务化构建中，一个系统会被拆分成许多模块。这些模块负责不同的功能，组合成系统，最终可以提供丰富的功能。在这种架构中，一次请求往往需要涉及到多个服务。互联网应用构建在不同的软件模块集上，这些软件模块，有可能是由不同的团队开发、可能使用不同的编程语言来实现、有可能布在了几千台服务器，横跨多个不同的数据中心，也就意味着这种架构形式也会存在一些问题： 如何快速发现问题？ 如何判断故障影响范围？ 如何梳理服务依赖以及依赖的合理性？ 如何分析链路性能
一文读懂Spring Cloud Sleuth：分布式链路追踪利器
最新发布
huaqianzkh的专栏
03-21 514
Spring Cloud Sleuth的核心价值‌：快速排障‌：通过TraceID串联分布式日志性能洞察‌：精确统计各服务处理耗时架构治理‌：可视化服务依赖关系通过简单的依赖引入和配置，开发者即可获得生产级的链路追踪能力。结合Zipkin等可视化工具，Sleuth成为微服务可观测性体系的重要基石。
微服务—链路追踪（Sleuth+Zipkin）
热门推荐
shi_AXing_a的博客
05-27 1万+
这里写自定义目录标题1、链路追踪介绍2、为什么需要链路追踪?2.1、那该如何解决呢？2.2、常见的链路追踪技术有下面这些：3、Sleuth3.1、Sleuth介绍3.2、相关术语3.3、Sleuth入门4、Zipkin4.1、ZipKin介绍4.2、ZipKin服务端安装4.3、Zipkin客户端集成4.4、ZipKin数据持久化4.4.1使用mysql实现数据持久化 1、链路追踪介绍 在大型系统的微服务化构建中，一个系统被拆分成了许多模块。这些模块负责不同的功能，组合成系统，最终可以提供丰富的功能。在这种
Spring Cloud Sleuth：分布式链路跟踪
qq_35763697的博客
02-20 1975
Spring Cloud Sleuth：分布式链路跟踪
Spring Cloud Sleuth 链路追踪
一树一菩提的博客
02-06 865
清晰地记录服务的调用链路是一个需要解决的问题。同时，由于各种原因，跨进程的服务调用失败时，运维人员希望能够通过查看日志和查看服务之间的调用关系来定位问题，而Spring cloud sleuth组件正是为了解决微服务跟踪的组件。一、背景单纯的理解链路追踪，就是将一次分布式请求还原成调用链路，进行日志记录，性能监控并将一次分布式请求的调用情况集中展示。比如各个服务节点上的耗时、请求具体到达哪台机器上、每个服务节点的请求状态等等。
详解spring cloud分布式日志链路跟踪
08-27
在Spring Cloud体系中，链路跟踪的实现一般依赖于Spring Cloud Sleuth与Zipkin。Spring Cloud Sleuth类似于一个中间件，可以在微服务调用过程中，将每个服务的调用记录下来。它会在日志中添加一些特有的标签，如...
SpringCloud服务链路追踪(Spring-Cloud-Sleuth)文档
07-21
### Spring Cloud Sleuth服务链路追踪详解 #### 一、Spring Cloud Sleuth简介 Spring Cloud Sleuth 是一款针对微服务架构中的服务链路追踪工具，主要用于解决分布式系统中服务调用链路的追踪问题。通过引入Sleuth...
SpringCloud分布式链路跟踪的方法
08-26
【SpringCloud分布式链路跟踪的方法】 在微服务架构中，SpringCloud分布式链路跟踪是解决服务间调用跟踪和故障排查的关键技术。通过这种方式，开发者可以了解整个服务调用链路，从而快速定位和解决问题。 ### 日志...
SpringCloudSleuth链路跟踪
明月为卿的博客
12-24 1457
sleuth生产链路日志 随着系统规模越来越大，微服务之间调用关系变得错综复杂，一条调用链路中可能调用多个微服务，任何一个微服务不可用都可能造整个调用过程失败 spring cloud sleuth 可以跟踪调用链路，分析链路中每个节点的执行情况 添加依赖后，被请求路过的每个微服务都会在控制台产生一个日志： [服务id,请求id,span id,是否发送到zipkin] **请求ID：**请求到达第一个微服务时生成一个请求id，该id在调用链路中会一直向后面的微服务传递 **span ID：**链路中每一步
微服务 SpringCloud Sleuth链路追踪
靖节先生的博客
02-09 633
微服务 SpringCloud Sleuth链路追踪一、Sleuth概述1.概述2.是什么二、zipkin概述1.下载2.运行3.监控三、案例验证1.服务提供者2.服务消费者3.监控效果 一、Sleuth概述 1.概述 在微服务架构中，不同服务之间的调用错综复杂，当一个客户端发起请求后，在后端往往需要经过很多个不同的服务节点经过协同调用才能产生结果，后端不同服务之间的调用会形成一条复杂的分布式服务调用链路，链路中任何一个环节出现延时或者错误都会引起整个请求失败。 比如，订单调用支付，调用积分，调用库存，调用
第七章 Spring Cloud Sleuth链路追踪
ReZero_486的博客
03-23 2728
7.1 链路追踪简介 7.1.1 为什么需要链路追踪 微服务架构是⼀个分布式架构，它按业务划分服务单元，⼀个分布式系统往往有很多个服务单元。 由于服务单元数量众多，业务的复杂性，如果出现了错误和异常，很难去定位。主要体现在，⼀个请求可能需要调⽤很多个服务，⽽内部服务的调⽤复杂性，决定了问题难以定位。所以微服务架构中，必须实现分布式链路追踪，去跟进⼀个请求到底有哪些服务参与，参与的顺序⼜是怎样的，从⽽达到每个请求的步骤清晰可⻅，出了问题，很快定位。 举个例⼦，在微服务系统...
Spring Cloud Sleuth在分布式中进行日志跟踪
怪咖@的博客
09-01 2275
Sleuth是什么？Zipkin是什么？他们两个是什么关系？Sleuth怎么用？Zipkin怎么用？Zipkin怎么配置持久化？怎么修改Sleuth发消息方式？引入sleuth是怎么输出traceId的？除了Zipkin还有哪些链路跟踪？针对于这些问题本篇文章会一一讲解！
SpringCloud Sleuth分布式链路跟踪
weixin_44302046的博客
05-25 537
目录 1、概述 1.1、现有问题 1.1.1、微服务框架中请求处理过程 1.1.2、造成问题 1.2、解决方法 2、实例 2.1、zipkin 2.1.1、下载 2.1.2、运行 2.1.3、运行控制台 2.2、服务提供者 2.2.1、POM文件 2.2.2、yaml配置文件 2.2.3、Controller 2.3、 服务消费者 2.3.1、POM和yaml文件同服务提供者 2.3.2、Controller 2.4、测试 1、概述 1.1、现有问题 1.1.1
SpringCloud 基础——Sleuth 链路追踪
贵在坚持
03-10 384
通过服务的的调用链路追踪，我们可以更快速地发现错误根源，也可用来监控分析链路的性能。 springcloud 提供了 sleuth 组件为微服务架构提供了分布式服务跟踪的能力。
【SpringCloud Alibaba】（十一）学习 Sleuth 链路追踪
sco5282的博客
09-01 1416
随着互联网业务快速扩展，企业的业务系统变得越来越复杂，不少企业开始向分布式、微服务方向发展，将原本的单体应用拆分成分布式、微服务。这也使得当客户端请求系统的接口时，原本在同一个系统内部的请求逻辑变成了需要在多个微服务之间流转的请求。单体架构中可以使用 AOP 在调用具体的业务逻辑前后分别打印一下时间即可计算出整体的调用时间，使用 AOP 捕获异常也可知道是哪里的调用导致的异常。
史上最简单的SpringCloud教程 | 第九篇: 服务链路追踪(Spring Cloud Sleuth)
weixin_30423977的博客
04-13 2466
转载请标明出处： 原文首发于：https://www.fangzhipeng.com/springcloud/2017/07/12/sc09-sleuth/ 本文出自方志朋的博客 最新Finchley版本请访问： https://www.fangzhipeng.com/springcloud/2018/08/30/sc-f9-sleut...
Spring Cloud Sleuth分布式请求链路跟踪详解
Spring Cloud Sleuth 分布式请求链路跟踪工具 Spring Cloud Sleuth 是一个分布式系统中跟踪服务间调用的工具，它可以直观地展示出一次请求的调用过程。随着我们的系统越来越庞大，各个服务间的调用关系也变得越来越...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值