spingcloud(8) gateway

一。简介

springcloud是第二代网关，取代zuul网关。具有强大的智能路由，过滤器功能。常见的功能有路由转发、权限校验、限流控制等作用

Spring Cloud Gateway 具有如下特性：

基于Spring Framework 5, Project Reactor 和 Spring Boot 2.0 进行构建；
动态路由：能够匹配任何请求属性；
可以对路由指定 Predicate（断言）和 Filter（过滤器）；
集成Hystrix的断路器功能；
集成 Spring Cloud 服务发现功能；
易于编写的 Predicate（断言）和 Filter（过滤器）；
请求限流功能；
支持路径重写。

After Route Predicate Factory

可配置在指定时间后的请求，都交给router处理。否则不通过路由

server:
  port: 8081
spring:
  profiles:
    active: add_request_header_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: after_route
          uri: http://httpbin.org:80/get #前面的路径替换为该值即http://xxx:8081这段
          filters: #增加请求header的过滤器
            - AddRequestHeader=X-Request-Foo, Bar
          predicates:
            - After=2017-01-20T17:42:47.789-07:00[America/Denver]
  profiles: add_request_header_route

启动工程，在浏览器上访问http://localhost:8081/，会显示http://httpbin.org:80/get返回的结果，此时gateway路由到了配置的uri。

Header Route Predicate Factory

Header Route Predicate Factory需要两个参数，header名称和值，当断言匹配了请求中的header名称和值后，断言通过，就能进入路由规则

spring:
  profiles:
    active: header_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: header_route
          uri: https://www.baidu.com
          predicates:
            - Header=X-Request-Id, d+ #当请求的Header中有X-Request-Id的header名，且header值为数字时
  profiles: header_route

测试：

curl -H "X-Request-Id:1" localhost:8081

返回页面请求就通过了，404则没有通过

spring:
  profiles:
    active: cookie_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: cookie_route
          uri: http://httpbin.org:80/get
          predicates:
            - Cookie=name, yy
  profiles: cookie_route

请求带有cookie名称为name，值为yy就能通过，被转发到http://httpbin.org:80/get

测试

curl -H "Cookie:name=forezp" localhost:8081

Host Route Predicate Factory

需要以一个参数即hostname,会匹配请求头中的host值，匹配则转发

spring:
  profiles:
    active: host_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: host_route
          uri: http://httpbin.org:80/get
          predicates:
            - Host=**.yy.com
  profiles: host_route

测试：curl -H "Host:www.fangzhipeng.com" localhost:8081

Method Route Predicate Factory

需要一个参数请求类型，GET

spring:
  profiles:
    active: method_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: method_route
          uri: http://httpbin.org:80/get
          predicates:
            - Method=GET
  profiles: method_route

测试：curl localhost:8081

模拟POST请求：curl -XPOST localhost:8081

Path Route Predicate Factory

需要一个参数匹配路径

spring:
  profiles:
    active: path_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: path_route
          uri: http://localhost:9600/
          predicates: 
            - Path=/hello
  profiles: path_route

Query Route Predicate Factory

需要两个参数，参数名和参数值，也可以只有一个参数即参数名

spring:
  profiles:
    active: query_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: query_route
          uri: http://httpbin.org:80/get
          predicates:
            - Query=foo, ba.
  profiles: query_route

测试：curl localhost:8081?foo=bar

Predict作为断言，它决定了请求会被路由到哪个router 中。在断言之后，请求会被进入到filter过滤器的逻辑

2.filter实战

确定哪个路由执行后，在路由处理之前，先经过”pre“类型的过滤器，路由处理后，经过”post“类型的过滤器

”pre“类型的过滤器可以做参数校验，权限校验，流量监控，日志输出，协议转换等

”post“类型的过滤器可以做响应内容，响应头修改，日志输出，流量监控等。

springcloud包含许多内置的GatewayFilter工厂，和predicate一样配置在application.yml，遵循了约定大于配置的原则，只需要配置filter工厂的名称，不需要配置全类名。

比如AddRequestHeaderGatewayFilterFactory只需要在配置文件中写AddRequestHeader，而不是全部类名

AddRequestHeader GatewayFilter Factory

server:
  port: 8081
spring:
  profiles:
    active: add_request_header_route #指定配置文件
---
spring:
  cloud:
    gateway:
      routes:
      - id: add_request_header_route
        uri: http://httpbin.org:80/get
        filters:
        - AddRequestHeader=X-Request-Foo, Bar #AddRequestHeaderGatewayFilterFactory
        predicates:
        - After=2017-01-20T17:42:47.789-07:00[America/Denver] #AfterPredictFactory
  profiles: add_request_header_route

模拟请求：curl localhost:8081

最终显示了从 http://httpbin.org:80/get得到了请求，响应如下：

