SpringCloud Gateway之filter

川长思鸟来 2023-06-28 11:10 11阅读 0赞

接上一篇：[SpringCloud Gateway之路由规则][SpringCloud Gateway]

Predict决定了请求由哪一个路由处理，在路由处理之前，需要经过“pre”类型的过滤器处理，处理返回响应之后，可以由“post”类型的过滤器处理。在“pre”类型的过滤器可以做参数校验、权限校验、流量监控、日志输出、协议转换等，在“post”类型的过滤器中可以做响应内容、响应头的修改，日志的输出，流量监控等。  
如下图所示，客户端的请求先经过“pre”类型的filter，然后将请求转发到具体的业务服务，比如上图中的user-service，收到业务服务的响应之后，再经过“post”类型的filter处理，最后返回响应到客户端。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70]  
Spring Cloud Gateway的Filter分为两种：GatewayFilter 与 GlobalFilter。GlobalFilter会应用到所有的路由上，而GatewayFilter将应用到单个路由或者一个分组的路由上。

### Gateway filter ###

GatewayFilter工厂可以在配置文件application.yml中配置，遵循了约定大于配置的思想，只需要在配置文件配置GatewayFilter Factory的名称，而不需要写全部的类名，比如AddRequestHeaderGatewayFilterFactory只需要在配置文件中写AddRequestHeader，而不是全部类名。在配置文件中配置的GatewayFilter Factory最终都会相应的过滤器工厂类处理。  
Spring Cloud Gateway包含许多内置的GatewayFilter工厂，如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 1]  
下面讲述几个常见的过滤器工厂：

#### 1 AddRequestHeader GatewayFilter Factory ####

##### 1.1 yml配置 #####

server:
      port: 8080
    spring:
      application:
        name: test-GATEWAY
      cloud:
        gateway:
          routes:
          - id: test-route
            uri: http://httpbin.org:80/get
            predicates:
              - After=2020-01-09T00:00:00+08:00[Asia/Shanghai]
            filters:
              - AddRequestHeader=Test,gateway

##### 1.2 分析并查看结果 #####

在上述配置中，配置了router的id为test-route，路由地址为http://httpbin.org:80/get，该router有AfterPredictFactory，有一个filter为AddRequestHeaderGatewayFilterFactory(约定写成AddRequestHeader)，AddRequestHeader过滤器工厂会在请求头加上一对请求头，名称为Test，值为gateway。我们在浏览器中输入：http://localhost:8080/get，得到如下：

{ 
        "args": { },
        "headers": { 
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
            "Accept-Encoding": "gzip, deflate, br",
            "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8,de;q=0.7",
            "Cache-Control": "max-age=0",
            "Cookie": "Hm_lvt_510ed80f0be980f190b7bfc3a27fabd9=1556184289; Hm_lvt_3242ee7ea9b8b5d0e409bb74bc4e0091=1556184289; Phpstorm-d6b3462e=aa37f591-2c2c-49d9-9293-479590c634c0; Idea-8bd2b531=a445ac7e-83b1-496c-baaa-96bc8d5cee14",
            "Forwarded": "proto=http;host=\"localhost:8080\";for=\"0:0:0:0:0:0:0:1:56947\"",
            "Host": "httpbin.org",
            "Sec-Fetch-Mode": "navigate",
            "Sec-Fetch-Site": "none",
            "Sec-Fetch-User": "?1",
            "Test": "gateway",
            "Upgrade-Insecure-Requests": "1",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36",
            "X-Forwarded-Host": "localhost:8080"
        },
        "origin": "0:0:0:0:0:0:0:1, 139.199.106.7, ::1",
        "url": "https://localhost:8080/get"
    }

在上述响应结果中，确实在请求头中加入了Test这样的一个请求头，在配置文件中配置的AddRequestHeader过滤器工厂生效。

#### 2 RewritePath GatewayFilter Factory ####

##### 2.1 yml配置 #####

