SpringCloud-Alibaba

born_thisway

已于 2023-05-25 15:54:41 修改

阅读量174

点赞数

文章标签： spring cloud java spring boot

于 2023-05-24 15:28:48 首次发布

本文链接：https://blog.csdn.net/born_thisway/article/details/130846798

版权

SpringCloud-Alibaba

第一章微服务介绍
第二章微服务环境搭建
第三章 Nacos Discovery--服务治理
第四章 Sentinel--服务容错

第一章微服务介绍

1.1系统架构演变

单体—>垂直—>分布式—>SOA—>微服务

1.2.微服务架构介绍

将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目

1.2.1微服务架构的常见问题

这么多小服务，
如何管理？(服务治理注册中心[服务注册发现剔除])
如何通讯？(feign)
如何访问？(网关)
一旦出现问题了，如何自处理？(容错)
如何排错? (链路追踪)

第二章微服务环境搭建

采用电商项目中的商品、订单、用户

2.1 案例准备

2.1.1 技术选型

持久层: SpingData Jpa（没用到mybatis）

2.1.2 模块设计

springcloud-alibaba 父工程
shop-common 公共模块【实体类】
shop-user 用户微服务【端口: 807x】
shop-product 商品微服务【端口: 808x】
shop-order 订单微服务【端口: 809x】

2.1.3 微服务调用

用户下单为例，保存订单之前需要调用商品微服务查询商品的信息。
在这里插入图片描述

2.2 创建父工程

创建父工程springcloud-alibaba ，pom.xml中添加以下内容
（springcloud和springboot版本对应、
Springcloud、Springboot和SpringCloudAlibaba版本对应）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>

    <groupId>com.itheima</groupId>
    <artifactId>springcloud-alibaba</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>shop-common</module>
        <module>shop-user</module>
        <module>shop_product</module>
        <module>shop_order</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-cloud.version>Hoxton.SR12</spring-cloud.version>
        <spring-cloud-alibaba.version>2.2.7.RELEASE</spring-cloud-alibaba.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

2.3 创建基础模块

1 创建 shop-common 模块，在pom.xml中添加依赖

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

    <artifactId>shop-common</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>

</project>

2 创建实体类

//用户
@Entity(name="shop_user")
@Data
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer uid;//主键
    private String username;//用户名
    private String password;//密码
    private String telephone;//手机号

}

//商品
@Entity(name = "shop_product")
@Data
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer pid;//主键
    private String pname;//商品名称
    private Double pprice;//商品价格
    private Integer stock;//库存

}

//订单
@Entity(name = "shop_order")
@Data
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long oid;//订单id
    private Integer uid;//用户id
    private String username;//用户名
    private Integer pid;//商品id
    private String pname;//商品名称
    private Double pprice;//商品单价
    private Integer number;//购买数量

}

2.4 创建用户微服务

步骤:
1 创建模块导入依赖
2 创建SpringBoot主类
3 加入配置文件
4 创建必要的接口和实现类(controller service dao)
新建一个 shop-user 模块，然后进行下面操作

1 创建pom.xml

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

    <artifactId>shop-user</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>shop-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--springboot-web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
    </dependencies>

</project>

2 编写主类

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

3 创建配置文件

server:
  port: 8071
spring:
  application:
    name: service-user
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: root
  jpa:
    properties:
      hibernate:
        hbm2ddl:
          auto: update
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect

2.5 创建商品微服务

1 创建一个名为 shop_product 的模块，并添加springboot依赖

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

    <artifactId>shop_product</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>shop-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
    </dependencies>

</project>

2 创建工程的主类

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

}

3 创建配置文件application.yml

server:
  port: 8081
spring:
  application:
    name: service-product
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: root
  jpa:
    properties:
      hibernate:
        hbm2ddl:
          auto: update
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

4 创建ProductDao接口

package com.itheima.dao;
public interface ProductDao extends JpaRepository<Product,Integer> {

}

5 创建ProductService接口和实现类

public interface ProductService {

    Product findByPid(Integer pid);
}


@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private ProductDao productDao;
    
    @Override
    public Product findByPid(Integer pid) {
        return productDao.findById(pid).get();
    }
}

