Spring Cloud Alibaba技术栈(上)

左手的ㄟ右手 2022-12-05 05:09 130阅读 0赞

### Spring Cloud Alibaba ###

*  基础介绍
 *   *  技术栈介绍
     *  核心组件
     *  项目管理规范
 *  Nacos
 *   *  Nacos 关键特性
     *  Nacos 核心概念
     *  Nacos Server 安装
     *   *  启动方式
         *  访问与用户配置
     *  Nacos 项目案例
     *   *  Naocs 远程调用测试
         *  负载均衡测试
         *  Nacos\_EndPoint\_配置项
     *  Nacos\_Config案例
     *   *  指定环境下配置文件的访问
         *  动态获取配置文件内容
         *  多配置文件配置
 *  Sentinel 高可用
 *   *  Sentinel 概述
     *  Sentinel Server 安装
     *  Sentinel 项目案例
     *   *  流控规则
         *  降级规则
         *  异常比例
         *  异常数
         *  热点规则
         *  系统规则
         *  授权规则
     *  @SentinelResource 远程调用案例

# 基础介绍 #

## 技术栈介绍 ##

> Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。依托 Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。  
> 作为 Spring Cloud 体系下的新实现，Spring Cloud Alibaba 跟官方的组件或其它的第三方实现如 Netflix, Consul，Zookeeper 等对比，具备了更多的功能和更高的可用性。

## 核心组件 ##

> Spring Cloud Alibaba依托于服务注册中心Nacos, 实现Spring Cloud所具备的功能诸如服务调用, 消息订阅, 事务处理, 任务调度, 服务限流熔断等. 而且利用自身云服务的技术优势又提供了文件存储以及短信服务等, 极大的改善了开发人员对Spring Cloud Netflix的( 尤其是Eureka )依赖

*  Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
 *  Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
 *  RocketMQ：一款开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的、高可靠的消息发布与订阅服务。
 *  Dubbo：Apache Dubbo™ 是一款高性能 Java RPC 框架。
 *  Seata：阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。
 *  Alibaba Cloud ACM：一款在分布式架构环境中对应用配置进行集中管理和推送的应用配置中心产品。
 *  Alibaba Cloud OSS: 阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。
 *  Alibaba Cloud SchedulerX: 阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。
 *  Alibaba Cloud SMS: 覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

## 项目管理规范 ##

> 为了后续方便使用SpringCloud Alibaba进行开发, 首先创建一个pom类型的父项目, 主要用于项目技术栈版本管理, 其步骤如下:

1.创建一个maven项目,名称为spring-cloud-alibaba-examples, 去除src文件, 修改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>ah.szxy</groupId>
        <artifactId>spring-cloud-alibaba-examples</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.3.RELEASE</version>
            <relativePath/> 
        </parent>
    
        <packaging>pom</packaging>
    
        <properties>
            <spring-cloud.version>Hoxton.SR3</spring-cloud.version>
            <com-alibaba-cloud.version>2.2.0.RELEASE</com-alibaba-cloud.version>
        </properties>
    
        
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
    
                <dependency>
                    <groupId>com.alibaba.cloud</groupId>
                    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                    <version>${com-alibaba-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    </project>

1.  后续创建的项目都放到此目录下, 只需要声明groupId和artifactId, 会自动引用父项目spring-cloud-alibaba-examples的版本

ps: 与其说是父项目, 不如说是**根项目**: 因为下面每学习一个新的技术, 就会新建一个真正的父项目, 而在对应的父项目下面又会创建许多的子项目

# Nacos #

> Nacos 的意思表示 Naming 和 Configuration 前两个字母， 而s 表示 Service 服务  
> Nacos 主要功能是注册中心 + 配置中心

> Nacos 致力于发现、配置和管理微服务。它提供了一组简单易用的特性集，帮助快速实 现动态服务发现、服务配置、服务元数据及流量管理。使用 Nacos 可以更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式) 的服务基础设施, 支持几乎所有主流类型的“服务”的发现、 配置和管理：

• Kubernetes Service.  
• gRPC & Dubbo RPC Service.  
• Spring Cloud RESTful Service.

## Nacos 关键特性 ##

1.  **服务发现和服务健康监测** ，支持基于 DNS 和 RPC 的服务发现，支持基于传输层和 应用层的监控检查；
2.  **动态配置服务** ，可以以中心化、外部化和动态化的方式管理所有环境的应用配置和 服务配置，同时支持版本追踪和一键回滚等功能；
3.  **动态 DNS 服务** ，动态 DNS 服务支持权重路由，让您更容易地实现中间层负载均衡、更灵活的路由策略、流量控制以及数据中心内网的简单 DNS 解析服务；
4.  **服务及其元数据管理** ，管理数据中心的所有服务及元数据，包括管理服务的描述、 生命周期、服务的静态依赖分析、服务的健康状态、服务的流量管理、路由及安全策略、服务的 SLA 以及最首要的 metrics 统计数据

## Nacos 核心概念 ##

*  **服务 (Service)**  
    服务是指一个或一组软件功能（例如特定信息的检索或一组操作的执行），其目的是不同的 客户端可以为不同的目的重用（例如通过跨进程的网络调用）。Nacos 支持主流的服务生态， 如 Kubernetes Service、gRPC|Dubbo RPC Service 或者 Spring Cloud RESTful Service.
 *  **服务注册中心 (Service Registry)**  
    服务注册中心，它是服务实例及元数据的数据库。服务实例在启动时注册到服务注册表，并 在关闭时注销。服务和路由器的客户端查询服务注册表以查找服务的可用实例。服务注册中 心可能会调用服务实例的健康检查 API 来验证它是否能够处理请求。
 *  **服务提供方 (Service Provider)**  
    提供可复用和可调用服务的应用方
 *  **服务消费方 (Service Consumer)**  
    发起对某个服务调用的应用方
 *  **服务元数据 (Service Metadata)**  
    服务**元数据**是指包括**服务端点(endpoints)、服务标签、服务版本号、服务实例权重、路由规则、安全策略等**描述服务的数据

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center]