{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Connection": "close",
    "Forwarded": "proto=http;host="localhost:8081";for="0:0:0:0:0:0:0:1:56248"",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.58.0",
    "X-Forwarded-Host": "localhost:8081",
    "X-Request-Foo": "Bar"
  },
  "origin": "0:0:0:0:0:0:0:1, 210.22.21.66",
  "url": "http://localhost:8081/get"
}

从响应知道，请求头中加入了 "X-Request-Foo": "Bar"

RewritePath GatewayFilter Factory

重写路径的功能，类似nginx的功能

spring:
  profiles:
    active: rewritepath_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: rewritepath_route
          uri: http://localhost:9600/
          predicates:
            - Path=/foo/**
          filters: #将/foo/(?.*)重写为{segment}，然后转发
            - RewritePath=/foo/(?<segment>.*), /${segment}
  profiles: rewritepath_route

比如在网页上请求localhost:8081/foo/forezp，此时会将请求转发到https://blog.csdn.net/forezp的页面

Hystrix GatewayFilter

允许将断路器功能添加到网关中，使服务免受级联故障？？这个如何实现？？，提供服务降级处理

pom.xml增加hystrix

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

增加服务降级处理类

@RestController
public class FallbackController {

    @GetMapping("/fallback")
    public Object fallback() {
        Map<String,Object> result = new HashMap<>();
        result.put("data",null);
        result.put("message","Get request fallback!");
        result.put("code",500);
        return result;
    }
}

在application-filter.yml中添加相关配置，当路由出错时会转发到服务降级处理的控制器上：

spring:
  cloud:
    gateway:
      routes:
        - id: hystrix_route
          uri: http://localhost:9600
          predicates:
            - Method=GET
          filters:
            - name: Hystrix
              args:
                name: fallbackcmd
                fallbackUri: forward:/fallback

访问http://localhost:8081/user转发到http://localhost:9600/user, 404错误转发到服务降级处理的控制器上，返回降级处理的信息

现在yml中配置测试不行，在java bean中配置可以返回

@Bean
    public RouteLocator myRoutes(RouteLocatorBuilder builder){
        String httpUri = "http://httpbin.org:80";
        return builder.routes()  //route来做断言
                .route(p -> p
                  .host("*.hystrix.com")
                  .filters(f->f.hystrix(config -> config
                            .setName("mycmd")
                            .setFallbackUri("forward:/fallback")))
                  .uri(httpUri))
                .build();
    }

测试： curl -H "Host:www.hystrix.com" localhost:8081?token=1
返回： {"code":500,"data":null,"message":"Get request fallback!"}

自定义过滤器

springcloud内置了19种过滤器工厂，也可以自动逸过滤器。在spring Cloud Gateway中，过滤器需要实现GatewayFilter和Ordered2个接口

/**
 * 自定义实现过滤器
 */
public class RequestTimeFilter implements GatewayFilter, Ordered {
    private static final Log log = LogFactory.getLog(RequestTimeFilter.class);
    private static final String REQUEST_TIME_BEGIN = "reqTimeBegin";
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 操作前执行
        exchange.getAttributes().put(REQUEST_TIME_BEGIN, System.currentTimeMillis());
        return chain.filter(exchange).then(
                // 操作后执行
                Mono.fromRunnable(()->{
                    Long startTime = exchange.getAttribute(REQUEST_TIME_BEGIN);
                    if(startTime!=null){
                        log.info(exchange.getRequest().getURI().getRawPath() + ":" + (System.currentTimeMillis() - startTime) + "ms");
                    }
                }));
    }

    /**
     * 给过滤器设定优先级别的，值越大则优先级越低
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
}

java中配置路由，使用自定义RequestTimeFilter

 @Bean
    public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) {
        // @formatter:off
        return builder.routes()
                .route(r -> r.path("/customer/**")
                        .filters(f -> f.filter(new RequestTimeFilter())
                                .addResponseHeader("X-Response-Default-Foo", "Default-Bar"))
                        .uri("http://httpbin.org:80/get")
                        .order(0)
                        .id("customer_filter_router")
                )
                .build();
        // @formatter:on
    }

测试：curl localhost:8081/customer/123

控制台输出请求时间的日志：

2020-10-14 22:17:48.528 INFO 107912 --- [ctor-http-nio-8] com.yy.gateway.RequestTimeFilter : /customer:28ms

自定义过滤器工厂

这样就能在配置文件中配置，自定义过滤器了

public class RequestTimeGatewayFilterFactory extends AbstractGatewayFilterFactory<RequestTimeGatewayFilterFactory.Config> {
    private static final Log log = LogFactory.getLog(RequestTimeGatewayFilterFactory.class);
    private static final String REQUEST_TIME_BEGIN = "requestTimeBegin";
    private static final String KEY = "withParams";

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList(KEY); //给config传参
    }

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

    @Override
    public GatewayFilter apply(Config config) {
        return ((exchange, chain) -> {
// 操作前执行
            exchange.getAttributes().put(REQUEST_TIME_BEGIN, System.currentTimeMillis());
            return chain.filter(exchange).then(
                    // 操作后执行
                    Mono.fromRunnable(()->{
                        Long startTime = exchange.getAttribute(REQUEST_TIME_BEGIN);
                        if(startTime!=null){
                            StringBuilder sb = new StringBuilder(exchange.getRequest().getURI().getRawPath())
                                    .append(":")
                                    .append(System.currentTimeMillis() - startTime)
                                    .append("ms");
                            if(config.isWithParams()){
                                sb.append("params:").append(exchange.getRequest().getQueryParams());
                            }
                            System.out.println(sb.toString());
                            log.info(sb.toString());
                        }
                    }));
        });
    }

    /**
     * 接收filter参数
     */
    public static class Config{
        private boolean withParams;

        public boolean isWithParams() {
            return withParams;
        }

        public void setWithParams(boolean withParams) {
            this.withParams = withParams;
        }
    }
}