6 创建Controller

@RestController
@Slf4j
public class ProductController {
    @Autowired
    private ProductService productService;

    @GetMapping("/product/{pid}")
    public Product product(@PathVariable("pid") Integer pid){
        Product product = productService.findByPid(pid);
        log.info("查询到商品：" + JSON.toJSONString(product));
        return product;
    }
}

7 创建数据库shop，接着启动工程，等到数据库表创建完毕之后，加入测试数据

INSERT INTO shop_product VALUE(NULL,'小米','1000','5000');
INSERT INTO shop_product VALUE(NULL,'华为','2000','5000');
INSERT INTO shop_product VALUE(NULL,'苹果','3000','5000');
INSERT INTO shop_product VALUE(NULL,'OPPO','4000','5000');

8 通过浏览器访问服务
在这里插入图片描述

2.6 创建订单微服务

1 创建一个名为 shop-order 的模块,并添加springboot依赖

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

    <artifactId>shop_order</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>shop-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
    </dependencies>

</project>

2 创建工程的主类

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients//开启feign
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class,args);
    }
}

3 创建配置文件application.yml

server:
  port: 8091
  tomcat:
    max-threads: 10 #tomcat的最大并发值修改为10,默认是200
spring:
  application:
    name: service-order
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: root
  jpa:
    properties:
      hibernate:
        hbm2ddl:
          auto: update
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    sentinel:
      transport:
        port: 9999
        dashboard: localhost:8080
      web-context-unify: false

4 创建OrderDao接口


public interface OrderDao extends JpaRepository<Order,Long> {
}

5 创建OrderService接口和实现类

public interface OrderService {

    void save(Order order);

    void message();
}

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderDao orderDao;

    @Override
    public void save(Order order) {
        orderDao.save(order);
    }
    @SentinelResource("message")
    public void message(){
        System.out.println("message");
    }
}

6 创建Controller

@RestController
@Slf4j
public class OrderController {

    @Autowired
    private OrderService orderService;
    @Autowired
    private ProductService productService;

    @GetMapping("/order/prod/{pid}")
    public Order order(@PathVariable("pid") Integer pid){
        log.info("接收到{}号商品的下单请求,接下来调用商品微服务查询此商品信息", pid);
        //通过fegin调用商品微服务
        Product product = productService.findByPid(pid);
        log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));
        //模拟微服务调用需要2S时间
        try {
            Thread.sleep(2001);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //下单(创建订单)
        Order order = new Order();
        order.setUid(1);
        order.setUsername("测试用户");
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        order.setNumber(1);
        //为了不产生太多垃圾数据,暂时不做订单保存
        //orderService.save(order);
        log.info("创建订单成功,订单信息为{}", JSON.toJSONString(order));
        return order;
    }

    @RequestMapping("/order/message")
    public String message() {
        return "高并发下的问题测试";
    }

    @RequestMapping("/order/message1")
    public String message1() {
        orderService.message();
        return "message1";
    }
    int i = 0;
    @RequestMapping("/order/message2")
    public String message2() {
        i++;
        //异常比例为0.333
        if (i % 3 == 0){
            throw new RuntimeException();
        }
        //orderService.message();
        return "message2";
    }
    @RequestMapping("/order/message3")
    @SentinelResource("message3")//注意这里必须使用这个注解标识,热点规则不生效
    public String message3(String name, Integer age) {
        return name + age;
    }
}

7 启动工程,通过浏览器访问服务进行测试
在这里插入图片描述

第三章 Nacos Discovery–服务治理

3.3 nacos实战入门

3.3.1 搭建nacos环境

第1步: 安装nacos

下载地址: https://github.com/alibaba/nacos/releases
下载zip格式的安装包，然后进行解压缩操作

第2步: 启动nacos

#切换目录
cd nacos/bin
#命令启动
startup.cmd -m standalone

第3步: 访问nacos
打开浏览器输入http://localhost:8848/nacos，即可访问服务，默认密码是nacos/nacos

3.3.2 将商品微服务注册到nacos

接下来开始修改 shop-product 模块的代码，将其注册到nacos服务上
1 在pom.xml中添加nacos的依赖

<!--nacos客户端-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

