服务容错保护Sentinel &服务网关Gateway

最新推荐文章于 2024-04-24 13:43:13 发布
最新推荐文章于 2024-04-24 13:43:13 发布
阅读量768 收藏 1
点赞数 1
文章标签： sentinel gateway java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36768098/article/details/130013269
版权

目录

主要内容

  • 服务保护Sentinel
  • 服务网关Gateway

1.服务保护Sentinel

1.1.高并发带来的问题

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

1.1.1.创建工程

1.1.1.1.创建服务提供者
1.1.1.1.1.创建工程

拷贝feign_provider工程：
在这里插入图片描述

1.1.1.1.2.application.yml
server:
  port: 9090
spring:
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.209.129:8848
  application:
    name: sentinel-provider
1.1.1.1.3.service
package com.bjpowernode.service;

import com.bjpowernode.pojo.User;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

	@Override
	public User getUserById(Integer id) {
		//模拟一次网络延时
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		return new User(id,"王粪堆-provider",18);
	}
}
1.1.1.2.创建feign接口
1.1.1.2.1.创建工程

拷贝feign_interface工程：
在这里插入图片描述

1.1.1.2.2.feign
package com.bjpowernode.feign;

import com.bjpowernode.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@FeignClient("sentinel-provider")
public interface UserFeign {
    @RequestMapping(value = "/provider/getUserById/{id}")
    public User getUserById(@PathVariable Integer id);
}
1.1.1.3.创建服务消费者
1.1.1.3.1.创建工程

拷贝feign_consumer工程：
在这里插入图片描述

1.1.1.3.2.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">
    <parent>
        <artifactId>springcloud_parent</artifactId>
        <groupId>com.bjpowernode</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sentinel_consumer</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.bjpowernode</groupId>
            <artifactId>springcloud_common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--feign接口-->
        <dependency>
            <groupId>com.bjpowernode</groupId>
            <artifactId>sentinel_feign</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>
1.1.1.3.3.application.yml
server:
  tomcat:
    max-threads: 10 #tomcat的最大并发值修改为10,默认是200
1.1.1.3.4.controller
@RequestMapping(value = "/hello")
public String hello() {
    return "Hello Sentienl！！！";
}

1.1.2.测试

  1. 下载jemeter压测工具：https://jmeter.apache.org/
    在这里插入图片描述
  2. 添加线程组
    在这里插入图片描述
  3. 配置线程并发数
    在这里插入图片描述
  4. 添加Http请求

在这里插入图片描述
5. 配置http请求并启动线程：http://127.0.0.1:8080/consumer/getUserById/1
在这里插入图片描述
6. 访问：http://127.0.0.1:8080/consumer/hello
在这里插入图片描述
结论：

此时会发现, 由于sentinel_consumer囤积了大量请求, 导致msg方法的访问出现了线程阻塞等待问题，这就是服务雪崩的雏形。

1.1.3.雪崩效应

​ 雪崩效应：微服务调用链路中的某个服务故障，引起整个链路中的所有微服务都不可用，这就是雪崩。
在这里插入图片描述
​ 雪要防止雪崩的扩散，我们就要做好服务的容错，容错说白了就是保护自己不被猪队友拖垮的一些措施。我们无法完全杜绝雪崩源头的发生，只有做好足够的容错，保证在一个服务发生问题，不会影响到其它服务的正常运行。也就是＂雪落而不雪崩＂。

1.1.4.常见容错组件

  • Hystrix

    Hystrix是由Netflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或者第三方库，防止级联失败，从而提升系统的可用性与容错性。

  • Resilience4J

    Resilicence4J一款非常轻量、简单，并且文档非常清晰、丰富的熔断工具，这也是Hystrix官方推荐的替代产品。不仅如此，Resilicence4j还原生支持Spring Boot 1.x/2.x，而且监控也支持和prometheus等多款主流产品进行整合。

  • Sentinel

    Sentinel 是阿里巴巴开源的一款断路器实现，本身在阿里内部已经被大规模采用，非常稳定。

1.2.Sentinel介绍

1.2.1.Sentinel 是什么

​ Sentinel (分布式系统的流量防卫兵) 是阿里开源的一套用于服务容错的流量控制框架。它以流量为切入点, 从流量控制、熔断降级等多个维度来保护服务的稳定性。

1.2.2.Sentinel的基本概念

  • 资源

    资源就是Sentinel要保护的东西，它可以是Java应用程序中的任何内容，可以是一个服务，也可以是一个方法；我们入门案例中的hello()方法就可以认为是一个资源。

  • 规则

    规则就是用来定义如何进行保护资源的，主要包括流量控制规则、熔断降级规等。

1.2.2.Sentinel的主要功能

Sentinel的主要功能就是容错，主要体现为下面这两个方面：

  • 流量控制(保证应用不被上游服务压垮)

    任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。Sentinel作为一个调配器，可以根据需要把随机的请求调整成合适的形状。
    在这里插入图片描述

  • 熔断降级(保证应用不被下游服务拖垮)

    当检测到调用链路中某个资源某个资源出现慢调用比例或异常比例超出阈值的时候，则暂时切断对下游服务的调用，避免级联故障
    在这里插入图片描述
    总之一句话，我们需要做的事情，就是在Sentinel的资源上配置各种各样的规则，来实现各种容错的功能：
    在这里插入图片描述

1.2.2.Sentinel 的历史

  • 2012 年，Sentinel 诞生，主要功能为入口流量控制。
  • 2013-2017 年，Sentinel 在阿里巴巴集团内部迅速发展，成为基础技术模块，覆盖了所有的核心场景。Sentinel 也因此积累了大量的流量归整场景以及生产实践。
  • 2018 年，Sentinel 开源，并持续演进。
  • 2019 年，Sentinel 朝着多语言扩展的方向不断探索，推出 C++ 原生版本。
  • 2020 年，推出 Sentinel Go 版本，继续朝着云原生方向演进。

1.2.3.Sentinel入门

1.2.3.1.抛异常方式
1.2.3.1.1.sentinel_consumer
1.2.3.1.1.1.pom.xml
<!--sentinel核心依赖-->
<dependency>
	<groupId>com.alibaba.csp</groupId>
	<artifactId>sentinel-core</artifactId>
