SpringCloud（H版以及Alibaba版本）的学习笔记（三）

本笔记学习自B站尚硅谷Springcloud时所记录学习视频链接源码地址【码云】笔记内容包括了：Springcloud的H版以及Alibaba版本H版具体内容包括：Eureka、Zookeeper、Consul、Ribbon、OpenFeign、Hystrix、Gateway、Config、Bus、Stream、Sleuth等技术的使用；Alibaba版本包括：Nacos、Sentinel、Sea

Coder_Oldou

4458人浏览 · 2021-08-12 10:08:53

Coder_Oldou · 2021-08-12 10:08:53 发布

本笔记学习自B站尚硅谷Springcloud时所记录

笔记内容包括了：Springcloud的H版以及Alibaba版本

H版具体内容包括：Eureka、Zookeeper、Consul、Ribbon、OpenFeign、Hystrix、Gateway、Config、Bus、Stream、Sleuth等技术的使用；
Alibaba版本包括：Nacos、Sentinel、Seata等技术的使用

点击直达

十二、SpringCloud Alibaba技术简介

1、SpringCloud Alibaba简介

Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。
依托 Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。
诞生：2018.10.31，Spring Cloud Alibaba 正式入驻了Spring Cloud官方孵化器，并在Maven 中央库发布了第一个版本。

2、SpringCloud Alibaba技术能干些什么？

服务限流降级：默认支持 WebServlet、WebFlux、OpenFeign、RestTemplate、Spring Cloud Gateway、 Zuul、Dubbo 和 RocketMQ 限流降级功能的接入，可以在运行时通过控制台实时修改限流降级规则，还支持查看限流降级 Metrics 监控。
服务注册与发现：适配 Spring Cloud 服务注册与发现标准，默认集成了 Ribbon 的支持。
分布式配置管理：支持分布式系统中的外部化配置，配置更改时自动刷新。
消息驱动能力：基于 Spring Cloud Stream 为微服务应用构建消息驱动能力。
分布式事务：使用 @GlobalTransactional注解，高效并且对业务零侵入地解决分布式事务问题。
阿里云对象存储：阿里云提供的海量、安全、低成本、高可靠的云存储服务。支持在任何应用、任何时间、任何地点存储和访问任意类型的数据。
分布式任务调度：提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。同时提供分布式的任务执行模型，如网格任务。网格任务支持海量子任务均匀分配到所有 Worker（schedulerx-client）上执行。
阿里云短信服务：覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

3、SpringCloud Alibaba怎么添加支持？

只需要使用已发布的版本，在 Pom文件中的dependencyManagement 添加以下依赖：

	<dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>com.alibaba.cloud</groupId>
              <artifactId>spring-cloud-alibaba-dependencies</artifactId>
              <version>2.2.5.RELEASE</version>
              <type>pom</type>
              <scope>import</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>

4、SpringCloud Alibaba包括哪些组件？

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

十三、SpringCloud Alibaba组件之Nacos【服务注册和配置中心】

1、Nacos的简介

Nacos，前四个字母分别为Naming和Configuration的前两个字母，最后的s为Service，因此全名为：Dynamic Naming and Configuration Service
Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
Nacos就是注册中心＋配置中心的组合，相当于Eureka + Config + Bus的组合
Nacos能够替代Eureka做服务注册中心，同时也能替代Config做服务配置中心

各中注册中心比较
在这里插入图片描述

2、Nacos之V2.x在Windows下的安装

环境准备： 本地Java8+Maven环境需要安装并配置OK
下载地址： 官网
在这里插入图片描述
安装使用

Nacos1.x的版本下载解压即可使用，但是我这里由于是Nacos2.x版本的，所以还需要进行步骤
首先找到nacos\bin\startup.cmd文件，将里面的配置改成如下图所示：
接着找到nacos\conf\application.properties文件，取消以下注释
然后去我们的数据库中，创建一个名为nacos的数据库，字符集为utf-8，排序规则为如下所示，然后在该数据库中导入nacos\conf\nacos-mysql.sql文件
最后就是运行nacos\bin\shutdown.cmd
注意：如果不行的话，那么需要重启电脑。

服务访问： 命令运行成功后直接访问http://localhost:8848/nacos，默认账号密码都是nacos
在这里插入图片描述

3、Nacos之服务提供者的注册

Nacos的官方文档教程

第一步： 新建一个Module，名为：cloud-provider-alibaba-payment9001
第二步： 改pom文件

在父工程的pom依赖中引入spring-cloud-alibaba的依赖

<!--spring cloud alibaba 2.1.0.RELEASE-->
     <dependency>
       <groupId>com.alibaba.cloud</groupId>
       <artifactId>spring-cloud-alibaba-dependencies</artifactId>
       <version>2.1.0.RELEASE</version>
       <type>pom</type>
       <scope>import</scope>
     </dependency>

在cloud-provider-alibaba-payment9001服务中引入以下依赖：

<?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>cloud2021</artifactId>
       <groupId>com.oldou.springcloud</groupId>
       <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>

   <artifactId>cloud-provider-alibaba-payment9001</artifactId>
   <dependencies>
       <!--SpringCloud ailibaba nacos    注意，这里不加版本会报错-->
       <dependency>
           <groupId>com.alibaba.cloud</groupId>
           <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
           <version>2.2.5.RELEASE</version>
       </dependency>

       <!-- SpringBoot整合Web组件 -->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-actuator</artifactId>
       </dependency>
       <!--日常通用jar包配置-->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-devtools</artifactId>
           <scope>runtime</scope>
           <optional>true</optional>
       </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <optional>true</optional>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
   </dependencies>
</project>

第三步： 改yml文件

server:
  port: 9001

spring:
  application:
    name: nacos-payment-provider
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #注册到哪，这里是配置Nacos的地址

management:
  endpoints:
    web:
      exposure:
        include: '*'

第四步： 主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@EnableDiscoveryClient
@SpringBootApplication
public class PaymentMain9001 {

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

}

第五步： 业务类

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

@RestController
public class PaymentController {

    @Value("${server.port}")
    private String serverPort;

    @GetMapping(value = "/pay/nacos/{id}")
    public String getPay(@PathVariable("id") Integer id) {
        return "nacos registry, serverPort: "+ serverPort+"\t id"+id;
    }
}

第六步： 启动测试，访问：http://localhost:9001/pay/nacos/1
在这里插入图片描述
同时，nacos的服务列表中，该服务就已经注册进去了。

同样的，参照以上步骤，新建一个cloud-provider-alibaba-payment9002的服务

4、Naco之服务消费者的注册和负载均衡

提问： 为什么nacos支持负载均衡？
答：因为spring-cloud-starter-alibaba-nacos-discovery内含netflix-ribbon包。

第一步： 新建一个Module，名为：cloud-consumer-alibaba-nacos-order83
第二步： 改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>cloud2021</artifactId>
        <groupId>com.oldou.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-alibaba-nacos-order83</artifactId>

    <dependencies>
        <!--SpringCloud ailibaba nacos -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <dependency>
            <groupId>com.oldou.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
        </dependency>
        <!-- SpringBoot整合Web组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--日常通用jar包配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

第三步： 改yml文件

server:
  port: 83

spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

#这里是消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者名称)
service-url:
  nacos-user-service: http://nacos-payment-provider

第四步： 主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

第五步： 业务类

ApplicationContextConfig

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ApplicationContextConfig {
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

OrderNacosController

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
@Slf4j
public class OrderNacosController {

   @Resource
   private RestTemplate restTemplate;

   @Value("${service-url.nacos-user-service}")
   private String serverURL;

   @GetMapping(value = "/consumer/pay/nacos/{id}")
   public String payInfo(@PathVariable("id") Long id) {
       return restTemplate.getForObject(serverURL+"/pay/nacos/"+id,String.class);
   }

}

第六步： 启动测试

启动9001/9002和刚刚创建的服务
访问http://localhost:83/consumer/pay/nacos/13
刷新，会发现端口号随着每次访问不断变化，轮询方式-负载均衡
同时，nacos中也有该服务的注册信息

5、Nacos之服务注册中心对比提示

Nacos的全景图展示：
在这里插入图片描述

Nacos和CAP

在这里插入图片描述
Nacos服务发现实例模型

重点注意： Nacos支持AP和CP模式的切换

C是所有节点在同一时间看到的数据是一致的;而A的定义是所有的请求都会收到响应。

何时选择使用何种模式?

—般来说，如果不需要存储服务级别的信息且服务实例是通过nacos-client注册，并能够保持心跳上报，那么就可以选择AP模式。当前主流的服务如Spring cloud和Dubbo服务，都适用于AP模式，AP模式为了服务的可能性而减弱了一致性，因此AP模式下只支持注册临时实例。
如果需要在服务级别编辑或者存储配置信息，那么CP是必须，K8S服务和DNS服务则适用于CP模式。CP模式下则支持注册持久化实例，此时则是以Raft协议为集群运行模式，该模式下注册实例之前必须先注册服务，如果服务不存在，则会返回错误。
切换命令： curl -X PUT '$NACOS_SERVER:8848/nacos/v1/ns/operator/switches?entry=serverMode&value=CP

6、Nacos之服务配置中心

第一步： 新建一个Module，名为：cloud-config-alibaba-nacos-client3377
第二步： 改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>cloud2021</artifactId>
        <groupId>com.oldou.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-config-alibaba-nacos-client3377</artifactId>
    <dependencies>
        <!--nacos-config-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>

        <!--nacos-discovery-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
        <!--web + actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--一般基础配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

第三步： 改yml文件

Nacos同springcloud-config一样，在项目初始化时，要保证先从配置中心进行配置拉取，拉取配置之后，才能保证项目的正常启动。
springboot中配置文件的加载是存在优先级顺序的，bootstrap优先级高于application
创建以下两个配置文件

bootstrap.yml

# nacos配置
server:
  port: 3377

spring:
  application:
    name: nacos-config-client
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #使用Nacos作为服务注册中心的地址
      config:
        server-addr: localhost:8848 #使用Nacos作为配置中心的地址
        file-extension: yaml #指定yaml格式的配置

# Nacos中的匹配规则公式，dataId的完整格式如下：
# ${prefix}-${spring.profile.active}.${file-extension}  最终公式如下：
# ${spring.application.name}-${spring.profile.active}.${spring.cloud.nacos.config.file-extension}

# 1、spring.application.name ---服务的名称

# 2、spring.profile.active --- 当前环境对应的profile，当这个为空时，对应的连接符 - 也将不存在，
#  dataId会变成${spring.application.name}.${spring.cloud.nacos.config.file-extension}
#  但是需要注意的是，这里最好不要为空

# 3、file-extension --- 配置内容的数据格式，可以通过 spring.cloud.nacos.config.file-extension 来进行配置
#  目前只支持properties 和 yaml 两种类型



# spring.application.name  为   nacos-config-client
# spring.profile.active  为 application.yml文件中的配置，值为 dev
# spring.cloud.nacos.config.file-extension 为 yaml
# 我们按照最终公式，当前环境的dataId最终为：nacos-config-client-dev.yaml


# nacos-config-client-test.yaml   ----> config.info

application.yml

spring:
 profiles:
   active: dev # 表示开发环境
   #active: test # 表示测试环境
   #active: prod

第四步： 主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

第五步： 业务类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RefreshScope  //此注解支持Nacos的动态刷新功能。
public class ConfigClientController {
    @Value("${config.info}")
    private String configInfo;

    @GetMapping("/config/info")
    public String getConfigInfo() {
        return configInfo;
    }
}

第六步：DataId配置属性介绍

Nacos中的dataid的组成格式及与SpringBoot配置文件中的匹配规则

官方文档说明
说明：之所以需要配置spring.application.name，是因为它是构成Nacos配置管理dataId 字段的一部分。
在 Nacos Spring Cloud中,dataId的完整格式如下：
${prefix}-${spring-profile.active}.${file-extension}
- prefix：默认为spring.application.name的值，也可以通过配置项spring.cloud.nacos.config.prefix来配置。
- spring.profile.active：即为当前环境对应的 profile，详情可以参考 Spring Boot文档。注意：当spring.profile.active为空时，对应的连接符 - 也将不存在，datald 的拼接格式变成${prefix}.${file-extension}
- file-exetension：为配置内容的数据格式，可以通过配置项spring .cloud.nacos.config.file-extension来配置。目前只支持properties和yaml类型。
- 通过Spring Cloud 原生注解@RefreshScope实现配置自动更新。
最后公式如下所示：
${spring.application.name)}-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
在我们这个配置中心的服务中，最终的dataId名为：nacos-config-client-dev.yaml，具体为什么是这个，请查看我在配置文件中标注的注释

第七步：在Nacos中添加配置信息
- 打开Nacos，点击
在这里插入图片描述
之后点击发布即可。

总结：
在这里插入图片描述
第八步： 启动测试

启动前需要在nacos客户端-配置管理-配置管理栏目下有对应的yaml配置文件
启动cloud-config-alibaba-nacos-client3377
调用接口查看配置信息，http://localhost:3377/config/info