2 在主类上添加@EnableDiscoveryClient注解

@SpringBootApplication
@EnableDiscoveryClient
public class ProductApplication

3 在application.yml中添加nacos服务的地址

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

4 启动服务，观察nacos的控制面板中是否有注册上来的商品微服务
在这里插入图片描述

3.4 实现服务调用的负载均衡

3.4.1 什么是负载均衡

负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器,组件）上进行执行。
根据负载均衡发生位置的不同,一般分为服务端负载均衡和客户端负载均衡。
服务端负载均衡指的是发生在服务提供者一方,比如常见的nginx负载均衡
而客户端负载均衡指的是发生在服务请求的一方，也就是在发送请求之前已经选好了由哪个实例处理请求
在这里插入图片描述
我们在微服务调用关系中一般会选择客户端负载均衡，也就是在服务调用的一方来决定服务由哪个提供者执行。

3.4.2 自定义实现负载均衡

1 通过idea再启动一个 shop-product 微服务，设置其端口为8082
方式：复制一个，并设置端口8082
在这里插入图片描述
2 通过nacos查看微服务的启动情况

3 修改 shop-order 的代码，实现负载均衡
TODO 暂时省略

3.4.3 基于Ribbon实现负载均衡

3.5 基于Feign实现服务调用

3.5.1 什么是Feign

Feign使得调用远程服务就像调用本地服务一样简单，只需要创建一个接口并添加一个注解即可。
Nacos很好的兼容了Feign， Feign默认集成了 Ribbon，所以在Nacos下使用Fegin默认就实现了负载均衡的效果。
注意：Feign都是使用在上游

3.5.2 Feign的使用

1 加入Fegin的依赖

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

2 在主类上添加Fegin的注解

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients//开启Fegin
public class OrderApplication {}

3 创建一个service，并使用Fegin实现微服务调用

@FeignClient("service-product")//声明调用的提供者的name
public interface ProductService {
    //指定调用提供者的哪个方法
    @GetMapping("/product/{pid}")
    Product findByPid(@PathVariable("pid") Integer pid);

}

4 修改controller代码，并启动验证

    @GetMapping("/order/prod/{pid}")
    public Order order(@PathVariable("pid") Integer pid){
        log.info("接收到{}号商品的下单请求,接下来调用商品微服务查询此商品信息", pid);
        //通过fegin调用商品微服务
        Product product = productService.findByPid(pid);
        log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));
        //下单(创建订单)
        Order order = new Order();
        order.setUid(1);
        order.setUsername("测试用户");
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        order.setNumber(1);
        //为了不产生太多垃圾数据,暂时不做订单保存
        //orderService.save(order);
        log.info("创建订单成功,订单信息为{}", JSON.toJSONString(order));
        return order;
    }

5 重启order微服务,查看效果

第四章 Sentinel–服务容错

4.1 高并发带来的问题

在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用，但是由于网络原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现问题，调用这个服务就会出现网络延迟，此时若有大量的网络涌入，会形成任务堆积，最终导致服务瘫痪。

模拟一个高并发的场景：
1 编写java代码

@RestController
@Slf4j
public class OrderController {
    @Autowired
    private OrderService orderService;
    @Autowired
    private ProductService productService;

    @GetMapping("/order/prod/{pid}")
    public Order order(@PathVariable("pid") Integer pid){
        log.info("接收到{}号商品的下单请求,接下来调用商品微服务查询此商品信息", pid);
        //通过fegin调用商品微服务
        Product product = productService.findByPid(pid);
        log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));
        //模拟微服务调用需要2S时间
        try {
            Thread.sleep(2001);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //下单(创建订单)
        Order order = new Order();
        order.setUid(1);
        order.setUsername("测试用户");
        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        order.setNumber(1);
        //为了不产生太多垃圾数据,暂时不做订单保存
        //orderService.save(order);
        log.info("创建订单成功,订单信息为{}", JSON.toJSONString(order));
        return order;
    }

    @RequestMapping("/order/message")
    public String message() {
        return "高并发下的问题测试";
    }
}

2 修改配置文件中tomcat的并发数

server:
  port: 8091
  tomcat:
    max-threads: 10 #tomcat的最大并发值修改为10,默认是200

