# SpringCloud

# 零、SpringCloud

# 0.1 微服务

微服务：是面向服务开发（SOA）的一种架构思维，主要是把一个大项目拆解为多个独立的小项目（服务）。每个小项目（服务），独立编码，独立部署和运行。

核心：1. 分而治之 2. 各司其职 3. 服务的高可用和可扩展性

微服务其实就是将一个项目按照功能模块（水平拆分）进行拆分，拆分为不同的服务，服务之间通过 http 请求完成调用

SpringCloud Alibaba

注册中心：nacos 作用：管理服务，实现服务的注册与发现 使用：注解 @EnableDiscoveryClient + 配置 (application)

配置中心：nacos 作用： 管理配置，实现配置的动态化管理，可以不用更改代码，实现不停机更新 使用：注解 @RefreshScope + 配置 (Nacos 配置管理 新建配置 Data ID 服务名一样)+ 配置 (Bootstrap)

远程调用：OpenFeign 作用：调用服务，实现服务间通信 使用：注解 @EnableFeignClients+@FeignClient

网关中心：gateway 作用：网关，实现服务的聚合统一接口，对请求过滤 使用：配置 + 接口 GlobalFilter

流量控制：Sentinel 作用：流控和熔断降级，流控就是流量控制，防止高并发导致服务器压力过大，熔断降级就是对核心方法的一种保护，如果核心方法出现问题可以立即响应保证可用性 使用：配置 (Sentinel 可视化 流控、熔断)

链路跟踪：Sleuth+Zipkin 作用：实现微服务下一次请求的完成过程的日志记录，实现服务间的调用关系 使用：配置

# 0.2 微服务技术方案

1.Dubbo（阿里巴巴，开源到 apache）：2012 面世，2014 停更；2015 底阿里巴巴宣布继续更新。Dubbox（即 Dubbo eXtensions，当当网基于 Dubbo 的扩展）

2.Spring Cloud（Spring）2016 年（曾经是 SpringCloud Netfiex 现如今是 SpringCloud + Aliababa）

3.ServiceComb（华为，开源到 apache，在公司内部叫 cse） 2017 年

4.Lstio（服务网格化 由谷歌、IBM 与 Lyft 合作开源）(uml.org.cn/wfw/201909063.asp)，2017 年 5 月发布

5.HSF (阿里内部使用的，面向企业收费):https://help.aliyun.com/document_detail/149498.html

# 一、Nacos

# 1.1 Nacos 是什么

Nacos: 阿里巴巴开源的，专门用来解决微服务中的服务管理和配置管理的软件。

主要用在微服务项目中，实现在微服务中，各个服务的管理，还可以实现动态配置管理的功能

官网地址：https://nacos.io/zh-cn/

# 1.2 Nacos 的作用

1. 注册中心 - 服务管理

​ 服务可以注册和发现，并且实现服务的实时状态监听（心跳连接）

2. 配置中心 - 配置管理

​ 实现项目中的配置的动态化管理，实现配置改变项目自动生效，无需重新发布项目

3. 可视化设置 - 动态 DNS 服务

​ 实现服务的负载均衡，流控访问控制等

# 1.3 安装 Nacos

​ 1. 下载 nacos

​ 2. 修改启动模式

​ windows 系统 startup.cmd 中，mac 或 linux 是在 startup.sh 中

​ 修改启动模式为：standalone

​ export MODE="cluster" 更改为 export MODE="standalone"

​ 3. 启动

​ 双击 startup.cmd （Windows 系统）

​ 如果闪退：

​ 1. 检查是否配置 jdk

​ 2. 右键管理员启动

​ 3. 查看日志，上网搜搜

​ 4. 访问

​ http://localhost:8848/nacos

#

# 1.3 Nacos 注册中心

# 1.3.1 注册中心

微服务的灵魂：就是服务，那么服务怎么管理？就需要使用注册中心，来完成服务的管理

