SpringCloudGateWay结合Sentinel针对部分接口url限流

 看了好多文章没有针对于指定url进行限流 自己实践了一下。

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-cloud.version>Hoxton.SR11</spring-cloud.version>
        <java.version>1.8</java.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>
        </dependencies>
    </dependencyManagement>

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



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

package com.main.fintech.config;

import com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayParamFlowItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
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.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.result.view.ViewResolver;

import javax.annotation.PostConstruct;
import java.util.*;

import static com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants.PARAM_PARSE_STRATEGY_CLIENT_IP;
import static com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants.RESOURCE_MODE_CUSTOM_API_NAME;


/**
 * @author whc
 * @version v1.0
 * @date 2021/9/13
 * @Description gateway限流配置 基于sentinel自定义api接口方式
 */
@Configuration
public class GatewayLimitConfiguration {

    private final List<ViewResolver> viewResolvers;
    private final ServerCodecConfigurer serverCodecConfigurer;

    public GatewayLimitConfiguration(ObjectProvider<List<ViewResolver>> viewResolverProvider,
                                     ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers = viewResolverProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    }

    /**
     * 配置限流的异常处理器
     *
     * @return SentinelGatewayBlockExceptionHandler
     */
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        // Register the block exception handler for Spring Cloud Gateway.
        return new SentinelGatewayBlockExceptionHandler(this.viewResolvers, this.serverCodecConfigurer);
    }

    /**
     * 配置限流过滤器
     *
     * @return SentinelGatewayFilter
     */
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public GlobalFilter sentinelGlobalFilter() {
        return new SentinelGatewayFilter();
    }


    /**
     * 初始化限流策略
     */
    @PostConstruct
    public void doInit() {
        initGatewayRules();
        initCustomizedApis();
    }


    /**
     * 全局限流配置器
     * resource:资源名称 可以为配置文件中的routesId 也可以为自定义Api分组名称 这里为Api分组名称
     * setResourceMode:模式为routesId->RESOURCE_MODE_ROUTE_ID还是为Api分组名称->RESOURCE_MODE_CUSTOM_API_NAME 配合resource一起使用 这里为Api分组名称
     * setCount       : 限流阈值 这里设置为15 即每秒可请求15次
     * setIntervalSec: 统计时间窗口/秒
     * setParamItem:参数限流配置,若不提供，则代表不针对参数进行限流，该网关规则将会被转换成普通流控规则。这里配置了IP模式
     * 最终限流结果为:每个IP每秒可访问15次
     *
     * @author whc
     */
    public void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();
        rules.add(new GatewayFlowRule("ocrLimit")
                .setResourceMode(RESOURCE_MODE_CUSTOM_API_NAME)
                .setCount(15)
                .setIntervalSec(1)
                .setParamItem(new GatewayParamFlowItem().setParseStrategy(PARAM_PARSE_STRATEGY_CLIENT_IP)));
        GatewayRuleManager.loadRules(rules);
    }

    /**
     * 自定义限流错误返回
     */
    @PostConstruct
    public void initBlockHandler() {
        BlockRequestHandler blockHandler = (serverWebExchange, throwable) -> {
            Map<String, String> map = new HashMap<>(8);
            map.put("code", "E88888");
            map.put("message", "操作频繁");
            return ServerResponse.status(HttpStatus.OK)
                    .contentType(MediaType.APPLICATION_JSON)
                    .body(BodyInserters.fromValue(map));
        };
        GatewayCallbackManager.setBlockHandler(blockHandler);
    }


    /**
     * 自定义Api策略
     * apiName:自定义Api名称
     * setPattern:限流策略 这里是针对my/ocr/**所有的请求进行限流
     * setMatchStrategy:匹配规则 这里是URL_MATCH_STRATEGY_PREFIX 前缀
     * @author whc
     */
    private void initCustomizedApis() {
        Set<ApiDefinition> definitions = new HashSet<>();
        ApiDefinition api1 = new ApiDefinition("ocrLimit")
                .setPredicateItems(new HashSet<ApiPredicateItem>() {
   
   {
                    add(new ApiPathPredicateItem().setPattern("/my/ocr/**")
                            .setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
                }});
        definitions.add(api1);
        GatewayApiDefinitionManager.loadApiDefinitions(definitions);
    }
}