Nacos自带动态刷新功能
我们在启动服务的情况下，修改下Nacos中的yaml配置文件，再次调用查看配置的接口，就会发现配置信息会根据修改进行动态刷新。

7、Nacos之命名空间、分组以及DataId之间的关系

问题一：多环境多项目管理

（1）我们在实际开发中，通常一个系统会有多个环境【开发、测试、生产…等等】，那么如何保证指定环境启动时服务能正确读取到Nacos上相应环境的配置文件呢?
（2）一个大型分布式微服务系统会有很多微服务子项目，每个微服务项目又都会有相应的开发环境、测试环境、预发环境、正式环境…怎么对这些微服务配置进行管理呢?

Nacos的图形化管理界面
在这里插入图片描述

我们在Nacos的界面中发现，Nacos有DataId、Group、命名空间。

提问：Namespace+Group+Data lD三者有什么关系？为什么这么设计？

这三个类似Java里面的package名和类名，最外层的namespace是可以用于区分部署环境的，Group和DatalD逻辑上区分两个目标对象。

三者情况如下图所示：
在这里插入图片描述
默认情况：Namespace=public，Group=DEFAULT_GROUP，默认Cluster是DEFAULT

Nacos默认的Namespace【命名空间】是public，Namespace主要用来实现隔离。
- 比方说我们现在有三个环境：开发、测试、生产环境，我们就可以创建三个Namespace，不同的Namespace之间是相互隔离的。
Group默认是DEFAULT_GROUP，Group可以把不同的微服务划分到同一个分组里面去
Service就是微服务：一个Service可以包含多个Cluster (集群)，Nacos默认Cluster是DEFAULT，Cluster是对指定微服务的一个虚拟划分。
- 比方说为了容灾，将Service微服务分别部署在了杭州机房和广州机房，这时就可以给杭州机房的Service微服务起一个集群名称(HZ) ，给广州机房的Service微服务起一个集群名称(GZ)，还可以尽量让同一个机房的微服务互相调用，以提升性能。
最后是Instance，就是微服务的实例。

8、Nacos之DataID配置

重点： 指定spring.profile.active和配置文件的DatalD来使不同环境下读取不同的配置

默认空间+默认分组+新建dev和test两个DatalD

在Nacos中，新建一个dev配置DatalD【我们在上面一节已经新建了】
在Nacos中，新建一个test配置DatalD
通过spring.profile.active属性就能进行多环境下配置文件的读取，这里我们配置读取test的【nacos-config-client-test.yaml】

测试： 访问http://localhost:3377/config/info

配置什么环境，就读取什么环境的配置文件。

9、Nacos之Group分组方案

通过Group实现环境区分：新建两个相同DataId的配置文件，但是配置时使用不同的分组。

在这里插入图片描述

接下来我们还需要去修改bootstrap.yml和application.yml文件

启动测试：

将bootstrap.yml中的分组配置成DEV_GROUP

因此，以上就实现了DataId相同，但是可以根据配置分组来实现不同环境的隔离。

10、Nacos之Namespace命名空间方案

通过Namespace实现环境区分：Nacos有一个默认的命名空间public，这个命名空间不可修改/删除，同时当我们新建一个命令空间时，新建的命名空间会有一个命名空间ID。
在这里插入图片描述

命名空间创建之后，我们可以在配置管理中进行选择，并新建配置

我们在dev命名空间下新建以下三个配置：

YML更改： 由于我们使用命名空间，所以要添加配置，这里由于我使用的是dev，因此要将dev的命名空间id给设置进去
在这里插入图片描述
测试

学会使用命名空间很重要，这里我不过多介绍，其余的自行测试。

11、Nacos之集群以及架构说明（重点）

Nacos集群官方文档说明

官网架构图
集群部署架构图
因此开源的时候推荐用户把所有服务列表放到一个vip下面，然后挂到一个域名下面

http://ip1:port/openAPI 直连ip模式，机器挂则需要修改ip才可以使用。
http://VIP:port/openAPI 挂载VIP模式，直连vip即可，下面挂server真实ip，可读性不好。
http://nacos.com:port/openAPI 域名＋VIP模式，可读性好，而且换ip方便，推荐模式

根据官方给出的介绍，总结如下：
在这里插入图片描述
以上结构图中，配置Nacos的集群，首先需要Nginx集群，Nacos集群，还有就是数据库Mysql

Nacos的环境部署介绍

Nacos默认使用嵌入式数据库实现数据的存储。如果启动多个默认配置下的Nacos节点，数据存储是存在一致性问题的。为了解决这个问题，Nacos采用了集中式存储的方式来支持集群化部署，目前只支持MySQL的存储。

Nacos支持三种部署模式

单机模式-用于测试和单机试用。
集群模式-用于生产环境，确保高可用。
多集群模式-用于多数据中心场景。

12、Nacos之持久化切换配置（重点）

Nacos默认自带的是嵌入式数据库derby，nacos的pom.xml中就可以看出。
而我们要实现持久化，一般会使用Mysql。

将Nacos从derby到mysql切换配置步骤在安装Nacos处就已经介绍过：

我们先去数据库中，创建一个名为nacos的数据库，字符集为utf-8，排序规则为如下所示，然后在该数据库中导入nacos\conf\nacos-mysql.sql文件
找到nacos\conf\application.properties文件，取消以下注释，同时填写好自己数据库信息

启动Nacos，可以看到是个全新的空记录界面，以前是记录进derby，当然了，这里我们安装的时候就已经将持久化设置成了Mysql，所以记录还是会有的。

13、Nacos之Linux版本的安装（重点）

实际上，我们要配置Nacos的集群的话，是需要2个Nginx+3个Nacos注册中心+Mysql集群，但是这里不过多介绍。

环境需求： 我们需要1个Nginx+3个nacos注册中心+1个mysql

Centos 7.x，IP为：192.168.15.131
安装好了JDK1.8
安装好Nginx，请参考此文章，这里单机版和集群版都有。
安装好Mysql，请参考这篇文章

安装步骤：

Nacos的下载地址，这里我们下载Linux版本的，下载完毕之后上传到Linux上
解压：tar -zxf nacos-server-2.0.2.tar.gz nacos
拷贝：cp nacos /usr/local/ -r
进入到bin目录下cd /usr/local/nacos/bin
将启动文件备份cp startup.sh startup.sh.bk -r

14、Nacos之集群配置（上）（重点）

第一步：Linux服务器上mysql数据库配置

首先，我们需要在Linux的数据库上执行Nacos的数据库脚本，当然了，我们下载的版本一致的话，使用Windows上的Nacos SQL脚本也是一样的，由于我这里使用Navicat连接了Linux上的Mysql，所以我就在Windows上执行了。
新建数据库nacos_config
运行nacos-mysql.sql脚本

第二步：修改application.properties文件

位置：/usr/local/nacos/conf/application.properties
修改前先备份：cp application.properties application.properties.init
修改配置：vim application.properties

第三步：Linux服务器上Nacos的集群配置cluster.conf

目的：梳理出三台Nacos机器的不同服务端口号【3333、4444、5555】
文件备份：cp cluster.conf.example cluster.conf
编辑：vim cluster.conf，注意，这里的ip不能写127.0.0.1，必须是Linux命令hostname -i能够识别的ip
编辑内容，然后保存退出：

第四步：编辑Nacos的启动脚本startup.sh，使它能够接受不同的启动端口
进入到bin目录下，备份好startup.sh文件之后，开始编辑
vim startup.sh

需要注意的是，新版的nacos中的p不是端口，不是端口，不是端口，重要的说三遍，找了好久的原因。

到最底部，修改如下所示：

nohup $JAVA - Dserver.port=${PORT} ${JAVA_OPT} nacos.nacos >> ${BASE_DIR}/logs/start.out 2>&1 &

# 注意：EMBEDDED_STORAGE就是上图中的 EMBEDDED_STORAGE=$OPTARG;;

在这里插入图片描述

由于Nacos启动的话，所占用的内存会非常大，因此我们需要调一下内存，这里我们设置最大为256m最小为128m。可根据自身情况进行设定。如果内存大的请忽略该修改

第五步：启动方式

启动的命令为：startup.sh - t 端口号
例如：我们启动startup.sh - t 3333就是启动了端口3333的nacos，然后再执行startup.sh - t 4444就相当于又启动了端口4444的nacos

到这里，Nacos的配置基本上就是完成了，接下来就是配置Nginx了。

15、Nacos之集群配置（下）（重点）

Nginx的安装目录如下所示，这里因为我在/usr/local下已经有一个Nginx了，所以安装在这个位置
在这里插入图片描述
备份nginx.conf文件： cp nginx.conf nginx.conf.bk

编辑： vim nginx.conf
在这里插入图片描述

启动测试：

启动三台Nacos
- /usr/local/nacos/bin/startup.sh -t 3333
- /usr/local/nacos/bin/startup.sh -t 4444
- /usr/local/nacos/bin/startup.sh -t 5555
查看Nacos是否启动了三台：ps -ef|grep nacos|grep -v grep | wc -l
如果三台nacos启动不了的话，可能是配置错误或者是需要重启一下虚拟机
启动Nginx，/root/upload-file/nginx/sbin/nginx -c /root/upload-file/nginx/conf/nginx.conf
查看Nginx是否启动：ps -ef|grep nginx
访问Nacos：http://192.168.15.131:1111/nacos/#/login
新建一个配置测试
新建后，可在linux服务器的mysql中查看到新插入了一条记录
select * from config;

以上测试结果表示配置成功，接下来我们让微服务cloud-provider-alibaba-payment9002启动注册进nacos集群 - 修改配置文件

server:
  port: 9002

spring:
  application:
    name: nacos-payment-provider
  c1oud:
    nacos:
      discovery:
        #配置Nacos地址
        #server-addr: Localhost:8848
        #换成nginx的1111端口，做集群
        server-addr: 192.168.111.144:1111

management:
  endpoints:
    web:
      exposure:
        inc1ude: '*'

配置文件中的地址写成Nginx的地址以及端口，然后由Nginx转发给Nacos集群

启动微服务cloud-provider-alibaba-payment9002，访问nacos，查看注册结果

高可用总结：
在这里插入图片描述
以上测试中，我们9002服务找到Nginx，Nacos集群的机器数目是多少不用管，服务只找Nginx，然后由Nginx进行转发，转发到Nacos集群中的某台机器，最后写进Mysql，最终实现高可用。

十四、SpringCloud Alibaba组件之Sentinel【服务熔断与限流】

1、Sentinel基本概念

Sentinel是什么？

随着微服务的流行，服务和服务之间的稳定性变得越来越重要。
Sentinel 是面向分布式服务架构的流量控制组件，主要以流量为切入点，从流量控制、熔断降级、系统自适应保护等多个维度来帮助您保障微服务的稳定性。

Sentinel的基本特征：

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

服务中遇到的各种问题：

服务雪崩
服务降级
服务熔断
服务限流

为什么已经有Hystrix了还要出现Sentinel？

Hystrix需要我们程序员自己手工搭建监控平台，而Sentinel是单独一个组件，可以独立出来
Hystrix没有一套web界面可以给我们进行更加细粒度化得配置流控、速率控制、服务熔断、服务降级，而Sentinel直接界面化的细粒度统一配置。
Hystrix已经宣布停更了，社区活跃度不高

Sentinel 分为两个部分：

核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。
控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

2、Sentinel下载安装运行

Sentinel的官方使用教程

Sentinel的下载地址

下载到本地是一个sentinel-dashboard-1.8.2.jar
在这里插入图片描述
如何运行？

首先，保证本机有JDK1.8以及以上环境
本机的8080端口不能被占用
运行很简单，就是在电脑上的cmd，运行java -jar +sentinel的jar包就可以了
运行之后，我们访问Sentinel管理界面，localhost:8080，账号密码均为sentinel

3、Sentinel初始化监控

前提：

启动本机电脑上的Nacos
启动Sentinel，上节中我们已经启动

需要新建一个微服务，该微服务注册进Nacos，同时使用Sentinel进行流量监控

第一步： 新建一个Module，名为：cloud-alibaba-sentinel-service8401
第二步： 改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>cloud2021</artifactId>
        <groupId>com.oldou.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-alibaba-sentinel-service8401</artifactId>

    <dependencies>
        <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
            <groupId>com.oldou.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--SpringCloud ailibaba nacos -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--SpringCloud ailibaba sentinel-datasource-nacos 后续做持久化用到-->
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-nacos</artifactId>
        </dependency>
        <!--SpringCloud ailibaba sentinel -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <!--openfeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- SpringBoot整合Web组件+actuator -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--日常通用jar包配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

第三步： 改yml文件

server:
  port: 8401

spring:
  application:
    name: cloud-alibaba-sentinel-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #Nacos服务注册中心地址
    sentinel:
      transport:
        dashboard: localhost:8080 #配置Sentinel dashboard地址
        port: 8719