*  **配置 (Configuration)**  
    在系统开发过程中通常会将一些需要变更的参数、变量等从代码中分离出来独立管理，以独立的配置文件的形式存在。目的是让静态的系统工件或者交付物（如 WAR，JAR 包等）更好地和实际的物理运行环境进行适配。配置管理一般包含在系统部署的过程中，由系统管理 员或者运维人员完成这个步骤。配置变更是调整系统运行时的行为的有效手段之一。
 *  **配置管理 (Configuration Management)**  
    在数据中心中，系统中所有配置的编辑、存储、分发、变更管理、历史版本管理、变更审计等所有与配置相关的活动统称为配置管理。
 *  **名字服务 (Naming Service)**  
    提供分布式系统中所有对象(Object)、实体(Entity)的“名字”到关联的元数据之间的映射管理 服务，例如 ServiceName -> Endpoints Info, Distributed Lock Name -> Lock Owner/Status Info, DNS Domain Name -> IP List, 服务发现和 DNS 就是名字服务的 2 大场景。
 *  **配置服务 (Configuration Service)**  
    在服务或者应用运行过程中，提供**动态配置**或者**元数据以及配置管理**的服务提供者。

## Nacos Server 安装 ##

1.  下载地址：https://github.com/alibaba/nacos/releases
2.  Nacos的目录结构  
    ![Nacos的目录结构][Nacos]
    
    > bin：可执行文件夹目录，包含：启动、停止命令等等  
    > conf：配置文件目录  
    > target：存放 naocs-server.jar  
    > LICENSE：授权信息，Nacos 使用 Apache License Version 2.0 授权  
    > NOTICE：公告信息
3.  **Nacos Server 配置**  
    **配置 Mysql 数据库连接**: 修改 conf 目录下 application.properties 文件，添加如下内容( **注意要根据自己数据库的实际情况而配置** )
    
        spring.datasource.platform=mysql
        db.num=1
        db.url.0=jdbc:mysql://localhost:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
        db.user=root
        db.password=root
4.  **将 MySQL 表导入**  
    在数据库中新建一个名称为nacos的数据库, 然后将 \{NACOS-HOME\}/conf/nacos-mysql.sql 导入到 MySQL 数据库中

> Tips: Nacos 建议使用MySQL 5.7 数据库

1.  **启动 Nacos**  
    通过启动脚本启动即可  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 1]

注意:  
在使用Nacos启动脚本的时候需要可能会遇到闪退脚本的情况, 解决方案**主要是在自己的Windows上面配置JAVA\_HOME的用户变量, [点击查看原文][Link 1]**

### 启动方式 ###

一. **Linux/Unix/Mac**  
启动命令(standalone代表着单机模式运行，非集群模式):

sh startup.sh -m standalone

