投稿
  1. 首页
  2. java

sentinel-基于springcloud gateway

code • 2022-4-28 • java • 阅读 64

sentinel-基于springcloud gateway,第1张

提示：本整合方案基于springcloud alibaba的毕业版本推荐，即：

        springboot version:2.6.3

        springcloud version:2021.0.01

        springcloud alibaba version: 2021.0.1.0

目录

前言

二、使用步骤

1.父pom内容

2.gateway工程pom

3.相关代码 

        3.1 gateway yml配置文件

        3.2 请求交易码判断自定义断言

        3.3 请求灰度字段判断自定义断言

        3.4 请求验签过滤器

        3.5 响应加签过滤器方法

        3.6 sentinel BlockRequest实现类

总结

前言

基于springcloud gateway和sentinel整合的配置，记录为主。

简陋的画了一个时序图

一、sentinel是什么

官方解释：面向分布式服务架构的高可用流量控制组件

二、使用步骤

请注意：以下配置由于部分原因不能展示编译、打包等构建相关的插件配置，如果您需要参考请自行按情况添加，此文档只记录和标题相关的配置项。

1.父pom内容 


    4.0.0

    com.hx
    qp-demo
    1.0-SNAPSHOT

    pom

    
        org.springframework.boot
        spring-boot-starter-parent
        2.6.3
         
    

    
        2021.0.1
        2021.0.1.0
    

    
        
            
                org.springframework.cloud
                spring-cloud-dependencies
                ${spring-cloud.version}
                pom
                import
            
            
                com.alibaba.cloud
                spring-cloud-alibaba-dependencies
                ${spring-cloud-alibaba.version}
                pom
                import
2.gateway工程pom 


    
        qp-demo
        com.hx
        1.0-SNAPSHOT
    
    4.0.0
    网关

    qp-gateway


    
        
            org.springframework.cloud
            spring-cloud-starter-bootstrap
        
        
            org.springframework.cloud
            spring-cloud-starter-gateway
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-config
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery
        
        
            org.springframework.cloud
            spring-cloud-starter-loadbalancer
        
        




        
        
            com.alibaba.cloud
            spring-cloud-alibaba-sentinel-gateway
3.相关代码          3.1 gateway yml配置文件 
spring:
  application:
    name: qp-gateway
  cloud:
    #sentinel配置
    sentinel:
      #sentinel控制台配置，本地端口不配置默认从8719开始尝试监听
      transport:
        dashboard: 127.0.0.1:8080
      #nacos持久化配置，一定要配置用户权限配置，不然无法生效，（此处还未进行验证）
      datasource:
        ds:
          nacos:
            server-addr: 128.0.0.1:8848
            data-id: qp-gateway-flow
            group-id: qp
            data-type: json
            #flow-限流，degrade-熔断
            rule-type: flow
            username: nacos
            password: nacos
    gateway:
      #全局过滤器，此处做了交易请求的验签和签名
      default-filters:
      #验证签名
      - NuccMsg=true
      #签名
      - name: ModifyResponseBody
        args:
          rewriteFunction: '#{@nuccSign}'
          outClass: java.lang.String
          inClass: java.lang.String
      routes:
      #灰度支付交易网关
      - id: payment-gary
        order: 1
        uri: lb://qp-server-payment-gary
        predicates:
        #交易路由自定义断言，按请求中交易码字段进行判断
        - Path=/main/**
        - name: Nucc
          args: 
            msgTps: ["tradecode01","tradecode02","test"]
        #灰度发布自定义断言，按请求中某字段的正则表达式进行判断
        - NuccGary=SgnNo, ^110120119.*
        filters:
        #请求地址重写
        - RewritePath=/main/?(?.*), /payment/$\{segment}
      #正常支付交易网关
      - id: payment
        order: 2
        uri: lb://qp-server-payment
        predicates:
        - Path=/main/**
        - name: Nucc
          args: 
            msgTps: ["tradecode01","tradecode02","test"]
        filters:
        - RewritePath=/main/?(?.*), /payment/$\{segment}
        
nacos:
  discovery:
    server-addr: 127.0.0.1:8848

config:
  fileName: dev


server:
  port: 8088
        3.2 请求交易码判断自定义断言 
import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.springframework.cloud.gateway.handler.AsyncPredicate;
import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.HandlerStrategies;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

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

/**
 * 某机构XML接口规范实现的路由断言工厂
 */
@Component
@Slf4j
public class NuccRoutePredicateFactory extends AbstractRoutePredicateFactory {

    private final List> messageReaders;

    public NuccRoutePredicateFactory() {
        super(NuccRoutePredicateFactory.Config.class);
        this.messageReaders = HandlerStrategies.withDefaults().messageReaders();
    }

    public NuccRoutePredicateFactory(List> messageReaders) {
        super(NuccRoutePredicateFactory.Config.class);
        this.messageReaders = messageReaders;
    }