目前市面上有哪些注册中心：Nacos、Zookeeper、Eureka、Consul……

我们选择 Nacos，首先：阿里巴巴开源，在阿里内部已经被使用 其次：功能强大，性能稳定 最后：活跃度高，和 SpringCloud 匹配度高

注册中心的作用：实现服务的管理，发现和注册服务，并监听服务的可用性

# 1.3.2 基于 Nacos 实现注册中心

0. 搭架子

Maven 多模块开发

一般都会有 common 公共项目、服务提供者:provider、server、服务消费者：不是必须的

1. 服务提供者

​ 1. 依赖 jar

<!--        依赖 Nacos 注册中心 -->

        <dependency>

            <groupId>com.alibaba.cloud</groupId>

            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>

            <version>2021.1</version>

        </dependency>

​ 2. 实现配置

​ 在 application.yml 实现 nacos 地址的配置

spring:

  cloud:

    nacos:

      discovery: #注册中心

        server-addr: 127.0.0.1:8848

  application:

    name: Hello-provider-lx # 服务起个名，名称唯一

​ 在开关类，使用注解标记服务的注册

@SpringBootApplication
@EnableDiscoveryClient //注册或发现服务 就会注册服务到注册中心
public class ProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class,args);
    }
}

​ 3. 编写代码

​ 服务直接暴露的是控制层

@RestController
public class HelloController {
    @GetMapping("h1")
    public R hi(){
        return new R(0,"OK","当前时间："+System.currentTimeMillis());
    }
}

​ 4. 运行测试

# 1.3.3 注册中心核心

1. 注解

@EnableDiscoveryClient 修饰类，作用：发现和注册服务

2. 配置

1. 项目（服务）需要有个名字，在注册中心中，需要唯一

2. 配置 Nacos 的地址

# 1.4 Nacos 配置中心

# 1.5 Nacos 底层原理

# 二、OpenFeign

# 2.1 OpenFeign 是什么

Openfeign: 是一种声明式的 web 工具，可以使用它的注解创建接口，从而实现服务的远程调用

OpenFeign 是基于 Feign 的二次开发，主要用来进行远程调用

RPC: 远程过程通信，2 个程序的调用，可能是相同语言，也可能不同的语言

我们在微服务开发中，采用 OpenFeign 进行服务的调用

# 2.2 OpenFeign 的使用

1. 依赖 jar

<!--        注册中心 -->

        <dependency>

            <groupId>com.alibaba.cloud</groupId>

            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>

            <version>2021.1</version>

        </dependency>

<!--        负载均衡 -->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-loadbalancer</artifactId>

        </dependency>

<!--        远程调用 -->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-openfeign</artifactId>

        </dependency>

2. 实现配置

在 application.yml 中完成

spring:

  application:

    name: lx-consumer

  cloud:

    nacos:

      discovery:

        server-addr: 127.0.0.1:8848

  mvc:

    pathmatch:

      matching-strategy: ant_path_matcher

server:

  port: 9092

在开关类上，使用注解

@SpringBootApplication
@EnableDiscoveryClient //注册服务
@EnableFeignClients //启用OpenFeign
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

3. 编写代码

远程调用接口层

@FeignClient(value = "lx-provider") //通过OpenFeign调用，远程服务，指定服务名
public interface WeatherService {
    /**
     * 指定要远程调用的 方法
     * 要求：
     * 1.返回值 需要和远程服务一样
     * 2.请求方式 必须一样
     * 3.请求路径 必须对
     * 4.请求参数 类型、顺序一致 (request和response 不写)*/
    @GetMapping("server/weather/today")
    R today();
}

控制层

@RestController
@Api(tags = "天气管理")
public class WeatherController {
    @Resource
    private WeatherService service;

    @GetMapping("api/weather/today")
    public R today(){
        return service.today();
    }
}

4. 运行测试

# 2.3 OpenFeign 的核心

# 2.3.1 注解