> 如果您使用的是ubuntu系统，或者运行脚本报错提示\[\[符号找不到，可尝试如下运行：

bash startup.sh -m standalone

二. **Windows**  
启动命令：

cmd startup.cmd

或者双击startup.cmd运行文件。

### 访问与用户配置 ###

访问地址

http://nacos_server_ip:8848/nacos/#/login

默认用户名密码: nacos/nacos

**如何添加或者修改nacos账号或者密码?**

1.  根据nacos提供的初始化sql,导入sql,会生成几个表,其中users是用户表, 他保存的就是可登录nacos的账号密码信息.  
    但是用户的密码经过了加密, 因此我们想要添加新的用户密码时, 必须按照它的加密方式去对密码进行加密  
    ![在这里插入图片描述][2021071317305293.png]
2.  具体步骤介绍: 新建一个maven项目->导入spring-boot-starter-security 坐标 -> 在任意一个类中的main()函数对项目进行加密
3.  导入spring-boot-starter-security 坐标
    
        <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
4.  密码字符串加密方法
    
        public static void main(String[] args) { 
                System.out.println(new BCryptPasswordEncoder().encode("需要被加密的密码字符串"));
            }
5.  将加密得到的字符串放入users 表中密码一栏即可添加nacos用户

## Nacos 项目案例 ##

![在这里插入图片描述][20200909161731934.png_pic_center]

1.  创建一个父项目nacos-examples, 修改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">
            <parent>
                <artifactId>spring-cloud-alibaba-examples</artifactId>
                <groupId>ah.szxy</groupId>
                <version>1.0-SNAPSHOT</version>
            </parent>
            <modelVersion>4.0.0</modelVersion>
        
            <artifactId>nacos-examples</artifactId>
            <modules>
                <module>provider</module>
            </modules>
        
            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-web</artifactId>
                </dependency>
                <dependency>
                    <groupId>com.alibaba.cloud</groupId>
                    <artifactId>spring-cloud-alibaba-nacos-discovery</artifactId>
                </dependency>
            </dependencies>
        </project>
2.  创建服务提供者项目provider, 修改其pom文件, 创建配置文件application.yml, 启动类, 创建相关的controller  
    **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">
            <parent>
                <artifactId>nacos-examples</artifactId>
                <groupId>ah.szxy</groupId>
                <version>1.0-SNAPSHOT</version>
            </parent>
            <modelVersion>4.0.0</modelVersion>
        
            <artifactId>provider</artifactId>
        </project>
    
    **配置文件application.yml**
    
        server:
          port: 8081
        spring:
          application:
            name: nacos-provider
          cloud:  #nacos注册中心地址的配置法
            nacos:
              discovery:
                server-addr: localhost:8848  # nacos 注册中心的地址
    
    **启动类**
    
        /** * 服务提供者启动类 * * @author caohaiyang * @create 2020-09-09 下午 03:24 */
        @SpringBootApplication
        @EnableDiscoveryClient  //开启服务的注册与发现
        public class ProviderServiceApplication { 
        
        
            public static void main(String[] args) { 
                SpringApplication.run(ProviderServiceApplication.class,args);
            }
        }
    
    **controller**
    
        /** * 测试用Controller * * @author caohaiyang * @create 2020-09-09 下午 03:16 */
        @Controller
        public class ProviderController { 
        
            @GetMapping("/data/{message}")
            public ResponseEntity<String> sendMsg(@PathVariable String message){ 
                return ResponseEntity.ok(String.format("Hello , %s", message));
            }
        }
3.  创建服务提供者项目consumer, 修改其pom文件, 创建配置文件application.yml, 启动类, 创建相关的controller  
    **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">
            <parent>
                <artifactId>nacos-examples</artifactId>
                <groupId>ah.szxy</groupId>
                <version>1.0-SNAPSHOT</version>
            </parent>
            <modelVersion>4.0.0</modelVersion>
        
            <artifactId>consumer</artifactId>
        </project>
    
    **配置文件application.yml**
    
        server:
          port: 8082
        spring:
          application:
            name: nacos-consumer
          cloud:  #nacos注册中心地址的配置
            nacos:
              discovery:
                server-addr: localhost:8848  # nacos 注册中心的地址
    
    **启动类**
    
        /** * 服务消费者启动类 * * @author caohaiyang * @create 2020-09-09 下午 03:37 */
        @SpringBootApplication
        @EnableDiscoveryClient
        public class ConsumerServiceApplication { 
        
            public static void main(String[] args) { 
                SpringApplication.run(ConsumerServiceApplication.class, args);
            }
        }
    
    **controller**
    
        /** * 服务消费者控制器 * * @author caohaiyang * @create 2020-09-09 下午 03:59 */
        @Controller
        public class ConsumerProvider { 
        
            @Autowired
            private DiscoveryClient discoveryClient;//用于进行服务的注册与发现
        
        
            @GetMapping("/discovery/{serviceName}")
            @ResponseBody
            public ResponseEntity<List<String>> discover (@PathVariable("serviceName") String serviceName){ 
                //通过服务的id or 名称得到服务的实例
                List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);
                //判空
                if (instances == null || instances.isEmpty()) { 
                    return ResponseEntity.notFound().build();
                }
        
                //创建一个list集合,用于接收服务信息
                List<String> services = new ArrayList<>(instances.size());
        
                instances.forEach(e->{ 
                    services.add(e.getHost() + ":" + e.getPort());
                });
        
                return ResponseEntity.ok(services);
            }
        }

测试接口

![在这里插入图片描述][2020091011423733.png_pic_center]

### Naocs 远程调用测试 ###

> 在服务消费者控制器上面, 添加用于远程调用的RestTemplate, 测试其使用, 代码如下:

@Controller
    public class ConsumerProvider { 
    
        @Autowired
        private DiscoveryClient discoveryClient;//用于进行服务的注册与发现
    
        @GetMapping("/discovery/{serviceName}")
        @ResponseBody
        public ResponseEntity<List<String>> discover (@PathVariable("serviceName") String serviceName){ 
            //通过服务的id or 名称得到服务的实例
            List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);
            //判空
            if (instances == null || instances.isEmpty()) { 
                return ResponseEntity.notFound().build();
            }
    
            //创建一个list集合,用于接收服务信息
            List<String> services = new ArrayList<>(instances.size());
    
            instances.forEach(e->{ 
                services.add(e.getHost() + ":" + e.getPort());
            });
    
            return ResponseEntity.ok(services);
        }
    
    
    
        @Autowired
        private RestTemplate restTemplate;
    
        @Bean
        public RestTemplate getRestTemplate() { 
            return new RestTemplate();
        }
    
        /** * 远程调用测试 * @param message 参数 * @return */
        @GetMapping("/rpc1/{message}")
        public ResponseEntity rpv1(@PathVariable String message) { 
            ResponseEntity<String> responseEntity = null;
            try{ 
                responseEntity = this.restTemplate.getForEntity(
                        // 调用服务的 url 地址
                        "http://localhost:8081/data/" + message,
                        // 调用服务的返回值类型
                        String.class
                );
            }catch (Exception e) { 
                e.printStackTrace();
                return ResponseEntity.badRequest().body("远程调用失败");
            }
            if (responseEntity.getStatusCode() == HttpStatus.OK) { 
                return ResponseEntity.ok("远程调用成功，内容为：" + responseEntity.getBody());
            }
            return ResponseEntity.badRequest().body("远程调用失败");
        }
    
    
        /** * 远程调用测试2 * @param message 参数 * @return */
        @GetMapping("/rpc2/{message}")
        public ResponseEntity rpv2(@PathVariable String message) { 
            List<ServiceInstance> instances = this.discoveryClient.getInstances("nacos-provider");
            ServiceInstance serviceInstance = instances.get(0);
            ResponseEntity<String> responseEntity = null;
            try{ 
                responseEntity = this.restTemplate.getForEntity(
                        // 调用服务的 url 地址
                        String.format("http://%s/data/%s", serviceInstance.getHost()+":"+serviceInstance.getPort(), message),
                        // 调用服务的返回值类型
                        String.class
                );
                System.out.println( String.format("http://%s/data/%s", serviceInstance.getHost()+":"+serviceInstance.getPort(), message));
            }catch (Exception e) { 
                e.printStackTrace();
                return ResponseEntity.badRequest().body("远程调用失败");
            }
            if (responseEntity.getStatusCode() == HttpStatus.OK) { 
                return ResponseEntity.ok("远程调用成功，内容为：" + responseEntity.getBody());
            }
            return ResponseEntity.badRequest().body("远程调用失败");
        }
    
    
        /** * 远程调用测试3 * @param message 参数 * @return */
        @GetMapping("/rpc3/{message}")
        public ResponseEntity rpv3(@PathVariable String message) { 
            List<ServiceInstance> instances = this.discoveryClient.getInstances("nacos-provider");
            ServiceInstance serviceInstance = loadBalance(instances);
            System.out.println("serviceInstance = " + serviceInstance);
            ResponseEntity<String> responseEntity = null;
            try{ 
                responseEntity = this.restTemplate.getForEntity(
                        // 调用服务的 url 地址
                        String.format("http://%s/data/%s", serviceInstance.getHost()+":"+serviceInstance.getPort(), message),
                        // 调用服务的返回值类型
                        String.class
                );
            }catch (Exception e) { 
                e.printStackTrace();
                return ResponseEntity.badRequest().body("远程调用失败");
            }
            if (responseEntity.getStatusCode() == HttpStatus.OK) { 
                return ResponseEntity.ok("远程调用成功，内容为：" + responseEntity.getBody());
            }
            return ResponseEntity.badRequest().body("远程调用失败");
        }
    
    
        /** * 随机从服务列表中选取一个服务地址 * @param instances 服务列表 * @return */
        private ServiceInstance loadBalance(List<ServiceInstance> instances) { 
            Random random = new Random(System.currentTimeMillis());
            return instances.get(random.nextInt(instances.size()));
        }
    }

测试远程调用的三个方法

