【SpringCloud】十一、Spring Cloud Gateway集成Sentinel

ゝ一世哀愁。 2023-10-09 14:51 60阅读 0赞

#### Spring Cloud Gateway集成Sentinel ####

*  一、Spring Cloud Gateway集成Sentinel
 *   *  1、添加依赖；
     *  2、添加sentinel控制台配置；
     *  3、在spring容器中配置一个Sentinel的全局过滤器；
     *  4、可以进行测试；
 *  二、Spring Cloud Gateway集成Sentinel规则持久化
 *   *  1、规则持久化到文件的步骤：
     *   *  （1）、配置依赖；
         *  （2）配置文件；
         *  （3）写代码；
     *  2、规则持久化到Nacos的步骤；
     *   *  1、添加sentinel-datasource-nacos依赖；
         *  2、application.properties配置持久化数据源；
         *  3、在nacos配置中心配置流控规则；

## 一、Spring Cloud Gateway集成Sentinel ##

网关集成Sentinel是为了流控熔断降级，具体集成整合步骤如下：  
Sentinel的可以看前面的文章 [【SpringCloud】八、SpringCloudAlibaba-流量防卫兵Sentinel][SpringCloud_SpringCloudAlibaba-_Sentinel]

### 1、添加依赖； ###

<dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
        <version>1.7.2</version>
    </dependency>

### 2、添加sentinel控制台配置； ###

#sentinel dashboard管理后台
    spring：
      cloud：
        sentinel:
          eager: true
          transport:
            dashboard: 127.0.0.1:8080

### 3、在spring容器中配置一个Sentinel的全局过滤器； ###

@Bean
    @Order(-1)
    public GlobalFilter sentinelGatewayFilter() {
        
        return new SentinelGatewayFilter();
    }

### 4、可以进行测试； ###

## 二、Spring Cloud Gateway集成Sentinel规则持久化 ##

### 1、规则持久化到文件的步骤： ###

#### （1）、配置依赖； ####

<dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-datasource-extension</artifactId>
    </dependency>

#### （2）配置文件； ####

暂时不需要配置；

#### （3）写代码； ####