management:
  endpoints:
    web:
      exposure:
        include: '*'

feign:
  sentinel:
    enabled: true # 激活Sentinel对Feign的支持

第四步： 主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

第五步： 业务类

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Slf4j
public class FlowLimitController {
    @GetMapping("/testA")
    public String testA() {
        return "------testA";
    }

    @GetMapping("/testB")
    public String testB() {
        log.info(Thread.currentThread().getName()+"\t"+"...testB");
        return "------testB";
    }
}

第六步： 启动测试，启动微服务cloud-alibaba-sentinel-service8401

去Sentinel Dashboard管理界面上查看

我们发现，Sentinel的监控页面空空如也，啥都没有，这是因为Sentinel采用的懒加载机制
我们访问以下8401服务上的接口，Sentinel Dashboard实时监控8401
- 访问：http://localhost:8401/testA ，http://localhost:8401/testB，多访问几次
再次刷新Sentinel Dashboard，发现已经有服务访问的监控数据了

总结： sentinel8080正在监控微服务8401

4、Sentinel流控规则简介

流控，指的是流量监控。
在这里插入图片描述
流控规则的参数解释说明：

资源名：唯一名称，默认请求路径。
针对来源：Sentinel可以针对调用者进行限流，填写微服务名，默认default（不区分来源）。
阈值类型/单机阈值：
- QPS(每秒钟的请求数量)︰当调用该API的QPS达到阈值的时候，进行限流。
- 线程数：当调用该API的线程数达到阈值的时候，进行限流。
是否集群：不需要集群。
流控模式：
- 直接：API达到限流条件时，直接限流。【默认】
- 关联：当关联的资源达到阈值时，就限流自己。
- 链路：只记录指定链路上的流量（指定资源从入口资源进来的流量，如果达到阈值，就进行限流)【API级别的针对来源】。
流控效果：
- 快速失败：直接失败，抛异常。
- Warm up：根据Code Factor（冷加载因子，默认3）的值，从阈值/codeFactor，经过预热时长，才达到设置的QPS阈值。
- 排队等待：匀速排队，让请求以匀速的速度通过，阈值类型必须设置为QPS，否则无效。

5、Sentinel流控-QPS直接失败

上节我们介绍了流控规则的基本参数，这节我们开始配置，【QPS–>直接–>快速失败】

重点：当调用该API的每秒钟的请求数量达到阈值的时候，进行限流。

我们打开Sentinel dashboard，点击左边的簇点链路
在这里插入图片描述
我们本地要对/testA接口添加一个流控，点击右边的流控，设置的意思为：当我们的/testA接口每秒请求超过【单机阈值】一次，那么就会【直接快速失败】直接报错。

点击新建之后，我们就可以在流控规则出看到新增了一条规则，此规则可进行修改/删除
在这里插入图片描述
测试：

访问：http://localhost:8401/testA，当一秒钟访问一次的时候，是没有任何问题的，但是一秒钟超过一次之后，就会报错
报错信息为：Blocked by Sentinel (flow limiting) 哨兵阻挡(流量限制)

当然，这是Sentinel默认的提示信息，我们是可以对提示信息进行设置的，它可以进行自定义的后续处理，类似fallback的兜底方法，请看后文设置。

6、Sentinel流控-线程数直接失败

重点：当调用该API的线程数达到阈值的时候，进行限流。

我们在/testA接口中添加一个线程睡眠800ms：
在这里插入图片描述
然后去Sentinel的监控页面，编辑流控规则，将阈值类型改成【并发线程数】，点击确认

测试：

这个时候选择的是并发线程数为1，所以当我们单独使用一个线程去调用时，出现短暂的转圈之后访问成功，但是我们使用两个访问同时去访问时，就会报错。
这个类似于银行网点，只有一个工作人员【单机阈值只允许一个线程】，当每秒的请求数目不管再多，只要线程数目不超过一个，还是可以访问成功的，但是超过阈值之后就会进行限流。

7、Sentinel流控-关联

Sentinel流控有三种模式，分别是：直接【默认】、关联、链路，而此次我们讲解的是关联

关联：当自己关联的资源达到阈值时，就限流自己。
当与A关联的资源B达到阀值后，就限流A自己（B惹事，A挂了）

我们cloud-alibaba-sentinel-service8401服务中有/testA和/testB两个接口，因此我们设置/testA，打开Sentinel 控制台，找到流控规则，点击编辑
在这里插入图片描述
将代码中的延时去除：

使用Postman工具模拟并发密集访问testB

打开Postman，新建一个Collections和请求B，并将请求B保存在该Collections中，该请求B能够保证访问成功
按照以下步骤操作

然后点击【Run Test 2021】，在访问testB的同时，我们迅速在浏览器访问testA，这个时候testA挂了

当testB的线程访问结束之后，我们再去访问testA，这个时候又正常了。

结论： 大批量线程高并发访问B，由于B与A进行了关联，所以导致A失效了。

应用场景： 当双十一的时候，当支付接口达到阈值以后，就限流下订单的服务防止连座效应。

Sentinel流控-链路：只记录指定链路上的流量（指定资源从入口资源进来的流量，如果达到阈值，就进行限流)【API级别的针对来源】

8、Sentinel流控-预热

官网地址
概念： 预热，Warm Up（RuleConstant.CONTROL_BEHAVIOR_WARM_UP）方式，即预热/冷启动方式，当系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统被压垮。

通常冷启动的过程系统允许通过的 QPS 曲线如下图所示：
在这里插入图片描述

默认coldFactor为3，即请求QPS 从 threshold / 3开始，经预热时长逐渐升至设定的QPS阈值。链接

那实际的解释一下，如下所示：
在这里插入图片描述

我们设置testA，希望它每秒钟能够承受10个请求，但是我们给它慢慢预热起来，冷加载因子默认是3，一运行的时候单机阈值就是【10/3=3】个，然后给你一个缓存预热的时间5秒，在5秒后，单机阈值慢慢的从3个升到10个。

【系统初始化的阀值为10/ 3约等于3,即阀值刚开始为3;然后过了5秒后阀值才慢慢升高恢复到10】

公式： 阈值除以coldFactor（默认值是3），经过预热时长后才会达到阈值

源码 - com.alibaba.csp.sentinel.slots.block.flow.controller.WarmUpController

测试： 将testA设置成如下所示：
在这里插入图片描述
不断迅速刷新访问testA，就会发现访问成功，然后报错，然后成功，然后报错然后一直成功。

应用场景 ：秒杀系统在开启的瞬间，会有很多流量上来，很有可能把系统打死，预热方式就是把为了保护系统，可慢慢的把流量放进来,慢慢的把阀值增长到设置的阀值。

9、Sentinel流控-排队等待

排队等待： 匀速排队，让请求以均匀的速度通过，阀值类型必须设成QPS，否则无效。

个人理解： 当B的QPS设置成1时，此时有大量的请求同时访问B接口，此时B只会一秒钟处理一个请求，其他的请求超时也好等待也好随意。

设置： /testB每秒1次请求，超过的话就排队等待，等待的超时时间为20000毫秒
在这里插入图片描述
匀速排队： RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER，此方式会严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法。详细文档可以参考流量控制 - 匀速器模式，具体的例子可以参见 PaceFlowDemo。
在这里插入图片描述
这种方式主要用于处理间隔性突发的流量，例如消息队列。想象一下这样的场景，在某一秒有大量的请求到来，而接下来的几秒则处于空闲状态，我们希望系统能够在接下来的空闲期间逐渐处理这些请求，而不是在第一秒直接拒绝多余的请求。

注意：匀速排队模式暂时不支持 QPS > 1000 的场景。链接

源码 - com.alibaba.csp.sentinel.slots.block.flow.controller.RateLimiterController

测试：

在源码中给testB添加打印线程名称的方法
Postman模拟并发密集访问testB
后台结果

10、Sentinel熔断降级简介

官方文档介绍

熔断降级概述

除了流量控制以外，对调用链路中不稳定的资源进行熔断降级也是保障高可用的重要措施之一。一个服务常常会调用别的模块，可能是另外的一个远程服务、数据库，或者第三方 API 等。例如，支付的时候，可能需要远程调用银联提供的 API；查询某个商品的价格，可能需要进行数据库查询。然而，这个被依赖服务的稳定性是不能保证的。如果依赖的服务出现了不稳定的情况，请求的响应时间变长，那么调用服务的方法的响应时间也会变长，线程会产生堆积，最终可能耗尽业务自身的线程池，服务本身也变得不可用。
现代微服务架构都是分布式的，由非常多的服务组成。不同服务之间相互调用，组成复杂的调用链路。以上的问题在链路调用中会产生放大的效果。复杂链路上的某一环不稳定，就可能会层层级联，最终导致整个链路都不可用。因此我们需要对不稳定的弱依赖服务调用进行熔断降级，暂时切断不稳定调用，避免局部不稳定因素导致整体的雪崩。熔断降级作为保护自身的手段，通常在客户端（调用端）进行配置。

在这里插入图片描述
熔断策略的三种模式介绍：

RT----平均响应时间，秒级，V1.7及以下版本
- 平均响应时间超出阈值且在时间窗口内通过的请求>=5，两个条件同时满足后触发降级。
- 窗口期过后关闭断路器。
- RT最大4900（更大的需要通过-Dcsp.sentinel.statistic.max.rt=XXXX才能生效）。
异常比列—秒级
- QPS >= 5且异常比例（秒级统计）超过阈值时，触发降级;时间窗口结束后，关闭降级。
  异常数(分钟级)
异常数----分钟统计
- 超过阈值时，触发降级;时间窗口结束后，关闭降级
注意：Sentinel 1.7.0才有平均响应时间（DEGRADE_GRADE_RT），Sentinel 1.8.0的没有这项，取而代之的是慢调用比例 (SLOW_REQUEST_RATIO)。
慢调用比例 (SLOW_REQUEST_RATIO)：选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用。当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。链接

Sentinel熔断降级介绍

Sentinel熔断降级会在调用链路中某个资源出现不稳定状态时（例如调用超时或异常比例升高)，对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联错误。
当资源被降级后，在接下来的降级时间窗口之内，对该资源的调用都自动熔断（默认行为是抛出 DegradeException）。
Sentinei的断路器是没有类似Hystrix半开状态的。(Sentinei 1.8.0 已有半开状态)
半开的状态系统自动去检测是否请求有异常，没有异常就关闭断路器恢复使用，有异常则继续打开断路器不可用。

Sentinel实现的熔断其实就会导致服务降级。

11、Sentinel服务降级-RT【V1.7】

RT的基本概念：

平均响应时间(DEGRADE_GRADE_RT)：当1s内持续进入5个请求，对应时刻的平均响应时间（秒级）均超过阈值（ count，以ms为单位），那么在接下的时间窗口（DegradeRule中的timeWindow，以s为单位）之内，对这个方法的调用都会自动地熔断(抛出DegradeException )。
注意Sentinel 默认统计的RT上限是4900 ms，超出此阈值的都会算作4900ms，若需要变更此上限可以通过启动配置项-Dcsp.sentinel.statistic.max.rt=xxx来配置。

在这里插入图片描述

RT测试

新增一个接口

@GetMapping("/testC")
    public String testC() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("testC 测试RT");
        return "testC 测试RT";
    }

Sentinel 工作台中新增一个熔断降级规则
jmeter压测设置

测试结果：按照上述配置，永远一秒钟打进来10个线程（大于5个了）调用testD，我们希望200毫秒处理完本次任务，如果超过200毫秒还没处理完，在未来1秒钟的时间窗口内，断路器打开（保险丝跳闸）微服务不可用，保险丝跳闸断电了后续我停止jmeter，没有这么大的访问量了，断路器关闭（保险丝恢复），微服务恢复OK。

11、Sentinel服务降级-慢调用比例【V1.8】

在这里插入图片描述

由于Sentinel 1.7.0才有平均响应时间（DEGRADE_GRADE_RT），但是Sentinel 1.8.0的没有这项，取而代之的是慢调用比例 (SLOW_REQUEST_RATIO)。

选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用。当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。链接

也就是说Sentinel在1.8.0版本对熔断降级做了大的调整，可以定义任意时长的熔断时间，引入了半开启恢复支持。

V1.8版本的熔断状态： 有三种，分别为OPEN、HALF_OPEN、CLOSED
在这里插入图片描述
熔断降级支持慢调用比例、异常比例、异常数三种熔断策略。

慢调用比例的基本属性介绍
在这里插入图片描述
执行逻辑：

熔断（OPEN）： 请求数大于最小请求数并且慢调用的比率大于比例阈值则发生熔断，熔断时长为用户自定义设置。
探测（HALFOPEN）： 当熔断过了定义的熔断时长，状态由熔断（OPEN）变为探测（HALFOPEN）。
如果接下来的一个请求小于最大RT，说明慢调用已经恢复，结束熔断，状态由探测（HALF_OPEN）变更为关闭（CLOSED）
如果接下来的一个请求大于最大RT，说明慢调用未恢复，继续熔断，熔断时长保持一致
注意Sentinel默认统计的RT上限是4900ms，超出此阈值的都会算作4900ms，若需要变更此上限可以通过启动配置项-Dcsp.sentinel.statistic.max.rt=xxx来配置