server:
      port: 8080
    spring:
      application:
        name: test-GATEWAY
      cloud:
        gateway:
          routes:
          - id: test-route
            uri: https://blog.csdn.net/
            predicates:
              - Path=/sso/**
            filters:
              - RewritePath=/sso/(?<segment>.*),/$\{ segment}

##### 2.2 分析并查看结果 #####

上面的配置中，所有的/sso/\*\*开始的路径都会命中配置的router，并执行过滤器的逻辑，在本案例中配置了RewritePath过滤器工厂，此工厂将/sso/(?.\*)重写为\{segment\}，然后转发到https://blog.csdn.net。比如在网页上请求localhost:8080/sso/mameng1988，此时会将请求转发到https://blog.csdn.net/mameng1988的页面。

### 自定义过滤器 ###

Spring Cloud Gateway内置了19种过滤器工厂，可以满足大部分场景，但我们也可以自定义过滤器。在Spring Cloud Gateway中，我们实现GatewayFilter和Ordered2个接口就可以自定义过滤器了，下面我们写一个

import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.cloud.gateway.filter.GatewayFilter;
    import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    import org.springframework.core.Ordered;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Mono;
    
    /** * @author by mazhen * @Classname CustomerFilter * @Description TODO * @Date 2020/1/11 22:22 */
    @Component
    public class CustomerFilter implements GatewayFilter, Ordered { 
    
        private static final Logger logger = LoggerFactory.getLogger(CustomerFilter.class);
        private static final String REQUEST_START_TIME = "Start_time";
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            exchange.getAttributes().put(REQUEST_START_TIME,System.currentTimeMillis());
            return chain.filter(exchange).then(
                    Mono.fromRunnable(
                            () -> { 
                                Long startTime = exchange.getAttribute(REQUEST_START_TIME);
                                if (null != startTime) { 
                                    logger.info(exchange.getRequest().getURI().getRawPath() + ": " 
                                    + (System.currentTimeMillis() - startTime) + "ms");
                                }
                            }
                    )
            );
        }
    
        @Override
        public int getOrder() { 
            return 0;
        }
    }

在上面的代码中，Ordered中的getOrder()方法是来给过滤器设定优先级的，值越大则优先级越低。还有一个filter(exchange,chain)方法，在该方法中，先记录了请求的开始时间，并保存在ServerWebExchange中，此处是一个“pre”类型的过滤器，然后再chain.filter的内部类中的run()方法中相当于"post"过滤器，在此处打印了请求所消耗的时间。然后将该过滤器注册到router中，代码如下：

@Bean
        public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) { 
            // @formatter:off
            return builder.routes()
                    .route(r -> r.path("/sso/**")
                            .filters(f -> f.filter(new CustomerFilter()))
                            .uri("lb://test-SSO")
                            .order(0)
                            .id("customer_filter_router")
                    )
                    .build();
            // @formatter:on
        }

重启服务，通过浏览器输入：http://localhost:8080/sso/test  
在服务的控制台输出一下的请求信息的日志：

[20200111 22:53:52][INFO ][appKey=IAM-GATEWAY][traceId=][SpanId=] c.c.i.g.c.CustomerFilter [reactor-http-nio-4] 
    [CustomerFilter  ][32 ] - /sso/test: 2514ms

由于自定义过滤器无法在配置文件中配置，而自定义过滤器工厂是可以的，下面我们实现一个过滤器工厂。

### 自定义过滤器工厂 ###

在实现自定义过滤器工厂之前，我们先看一下GatewayFilterFactory的源码，其层级如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 2]  
过滤器工厂的顶级接口是GatewayFilterFactory，有两个较接近具体实现的抽象类，分别为AbstractGatewayFilterFactory和AbstractNameValueGatewayFilterFactory，这两个类前者接收一个参数，比如它的实现类RedirectToGatewayFilterFactory；后者接收两个参数，比如它的实现类AddRequestHeaderGatewayFilterFactory类。现在需要将请求的日志打印出来，需要使用一个参数，这时可以参照RedirectToGatewayFilterFactory的写法。

import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.cloud.gateway.filter.GatewayFilter;
    import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
    import org.springframework.stereotype.Component;
    import reactor.core.publisher.Mono;
    
    import java.util.Arrays;
    import java.util.List;
    
    /** * @author by mazhen * @Classname CustomerGatewayFilterFactory * @Description 自定义过滤器工厂 * @Date 2020/1/11 23:17 */
    @Component
    public class CustomerGatewayFilterFactory extends AbstractGatewayFilterFactory<CustomerGatewayFilterFactory.Config> { 
    
        private static final Logger logger = LoggerFactory.getLogger(CustomerGatewayFilterFactory.class);
        private static final String REQUEST_START_TIME = "startTime";
    
        @Override
        public List<String> shortcutFieldOrder() { 
            return Arrays.asList("enabled");
        }
    
        public CustomerGatewayFilterFactory () { 
            super(Config.class);
            logger.info("Loaded CustomerGatewayFilterFactory");
        }
    
        @Override
        public GatewayFilter apply(Config config) { 
            return (exchange, chain) -> { 
                if (!config.isEnabled()) { 
                    return chain.filter(exchange);
                }
                exchange.getAttributes().put(REQUEST_START_TIME,System.currentTimeMillis());
                return chain.filter(exchange).then(Mono.fromRunnable(() -> { 
                    Long startTime = exchange.getAttribute(REQUEST_START_TIME);
                    if (startTime != null) { 
                        StringBuilder sb = new StringBuilder(exchange.getRequest().getURI().getRawPath())
                                .append(": ")
                                .append(System.currentTimeMillis() - startTime)
                                .append("ms");
                        sb.append(" params:").append(exchange.getRequest().getQueryParams());
                        sb.append(" heads:").append(exchange.getRequest().getHeaders());
                        logger.info(sb.toString());
                    }
                }));
            };
        }
    
        public static class Config { 
            /** * 控制是否开启统计 */
            private boolean enabled;
            public Config() { }
            public boolean isEnabled() { 
                return enabled;
            }
            public void setEnabled(boolean enabled) { 
                this.enabled = enabled;
            }
        }
    }

