微服务网关是整个微服务API请求的入口,可以实现日志拦截、权限控制、解决跨域问题、
限流、熔断、负载均衡、黑名单与白名单拦截、授权等。
Zuul网关属于netfix公司开源的产品属于第一代微服务网关
Gateway属于SpringCloud自研发的第二代微服务网关
相比来说SpringCloudGateway性能比Zuul性能要好:
注意:Zuul基于Servlet实现的,阻塞式的Api, 不支持长连接。
SpringCloudGateway基于Spring5构建,能够实现响应式非阻塞式的Api,支持长连接,能够更好的整合Spring体系的产品。
过滤器用于拦截单个服务
网关拦截整个的微服务
注意使用的是 webflux,不是web
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.0.1.RELEASE
sprng-cloud-gateway
0.0.1-SNAPSHOT
sprng-cloud-gateway
Demo project for Spring Boot
org.springframework.boot
spring-boot-starter-webflux
org.springframework.boot
spring-boot-starter-actuator
org.springframework.cloud
spring-cloud-starter-alibaba-nacos-discovery
0.2.2.RELEASE
org.springframework.cloud
spring-cloud-starter-gateway
2.0.0.RELEASE
org.springframework.boot
spring-boot-maven-plugin
### 网关端口号
server:
port: 80
spring:
application:
### 服务名称,不能使用下划线
name: alibaba-gateway
cloud:
### 注册中心
nacos:
discovery:
server-addr: 192.168.177.128:8848
### 网关
gateway:
### 开启基于注册中心的路由表。gateway可以通过开启以下配置来打开根据服务的serviceId来匹配路由,
### 默认是大写,如果需要小写serviceId,则配置# spring.cloud.gateway.locator.lowerCaseServiceId:true
discovery:
locator:
enabled: true
###路由策略
routes:
### 配置方式一:绝对路径
### 路由id, 如果不写的话默认是uuid 唯一值
- id: baidu
####转发http://www.mayikt.com/
uri: http://www.baidu.com/
### 匹配规则
predicates:
- Path=/baidu/**
### 配置方式二:根据serviceId 动态获取url路径
- id: member
#### 基于lb负载均衡形式转发, 而是lb://开头,加上serviceId
uri: lb://alibaba-server
### 这个是过滤器,对应的是filters 配置,有写好的过滤器,应该也可以自定义
filters:
- StripPrefix=1
### 匹配规则,可以配置多个,使用正则匹配,请求地址携带***(/***/)跳转到我们配置的uri,如:uri/***
predicates:
- Path=/alibaba-server/**
@SpringBootApplication
class SprngCloudGatewayApplication {
public static void main(String[] args) {
SpringApplication.run(SprngCloudGatewayApplication.class, args);
}
}
配置方式一:访问 127.0.0.1/baidu 会直接跳转到百度首页
配置方式二:
alibaba-server 是我本地的服务,已注册到nacos,并提供了getUserId 接口
如下:使用网关80端口+ 服务id ,转发到具体的服务
nacos 服务列表
gateway 过滤器分为俩种。GatewayFilter 与 GlobalFilter。
GlobalFilter :全局过滤器
GatewayFilter :将应用到单个路由或者一个分组的路由上。
还有内置的过滤器断言机制
有token 参数放行,无返回错误信息
/**
* TODO 全局过滤器
*
* @return
*/
@Component
public class TestFilter implements GlobalFilter, Ordered {
@Bean
public GlobalFilter TestFilter() {
return new TestFilter();
}
@Override
public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
System.out.println("============执行全局过滤器==============");
String token = exchange.getRequest().getQueryParams().getFirst("token");
if (token == null || token.isEmpty()) {
// 验证不通过,返回错误信息
String msg = "token not is null ";
ServerHttpResponse response = exchange.getResponse();
response.setStatusCode(HttpStatus.BAD_REQUEST);
DataBuffer buffer = response.bufferFactory().wrap(msg.getBytes());
return response.writeWith(Mono.just(buffer));
}
// 验证通过,放行
return chain.filter(exchange);
}
/**
* TODO 过滤顺序指定,过滤Web处理程序会将的所有实例GlobalFilter和所有特定GatewayFilter于路由的实例添加到过滤器链中。
*/
@Override
public int getOrder() {
return -1;
}
}
/**
* TODO 获取前端传递的token,先请求头同获取token,如果请求头没有获取到,从queryParams获取
*
* @return
* @author ws
* @mail [email protected]
* @date 2020/2/12 0012 9:57
*/
public static String getToken(ServerHttpRequest request) {
String token = null;
// 请求头同获取token
List tokenHeaders = request.getHeaders().get("TOKEN");
if (tokenHeaders != null) {
token = tokenHeaders.get(0);
}
// 如果请求头没有获取到,从QueryParams获取
if (token == null) {
token = request.getQueryParams().getFirst("TOKEN");
}
return token;
}
网关集群,那么具体的服务怎么获取到是哪个网关转发过来的呢
/**
* TODO 全局过滤器
*
* @return
*/
@Component
public class TestFilter implements GlobalFilter{
@Value("${server.port}")
private String serverPort;
@Bean
public GlobalFilter TestFilter() {
return new TestFilter();
}
@Override
public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 添加当前网关消息request 在转发到具体的服务,如:ip,端口
ServerHttpRequest request = exchange.getRequest().mutate().header("serverPort", serverPort).build();
exchange.mutate().request(request).build();
// 验证通过,放行
return chain.filter(exchange);
}
}
如需要添加黑名单,白名单功能,自行配置可获取用户真实ip,默认无法获取
可使用Nginx 或者 lvs虚拟vip 访问增加系统的高可用
hosts 文件添加配置
127.0.0.1 a80.www.baidu.com
hosts 文件路径 : C:\windows\system32\drivers\etc
nginx.conf 配置参考
upstream mysvr {
server 127.0.0.1:8080; # 这里定义可以加 http://
server 127.0.0.1:8081;
}
server {
listen 80;
server_name a80.www.baidu.com;
location ~*^.+$ { # 请求的url过滤,正则匹配,~为区分大小写,~*为不区,区分大小写。 默认 /
proxy_pass http://mysvr; # 请求转向mysvr 定义的服务器列表
}
配置说明:拦截服务地址为 a80.www.baidu.com,端口为 80的 url ,
通过 mysvr 找到----> upstream mysvr 对应的配置
并轮询upstream mysvr 下配置的服务器
服务器的请求顺序为:ABABABABAB…
直接把 yml 配置信息移动到配置中心即可
下面介绍数据库配置方式
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for gateway_config
-- ----------------------------
DROP TABLE IF EXISTS `gateway_config`;
CREATE TABLE `gateway_config` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
`route_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL COMMENT '路由Id',
`route_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL COMMENT '名称',
`route_pattern` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL COMMENT '规则',
`route_type` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL COMMENT '类型(1:绝对路径,0:根据服务serverId匹配)',
`route_url` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL COMMENT 'url地址',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = latin1 COLLATE = latin1_swedish_ci ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;
参考配置
INSERT INTO `gateway_config` VALUES (1, 'baidu', '跳转百度首页', '/baidu/**', '1', 'https://www.baidu.com');
INSERT INTO `gateway_config` VALUES (2, 'alibaba-server', '生产者测试服务', '/alibaba-server/**', '0', 'lb://alibaba-server');
注意这里druid 的版本为1.1.10 版本会报错
com.alibaba
druid-spring-boot-starter
1.1.17
org.springframework.boot
spring-boot-starter-data-jpa
mysql
mysql-connector-java
8.0.16
runtime
org.projectlombok
lombok
spring:
### 数据库连接信息
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://12.7.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&useTimezone=true&serverTimezone=GMT%2B8
username: root
password: 123456
type: com.alibaba.druid.pool.DruidDataSource
#最大活跃数
maxActive: 20
#初始化数量
initialSize: 1
#最大连接等待超时时间
maxWait: 60000
#打开PSCache,并且指定每个连接PSCache的大小
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
#通过connectionProperties属性来打开mergeSql功能;慢SQL记录
#connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
minIdle: 1
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 1 from dual
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
#配置监控统计拦截的filters,去掉后监控界面sql将无法统计,'wall'用于防火墙
filters: stat, wall, log4j
main:
allow-bean-definition-overriding: true #当遇到同样名字的时候,是否允许覆盖注册
jpa:
hibernate:
ddl-auto: update # 第一次建表create 后面用update
show-sql: true
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Data
@Entity
@Table(name = "gateway_config")
public class GateWayEntity {
@Id
private Long id;
private String routeId;
private String routeName;
private String routePattern;
private String routeType;
private String routeUrl;
}
import com.example.alibabaclient.entity.GateWayEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Component;
@Component
public interface GatewayConfigDao extends JpaRepository, JpaSpecificationExecutor {
}
import com.example.alibabaclient.dao.GatewayConfigDao;
import com.example.alibabaclient.entity.GateWayEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.filter.FilterDefinition;
import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Service;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;
import java.net.URI;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class GatewayService implements ApplicationEventPublisherAware {
private ApplicationEventPublisher publisher;
@Autowired
@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
private RouteDefinitionWriter routeDefinitionWriter;
@Autowired
private GatewayConfigDao gatewayConfigDao;
@Override
public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
this.publisher = applicationEventPublisher;
}
public void initAllRoute() {
// 从数据库查询配置的网关配置
List gateWayEntities = gatewayConfigDao.findAll();
for (GateWayEntity gw : gateWayEntities) {
loadRoute(gw);
}
}
/**
* TODO 配置更新
*/
private String loadRoute(GateWayEntity gateWayEntity) {
RouteDefinition definition = new RouteDefinition();
Map predicateParams = new HashMap<>(8);
PredicateDefinition predicate = new PredicateDefinition();
FilterDefinition filterDefinition = new FilterDefinition();
Map filterParams = new HashMap<>(8);
// 如果配置路由type为0的话,则从注册中心获取服务
URI uri = null;
if (gateWayEntity.getRouteType().equals("0")) {
uri = uri = UriComponentsBuilder.fromUriString("lb://" + gateWayEntity.getRouteUrl() + "/").build().toUri();
} else {
uri = UriComponentsBuilder.fromHttpUrl(gateWayEntity.getRouteUrl()).build().toUri();
}
// 定义的路由唯一的id
definition.setId(gateWayEntity.getRouteId());
predicate.setName("Path");
//路由转发地址
predicateParams.put("pattern", gateWayEntity.getRoutePattern());
predicate.setArgs(predicateParams);
// 名称是固定的, 路径去前缀
filterDefinition.setName("StripPrefix");
filterParams.put("_genkey_0", "1");
filterDefinition.setArgs(filterParams);
definition.setPredicates(Arrays.asList(predicate));
definition.setFilters(Arrays.asList(filterDefinition));
definition.setUri(uri);
routeDefinitionWriter.save(Mono.just(definition)).subscribe();
this.publisher.publishEvent(new RefreshRoutesEvent(this));
return "success";
}
}
import com.example.alibabaclient.service.GatewayService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* TODO 路由配置更新
*/
@RestController
public class RouteController {
@Autowired
private GatewayService gatewayService;
@GetMapping("/route")
public String route(){
gatewayService.initAllRoute();
return "success";
}
}
1、添加数据库数据(如第一步添加了忽视)
INSERT INTO `gateway_config` VALUES (1, 'baidu', '跳转百度首页', '/baidu/**', '1', 'https://www.baidu.com');
INSERT INTO `gateway_config` VALUES (2, 'alibaba-server', '生产者测试服务', '/alibaba-server/**', '0', 'lb://alibaba-server');
加载配置,访问接口:http://127.0.0.1/route ,访问: http://127.0.0.1/baidu 直接跳到百度首页,表示配置成功
1、数据库添加一条新数据
INSERT INTO `gateway_config` VALUES (3, 'gitee', '跳转码云', '/gitee/**', '1', 'https://gitee.com/');
加载配置,访问接口:http://127.0.0.1/route ,访问: http://127.0.0.1/gitee 直接跳到码云首页,表示动态配置成功
到此就结束了,该配置直接修改、添加、删除配置信息后,调用接口 /route 后都会立即生效。
勿用此方法获取body数据,会出现获取参数不完整的情况
// public static String resolveBodyFromRequest(ServerHttpRequest serverHttpRequest) {
// //获取请求体
// Flux body = serverHttpRequest.getBody();
// AtomicReference bodyRef = new AtomicReference<>();
// body.subscribe(buffer -> {
// CharBuffer charBuffer = StandardCharsets.UTF_8.decode(buffer.asByteBuffer());
// DataBufferUtils.release(buffer);
// bodyRef.set(charBuffer.toString());
// System.out.println(charBuffer.toString());
// });
// //获取request body
// return bodyRef.get();
// }
package com.gateway.filter;
import com.alibaba.fastjson.JSONObject;
import com.gateway.common.properties.AuthProperties;
import com.gateway.common.utils.HtmlEncodeUtil;
import com.gateway.common.utils.SqlEncodeUtil;
import com.gateway.error.ErrorConstantEnum;
import com.gateway.error.ErrorException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.support.BodyInserterContext;
import org.springframework.cloud.gateway.support.CachedBodyOutputMessage;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.HandlerStrategies;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
/**
* TODO Request 请求参数过滤
* 参考文章一 body数据处理: https://blog.csdn.net/tianyaleixiaowu/article/details/83375246
* 参考文章二 请求参数获取:https://blog.csdn.net/fuck487/article/details/85166162
*
* @author ws
* @mail [email protected]
* @date 2020/2/14 0014 0:21
*/
@Component
@Slf4j
@SuppressWarnings("all")
public class RequestFilter implements GlobalFilter, Ordered {
/**
* 过滤执行顺序
*/
private int order;
public RequestFilter(int order) {
this.order = order;
}
@Override
public int getOrder() {
return order;
}
@Autowired
private AuthProperties authProperties;
@Override
public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// req
ServerHttpRequest serverHttpRequest = exchange.getRequest();
// 重新构造request,参考ModifyRequestBodyGatewayFilterFactory
ServerRequest serverRequest = ServerRequest.create(exchange, HandlerStrategies.withDefaults().messageReaders());
// 请求方式 -- //if (method == HttpMethod.POST || method == HttpMethod.PUT || method == HttpMethod.DELETE || method == HttpMethod.GET) {
String method = serverHttpRequest.getMethodValue();
// 请求参数类型
MediaType mediaType = exchange.getRequest().getHeaders().getContentType();
// 不对文件上传做处理
if (MediaType.MULTIPART_FORM_DATA.isCompatibleWith(mediaType)) {
return chain.filter(exchange);
}
// json 格式参数传参
if (MediaType.APPLICATION_JSON.isCompatibleWith(mediaType) || MediaType.APPLICATION_JSON_UTF8.isCompatibleWith(mediaType)) {
Mono modifiedBody = serverRequest.bodyToMono(String.class).flatMap(body -> {
//验签,xss攻击等
String newBody = handleBody(body);
//临时保存数据
exchange.getResponse().getHeaders().add("bodyStr", newBody);
//返回数据
return Mono.just(newBody);
// return Mono.empty();
});
BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
HttpHeaders headers = new HttpHeaders();
headers.putAll(exchange.getRequest().getHeaders());
//猜测这个就是之前报400错误的元凶,之前修改了body但是没有重新写content length
headers.remove("Content-Length");
//CachedBodyOutputMessage
CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);
// return开始执行 serverRequest.bodyToMono方法
return bodyInserter.insert(outputMessage, new BodyInserterContext()).then(Mono.defer(() -> {
ServerHttpRequest decorator = this.decorate(exchange, headers, outputMessage);
return returnMono(chain, exchange.mutate().request(decorator).build());
}));
} else {
// 非 json 格式参数传参,得到 queryParams 参数后,做你想做的事,可以处理sql 注入, xss 攻击处理等,java中URL 的编码和解码函数java.net.URLEncoder.encode(String s)和java.net.URLDecoder.decode(String s);
MultiValueMap queryParams = serverHttpRequest.getQueryParams();
URI uri = serverHttpRequest.getURI();
// 重写uri参数,自定义handleParam 方法进行参数替换/过滤
URI newUri = UriComponentsBuilder.fromUri(uri)
.replaceQuery(this.handleParam(queryParams))
.build(true)
.toUri();
//下面的将请求体再次封装写回到request里,传到下一级,否则,由于请求体已被消费,后续的服务将取不到值
ServerHttpRequest request = serverHttpRequest.mutate().uri(newUri).build();
// 临时保存请求参数
exchange.getResponse().getHeaders().add("queryParams", queryParams.toString());
//封装request,传给下一级
return chain.filter(exchange.mutate().request(request).build());
}
// return chain.filter(exchange);
}
private Mono returnMono(GatewayFilterChain chain, ServerWebExchange exchange) {
return chain.filter(exchange).then(Mono.fromRunnable(() -> {
Long startTime = exchange.getAttribute("startTime");
if (startTime != null) {
long executeTime = (System.currentTimeMillis() - startTime);
log.info("耗时:{}ms", executeTime);
log.info("状态码:{}", Objects.requireNonNull(exchange.getResponse().getStatusCode()).value());
}
}));
}
ServerHttpRequestDecorator decorate(ServerWebExchange exchange, HttpHeaders headers, CachedBodyOutputMessage outputMessage) {
return new ServerHttpRequestDecorator(exchange.getRequest()) {
public HttpHeaders getHeaders() {
long contentLength = headers.getContentLength();
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.putAll(super.getHeaders());
if (contentLength > 0L) {
httpHeaders.setContentLength(contentLength);
} else {
httpHeaders.set("Transfer-Encoding", "chunked");
}
return httpHeaders;
}
public Flux getBody() {
return outputMessage.getBody();
}
};
}
/**
* TODO 处理params 参数
*
* @return 为url 字符串拼接内容,如: ?aldtype=16047&query=&keyfrom=baidu ,value值需 URLEncoder.encode
* @author ws
* @mail [email protected]
* @date 2020/2/13 0013 23:52
*/
private String handleParam(MultiValueMap queryParams) {
// 处理get请求参数
if (queryParams.size() <= 0) {
return "";
}
// sql 注入攻击处理
if (authProperties.isSqlReqAttack()) {
boolean passSqlInjection = SqlEncodeUtil.isPassSqlInjection(queryParams.toString());
if (!passSqlInjection) {
throw new ErrorException(ErrorConstantEnum.IS_NO_PARAM.getCode(), queryParams.toString() + " " + ErrorConstantEnum.IS_NO_PARAM.getMsg());
}
}
// xss 攻击处理,去掉[ 和 ]
String jsonQueryParams = JSONObject.toJSONString(queryParams);
String newJsonQueryParams = jsonQueryParams.replaceAll("\\[", "").replaceAll("\\]", "");
Map mapParams = new HashMap<>();
if (authProperties.isXssReqAttack()) {
mapParams = JSONObject.parseObject(HtmlEncodeUtil.htmlEncode(newJsonQueryParams), Map.class);
} else {
mapParams = JSONObject.parseObject(newJsonQueryParams, Map.class);
}
StringBuilder query = new StringBuilder();
for (String key : mapParams.keySet()) {
// 对原有的每个参数进行操作
query.append(key + "=" + java.net.URLEncoder.encode(mapParams.get(key)) + "&");
}
return query.toString().substring(0, query.length() - 1);
}
/**
* TODO 处理 body参数
*
* @param bodyStr 请求boay数据
* @return boay
* @author ws
* @mail [email protected]
* @date 2020/2/13 0013 23:52
*/
private String handleBody(String bodyStr) {
if (bodyStr.isEmpty()) {
return "";
}
// sql 注入攻击处理
if (authProperties.isSqlReqAttack()) {
boolean passSqlInjection = SqlEncodeUtil.isPassSqlInjection(bodyStr);
if (!passSqlInjection) {
throw new ErrorException(ErrorConstantEnum.IS_NO_PARAM);
}
}
// xss攻击处理
if (authProperties.isXssReqAttack()) {
return HtmlEncodeUtil.htmlEncode(bodyStr);
} else {
return bodyStr;
}
}
}
package com.gateway.common.utils;
/**
* TODO html 特殊字符转换工具
* @author ws
* @mail [email protected]
* @date 2020/2/13 0013 11:01
*/
@SuppressWarnings("ALL")
public class HtmlEncodeUtil {
/**
* TODO Html 文本特殊符号转换,防止 xss攻击字符转换配置工具类
*
* @param source
* @return java.lang.String
* @author ws
* @mail [email protected]
* @date 2020/2/9 0009 16:31
*/
public static String htmlEncode(String source) {
if (source == null) {
return "";
}
String html = "";
StringBuffer buffer = new StringBuffer();
for (int i = 0; i < source.length(); i++) {
char c = source.charAt(i);
switch (c) {
case '<':
buffer.append("<");
break;
case '>':
buffer.append(">");
break;
case '&':
buffer.append("&");
break;
// case '"':
// buffer.append(""");
// break;
default:
buffer.append(c);
}
}
html = buffer.toString();
return html;
}
}
package com.gateway.common.utils;
import org.apache.commons.lang.StringUtils;
/**
* TODO 防止 sql注入攻击字段检查配置工具类
* @author ws
* @mail [email protected]
* @date 2020/2/14 0014 17:35
*/
@SuppressWarnings("all")
public class SqlEncodeUtil {
private static String[] badStr = {
"and", "exec", "execute", "insert", "select", "delete", "update",
"count", "chr", "mid", "master", "truncate", "char", "declare", "sitename",
"net user", "xp_cmdshell", "or", "create", "drop", "table", "from",
"grant", "use", "group_concat", "column_name", "information_schema.columns",
"table_schema", "union", "where", "order", "by", "like", "%"
};
static String[] illegalCharacterSetStr = {
"*"
};
/**
* TODO 检查传入参数
*
* @param value
* @return boolean true 正常,false 存在风险字段
* @author ws
* @mail [email protected]
* @date 2020/2/14 0014 15:28
*/
public static boolean isPassSqlInjection(String value) {
if (StringUtils.isBlank(value)) {
return true;
}
value = value.toLowerCase();
for (String bad : badStr) {
if (value.indexOf(bad + " ") >= 0 || value.indexOf(" " + bad) >= 0 || value.indexOf("" + bad + " ") >= 0) {
return false;
}
}
for (String bad : illegalCharacterSetStr) {
if (value.indexOf(bad) >= 0) {
return false;
}
}
return true;
}
}
1、yml 配置
#auth:
# adminRouteIds: baidu
# userRouteIds: baidu
# interfaceNoCheck:
# -baidu-555: /baidu/555 该值随意填写,尽量填写为具体接口名称
# -baidu-666: /baidu/666
# -test: 测试xss
# -test-api-test2: /test/api/test221
# sqlReqAttack: true
# xssReqAttack: true
# xssRespAttack: true
** 2、AuthProperties** 类,动态获取yml 配置
package com.gateway.common.properties;
/**
* TODO yml配置文件中Auth节点下的所有数据
*
* @author ws
* @mail [email protected]
* @date 2020/2/12 0012 15:54
*/
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
/**
* TODO 映射Org属性,yml 配置数据:参考 https://blog.csdn.net/weixin_34220834/article/details/91427948
*
* @author ws
* @mail [email protected]
* @date 2020/2/13 0013 11:02
* * @ConfigurationProperties("auth") 读取 auth 开头的配置数据
* * @Configuration + @EnableConfigurationProperties({ServerProperties.class}) 注册到spring容器
* * @RefreshScope 配置中心可直接修改更新立即生效
*/
@Data
@RefreshScope
@Configuration
@ConfigurationProperties("auth")
@EnableConfigurationProperties({AuthProperties.class})
public class AuthProperties {
/**
* 是否对请求参数进行 sql注入过滤
*/
private boolean sqlReqAttack = false;
/**
* 是否对请求参数进行 xss过滤
*/
private boolean xssReqAttack = false;
/**
* 是否对响应参数进行过滤
*/
private boolean xssRespAttack = false;
/**
* 后端需要token验证的服务,网关路由Id,多个逗号分隔
*/
private String adminRouteIds;
/**
* 前端需要token验证的服务,网关路由Id,多个逗号分隔
*/
private String userRouteIds;
/**
* 不需要token 验证的接口集
*/
private Map interfaceNoCheck = new HashMap<>();
}
package com.gateway.filter;
import com.gateway.common.properties.AuthProperties;
import com.gateway.common.utils.HtmlEncodeUtil;
import com.gateway.config.GatewayLogConfig;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.springframework.beans.factory.annotation.Autowired;
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.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.nio.charset.Charset;
/**
* TODO xss 攻击拦截处理器,Response 返回数据过滤order必须小于-1
*
* @author ws
* @mail [email protected]
* @date 2020/2/13 0013 10:48
*/
@Component
@NoArgsConstructor
@Slf4j
@SuppressWarnings("all")
public class ResponseFilter implements GlobalFilter, Ordered {
/**
* 过滤执行顺序
*/
private int order;
public ResponseFilter(int order) {
this.order = order;
}
@Override
public int getOrder() {
return order;
}
@Autowired
private AuthProperties authProperties;
@Autowired
private GatewayLogConfig gatewayLogConfig;
@Override
public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
ServerHttpResponse originalResponse = exchange.getResponse();
DataBufferFactory bufferFactory = originalResponse.bufferFactory();
ServerHttpResponseDecorator decoratedResponse = new ServerHttpResponseDecorator(originalResponse) {
@Override
public Mono writeWith(Publisher extends DataBuffer> body) {
if (body instanceof Flux) {
Flux extends DataBuffer> fluxBody = (Flux extends DataBuffer>) body;
Mono voidMono = super.writeWith(fluxBody.map(dataBuffer -> {
byte[] content = new byte[dataBuffer.readableByteCount()];
dataBuffer.read(content);
//释放掉内存
DataBufferUtils.release(dataBuffer);
//原数据,想修改、查看就随意而为了
String data = new String(content, Charset.forName("UTF-8"));
// 不对html 页面进行过滤
// if (data.indexOf("") == -1) { // }
// 判断是否为swagger文档,v2/api-docs ,是不进行xss过滤
if (data.toString().indexOf("v2/api-docs") == -1 && authProperties.isXssRespAttack()) {
data = HtmlEncodeUtil.htmlEncode(data);
}
//byte[] uppedContent = new String(data, Charset.forName("UTF-8")).getBytes();
return bufferFactory.wrap(data.getBytes());
}));
// 注意,body数据在exchange 只能读取一次
gatewayLogConfig.putLog(exchange, "响应成功");
return voidMono;
}
// if body is not a flux. never got there.
return super.writeWith(body);
}
};
// replace response with decorator
return chain.filter(exchange.mutate().response(decoratedResponse).build());
}
}
@Data
public class Result implements Serializable {
private static final long serialVersionUID = 0L;
/**
* 响应结果码
*/
private Integer code;
/**
* 响应结果信息
*/
private String msg;
public Result(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
public Result(ErrorConstantEnum errorConstantEnum) {
this.code = errorConstantEnum.getCode();
this.msg = errorConstantEnum.getMsg();
}
}
package com.gateway.error;
import lombok.Getter;
import lombok.NoArgsConstructor;
/**
* TODO 异常常量类
*
* @author ws
* @mail [email protected]
* @date 2020/2/9 0009 11:16
* @return
*/
@Getter
@NoArgsConstructor
public enum ErrorConstantEnum {
IS_NO_TOKEN(10001, "没有 token"),
IS_NO_TOKEN_INVALID(10002, "无效 token"),
IS_NO_PARAM(10003, "存在非法参数"),
IS_NO_SENTINEL_MAX(10004, "QBS已到达阀值,请稍后重试"),
private Integer code;
private String msg;
ErrorConstantEnum(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
}
package com.gateway.error;
import lombok.Data;
import org.springframework.stereotype.Component;
/**
* TODO 自定义异常类,通过此类可返回各种自定义异常信息,由GlobalExceptionHandler 处理返回
*
* 使用:throw new ErrorException("1000000","自定义异常测试");
* 返回:{"code": 1000000,"msg": "自定义异常测试"}
*
* @author ws
* @mail [email protected]
* @date 2020/2/9 0009 12:44
* @return
*/
@Data
@Component
public class ErrorException extends RuntimeException {
private Integer code;
private String msg;
//直接传递
public ErrorException(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
//枚举传递(建议先定义枚举)
public ErrorException(ErrorConstantEnum errorConstantEnum) {
this.code = errorConstantEnum.getCode();
this.msg = errorConstantEnum.getMsg();
}
}
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.result.view.ViewResolver;
import java.util.Collections;
import java.util.List;
/**
* TODO 网关全局异常捕获配置
*
* @author ws
* @mail [email protected]
* @date 2020/2/14 0014 11:01
* @return
*/
@Configuration
public class ExceptionConfig {
/**
* 自定义异常处理[@@]注册Bean时依赖的Bean,会从容器中直接获取,所以直接注入即可
*/
@Primary
@Bean
@Order(Ordered.HIGHEST_PRECEDENCE)
public ErrorWebExceptionHandler errorWebExceptionHandler(ObjectProvider> viewResolversProvider,
ServerCodecConfigurer serverCodecConfigurer) {
JsonExceptionHandler jsonExceptionHandler = new JsonExceptionHandler();
jsonExceptionHandler.setViewResolvers(viewResolversProvider.getIfAvailable(Collections::emptyList));
jsonExceptionHandler.setMessageWriters(serverCodecConfigurer.getWriters());
jsonExceptionHandler.setMessageReaders(serverCodecConfigurer.getReaders());
return jsonExceptionHandler;
}
}
package com.gateway.error;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.fastjson.JSONObject;
import com.gateway.common.vo.Result;
import com.gateway.config.GatewayLogConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.reactive.error.ErrorWebExceptionHandler;
import org.springframework.cloud.gateway.support.NotFoundException;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.http.codec.HttpMessageWriter;
import org.springframework.util.Assert;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.RequestPredicates;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* TODO gateway 全局异常处理类
*
* @author ws
* @mail [email protected]
* @date 2020/2/14 0014 12:04
*/
@Slf4j
public class JsonExceptionHandler implements ErrorWebExceptionHandler {
@Autowired
private GatewayLogConfig gatewayLogConfig;
@Override
public Mono handle(ServerWebExchange exchange, Throwable ex) {
// 按照异常类型进行处理
HttpStatus httpStatus;
String msg;
Result data;
if (ex instanceof ErrorException) {
// 自定义异常错误
data = new Result(((ErrorException) ex).getCode(), ((ErrorException) ex).getMsg());
} else if (ex instanceof FlowException) {
// sentinel 限流
data = new Result(ErrorConstantEnum.IS_NO_SENTINEL_MAX);
} else if (ex instanceof NotFoundException) {
// 404错误
data = new Result(ErrorConstantEnum.NOT_FOUND);
} else if (ex instanceof ResponseStatusException) {
ResponseStatusException responseStatusException = (ResponseStatusException) ex;
httpStatus = responseStatusException.getStatus();
msg = responseStatusException.getMessage();
data = new Result(httpStatus.value(), msg);
} else {
// 500错误
data = new Result(500, ex.toString());
ex.printStackTrace();
}
String dataJson = JSONObject.toJSONString(data);
//封装响应体,此body可修改为自己的jsonBody
Map result = new HashMap<>(2, 1);
result.put("httpStatus", HttpStatus.OK);
result.put("body", dataJson);
// 记录日志
gatewayLogConfig.putLog(exchange, "异常:" + dataJson);
//参考AbstractErrorWebExceptionHandler
if (exchange.getResponse().isCommitted()) {
return Mono.error(ex);
}
exceptionHandlerResult.set(result);
ServerRequest newRequest = ServerRequest.create(exchange, this.messageReaders);
return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse).route(newRequest)
.switchIfEmpty(Mono.error(ex))
.flatMap((handler) -> handler.handle(newRequest))
.flatMap((response) -> write(exchange, response));
}
/**
* MessageReader
*/
private List> messageReaders = Collections.emptyList();
/**
* MessageWriter
*/
private List> messageWriters = Collections.emptyList();
/**
* ViewResolvers
*/
private List viewResolvers = Collections.emptyList();
/**
* 存储处理异常后的信息
*/
private ThreadLocal
org.springframework.cloud
spring-cloud-starter-gateway
2.0.4.RELEASE
io.springfox
springfox-swagger2
2.9.2
io.springfox
springfox-swagger-ui
2.9.2
package com.gateway.swagger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;
import springfox.documentation.swagger.web.*;
import java.util.Optional;
/**
* TODO 因为Gateway里没有配置SwaggerConfig,而运行Swagger-ui又需要依赖一些接口,所以我的想法是自己建立相应的swagger-resource端点。
* @author ws
* @mail [email protected]
* @date 2020/3/2 0002 12:06
*/
@RestController
@RequestMapping("/swagger-resources")
public class SwaggerHandler {
@Autowired(required = false)
private SecurityConfiguration securityConfiguration;
@Autowired(required = false)
private UiConfiguration uiConfiguration;
private final SwaggerResourcesProvider swaggerResources;
@Autowired
public SwaggerHandler(SwaggerResourcesProvider swaggerResources) {
this.swaggerResources = swaggerResources;
}
@GetMapping("/configuration/security")
public Mono> securityConfiguration() {
return Mono.just(new ResponseEntity<>(
Optional.ofNullable(securityConfiguration).orElse(SecurityConfigurationBuilder.builder().build()), HttpStatus.OK));
}
@GetMapping("/configuration/ui")
public Mono> uiConfiguration() {
return Mono.just(new ResponseEntity<>(
Optional.ofNullable(uiConfiguration).orElse(UiConfigurationBuilder.builder().build()), HttpStatus.OK));
}
@GetMapping("")
public Mono swaggerResources() {
return Mono.just((new ResponseEntity<>(swaggerResources.get(), HttpStatus.OK)));
}
}
package com.gateway.swagger;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
/**
* TODO 路由配置添加SwaggerHeaderFilter 过滤器【Spring Boot版本超过2.0.6的应该可以跳过这一步,最新源码也更新了。Spring修复了bug给我们添加上了这个Header】
* 另外,我发现在路由为admin/test/{a}/{b},在swagger会显示为test/{a}/{b},缺少了admin这个路由节点。
* 断点源码时发现在Swagger中会根据X-Forwarded-Prefix这个Header来获取BasePath,将它添加至接口路径与host中间,这样才能正常做接口测试,
* 而Gateway在做转发的时候并没有这个Header添加进Request,所以发生接口调试的404错误。
* 解决思路是在Gateway里加一个过滤器来添加这个header。
*
* @author ws
* @mail [email protected]
* @date 2020/3/2 0002 11:56
*/
@Component
public class SwaggerHeaderFilter extends AbstractGatewayFilterFactory {
private static final String HEADER_NAME = "X-Forwarded-Prefix";
@Override
public GatewayFilter apply(Object config) {
return (exchange, chain) -> {
ServerHttpRequest request = exchange.getRequest();
String path = request.getURI().getPath();
if (!StringUtils.endsWithIgnoreCase(path, SwaggerProvider.API_URI)) {
return chain.filter(exchange);
}
String basePath = path.substring(0, path.lastIndexOf(SwaggerProvider.API_URI));
ServerHttpRequest newRequest = request.mutate().header(HEADER_NAME, basePath).build();
ServerWebExchange newExchange = exchange.mutate().request(newRequest).build();
return chain.filter(newExchange);
};
}
}
package com.gateway.swagger;
import lombok.AllArgsConstructor;
import org.springframework.cloud.gateway.config.GatewayProperties;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.support.NameUtils;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import springfox.documentation.swagger.web.SwaggerResource;
import springfox.documentation.swagger.web.SwaggerResourcesProvider;
import java.util.ArrayList;
import java.util.List;
/**
* TODO 因为Swagger暂不支持webflux项目,所以Gateway里不能配置SwaggerConfig,
* 也就是说Gateway无法提供自身API。但我想一般也不会在网关项目代码里写业务API代码吧。。
* 所以这里的集成只是基于基于WebMvc的微服务项目。
*
* @author ws
* @mail [email protected]
* @date 2020/3/2 0002 11:54
*/
@Component
@Primary
@AllArgsConstructor
public class SwaggerProvider implements SwaggerResourcesProvider {
public static final String API_URI = "/v2/api-docs";
private final RouteLocator routeLocator;
private final GatewayProperties gatewayProperties;
@Override
public List get() {
List resources = new ArrayList<>();
List routes = new ArrayList<>();
//取出gateway的route
routeLocator.getRoutes().subscribe(route -> routes.add(route.getId()));
//结合配置的route-路径(Path),和route过滤,只获取有效的route节点
gatewayProperties.getRoutes().stream().filter(routeDefinition -> routes.contains(routeDefinition.getId()))
.forEach(routeDefinition -> routeDefinition.getPredicates().stream()
.filter(predicateDefinition -> ("Path").equalsIgnoreCase(predicateDefinition.getName()))
.forEach(predicateDefinition -> resources.add(swaggerResource(routeDefinition.getId(),
predicateDefinition.getArgs().get(NameUtils.GENERATED_NAME_PREFIX + "0")
.replace("/**", API_URI)))));
return resources;
}
private SwaggerResource swaggerResource(String name, String location) {
SwaggerResource swaggerResource = new SwaggerResource();
swaggerResource.setName(name);
swaggerResource.setLocation(location);
swaggerResource.setSwaggerVersion("2.0");
return swaggerResource;
}
}
需要swagger 的路由下添加 - SwaggerHeaderFilter 过滤器
# - id: lplb-coupon-api
# uri: lb://lplb-coupon-api
# predicates:
# - Path=/lplb-coupon-api/**
# filters:
# - SwaggerHeaderFilter
# - StripPrefix=1
com.alibaba.csp
sentinel-spring-cloud-gateway-adapter
1.6.0
/**
* TODO 获取路由相关配置
*
* @author ws
* @mail [email protected]
* @date 2020/2/19 0019 10:28
*/
@Data
@RefreshScope
@Configuration
@ConfigurationProperties("spring.cloud.gateway")
@EnableConfigurationProperties({RoutesProperties.class})
public class RoutesProperties {
private List
package com.gateway.sentinel;
import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
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.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.result.view.ViewResolver;
import java.util.Collections;
import java.util.List;
/**
* TODO sentinel 限流核心配置
* @author ws
* @mail [email protected]
* @date 2020/2/17 0017 14:08
*/
@Configuration
public class GatewayConfiguration {
private final List viewResolvers;
private final ServerCodecConfigurer serverCodecConfigurer;
public GatewayConfiguration(ObjectProvider> viewResolversProvider,
ServerCodecConfigurer serverCodecConfigurer) {
this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
this.serverCodecConfigurer = serverCodecConfigurer;
}
@Bean
@Order(Ordered.HIGHEST_PRECEDENCE)
public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
// Register the block exception handler for Spring Cloud Gateway.
return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
}
@Bean
@Order(Ordered.HIGHEST_PRECEDENCE)
public GlobalFilter sentinelGatewayFilter() {
return new SentinelGatewayFilter();
}
}
initGatewayRules() 方法配置限流属性
handle 方法是nacos 监听路由相关配置yml 修改,在调用initGatewayRules() 实现刷新’
package com.gateway.sentinel;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import com.gateway.common.properties.RoutesProperties;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.endpoint.event.RefreshEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import java.util.*;
/**
* TODO sentinel限流规则配置
*
* @author ws
* @mail [email protected]
* @date 2020/2/17 0017 14:09
*/
@SuppressWarnings("all")
@Slf4j
@Component
public class SentinelApplicationRunner {
@Autowired
private RoutesProperties routesProperties;
/**
* TODO 监听nacos配置中心数据修改重置sentinel 配置
*
* @param event
* @return void
* @author ws
* @mail [email protected]
* @date 2020/2/22 0022 17:26
*/
@EventListener
public void handle(RefreshEvent event) {
if (event.getEventDesc().equals("Refresh Nacos entity")) {
//等待10秒,让配置中心数据已经修改完本地数据在修改限流配置
new Thread(new Runnable() {
@SneakyThrows
@Override
public void run() {
Thread.sleep(10*1000);
initGatewayRules();
}
}).start();
}
}
/**
* TODO 初始化配置sentinel限流规则
*
* @return void
* @author ws
* @mail [email protected]
* @date 2020/2/22 0022 16:10
*/
private void initGatewayRules() {
//限流规则容器
Set rules = new HashSet<>();
// 获取到所有路由配置
List
sentinel:限流配置 -> intervalSec:限流时间单位(秒), count:限流数量(秒),修改后等待10秒后生效
# - id: lplb-coupon-api
# uri: lb://lplb-coupon-api
# predicates:
# - Path=/lplb-coupon-api/**
# filters:
# - SwaggerHeaderFilter
# - StripPrefix=1
# sentinel:
# intervalSec: 1
# count: 10