3 接下来使用压测工具,对请求进行压力测试
下载地址https://jmeter.apache.org/

第一步：修改配置，并启动软件
进入bin目录,修改jmeter.properties文件中的语言支持为language=zh_CN，然后点击jmeter.bat启动软件。
第二步：添加线程组
第三步：配置线程并发数

将发起20个线程，每个线程执行100次，在1秒内发起全部的线程（Ramp-Up Period=0时，同时发起所有线程）
第四步：添加Http取样
第五步：配置取样，并启动测试

4 访问ｍessage方法观察效果
结论:
此时会发现, 由于order方法囤积了大量请求, 导致ｍessage方法的访问出现了问题，这就是服务雪崩的雏形。

4.3 常见容错方案

常见的容错思路有隔离、超时、限流、熔断、降级这几种

4.4 Sentinel入门

4.4.1 什么是Sentinel

Sentinel (分布式系统的流量防卫兵)用于服务容错,从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。

Sentinel 分为两个部分:

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

4.4.2 微服务集成Sentinel

为微服务集成Sentinel非常简单, 只需要加入Sentinel的依赖即可
1 在pom.xml中加入下面依赖

<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

2 编写一个Controller测试使用

@RestController
@Slf4j
public class OrderController3 {
	@RequestMapping("/order/message1")
	public String message1() {
		return "message1";
	}
	@RequestMapping("/order/message2")
	public String message2() {
		return "message2";
	}
}

4.4.3 安装Sentinel控制台

1 下载jar包,解压到文件夹
https://github.com/alibaba/Sentinel/releases
2 启动控制台

# 直接使用jar命令启动项目(控制台本身是一个SpringBoot项目)
java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar

3 修改 shop-order ,在里面加入有关控制台的配置
我们需要将我们的微服务程序注册到控制台上,即在微服务中指定控制台的地址, 并且还要开启一个跟控制台传递数据的端口, 控制台也可以通过此端口调用微服务中的监控程序获取微服务的各种信息

spring:
  cloud:
    sentinel:
      transport:
        port: 9999 #跟控制台交流的端口,随意指定一个未使用的端口即可
        dashboard: localhost:8080 # 指定控制台服务的地址

第4步: 通过浏览器访问localhost:8080 进入控制台 ( 默认用户名密码是 sentinel/sentinel )
(注意：sentinel是懒加载，需访问那个接口才会出来）

4.6 Sentinel规则

4.6.1 流控规则

流量控制：其原理是监控应用流量的QPS(每秒查询率) 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮

第1步: 点击簇点链路，我们就可以看到访问过的接口地址（因为是懒加载所以需要访问过的接口才能看到），然后点击对应的流控按钮，进入流控规则配置页面。新增流控规则界面如下:
在这里插入图片描述

资源名：唯一名称，默认是请求路径，可自定义
针对来源：指定对哪个微服务进行限流，默认指default，意思是不区分来源，全部限制
阈值类型/单机阈值：

QPS（每秒请求数量）: 当调用该接口的QPS达到阈值的时候，进行限流；一秒内的阈值 (这里选了QPS，表示秒内的并发量最大为**)
线程数：当调用该接口的线程数达到阈值的时候，进行限流

是否集群：暂不需要集群

接下来我们以QPS为例来研究限流规则的配置。

4.6.1.1 简单配置

设置阈值类型为QPS，单机阈值为3。即每秒请求量大于3的时候开始限流。
接下来，在流控规则页面就可以看到这个配置。
在这里插入图片描述
然后快速访问 /order/message1 接口，观察效果。此时发现，当QPS > 3的时候，服务就不能正常响应，而是返回Blocked by Sentinel (flow limiting)结果。

4.6.1.2 配置流控模式

点击上面设置流控规则的编辑按钮，然后在编辑页面点击高级选项，会看到有流控模式一栏。
在这里插入图片描述
sentinel共有三种流控模式，分别是：

直接（默认）：接口达到限流条件时，开启限流
关联：当关联的资源（接口）达到限流条件时，开启限流【适合做应用让步】（使用场景：比如用户支付时需要修改订单状态，同时用户要查询订单。查询和修改操作会争抢数据库锁，产生竞争。业务需求是有限支付和更新订单的业务，因此当修改订单业务触发阈值时，需要对查询订单业务限流。当/write资源访问量触发阈值时，就会对/read资源限流，避免影响/write资源。）
链路：当从某个接口过来的资源达到限流条件时，开启限流

在这里插入图片描述

下面呢分别演示三种模式：
直接流控模式：最简单，指定的接口达到限流条件时开启限流。
在这里插入图片描述

关联流控模式：指定接口关联的接口达到限流条件时，开启对指定接口开启限流。
第1步：配置限流规则, 将流控模式设置为关联，关联资源设置为的 /order/message2。
在这里插入图片描述
第3步：通过jmeter软件向/order/message2连续发送请求，注意QPS一定要大于3

线程数：相当于模拟的用户数量（线程）
Ramp-up period(seconds)：达到指定线程需要的时间，例如线程数为100，时间设定为10s，那么就是10s加载100个线程，每秒启动的线程数=100/10=10；
循环次数：如果填具体的数值，就是循环对应的次数；如果选择永远，则一直执行下去，直到手动停止；循环开始的时间几乎和第一次启动时间相同；
在这里插入图片描述
第4步：访问/order/message1,会发现已经被限流

链路流控模式指的是，当从某个接口过来的资源达到限流条件时，开启限流。它的功能有点类似于针对来源配置项，区别在于：针对来源是针对上级微服务，而链路流控是针对上级接口，也就是说它的粒度更细。
在这里插入图片描述

第1步：编写一个service，在里面添加一个方法message
注意：一定要加上这个注解@SentinelResource(“message”)

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderDao orderDao;

    @Override
    public void save(Order order) {
        orderDao.save(order);
    }
    @SentinelResource("message")
    public void message(){
        System.out.println("message");
    }
}

