springcloud gateway高级功能之根据参数自定义路由Predicate

逃离我推掉我的手 2023-01-02 01:15 162阅读 0赞

# 背景 #

我们使用了springcloud gateway作为也给路由转发功能，由于历史遗留问题，不仅仅需要根据path转发，还需要根据get或者post中的参数进行转发

# 解决方案 #

这里我们使用自定义的Predicate进行转发

## 简介 ##

这里简单介绍下相关术语  
（1）Filter（过滤器）：

和Zuul的过滤器在概念上类似，可以使用它拦截和修改请求，并且对上游的响应，进行二次处理。过滤器为org.springframework.cloud.gateway.filter.GatewayFilter类的实例。

（2）Route（路由）：

网关配置的基本组成模块，和Zuul的路由配置模块类似。一个Route模块由一个 ID，一个目标 URI，一组断言和一组过滤器定义。如果断言为真，则路由匹配，目标URI会被访问。

（3）Predicate（断言）：

这是一个 Java 8 的 Predicate，可以使用它来匹配来自 HTTP 请求的任何内容，例如 headers 或参数。断言的输入类型是一个 ServerWebExchange。

这里我们会使用自定义的断言来实现，常用的断言有如下几个：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xwMTk4NjExMjY_size_16_color_FFFFFF_t_70]  
详细信息可以参考下面链接：https://www.jianshu.com/p/d2c3b6851e1d?utm\_source=desktop&utm\_medium=timeline

## GET请求转发 ##

在常用断言中就有支持根据get参数转发，所以这里需要同时使用path以及query断言，可以根据如下配置

spring:
      cloud:
        gateway:
          routes:
            - id: blog
              uri: http://blog.yuqiyu.com
              predicates:
                - Path=/api/demo
                - Query=xxx, zzz

根据上面配置，我们限定了参数xxx必须为zzz时才会被成功转发，否则会出现404抓发失败，根据上面配置就可以根据get参数转发

## POST请求转发 ##

post参数转发，没有现成的转发断言，这里我们需要参考readbody断言来实现，下面是ReadBodyPredicateFactory 的源码

public class ReadBodyPredicateFactory extends AbstractRoutePredicateFactory<ReadBodyPredicateFactory.Config> {
        protected static final Log log = LogFactory.getLog(ReadBodyPredicateFactory.class);
        private static final String TEST_ATTRIBUTE = "read_body_predicate_test_attribute";
        private static final String CACHE_REQUEST_BODY_OBJECT_KEY = "cachedRequestBodyObject";
        private static final List<HttpMessageReader<?>> messageReaders = HandlerStrategies.withDefaults().messageReaders();
    
        public ReadBodyPredicateFactory() {
            super(ReadBodyPredicateFactory.Config.class);
        }
    
        public AsyncPredicate<ServerWebExchange> applyAsync(ReadBodyPredicateFactory.Config config) {
            return (exchange) -> {
                Class inClass = config.getInClass();
                Object cachedBody = exchange.getAttribute("cachedRequestBodyObject");
                if (cachedBody != null) {
                    try {
                        boolean test = config.predicate.test(cachedBody);
                        exchange.getAttributes().put("read_body_predicate_test_attribute", test);
                        return Mono.just(test);
                    } catch (ClassCastException var6) {
                        if (log.isDebugEnabled()) {
                            log.debug("Predicate test failed because class in predicate does not match the cached body object", var6);
                        }
    
                        return Mono.just(false);
                    }
                } else {
                    return ServerWebExchangeUtils.cacheRequestBodyAndRequest(exchange, (serverHttpRequest) -> {
                        return ServerRequest.create(exchange.mutate().request(serverHttpRequest).build(), messageReaders).bodyToMono(inClass).doOnNext((objectValue) -> {
                            exchange.getAttributes().put("cachedRequestBodyObject", objectValue);
                        }).map((objectValue) -> {
                            return config.getPredicate().test(objectValue);
                        });
                    });
                }
            };
        }
    
        public Predicate<ServerWebExchange> apply(ReadBodyPredicateFactory.Config config) {
            throw new UnsupportedOperationException("ReadBodyPredicateFactory is only async.");
        }
    
        public static class Config {
            private Class inClass;
            private Predicate predicate;
            private Map<String, Object> hints;
    
            public Config() {
            }
    
            public Class getInClass() {
                return this.inClass;
            }
    
            public ReadBodyPredicateFactory.Config setInClass(Class inClass) {
                this.inClass = inClass;
                return this;
            }
    
            public Predicate getPredicate() {
                return this.predicate;
            }
    
            public ReadBodyPredicateFactory.Config setPredicate(Predicate predicate) {
                this.predicate = predicate;
                return this;
            }
    