静态内部类类Config就是为了接收参数的，里边的变量名可以随意写，但是要重写List shortcutFieldOrder()这个方法‘

注册RequestTimeGatewayFilterFactory bean

    @Bean
    public RequestTimeGatewayFilterFactory elapsedGatewayFilterFactory() {
        return new RequestTimeGatewayFilterFactory();
    }

application.yml 增加配置

spring:
  profiles:
    active: elapse_route
---
spring:
  cloud:
    gateway:
      routes:
        - id: elapse_route
          uri: http://httpbin.org:80/get #前面的路径替换即http://xxx:8081这段
          filters: #增加自定义Factory的filter
            - RequestTime=true
          predicates:
            - Method=GET
  profiles: elapse_route

测试：curl localhost:8081/customer/123

控制台输出请求时间的日志

global filter

全局过滤器，不用在配置文件中配置，作用在所有路由上

自定义全局路由，不包含token的请求不转发，需要实现GlobalFilter和Ordered接口

/**
 * 全局过滤器，如果不包含token参数直接返回不路由
 */
public class TokenGlobalFilter implements GlobalFilter, Ordered {
    private static final Log log = LogFactory.getLog(TokenGlobalFilter.class);
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getQueryParams().getFirst("token");
        if(token == null || token.isEmpty()){
            log.info("token is empty");
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -100;
    }
}

注入到容器

/**
     * 将自定义全局过滤器注入到IOC容器
     * @return
     */
    @Bean
    public TokenGlobalFilter tokenGlobalFilter(){
        return new TokenGlobalFilter();
    }

测试： curl localhost:8081

控制台打印日志：2020-10-14 22:29:50.985 INFO 107912 --- [ctor-http-nio-2] com.yy.gateway.TokenGlobalFilter : token is empty

Spring Cloud Gateway限流

RequestRateLimiterGatewayFilterFactory这个类，RequestRateLimiter 过滤器可以用于限流，使用RateLimiter实现来确定是否允许当前请求继续进行，如果请求太大默认会返回HTTP 429-太多请求状态。使用Redis和lua脚本实现了令牌桶的方式

pom.xml引入redis依赖

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

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifatId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

application.yml

---
spring:
  cloud:
    gateway:
      routes:
        - id: limit_route
          uri: http://localhost:9600/ #前面的路径替换即http://xxx:8081这段
          predicates:
            - Method=GET
          filters:
            - name: RequestRateLimiter
              args:
                key-resolver: "#{@hostAddrKeyResolver}" #用于限流的键的解析器的 Bean 对象的名字。它使用 SpEL 表达式根据#{@beanName}从 Spring 容器中获取 Bean 对象
                redis-rate-limiter.replenishRate: 1 # 令牌桶每秒填充平均速率, 即平均访问速率每秒
                redis-rate-limiter.burstCapacity: 2 #令牌桶总容量 即每秒最大访问速率
  profiles: limit_route
  redis:
    host: 192.168.31.211
    port: 6379

KeyResolver需要实现resolve方法，比如根据Hostname进行限流，则需要用hostAddress去判断。实现完KeyResolver之后，需要将这个类的Bean注册到Ioc容器中。

/**
 * 根据Hostname进行限流，则需要用hostAddress去判断
 */
public class HostAddrKeyResolver implements KeyResolver {
    Log log = LogFactory.getLog(HostAddrKeyResolver.class);
    @Override
    public Mono<String> resolve(ServerWebExchange exchange) {return Mono.just(exchange.getRequest().getRemoteAddress().getHostName());
    }
}

@Bean
    public HostAddrKeyResolver hostAddrKeyResolver(){
        return new HostAddrKeyResolver();
    }

多次访问http://localhost:8081,会返回429错误

可以用其他维度限流，例如用户维度

    @Bean
    KeyResolver userKeyResolver(){
        return exchange -> Mono.just(exchange.getRequest().getQueryParams().getFirst("user"));
    }

三。服务的注册与发现

上面都是用硬编码方式进行路由转发，gateway可以配合注册中心进行路由转发

pom.xml

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