12、Sentinel服务降级-异常比例

Sentinel V1.7版本
基本概念：

异常比例（DEGRADE_GRADE_EXCEPTION_RATIO）：当资源的每秒请求量 >= 5，并且每秒异常总数占通过量的比值超过阈值（ DegradeRule中的 count）之后，资源进入降级状态，即在接下的时间窗口(DegradeRule中的timeWindow，以s为单位）之内，对这个方法的调用都会自动地返回。异常比率的阈值范围是[0.0, 1.0]，代表0% -100%。

也就是说，满足QPS≥5，并且每秒异常总数占通过量的比值超过阈值（ DegradeRule中的 count）这两个条件才能触发服务熔断降级。

1.7版本测试：

新增一个接口

@GetMapping("/testD")
    public String testD() {
        log.info("testD 异常比例");
        int age = 10/0;
        return "------testD";
    }

设置异常比例，下图的意思就是：假如每秒有10个请求（10>5），当10个请求中报异常的超过了20%就会进行服务熔断。
使用jmeter进行压测，每秒钟发10个请求

但是需要注意的是，以上描述的是Sentinel1.8之前的，与Sentinel 1.8.0相比，有些不同（Sentinel 1.8.0才有的半开状态），Sentinel 1.8.0的如下：

Sentinel V1.8版本

异常比例（ERROR_RATIO）：当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 [0.0, 1.0]，代表 0% - 100%。链接

在这里插入图片描述
V1.8版本更改了描述，

当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目
且异常的比例大于阈值
则接下来的熔断时长内请求会自动被熔断
经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断

之前的QPS是每秒内的请求次数大于5次，这个在1.8版本之前是限定死的，不可修改，而在1.8版本之后，这些是可以设置的，按照上图中的设置，意思就是：设置了2秒内的请求大于大于5个，并且请求数目中发生异常的比例≥20%，那么接下来在2秒内请求会被自动熔断，当2秒后的下一个请求成功了则会结束熔断，否则会再次被熔断

13、Sentinel服务降级-异常数

Sentinel V1.7版本

异常数（DEGRADE_GRADF_EXCEPTION_COUNT）：当资源近1分钟的异常数目超过阈值之后会进行熔断。注意由于统计时间窗口是分钟级别的，若timeWindow小于60s，则结束熔断状态后码可能再进入熔断状态。

注意：异常数是按照分钟统计的，时间窗口一定要大于等于60秒。
在这里插入图片描述
1.7版本的测试：

代码新增接口

	@GetMapping("/testE")
    public String testE(){
        log.info("testE 测试异常数");
        int age = 10/0;
        return "------testE 测试异常数";
    }

异常数设置
以上设置的意思就是：当70秒钟以内的请求报异常超过5次，那么服务就会进行熔断降级。
启动测试，访问以上接口，访问6次，会发现第5次就不会报异常了，而是报熔断提示信息。

注意，与Sentinel 1.8.0相比，有些不同（Sentinel 1.8.0才有的半开状态），Sentinel 1.8.0的如下：

Sentinel V1.8版本

异常数 （ERROR_COUNT）：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。

在这里插入图片描述
这些参数是都可以设置的，请结合概念加以理解。

14、Sentinel热点Key限流（上）

在这里插入图片描述

热点的概念

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

比如：

商品 ID 为参数，统计一段时间内最常购买的商品 ID 并进行限制
用户 ID 为参数，针对一段时间内频繁访问的用户 ID 进行限制

热点参数限流会统计传入参数中的热点参数，并根据配置的限流阈值与模式，对包含热点参数的资源调用进行限流。热点参数限流可以看做是一种特殊的流量控制，仅对包含热点参数的资源调用生效。
在这里插入图片描述
Sentinel 利用 LRU 策略统计最近最常访问的热点参数，结合令牌桶算法来进行参数级别的流控。热点参数限流支持集群模式。

提示信息： 我们之前说到，Sentinel出现熔断限流后，都是用的系统默认提示: Blocked by Sentinel (flow limiting)，那么我们能不能想Hystrix一样有一个兜底的方法，能够自己定义提示信心呢？
从HystrixCommand到@SentinelResource

案例演示：演示第一个参数p1，当QPS超过1秒1次点击后马上被限流。

代码修改： 我们在cloud-alibaba-sentinel-service8401服务中新增以下代码

	@GetMapping("/testHotKey")
    @SentinelResource(value = "testHotKey",blockHandler/*兜底方法*/ = "deal_testHotKey")
    public String testHotKey(@RequestParam(value = "p1",required = false) String p1,
                             @RequestParam(value = "p2",required = false) String p2) {
        //int age = 10/0;
        return "------testHotKey";
    }
    
    /*兜底方法*/
    public String deal_testHotKey (String p1, String p2, BlockException exception) {
        //sentinel系统默认的提示：Blocked by Sentinel (flow limiting)
        return "------deal_testHotKey,o(╥﹏╥)o";  
    }

Sentinel控制台配置
在这里插入图片描述
以上的配置说明：资源名称为@SentinelResource(value = "testHotKey",blockHandler/*兜底方法*/ = "deal_testHotKey")的value的值，参数索引为对索引为0的参数进行限流，我们这里有两个参数【p1和p2】，因此索引为0的是p1，单机阈值设置为1，窗口时长也是设置为1，也就是说：1秒钟访问不能超过1次。方法testHotKey里面第一个参数只要QPS超过每秒1次，马上熔断降级处理

测试：

访问：http://localhost:8401/testHotKey?p1=abc&p2=33，先一秒刷新一次，然后1秒刷新两次及以上
http://localhost:8401/testHotKey?p1=abc
以上测试会发现，我们现在的提示信息就是我们自定义的提示信息了。
当我们访问http://localhost:8401/testHotKey?p2=abc，不管你刷多少次，都不会限流。

@SentinelResource的注解说明

我们在程序中配置的是@SentinelResource(value = "testHotKey", blockHandler = "dealHandler_testHotKey")
当我们将配置修改成@SentinelResource(value = "testHotKey")时，也就是不需要兜底的方法时，服务进行熔断降级后会将异常打到了前台用户界面看到，这样特别不友好，因此使用此注解，强烈建议配置兜底的方式。

15、Sentinel热点Key限流（下）

上节案例我们演示了对第一个参数p1进行热点Key的限流，当QPS超过1秒1次点击后马上被限流。本节主要讲述参数例外项

本节目标：

我们上节配置的普通热点Key限流，参数p1的QPS，达到阈值1后马上被限流
我们期望p1参数当它是某个特殊值时，它的限流值和平时不一样，阈值可以达到更高或变得更低
特例 - 假如当p1的值等于5时，它的阈值可以达到200

配置
在这里插入图片描述
这里需要注意的是：参数类型为8中基本数据类型和String类型，根据需要限流的参数类型进行选择，设置好特殊值之后记得要点击添加。

测试：

正确：http://localhost:8401/testHotKey?p1=5，当p1等于5的时候，阈值变为200，只要一秒内不超过200次，都是正常
错误：http://localhost:8401/testHotKey?p1=3，当一秒内超过1次，就会限流

注意事项：

@SentinelResource只处理sentinel控制台配置的违规情况，有blockHandler方法配置的兜底处理，但是如果接口内报异常的话，那么是不会调用兜底的提示信息的。如下所示：
RuntimeException int age = 10/0，这个是java运行时报出的运行时异常RunTimeException，@SentinelResource不管
@SentinelResource主管配置出错，运行出错该走异常走异常

16、Sentinel系统规则介绍

官方文档

我们前面的限流，范围基本上是对系统的某个接口甚至方法，而本节介绍的是对整个系统进行自适应限流，举个例子说：整个系统就相当于一个小区，而里面的住户就相当于一个个的接口，之前的都是面向住户的，而这个就是面向小区所有住户的。

系统自适应限流：

Sentinel 系统自适应限流从整体维度对应用入口流量进行控制，结合应用的 Load、CPU 使用率、总体平均 RT、入口 QPS 和并发线程数等几个维度的监控指标，通过自适应的流控策略，让系统的入口流量和系统的负载达到一个平衡，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。

系统规则介绍

系统保护规则是从应用级别的入口流量进行控制，从单台机器的 load、CPU 使用率、平均 RT、入口 QPS 和并发线程数等几个维度监控应用指标，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。
系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量生效。入口流量指的是进入应用的流量（EntryType.IN），比如 Web 服务或 Dubbo 服务端接收的请求，都属于入口流量。

在这里插入图片描述

系统规则支持的模式：

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 达到阈值即触发系统保护。

17、Sentinel之@SentinelResource配置（上）

（1）按照资源名称进行限流处理

目标：根据@SentinelResource注解中属性value的值进行限流
环境：需要启动Nacos、Sentinel控制台

业务类：在cloud-alibaba-sentinel-service8401服务中新增一个名为RateLimitController的业务类

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RateLimitController {
    
    @GetMapping("/byResource")
    @SentinelResource(value = "byResource",blockHandler = "handleException")
    public CommonResult byResource() {
        return new CommonResult(200,"按资源名称限流测试OK",new Payment(2020L,"serial001"));
    }
    
    public CommonResult handleException(BlockException exception) {
        return new CommonResult(444,exception.getClass().getCanonicalName()+"\t 服务不可用");
    }

}

配置，新增流控规则
测试：访问http://localhost:8401/byResource，当QPS大于1时会调用我们自定义的异常提示方法
问题：当我们在IDEA中停止cloud-alibaba-sentinel-service8401服务的运行时，Sentinel控制台上配置的流控规则消失了！！！【持久性和临时性问题】

（2）按照访问的URL进行限流处理

目标： 通过访问的URL来限流，会返回Sentinel自带默认的限流处理信息，如下图所示：

业务类：新增以下接口，注意我们的url和resource是不一样的，之前配置时一样的，同时没有blockHandler的配置

    @GetMapping("/rateLimit/byUrl")
    @SentinelResource(value = "byUrl")
    public CommonResult byUrl() {
        return new CommonResult(200,"按url限流测试OK",new Payment(2020L,"serial002"));
    }

配置：新增流控规则，这里我在资源名配置的是url
测试：快速点击http://localhost:8401/rateLimit/byUrl，会返回Sentinel自带的限流处理结果 Blocked by Sentinel (flow limiting)

（3）以上两个测试的实现出现的问题：

兜底方案有系统默认的，没有体现我们自己的业务要求。
依照现有条件，我们自定义的处理方法又和业务代码耦合在一块，不直观。
每个业务方法都添加—个兜底的方法，导致代码膨胀加剧。
全局统—的处理方法没有体现。

18、Sentinel之@SentinelResource配置（中）

本节重点：自定义限流处理逻辑

自定义限流处理类

创建CustomerBlockHandler类用于自定义限流处理逻辑

package com.oldou.springcloud.config;

import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.oldou.springcloud.entities.CommonResult;

public class CustomerBlockHandler {
    // 注意：这里不能是private，同时必须是static的
    public static CommonResult handlerException(BlockException exception) {
        return new CommonResult(4444,"按客戶自定义,global handlerException----1");
    }
    
    public static CommonResult handlerException2(BlockException exception) {
        return new CommonResult(4444,"按客戶自定义,global handlerException----2");
    }
}

RateLimitController新增接口：

	@GetMapping("/rateLimit/customerBlockHandler")
    @SentinelResource(value = "customerBlockHandler", //<-------- 限流规则
            blockHandlerClass = CustomerBlockHandler.class,//<-------- 指向自定义限流处理类
            blockHandler = "handlerException2")//<----------- 指向那个方法
    public CommonResult customerBlockHandler() {
        return new CommonResult(200,"按客戶自定义",new Payment(2020L,"serial003"));
    }

Sentinel控制台配置流控规则：
在这里插入图片描述
测试：

启动微服务，访问http://localhost:8401/rateLimit/customerBlockHandler，多刷新几次可以看见我们自定义的提示信息已经打印出来了。

解释：

@SentinelResource(value = "customerBlockHandler", //<-------- 限流规则
            blockHandlerClass = CustomerBlockHandler.class,//<-------- 指向自定义限流处理类
            blockHandler = "handlerException2")

value ：这里我们指向的是Sentinel中配置的流控规则
blockHandlerClass ：这里的意思是当违背了流控规则之后，我们兜底的类是哪一个？
blockHandler ：这个是从兜底的类中去哪个方法进行调用

结论： 解决了上一节提出的四个问题。

19、Sentinel之@SentinelResource配置（下）

本节重点：@SentinelResource注解的其他属性介绍

注意：此注解方式埋点不支持 private 方法。

官方文档说明

@SentinelResource用于定义资源，并提供可选的异常处理和 fallback 配置项。
@SentinelResource 注解包含以下属性：

value：资源名称，必需项（不能为空）
entryType：entry 类型，可选项（默认为 EntryType.OUT）
blockHandler / blockHandlerClass: blockHandler 对应处理 BlockException 的函数名称，可选项。blockHandler 函数访问范围需要是 public，返回类型需要与原方法相匹配，参数类型需要和原方法相匹配并且最后加一个额外的参数，类型为 BlockException。blockHandler 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 blockHandlerClass 为对应的类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析。
fallback /fallbackClass：fallback 函数名称，可选项，用于在抛出异常的时候提供 fallback 处理逻辑。fallback 函数可以针对所有类型的异常（除了exceptionsToIgnore里面排除掉的异常类型）进行处理。fallback 函数签名和位置要求：
- 返回值类型必须与原函数返回值类型一致；
- 方法参数列表需要和原函数一致，或者可以额外多一个 Throwable类型的参数用于接收对应的异常。
- fallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 fallbackClass为对应的类的 Class对象，注意对应的函数必需为 static 函数，否则无法解析。
defaultFallback（since 1.6.0）：默认的 fallback 函数名称，可选项，通常用于通用的 fallback 逻辑（即可以用于很多服务或方法）。默认 fallback 函数可以针对所有类型的异常（除了exceptionsToIgnore里面排除掉的异常类型）进行处理。若同时配置了 fallback 和 defaultFallback，则只有 fallback 会生效。defaultFallback 函数签名要求：
- 返回值类型必须与原函数返回值类型一致；
- 方法参数列表需要为空，或者可以额外多一个 Throwable 类型的参数用于接收对应的异常。
- defaultFallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 fallbackClass 为对应的类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析。
exceptionsToIgnore（since 1.6.0）：用于指定哪些异常被排除掉，不会计入异常统计中，也不会进入 fallback 逻辑中，而是会原样抛出。

Sentinel主要有三个核心Api：SphU定义资源、Tracer定义统计、ContextUtil定义了上下文

20、Sentinel之服务熔断Ribbon环境介绍

本节目标： sentinel整合Ribbon+OpenFeign+fallback

Ribbon系列

启动nacos和sentinel
提供者9003/9004
消费者84

提供者9003/9004的新建： 新建cloud-alibaba-provider-payment9003/9004，两个一样的做法

第一步： 新建一个Module，名为：cloud-alibaba-provider-payment9003
第二步： 改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>cloud2021</artifactId>
        <groupId>com.oldou.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-alibaba-provider-payment9003</artifactId>

    <dependencies>
        <!--SpringCloud ailibaba nacos -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
            <groupId>com.oldou.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- SpringBoot整合Web组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--日常通用jar包配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

第三步： 改yml文件

server:
  port: 9003

spring:
  application:
    name: nacos-payment-provider
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #配置Nacos地址

management:
  endpoints:
    web:
      exposure:
        include: '*'

第四步： 主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

第五步： 业务类

import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;

@RestController
public class PaymentController {
    @Value("${server.port}")
    private String serverPort;

    //模拟数据库
    public static HashMap<Long,Payment> hashMap = new HashMap<>();
    static
    {
        hashMap.put(1L,new Payment(1L,"28a8c1e3bc2742d8848569891fb42181"));
        hashMap.put(2L,new Payment(2L,"bba8c1e3bc2742d8848569891ac32182"));
        hashMap.put(3L,new Payment(3L,"6ua8c1e3bc2742d8848569891xt92183"));
    }

    @GetMapping(value = "/paymentSQL/{id}")
    public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id)
    {
        Payment payment = hashMap.get(id);
        CommonResult<Payment> result = new CommonResult(200,"from mysql,serverPort:  "+serverPort,payment);
        return result;
    }

}

