SpringCloud Gateway自定义filter获取body中的数据为空

灰太狼 2022-11-21 01:17 257阅读 0赞

最近在使用SpringCloud Gateway进行网关的开发，我使用的版本是：SpringBoot的2.3.4.RELEASE+SpringCloud的Hoxton.SR8，在自定义过滤器时需要获取ServerHttpRequest中body的数据，发现一直无法获取到数据，经过各种百度、谷歌，再加上自己的实践，终于找到解决方案：  
1、首先创建一个全局过滤器把body中的数据缓存起来

package com.cloudpath.gateway.portal.filter;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    import org.springframework.cloud.gateway.filter.GlobalFilter;
    import org.springframework.core.Ordered;
    import org.springframework.core.io.buffer.DataBuffer;
    import org.springframework.core.io.buffer.DataBufferUtils;
    import org.springframework.http.server.reactive.ServerHttpRequest;
    import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Flux;
    import reactor.core.publisher.Mono;
    
    /** * @author mazhen * @className CacheBodyGlobalFilter * @Description 把body中的数据缓存起来 * @date 2020/10/28 18:02 */
    @Slf4j
    @Component
    public class CacheBodyGlobalFilter implements Ordered, GlobalFilter { 
    
        // public static final String CACHE_REQUEST_BODY_OBJECT_KEY = "cachedRequestBodyObject";
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            if (exchange.getRequest().getHeaders().getContentType() == null) { 
                return chain.filter(exchange);
            } else { 
                return DataBufferUtils.join(exchange.getRequest().getBody())
                        .flatMap(dataBuffer -> { 
                            DataBufferUtils.retain(dataBuffer);
                            Flux<DataBuffer> cachedFlux = Flux
                                    .defer(() -> Flux.just(dataBuffer.slice(0, dataBuffer.readableByteCount())));
                            ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(
                                    exchange.getRequest()) { 
                                @Override
                                public Flux<DataBuffer> getBody() { 
                                    return cachedFlux;
                                }
                            };
                            //exchange.getAttributes().put(CACHE_REQUEST_BODY_OBJECT_KEY, cachedFlux);
    
                            return chain.filter(exchange.mutate().request(mutatedRequest).build());
                        });
            }
        }
    
        @Override
        public int getOrder() { 
            return Ordered.HIGHEST_PRECEDENCE;
        }
    
    }

CacheBodyGlobalFilter这个全局过滤器的目的就是把原有的request请求中的body内容读出来，并且使用ServerHttpRequestDecorator这个请求装饰器对request进行包装，重写getBody方法，并把包装后的请求放到过滤器链中传递下去。这样后面的过滤器中再使用exchange.getRequest().getBody()来获取body时，实际上就是调用的重载后的getBody方法，获取的最先已经缓存了的body数据。这样就能够实现body的多次读取了。  
值得一提的是，这个过滤器的order设置的是Ordered.HIGHEST\_PRECEDENCE，即最高优先级的过滤器。优先级设置这么高的原因是某些系统内置的过滤器可能也会去读body，这样就会导致我们自定义过滤器中获取body的时候报body只能读取一次这样的错误如下:

java.lang.IllegalStateException: Only one connection receive subscriber allowed.
    	at reactor.ipc.netty.channel.FluxReceive.startReceiver(FluxReceive.java:279)
    	at reactor.ipc.netty.channel.FluxReceive.lambda$subscribe$2(FluxReceive.java:129)
    	at

所以，必须把CacheBodyGlobalFilter的优先级设到最高。  
2、在自定义的过滤器中尝试获取body中的数据