            public <T> ReadBodyPredicateFactory.Config setPredicate(Class<T> inClass, Predicate<T> predicate) {
                this.setInClass(inClass);
                this.predicate = predicate;
                return this;
            }
    
            public Map<String, Object> getHints() {
                return this.hints;
            }
    
            public ReadBodyPredicateFactory.Config setHints(Map<String, Object> hints) {
                this.hints = hints;
                return this;
            }
        }
    }

这个只是把post参数读入到缓存，配置如下

predicates:
            - Path=/card/api/**
            - name: ReadBodyPredicateFactory #使用ReadBodyPredicateFactory断言，将body读入缓存
              args:
                inClass: '#{T(String)}'
                predicate: '#{@bodyPredicate}' #注入实现predicate接口类

但是这个暂时不能满足要求，我们需要参考ReadBodyPredicateFactory自定义一个predicatefactory来实现我们的需求

@Component()
    @Slf4j
    public class MyReadBodyPredicateFactory extends AbstractRoutePredicateFactory<MyReadBodyPredicateFactory.Config> {
    
    
        private static final List<HttpMessageReader<?>> messageReaders = HandlerStrategies
                .withDefaults().messageReaders();
    
        public MyReadBodyPredicateFactory() {
            super(MyReadBodyPredicateFactory.Config.class);
        }
    
        public MyReadBodyPredicateFactory(Class<MyReadBodyPredicateFactory.Config> configClass) {
            super(configClass);
        }
    
        @Override
        @SuppressWarnings("unchecked")
        public AsyncPredicate<ServerWebExchange> applyAsync(MyReadBodyPredicateFactory.Config config) {
            return new AsyncPredicate<ServerWebExchange>() {
                @Override
                public Publisher<Boolean> apply(ServerWebExchange exchange) {
                    Object cachedBody = exchange.getAttribute(MyFacadeConstants.CACHE_REQUEST_BODY_OBJECT_KEY);
                    if (cachedBody != null) {
                        try {
                            boolean test = match(config.sceneIds, (MycRequest) cachedBody);
                            return Mono.just(test);
                        } catch (ClassCastException e) {
                            if (log.isDebugEnabled()) {
                                log.debug("Predicate test failed because class in predicate "
                                        + "does not match the cached body object", e);
                            }
                        }
                        return Mono.just(false);
                    } else {
                        return ServerWebExchangeUtils.cacheRequestBodyAndRequest(exchange,
                                (serverHttpRequest) -> ServerRequest.create(exchange.mutate().request(serverHttpRequest).build(), messageReaders)
                                        .bodyToMono(MycRequest.class)
                                        .doOnNext(objectValue -> exchange.getAttributes().put(MyFacadeConstants.CACHE_REQUEST_BODY_OBJECT_KEY,objectValue))
                                        .map(objectValue -> { return match(config.sceneIds, objectValue);}));
                    }
                }
            };
        }
    
        private boolean match(String params, MycRequest mycRequest) {
            if("others".equals(params)){
                return true;
            }
            String[] paramArray = params.split(",");
            if (ArrayUtils.contains(paramArray, mycRequest.getRouteId)) {
                return true;
            } else {
                return false;
            }
        }
    
        @Override
        @SuppressWarnings("unchecked")
        public Predicate<ServerWebExchange> apply(MyReadBodyPredicateFactory.Config config) {
            throw new UnsupportedOperationException(
                    "MyReadBodyPredicateFactory is only async.");
        }
    
        public static class Config {
    
            private String params;
    
            public MyReadBodyPredicateFactory.Config setParams(params) {
                this.params = params;
                return this;
            }
    
            public String getParams() {
                return params;
            }
        }
    }

这里我们可以根据将参数转为MyRequest，然后再进行判断是否路由，当然这里我们同样也需要使用到path断言，配置如下：

spring:
      cloud:
        gateway:
          routes:
            - id: route1
              uri: http://host1:8080
              predicates:
                - Path=/api/demo
                - name: MyReadBodyPredicateFactory 
                  args:
                    params: "23,22" 
            - id: route2
              uri: http://host2:8080
              predicates:
                - Path=/api/demo
                - name: RecommendReadBodyPredicateFactory 
                  args:
                    params: "44,56"

这样就可以根据post参数路由转发了，如下监控：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xwMTk4NjExMjY_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xwMTk4NjExMjY_size_16_color_FFFFFF_t_70]: /images/20221120/928dfa44fca74cb199026a8c7fb3fa03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xwMTk4NjExMjY_size_16_color_FFFFFF_t_70 1]: /images/20221120/45306a62335d45bf97d10855421d9959.png