    @Override
    public AsyncPredicate applyAsync(NuccRoutePredicateFactory.Config config) {
        return new AsyncPredicate() {
            @Override
            public Publisher apply(ServerWebExchange exchange) {
                Object cachedBody = exchange.getAttribute("bodyCache");
                if (cachedBody != null) {
                    return Mono.just(checkMspTp(cachedBody, config));
                } else {
                    log.debug("解析....");
                    return ServerWebExchangeUtils.cacheRequestBodyAndRequest(exchange,
                            (serverHttpRequest) -> ServerRequest
                                    .create(exchange.mutate().request(serverHttpRequest).build(), messageReaders)
                                    .bodyToMono(String.class).doOnNext(objectValue -> exchange.getAttributes()
                                            .put(GatewayCons.CACHE_REQUEST_BODY_OBJECT_KEY, objectValue))
                                    .map(objectValue -> checkMspTp(objectValue, config)));
                }
            }

            @Override
            public Object getConfig() {
                return config;
            }
        };
    }

    /**
     * 校验报文编号
     *
     * @param requestBody 请求body正文
     * @param config      配置
     * @return
     */
    private boolean checkMspTp(Object requestBody, NuccRoutePredicateFactory.Config config) {
        String content = String.valueOf(requestBody);
        if (content == null) {
            log.warn("没有获取到请求body，请核实");
            return false;
        }
        if (!content.contains("") + 7);// xml报文域
        String sign = content.substring(content.indexOf("{S:") + 3, content.lastIndexOf("}"));// 签名域
        String msgTp = content.substring(content.indexOf(""));// 报文编号
        return Arrays.asList(config.msgTps).contains(msgTp);
    }

    @Override
    public Predicate apply(NuccRoutePredicateFactory.Config config) {
        throw new UnsupportedOperationException("NuccRoutePredicateFactory is only async.");
    }

    public static class Config {
        String[] msgTps; //报文编号

        public String[] getMsgTps() {
            return msgTps;
        }

        public NuccRoutePredicateFactory.Config setMsgTps(String[] msgTps) {
            this.msgTps = msgTps;
            return this;
        }
    }

}
        3.3 请求灰度字段判断自定义断言 
package com.yld.gateway.predicate;

import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.springframework.cloud.gateway.handler.AsyncPredicate;
import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.web.reactive.function.server.HandlerStrategies;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

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

/**
 * 灰度路由断言工厂
 */
@Component
@Slf4j
public class NuccGaryRoutePredicateFactory extends AbstractRoutePredicateFactory {

    private final List> messageReaders;

    @Override
    public List shortcutFieldOrder() {
        return Arrays.asList("xmlTag", "regexp");
    }

    public NuccGaryRoutePredicateFactory() {
        super(NuccGaryRoutePredicateFactory.Config.class);
        this.messageReaders = HandlerStrategies.withDefaults().messageReaders();
    }

    public NuccGaryRoutePredicateFactory(List> messageReaders) {
        super(NuccGaryRoutePredicateFactory.Config.class);
        this.messageReaders = messageReaders;
    }

    @Override
    public AsyncPredicate applyAsync(NuccGaryRoutePredicateFactory.Config config) {
        return new AsyncPredicate() {
            @Override
            public Publisher apply(ServerWebExchange exchange) {
                Object cachedBody = exchange.getAttribute("bodyCache");
                if (cachedBody != null) {
                    return Mono.just(checkGaryTag(cachedBody, config));
                } else {
                    log.debug("解析....");
                    return ServerWebExchangeUtils.cacheRequestBodyAndRequest(exchange,
                            (serverHttpRequest) -> ServerRequest
                                    .create(exchange.mutate().request(serverHttpRequest).build(), messageReaders)
                                    .bodyToMono(String.class).doOnNext(objectValue -> exchange.getAttributes()
                                            .put(GatewayCons.CACHE_REQUEST_BODY_OBJECT_KEY, objectValue))
                                    .map(objectValue -> checkGaryTag(objectValue, config)));
                }
            }

            @Override
            public Object getConfig() {
                return config;
            }
        };
    }

    /**
     * 判断是否符合灰度断言校验
     * @param requestBody
     * @param config
     * @return
     */
    private boolean checkGaryTag(Object requestBody, NuccGaryRoutePredicateFactory.Config config) {
        String content = String.valueOf(requestBody);
        if (content == null) {
            log.warn("没有获取到请求body，请核实");
            return false;
        }
        if (!content.contains("", config.xmlTag); //格式化标签开始
            String tagEnd = String.format("", config.xmlTag); //格式化标签结束
            String xmlTagValue = content.substring(content.indexOf(tag) + tag.length(), content.indexOf(tagEnd)); //xml标签截取
            if (xmlTagValue.matches(config.regexp)) { //按正则判断
                log.debug("断言匹配到了灰度标记：xmltag：{}，regexp：{}，报文匹配：{}",config.xmlTag, config.regexp, xmlTagValue);
                return true;
            }
            return false;
        }
        return false;
    }

    @Override
    public Predicate apply(NuccGaryRoutePredicateFactory.Config config) {
        throw new UnsupportedOperationException("NuccGaryRoutePredicateFactory is only async.");
    }

    public static class Config {
        private String xmlTag;// 报文的XML标签名
        private String regexp;// 报文内容的正则

