spring cloud gateway (五)

Gateway简介

Spring Cloud Gateway是Spring公司基于Spring 5.0，Spring Boot 2.0 和 Project Reactor 等技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。它的目标是替代Netflix Zuul，其不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如：安
全，监控和限流。
优点：
1 性能强劲：是第一代网关Zuul的1.6倍
2 功能强大：内置了很多实用的功能，例如转发、监控、限流等
3 设计优雅，容易扩展
缺点：
1 其实现依赖Netty与WebFlux，不是传统的Servlet编程模型，学习成本高
2 不能将其部署在Tomcat、Jetty等Servlet容器里，只能打成jar包执行
3 需要Spring Boot 2.0及以上的版本，才支持

Gateway

 		<!-- SpringCloud Alibaba Sentinel Gateway -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
        </dependency>

spring:
  redis:
    host: localhost
    port: 6379
    password:
  cloud:
    gateway:
      discovery:
        locator:
          lowerCaseServiceId: true
          enabled: true # 让gateway可以发现nacos中的微服务
      routes:# 路由数组[路由 就是指定当请求满足什么条件的时候转到哪个微服务
        # 认证中心
        - id: com-xzx-auth # 当前路由的标识, 要求唯一
          #lb指的是从nacos中按照名称获取微服务,并遵循负载均衡策略
          uri: lb://com-xzx-auth  # 请求要转发到的地址
          predicates: # 断言(就是路由转发要满足的条件)
            - Path=/service-auth/** # 当请求路径满足Path指定的规则时,才进行路由转发
          filters: # 当请求路径满足Path指定的规则时,才进行路由转发
            - StripPrefix=1 # 转发之前去掉1层路径

        # 商品中心
        - id: com-xzx-shop
          uri: lb://com-xzx-shop 
          predicates:
            - Path=/service-shop/**
          filters:
            - StripPrefix=1
        # 工单
        - id: com-xzx-order
          uri: lb://com-xzx-order
          predicates:
            - Path=/service-order/**
          filters:
            - StripPrefix=1
        # 用户中心
        - id: com-xzx-user
          uri: lb://com-xzx-user
          predicates:
            - Path=/service-user/**
          filters:
            - LogGatewayFilterFactory=true,true
            - StripPrefix=1
# 安全配置
security:
  # 不校验白名单
  ignore:
    whites:
      - /service-auth/auth/logout
      - /service-auth/auth/login
      - /service-auth/auth/login/test
      - /service-auth/auth/register

Gateway 内置有许多的路由断言

基于Datetime类型的断言工厂

此类型的断言根据时间做判断，主要有三个：
AfterRoutePredicateFactory： 接收一个日期参数，判断请求日期是否晚于指定日期
BeforeRoutePredicateFactory： 接收一个日期参数，判断请求日期是否早于指定日期
BetweenRoutePredicateFactory： 接收两个日期参数，判断请求日期是否在指定时间段内
-After=2019-12-31T23:59:59.789+08:00[Asia/Shanghai]

基于远程地址的断言工厂 RemoteAddrRoutePredicateFactory：接收一个IP地址段，判断请求主机地址是否在地址段中

-RemoteAddr=192.168.1.1/24

基于Cookie的断言工厂

CookieRoutePredicateFactory：接收两个参数，cookie 名字和一个正则表达式。 判断请求
cookie是否具有给定名称且值与正则表达式匹配。
-Cookie=chocolate, ch.

基于Header的断言工厂

HeaderRoutePredicateFactory：接收两个参数，标题名称和正则表达式。 判断请求Header是否
具有给定名称且值与正则表达式匹配。
-Header=X-Request-Id, \d+

基于Host的断言工厂

HostRoutePredicateFactory：接收一个参数，主机名模式。判断请求的Host是否满足匹配规则。
-Host=**.testhost.org

基于Method请求方法的断言工厂

MethodRoutePredicateFactory：接收一个参数，判断请求类型是否跟指定的类型匹配。
-Method=GET

基于Path请求路径的断言工厂

PathRoutePredicateFactory：接收一个参数，判断请求的URI部分是否满足路径规则。
-Path=/foo/{segment}

基于Query请求参数的断言工厂

QueryRoutePredicateFactory ：接收两个参数，请求param和正则表达式， 判断请求参数是否具
有给定名称且值与正则表达式匹配。
-Query=baz, ba.

基于路由权重的断言工厂

WeightRoutePredicateFactory：接收一个[组名,权重], 然后对于同一个组内的路由按照权重转发
routes:
-id: weight_route1 uri: host1 predicates:
-Path=/product/**
-Weight=group3, 1
-id: weight_route2 uri: host2 predicates:
-Path=/product/**
-Weight= group3, 9

gateway自定义断言

//泛型 用于接收一个配置类,配置类用于接收中配置文件中的配置
    @Component
    public class AgeRoutePredicateFactory extends AbstractRoutePredicateFactory<AgeRoutePredicateFactory.Config> {
        public AgeRoutePredicateFactory() {
            super(AgeRoutePredicateFactory.Config.class);
        }
        //用于从配置文件中获取参数值赋值到配置类中的属性上
        @Override
        public List<String> shortcutFieldOrder() {
            //这里的顺序要跟配置文件中的参数顺序一致
            return Arrays.asList("minAge", "maxAge");
        }
        //断言
        @Override
        public Predicate<ServerWebExchange> apply(AgeRoutePredicateFactory.Config
                                                          config) {
            return new Predicate<ServerWebExchange>() {
                @Override
                public boolean test(ServerWebExchange serverWebExchange) {
                    String ageStr =
                            serverWebExchange.getRequest().getQueryParams().getFirst("age");
                    if (StringUtils.isNotEmpty(ageStr)) {
                        int age = Integer.parseInt(ageStr);
                        return age > config.getMinAge() && age < config.getMaxAge();
                    }
                    return true;
                }
            };
        }
    }
    //自定义一个配置类, 用于接收配置文件中的参数
    @Data
    class Config {
        private int minAge;
        private int maxAge;
    }
# 自定义断言使用
routes:
- id: product-route
uri: lb://service-product
predicates:
- Path=/product-serv/**
- Age=18,60  # 限制年龄只有在18到60岁之间的人能访问
filters:
- StripPrefix=1

gateway 过滤器

gateway 过滤器分局部过滤器和全局过滤器，局部过滤要配置在具体的路由下，全局过滤器则对所有路由生效 全局过滤器可用来进行网关鉴权

/**
	全局过滤器
 * 网关鉴权
 */