第2步：两个测试链路–在Controller中声明两个方法，分别调用service中的方法

@RestController
@Slf4j
public class OrderController3 {
	@Autowired
	private OrderServiceImpl3 orderServiceImpl3;
	@RequestMapping("/order/message1")
	public String message1() {
		orderServiceImpl3.message();
		return "message1";
	}
	@RequestMapping("/order/message2")
	public String message2() {
		orderServiceImpl3.message();
		return "message2";
	}
}

第3步: 关闭 context整合
SCA 2.1.1.RELEASE之后的版本,可以通过配置spring.cloud.sentinel.web-context-unify=false即可关闭收敛
在这里插入图片描述
第4步: 控制台配置限流规则

第5步: 分别通过 /order/message1 和 /order/message2 访问, 发现2没问题, 1的被限流了

总结链路流控的注意点：
Sentinel默认只标记Controller中的方法为资源，如果要标记其它方法，需要利用@SentinelResource注解

去配置文件里配置，关闭context，就可以让controller里的方法单独成为一个链路；不关闭context的话，controller里的方法都会默认进去sentinel默认的根链路里，这样就只有一条链路，无法流控链路模式
在这里插入图片描述

4.6.1.3 配置流控效果

快速失败（默认）: 直接失败，抛出异常，不做任何额外的处理，是最简单的效果
Warm Up：它从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS阈值的1/3，然后慢慢增长，直到最大阈值，适用于将突然增大的流量转换为缓步增长的场景。
排队等待：让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待；它还会让设置一个超时时间，当请求超过超时间时间还未处理，则会被丢弃

4.6.2 降级规则

降级规则就是设置当满足什么条件的时候，对服务进行降级。Sentinel提供了三个衡量条件：

平均响应时间
异常比例
异常数

接下来详细描述：

平均响应时间 ：当资源的平均响应时间超过阈值（以 ms 为单位）之后，资源进入准降级状态。
如果接下来 1s 内持续进入 5 个请求，它们的 RT都持续超过这个阈值，那么在接下的时间窗口（以 s 为单位）之内，就会对这个方法进行服务降级。

注意 Sentinel 默认统计的 RT 上限是 4900 ms，超出此阈值的都会算作 4900 ms，若需要变更此上限可以通过启动配置项 -Dcsp.sentinel.statistic.max.rt=xxx 来配置。