![http://localhost:8082/rpc1/1][http_localhost_8082_rpc1_1]

![http://localhost:8082/rpc2/2][http_localhost_8082_rpc2_2]

![http://localhost:8082/rpc3/3][http_localhost_8082_rpc3_3]

### 负载均衡测试 ###

> 修改服务提供者controller代码, 使其在访问对应controller方法的时候能够带上当前服务所在端口号, 便于后续进行负载均衡测试的时候能够被看到

1.  修改ProviderController代码

@Value("${server.port}")
        private Integer port; //在一台主机上启动多个服务,端口需要不同
    
        @GetMapping("/data2/{message}")
        public ResponseEntity<String> sendMsg2(@PathVariable String message){ 
            return ResponseEntity.ok(String.format("Hello , %s, 我是%s", message, port));
        }

1.  配置多端口启动

> 在启动类中编辑配置, 创建ProviderServiceApplication-8083, ProviderServiceApplication-8084, 在启动参数上面编辑启动的端口号,分别为8083和8084. 然后器动 ProviderServiceApplication, ProviderServiceApplication-8083,ProviderServiceApplication-8084三个消息提供者服务

![在这里插入图片描述][20200910141108213.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 2]

1.  登录nacos的图形化界面 http://localhost:8848/nacos

> 可以看到现在服务提供者实例有3个, 点击详情可以看到这三个实例具体信息, 如下图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 4]  
4. 通过nacos的负载均衡机制访问服务提供者

> 可以看到, **通过调用相同的服务消费者接口, 访问到的服务实例不同**

![在这里插入图片描述][20200910141952857.png_pic_center]  
![在这里插入图片描述][20200910142012961.png_pic_center]  
![在这里插入图片描述][20200910142026320.png_pic_center]

5: 通过ribbon方式来进行负载均衡访问

> 使用原生的ribbon进行服务的调用更加方便, 主要分为两个步骤  
> 一. 在getRestTemplate 方法上面加上一个@LoadBalanced注解  
> 二. 无需通过服务名获取服务实例, 直接在请求时通过url请求. (**之前是通过服务名来获取服务实例, 在发送请求时将Host, Port进行拼接**)

//之前拼接请求的代码
    responseEntity = this.restTemplate.getForEntity(
                        // 调用服务的 url 地址
                        String.format("http://%s/data2/%s", serviceInstance.getHost()+":"+serviceInstance.getPort(), message),
                        // 调用服务的返回值类型
                        String.class
                );

修改原来代码, 使其使用ribbon进行服务的调用

/** * 将 restTemplate 纳入 Spring IOC 容器中 * * @return */
        @LoadBalanced
        @Bean
        public RestTemplate getRestTemplate() { 
            return new RestTemplate();
        }
    
    
      /** * 远程调用测试4 * @param message 参数 * @return */
        @GetMapping("/rpc4/{message}")
        public ResponseEntity rpv4(@PathVariable String message) { 
            ResponseEntity<String> responseEntity = null;
            try{ 
                responseEntity = this.restTemplate.getForEntity(
                        // 调用服务的 url 地址
                        "http://nacos-provider/data2/{message}",
                        // 调用服务的返回值类型
                        String.class,
                        // 参数值
                        message
                );
            }catch (Exception e) { 
                e.printStackTrace();
                return ResponseEntity.badRequest().body("远程调用失败");
            }
            if (responseEntity.getStatusCode() == HttpStatus.OK) { 
                return ResponseEntity.ok("远程调用成功，内容为：" + responseEntity.getBody());
            }
            return ResponseEntity.badRequest().body("远程调用失败");
        }

测试效果

> 可以看到, 两种负载效果是相同的

![在这里插入图片描述][20200910143200979.png_pic_center]  
![在这里插入图片描述][20200910143213671.png_pic_center]  
![在这里插入图片描述][20200910143227464.png_pic_center]

### Nacos\_EndPoint\_配置项 ###

> Nacos Discovery 内部提供了一个 Endpoint, 对应的 endpoint id 为 nacos-discovery。我们通  
> 过该 Endpoint，能获取到：

*  当前服务有哪些服务订阅者 ；
 *  当前应用 Nacos 的基础配置信息 ；

**下面将修改 Provider 子模块，实现 Nacos Discovery 对外暴露 EndPoint**

1.  修改 pom.xml ,添加依赖

<dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
        </dependencies>

1.  修改 application.yml

server:
      port: 8081
    
    spring:
      application:
        name: service-provider
      cloud:
        nacos:
          discovery:
            ip: localhost
            server-addr: localhost:8848 # Nacos 注册中心地址
            enabled: true #开启或者关闭 Nacos 注册中心功能
    
    # Endpoint 本身对外界隐藏显示，我们需要在配置里面开启对 Endponit 的显示支持。
    # exposure.include：对外界保留那些 Endpoint，若是所有则使用* ；
    management:
      endpoints:
        web:
          exposure:
            include: "*"

1.  重启项目后访问 http://localhost:8081/actuator/nacos-discovery

![在这里插入图片描述][20200910144123552.png_pic_center]

1.  通过[json的校验][json]可以看到服务的相关信息了  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 5]

ps: 附上Nacos Discovery Stater 配置项(在application.yml配置)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 7]  
![在这里插入图片描述][20200910150743254.png_pic_center]

## Nacos\_Config案例 ##

**项目搭建架构**

> 在 nacos-examples 的基础上，搭建一个 config-client，用来今天 nacos 配置中 心的案例测试,如下图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 8]

1.  创建 config-client 模块，并修改 pom.xml 文件

1.  在 nacos 服务 web 端界面中添加 config-client 模块的配置文件

> 配置以下内容  
> user.name=timepause  
> user.age=25

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 9]  
3. 在 config-client 模块添加 bootstrap.yml 文件（启动优先于 application.yml）

server:
      port: 8888
    spring:
      application:
        name: config-client
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848

1.  创建启动类

@SpringBootApplication
    @EnableDiscoveryClient
    @RefreshScope // 表示配置文件更新后可以重新加载
    @RestController
    public class ConfigClientServiceApplication { 
    
        @Value("${user.name}")
        private String userName;
        @Value("${user.age}")
        private String userAge;
    
        public static void main(String[] args) { 
            SpringApplication.run(ConfigClientServiceApplication.class, args);
        }
    
        @GetMapping("/config/get")
        public ResponseEntity getConfig() { 
            return ResponseEntity.ok(String.format("获取配置信息 : userName = %s, userAge = %s", this.userName, this.userAge));
        }
    }

1.  测试结果

![在这里插入图片描述][20200910152540556.png_pic_center]

### 指定环境下配置文件的访问 ###

1.  创建一个命名空间, 用于管理一个项目不同环境下的配置文件

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 10]

1.  命名空间创建后, 在配置列表中就可以选择对应命名空间,然后创建不同环境下的配置文件