@EnableFeignClients 修饰类，作用：启用 Openfeign 就会扫描，如果找到带有 @FeignClient 就会自动生成接口的实现类（动态代理）

@FeignClient 修饰类，作用：设置要请求的服务，和请求的一些设置

示例：

@FeignClient(value = "lx-provider") //通过OpenFeign调用，远程服务，指定服务名
public interface WeatherService {
    /**
     * 指定要远程调用的 方法
     * 要求：
     * 1.返回值 需要和远程服务一样
     * 2.请求方式 必须一样
     * 3.请求路径 必须对
     * 4.请求参数 类型、顺序一致 (request和response 不写)*/
    @GetMapping("server/weather/today")
    R today();
}

# 2.3.2 参数传递

OpenFeign 调用参数的时候，需要使用注解进行标记

根据参数格式不一样，使用的注解也不一样：

1. 键值对：@RequestParam ("参数名")

2.json：@RequestBody

3. 文件上传：@RequestPart ("参数名")

示例：

@FeignClient(value = "lx-provider")
public interface FoodService {
    /**
     * json格式 @RequestBody*/
    @PostMapping("server/food/save")
    R save(@RequestBody FoodAddDto dto);
    /**
     * 键值对格式 @RequestParam("参数名")
     * 接口请求 参数格式：键值对的时候，需要添加注解，指定参数名称 不可省略*/
    @GetMapping("server/food/page")
    R page(@RequestParam("page") int page,@RequestParam("size") int size);
}

# 2.3.3 请求消息头传输

OpenFeign 请求接口的时候，默认不会传输请求消息头，这样就导致我们定义的请求消息头不能被传递到服务提供者。

为什么不会传输？

因为 OpenFeign 请求接口的时候，是重新发起的请求，会生成本次请求的 request 和 response，跟原来那么请求对象不是同一个

怎么解决？

需要把要传输的请求消息头，添加到 OpenFeign 的请求中

自定义一个类，设置一下即可

实现步骤：

1. 定义类，实现接口

public class OpenFeignConfig implements RequestInterceptor {
    @Override
    public void apply(RequestTemplate template) {
        //1.获取请求对象
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request=attributes.getRequest();

        //2.把需要传递的请求消息头传输给OpenFeign
        template.header("token",request.getHeader("token"));
        //……
    }
}

2. 在 OpenFeign 的接口上设置配置类即可

@FeignClient 的 configuration 设置即可

@FeignClient(value = "lx-provider",configuration = OpenFeignConfig.class) // 通过 OpenFeign 调用，远程服务，指定服务名

public interface WeatherService {

    /**

     * 指定要远程调用的 方法

     * 要求：

     * 1. 返回值 需要和远程服务一样

     * 2. 请求方式 必须一样

     * 3. 请求路径 必须对

     * 4. 请求参数 类型、顺序一致 (request 和 response 不写)*/

    @GetMapping("server/weather/today")

    R today();

    @GetMapping("check")

    R check();

}

# 2.3.4 文件上传

如果 OpenFeign 调用的接口的参数是：MultipartFile 文件上传的

那么需要安装下面的步骤进行

/**
 * 文件上传的参数 需要配置
 * 1.注解 @RequestPart
 * 2.设置 请求属性：consumes = MediaType.MULTIPART_FORM_DATA_VALUE  */