异常比例：当资源的每秒异常总数占通过量的比值超过阈值之后，资源进入降级状态，即在接下的时间窗口（以 s 为单位）之内，对这个方法的调用都会自动地返回。异常比率的阈值范围是 [0.0,1.0]。
第1步: 首先模拟一个异常

 	int i = 0;
    @RequestMapping("/order/message2")
    public String message2() {
        i++;
        //异常比例为0.333
        if (i % 3 == 0){
            throw new RuntimeException();
        }
        return "message2";
    }

第2步: 设置异常比例为0.25
在这里插入图片描述

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

问题：流控规则和降级规则返回的异常页面是一样的，我们怎么来区分到底是什么原因导致的呢？

4.6.3 热点规则

热点参数流控规则是一种更细粒度的流控规则, 它允许将规则具体到参数上。
注意： @SentinelResource(“message3”)//注意这里必须使用这个注解标识,否则热点规则不生效

热点规则简单使用
热点规则增强使用

接下来详细描述：

热点规则简单使用
第1步: 编写代码

@RequestMapping("/order/message3")
    @SentinelResource("message3")//注意这里必须使用这个注解标识,热点规则不生效
    public String message3(String name, Integer age) {
        return name + age;
    }

第2步: 配置热点规则
在这里插入图片描述
第3步: 分别用两个参数访问,会发现只对第一个参数限流了，第二个没限流

热点规则增强使用
参数例外项允许对一个参数的具体值进行流控
编辑刚才定义的规则,增加参数例外项
注意：需要先在簇点链路添加热点规则，再在热点规则中编辑，再点高级选项
在这里插入图片描述

4.6.4 授权规则

很多时候，我们需要根据调用来源来判断该次请求是否允许放行，这时候可以使用 Sentinel 的来源访问控制的功能。来源访问控制根据资源的请求来源（origin）限制资源是否通过：

若配置白名单，则只有请求来源位于白名单内时才可通过；
若配置黑名单，则请求来源位于黑名单时不通过，其余的请求通过。

在这里插入图片描述
只要Sentinel保护的接口资源被访问，Sentinel就会调用 RequestOriginParser 的实现类去解析访问来源。
第1步: 自定义来源处理规则

@Component
public class RequestOriginParserDefinition implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest request) {
        String serviceName = request.getParameter("serviceName");
        if(StringUtils.isEmpty(serviceName)){
            throw new RuntimeException("serviceName is null!");
        }
        return serviceName;
    }
}

第2步: 授权规则配置
这个配置的意思是只有serviceName=pc不能访问(黑名单)
在这里插入图片描述
第3步: 访问 http://localhost:8091/order/message1?serviceName=pc观察结果

4.6.5 系统规则（暂略）

系统保护规则是从应用级别的入口流量进行控制，从单台机器的总体 Load、RT、入口 QPS 、CPU使用率和线程数五个维度监控应用数据，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。
系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量 (进入应用的流量) 生效。

Load（仅对 Linux/Unix-like 机器生效）：当系统 load1 超过阈值，且系统当前的并发线程数超过。系统容量时才会触发系统保护。系统容量由系统的 maxQps * minRt 计算得出。设定参考值一般是 CPU cores * 2.5。
RT：当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。入口 QPS：当单台机器上所有入口流量的 QPS
达到阈值即触发系统保护。 CPU使用率：当单台机器上所有入口流量的 CPU使用率达到阈值即触发系统保护。

扩展: 自定义异常返回

@Component
public class ExceptionHandlerPage implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
        response.setContentType("application/json;charset=utf-8");
        ///BlockException 异常接口,包含Sentinel的五个异常
            //AuthorityException 授权异常
            //DegradeException 降级异常
            //FlowException 限流异常
            //ParamFlowException 参数限流异常
            //SystemBlockException 系统负载异常
        ResponseData data = null;
        if(e instanceof FlowException){
            data = new ResponseData(-1, "接口被限流了...");
        }else if(e instanceof DegradeException){
            data = new ResponseData(-2, "接口被降级了...");
        }
        response.getWriter().write(JSON.toJSONString(data));
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    class ResponseData{
        private int code;
        private String message;
    }

}