> 这里创建的是dev环境下的配置文件

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 12]

1.  修改bootstrap.yml

server:
      port: 8888
    spring:
      application:
        name: config-client
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848
    # namespace: c24f52a3-604d-418b-98d3-52e5e394510a # 命名空间 ID ，非命名空间名称
    # group: GROUP_A # 组名
    # file-extension: properties
          config:  # 应该在这里配置 namespace group file-extension
            namespace: c24f52a3-604d-418b-98d3-52e5e394510a #命名空间的ID
            group: GROUP_A
            file-extension: yml
    
      profiles:
        active: prod   # 使用开发环境配置文件

1.  测试访问结果

![在这里插入图片描述][20200910174930432.png_pic_center]

### 动态获取配置文件内容 ###

>  只需在启动类/controller上面加上@RefreshScope // 表示配置文件更新后可以重新加载即可

1.  可以在nacos上面, 找到对应的配置文件, 修改原来的内容, 测试成功
2.  可以nocos的配置列表, 在更多选项中->选择历史版本, 然后回滚配置文件, 测试成功

### 多配置文件配置 ###

> 下面的配置就是让项目可以同时访问test-a.yml 和test-b.yml,  
> 并且设置tes-a.yml的配置文件可以被刷新, 而test-b.yml的配置文件不可被刷新

server:
      port: 8888
    spring:
      application:
        name: config-client
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848
          config: # 指定配置中心的地址和配置中心使用的数据格式
            server-addr: localhost:8848
            extension-configs:  # 多配置
              - dataId: test-a.yml
                group: DEFAULT_GROUP
                refresh: true   # 刷新
              - dataId: test-b.yml
                group: DEFAULT_GROUP
                refresh: false  # 不刷新

# Sentinel 高可用 #

## Sentinel 概述 ##

> 随着微服务的流行，服务和服务之间的稳定性变得越来越重要。  
> Sentinel 以流量为切入点， 从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

**Sentinel 具有以下特征:**

*  **丰富的应用场景**： Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景， 例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、实时熔断下游不可用应用等。
 *  **完备的实时监控**： Sentinel 同时提供实时的监控功能。您可以在控制台中看到接入应 用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。
 *  **广泛的开源生态**： Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。您只需要引入相应的依赖并进行简单的配置即可 快速地接入 Sentinel。
 *  **完善的 SPI 扩展点**： Sentinel 提供简单易用、完善的 SPI 扩展点。您可以通过实现扩展点，快速的定制逻辑。例如定制规则管理、适配数据源等

## Sentinel Server 安装 ##

**下载 Sentinel 控制台**

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

**运行 Sentinel 控制台**

java -jar sentinel-dashboard-1.7.1.jar  # 默认以8080端口启动
    java -jar sentinel-dashboard-1.7.1.jar  --server.port=8888    
    java -jar -DServer.port=8888 serverPath

**访问图形化界面**

http://localhost:8080/
    登录: 账号密码默认都是Sentinel

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 13]

**ps: Sentinel图形化界面是懒加载, 一开始主页没有内容, 只有监控到数据流量了才会显示更多的内容**

## Sentinel 项目案例 ##

> 在根项目spring-cloud-alibaba-examples下创建entinel-example-client父项目  
> 在后续的配置中, 会遇到**qps, tps, rt**等术语, 可以参照下面[链接][Link 2]

1.创建项目并修改 pom.xml 文件, 添加如下依赖

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
            </dependency>
        </dependencies>
    
        
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

1.  创建并修改配置文件 application.yml

> 指定当前项目运行端口8089  
> 图形化界面的端口8080  
> sentinel监控端口8779

server:
      port: 8089
      
    spring:
      application:
        name: sentinel-client
    
      cloud:
        sentinel:
          transport:
            dashboard: localhost:8080
            port: 8779 # sentinel dashboard 监听端口，若该端口被占用，则进行端口+1

1.  创建启动类

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

1.  创建测试用Controller

@RestController
    public class TestController { 
    
        @GetMapping("/test")
        public ResponseEntity<String> test() { 
            return ResponseEntity.ok("OK");
        }
    }

5.访问测试

//最好多访问几次
    http://localhost:8089/test
    //然后访问Sentinel的图形化界面, 可以看到出现了如下内容
    http://localhost:8080/

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 14]

### 流控规则 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 15]

**资源名 ：**  
标识资源 的唯一名称 ， 默认为请求路径 ， 也可以在客户端中使用@SentinelResource 配置；

**针对来源 ：**  
Sentinel 可以针对服务调用者进行限流 ， 填写微服务名称即 spring.application.name，默认为 default，不区分来源；

**阈值类型、单机阈值：**

*  **QPS**（Queries-per-second，**每秒钟的请求数量**）：当调用该 api 的 QPS 达到阈值的时候， 进行限流；
 *  线程数：当调用该 api 的线程数达到阈值的时候，进行限流。
 *  是否集群：默认不集群；

**流控效果：**

*  快速失败：直接失败；
 *  Warm Up：根据 codeFactor（冷加载因子，默认值为 3）的值，从阈值/codeFactor，经过预热时长，才达到设置的 QPS 阈值；
 *  排队等待：匀速排队，让请求匀速通过，阈值类型必须设置为 QPS，否则无效。

一. **QPS (Queried Per Second) 配置**

> 配置 localhost:8089/test ,每秒只允许两次请求通过，其余的”快速失败"(抛出异常)

1.  进入簇点链路, 找到需要进行限流的url  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 16]
2.  设置流控规则  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 17]
3.  设置成功后, 无需重启, 每秒启动大于2次则会返回托底数据  
    ![在这里插入图片描述][20200911153657677.png_pic_center]

二. 设置线程数限制

> 当访问处理的线程数大于2时,则会返回托底数据

1.  Controller中新增一个方法, 用于进行限流设置

@GetMapping("/thread")
        public ResponseEntity<String> testThread() throws InterruptedException { 
            TimeUnit.SECONDS.sleep(1);
            return ResponseEntity.ok("thread");
        }

1.  Sentinel图形化界面配置流控规则

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 18]

1.  进行快速访问  
    ![在这里插入图片描述][20200911154620751.png_pic_center]

三. **关联和链路**

**关联**

> 当 /test2 超过阈值时，限制 /test1

1.  配置流控规则  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 19]
2.  测试访问结果  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 20]

**链路**