第六步： 测试

访问：http://localhost:9003/paymentSQL/1

同理，9004参照9003步骤

消费者84服务
第一步： 新建一个Module，名为：cloud-alibaba-consumer-nacos-order84
第二步： 改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>cloud2021</artifactId>
        <groupId>com.oldou.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-alibaba-consumer-nacos-order84</artifactId>

    <dependencies>
        <!--SpringCloud openfeign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--SpringCloud ailibaba nacos -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--SpringCloud ailibaba sentinel -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <dependency>
            <groupId>com.oldou.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- SpringBoot整合Web组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--日常通用jar包配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

第三步： 改yml文件

server:
  port: 84

spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: localhost:8080
        #默认8719端口，假如被占用会自动从8719开始依次+1扫描,直至找到未被占用的端口
        port: 8719

#消费者将要去访问的微服务名称(注册成功进nacos的微服务提供者)
service-url:
  nacos-user-service: http://nacos-payment-provider

# 激活Sentinel对Feign的支持
feign:
  sentinel:
    enabled: false

第四步： 主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

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

第五步： 业务类

ApplicationContextConfig

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;


@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

CircleBreakerController

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
@Slf4j
public class CircleBreakerController {
   public static final String SERVICE_URL = "http://nacos-payment-provider";

   @Resource
   private RestTemplate restTemplate;

   @RequestMapping("/consumer/fallback/{id}")
   @SentinelResource(value = "fallback")//没有配置
   public CommonResult<Payment> fallback(@PathVariable Long id)
   {
       CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,CommonResult.class,id);

       if (id == 4) {
           throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
       }else if (result.getData() == null) {
           throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
       }

       return result;
   }
   
}

以上就是三个服务的搭建过程，后面的测试中，修改84服务的代码以后记得要重启服务：

热部署对java代码生效及时，但是对@SentinelResource注解内属性有时没啥效果。

要实现的目标：

@SentinelResource注解的fallback管Java的运行异常
@SentinelResource注解的blockHandler管配置违规

21、Sentinel之服务熔断-无配置

启动服务9003/9004、84三个，然后测试84消费者是否能够实现以负载均衡轮询的方式调用9003/9004

测试：

访问http://localhost:84/consumer/fallback/1，刷新发现9003/9004的端口在不停变化，测试OK
这次我们访问http://localhost:84/consumer/fallback/4
访问：http://localhost:84/consumer/fallback/5

我们发现，当Sentinel没有任何配置时，Java运行异常返回给用户的error页面，特别不友好，因此我们需要解决这一个问题。

22、Sentinel之服务熔断-只配置fallback

@SentinelResource注解的fallback管Java的运行异常

业务类Controller修改

@RestController
@Slf4j
public class CircleBreakerController {
    public static final String SERVICE_URL = "http://nacos-payment-provider";

    @Resource
    private RestTemplate restTemplate;
 
    @RequestMapping("/consumer/fallback/{id}")
    //@SentinelResource(value = "fallback")//没有任何配置
    @SentinelResource(value = "fallback",fallback = "handlerFallback") //情况二：配置fallback，只负责业务异常，需要一个兜底方法handlerFallback
    public CommonResult<Payment> fallback(@PathVariable Long id)
    {
        CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,CommonResult.class,id);

        if (id == 4) {
            throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
        }else if (result.getData() == null) {
            throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
        }

        return result;
    }

    //本例是fallback，兜底方法
    public CommonResult handlerFallback(@PathVariable  Long id,Throwable e) {
        Payment payment = new Payment(id,"null");
        return new CommonResult<>(444,"兜底异常handlerFallback,exception内容  "+e.getMessage(),payment);
    }
}

访问之前的地址：http://localhost:84/consumer/fallback/4
在这里插入图片描述
再次访问：http://localhost:84/consumer/fallback/5

我们发现，使用了fallback，Java运行时异常返回的提示信息都变得非常友好了。

23、Sentinel之服务熔断-只配置blockHandler

@SentinelResource注解的blockHandler管Sentinel控制台的配置违规

业务类

@RestController
@Slf4j
public class CircleBreakerController {
    public static final String SERVICE_URL = "http://nacos-payment-provider";

    @Resource
    private RestTemplate restTemplate;
 
    @RequestMapping("/consumer/fallback/{id}")
    //@SentinelResource(value = "fallback")//没有任何配置
    //@SentinelResource(value = "fallback",fallback = "handlerFallback") //情况二：配置fallback，只负责业务异常，需要一个兜底方法handlerFallback
    @SentinelResource(value = "fallback",blockHandler = "blockHandler") //blockHandler只负责sentinel控制台配置违规
    public CommonResult<Payment> fallback(@PathVariable Long id) {
        CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,CommonResult.class,id);

        if (id == 4) {
            throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
        }else if (result.getData() == null) {
            throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
        }

        return result;
    }

    //本例是fallback，兜底方法
    /*
    public CommonResult handlerFallback(@PathVariable  Long id,Throwable e) {
        Payment payment = new Payment(id,"null");
        return new CommonResult<>(444,"兜底异常handlerFallback,exception内容  "+e.getMessage(),payment);
    }*/

    //本例是blockHandler
    public CommonResult blockHandler(@PathVariable  Long id, BlockException blockException) {
        Payment payment = new Payment(id,"null");
        return new CommonResult<>(445,"blockHandler-sentinel限流,无此流水: blockException  "+blockException.getMessage(),payment);
    }

}

Sentinel控制台添加熔断配置：
在这里插入图片描述

测试地址 - http://localhost:84/consumer/fallback/4
当2秒内报异常超过2次，就会触发规则，当访问第一次时，会有以下界面在这里插入图片描述
当我们快速刷新，2秒内刷新两次及以上：

24、Sentinel之服务熔断-blockHandler和fallback都配置

若blockHandler和fallback 都进行了配置，则被限流降级而抛出BlockException时只会进入blockHandler处理逻辑。

package com.oldou.springcloud.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@RestController
@Slf4j
public class CircleBreakerController {
    public static final String SERVICE_URL = "http://nacos-payment-provider";

    @Resource
    private RestTemplate restTemplate;
 
    @RequestMapping("/consumer/fallback/{id}")
    //@SentinelResource(value = "fallback")//没有任何配置
    //@SentinelResource(value = "fallback",fallback = "handlerFallback") //情况二：配置fallback，只负责业务异常，需要一个兜底方法handlerFallback
    //@SentinelResource(value = "fallback",blockHandler = "blockHandler") //blockHandler只负责sentinel控制台配置违规
    @SentinelResource(value = "fallback",fallback = "handlerFallback",blockHandler = "blockHandler")
    public CommonResult<Payment> fallback(@PathVariable Long id) {
        CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id,CommonResult.class,id);

        if (id == 4) {
            throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
        }else if (result.getData() == null) {
            throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
        }

        return result;
    }

    //本例是fallback，兜底方法
    public CommonResult handlerFallback(@PathVariable  Long id,Throwable e) {
        Payment payment = new Payment(id,"null");
        return new CommonResult<>(444,"兜底异常handlerFallback,exception内容  "+e.getMessage(),payment);
    }

    //本例是blockHandler
    public CommonResult blockHandler(@PathVariable  Long id, BlockException blockException) {
        Payment payment = new Payment(id,"null");
        return new CommonResult<>(445,"blockHandler-sentinel限流,无此流水: blockException  "+blockException.getMessage(),payment);
    }

}

Sentinel控制台新增一个流控规则【把之前的删掉】
在这里插入图片描述

25、Sentinel之服务熔断-exceptionsToIgnore

exceptionsToIgnore，忽略指定异常，即这些异常不用兜底方法处理。

@SentinelResource(value = "fallback",fallback = "handlerFallback",blockHandler = "blockHandler",
            exceptionsToIgnore = {IllegalArgumentException.class})

// 若配置了exceptionsToIgnore 属性，那么久不会走fallback 兜底的方法

26、Sentinel之服务熔断-OpenFeign

本节重点：整合OpenFeign实现服务降级

修改84模块

84消费者调用提供者9003
Feign组件一般是消费侧

修改Pom文件，添加OpenFeign的依赖

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

修改YML文件，添加OpenFeign的支持

业务类：带@Feignclient注解的业务接口，fallback = PaymentFallbackService.class

import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

// 服务提供者的名称   后面是服务降级的处理方法
@FeignClient(value = "nacos-payment-provider",fallback = PaymentFallbackService.class)
public interface PaymentService {
    @GetMapping(value = "/paymentSQL/{id}")
    public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id);
}

import com.oldou.springcloud.entities.CommonResult;
import com.oldou.springcloud.entities.Payment;
import org.springframework.stereotype.Component;

@Component
public class PaymentFallbackService implements PaymentService {
    @Override
    public CommonResult<Payment> paymentSQL(Long id) {
        return new CommonResult<>(44444,"服务降级返回,---PaymentFallbackService",new Payment(id,"errorSerial"));
    }
}

CircleBreakerController

@RestController
@Slf4j
public class CircleBreakerController {
    ...
	//==================OpenFeign
    @Resource
    private PaymentService paymentService;

    @GetMapping(value = "/consumer/paymentSQL/{id}")
    public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id){
        return paymentService.paymentSQL(id);
    }
}

84启动类，开启对OpenFeign的支持