@PostMapping(value = "server/food/import",consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
R importExcel(@RequestPart("file") MultipartFile file);

核心：

1.MultipartFile 参数 使用注解 @RequestPart ("file")

2. 设置请求属性：consumes = MediaType.MULTIPART_FORM_DATA_VALUE

# 2.4 OpenFeign 的底层原理

# 三、微服务核心案例

# 3.1 需求

请实现一个，每日只能预约 10 个，不能超出，每个用户每日只能预约 1 个。

主要：

1. 注册

2. 登录

3. 预约

4. 预约列表

5. 查询剩余预约数量

6. 查询自己的预约记录

用户表：id name password ctime

预约记录表：id uid bdate ctime

SQL 脚本：

create table t_user01

          (

              id int primary key auto_increment,

              name varchar(20),

              password varchar(300),

              ctime datetime

          )

[2023-10-10 16:12:06] completed in 69 ms

db_j2310> create table t_user_book

          (

              id int primary key auto_increment,

              uid int,

              bdate date,

              ctime datetime

          )

选择微服务架构，为了未来可能的高并发

# 3.2 搭架子

Maven 多模块进行开发

# 3.3 提供者 - 编码

主要实现业务逻辑

实体层

持久层

业务层

接口层

# 3.4 消费者 - 编码

就是实现服务的远程调用，提供对外暴露的接口

# 3.5 测试

# 四、Gateway

# 4.1 网关

网关为微服务架构的系统提供简单、有效且统一的 API 路由管理，作为系统的统一入口，提供内部服务的路由中转，给客户端提供统一的服务，可以实现一些和业务没有耦合的公用逻辑，主要功能包含认证、鉴权、路由转发、安全策略、防刷、流量控制、监控日志等。

# 4.2 Gateway

Gateway 就是微服务项目提供一种简单有效的统一的 API 路由管理方式并且可以对请求进行过滤处理。

优点

性能强劲，是 Zuul 的 1.6 倍 功能强大，内置了很多实用的功能，例如转发、监控、限流等设计优雅，容易扩展

缺点

依赖 Netty 与 WebFlux，不是传统的 Servlet 编程模型，有一定的学习成本不能在 Servlet 容器下工作，也不能构建成 WAR 包，即不能将其部署在 Tomcat、Jetty 等 Servlet 容器里，只能打成 jar 包执行 不支持 Spring Boot 1.x， 需 2.0 及更高的版本

Getway 核心的作用：

1. 服务路由匹配

​ 可以根据请求匹配到对应的服务

2. 对请求进行过滤处理

​ 支持全局过滤器

# 4.3 Gateway 核心

# 4.3.0 多服务的项目

拼多多项目

根据功能模块，划分为多个服务

1. 认证服务（注册、登录、密码找回等）

2. 用户服务（用户个人信息、签到、积分、等级）

3. 商品服务（商品信息、榜单、列表、详情等等）

4. 订单服务（下单相关业务）

核心结构：

# 4.3.1 网关路由匹配

目前都是使用的 Path 匹配，路径匹配，通过访问路径匹配对应的服务

路由（Route）是 GateWay 中最基本的组件之一，表示一个具体的路由信息载体，主要由下面几个部分组成：

1. id：路由唯一标识，区别于其他的 route
2. url： 路由指向的目的地 URL，客户端请求最终被转发到的微服务
3. order： 用于多个 Route 之间的排序，数值越小越靠前，匹配优先级越高
4. predicate：断言的作用是进行条件判断，只有断言为 true，才执行路由
5. filter: 过滤器用于修改请求和响应信息

实现步骤：

1. 创建网关项目

2. 依赖 jar

<dependencies>

    <dependency>

        <groupId>org.springframework.cloud</groupId>

        <artifactId>spring-cloud-starter-loadbalancer</artifactId>

    </dependency>

    <dependency>

        <groupId>org.springframework.cloud</groupId>

        <artifactId>spring-cloud-starter-gateway</artifactId>

    </dependency>

    <dependency>

        <groupId>com.alibaba.cloud</groupId>

        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>

    </dependency>

    <dependency>

        <groupId>com.qfedu</groupId>

        <artifactId>common</artifactId>

        <version>1.0</version>

    </dependency>

</dependencies>

3. 实现配置

在 application.yml 实现

spring:

  application:

    name: lx-gateway

  cloud:

    nacos:

      discovery:

        server-addr: 127.0.0.1:8848

    gateway:

      routes: #静态路由

      - id: auth #唯一

        uri: lb://lx-authapi  #对应要匹配的服务名称，lb 的意思，就是从注册中心获取，后面才可以跟服务的名称

        predicates:

        - Path=/auth/** #外界的访问路径

        filters:

        - StripPrefix=1 #过滤器，去除访问的 1 个路径

      - id: goods #唯一

        uri: lb://lx-goodsapi  #对应要匹配的服务名称，lb 的意思，就是从注册中心获取，后面才可以跟服务的名称

        predicates:

          - Path=/goods/** #外界的访问路径

        filters:

          - StripPrefix=1 #过滤器，去除访问的 1 个路径

4. 运行测试

核心：

gateway 实现路由匹配的方式有 2 种：

第一种：静态路由 可以自己设置信息

gateway:

  routes: #静态路由

  - id: auth #唯一

    uri: lb://lx-authapi  #对应要匹配的服务名称，lb 的意思，就是从注册中心获取，后面才可以跟服务的名称

    predicates:

    - Path=/auth/** #外界的访问路径

    filters:

    - StripPrefix=1 #过滤器，去除访问的 1 个路径

第二种：动态路由 可以直接通过服务名访问

gateway:

	discovery: #动态路由，可以通过服务名直接访问

  	locator:

   	 enabled: true

访问路径：http://localhost:8080/lx-usersapi/doc.html

带上服务名就可以直接请求对应的服务接口

# 4.3.2 Gateway 请求过滤

因为请求先到 Gateway，所以网关提供了对请求进行过滤处理

Gateway 的过滤分为 2 种：

第一种：全局过滤器 GlobalFilter

第二种：局部过滤器

Bio、Nio、Aio 的区别和联系

Spring WebFlux - 异步 响应式 底层 Netty --

Spring WebMVC - 同步

@Slf4j
@Component //IOC
public class HelloFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //获取请求
        ServerHttpRequest request=exchange.getRequest();
        ServerHttpResponse response=exchange.getResponse();
        //获取参数
        log.info("获取参数:{}",request.getQueryParams().get("name"));
        log.info("获取请求消息头：{}",request.getHeaders().get("token"));
        //如果参数name为lx 就拦截
        List<String> list=request.getQueryParams().get("name");
        if(list!=null && list.size()>0){
            if(list.get(0).equals("lx")){
                //拦截
                response.getHeaders().add("Content-Type","application/json;charset=UTF-8");
                return response.writeWith(
                        Mono.just(response.bufferFactory().
                                wrap(JSONUtil.toJsonStr(R.fail()).getBytes())));
            }
        }
        //放行
        return chain.filter(exchange);
    }
}

# 4.3.3 网关配置全局跨域

在 application.yml

spring:

  application:

    name: lx-gateway

  cloud:

    nacos:

      discovery:

        server-addr: 127.0.0.1:8848

    gateway:

      globalcors: #配置全局跨域

        cors-configurations:

          '[/**]': # 匹配所有请求

            allowedOrigins: "*" # 跨域处理 允许所有的域

            allowedMethods: # 支持的方法

              - GET

              - POST

              - PUT

              - DELETE

# 五、Sentinel

# 5.1 Sentinel

Sentinel 阿里巴巴开源，面向分布式、多语言异构化服务架构的流量治理组件，主要以流量为切入点，从流量控制、流量路由、熔断降级、系统自适应保护等多个维度来帮助用户保障微服务的稳定性。

提供了流量控制，并且可以完成服务的熔断降级。

熔断降级：对核心接口，进行设置降级方法，一旦核心接口出现故障，就会自动执行定义的降级方法，避免核心接口长时间阻塞。

# 5.2 Sentinel 作用

Sentinel 核心就是为了帮助保障微服务的稳定性

1. 流量控制：

防止某一瞬间的并发量过高，从而导致系统的稳定性，所以我们会针对高并发的需求进行流量控制，保证项目的稳定性

Sentinel 可视化的流量控制

2. 熔断降级：

对调用链路中不稳定的资源进行熔断降级也是保障高可用的重要措施之一。一个服务常常会调用别的模块，可能是另外的一个远程服务、数据库，或者第三方 API 等。例如，支付的时候，可能需要远程调用银联提供的 API；查询某个商品的价格，可能需要进行数据库查询。然而，这个被依赖服务的稳定性是不能保证的。如果依赖的服务出现了不稳定的情况，请求的响应时间变长，那么调用服务的方法的响应时间也会变长，线程会产生堆积，最终可能耗尽业务自身的线程池，服务本身也变得不可用

# 5.3 Sentinel 安装

1. 下载 jar

https://github.com/alibaba/Sentinel/releases

2. 启动 java -jar 路径 /sentinel.jar

<img src="/Users/ruili/Library/Application Support/typora-user-images/image-20221009102310290.png" alt="image-20221009102310290" style="zoom:30%;" />

<img src="/Users/ruili/Library/Application Support/typora-user-images/image-20221009102427087.png" alt="image-20221009102427087" style="zoom:20%;" />

默认的账号和密码：sentinel/sentinel

<img src="/Users/ruili/Library/Application Support/typora-user-images/image-20221009102535830.png" alt="image-20221009102535830" style="zoom:20%;" />

# 5.4 Sentinel 流量控制

1. 依赖 jar

<!--        Sentinel 流控和熔断 -->

        <dependency>

            <groupId>com.alibaba.cloud</groupId>

            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>

        </dependency>

<!--        jsr303 校验 -->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-validation</artifactId>

        </dependency>

2. 实现配置

spring:

  application:

    name: lx-consumer

  cloud:

    nacos:

      discovery:

        server-addr: 127.0.0.1:8848

    sentinel: #流控和熔断

      transport:

        dashboard: 127.0.0.1:8080

        port: 8719

  main: #允许循环依赖

    allow-circular-references: true

  mvc:

    pathmatch:

      matching-strategy: ant_path_matcher

server:

  port: 8082

3. 访问测试

核心：

阈值类型：1.QPS 2. 并发线程数

服务器类型：1. 单机 2. 集群

流控模式

​ 1. 直接 简单好用，不区分调用者，来自任何调用者的请求都将进行限流统计。如果这个资源名的调用总和超过了这条规则定义的阈值，则触发限流。

​ 2. 关联 一般是多个方法之间竞争，当两个资源之间具有资源争抢或者依赖关系的时候，这两个资源便具有了关联

​ 3. 链路 嵌套调用，对特定的调用者，只有来自这个调用者的请求才会进行流量控制

流控效果：

​ 1. 快速失败 使用最多，该方式是默认的流量控制方式，当 QPS 超过任意规则的阈值后，新的请求就会被立即拒绝

2.预热 主要用于系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统被压垮的情况

​ 3. 排队 严格控制了请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法

# 5.5 Sentinel 熔断降级

熔断降级自动进行，满足熔断规则就自动触发熔断

实现步骤：

1. 在需要保护的方法上 设置就可以

@GetMapping("login")
@SentinelResource(fallback = "loginError")
public R login(){
    if(new Random().nextBoolean()){
        System.out.println(1/0);
    }
    return service.login();
}
//降级方法（返回值和参数需要和上面的方法一致），一旦login方法出问题，Sentinel触发熔断，就会降级方法代替原来的方法
public R loginError(){
    System.err.println("触发熔断降级");
    return R.fail();
}

重点：

1. 熔断策略

• 慢调用比例 ( SLOW_REQUEST_RATIO )：选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用。当单位统计时长（ statIntervalMs ）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。
• 异常比例 ( ERROR_RATIO )：当单位统计时长（ statIntervalMs ）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 [0.0, 1.0] ，代表 0% - 100%。
• 异常数 ( ERROR_COUNT )：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。

# 六、Sleuth+Zipkin

链路跟踪

# 七、微服务综合案例

涵盖各个组件

QPS: 每秒的请求查询数量

TPS: 每秒的事务处理数量

RT: 响应时间