> 程序的调用可以看成为一条链路。当触发链路的某条规则后，该链路被限流。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 21]

1.  修改后端代码，添加 TestService， 声明资源

@Service
    public class TestService { 
    
        /** * 链路资源 * @return */
        @SentinelResource("hello")
        public String hello() { 
            return "Hello";
        }
    }

1.  修改TestController

@Autowired
        private TestService testService;
    
        /** * 链路1 * @return */
        @GetMapping("/link1")
        public ResponseEntity<String> link1() { 
            String hello = this.testService.hello();
            System.out.println("hello1 = " + hello);
            return ResponseEntity.ok("link1 -> hello -> others");
        }
    
        /** * 链路2 * @return */
        @GetMapping("/link2")
        public ResponseEntity<String> link2() { 
            String hello = this.testService.hello();
            System.out.println("hello2 = " + hello);
            return ResponseEntity.ok("link2 -> hello -> others");
        }

1.  添加流控规则

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 22]

1.  配置 hello 链路规则

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 24]

1.  测试访问效果  
    说明：当访问 /link2 超过阈值后， 限制 /link1 的访问

**四. 预热和排队**

**预热（warm up）**

> sentinel 客户端的默认冷加载因子 coldFactor 为 3，即请求 QPS 从 threshold / 3 开始，经预热时长逐渐升至设定的 QPS 阈值。

**排队**

> 排队：匀速排队，让请求匀速通过，阈值类型必须设置为 QPS，否则无效。  
> 新增排队规则： 采用“排队等待”，一秒只允许一个请求通过

1.  创建测试代码

/** * 日志打印 */
        private static final Logger logger = LoggerFactory.getLogger(TestController.class);
    
        /** * 排队 * @return */
        @GetMapping("/queue")
        public ResponseEntity<String> quence() { 
            logger.info("开始处理 ....");
            return ResponseEntity.ok("quence");
        }

1.  配置流控规则  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 25]
2.  访问测试  
    经过访问测试可以发现, 单机阈值代表每秒可以处理的次数  
    而超时时间则表示超出这段时间(ms)则会抛出异常  
    从下图可以看到对流程的控制几乎是可以达到毫秒级别的

![在这里插入图片描述][20200911175627676.png_pic_center]

### 降级规则 ###

**一. RT 平均响应时间**

1.  修改 TestController

/** * 降级 */
        @GetMapping("/rt")
        public ResponseEntity<String> rt() throws InterruptedException { 
            // 睡眠一秒
            TimeUnit.SECONDS.sleep(1);
            return ResponseEntity.ok("rt");
        }

1.  设置降级规则  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 26]
2.  利用jmeter软件进行测试

> 在选项栏第一个设置外观, 为Windows  
> 在选项栏第五个设置语言为中文简体, 效果如下图  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 27]

1.  在测试计划右击添加线程组
    
    > 设置1s五次, 永远循环
    
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 28]
2.  在线程组右击, 添加取样器, 设置http请求  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 29]
3.  在GET请求后右击,添加监听器->查看结果树  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 30]  
    首先我们来启动测试  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 31]
4.  可以看到随着请求的不断进行, 会出现异常的http请求  
    **然后我们通过浏览器访问也是会返回如下的托底数据, 我们将循环测试结束后, 访问又会正常了**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 32]  
访问正常的截图  
![在这里插入图片描述][20200911184618469.png_pic_center]

### 异常比例 ###

> 当资源的每秒请求量 >= 5，并且每秒异常总数占通过量的比值超过阈值之后，资源进入降级状态，  
> 在接下来的时间窗口内，程序都会快速失败

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 33]

> 上面的配置含义是：**如果/exception 的 QPS 大于 5，并且每秒钟的请求异常比例大于 0.5  
> 的话，那么在未来的 3 秒钟（时间窗口）内，sentinel 断路器打开，该 api 接口不可用。  
> 也就是说，如果一秒内有 10 个请求进来，超过 5 个以上都出错，那么会触发熔断，1  
> 秒钟内这个接口不可用。**

### 异常数 ###

> 注意： 异常数默认的时间窗口大于 1 分钟，若设置的时间窗口小于 1 分钟，则会再次进入熔断

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 34]

> 上面的配置含义时, **当每分钟出现的异常数>=5时, 服务会进行熔断, 等待时间窗口规定时间结束后服务方可访问**

### 热点规则 ###

> 热点即经常访问的数据。很多时候我们希望统计某个热点数据中访问频次最高的数据，并对其访问进行限制。

1.  修改 TestController 代码

@GetMapping("/buy")
        @SentinelResource("buy")
        public ResponseEntity<String>  bug( String goodsName, Integer goodsCount){ 
            return ResponseEntity.ok(String.format("购买%s， 一共%s件", goodsName, goodsCount));
        }

1.  在sentinel控制台找到管理的资源buy,添加热点规则  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 35]
2.  设置热点规则, 该图代表的含义是, 对buy资源下传入的第1个参数进行限制, 只能访问一次, 超过以后则3秒之后才能访问!  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 36]
3.  在sentinel的左侧菜单栏, 可以**直接设置热点规则还有热点规则的高级设置**, 如下图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 37]

> 说明：对 buy资源添加热点规则，对于非 goodsName不等于 小米，每 3 秒可以请求一次，其余的拒绝，  
> 对于 prodName 等于 小米， 每 3 秒可以请求二次， 其余的拒绝。

1.  测试  
    访问 `http://localhost:8089/buy?goodsName=小米&goodsCount=123`前两次正常, 第三次会抛出异常, 3s后又可重新访问

### 系统规则 ###

> 系统规则则是针对整个系统设置限流规则，并不针对某个资源，设置页面如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 38]

**阈值类型包含以下五种：**

*  **Load 自适应**（仅对 Linux/Unix-like 机器生效）：系统的 load1 作为启发指标，进行自 适应系统保护。当系统 load1 超过设定的启发值，且系统当前的并发线程数超过估算 的系统容量时才会触发系统保护（BBR 阶段）。系统容量由系统的 maxQps minRt 估算得出。设定参考值一般是 CPU cores 2.5。
 *  **CPU usage**（1.5.0+ 版本）：当系统 CPU 使用率超过阈值即触发系统保护（取值范围 0.0-1.0），比较灵敏。
 *  **平均 RT**：当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
 *  **并发线程数**：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
 *  **入口 QPS**：当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。

### 授权规则 ###

> 授权规则用于配置黑白名单

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 39]