测试：
启动9003、84服务
访问：http://localhost:84/consumer/paymentSQL/1 访问正常
当停掉9003服务之后，再次访问

Sentinel整合OpenFeign出现的问题：
按照以上步骤之后，启动84服务时发现启动不了，并报错

这是控制台最上面的
sun.misc.Unsafe.park(Native Method)
 java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:215)
 java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2078)
 java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1093)
 java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809)
 java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074)
 java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)
 java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
 java.lang.Thread.run(Thread.java:748)
#下面的是这样
Caused by: java.lang.AbstractMethodError: com.alibaba.cloud.sentinel.feign.SentinelContractHolder.parseAndValidateMetadata(Ljava/lang/Class;)Ljava/util/List;
	at feign.ReflectiveFeign$ParseHandlersByName.apply(ReflectiveFeign.java:151) ~[feign-core-10.7.4.jar:na]
	at feign.ReflectiveFeign.newInstance(ReflectiveFeign.java:49) ~[feign-core-10.7.4.jar:na]
	at feign.Feign$Builder.target(Feign.java:252) ~[feign-core-10.7.4.jar:na]
	at org.springframework.cloud.openfeign.HystrixTargeter.target(HystrixTargeter.java:38) ~[spring-cloud-openfeign-core-2.2.2.RELEASE.jar:2.2.2.RELEASE]
	at org.springframework.cloud.openfeign.FeignClientFactoryBean.loadBalance(FeignClientFactoryBean.java:253) ~[spring-cloud-openfeign-core-2.2.2.RELEASE.jar:2.2.2.RELEASE]
	at org.spring
framework.cloud.openfeign.FeignClientFactoryBean.getTarget(FeignClientFactoryBean.java:282) ~[spring-cloud-openfeign-core-2.2.2.RELEASE.jar:2.2.2.RELEASE]
	at org.springframework.cloud.openfeign.FeignClientFactoryBean.getObject(FeignClientFactoryBean.java:262) ~[spring-cloud-openfeign-core-2.2.2.RELEASE.jar:2.2.2.RELEASE]
	at org.springframework.beans.factory.support.FactoryBeanRegistrySupport.doGetObjectFromFactoryBean(FactoryBeanRegistrySupport.java:171) ~[spring-beans-5.2.4.RELEASE.jar:5.2.4.RELEASE]
	... 33 common frames omitted

之后我找了很多问题，最后发现是SpringCloud的版本问题
在这里插入图片描述
这个问题是由于版本冲突造成的，because：spring-cloud版本不同，openfeign的版本也不同
我将Springcloud的版本修改成2.2.0版本就可以了

27、Sentinel之持久化规则

问题产生的背景： 当我们重启服务的时候，我们在Sentinel控制台中配置的规则将消失，而生产环境需要将配置规则进行持久化。

解决方法： 将限流配置规则持久化进Nacos保存，只要刷新8401某个rest地址，sentinel控制台的流控规则就能看到，只要Nacos里面的配置不删除，针对8401上sentinel上的流控规则持续有效。

本次演示的服务为：cloud-alibaba-sentinel-service8401

实现持久化的步骤：

修改cloud-alibaba-sentinel-service8401服务

修改POM文件，增加依赖

<!--SpringCloud ailibaba sentinel-datasource-nacos 后续做持久化用到-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

修改yml文件

server:
  port: 8401

spring:
  application:
    name: cloud-alibaba-sentinel-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #Nacos服务注册中心地址
    sentinel:
      transport:
        dashboard: localhost:8080 #配置Sentinel dashboard地址
        port: 8719
      datasource: #添加Nacos数据源配置,用于Sentinel的持久化    <------
        ds1:
          nacos:
            server-addr: localhost:8848
            dataId: cloud-alibaba-sentinel-service
            groupId: DEFAULT_GROUP
            data-type: json
            rule-type: flow
management:
  endpoints:
    web:
      exposure:
        include: '*'

feign:
  sentinel:
    enabled: true # 激活Sentinel对Feign的支持

在Nacos中添加业务规则配置
```
[{
    "resource": "/rateLimit/byUrl",  
    "IimitApp": "default",
    "grade": 1,
    "count": 1, 
    "strategy": 0,
    "controlBehavior": 0,
    "clusterMode": false
}]
```
以上参数的介绍：
- resource：资源名称；
- limitApp：来源应用；
- grade：阈值类型，0表示线程数, 1表示QPS；
- count：单机阈值；
- strategy：流控模式，0表示直接，1表示关联，2表示链路；
- controlBehavior：流控效果，0表示快速失败，1表示Warm Up，2表示排队等待；
- clusterMode：是否集群。

测试：

启动8401后服务，访问http://localhost:8401/rateLimit/byUrl，访问成功之后我们去Sentinel控制台配置一个简单的流控规则
快速访问测试接口 http://localhost:8401/rateLimit/byUrl，页面返回Blocked by Sentinel (flow limiting)
停止8401之后，我们刷新Sentinel控制台，发现规则消失了
我们再次启动8401服务，去刷新Sentinel控制台的流控规则页面，发现还是没有，但是我们多次调用 http://localhost:8401/rateLimit/byUrl，流控规则又重新出现了！！

以上配置实现了Sentinel配置的持久化。

十五、SpringCloud Alibaba组件之Seata【分布式事务处理】

1、分布式事务问题由来

问题： 单体应用被拆分成微服务应用，原来的三个模块被拆分成三个独立的应用,分别使用三个独立的数据源，业务操作需要调用三个服务来完成。此时每个服务内部的数据一致性由本地事务来保证，但是全局的数据一致性问题没法保证。

举个例子说：用户购买商品的业务逻辑，整个业务逻辑由三个微服务提供支持：

仓储服务：对给定的商品扣除仓储数量；
订单服务：根据采购需求创建订单；
账户服务：从用户账户中扣除余额；

总结：一次业务操作需要跨多个数据源或需要跨多个系统进行远程调用，就会产生分布式事务问题。 因此我们要保证全局数据一致性问题。

2、Seata术语

基本概念： Seata是一款开源的分布式事务解决方案，致力于在微服务架构下提供高性能和简单易用的分布式事务服务。

作用： 它是一个典型的分布式事务过程，分布式事务处理过程的一个ID+三个组件模型：

Transaction ID XID：全局唯一的事务ID
三组件概念：
- TC (Transaction Coordinator)：事务协调者，维护全局和分支事务的状态，驱动全局事务提交或回滚；
- TM (Transaction Manager) ：事务管理器，定义全局事务的范围：开始全局事务、提交或回滚全局事务。
- RM (Resource Manager) ：资源管理器，管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚。

Seata的分布式事务处理过程
在这里插入图片描述

第一步：TM向TC申请开启一个全局事务，全局事务创建成功并生成一个全局唯一的XID；
第二步：XID在微服务调用链路的上下文中传播；
第三步：RM向TC注册分支事务，将其纳入XID对应全局事务的管辖；
第四步：TM向TC发起针对XID的全局提交或回滚决议；
第五步：TC调度XID下管辖的全部分支事务完成提交或回滚请求。

举例解释过程：
假设上图中的一个Microservices就是一个组，一个组是20个同学【RM是同学】，TC就是授课的老师，TM就是班主任；

第一步：班主任A向授课的老师询问是否可以开一个班【申请开启一个全局事务】，要是开班的话就在网络平台上创建一个班号【全局唯一的XID】
第二步：班主任A在网络平台上创建好班号【全局唯一的XID】以后，就开始将班号在各个微信群里面转发【XID在微服务调用链路的上下文中传播】，只要加进这个班【具备这个全局唯一的XID】的同学就是代表参加这次网课的同班同学；
第三步：同学们加进课堂的直播间之后，授课老师就会在右边的小窗口看到XXX加入了课堂的提示信息，然后授课老师会让同学们刷1，向授课老师说我是xxx【RM向TC注册分支事务】，然后上课期间授课老师会点名让某个同学回答问题，如果逮住了XXA在玩手机，那么授课老师可以将XXA同学踢出班级【将其纳入XID对应全局事务的管辖】；
第四步：班主任A向同学们发起一个签到，看看人数到齐没有，如果人数到齐的话，那么班主任A就会向授课老师说人齐了，授课老师你可以上课了【M向TC发起针对XID的全局提交或回滚决议】；
第五步：授课老师开始讲课，大家都在这个班级下，都可以看到授课老师讲课的屏幕，过了一段时间以后，讲课完毕，然后授课老师向同学们说授课结束，请同学们休息一下【TC调度XID下管辖的全部分支事务完成提交或回滚请求】

大家阅读时，请注意我加粗的字体和后面的【信息】是对应的，这样加深理解。

3、Seata Server的安装

下载地址：http://seata.io/zh-cn/blog/download.html
版本发布地址：Seata的版本发布地址

我本地下载的是Seata版本是：V1.3.0 (这里需要注意的是，别下载1.4的，有问题巨坑)
在这里插入图片描述

安装步骤：

第一步：解压到指定目录，进入到seata-server-1.3.0\seata\conf目录下；
第二步：先备份file.conf文件，我们主要修改的是【事务日志存储模式为db+数据库连接信息】【1.0版本以前需要修改自定义事务组名称】；

第三步：打开file.conf文件进行以下修改【注意：我下载的是1.3版本的，和0.9版本的不一样】：

store {
  ## store mode: file、db、redis
  mode = "db"  # 将存储方式设置成数据库db

....
  ## database store property
  db {
    ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp)/HikariDataSource(hikari) etc.
    datasource = "druid"
    ## mysql/oracle/postgresql/h2/oceanbase etc.
    dbType = "mysql"
    driverClassName = "com.mysql.jdbc.Driver"
    url = "jdbc:mysql://127.0.0.1:3306/seata"  #修改这里 数据库连接信息
    user = "root"  #修改这里  数据库连接信息
    password = "root" # 修改这里  数据库连接信息
    minConn = 5
    maxConn = 100
    globalTable = "global_table"
    branchTable = "branch_table"
    lockTable = "lock_table"
    queryLimit = 100
    maxWait = 5000
  }
....
}

第四步：在mysql5.7数据库中新建一个名为seata的数据库

第五步：在数据库seata中新建表，导入sql文件，这里我说明一下，有点坑，这个建表语句在下面这个压缩包中的seata-1.3.0\script\server\db\mysql.sql这里，但是sql语句我给出来了
在这里插入图片描述