        public String getXmlTag() {
            return xmlTag;
        }

        public NuccGaryRoutePredicateFactory.Config setXmlTag(String xmlTag) {
            this.xmlTag = xmlTag;
            return this;
        }

        public String getRegexp() {
            return regexp;
        }

        public NuccGaryRoutePredicateFactory.Config setRegexp(String regexp) {
            this.regexp = regexp;
            return this;
        }
    }
}
        3.4 请求验签过滤器 
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

/**
 * 请求验签过滤器
 */
@Component
@Slf4j
public class NuccMsgGatewayFilterFactory extends AbstractGatewayFilterFactory {

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

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            Object requestBody = exchange.getAttribute("bodyCache");
            String content = String.valueOf(requestBody);
            if (content == null) {
                log.warn("没有获取到请求body，请核实");
            }
            if (!content.contains("") + 7);// xml报文域
            String sign = content.substring(content.indexOf("{S:") + 3, content.lastIndexOf("}"));// 签名域
            log.debug("mock验签......");
            //..TODO
            log.debug("请求正文：{}，签名：{}", xmlStr, sign);
            return chain.filter(exchange);
        };
    }

    @Data
    public static class Config {
        boolean signCheckType; //签名校验类型，true校验，false不校验
    }
}
        3.5 响应加签过滤器方法

加签没有编写过滤器是因为scg已经实现了ModifyResponseBody，我们直接对接口RewriteFunction编写实现类即可，网关Yml配置文件可见配置关系。

import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.springframework.cloud.gateway.filter.factory.rewrite.RewriteFunction;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component("nuccSign")
@Slf4j
public class NuccSignFunction implements RewriteFunction {

    /**
     * 响应进行签名
     *
     * @param serverWebExchange 下游web句柄
     * @param resp              响应报文
     * @return
     */
    @Override
    public Publisher apply(ServerWebExchange serverWebExchange, String resp) {
        log.debug("响应报文签名：{}", resp);
        if (!resp.contains("root")) {
            return Mono.just(resp);
        }
        String xmlStr = resp.substring(resp.indexOf("") + 7);// xml报文域
        resp = resp + "{S:mocksign}"; //MOCK

        return Mono.just(resp);
    }

}
        3.6 sentinel BlockRequest实现类

此方法是通过对BlockRequestHandler接口进行实现完成的，对BlockRequestHandler官方的解释是：

您可以在 GatewayCallbackManager 注册回调进行定制：

setBlockHandler：注册函数用于实现自定义的逻辑处理被限流的请求，对应接口为 BlockRequestHandler。默认实现为 DefaultBlockRequestHandler，当被限流时会返回类似于下面的错误信息：Blocked by Sentinel: FlowException。

所以我先根据我的接口规范，编写了限流或熔断规则发生时，响应给客户端的规范报文

import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.text.ParseException;
import java.util.Date;

/**
 * sentinel拦截后实现类
 *
 * @author hx
 * @Description 完善响应报文，按规范返回
 * @date 2022/4/25 10:46
 */
@Slf4j
@Component
public class NuccSentinelBlockHandler implements BlockRequestHandler {


    @Override
    public Mono handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
        log.error("NuccSentinelBlockHandler block throw ", throwable);
        String responseXml;

        if (throwable instanceof ParamFlowException) { //限流规则
            responseXml = errorMsg("00000001", "系统达到最大流量限制");
        } else if (throwable instanceof DegradeException) { //熔断规则
            responseXml = errorMsg("00000002", "系统暂时忙");
        } else {
            responseXml = errorMsg("00000003", "系统错误请稍后重试");
        }

        return ServerResponse.status(HttpStatus.TOO_MANY_REQUESTS).bodyValue(responseXml);
    }

    /**
     * 生成通用响应报文
     *
     * @param sysRtnCd   系统返回代码
     * @param sysRtnDesc 系统返回代码详细信息
     * @return
     */
    private String errorMsg(String sysRtnCd, String sysRtnDesc) {

        return String.format("%s-%s", sysRtnCd, sysRtnDesc); //规范不方便公开，理解这么做的意义即可
    }

}

GatewayCallbackManager注册可以通过CommandLineRunner容器启动后进行加载：

import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import com.yld.gateway.callback.NuccSentinelBlockHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * 网关配置类
 * @author hx
 * @Description 加载配置类
 * @date 2022/4/25 21:32
 */
@Slf4j
@Component
public class GatewayConfig implements CommandLineRunner {

    @Autowired
    NuccSentinelBlockHandler blockHandler;

    @Override
    public void run(String... args) throws Exception {
        GatewayCallbackManager.setBlockHandler(blockHandler);
    }
}
总结

以上内容仅为个人记录，如有可以参考到的地方希望对你有帮助，如果有错误、或更好的方式实现以上功能可以留言。

PS：nacos配置sentinel规则尝试中，还没有找到配置文档，后续补充

欢迎分享，转载请注明来源：内存溢出

原文地址: https://www.outofmemory.cn/langs/737593.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-28
下一篇 2022-04-28

发表评论

登录后才能评论

评论列表（0条）

保存