spring url匹配工具类----AntPathMatcher

在gateway进行授权认证时，有些请求url需要过滤掉，针对带/service/{id}/user-info这种带操作符的请求，需要特殊处理----AntPathMatcher就上场啦
具体使用场景：
1.登录授权验证：过滤掉登录请求，一些资源获取请求
2.请求接口日志打印：过滤掉文件上传和下载的一些请求，requestBody里的文件流会被异常修改

具体代码：

请求body的二次写入

@Component
public class CachePostBodyFilter implements GlobalFilter, Ordered {

    private final List<HttpMessageReader<?>> messageReaders;

    public CachePostBodyFilter() {
        this.messageReaders = HandlerStrategies.withDefaults().messageReaders();
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        if (FilterUrl.excludeUrls(new FilterUrl(request.getPath().toString(), request.getMethod()))) {
            return chain.filter(exchange);
        }
        if (Objects.equals(request.getMethod(), HttpMethod.POST)) {
            ServerRequest serverRequest = ServerRequest.create(exchange,
                    messageReaders);
            Mono<String> modifiedBody = serverRequest.bodyToMono(String.class)
                    .flatMap(body -> {
                        exchange.getAttributes().put(RequestConstants.REQUEST_BODY, body);
                        return Mono.just(body);
                    });

            BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
            HttpHeaders headers = new HttpHeaders();
            headers.putAll(exchange.getRequest().getHeaders());

            // the new content type will be computed by bodyInserter
            // and then set in the request decorator
            headers.remove(HttpHeaders.CONTENT_LENGTH);

            CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);
            return bodyInserter.insert(outputMessage, new BodyInserterContext()).
                    then(Mono.defer(() -> {
                        ServerHttpRequest decorator = decorate(exchange, headers,
                                outputMessage);
                        return chain.filter(exchange.mutate().request(decorator).build());
                    }));
        }
        return chain.filter(exchange);
    }


    ServerHttpRequestDecorator decorate(ServerWebExchange exchange, HttpHeaders headers,
            CachedBodyOutputMessage outputMessage) {
        return new ServerHttpRequestDecorator(exchange.getRequest()) {
            @Override
            public HttpHeaders getHeaders() {
                long contentLength = headers.getContentLength();
                HttpHeaders httpHeaders = new HttpHeaders();
                httpHeaders.putAll(headers);
                if (contentLength > 0) {
                    httpHeaders.setContentLength(contentLength);
                } else {
                    httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
                }
                return httpHeaders;
            }

            @Override
            public Flux<DataBuffer> getBody() {
                return outputMessage.getBody();
            }
        };
    }

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


}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class FilterUrl {

    private String url;
    private HttpMethod method;


    public static boolean excludeUrls(FilterUrl targetUrl) {
        List<FilterUrl> excludeUrls = Lists.newArrayList();
        excludeUrls.add(new FilterUrl("/api/v1/service/users", HttpMethod.POST));
        excludeUrls.add(new FilterUrl("/api/v1/service/terms/{termId}/export", HttpMethod.GET));

        AntPathMatcher antPathMatcher = new AntPathMatcher();

        return excludeUrls.stream()
                .anyMatch(url -> antPathMatcher.match(url.getUrl(), targetUrl.getUrl()) && url.getMethod().equals(targetUrl.getMethod()));
    }
}