</dependency>
1.2.3.1.1.2.controller
    @RequestMapping(value = "/hello")
    public String hello() {
        Entry entry = null;
        try {
            //SphU：执行规则检查，获取资源失败时会抛BlockException异常
            entry = SphU.entry("/consumer/hello");
            return "Hello Sentienl！！！";//被保护的逻辑
        } catch (BlockException e) {
            //资源访问被阻止
            e.printStackTrace();
            return "接口被限流了, exception: " + e;
        }finally {
            // SphU.entry(xxx) 需要与 entry.exit() 成对出现,否则会导致调用链记录异常
            if (entry != null) {
                entry.exit();
            }
        }
    }

    /**
     * 定义限流/流控规则
     */
    @PostConstruct//当前类的构造函数执行之后执行
    public void initFlowQpsRule() {
        //1.创建存放限流规则的集合
        List<FlowRule> rules = new ArrayList<FlowRule>();
        //2.创建限流规则
        FlowRule rule1 = new FlowRule();
        rule1.setResource("/consumer/hello");//定义资源，名称唯一
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);//定义限流规则类型
        rule1.setCount(2); // QPS控制在2以内
        //3.将限流规则存放到集合中
        rules.add(rule1);
        //4.加载限流规则
        FlowRuleManager.loadRules(rules);
    }
1.2.3.1.2.测试
  1. 正常访问：http://127.0.0.1/consumer/hello
    在这里插入图片描述
  2. 高并发访问：http://127.0.0.1/consumer/hello
    在这里插入图片描述
1.2.2.2.注解方式

上述通过try-catch风格的API可以实现限流，但是对代码侵入性太高，推荐使用注解的方式来实现。

1.2.3.1.1.sentinel_consumer
1.2.3.1.1.1.pom.xml
<!--sentinel注解依赖-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
</dependency>
1.2.3.1.1.2.controller
    @RequestMapping(value = "/hello2")
    @SentinelResource(value="/consumer/hello2",blockHandler = "blockHandlerMethod")
    public String hello2() {
        return "Hello Sentienl2！！！";//被保护的逻辑
    }

    /**
     *资源访问被阻止的兜底方法
     */
    public String blockHandlerMethod(BlockException e){
        return "接口被限流了, exception: " + e;
    }

    @PostConstruct
    public void initFlowQpsRule() {
        List<FlowRule> rules = new ArrayList<FlowRule>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource("/consumer/hello2");//注意修改资源名称
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setCount(2);
        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
    }
1.2.3.1.1.3.app
    //开启sentinel注解扫描
    @Bean
    public SentinelResourceAspect sentinelResourceAspect(){
        return new SentinelResourceAspect();
    }
1.2.3.1.2.测试
  1. 正常访问：http://127.0.0.1/consumer/hello2
    在这里插入图片描述
  2. 高并发访问：http://127.0.0.1/consumer/hello2
    在这里插入图片描述

1.2.3.Sentinel的安装和启动

Sentinel 提供一个轻量级的控制台, 它提供资源实时监控以及规则管理等功能。

  1. 下载地址：https://github.com/alibaba/Sentinel/releases
    在这里插入图片描述
  2. 执行命令：java -jar sentinel-dashboard-1.8.1.jar
    在这里插入图片描述
  3. 浏览器访问：http://localhost:8080，默认账号密码：sentinel/sentinel
    在这里插入图片描述

1.2.4.Sentinel接入控制台

1.2.4.1.sentinel_consumer
1.2.4.1.1.pom.xml
        <!--sentinel核心依赖-->
        <!--<dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-core</artifactId>
        </dependency>-->
        <!--sentinel注解依赖-->
        <!--<dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-annotation-aspectj</artifactId>
        </dependency>-->
        <!-- sentinel启动器 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
1.2.4.1.2.application.yml
spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8080 #指定sentinel的地址
1.2.4.1.3.controller
/**
 *被保护的逻辑
 */
@RequestMapping(value = "/hello3")
public String hello3() {
    return "Hello Sentienl3！！！";
}
1.2.4.2.测试

  1. 流量监控：sentinel是懒加载，需要浏览器访问：http://127.0.0.1/consumer/hello3
    在这里插入图片描述

  2. 新增流控规则
    在这里插入图片描述
    在这里插入图片描述

  3. 高并发访问：http://127.0.0.1/consumer/hello3
    在这里插入图片描述

1.3.Sentinel规则

流控规则说明：

  • 资源名：唯一名称，默认请求路径

  • 针对来源：Sentinel可以针对调用者进行限流，填写微服务名，指定对哪个微服务进行限流 ，默认default(不区分来源，全部限制)

  • 阈值类型：

    1. QPS：当调用该接口的QPS达到了阈值的时候，进行限流；

    2. 线程数：当调用该接口的线程数达到阈值时，进行限流

  • 单机阈值：次数

  • 是否集群：不需要集群

  • 流控模式：

    1. 直接：接口达到限流条件时，直接限流

    2. 关联：当关联的资源达到阈值时限流自己[适合做应用让步]

    3. 链路：当从某个接口过来的资源达到限流条件时，开启限流

  • 流控效果

    1. 快速失败：直接失败
    2. Warm Up：即请求 QPS 从 threshold / 3 开始，经预热时长逐渐升至设定的 QPS 阈值
    3. 排队等待：让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待；当请求超过超指定时间还未处理，则会被丢弃。

1.3.1.流控规则

1.3.1.1.阈值类型
1.3.1.1.1.QPS

  • 说明

    QPS：代表每秒的访问次数，只要访问次数到达一定的阈值，则进行限流操作

  • 案例

  1. 新增流控规则
    在这里插入图片描述

  2. 浏览器高并发访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述

1.3.1.1.2.线程数

  • 说明

    线程数：代表的是每秒内访问该api接口的线程数，如果该接口的操作比较长，当排队的线程数到达阈值的时候，进行限流操作

  • 案例

1.新增流控规则
在这里插入图片描述
2.jmeter模拟高并发

在这里插入图片描述
在这里插入图片描述
3.浏览器访问：http://127.0.0.1/consumer/getUserById/1
在这里插入图片描述

1.3.1.2.流控模式
1.3.1.2.1.直接

  • 说明

    对当前资源的流量控制

1.3.1.2.2.关联

  • 说明

    当关联的资源达到阈值时，限流自己。如支付接口达到阈值时限流订单接口。

  • 案例

  1. 新增关联资源
@RequestMapping(value="/test")
public String test(){
    return "test";
}
  1. 新增流控规则
    在这里插入图片描述
  2. jmeter模拟高并发：http://127.0.0.1:/consumer/test
    在这里插入图片描述
    在这里插入图片描述
  3. 浏览器访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述