-- -------------------------------- The script used when storeMode is 'db' --------------------------------
-- the table to store GlobalSession data
CREATE TABLE IF NOT EXISTS `global_table`
(
    `xid`                       VARCHAR(128) NOT NULL,
    `transaction_id`            BIGINT,
    `status`                    TINYINT      NOT NULL,
    `application_id`            VARCHAR(32),
    `transaction_service_group` VARCHAR(32),
    `transaction_name`          VARCHAR(128),
    `timeout`                   INT,
    `begin_time`                BIGINT,
    `application_data`          VARCHAR(2000),
    `gmt_create`                DATETIME,
    `gmt_modified`              DATETIME,
    PRIMARY KEY (`xid`),
    KEY `idx_gmt_modified_status` (`gmt_modified`, `status`),
    KEY `idx_transaction_id` (`transaction_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

-- the table to store BranchSession data
CREATE TABLE IF NOT EXISTS `branch_table`
(
    `branch_id`         BIGINT       NOT NULL,
    `xid`               VARCHAR(128) NOT NULL,
    `transaction_id`    BIGINT,
    `resource_group_id` VARCHAR(32),
    `resource_id`       VARCHAR(256),
    `branch_type`       VARCHAR(8),
    `status`            TINYINT,
    `client_id`         VARCHAR(64),
    `application_data`  VARCHAR(2000),
    `gmt_create`        DATETIME(6),
    `gmt_modified`      DATETIME(6),
    PRIMARY KEY (`branch_id`),
    KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

-- the table to store lock data
CREATE TABLE IF NOT EXISTS `lock_table`
(
    `row_key`        VARCHAR(128) NOT NULL,
    `xid`            VARCHAR(96),
    `transaction_id` BIGINT,
    `branch_id`      BIGINT       NOT NULL,
    `resource_id`    VARCHAR(256),
    `table_name`     VARCHAR(32),
    `pk`             VARCHAR(36),
    `gmt_create`     DATETIME,
    `gmt_modified`   DATETIME,
    PRIMARY KEY (`row_key`),
    KEY `idx_branch_id` (`branch_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8;

第六步：备份此文件，并打开seata-server-1.3.0\seata\conf\registry.conf文件作以下修改

registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "nacos"  # 指定注册中心为nacos  <-----
  loadBalance = "RandomLoadBalance"
  loadBalanceVirtualNodes = 10

  nacos {
    application = "seata-server"
    serverAddr = "localhost:8848"  # 修改Nacos的链接信息    <-----
    group = "SEATA_GROUP"
    namespace = ""
    cluster = "default"
    username = ""
    password = ""
  }
  ...........
}

第七步：先启动Nacos，再启动seate-server，不然Seata会报错

安装配置完成！！！

4、Seata之业务数据库准备

案例：SEATA 的分布式交易解决方案
在这里插入图片描述
我们只需要使用一个 @GlobalTransactional注解在业务方法上;

这里我们会创建三个服务，一个订单服务，一个库存服务，一个账户服务。
当用户下单时,会在订单服务中创建一个订单, 然后通过远程调用库存服务来扣减下单商品的库存，再通过远程调用账户服务来扣减用户账户里面的余额，最后在订单服务中修改订单状态为已完成。

该操作跨越三个数据库，有两次远程调用，很明显会有分布式事务问题。
总的来说：下订单—>扣库存—>减账户(余额)。

创建业务数据库

seata_order：存储订单的数据库;
seata_storage：存储库存的数据库;
seata_account：存储账户信息的数据库。

分别在以上三个数据库中创建表：

seata_order库中新建t_order表

CREATE TABLE `t_order` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT,
  `user_id` bigint(11) DEFAULT NULL COMMENT '用户id',
  `product_id` bigint(11) DEFAULT NULL COMMENT '产品id',
  `count` int(11) DEFAULT NULL COMMENT '数量',
  `money` decimal(11,0) DEFAULT NULL COMMENT '金额',
  `status` int(1) DEFAULT NULL COMMENT '订单状态: 0:创建中; 1:已完结',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

SELECT * FROM t_order;

seata_storage库中新建t_storage表

CREATE TABLE t_storage (
`id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
`product_id` BIGINT(11) DEFAULT NULL COMMENT '产品id',
`total` INT(11) DEFAULT NULL COMMENT '总库存',
`used` INT(11) DEFAULT NULL COMMENT '已用库存',
`residue` INT(11) DEFAULT NULL COMMENT '剩余库存'
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO seata_storage.t_storage(`id`, `product_id`, `total`, `used`, `residue`)
VALUES ('1', '1', '100', '0','100');

SELECT * FROM t_storage;

seata_account库中新建t_account表

CREATE TABLE t_account(
	`id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT 'id',
	`user_id` BIGINT(11) DEFAULT NULL COMMENT '用户id',
	`total` DECIMAL(10,0) DEFAULT NULL COMMENT '总额度',
	`used` DECIMAL(10,0) DEFAULT NULL COMMENT '已用余额',
	`residue` DECIMAL(10,0) DEFAULT '0' COMMENT '剩余可用额度'
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO seata_account.t_account(`id`, `user_id`, `total`, `used`, `residue`)
VALUES ('1', '1', '1000', '0', '1000');

SELECT * FROM t_account;

按照上述3库分别建对应的回滚日志表

订单-库存-账户3个库下都需要建各自的回滚日志表，分别运行以下sql语句

-- the table to store seata xid data
-- 0.7.0+ add context
-- you must to init this sql for you business databese. the seata server not need it.
-- 此脚本必须初始化在你当前的业务数据库中，用于AT 模式XID记录。与server端无关（注：业务数据库）
-- 注意此处0.3.0+ 增加唯一索引 ux_undo_log
drop table `undo_log`;
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

到此，数据库就完成了。

5、Seata之Order-Module配置搭建

第一步： 新建一个Module，名为：seata-order-service2001
第二步： 改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>cloud2021</artifactId>
        <groupId>com.oldou.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>seata-order-service2001</artifactId>

    <dependencies>
        <!--nacos-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--seata-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>seata-all</artifactId>
                    <groupId>io.seata</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--这里用的版本最好和安装的版本保持一致-->
        <dependency>
            <groupId>io.seata</groupId>
            <artifactId>seata-all</artifactId>
            <version>1.3.0</version>
        </dependency>
        <!--feign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--web-actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--mysql-druid-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

</project>

第三步： 配置文件

改yml文件

server:
  port: 2001

spring:
  application:
    name: seata-order-service
  cloud:
    alibaba:
      seata:
        #自定义事务组名称需要与seata-server中的对应  没有配置写default
        tx-service-group: default
    nacos:
      discovery:
        server-addr: localhost:8848
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/seata_order
    username: root
    password: 123456

feign:
  hystrix:
    enabled: false

logging:
  level:
    io:
      seata: info

mybatis:
  mapperLocations: classpath:mapper/*.xml

在resources下新建file.conf，并将seata-server的这个文件内容拷贝过来

## transaction log store, only used in seata-server
store {
  ## store mode: file、db、redis
  mode = "db"

  ## file store property
  file {
    ## store location dir
    dir = "sessionStore"
    # branch session size , if exceeded first try compress lockkey, still exceeded throws exceptions
    maxBranchSessionSize = 16384
    # globe session size , if exceeded throws exceptions
    maxGlobalSessionSize = 512
    # file buffer size , if exceeded allocate new buffer
    fileWriteBufferCacheSize = 16384
    # when recover batch read size
    sessionReloadReadSize = 100
    # async, sync
    flushDiskMode = async
  }

  ## database store property
  db {
    ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp)/HikariDataSource(hikari) etc.
    datasource = "druid"
    ## mysql/oracle/postgresql/h2/oceanbase etc.
    dbType = "mysql"
    driverClassName = "com.mysql.jdbc.Driver"
    url = "jdbc:mysql://127.0.0.1:3306/seata"
    user = "root"
    password = "root"
    minConn = 5
    maxConn = 100
    globalTable = "global_table"
    branchTable = "branch_table"
    lockTable = "lock_table"
    queryLimit = 100
    maxWait = 5000
  }

  ## redis store property
  redis {
    host = "127.0.0.1"
    port = "6379"
    password = ""
    database = "0"
    minConn = 1
    maxConn = 10
    maxTotal = 100
    queryLimit = 100
  }

}

在resources下新建registry.conf，并将seata-server的这个文件内容拷贝过来

registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "nacos"  # 指定注册中心为nacos
  loadBalance = "RandomLoadBalance"
  loadBalanceVirtualNodes = 10

  nacos {
    application = "seata-server"
    serverAddr = "localhost:8848"  # 修改Nacos的链接信息
    group = "SEATA_GROUP"
    namespace = ""
    cluster = "default"
    username = ""
    password = ""
  }
  eureka {
    serviceUrl = "http://localhost:8761/eureka"
    application = "default"
    weight = "1"
  }
  redis {
    serverAddr = "localhost:6379"
    db = 0
    password = ""
    cluster = "default"
    timeout = 0
  }
  zk {
    cluster = "default"
    serverAddr = "127.0.0.1:2181"
    sessionTimeout = 6000
    connectTimeout = 2000
    username = ""
    password = ""
  }
  consul {
    cluster = "default"
    serverAddr = "127.0.0.1:8500"
  }
  etcd3 {
    cluster = "default"
    serverAddr = "http://localhost:2379"
  }
  sofa {
    serverAddr = "127.0.0.1:9603"
    application = "default"
    region = "DEFAULT_ZONE"
    datacenter = "DefaultDataCenter"
    cluster = "default"
    group = "SEATA_GROUP"
    addressWaitTime = "3000"
  }
  file {
    name = "file.conf"
  }
}

config {
  # file、nacos 、apollo、zk、consul、etcd3
  type = "file"

  nacos {
    serverAddr = "127.0.0.1:8848"
    namespace = ""
    group = "SEATA_GROUP"
    username = ""
    password = ""
  }
  consul {
    serverAddr = "127.0.0.1:8500"
  }
  apollo {
    appId = "seata-server"
    apolloMeta = "http://192.168.1.204:8801"
    namespace = "application"
    apolloAccesskeySecret = ""
  }
  zk {
    serverAddr = "127.0.0.1:2181"
    sessionTimeout = 6000
    connectTimeout = 2000
    username = ""
    password = ""
  }
  etcd3 {
    serverAddr = "http://localhost:2379"
  }
  file {
    name = "file.conf"
  }
}

第四步： 主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

第五步： 实体类

package com.oldou.springcloud.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult<T>{
    private Integer code;
    private String  message;
    private T       data;

    public CommonResult(Integer code, String message){
        this(code,message,null);
    }
}

package com.oldou.springcloud.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order
{
    private Long id;

    private Long userId;

    private Long productId;

    private Integer count;

    private BigDecimal money;

    private Integer status; //订单状态：0：创建中；1：已完结
}

6、Seata之Order-Module撸码

Dao层

package com.oldou.springcloud.dao;


import com.oldou.springcloud.domain.Order;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface OrderDao {
    //1 新建订单
    void create(Order order);

    //2 修改订单状态，从零改为1
    void update(@Param("userId") Long userId,@Param("status") Integer status);
}

OrderMapper.xml： 在resources下新建一个mapper的包

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

<mapper namespace="com.oldou.springcloud.dao.OrderDao">

    <resultMap id="BaseResultMap" type="com.oldou.springcloud.domain.Order">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <result column="user_id" property="userId" jdbcType="BIGINT"/>
        <result column="product_id" property="productId" jdbcType="BIGINT"/>
        <result column="count" property="count" jdbcType="INTEGER"/>
        <result column="money" property="money" jdbcType="DECIMAL"/>
        <result column="status" property="status" jdbcType="INTEGER"/>
    </resultMap>

    <insert id="create">
        insert into t_order (id,user_id,product_id,count,money,status)
        values (null,#{userId},#{productId},#{count},#{money},0);
    </insert>


    <update id="update">
        update t_order set status = 1
        where user_id=#{userId} and status = #{status};
    </update>

</mapper>

service层：

订单服务的接口

package com.oldou.springcloud.service;

import com.oldou.springcloud.domain.Order;

/**
 * 订单服务
 */
public interface OrderService {

    void create(Order order);
    
}

库存服务的feign调用

package com.oldou.springcloud.service;

import com.oldou.springcloud.domain.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * 库存服务的feign调用
 */
@FeignClient(value = "seata-storage-service")
public interface StorageService {

    @PostMapping(value = "/storage/decrease")
    CommonResult decrease(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);

}

账户服务的feign调用

package com.oldou.springcloud.service;

import com.oldou.springcloud.domain.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import java.math.BigDecimal;

/**
 * 订单服务的RPC调用
 */
@FeignClient(value = "seata-account-service")
public interface AccountService {
    @PostMapping(value = "/account/decrease")
    CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
}

订单服务的实现类

package com.oldou.springcloud.service.impl;

import com.oldou.springcloud.dao.OrderDao;
import com.oldou.springcloud.domain.Order;
import com.oldou.springcloud.service.AccountService;
import com.oldou.springcloud.service.OrderService;
import com.oldou.springcloud.service.StorageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    @Resource
    private OrderDao orderDao;
    @Resource
    private StorageService storageService;
    @Resource
    private AccountService accountService;

    /**
     * 创建订单->调用库存服务扣减库存->调用账户服务扣减账户余额->修改订单状态
     * 简单说：下订单->扣库存->减余额->改状态
     */
    @Override
    //@GlobalTransactional(name = "fsp-create-order",rollbackFor = Exception.class)
    public void create(Order order) {
        log.info("----->开始新建订单");
        //1 新建订单
        orderDao.create(order);

        //2 扣减库存
        log.info("----->订单微服务开始调用库存，做扣减Count");
        storageService.decrease(order.getProductId(),order.getCount());
        log.info("----->订单微服务开始调用库存，做扣减end");

        //3 扣减账户
        log.info("----->订单微服务开始调用账户，做扣减Money");
        accountService.decrease(order.getUserId(),order.getMoney());
        log.info("----->订单微服务开始调用账户，做扣减end");

        //4 修改订单状态，从零到1,1代表已经完成
        log.info("----->修改订单状态开始");
        orderDao.update(order.getUserId(),0);
        log.info("----->修改订单状态结束");

        log.info("----->下订单结束了，O(∩_∩)O哈哈~");

    }
}

controller层

package com.oldou.springcloud.controller;

import com.oldou.springcloud.domain.CommonResult;
import com.oldou.springcloud.domain.Order;
import com.oldou.springcloud.service.OrderService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class OrderController {
    @Resource
    private OrderService orderService;

    @GetMapping("/order/create")
    public CommonResult create(Order order) {
        orderService.create(order);
        return new CommonResult(200,"订单创建成功");
    }
}

配置类

package com.oldou.springcloud.config;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan({"com.oldou.springcloud.dao"})
public class MyBatisConfig {
}

package com.oldou.springcloud.config;

import com.alibaba.druid.pool.DruidDataSource;
import io.seata.rm.datasource.DataSourceProxy;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;

/**
 * 使用Seata对数据源进行代理
 */
@Configuration
public class DataSourceProxyConfig {

    @Value("${mybatis.mapperLocations}")
    private String mapperLocations;

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }

    @Bean
    public DataSourceProxy dataSourceProxy(DataSource dataSource) {
        return new DataSourceProxy(dataSource);
    }

    @Bean
    public SqlSessionFactory sqlSessionFactoryBean(DataSourceProxy dataSourceProxy) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSourceProxy);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
        sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
        return sqlSessionFactoryBean.getObject();
    }

}