import com.alibaba.csp.sentinel.command.handler.ModifyParamFlowRulesCommandHandler;
    import com.alibaba.csp.sentinel.datasource.*;
    import com.alibaba.csp.sentinel.init.InitFunc;
    import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
    import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager;
    import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
    import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
    import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
    import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
    import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
    import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
    import com.alibaba.csp.sentinel.slots.system.SystemRule;
    import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
    import com.alibaba.csp.sentinel.transport.util.WritableDataSourceRegistry;
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.TypeReference;
    
    import java.io.File;
    import java.io.IOException;
    import java.util.List;
    
    /**
     * 规则持久化
     */
    public class FileDataSourceInit implements InitFunc {
        
    
        @Override
        public void init() throws Exception {
        
            //可以根据需要指定规则文件的位置
            String ruleDir = System.getProperty("user.home") + "/gateway/rules";
    
            String flowRulePath = ruleDir + "/flow-rule.json";
            String degradeRulePath = ruleDir + "/degrade-rule.json";
            String paramFlowRulePath = ruleDir + "/param-flow-rule.json";
            String systemRulePath = ruleDir + "/system-rule.json";
            String authorityRulePath = ruleDir + "/authority-rule.json";
    
            this.mkdirIfNotExits(ruleDir);
    
            this.createFileIfNotExits(flowRulePath);
            this.createFileIfNotExits(degradeRulePath);
            this.createFileIfNotExits(paramFlowRulePath);
            this.createFileIfNotExits(systemRulePath);
            this.createFileIfNotExits(authorityRulePath);
    
            // 流控规则：可读数据源
            ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>(
                    flowRulePath,
                    flowRuleListParser
            );
            // 将可读数据源注册至FlowRuleManager
            // 这样当规则文件发生变化时，就会更新规则到内存
            FlowRuleManager.register2Property(flowRuleRDS.getProperty());
            // 流控规则：可写数据源
            WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
                    flowRulePath,
                    this::encodeJson
            );
            // 将可写数据源注册至transport模块的WritableDataSourceRegistry中
            // 这样收到控制台推送的规则时，Sentinel会先更新到内存，然后将规则写入到文件中
            WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);
    
    
            // 降级规则：可读数据源
            ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(
                    degradeRulePath,
                    degradeRuleListParser
            );
            DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());
            // 降级规则：可写数据源
            WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(
                    degradeRulePath,
                    this::encodeJson
            );
            WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);
    
    
            // 热点参数规则：可读数据源
            ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
                    paramFlowRulePath,
                    paramFlowRuleListParser
            );
            ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());
            // 热点参数规则：可写数据源
            WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
                    paramFlowRulePath,
                    this::encodeJson
            );
            ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    
    
            // 系统规则：可读数据源
            ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
                    systemRulePath,
                    systemRuleListParser
            );
            SystemRuleManager.register2Property(systemRuleRDS.getProperty());
            // 系统规则：可写数据源
            WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(
                    systemRulePath,
                    this::encodeJson
            );
            WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);
    
    
            // 授权规则：可读数据源
            ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(
                    authorityRulePath,
                    authorityRuleListParser
            );
            AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());
            // 授权规则：可写数据源
            WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(
                    authorityRulePath,
                    this::encodeJson
            );
            WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);
        }
    
    
        private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(
                source,
                new TypeReference<List<FlowRule>>() {
        
                }
        );
    
        private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(
                source,
                new TypeReference<List<DegradeRule>>() {
        
                }
        );
    
        private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(
                source,
                new TypeReference<List<SystemRule>>() {
        
                }
        );
    
        private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(
                source,
                new TypeReference<List<AuthorityRule>>() {
        
                }
        );
    
        private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(
                source,
                new TypeReference<List<ParamFlowRule>>() {
        
                }
        );
    
        private void mkdirIfNotExits(String filePath) throws IOException {
        
            File file = new File(filePath);
            if (!file.exists()) {
        
                file.mkdirs();
            }
        }
    
        private void createFileIfNotExits(String filePath) throws IOException {
        
            File file = new File(filePath);
            if (!file.exists()) {
        
                file.createNewFile();
            }
        }
    
        private <T> String encodeJson(T t) {
        
            return JSON.toJSONString(t);
        }
    }

（4）配置SPI；  
resources\\META-INF\\services\\com.alibaba.csp.sentinel.init.InitFunc  
![在这里插入图片描述][44ea2c72d20948909f48efb5a0318fc2.png]

### 2、规则持久化到Nacos的步骤； ###

#### 1、添加sentinel-datasource-nacos依赖； ####

<dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-datasource-nacos</artifactId>
    </dependency>

#### 2、application.properties配置持久化数据源； ####

#配置sentinel规则持久化到nacos
    datasource:
      ncs1:
        nacos:
          server-addr: 192.168.172.128:80
          data-id: ${
        spring.application.name}.json
          group-id: DEFAULT_GROUP
          rule-type: flow
          data-type: json
    
    degrade:
       nacos:
         server-addr: 192.168.172.128:80
         data-id: ${
        spring.application.name}-degrade.json
         group-id: DEFAULT_GROUP
         rule-type: degrade
         data-type: json

#### 3、在nacos配置中心配置流控规则； ####

[
      {
        
        "resource": "abc",
        "controlBehavior": 0,
        "count": 1.0,
        "grade": 1,
        "limitApp": "default",
        "strategy": 0
      }
    ]

[SpringCloud_SpringCloudAlibaba-_Sentinel]: https://blog.csdn.net/weixin_43333483/article/details/127097264?spm=1001.2014.3001.5501
[44ea2c72d20948909f48efb5a0318fc2.png]: https://img-blog.csdnimg.cn/44ea2c72d20948909f48efb5a0318fc2.png