配置案例

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 40]

## @SentinelResource 远程调用案例 ##

> Sentinel 提供了@SentinelResource 注解用于定义资源，并提供可选的**异常回退**和 **Block 回退**。 异常回退指的是@SentinelResource 注解标注的方法发生 Java 异常时的回退处理；Block 回退指的是当@SentinelResource 资源访问不符合 Sentinel 控制台定义的规则时的回退（默认返回 Blocked by Sentinel (flow limiting)）。这节简单记录下该注解的用法

1.  项目架构  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 41]
2.  创建父项目sentinel-example, pom文件添加相关依赖

1.  在父项目下创建子模块sentinel-provider, pom文件添加依赖

<build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

1.  修改配置文件

server:
      port: 8091
    
    spring:
      application:
        name: sentinel-provider
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848  #需要启动nacos

1.  创建启动类

/** * 服务提供者启动类 * * @author TimePause * @create 2020-09-13 20:52 */
    @SpringBootApplication
    @RestController
    public class SentinelProviderApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(SentinelProviderApplication.class);
        }
    
        @GetMapping("test")
        public ResponseEntity<String> test(){ 
            return ResponseEntity.ok("test,我是服务提供者");
        }
    }

1.  在父项目下创建子模块sentinel-consumer, pom文件添加依赖

<dependencies>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

1.  修改配置文件

server:
      port: 8092
    
    spring:
      application:
        name: sentinel-consumer
      cloud:
        nacos:
          discovery:
            server-addr: localhost:8848 # nacos
        sentinel:
          transport:
            dashboard: localhost:8080  # sentinel需要启动
            port: 8719

1.  创建消费者项目启动类(自带controller)

/** * 基于Sentinel的服务消费者启动类 * * @author TimePause * @create 2020-09-13 21:05 */
    @SpringBootApplication
    @RestController
    @EnableDiscoveryClient
    public class SentinelConsumerApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(SentinelConsumerApplication.class);
        }
    
        @LoadBalanced
        @Bean
        public RestTemplate getRestTemplate() { //将远程调用对象注入到Spring容器
            return new RestTemplate();
        }
    
        @Autowired
        private RestTemplate restTemplate;
    
        /** * 远程调用测试 * @return */
        @GetMapping("/rpc")
        public ResponseEntity<String> rpc(String type) { 
            System.out.println("调用远程服务 rpc");
            ResponseEntity<String> result = this.restTemplate.getForEntity(
                    "http://sentinel-provider/test",
                    String.class
            );
            String body = result.getBody();
            if (result.getStatusCode() == HttpStatus.OK) { 
                return ResponseEntity.ok("远程调用 success!\t "+"内容: "+body);
            }
            throw new RuntimeException("远程调用失败 ...");
        }
    }

1.  访问测试  
    ![在这里插入图片描述][20200913212938434.png_pic_center]
2.  待项目能够跑通后, 修改代码, 使其能够对java异常和流程控制异常进行返回, 返回托底数据信息

@SpringBootApplication
    @RestController
    @EnableDiscoveryClient
    public class SentinelConsumerApplication { 
    
        public static void main(String[] args) { 
            SpringApplication.run(SentinelConsumerApplication.class);
        }
    
        @LoadBalanced
        @Bean
        public RestTemplate getRestTemplate() { //将远程调用对象注入到Spring容器
            return new RestTemplate();
        }
    
        @Autowired
        private RestTemplate restTemplate;
    
        /** * 远程调用测试 * @return */
        @SentinelResource(value = "rpc", fallback = "rpcFallBack", blockHandler = "rpcHandler")
        @GetMapping("/rpc")
        public ResponseEntity<String> rpc(String type) { 
            System.out.println("调用远程服务 rpc");
            if(null != type && type.equals("java")) { 
                throw new RuntimeException("不想成功 ...");
            }
            ResponseEntity<String> result = this.restTemplate.getForEntity(
                    "http://sentinel-provider/test",
                    String.class
            );
            if (result.getStatusCode() == HttpStatus.OK) { 
                return ResponseEntity.ok("远程调用 success");
            }
            throw new RuntimeException("远程调用失败 ...");
            // return ResponseEntity.badRequest().body("远程调用失败 ...");
        }
    
        /** * 服务降级 * @param e * @return */
        public ResponseEntity rpcFallBack(String type, Throwable e) { 
            return ResponseEntity.ok("异常类型为 "+type+",发生 java 异常, 异常信息为 ：" + e);
        }
    
        /** * block 方法回退 * @param type * @param e * @return */
        public ResponseEntity rpcHandler(String type, BlockException e) { 
            return ResponseEntity.ok("异常类型为" + type + ",sentinel 流控规则错误, 错误信息为：" + e);
        }
    }

1.  设置Sentinel流控规则

> 每秒访问2次后就会出现流控规则错误

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 42]  
12. 测试效果

测试java异常返回的托底数据

![在这里插入图片描述][20200913220553549.png_pic_center]  
测试流控规则异常时返回的托底数据

![在这里插入图片描述][20200913220424168.png_pic_center]  
13.  提取 FallBack 类 和 BlockHandler 类

FallBack

public class RpcFallback { 
    
        /** * 服务降级 * @param e * @return */
        public static ResponseEntity rpcFallBack(String type, Throwable e) { 
            return ResponseEntity.ok("异常类型为 "+type+",发生 java 异常, 异常信息为 ：" + e);
        }
    }

BlockHandler

public class BlockHandleConf { 
    
        /** * block 方法回退 * @param type * @param e * @return */
        public static ResponseEntity rpcHandler(String type, BlockException e) { 
            return ResponseEntity.ok("异常类型为" + type + ",sentinel 规则错误, 错误信息为：" + e);
        }
    }

在原来的controller方法注解上面引用这两个类

//blockHandlerClass 和 fallbackClass 用于引用自定义的两个类
      @SentinelResource(value = "rpc", fallbackClass = RpcFallback.class, blockHandlerClass = BlockHandleConf.class, fallback = "rpcFallBack", blockHandler = "rpcHandler")
      @GetMapping("/rpc")

ps:

1.  特别感谢 [爱吃酸梨][Link 3] 提供的帮助, 欢迎大家关注
2.  软件nacos, sentinel, jemeter分享  
    链接：https://pan.baidu.com/s/1LNIRZUDznekZOSEmazSoqw  
    提取码：0d1u