1.3.2.2.3.链路

  • 说明

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

  • 案例

    略…

1.3.1.3.流控效果
1.3.1.3.1.快速失败

  • 说明

    限流的时候直接提示

  • 案例

    略…

1.3.1.3.2.warm up

  • 说明

    它从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS阈值的 1/3，然后慢慢增长，直到最大阈值，适用于将突然增大的流量转换为缓步增长的场景。

  • 案例

  1. 新增流控规则
    在这里插入图片描述
  2. 5秒前访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述
  3. 5秒后访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述
1.3.2.3.3.排队等待

  • 说明

    即/consumer/getUserById/1每秒1次请求，超过的话就排队等待，等待的超时时间为10ms，目的是为了匀速处理请求，保证服务的均匀性，而不是一会处理大量的请求，一会有没有请求可处理。

  • 案例

  1. 新增流控规则
    在这里插入图片描述
  2. 打印请求时间
@RequestMapping(value = "/getUserById/{id}")
public User getUserById(@PathVariable Integer id) {
    //打印请求时间
    System.out.println("排队等待效果："+new Date());
    return userFeign.getUserById(id);
}
  1. 高并发访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述

1.3.2.热点规则

1.3.2.1.什么是热点参数流控

  • 热点即经常访问的数据，比如：

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

  • 热点参数流控规则是一种更细粒度的流控规则, 它允许将规则具体到参数上。

1.3.2.2.案例
  1. 添加参数
    @RequestMapping(value = "/getUserById/{id}")
	//不加@SentinelResource注解注解则不会触发热点参数流控
    @SentinelResource(value = "getUserById", blockHandler = "blockHandlerMethod")
    public User getUserById(@PathVariable Integer id) {
        return userFeign.getUserById(id);
    }
	//资源访问被阻止的备选逻辑
    public User blockHandlerMethod(Integer id, BlockException e){
        return new User(id,"this is blockHandlerMethod",0);
    }
  1. 新增流控规则
    在这里插入图片描述
  2. 高并发访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述
    **注意：**使用@SentinelResource注解时，sentinel不在使用默认行为
1.3.3.3.参数例外项

  1. 新增流控规则
    在这里插入图片描述

  2. 5秒内超过2次访问：http://127.0.0.1/consumer/getUserById/2
    在这里插入图片描述

  3. 5秒内超过3次访问：
    在这里插入图片描述

1.3.3.系统规则

1.3.3.1.什么是系统规则

系统规则和流控规则不一样，流控规则是针对方法设定的，系统规则是针对一个应用设定的；发生系统规则中配置的情况的时候，会把整个应用都断掉，所有的接口对不能对外提供服务了，这个设计很少用，因为粒度太大了，用 Sentinel 一般都是做细粒度的维护，如果设置了系统规则，可能自己都不知道怎么回事，系统就用不了了；

1.3.3.2.系统限流的 5 中预置类型
  • LOAD：只有在 Linux 系统的机器上才会生效，可以根据当前操作系统的负载，来决定是否触发保护；
  • RT：这个应用上，所有请求的平均响应时间，如果超过某个值，就停止新的请求；
  • 线程数：这个应用上，所有的请求消耗的线程数加起来，如果超过某个值，就停止新的请求；
  • 入口 QPS：这个应用上，所有接口的 QPS 加起来，如果超过某个值，就停止新的请求；
  • CPU 使用率：CPU 的使用率，如果超过一个百分比，就停止新的请求；
1.3.3.3.案例

  1. 新增流控规则
    在这里插入图片描述

  2. 高并发访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述

1.3.4.授权规则

1.3.4.1.什么是授权规则

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

  • 若配置白名单，则只有请求来源位于白名单内时才可通过；

  • 若配置黑名单，则请求来源位于黑名单时不通过，其余的请求通过。

1.3.4.2.案例
  1. 获取来源标识
package com.bjpowernode.config;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.RequestOriginParser;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
//sentinel是通过RequestOriginParser这个接口的parseOrigin来获取请求头资源的
@Component
public class RequestOriginParserDefinition implements RequestOriginParser {

    /**
     * Sentinel保护的接口资源被访问，Sentinel就会调用 RequestOriginParser 的实现类去解析访问来源。
     * @param request
     * @return
     */
    @Override
    public String parseOrigin(HttpServletRequest request) {
        //当前 来源标识 放在了请求参数里面，可以放到的地方有很多，比如参数/请求头/session/等等
        String origin = request.getParameter("origin");
        System.out.println("origin："+origin);
        return origin;
    }
}
  1. 新增流控规则
    在这里插入图片描述
  2. 黑名单规则：
    在这里插入图片描述
    在这里插入图片描述
  3. 白名单规则：
    在这里插入图片描述
    在这里插入图片描述

1.3.5.降级规则

熔断规则就是设置当满足什么条件的时候，暂时切断对下游服务的调用。那么怎么去判断资源是否处于稳定状态呢？

  • Sentinel提供了三个衡量条件：
  1. 慢调用比例
属性说明
最大RT需要设置的阈值，超过该值则为慢调用
比例阈值慢调用占所有的调用的比率，范围：[0~1]
熔断时长在这段时间内发生熔断、拒绝所有请求
最小请求数即允许通过的最小请求数，在该数量内不发生熔断
  1. 异常比例
属性说明
异常比例阈值异常比例=发生异常的请求数÷请求总数取值范围：[0~1]
熔断时长在这段时间内发生熔断、拒绝所有请求
最小请求数即允许通过的最小请求数，在该数量内不发生熔断
  1. 异常数
属性说明
异常数请求发生异常的数量
熔断时长在这段时间内发生熔断、拒绝所有请求
最小请求数即允许通过的最小请求数，在该数量内不发生熔断
  • 服务熔断状态切换：
    在这里插入图片描述
1.3.5.1.慢调用比例
  1. 新增熔断策略
    在这里插入图片描述
  2. 控制请求时间
    @RequestMapping(value = "/getUserById/{id}")
    public User getUserById(@PathVariable Integer id) {
        System.out.println("熔断降级效果："+new Date());
        //控制请求时间
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userFeign.getUserById(id);
    }
  1. 高并发访问：http://127.0.0.1:9091/consumer/getUserById/1
    在这里插入图片描述
  2. 两次访问间隔5秒
    在这里插入图片描述
1.3.5.2.异常比例
  1. 新增熔断策略
    在这里插入图片描述
  2. 请求报异常
