网关简介
大家都都知道在微服务架构中,一个系统会被拆分为很多个微服务。那么作为客户端要如何去调用这么多的微服务呢?如果没有网关的存在,我们只能在客户端记录每个微服务的地址,然后分别去调用。
这样的架构,会存在着诸多的问题:
- 客户端多次请求不同的微服务,增加客户端代码或配置编写的复杂性
- 认证复杂,每个服务都需要独立认证。
- 存在跨域请求,在一定场景下处理相对复杂。
上面的这些问题可以借助API****网关来解决。
所谓的API网关,就是指系统的统一入口,它封装了应用程序的内部结构,为客户端提供统一服务,一些与业务本身功能无关的公共逻辑可以在这里实现,诸如认证、鉴权、监控、路由转发等等。
添加上API网关之后,系统的架构图变成了如下所示:
我们也可以观察下,我们现在的整体架构图:
在业界比较流行的网关,有下面这些:
使用nginx的反向代理和负载均衡可实现对api服务器的负载均衡及高可用lua是一种脚本语言,可以来编写一些简单的逻辑, nginx支持lua脚本
基于Nginx+Lua开发,性能高,稳定,有多个可用的插件(限流、鉴权等等)可以开箱即用。 问题:只支持Http协议;二次开发,自由扩展困难;提供管理API,缺乏更易用的管控、配置方式。
Netflflix开源的网关,功能丰富,使用JAVA开发,易于二次开发 问题:缺乏管控,无法动态配置;依赖组件较多;处理Http请求依赖的是Web容器,性能不如Nginx
Spring公司为了替换Zuul而开发的网关服务,将在下面具体介绍。
注意:SpringCloud alibaba技术栈中并没有提供自己的网关,我们可以采用Spring Cloud Gateway来做网关
Gateway简介
Spring Cloud Gateway是Spring公司基于Spring 5.0,Spring Boot 2.0 和 Project Reactor 等技术开发的网关,它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。它的目标是替代Netflflix Zuul,其不仅提供统一的路由方式,并且基于 Filter 链的方式提供了网关基本的功能,例如:安全,监控和限流。
优点:
- 性能强劲:是第一代网关Zuul的1.6倍
- 功能强大:内置了很多实用的功能,例如转发、监控、限流等
- 设计优雅,容易扩展
缺点:
- 其实现依赖Netty与WebFlux,不是传统的Servlet编程模型,学习成本高
- 不能将其部署在Tomcat、Jetty等Servlet容器里,只能打成jar包执行
- 需要Spring Boot 2.0及以上的版本,才支持
Gateway快速入门
要求: 通过浏览器访问api网关,然后通过网关将请求转发到商品微服务
基础版
创建新模块shop-gateway
导入相关网关依赖
1 2 3 4 5 6 7
| <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-gateway</artifactId> </dependency> </dependencies>
|
创建shop-gateway
模块启动类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
| package com.letcoding.gateway;
import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication public class ShopGatewayApplication {
public static void main(String[] args) { SpringApplication.run(ShopGatewayApplication.class, args); } }
|
添加配置文件
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
| server: port: 7000 spring: application: name: shop-gateway cloud: gateway: routes: - id: shop-product uri: http://localhost:8081 order: 1 predicates: - Path=/shop-product/** filters: - StripPrefix=1
|
启动服务,通过网关访问路径,请求测试
http://localhost:7000/shop-product/product/info/1
增强版
现在在配置文件中写死了转发路径的地址, 前面我们已经分析过地址写死带来的问题, 接下来我们从注册中心获取此地址。
添加依赖
1 2 3 4 5
| <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency>
|
添加注解,让注册中心能发现
1 2 3 4 5 6 7 8 9 10 11 12 13 14
|
@SpringBootApplication @EnableDiscoveryClient public class ShopGatewayApplication {
public static void main(String[] args) { SpringApplication.run(ShopGatewayApplication.class, args); } }
|
修改配置文件
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
| server: port: 7000 spring: application: name: shop-gateway cloud: nacos: discovery: server-addr: 192.168.56.120:8848 namespace: 6d39b87a-55bb-4497-bec5-79bdd3b9789b gateway: discovery: locator: enabled: true routes: - id: shop-product uri: lib://shop-product order: 1 predicates: - Path=/shop-product/** filters: - StripPrefix=1
|
启动测试
备注:这里说一个博猪开发的微服务开发的习惯:
- 启动项目
- 打开对应环境配置的注册发现中心-
nacos
- 打开
服务管理
-服务配置
- 查看服务是否启动成功
- 查看使用服务是否都在一个服务环境里面,
nacos
默认为public
,不用环境服务调试的时候不通的!!!
访问地址:http://localhost:7000/shop-product/product/info/1
简写版
有人可能觉得上方配置可能太繁琐了,在开发中流行一句话约定大于配置
,而SpringCloud-gateway
也遵循了这么一个良好的规范,如果对于这一块不太了解的朋友,请先学习一下SpringBoot
,对于去配置化
有个大概的了解,同时对SpringCloud
也有个基础。当然话归正题我还是不太建议这样配置的,当然日常开发中也很少使用到默认的配置,这里只限于练习配置。
修改配置
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| server: port: 7000 spring: application: name: shop-gateway cloud: nacos: discovery: server-addr: 192.168.56.120:8848 namespace: 6d39b87a-55bb-4497-bec5-79bdd3b9789b gateway: discovery: locator: enabled: true
|
启动测试
访问地址:http://localhost:7000/shop-product/product/info/1
这时候,就发现只要按照网关地址/微服务/接口的格式去访问,就可以得到成功响应。
同时这里也会发现我之前的命名规则和一些开发习惯,这个也会省去很大的功夫,所以我很建议个人再去开发的时候一定要好好设计一下自己的代码编写规范和实现的逻辑思路。
Gateway核心架构
基本概念
路由(Route) 是 gateway 中最基本的组件之一,表示一个具体的路由信息载体。主要定义了下面的几个信息:
字段名 | 字段含义 |
---|
id | 路由标识符,区别于其他 Route |
uri | 路由指向的目的地 uri,即客户端请求最终被转发到的微服务 |
order | 用于多个 Route 之间的排序,数值越小排序越靠前,匹配优先级越高 |
predicate | 断言的作用是进行条件判断,只有断言都返回真,才会真正的执行路由 |
filter | 过滤器用于修改请求和响应信息 |
执行流程
执行流程大体如下:
- Gateway Client向Gateway Server发送请求
- 请求首先会被HttpWebHandlerAdapter进行提取组装成网关上下文
- 然后网关的上下文会传递到DispatcherHandler,它负责将请求分发给RoutePredicateHandlerMapping
- RoutePredicateHandlerMapping负责路由查找,并根据路由断言判断路由是否可用
- 如果过断言成功,由FilteringWebHandler创建过滤器链并调用6. 请求会一次经过PreFilter–微服务–PostFilter的方法,最终返回响应
断言
Predicate(断言, 谓词) 用于进行条件判断,只有断言都返回真,才会真正的执行路由。
断言就是说: 在 什么条件下 才能进行路由转发
内置路由断言工厂
SpringCloud Gateway包括许多内置的断言工厂,所有这些断言都与HTTP请求的不同属性匹配。具体如下:
1
| -RemoteAddr=192.168.1.1/24
|
CookieRoutePredicateFactory:接收两个参数,cookie 名字和一个正则表达式。 判断请求cookie是否具有给定名称且值与正则表达式匹配。
HeaderRoutePredicateFactory:接收两个参数,标题名称和正则表达式。 判断请求Header是否具有给定名称且值与正则表达式匹配。
1
| -Header=X-Request-Id, \d+
|
HostRoutePredicateFactory:接收一个参数,主机名模式。判断请求的Host是否满足匹配规则。
MethodRoutePredicateFactory:接收一个参数,判断请求类型是否跟指定的类型匹配。
PathRoutePredicateFactory:接收一个参数,判断请求的URI部分是否满足路径规则。
QueryRoutePredicateFactory :接收两个参数,请求param和正则表达式, 判断请求参数是否具有给定名称且值与正则表达式匹配。
WeightRoutePredicateFactory:接收一个[组名,权重], 然后对于同一个组内的路由按照权重转发
1 2 3 4 5 6 7
| routes: -id: weight_route1 uri: host1 predicates: -Path=/product/** -Weight=group3, 1 -id: weight_route2 uri: host2 predicates: -Path=/product/** -Weight= group3, 9
|
内置路由断言工厂的使用
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
| server: port: 7000 spring: application: name: shop-gateway cloud: nacos: discovery: server-addr: 192.168.56.120:8848 namespace: 6d39b87a-55bb-4497-bec5-79bdd3b9789b gateway: discovery: locator: enabled: true routes: - id: shop-product uri: lib://shop-product order: 0 predicates: - Method=POST filters: - StripPrefix=1
|
一定要把Path
路径转发去掉,要不然对应的method断言不会生效的。
自定义路由断言工厂
我们来设定一个场景: 假设我们的应用仅仅让age在(min,max)之间的人来访问。
编写年龄配置
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
| server: port: 7000 spring: application: name: shop-gateway cloud: nacos: discovery: server-addr: http://192.168.56.120:8848 namespace: 6d39b87a-55bb-4497-bec5-79bdd3b9789b gateway: discovery: locator: enabled: true lower-case-service-id: true routes: - id: shop-product uri: lb://shop-product predicates: - Path=/shop-product/** - Age=18,60 filters: - StripPrefix=1
|
自定义一个断言工厂, 实现断言方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
| package com.letcoding.gateway.predicate;
import com.alibaba.fastjson.JSONObject; import lombok.extern.slf4j.Slf4j; import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory; import org.springframework.stereotype.Component; import org.springframework.util.MultiValueMap; import org.springframework.util.StringUtils; import org.springframework.validation.annotation.Validated; import org.springframework.web.server.ServerWebExchange;
import java.util.Arrays; import java.util.List; import java.util.function.Predicate;
@Component @Slf4j public class AgeRoutePredicateFactory extends AbstractRoutePredicateFactory<AgeRoutePredicateFactory.Config> {
public AgeRoutePredicateFactory() { super(AgeRoutePredicateFactory.Config.class); }
@Override public Predicate<ServerWebExchange> apply(Config config) { return new Predicate<ServerWebExchange>() { @Override public boolean test(ServerWebExchange serverWebExchange) { MultiValueMap<String, String> queryParams = serverWebExchange.getRequest().getQueryParams(); log.info(">>>>>>>>>>>>>>>>queryParams is ", JSONObject.toJSONString(queryParams)); String age = queryParams.getFirst("age"); log.info(">>>>>>>>>>>>>>>age is ",age); System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"+age); if (!StringUtils.isEmpty(age) && age.matches("[0-9]+")) { int ageInt = Integer.parseInt(age); if (ageInt >= config.getMinAge() && ageInt < config.getMinAge()) { return true; }else { return false; } } return false; }
@Override public String toString() { return String.format("minAge: %s,MaxAge: %s", config.getMinAge(),config.getMinAge()); } }; }
@Override public List<String> shortcutFieldOrder() { return Arrays.asList("minAge", "maxAge"); }
@Validated public static class Config{ private Integer minAge; private Integer maxAge;
public Integer getMinAge() { return minAge; }
public void setMinAge(Integer minAge) { this.minAge = minAge; }
public Integer getMaxAge() { return maxAge; }
public void setMaxAge(Integer maxAge) { this.maxAge = maxAge; } }
}
|
启动测试,分别测试一下请求
#测试发现当age在(20,60)可以访问,其它范围不能访问
http://localhost:7000/product-serv/product/1?age=30
http://localhost:7000/product-serv/product/1?age=10
http://localhost:7000/product-serv/product/1?age=80
注意:
- 网关服务和产品的服务,一定要在同一个nacos、命名空间下面!!!!!
- 版本问题,博猪由于在最初选择springCloud和SpringcloudAlibaba的版本上不太兼容,导致博猪在进行自定义断言配置时出现问题,正确配置如下:
1 2
| <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version> <spring-cloud-alibaba.version>2.1.0.RELEASE</spring-cloud-alibaba.version>
|
版本问题很重要!!!!!!!
过滤器
- 作用: 过滤器就是在请求的传递过程中,对请求和响应做一些手脚
- 生命周期:
Pre Post
- 分类: 局部过滤器(作用在某一个路由上) 全局过滤器(作用全部路由上)
- 在Gateway中, Filter的生命周期只有两个:“pre” 和 “post”。
- PRE: 这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择 请求的微服务、记录调试信息等。
- POST:这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等
Gateway 的Filter从作用范围可分为两种: GatewayFilter与GlobalFilter。
- GatewayFilter:应用到单个路由或者一个分组的路由上。
- GlobalFilter:应用到所有的路由上
局部过滤器
局部过滤器是针对单个路由的过滤器。
内置局部过滤器
在SpringCloud Gateway中内置了很多不同类型的网关路由过滤器。具体如下:
过滤器工厂 | 作用 | 参数 |
---|
AddRequestHeader | 为原始请求添加Header | Header的名称及值 |
AddRequestParameter | 为原始请求添加请求参数 | 参数名称及值 |
AddResponseHeader | 为原始响应添加Header | Header的名称及值 |
DedupeResponseHeader | 剔除响应头中重复的值 | 需要去重的Header名 称及去重策略 |
Hystrix | 为路由引入Hystrix的断路器保护 | HystrixCommand的名 称 |
FallbackHeaders | 为fallbackUri的请求头中添加具 体的异常信息 | Header的名称 |
PrefixPath | 为原始请求路径添加前缀 | 前缀路径 |
PreserveHostHeader | 为请求添加一个 preserveHostHeader=true的属 性,路由过滤器会检查该属性以 决定是否要发送原始的Host | 无 |
RequestRateLimiter | 用于对请求限流,限流算法为令 牌桶 | keyResolver、 rateLimiter、 statusCode、 denyEmptyKey、 emptyKeyStatus |
RedirectTo | 将原始请求重定向到指定的URL | http状态码及重定向的 url |
RemoveHopByHopHeadersFilter | 为原始请求删除IETF组织规定的 一系列Header | 默认就会启用,可以通 过配置指定仅删除哪些 Header |
RemoveRequestHeader | 为原始请求删除某个Heade | Header名称 |
RemoveResponseHeader | 为原始请求删除某个Heade | Header名称 |
RewritePath | 重写原始的请求路径 | 原始路径正则表达式以 及重写后路径的正则表 达式 |
RewriteResponseHeader | 重写原始响应中的某个Header | Header名称,值的正 则表达式,重写后的值 |
SaveSession | 在转发请求之前,强制执行 WebSession::save操作 | 无 |
SecureHeaders | 为原始响应添加一系列起安全作 用的响应头 | 无,支持修改这些安全 响应头的值 |
SetPath | 修改原始的请求路径 | 修改后的路径 |
SetResponseHeader | 修改原始响应中某个Header的值 | Header名称,修改后 的值 |
SetStatus | 修改原始响应的状态码 | HTTP 状态码,可以是 数字,也可以是字符串 |
StripPrefix | 用于截断原始请求的路径 | 使用数字表示要截断的 路径的数量 |
Retry | 针对不同的响应进行重试 | retries、statuses、 methods、series |
RequestSize | 设置允许接收最大请求包的大 小。如果请求包大小超过设置的 值,则返回 413 Payload Too Large | 请求包大小,单位为字 节,默认值为5M |
ModifyRequestBody | 在转发请求之前修改原始请求体 内容 | 修改后的请求体内容 |
ModifyResponseBody | 修改原始响应体的内容 | 修改后的响应体内容 |
内置局部过滤器使用
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
| server: port: 7000 spring: application: name: shop-gateway cloud: nacos: discovery: server-addr: 192.168.56.120:8848 namespace: 6d39b87a-55bb-4497-bec5-79bdd3b9789b gateway: discovery: locator: enabled: true routes: - id: shop-product uri: lb://shop-product predicates: - Path=/shop-product-server/** - Age=16,80 filters: - StripPrefix=1 - SetStatus=250
|
自定义局部过滤器
场景如下:配置日志过滤器,从而实现日志的记录和拦截
在配置文件中,添加一个Log的过滤器配置
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
| server: port: 7000 spring: application: name: shop-gateway cloud: nacos: discovery: server-addr: 192.168.56.120:8848 namespace: 6d39b87a-55bb-4497-bec5-79bdd3b9789b gateway: discovery: locator: enabled: true routes: - id: shop-product uri: lb://shop-product predicates: - Path=/shop-product-server/** - Age=16,80 filters: - StripPrefix=1 - SetStatus=250 - Log=true,false
|
自定义一个过滤器工厂,实现方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
| package com.letcoding.gateway.predicate;
import lombok.extern.slf4j.Slf4j; 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.validation.annotation.Validated; import org.springframework.web.server.ServerWebExchange; import reactor.core.publisher.Mono;
import java.util.Arrays; import java.util.List;
@Component @Slf4j public class LogGatewayFilterFactory extends AbstractGatewayFilterFactory<LogGatewayFilterFactory.Config> {
public LogGatewayFilterFactory() { super(LogGatewayFilterFactory.Config.class); }
@Override public GatewayFilter apply(Config config) { return new GatewayFilter() { @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { if (config.getConsoleLog()) { log.info(">>>>>>>>>>>>>>>> 控制台日志开启!"); } if (config.getCacheLog()) { log.info(">>>>>>>>>>>>>>>>>缓存开启!"); } return chain.filter(exchange); } }; }
@Override public List<String> shortcutFieldOrder() { return Arrays.asList("consoleLog", "cacheLog"); }
@Validated public static class Config{ private Boolean consoleLog; private Boolean cacheLog;
public Boolean getConsoleLog() { return consoleLog; }
public void setConsoleLog(Boolean consoleLog) { this.consoleLog = consoleLog; }
public Boolean getCacheLog() { return cacheLog; }
public void setCacheLog(Boolean cacheLog) { this.cacheLog = cacheLog; } } }
|
全局过滤器
全局过滤器作用于所有路由, 无需配置。通过全局过滤器可以实现对权限的统一校验,安全性验证等功 能。
内置全局过滤器
SpringCloud Gateway内部也是通过一系列的内置全局过滤器对整个路由转发进行处理如下:
自定义全局过滤器
内置的过滤器已经可以完成大部分的功能,但是对于企业开发的一些业务功能处理,还是需要我们 自己编写过滤器来实现的,那么我们一起通过代码的形式自定义一个过滤器,去完成统一的权限校验。
开发中的鉴权逻辑:
- 当客户端第一次请求服务时,服务端对用户进行信息认证(登录)
- 认证通过,将用户信息进行加密形成token,返回给客户端,作为登录凭证
- 以后每次请求,客户端都携带认证的token
- 服务端对token进行解密,判断是否有效。
如上图,对于验证用户是否已经登录鉴权的过程可以在网关统一检验。
检验的标准就是请求中是否携带token凭证以及token的正确性。
下面的我们自定义一个GlobalFilter,去校验所有请求的请求参数中是否包含“token”,如何不包含请求
参数“token”则不转发路由,否则执行正常的逻辑。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
|
@Component @Slf4j public class AuthGlobalFilter implements GlobalFilter, Ordered {
private final String ACCESS_TOKEN = "ACCESS_TOKEN";
@Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { HttpHeaders headers = exchange.getRequest().getHeaders(); if (!headers.containsKey(ACCESS_TOKEN)) { log.error("请求没有权限!"); exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED); return exchange.getResponse().setComplete(); } return chain.filter(exchange); }
@Override public int getOrder() { return 0; } }
|
网关限流
网关是所有请求的公共入口,所以可以在网关进行限流,而且限流的方式也很多,我们本次采用前 面学过的Sentinel组件来实现网关的限流。Sentinel支持对SpringCloud Gateway、Zuul等主流网关进 行限流。
从1.6.0版本开始,Sentinel提供了SpringCloud Gateway的适配模块,可以提供两种资源维度的限流:
- route维度:即在Spring配置文件中配置的路由条目,资源名为对应的routeId
- 自定义API维度:用户可以利用Sentinel提供的API来自定义一些API分组
导入依赖
1 2 3 4 5
| <dependency> <groupId>com.alibaba.csp</groupId> <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId> </dependency>
|
编写配置类
基于Sentinel 的Gateway限流是通过其提供的Filter来完成的,使用时只需注入对应的 SentinelGatewayFilter
实例以及 SentinelGatewayBlockExceptionHandler
实例即可。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
|
@Configuration public class GatewayConfiguration {
private final List<ViewResolver> viewResolvers;
private final ServerCodecConfigurer serverCodecConfigurer;
public GatewayConfiguration(List<ViewResolver> viewResolvers, ServerCodecConfigurer serverCodecConfigurer) { this.viewResolvers = viewResolvers; this.serverCodecConfigurer = serverCodecConfigurer; }
@Bean @Order(Ordered.HIGHEST_PRECEDENCE) public GlobalFilter sentinelGatewayFilter() { return new SentinelGatewayFilter(); }
@PostConstruct public void initGatewayRules() { Set<GatewayFlowRule> rules = new HashSet<>(); rules.add( new GatewayFlowRule("shop-product") .setCount(1) .setIntervalSec(1)
); GatewayRuleManager.loadRules(rules); }
@Bean @Order(Ordered.HIGHEST_PRECEDENCE) public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() { return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer); }
@PostConstruct public void initBlockHandlers() { BlockRequestHandler blockRequestHandler = new BlockRequestHandler() { @Override public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) { Map<String, Object> resultMap = new HashMap<>(2); resultMap.put("code", 0); resultMap.put("message", "接口被限流"); return ServerResponse.status(HttpStatus.OK) .contentType(MediaType.APPLICATION_JSON_UTF8) .body(BodyInserters.fromObject(resultMap)); } }; GatewayCallbackManager.setBlockHandler(blockRequestHandler); }
}
|
测试
在一秒钟内多次访问http://localhost:7000/shop-product-server/product/info/1?age=30就可以看到限流启作用了。
自定义API分组
自定义API分组是一种更细粒度的限流规则定义
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
|
@PostConstruct public void initGatewayRules() { Set<GatewayFlowRule> rules = new HashSet<>(); rules.add(new GatewayFlowRule("product_api1").setCount(1).setIntervalSec(1)); rules.add(new GatewayFlowRule("product_api2").setCount(1).setIntervalSec(1)); GatewayRuleManager.loadRules(rules); }
@PostConstruct private void initCustomizedApis() { Set<ApiDefinition> definitions = new HashSet<>(); ApiDefinition api1 = new ApiDefinition("product_api1") .setPredicateItems(new HashSet<ApiPredicateItem>() {{ add(new ApiPathPredicateItem().setPattern("/product- serv/product/api1/**"). setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX)); }}); ApiDefinition api2 = new ApiDefinition("product_api2") .setPredicateItems(new HashSet<ApiPredicateItem>() {{ add(new ApiPathPredicateItem().setPattern("/product- serv/product/api2/demo1")); }}); definitions.add(api1); definitions.add(api2); GatewayApiDefinitionManager.loadApiDefinitions(definitions); }
|