3.  下部分正在整理ing…

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 43]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/fa7bfc756fd146dd927c25a97f48d4b6.png
[Nacos]: /images/20221123/1651185e66004c9a8373d5c7b4ca1ca9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/229a6dd43298490aa7056164f5e17294.png
[Link 1]: https://www.cnblogs.com/jm-wmj/p/11236381.html
[2021071317305293.png]: /images/20221123/ce23d1261774467aadd4e5461e2061bf.png
[20200909161731934.png_pic_center]: /images/20221123/218eaef5fd6d437bb91d8df216ced1ff.png
[2020091011423733.png_pic_center]: /images/20221123/7e43b062493a474cb243e0dc7b0a15f0.png
[http_localhost_8082_rpc1_1]: /images/20221123/bbec00748bbd4bedac26813f56955e20.png
[http_localhost_8082_rpc2_2]: /images/20221123/a12d4dfc7ad249a4b237a5e2060fab4c.png
[http_localhost_8082_rpc3_3]: /images/20221123/4ff1f6a8bca54c7299d323e2a88fc08c.png
[20200910141108213.png_pic_center]: /images/20221123/a2b4ec4c1c5a4c7090f636a15b053c61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/9547917514c24d1694b494dd564790c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/dd6b93d0598e45cd9e58afb18faec61d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/10eb30cbc25d4692825cfa71031cd0a1.png
[20200910141952857.png_pic_center]: /images/20221123/86656e46ceab46359d26f25be2ac3d63.png
[20200910142012961.png_pic_center]: /images/20221123/da6e652b8e9b497cbddb688cba6341ed.png
[20200910142026320.png_pic_center]: /images/20221123/f7d052f862a942e59317dceb0fed4df1.png
[20200910143200979.png_pic_center]: /images/20221123/92b6c95db26d4116bf8a896b8e21bd52.png
[20200910143213671.png_pic_center]: /images/20221123/035839e8402144afa1814c810350d7c1.png
[20200910143227464.png_pic_center]: /images/20221123/9b23dc9312034ab1860d673d97ac170c.png
[20200910144123552.png_pic_center]: /images/20221123/44f1f16458bd4d959b3f285d034677c4.png
[json]: http://json.cn/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/562dfce6717a452a8c7679d37de319a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/949ee2ec47e74cca9a371632c816acba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/b189db1c2d524c85a4961a5c6f1dcd11.png
[20200910150743254.png_pic_center]: /images/20221123/02c26bc18ea64a1dad6077721f4f0296.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/2a3fbfbfb2d747f0976864741f7ca0ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/3befbcfec3a94313aaabac30d592a6ca.png
[20200910152540556.png_pic_center]: /images/20221123/59917ccf704c4c9dbd11747cc7628917.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/930b7f6075eb416999051a021bce1579.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221123/6fd5bd5a00784fcea24ad2e67795ee96.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221123/50374c4bf820426ea006ae201f8825e0.png
[20200910174930432.png_pic_center]: /images/20221123/5c68abcc979341a2931fff00ea4647f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221123/aed1ede9faad40868d5356f76843ff88.png
[Link 2]: https://www.cnblogs.com/longxiaojiangi/p/9259745.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221123/210348c757024bc5a317bac538c86887.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221123/2cec07e1c3c643e19ffa32718acc7339.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221123/6d3813e63996452b956f6595f338bfba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221123/2653734c2fe24341903d0bb369369446.png
[20200911153657677.png_pic_center]: /images/20221123/90a14ede2a6246bdb1e315528b468b7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221123/ccd980fea80e4016a7d659a4e6190112.png
[20200911154620751.png_pic_center]: /images/20221123/d9328eb401794db5858d0524f75eb42d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20221123/ed56c2a494a94e71b9e3387cc8303940.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20221123/9a4a849224de49c493013070b5ee1fa4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 21]: /images/20221123/c1c236fa5c194c98b6be04b61541f40e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 22]: /images/20221123/89e7eef32ef049ad9ca4e5e1b1aa442d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 23]: /images/20221123/14af44982e9a45459b9d3047b114b476.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 24]: /images/20221123/256fea5d63c24e24b2c971e96e315c1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 25]: /images/20221123/c7a16bf56f5a4deaa9a576b45efcfc54.png
[20200911175627676.png_pic_center]: /images/20221123/c38c23324f0e4f3382f1577183aedd8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 26]: /images/20221123/4589baba3e004994a9f283b9d7fce46c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 27]: /images/20221123/97c82d76a0484007b73b695dd0092280.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 28]: /images/20221123/2288a128fc2345a0a9bf2519b53b39a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 29]: /images/20221123/54e3477b269447bf96c8cbd2037d8083.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 30]: /images/20221123/f8ee5a54f37e4dc388cce0594e0fe63b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 31]: /images/20221123/3ac0b72dbfe44d9f9554c5e90b46b2d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 32]: /images/20221123/62bb1d00be3b4638a904e99ed245660f.png
[20200911184618469.png_pic_center]: /images/20221123/64bc270a5f79438cbd3dd21167009f13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 33]: /images/20221123/23635d0b55df4e2784e9a93b62691fbc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 34]: /images/20221123/34b4c92dab0a44839eae80f4c9dcb1ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 35]: /images/20221123/864e906174024167bb436183cbced521.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 36]: /images/20221123/a9ebc8b0c737446d8d5baf4be41f4704.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 37]: /images/20221123/7c018dbd59df4553a84d95c534c9dc7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 38]: /images/20221123/bd4024864d8e4742b884e338ee04b1c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 39]: /images/20221123/d678d6cb68bd42bb96e96e3eb0b47606.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 40]: /images/20221123/609e24c11ca746018cb747d0345fef72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 41]: /images/20221123/7e29845c9b684687a54de31a0e55e200.png
[20200913212938434.png_pic_center]: /images/20221123/08c9915681c1402eb4eeba8e58a0a512.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 42]: /images/20221123/d432fc3b1c964bf4948bffdfd03188aa.png
[20200913220553549.png_pic_center]: /images/20221123/5361b717d3e340f99e95404a5efd9c45.png
[20200913220424168.png_pic_center]: /images/20221123/478b059b914b488c9a81065970a38733.png
[Link 3]: https://blog.csdn.net/sunshine_wz/article/month/2020/02
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzcxNTU2_size_16_color_FFFFFF_t_70_pic_center 43]: /images/20221123/7d97758e848c43248eeb51f63159304b.png