@RequestMapping(value = "/getUserById/{id}")
public User getUserById(@PathVariable Integer id) {
    System.out.println("熔断降级效果："+new Date());
    //请求报异常
    int a = 6/0;
    return userFeign.getUserById(id);
}
  1. 浏览器访问：http://127.0.0.1:9091/consumer/getUserById/1
    在这里插入图片描述
  2. 熔断后两次访问间隔5秒
    在这里插入图片描述
    在这里插入图片描述
1.3.5.3.异常数
  1. 新增熔断策略
    在这里插入图片描述
  2. 请求报异常
@RequestMapping(value = "/getUserById/{id}")
public User getUserById(@PathVariable Integer id) {
    System.out.println("熔断降级效果："+new Date());
    //请求报异常
    int a = 6/0;
    return userFeign.getUserById(id);
}
  1. 浏览器访问5次以上：http://127.0.0.1:9091/consumer/1
    在这里插入图片描述
  2. 熔断后两次访问间隔60秒
    在这里插入图片描述
    在这里插入图片描述

1.4.Sentinel的blockHandler

1.4.1.blockHandler

​ 当服务经过sentinel流控或熔断的时候，使用的是Sentinel默认的兜底方法，但是系统默认的方法并没有体现我们的业务要求。

​ 所以Sentinel的@SentinelResource提供了blockHandler属性，让我们可以另外定义一个方法来替服务被限制时的返回数据。

1.4.2.@SentinelResource注解说明

  • 其主要属性如下:：
属性作用
value资源名称
blockHandler处理BlockException(Sentinel的配置)的兜底方法，要求：
1.返回类型与原方法一致
2.参数类型与原方法一致，并在最后加BlockException类型的参数
blockHandlerClass存放blockHandler方法的类，要求：
1.对应的方法必须static修饰

1.4.3.同一个类中定义

@RestController
@RequestMapping(value = "/consumer")
public class ConsumerController {

    @Autowired
    private UserFeign userFeign;

    @RequestMapping(value = "/getUserById/{id}")
    @SentinelResource(value ="getUserById",
            blockHandler="blockHandlerMethod")
    public User getUserById(@PathVariable Integer id) {
        int a = 6/0;
        return userFeign.getUserById(id);
    }

    //BlockException异常时调用
    public static User blockHandlerMethod(Integer id, BlockException e) {
        return new User(0, "接口被流控或者熔断了："+e, 0);
    }
}

1.4.4.外置类中定义

  1. 创建存放blockHandler方法的类
package com.bjpowernode.exception;

import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.bjpowernode.pojo.User;

public class BlockHandlerClass {

    //BlockException异常时调用
    public static User blockHandlerMethod(Integer id, BlockException e) {
        return new User(0, "接口被流控或者熔断了："+e, 0);
    }
}
  1. 使用外置类中定义的方法
@RestController
@RequestMapping(value = "/consumer")
public class ConsumerController {

    @Autowired
    private UserFeign userFeign;

    @RequestMapping(value = "/getUserById/{id}")
    @SentinelResource(value ="getUserById",
           blockHandler="blockHandlerMethod",blockHandlerClass = BlockHandlerClass.class)
    public User getUserById(@PathVariable Integer id) {
        int a = 6/0;
        return userFeign.getUserById(id);
    }

    //BlockException异常时调用
    //public static User blockHandlerMethod(Integer id, BlockException e) {
    //    return new User(0, "接口被流控或者熔断了："+e, 0);
    //}
}

1.4.5.测试

  1. 新增流控规则
    在这里插入图片描述

  2. 熔断后访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述

1.5.Sentinel全局异常处理

1.5.1.BlockExceptionHandler接口

​ 默认情况下，BlockExceptionHandler 有一个默认的 DefaultBlockExceptionHandler 实现类，返回 Block 字符串提示。这个类是默认处理异常阻塞的，代码如下：
在这里插入图片描述

我们可以实现该接口对返回数据进行重写, 从而符合我们的业务要求

1.5.2.BlockException接口

BlockException 是一个异常抽象基类，其有 5 个实现类，刚好对应 Sentinel 的 5 种流量控制异常，如下图所示：
在这里插入图片描述

1.5.3.实现BlockExceptionHandler

package com.bjpowernode.exception;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.alibaba.fastjson.JSON;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Component
public class GloabBlockExceptionHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
        response.setContentType("application/json;charset=utf-8");
        BaseResult data = null;
        if (e instanceof FlowException) {
            data = new BaseResult(-1, "限流异常...");
        } else if (e instanceof DegradeException) {
            data = new BaseResult(-2, "降级异常...");
        }else if (e instanceof ParamFlowException) {
            data = new BaseResult(-3, "参数限流异常...");
        }else if (e instanceof AuthorityException) {
            data = new BaseResult(-4, "授权异常...");
        }else if (e instanceof SystemBlockException) {
            data = new BaseResult(-5, "系统负载异常...");
        }
        response.getWriter().write(JSON.toJSONString(data));
    }
}

class BaseResult {
    private int status;
    private String msg;
    private Object data;

    public BaseResult() {
    }

    public BaseResult(int status, String msg) {
        this.status = status;
        this.msg = msg;
    }

    public BaseResult(int status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}

1.5.4.测试

  1. 新增流控规则
    在这里插入图片描述
  2. 高并发访问：http://127.0.0.1/consumer/getUserById/1
    在这里插入图片描述

1.6.Sentinel整合Feign

1.6.1.为什么整合Feign

​ 前文的熔断降级是对客户端（调用方）的保护，而我们的微服务远程调用都是基于Feign来完成的，因此我们可以将Feign与Sentinel整合，在Feign里面实现服务熔断。

1.6.2.sentinel_consumer

1.6.2.1.application.yml
feign:
  sentinel:
    enabled: true #开启Feign对Sentinel的支持

1.6.3.sentinel_feign

1.6.3.1.FallbackFactory
  • 创建异常处理逻辑
package com.bjpowernode.exception;

import com.bjpowernode.feign.UserFeign;
import com.bjpowernode.pojo.User;
import feign.hystrix.FallbackFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
 *一旦Feign远程调用服务失败，就会进入当前类同名方法，执行容错逻辑
 */
@Component
public class UserFeignFallback implements FallbackFactory<UserFeign> {