@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    private static final Logger log = LoggerFactory.getLogger(AuthFilter.class);
	//网关放行白名单
    private IgnoreWhiteProperties whiteProperties;
    private RedisService redisService;

    @Autowired
    public AuthGlobalFilter(RedisService redisService,IgnoreWhiteProperties whiteProperties){
        this.redisService = redisService;
        this.whiteProperties = whiteProperties;
    }


    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest serverHttpRequest = exchange.getRequest();
        ServerHttpRequest.Builder mutate = serverHttpRequest.mutate();

        String url = serverHttpRequest.getURI().getPath();
        //跳过不需要验证的路径
        if (match(url,whiteProperties.getWhites())){
            return chain.filter(exchange);
        }
        String token = getToken(serverHttpRequest);
        if (StringUtils.isEmpty(token)){
            return unauthorizedResponse(exchange,"令牌不能为空");
        }
        Claims claims = JWTUtils.parseToken(token);
        if (Objects.isNull(claims)){
            return unauthorizedResponse(exchange,"令牌过期或者不正确");
        }
        String userKey = JWTUtils.getUserKey(claims);
        Boolean isLogin = redisService.hasKey(getTokenKey(userKey));
        if (!isLogin){
            return unauthorizedResponse(exchange,"登陆状态已过期");
        }
        String userId = JWTUtils.getUserId(claims);
        String username = JWTUtils.getUsername(claims);
        if (StringUtils.isEmpty(userId) || StringUtils.isEmpty(username)){
            return unauthorizedResponse(exchange,"令牌验证失败");
        }
        addHeader(mutate,"user_key",userKey);
        addHeader(mutate,"user_id",userId);
        addHeader(mutate,"username",username);

        //内部请求来源参数清除
        removerHeader(mutate,"from-source");
        return chain.filter(exchange.mutate().request(mutate.build()).build());
    }

    private void removerHeader(ServerHttpRequest.Builder mutate, String name) {
        mutate.headers(httpHeaders -> httpHeaders.remove(name)).build();
    }

    private void addHeader(ServerHttpRequest.Builder mutate, String key, Object value) {
        if (Objects.isNull(value)){
            return;
        }
        String valueString = value.toString();
        String valueEncode = ServletUtils.urlEncode(valueString);
        mutate.header(key,valueEncode);
    }

    private String getTokenKey(String userKey) {
        return "login_tokens:" + userKey;
    }

    private Mono<Void> unauthorizedResponse(ServerWebExchange exchange, String msg) {
        log.error("[鉴权异常处理]请求路径{}",exchange.getRequest().getPath());
        return ServletUtils.webFluxResponseWriter(exchange.getResponse(),msg,401);
    }

    private String getToken(ServerHttpRequest serverHttpRequest) {
        String token = serverHttpRequest.getHeaders().getFirst("Authorization");
        if (StringUtils.isNotEmpty(token) && token.startsWith("Bearer")){
            token = token.replaceFirst("Bearer","");
        }
        return token;
    }

    @Override
    public int getOrder() {
        return 0;
    }


    private Boolean match(String url,List<String> whiteList){
        if (StringUtils.isEmpty(url) || CollectionUtils.isEmpty(whiteList)){
            return false;
        }
        for (String whiteUrl : whiteList) {
            if (isMatch(url,whiteUrl)){
                return true;
            }
        }
        return false;
    }

    private Boolean isMatch(String url,String whiteUrl){
        AntPathMatcher matcher = new AntPathMatcher();
        return matcher.match(url,whiteUrl);
    }
}