配置文件

server:
      port: 8080
    spring:
      application:
        name: test-GATEWAY
      cloud:
        gateway:
          routes:
          - id: sso-route
            uri: lb://test-sso
            predicates:
              - Path=/sso/**
            filters:
              - Customer=true

上面的配置文件中为什么是Customer属性，那是有个规范，就是工厂类要以GatewayFilterFactory为结尾，前面的名称为配置文件的属性，所以配置文件中就用Customer作为属性。值true赋值给的对象就CustomerGatewayFilterFactory中的config内部类，设置true就是对enable进行赋值。  
重启服务后，和上面的自定义过滤器的访问效果是一样的。

### GlobalFilter ###

Spring Cloud Gateway根据作用范围划分为GatewayFilter和GlobalFilter，二者区别如下：

*  GatewayFilter : 需要通过spring.cloud.routes.filters 配置在具体路由下，只作用在当前路由上或通过spring.cloud.default-filters配置在全局，作用在所有路由上
 *  GlobalFilter : 全局过滤器，不需要在配置文件中配置，作用在所有的路由上，最终通过GatewayFilterAdapter包装成GatewayFilterChain可识别的过滤器，它为请求业务以及路由的URI转换为真实业务服务的请求地址的核心过滤器，不需要配置，系统初始化时加载，并作用在每个路由上。  
    Spring Cloud Gateway框架内置的GlobalFilter如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 3]  
    上图中每一个GlobalFilter都作用在每一个router上，能够满足大多数的需求。但是如果遇到业务上的定制，可能需要编写满足自己需求的GlobalFilter。在下面的案例中将讲述如何编写自己GlobalFilter，该GlobalFilter会校验请求中是否包含了请求参数“token”，如何不包含请求参数“token”则不转发路由，否则执行正常的逻辑。代码如下：

import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    import org.springframework.cloud.gateway.filter.GlobalFilter;
    import org.springframework.core.Ordered;
    import org.springframework.http.HttpStatus;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Mono;
    
    /** * @author by mazhen * @Classname AuthorizeFilter * @Description TODO * @Date 2020/1/12 00:17 */
    @Component
    public class AuthorizeFilter implements GlobalFilter , Ordered { 
        private static final Logger logger = LoggerFactory.getLogger(AuthorizeFilter.class);
        private static final String AUTHORIZE_TOKEN = "token";
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            String token = exchange.getRequest().getQueryParams().getFirst(AUTHORIZE_TOKEN);
            if (StringUtils.isBlank(token)) { 
                logger.info("token is empty");
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }
            return chain.filter(exchange);
        }
    
        @Override
        public int getOrder() { 
            return 0;
        }
    }

启动请求  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 4]  
以上请求没有参数token，无法转发路由。看看下面我们带上参数token  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 5]  
参考文章：[微服务网关Gateway在实战中如何结合注册中心，定义过滤器？][Gateway]  
[spring cloud gateway之filter篇][spring cloud gateway_filter]

[SpringCloud Gateway]: https://blog.csdn.net/mameng1988/article/details/103888934
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200110145724930.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200110172422344.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200111230104696.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200111231815311.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200111232448837.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200111232551448.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21hbWVuZzE5ODg=,size_16,color_FFFFFF,t_70
[Gateway]: https://www.toutiao.com/i6739819010973499915/?tt_from=weixin&utm_campaign=client_share&wxshare_count=1&timestamp=1578306180&app=news_article&utm_source=weixin&utm_medium=toutiao_ios&req_id=202001061822590101290482230C13F6DA&group_id=6739819010973499915
[spring cloud gateway_filter]: https://blog.csdn.net/forezp/article/details/85057268