    @Override
    public UserFeign create(Throwable t) {
        return new UserFeign() {
            @Override
            public User getUserById(Integer id) {
                return new User(id,"feign调用失败："+t,0);
            }
        };
    }
}
1.6.3.2.feign
  • 为feign接口指定异常处理逻辑
package com.bjpowernode.feign;

import com.bjpowernode.exception.UserFeignFallback;
import com.bjpowernode.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
@FeignClient(value="sentinel-provider",fallbackFactory = UserFeignFallback.class)
@RequestMapping(value = "/provider")
public interface UserFeign {
    @RequestMapping(value = "/getUserById/{id}")
    public User getUserById(@PathVariable("id") Integer id);
}

1.6.4.sentinel

1.6.4.1.新增熔断规则

在这里插入图片描述

1.6.5.测试

  1. 关闭服务端
    在这里插入图片描述

  2. 熔断前访问：
    在这里插入图片描述

  3. 熔断后访问：
    在这里插入图片描述

1.7.Sentinel持久化

1.7.1.为什么要持久化?

​ 在上一篇，我们讲解了Sentinel的整合与使用，但是有个很明显的问题，就是一旦服务重启，当前配置的针对某个接口的规则就丢掉了，然后就需要重新再配一遍，这就很坑爹了，如果开发中需要配置的接口太多，这样岂不是让人疯掉。
在这里插入图片描述
​ 因此需要一个地方来保存dashboard中配置的规则，Sentinel提供了多种持久化的方案，可以集成redis、mysql、nacos等。
在这里插入图片描述

1.7.2.sentinel_consumer

1.7.2.1.pom.xml
<!--sentinel持久化启动器-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
</dependency>
1.7.2.2.application.yml
spring:
  application:
    name: sentinel-consumer
  cloud:
    sentinel:
      datasource:
        ds1:
          nacos:
            server-addr: ${spring.cloud.nacos.discovery.server-addr} #nacos连接地址
            namespace: sentinel
            groupId: SENTINEL_GROUP #nacos连接的分组名称
            dataId: ${spring.application.name}-flow-rules #读取配置文件的名称
            rule-type: flow #配置文件内容为flow
        ds2:
          nacos:
            server-addr: ${spring.cloud.nacos.discovery.server-addr} #nacos连接地址
            namespace: sentinel
            groupId: SENTINEL_GROUP #nacos连接的分组名称
            dataId: ${spring.application.name}-degrade-rules #读取配置文件的名称
            rule-type: degrade #配置文件内容为degrade

1.7.3.sentinel

1.7.3.1.改造Sentinel 源代码
  1. 下载

下载地址：https://github.com/alibaba/Sentinel/tree/master/sentinel-dashboard

  1. idea打开sentinel-dashboard工程
    在这里插入图片描述
    在这里插入图片描述
  2. 修改application.properties
nacos.address=192.168.209.129:8848
  1. 打jar包
    在这里插入图片描述
1.7.3.2.新增规则

在这里插入图片描述

1.7.4.nacos

1.7.4.1.新建命名空间

在这里插入图片描述

1.7.5.测试

  1. 浏览器访问：http://127.0.0.1/consumer/getUserById/1?origin=order
    在这里插入图片描述
  2. nacos持久化流控规则
    在这里插入图片描述

2.服务网关Gateway

2.1.为什么要使用Gateway?

​ 大家都都知道在微服务架构中，一个系统会被拆分为很多个微服务。那么作为客户端要如何去调用这么多的微服务呢？如果没有网关的存在，我们只能在客户端记录每个微服务的地址，然后分别去调用。这样的架构，会存在着诸多的问题：

  1. 客户端请求不同的微服务，就要维护不同的ip

  2. 客户端无法实现负载均衡

上面的这些问题可以借助API网关来解决：
在这里插入图片描述
在业界比较流行的网关，有下面这些：

  • Ngnix+lua

    使用nginx的反向代理和负载均衡可实现对api服务器的负载均衡及高可用 lua是一种脚本语言,可以来编写一些简单的逻辑,nginx支持lua脚本

  • Spring Cloud Gateway

    Spring公司为了替换Zuul而开发的网关服务，将在下面具体介绍。

注意：SpringCloud alibaba技术栈中并没有提供自己的网关，我们可以采用Spring Cloud Gateway来做网关。

2.2.Gateway介绍

2.2.1.Gateway是什么

​ Spring Cloud Gateway是Spring公司基于Spring 5.0，Spring Boot 2.0 和 WebFlux等技术开发的网关，目标是替代 Netflflix ZUUL，并且基于 Filter 链的方式提供了路由，过滤，和限流等功能。

组件RPS(request per second)
Spring Cloud GatewayRequests/sec: 32213.38
Zuul1XRequests/sec: 20800.13

上表为Spring Cloud Gateway与Zuul的性能对比，从结果可知，Spring Cloud Gateway的RPS是Zuul的1.6倍

2.2.3.Gateway执行流程

  1. Gateway Client向Gateway Server发送请求

  2. HandlerMapping负责路由查找，并根据路由断言判断路由是否可用

  3. WebHandler创建过滤器链并调用

  4. 请求会一次经过PreFilter–微服务–PostFilter的方法，最终返回响应给Gateway Client
    在这里插入图片描述

2.2.创建gateway工程

2.2.1.创建工程

在这里插入图片描述

2.2.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">
    <parent>
        <artifactId>springcloud_parent</artifactId>
        <groupId>com.bjpowernode</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>api_gateway</artifactId>

    <dependencies>
        <!-- nacos启动器 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- gateway的启动器 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
    </dependencies>
</project>

注意：不要添加spring-boot-starter-web启动器