订单服务seata-order-service2001的启动类

package com.oldou.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableDiscoveryClient
@EnableFeignClients
//取消数据源的自动创建，而是使用自己定义的
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class SeataOrderMainApp2001 {
    public static void main(String[] args) {
        SpringApplication.run(SeataOrderMainApp2001.class,args);
    }
}

8、Seata之Storage-Module说明

与seata-order-service2001服务类似：
第一步： 新建一个Module，名为：seata-storage-service2002
第二步： 改pom文件（与seata-order-service2001服务一致）
第三步： 配置文件

改yml文件

server:
  port: 2002

spring:
  application:
    name: seata-storage-service
  cloud:
    alibaba:
      seata:
        tx-service-group: fsp_tx_group
    nacos:
      discovery:
        server-addr: localhost:8848
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/seata_storage
    username: root
    password: root

logging:
  level:
    io:
      seata: info

mybatis:
  mapperLocations: classpath:mapper/*.xml

file.conf以及registry.conf文件和2001一致

第四步： 实体类，除了以下类之外，CommonResult和2001一致

domain

@Data
public class Storage {

    private Long id;

    /**
     * 产品id
     */
    private Long productId;

    /**
     * 总库存
     */
    private Integer total;

    /**
     * 已用库存
     */
    private Integer used;

    /**
     * 剩余库存
     */
    private Integer residue;
}

第五步： 业务类

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface StorageDao {

    //扣减库存
    void decrease(@Param("productId") Long productId, @Param("count") Integer count);
}

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

<mapper namespace="com.oldou.springcloud.dao.StorageDao">

    <resultMap id="BaseResultMap" type="com.oldou.springcloud.domain.Storage">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <result column="product_id" property="productId" jdbcType="BIGINT"/>
        <result column="total" property="total" jdbcType="INTEGER"/>
        <result column="used" property="used" jdbcType="INTEGER"/>
        <result column="residue" property="residue" jdbcType="INTEGER"/>
    </resultMap>

    <update id="decrease">
        UPDATE
            t_storage
        SET
            used = used + #{count},residue = residue - #{count}
        WHERE
            product_id = #{productId}
    </update>

</mapper>

Service

public interface StorageService {
    /**
     * 扣减库存
     */
    void decrease(Long productId, Integer count);
}

serviceImpl

import javax.annotation.Resource;


@Service
public class StorageServiceImpl implements StorageService {

    private static final Logger LOGGER = LoggerFactory.getLogger(StorageServiceImpl.class);

    @Resource
    private StorageDao storageDao;

    /**
     * 扣减库存
     */
    @Override
    public void decrease(Long productId, Integer count) {
        LOGGER.info("------->storage-service中扣减库存开始");
        storageDao.decrease(productId,count);
        LOGGER.info("------->storage-service中扣减库存结束");
    }
}

Controller

import com.oldou.springcloud.domain.CommonResult;
import com.oldou.springcloud.service.StorageService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class StorageController {

    @Resource
    private StorageService storageService;

    /**
     * 扣减库存
     */
    @RequestMapping("/storage/decrease")
    public CommonResult decrease(Long productId, Integer count) {
        storageService.decrease(productId, count);
        return new CommonResult(200,"扣减库存成功！");
    }
}

config与2001服务保持一致
启动类：与2001类似，改改名称即可

9、Seata之Account-Module说明

与seata-order-service2001服务类似：
第一步： 新建一个Module，名为：seata-account-service2003
第二步： 改pom文件（与seata-order-service2001服务一致）
第三步： 配置文件

改yml文件

server:
  port: 2003

spring:
  application:
    name: seata-account-service
  cloud:
    alibaba:
      seata:
        tx-service-group: default
    nacos:
      discovery:
        server-addr: localhost:8848
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/seata_account?useSSL=false
    username: root
    password: root

feign:
  hystrix:
    enabled: false

logging:
  level:
    io:
      seata: info

mybatis:
  mapperLocations: classpath:mapper/*.xml

file.conf以及registry.conf文件和2001一致

第四步： 实体类，除了以下类之外，CommonResult和2001一致

domain

package com.oldou.springcloud.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {

    private Long id;

    /**
     * 用户id
     */
    private Long userId;

    /**
     * 总额度
     */
    private BigDecimal total;

    /**
     * 已用额度
     */
    private BigDecimal used;

    /**
     * 剩余额度
     */
    private BigDecimal residue;
}

第五步： 业务类

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.math.BigDecimal;

@Mapper
public interface AccountDao {

    /**
     * 扣减账户余额
     */
    void decrease(@Param("userId") Long userId, @Param("money") BigDecimal money);
}

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

<mapper namespace="com.oldou.springcloud.dao.AccountDao">

    <resultMap id="BaseResultMap" type="com.oldou.springcloud.domain.Account">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <result column="user_id" property="userId" jdbcType="BIGINT"/>
        <result column="total" property="total" jdbcType="DECIMAL"/>
        <result column="used" property="used" jdbcType="DECIMAL"/>
        <result column="residue" property="residue" jdbcType="DECIMAL"/>
    </resultMap>

    <update id="decrease">
        UPDATE t_account
        SET
          residue = residue - #{money},used = used + #{money}
        WHERE
          user_id = #{userId};
    </update>

</mapper>

Service

import org.springframework.web.bind.annotation.RequestParam;

import java.math.BigDecimal;

public interface AccountService {

    /**
     * 扣减账户余额
     * @param userId 用户id
     * @param money 金额
     */
    void decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
}

serviceImpl

package com.oldou.springcloud.service.impl;

import com.oldou.springcloud.dao.AccountDao;
import com.oldou.springcloud.service.AccountService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;

/**
 */
@Service
public class AccountServiceImpl implements AccountService {

    private static final Logger LOGGER = LoggerFactory.getLogger(AccountServiceImpl.class);


    @Resource
    private AccountDao accountDao;

    /**
     * 扣减账户余额
     */
    @Override
    public void decrease(Long userId, BigDecimal money) {
        LOGGER.info("------->account-service中扣减账户余额开始");
        accountDao.decrease(userId,money);
        LOGGER.info("------->account-service中扣减账户余额结束");
    }
}

Controller

@RestController
public class AccountController {

    @Resource
    AccountService accountService;

    /**
     * 扣减账户余额
     */
    @RequestMapping("/account/decrease")
    public CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money){
        accountService.decrease(userId,money);
        return new CommonResult(200,"扣减账户余额成功！");
    }
}

config与2001服务保持一致
启动类：与2001类似，改改名称即可

倒刺，我们环境和代码就准备好了。

10、Seata之@GlobalTransactional验证

测试的流程： 订单服务下订单 -> 库存服务减库存 -> 账户服务扣余额 -> 订单服务改（订单）状态

数据库数据初始情况：
在这里插入图片描述

启动Nacos、Seata-server以及三个微服务，Nacos中可以看到服务注册进列表

正常下单测试： 调用http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100

下单成功之后数据库状况：

测试异常，我们在账户服务的AccountServiceImpl中添加一个延时代码，由于Feign调用默认时间是1秒钟，我们这里弄一个超时异常

模拟AccountServiceImpl添加超时

@Service
public class AccountServiceImpl implements AccountService {

    private static final Logger LOGGER = LoggerFactory.getLogger(AccountServiceImpl.class);

    @Resource
    private AccountDao accountDao;

    /**
     * 扣减账户余额
     */
    @Override
    public void decrease(Long userId, BigDecimal money) {
        //让线程睡20秒钟，模拟超时异常，全局事务回滚
        try { TimeUnit.SECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
        LOGGER.info("------->account-service中扣减账户余额开始");
        accountDao.decrease(userId,money);
        LOGGER.info("------->account-service中扣减账户余额结束");
    }
}

修改账户服务的代码以后，重启服务，再次访问： http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100
在这里插入图片描述
数据库状况：

从以上测试数据我们发现，服务出现异常，当库存和账户金额扣减后，订单状态并没有设置为已经完成，没有从0改为1，同时由于feign的重试机制，账户余额和库存还有可能被多次扣减，这是一个大问题啊。

解决方案：Seata的全局事务@GlobalTransactional

首先，找到业务的入口：订单服务的OrderServiceImpl，用@GlobalTransactional标注create()方法

@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    @Resource
    private OrderDao orderDao;
    @Resource
    private StorageService storageService;
    @Resource
    private AccountService accountService;

    /**
     * 创建订单->调用库存服务扣减库存->调用账户服务扣减账户余额->修改订单状态
     * 简单说：下订单->扣库存->减余额->改状态
     *
     * @GlobalTransactional的属性说明
     *      --name：随便命名，只要名字不冲突
     *      --rollbackFor：发生什么异常的时候进行回滚，这里定义为Exception.class表示发生任何异常都进行回滚
     */
    @Override
    @GlobalTransactional(name = "fsp-create-order",rollbackFor = Exception.class)
    public void create(Order order) {
        log.info("----->开始新建订单");
        //1 新建订单
        orderDao.create(order);

        //2 扣减库存
        log.info("----->订单微服务开始调用库存，做扣减Count");
        storageService.decrease(order.getProductId(),order.getCount());
        log.info("----->订单微服务开始调用库存，做扣减end");

        //3 扣减账户
        log.info("----->订单微服务开始调用账户，做扣减Money");
        accountService.decrease(order.getUserId(),order.getMoney());
        log.info("----->订单微服务开始调用账户，做扣减end");

        //4 修改订单状态，从零到1,1代表已经完成
        log.info("----->修改订单状态开始");
        orderDao.update(order.getUserId(),0);
        log.info("----->修改订单状态结束");

        log.info("----->下订单结束了，O(∩_∩)O哈哈~");

    }
}

重启订单服务，再次测试，还是模拟AccountServiceImpl添加超时，下单后数据库数据并没有任何改变，记录都添加不进来，达到出异常，数据库回滚的效果。

11、Seata之工作原理简介

Seata： Simple Extensible Autonomous Transaction Architecture，简单可扩展自治事务框架。2020起始，建议使用1.0以后的版本，0.9版本的不支持集群。
在这里插入图片描述
结合我们的案例，再看一下TC、TM、RM

TC：seata服务器，其实就是我们启动的seata-server-1.3.0
TM：事务的发起方，标注了@GlobalTransactional的方法
RM：事务的参与方，是我们三个【订单、库存、账户】数据库

分布式事务的执行流程

第一步： TM开启分布式事务(TM向TC注册全局事务记录) ，【加了@GlobalTransactional注解就开启事务】；
第二步： 按业务场景，编排数据库、服务等事务内资源(RM向TC汇报资源准备状态) ；
第三步： TM结束分布式事务，事务一阶段结束(TM通知TC提交/回滚分布式事务) ；
第四步： TC汇总事务信息，决定分布式事务是提交还是回滚；
第五步： TC通知所有RM提交/回滚资源，事务二阶段结束。

事务的一阶段和二阶段，后续解释。

Seata 是一款开源的分布式事务解决方案，致力于提供高性能和简单易用的分布式事务服务。Seata 将为用户提供了 AT、TCC、SAGA 和 XA 事务模式，为用户打造一站式的分布式解决方案。

Seata默认使用的是AT模式。
在这里插入图片描述

AT模式的介绍以及底层工作原理

前提

基于支持本地 ACID 事务的关系型数据库。
Java 应用，通过 JDBC 访问数据库。

整体机制 两阶段提交协议的演变：官方解释

一阶段：业务数据和回滚日志记录在同一个本地事务中提交，释放本地锁和连接资源。
二阶段：
提交异步化，非常快速地完成。
回滚通过一阶段的回滚日志进行反向补偿。

详细描述各阶段

一阶段加载： 在一阶段，Seata会拦截“业务SQL”
在这里插入图片描述

解析SQL语义，找到“业务SQL”要更新的业务数据，在业务数据被更新前，将其保存为“before image”【前置镜像SQL快照】；
执行“业务SQL”，更新业务数据；
在业务数据更新之后，将其保存为“after image” ，最后生产行锁。

以上操作全部在一个数据库事务内完成，这样就保证了一阶段操作的原子性。类似于Spring的AOP思想

二阶段提交： 二阶段如果是顺利提交的话【表示不会出现异常】，由于“业务SQL”在一阶段的时候已经提交到数据库了，所以Seata框架只需要将一阶段保存的快照数据和行锁删掉，完成数据的清理即可。【提交异步化，非常快速地完成】
在这里插入图片描述

二阶段回滚： 回滚通过一阶段的回滚日志进行反向补偿。
在这里插入图片描述

二阶段如果是回滚的话，Seata就需要回滚一阶段已经执行的“业务SQL”，还原业务数据；
回滚的方式便是使用“before image”还原业务数据；
但是在还原前要首先校验脏写，对比“数据库当前业务数据”和“after image” ；
如果两份数据完全一直就说明没有脏写，可以还原业务数据，如果不一致就说明有脏写，出现脏写就需要转人工处理。

在这里插入图片描述

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...