package com.cloudpath.iam.gateway.customerfilter;
    
    import com.cloudpath.iam.gateway.utils.FilterRequestResponseUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.cloud.gateway.filter.GatewayFilter;
    import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
    import org.springframework.core.io.buffer.DataBuffer;
    import org.springframework.http.server.reactive.ServerHttpRequest;
    import org.springframework.stereotype.Component;
    import reactor.core.publisher.Flux;
    
    import java.util.Arrays;
    import java.util.List;
    
    /** * @author by mazhen * @Classname TestGatewayFilterFactory * @Description 自定义过滤器获取body中的数据 * @Date 2020/10/27 14:38 */
    @Component
    @Slf4j
    public class TestGatewayFilterFactory extends AbstractGatewayFilterFactory<TestGatewayFilterFactory.Config> { 
    
    
        @Override
        public List<String> shortcutFieldOrder() { 
            return Arrays.asList("enabled");
        }
    
        public TestGatewayFilterFactory() { 
            super(Config.class);
            log.info("Loaded TestGatewayFilterFactory");
        }
    
        @Override
        public GatewayFilter apply(Config config) { 
            return (exchange, chain) -> { 
                if (!config.isEnabled()) { 
                    return chain.filter(exchange);
                }
    
                if (null != exchange) { 
                    ServerHttpRequest httpRequest = exchange.getRequest();
                        try { 
    
                            Flux<DataBuffer> dataBufferFlux = httpRequest.getBody();
                            //获取body中的数据
                            String body = FilterRequestResponseUtil.resolveBodyFromRequest(dataBufferFlux);
                            log.info("body:{}",body);
    
                        } catch (Exception e) { 
                            log.error("异常:",e);
                            return chain.filter(exchange);
                        }
                }
                return chain.filter(exchange);
            };
        }
    
    
        public static class Config { 
            /** * 控制是否开启统计 */
            private boolean enabled;
    
            public Config() { 
            }
    
            public boolean isEnabled() { 
                return enabled;
            }
    
            public void setEnabled(boolean enabled) { 
                this.enabled = enabled;
            }
        }
    }

3、解析body的工具类

package com.cloudpath.iam.gateway.utils;
    
    
    import org.springframework.core.io.buffer.DataBuffer;
    import org.springframework.core.io.buffer.DataBufferUtils;
    import reactor.core.publisher.Flux;
    import java.nio.CharBuffer;
    import java.nio.charset.StandardCharsets;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    /** * @author mazhen * @className FilterHeadersUtil * @Description 过滤器请求/响应工具类 * @date 2020/10/29 9:31 */
    public final class FilterRequestResponseUtil { 
    
        /** * spring cloud gateway 获取post请求的body体 * @param body * @return */
        public static String resolveBodyFromRequest( Flux<DataBuffer> body){ 
            AtomicReference<String> bodyRef = new AtomicReference<>();
            // 缓存读取的request body信息
            body.subscribe(dataBuffer -> { 
                CharBuffer charBuffer = StandardCharsets.UTF_8.decode(dataBuffer.asByteBuffer());
                DataBufferUtils.release(dataBuffer);
                bodyRef.set(charBuffer.toString());
            });
            //获取request body
            return bodyRef.get();
    
        }
    
        /** * 读取body内容 * @param body * @return */
        public static String resolveBodyFromRequest2( Flux<DataBuffer> body){ 
            StringBuilder sb = new StringBuilder();
    
            body.subscribe(buffer -> { 
                byte[] bytes = new byte[buffer.readableByteCount()];
                buffer.read(bytes);
                DataBufferUtils.release(buffer);
                String bodyString = new String(bytes, StandardCharsets.UTF_8);
                sb.append(bodyString);
            });
            return formatStr(sb.toString());
        }
    
        /** * 去掉空格,换行和制表符 * @param str * @return */
        private static String formatStr(String str){ 
            if (str != null && str.length() > 0) { 
                Pattern p = Pattern.compile("\\s*|\t|\r|\n");
                Matcher m = p.matcher(str);
                return m.replaceAll("");
            }
            return str;
        }
    }

解析body的内容，网上普遍是上面的两种方式,亲测resolveBodyFromRequest方法解析body中的数据，没有1024字节的限制。  
ps：我传的参数有1万多字节。。。。。。。  
大家可以按需所选。