        <!--servlet运行的服务器是tomcat-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

2.2.1.application.yml

spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.209.129:8848
server:
  port: 9527

2.2.1.App

package com.bjpowernode;

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

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

2.3.路由

2.3.1.通过断言条件路由

2.3.1.1.application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: sentinel-consumer #自定义的路由ID，保持唯一
          uri: http://localhost:80 # 请求要转发到的地址
          predicates: #断言
            - Path=/consumer/** #只有断言条件返回true(请求路径包含“/consumer”)时,才进行路由转发
2.3.1.2. 测试

1.开启服务和网关：

  • api_gateway
  • sentinel_consumer
  • sentinel_provider

2.浏览器访问：http://127.0.0.1:9527/consumer/getUserById/1
在这里插入图片描述

2.3.2.通过服务名路由

2.3.2.1.application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: sentinel-consumer #自定义的路由ID，保持唯一
          uri: lb://sentinel-consumer #lb代表从注册中心获取服务
          predicates: #断言
            - Path=/consumer/** #只有断言条件返回true(请求路径包含“/consumer”)时,才进行路由转发
2.3.2.2. 测试
  1. 重启网关：
  • api_gateway
  1. 浏览器访问：http://127.0.0.1:9527/sentinel-consumer/consumer/getUserById/1
    在这里插入图片描述

2.4.断言

2.4.1.内置断言工厂

Spring Cloud Gateway 的功能很强大，前面我们只是使用了 predicates 进行了简单的条件匹配，其实Spring Cloud Gataway 帮我们内置了很多 Predicates 功能。

可参考spring官网：https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gateway-request-predicates-factories

2.4.1.1.基于Datetime类型的断言工厂
  • 说明

此类型的断言根据时间做判断，主要有三个：

AfterRoutePredicateFactory：接收一个日期参数，判断请求日期是否晚于指定日期。

BeforeRoutePredicateFactory：接收一个日期参数，判断请求日期是否早于指定日期。

BetweenRoutePredicateFactory：接收两个日期参数，判断请求日期是否在指定时间段内。

  • 案例
- After=2022-04-09T17:20:54.957+08:00[Asia/Shanghai]
2.4.1.2.基于RemoteAddr的断言工厂
  • 说明

RemoteAddrRoutePredicateFactory：接收一个IP地址段，判断请求主机地址是否在地址段中。

  • 案例
- RemoteAddr=192.168.1.1/24
2.4.1.3.基于Cookie的断言工厂
  • 说明

CookieRoutePredicateFactory：接收两个参数，cookie名字和一个正则表达式。判断请求cookie是否具有给定名称且值与正则表达式匹配。

  • 案例
- Cookie=chocolate, ch.
2.4.1.4.基于Header的断言工厂
  • 说明

HeaderRoutePredicateFactory：接收两个参数，标题名称和正则表达式。 判断请求Header是否 具有给定名称且值与正则表达式匹配。

  • 案例
- Header=X-Request-Id, \d+
2.4.1.3.基于Host的断言工厂
  • 说明

HostRoutePredicateFactory：接收一个参数，主机名模式。判断请求的Host是否满足匹配规则。

  • 案例
- Host=**.testhost.org
2.4.1.5.基于Method请求方法的断言工厂
  • 说明

MethodRoutePredicateFactory：接收一个参数，判断请求类型是否跟指定的类型匹配。

  • 案例
- Method=GET
2.4.1.6.基于Path请求路径的断言工厂
  • 说明

PathRoutePredicateFactory：接收一个参数，判断请求的URI部分是否满足路径规则。

  • 案例
- Path=/foo/{segment}
2.4.1.7.基于Query请求参数的断言工厂
  • 说明

QueryRoutePredicateFactory ：接收两个参数，请求param和正则表达式， 判断请求参数是否具有给定名称且值与正则表达式匹配。

  • 案例
- Query=baz, ba.

2.4.2.自定义路由断言工厂

2.4.2.1.内置断言工厂的实现原理

我们来设定一个场景: 假设我们的应用仅仅让age>18的人来访问，在自定义断言工厂之前，我们先看内置断言工厂的实现原理，打开AfterRoutePredicateFactory这个内置断言工厂：
在这里插入图片描述

2.4.2.2.创建断言工厂
package com.bjpowernode.PredicateFactory;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * 自定义断言工厂
 * Config 是一个类  需要我们自己去定义
 */
@Component
public class AgeRoutePredicateFactory extends AbstractRoutePredicateFactory<AgeRoutePredicateFactory.Config> {

    public AgeRoutePredicateFactory() {
        super(AgeRoutePredicateFactory.Config.class);
    }

    //读取配置文件的中参数值 给他赋值到配置类中的属性上
    @Override
    public List<String> shortcutFieldOrder() {
        //这里的顺序要跟配置文件中的参数顺序一致
        return Arrays.asList("minAge", "maxAge");
    }

    //断言逻辑
    @Override
    public Predicate<ServerWebExchange> apply(AgeRoutePredicateFactory.Config config) {
        return new Predicate<ServerWebExchange>() {
            @Override
            public boolean test(ServerWebExchange serverWebExchange) {
                //1 接收前台传入的age参数
                String ageStr = 
                    serverWebExchange.getRequest().getQueryParams().getFirst("age");
                //2 先判断是否为空
                if (StringUtils.isNotEmpty(ageStr)) {
                    //3 如果不为空,再进行路由逻辑判断
                    int age = Integer.parseInt(ageStr);
                    if (age < config.getMaxAge() && age > config.getMinAge()) {
                        return true;
                    } else {
                        return false;
                    }
                }
                return false;
            }
        };
    }