局部过滤器

@Component
public class LogGatewayFilterFactory extends AbstractGatewayFilterFactory<LogGatewayFilterFactory.Config> {

    @Override
    public String name() {
    	//重写name方法 这里就是配置中的名字，如果不重写 配置中就写Gateway前的 也就是log
        return "LogGatewayFilterFactory";
    }

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

    /**
     * 读取配置文件中的参数 赋值到 配置类中
     * @return
     */
    @Override
    public List<String> shortcutFieldOrder() {
    	// 会把配置中的值赋值到 Config中
        return Arrays.asList("consoleLog","cacheLog");
    }

    @Override
    public GatewayFilter apply(LogGatewayFilterFactory.Config config) {
        return (exchange, chain) -> {
            if (config.isCacheLog()){
                System.out.println("缓存日志开启");
            }
            if (config.isConsoleLog()){
                System.out.println("控制台日志开启");
            }
            return chain.filter(exchange);
        };
    }

	//接收配置中的参数
    public static class Config{
        private boolean consoleLog;
        private boolean cacheLog;

        public boolean isConsoleLog() {
            return consoleLog;
        }

        public void setConsoleLog(boolean consoleLog) {
            this.consoleLog = consoleLog;
        }

        public boolean isCacheLog() {
            return cacheLog;
        }

        public void setCacheLog(boolean cacheLog) {
            this.cacheLog = cacheLog;
        }
    }
}
## 配置
filters:
  - LogGatewayFilterFactory=true,true
  - StripPrefix=1

gateway 统一异常处理

/**
 * 网关统一异常处理
 */
@Configuration
@Order(-1)
public class GatewayExceptionHandle implements ErrorWebExceptionHandler {

    private static final Logger log = LoggerFactory.getLogger(GatewayExceptionHandle.class);

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
        ServerHttpResponse response = exchange.getResponse();
        if (exchange.getResponse().isCommitted()){
            //响应已经提交到客户端
            return Mono.error(ex);
        }
        String msg;
        if (ex instanceof NotFoundException){
            msg = "服务未找到";
        }else if (ex instanceof ResponseStatusException){
            ResponseStatusException responseStatusException = (ResponseStatusException) ex;
            msg = responseStatusException.getMessage();
        }else {
            msg = "内部服务器错误";
        }
        log.error("[网关异常处理]请求路径：{},异常信息：{}",exchange.getRequest().getPath(),ex.getMessage());
        return ServletUtils.webFluxResponseWriter(response,msg);
    }
}

gateway依赖WebFlux所以要学习下WebFlux
WebFlux