    //自定义一个配置类, 用于接收配置文件中的参数
    @Data
    @NoArgsConstructor
    public static class Config {
        private int minAge;//18
        private int maxAge;//60
    }
}
2.4.2.3.配置断言
spring:
  cloud:
    gateway:
      routes:
        - id: sentinel-consumer
          uri: lb://sentinel-consumer
          predicates:
            - Path=/consumer/**
            - Age=18,60 #配置断言必须使用断言工厂类名的前缀
2.4.2.4.测试
  1. 浏览器访问：http://127.0.0.1:9527/consumer/getUserById/1?age=17
    在这里插入图片描述
  2. 浏览器访问：http://127.0.0.1:9527/consumer/getUserById/1?age=19
    在这里插入图片描述

2.5.过滤

Spring Cloud Gateway提供了过滤器的功能，可以对进入网关的请求和响应做处理：
在这里插入图片描述
Spring Cloud Gateway 的 Filter 从作用范围可分为另外两种GatewayFilter 与 GlobalFilter。

  • GatewayFilter：应用到单个路由或者一个分组的路由上。

  • GlobalFilter：应用到所有的路由上。

2.5.1.内置过滤器工厂

Spring Cloud Gateway中通过GatewayFilter的形式内置了很多不同类型的局部过滤器，可参考spring官网：https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gatewayfilter-factories

过滤器工厂作用
AddRequestHeader给当前请求添加一个请求头
AddRequestParameter为原始请求添加请求参数
AddResponseHeader给响应结果中添加一个响应头
DedupeResponseHeader去掉重复请求头
Spring Cloud CircuitBreaker断路器
FallbackHeaders添加熔断后的异常信息到请求头
MapRequestHeader将上游请求头的值赋值到下游请求头
PrefixPath匹配的路由添加前缀
PreserveHostHeader保留原请求头
RequestRateLimiter限制请求的流量
RedirectTo重定向
RemoveRequestHeader移除请求中的一个请求头
RemoveResponseHeader从响应结果中移除有一个响应头
RemoveRequestParameter移除请求参数
RewritePath重写路径
RewriteLocationResponseHeader重写响应头中Location的值
RewriteResponseHeader重写响应头
SaveSession向下游转发请求前前置执行WebSession::save的操作
SecureHeaders禁用默认值
SetPath设置路径
SetRequestHeader重置请求头
SetResponseHeader修改响应头
SetStatus修改响应的状态码
StripPrefix对指定数量的路径前缀进行去除
Retry重试
RequestSize请求大小大于限制时，限制请求到达下游服务
SetRequestHostHeader重置请求头值
Modify a Request Body修改请求体内容
Modify a Response Body修改响应体内容
Relay将 OAuth2 访问令牌向下游转发到它所代理的服务
CacheRequestBody在请求正文发送到下游之前缓存请求正文并从 exchagne 属性获取正文

2.5.2.自定义过滤器工厂

需求：记录调用远程服务所需要的时间

2.5.2.1.创建过滤器工厂
package com.bjpowernode.FilterFactory;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.util.Arrays;
import java.util.Date;
import java.util.List;

@Component
public class LogGatewayFilterFactory
        extends AbstractGatewayFilterFactory<LogGatewayFilterFactory.Config> {

    public LogGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, 
                                     GatewayFilterChain chain) {
                if (config.paramValue) {
                    long beginTime = System.currentTimeMillis();
                    return chain.filter(exchange).then(Mono.fromRunnable(new Runnable() {
                        @Override
                        public void run() {
                            long endTime = System.currentTimeMillis();
                            System.out.println("time of call service ：" + 
                                               			(endTime - beginTime));
                        }
                    }));
                }
                return chain.filter(exchange);
            }
        };
    }

    //读取配置文件中的参数 赋值到配置类中
    @Override
    public List<String> shortcutFieldOrder() {
        //这里的顺序要跟配置文件中的参数顺序一致
        return Arrays.asList("paramValue");
    }

    //自定义一个配置类, 用于接收配置文件中的参数
    @Data
    @NoArgsConstructor
    public static class Config {
        private boolean paramValue;
    }
}
2.5.2.2.配置过滤器
spring:
  cloud:
      routes:
        - id: sentinel-consumer
          uri: lb://sentinel-consumer
          predicates:
            - Path=/consumer/**
          filters: #过滤
            - Log=true
2.5.2.3.测试
  1. 浏览器访问：http://127.0.0.1:9527/consumer/getUserById/1
    在这里插入图片描述

2.5.3.自定义全局过滤器

  • 需求：

在网关过滤器中通过Token 判断用户是否登录

  • 全局过滤器（GlobalFilter）：

作用于所有路由，Spring Cloud Gateway 定义了Global Filter接口，用户可以自定义实现自己的Global Filter。通过全局过滤器可以实现对权限的统一校验，安全性验证等功能，并且全局过滤器也是程序员使用比较多的过滤器。Spring Cloud Gateway内部也是通过一系列的内置全局过滤器对整个路由转发进行处理如下：
在这里插入图片描述

2.5.2.1.创建过滤器

在服务网关中定义过滤器只需要实现 GlobalFilter, Ordered接口就可对请求进行拦截与过滤。

package com.bjpowernode.FilterFactory;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;

@Component
public class LoginFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        String token = request.getQueryParams().getFirst("token");
        if (token == null) {
            BaseResult data = new BaseResult(401, "未登录");
            return response(response,data);
        }
        //放行
        return chain.filter(exchange);
    }

    private Mono<Void> response(ServerHttpResponse response, BaseResult data) {
        String jsonData = null;
        try {
            jsonData = new ObjectMapper().writeValueAsString(data);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        DataBuffer buffer = 
            response.bufferFactory().wrap(jsonData.getBytes(StandardCharsets.UTF_8));
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }

    /**
     * 过滤器的执行顺序：通过整数表示顺序，数值越小，优先级越高
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
}
class BaseResult {
    private int status;
    private String msg;
    private Object data;

    public BaseResult() {
    }

    public BaseResult(int status, String msg) {
        this.status = status;
        this.msg = msg;
    }

    public BaseResult(int status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}
2.5.2.2.测试
  1. 不加token：http://127.0.0.1:9527/gateway/consumer/getUserById?id=1&nam=zs
    在这里插入图片描述
  2. 加token：http://127.0.0.1:9527/consumer/getUserById/1?token=123
    在这里插入图片描述

2.5.限流

网关是所有请求的公共入口，所以可以在网关进行限流，而且限流的方式也很多，我们本次采用前 面学过的Sentinel组件来实现网关的限流。

2.5.1.api_gateway

2.5.1.1.pom.xml
        <!--sentinel的启动器-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <!--spring cloud gateway整合sentinel的启动器-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
        </dependency>
2.5.1.2.application.yml
spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8080 #指定sentinel的地址
2.5.1.3.自定义异常处理
package com.bjpowernode.exception;

import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.alibaba.fastjson.JSON;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class GatewayConfig {
 
    @PostConstruct
    public void init() {
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange exchange,
                                                      				Throwable t) {
                // 自定义异常信息
                Map map = new HashMap<>();
                map.put("status", 200);
                map.put("msg", "接口被限流了");
                return ServerResponse.status(HttpStatus.OK)
                        .contentType(MediaType.APPLICATION_JSON)
                        .body(BodyInserters.fromValue(map));
            }
        };
        //自定义异常处理
        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }
}

2.5.2.测试

  1. 新增流控规则
    在这里插入图片描述
  2. 高并发访问：http://127.0.0.1:9527/consumer/getUserById/1
    在这里插入图片描述
YiXuCodeMonkey
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
nacos、gateway、sentinel相关的demo源码实现，初学的同学可以参考
09-27
在IT行业中，Nacos、Gateway和Sentinel是三个非常重要的微服务组件，它们分别在服务发现、API路由管理和流量控制方面发挥着关键作用。这个压缩包文件提供的"springnacos"目录下的源码示例，为初学者提供了一个了解和...
springcloudalibaba微服务dubbo+sentinel+gateway+zookeeper+nacos的demo
03-10
3. **Spring Cloud Gateway**: Spring Cloud Gateway作为Spring Cloud生态的新一代API网关，它提供了统一的请求处理入口，支持路由转发、过滤器链路、动态路由等功能。在微服务架构中，Gateway可以作为前端请求的...
微服务框架 SpringCloud微服务架构 微服务面试篇 54 微服务篇 54.8 Sentinel的限流与Gateway的限流有什么差别？
谢谢你们的关注
12-20 1696
微服务框架 SpringCloud微服务架构 微服务面试篇 54 微服务篇 54.8 Sentinel的限流与Gateway的限流有什么差别？
使用Sentinel实现gateway网关及服务接口限流
热门推荐
骏马逸动，心随你动的博客
01-25 1万+
1、Sentinel 简介 1.1 Sentinel是什么： 随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式服务架构的流量控制组件，主要以流量为切入点，从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的稳定性。 1.2 Sentinel 的主要工作机制： 对主流框架提供适配或者显示的 API，来定义需要保护的资源，并提供设施对资源进行实时统计和调用链路分析。 根据预设的规则，结合对资源的实时统计信息，对流量进行控制。同时，S
小白学习gateway集成sentinel
BASK2312的博客
04-24 1247
Sentinel支持对Spring Cloud Gateway、Zuul等主流的API Gataway 进行限流，作用在网关的流控称之为网关流控，其实现原理请点击网关限流进入官方Wiki查看。这里只把原理图从官方文档摘出来，需多关注图中提到的模块名和几个类名，因为都是核心级别的存在。规则类型gw-flow和为网关流控规则，具体类型请查看规则类型枚举RuleTypejava复制代码。
Spring Cloud Alibaba 第二篇（Sentinel、Sleuth、Gateway组件）
小yu别错过的博客
11-22 2514
Spring Cloud Gateway 是 Spring 官方基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等技术开发的网关，Spring Cloud Gateway 旨在为微服务架构提供一种简单而有效的统一的 API 路由管理方式。Spring Cloud Gateway 作为 Spring Cloud 生态系中的网关，目标是替代 Netflix ZUUL。
spring cloud alibaba-gateway使用以及整合sentinel
weixin_38612401的博客
08-05 2412
gateway网关的基本介绍，gateway的使用以及整合sentinel进行网关层限流
网关流控实现原理 (gateway集成Sentinel )
m0_45406092的博客
09-19 3048
网关流控实现原理 当通过 GatewayRuleManager 加载网关流控规则（GatewayFlowRule）时，无论是否针对请求属性进行限流，Sentinel 底层都会将网关流控规则转化为热点参数规则（ParamFlowRule），存储在 GatewayRuleManager 中，与正常的热点参数规则相隔离。转换时 Sentinel 会根据请求属性配置，为网关流控规则设置参数索引（idx），并同步到生成的热点参数规则中。 外部请求进入 API Gateway 时会经过 Sentinel 实现的 fil
spring-cloud-gateway降级的实现
08-19
Spring Cloud Gateway 提供了降级机制，通过与 Hystrix 的集成，实现服务降级。 降级机制的必要性 在微服务架构中，如果某个服务不可用或响应时间过长，可能会导致整个系统的崩溃。例如，如果某个服务需要 2 秒钟...
springcloud+nacos+gateway
最新发布
06-24
SpringCloud Gateway作为Spring Cloud生态中的新一代API网关，其主要职责是路由请求到不同的微服务，并提供过滤器功能进行请求预处理和响应后处理。它的核心特性包括： 1. **路由规则**：可以定义路由规则，将特定...
Spring Cloud Alibaba 2.1.0.RELEASE 整合 Nocas Feign Webflux Gateway Sentinel等组件代码
09-18
整合以上组件，开发者可以构建出一套完整的微服务架构，实现服务治理、服务发现、流量控制、API管理和容错保护。具体整合步骤通常包括以下几个部分： - 配置Nacos服务器，启动并注册服务提供者和消费者。 - 在服务...
Gateway配合sentinel自定义限流_使用Sentinel实现gateway网关及服务接口限流
weixin_39736934的博客
11-22 932
点击关注“阿甘正专”，设为星标奇迹每天都在发生，等你而来1、Sentinel 简介1.1 Sentinel是什么：随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式服务架构的流量控制组件，主要以流量为切入点，从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的稳定性。1.2 Sentinel 的主要工作机制：对主流框架提...
Spring Cloud Gateway整合Sentinel
c_study__c的博客
01-04 2740
Spring Cloud Gateway整合Sentinel实现网关限流熔断
从零开始搭建高负载java架构(06)：gateway网关节点(sentinel篇)
lyz2015lyz的博客
05-16 282
1. 下载sentinel 1.8.6最新版本2. 启动sentinel控制后台其中，6003是控制后台的端口，启动后，通过网页访问：http://127.0.0.1:6003默认的登录名和密码：sentinel。
【微服务】Sentinel 适配网关进行流量控制
qq_57756904的博客
11-09 2548
外部请求进入 API Gateway 时会经过 Sentinel 实现的 filter，其中会依次进行路由/API 分组匹配、请求属性解析和参数组装。Sentinel 会根据配置的网关流控规则来解析请求属性，并依照参数索引顺序组装参数数组，最终传入SphU.entry(res, args)中。Sentinel API Gateway Adapter Common 模块向 Slot Chain 中添加了一个GatewayFlowSlot，专门用来做网关规则的检查。......
微服务系列：Spring Cloud Alibaba 之 Sentinel 详细入门
zhang33565417的博客
01-31 1494
Sentinel 是阿里中间件团队开源的，面向分布式服务架构的轻量级高可用流量控制组件，主要以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来帮助用户保护服务的稳定性。
springcloud Alibaba中gateway和sentinel联合使用
A_cup的博客
01-15 2215
看到这个文章相信你有一定的sentinel和gateway基础了吧。官网的gateway和sentinel联合使用有些过时了，于是有了这个哈哈，给你看看官网的：才sentinel1.6，现在都几了啊，所以有些过时。下面开始讲解：首先我们总的回顾一下，sentinel就是需要运行一个jar包，开启dashbord页面，来显示流控信息。然后运行我们的程序，调用需要的接口，该接口就会在dashbord上面显示了对吧。
Sentinel dashboard无法查询到应用的限流配置问题以及解决
寂夜了无痕的博客
08-25 1604
Sentinel dashboard无法查询到应用的限流配置问题以及解决
nacos openfeign gateway sentinel
08-30
综上所述，Nacos提供了服务发现和配置管理，OpenFeign简化了微服务间的调用，Gateway实现了高性能的API网关，Sentinel用于流量控制和治理。这些工具的结合使用可以帮助我们构建可靠、稳定的微服务架构，并提升系统的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值