Spring Boot通过过滤器的方式实现RESTful根据请求需要过滤嵌套对象字段

可以通过编写自定义过滤器来实现RESTful根据请求需要过滤嵌套对象字段。具体步骤如下：

1. 创建一个实现了javax.servlet.Filter接口的过滤器类，重写doFilter方法。

2. 在doFilter方法中，获取请求中的URI和请求体，判断是否需要过滤嵌套对象字段。

3. 如果需要过滤，则将请求体转换为Map对象，递归遍历Map对象，过滤掉不需要的字段。

4. 最后将过滤后的请求体转换为JSON字符串，并重新设置到HttpServletRequest对象中。

5. 在Spring Boot应用中配置自定义过滤器。

示例代码如下：

@Component
public class NestedObjectFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String uri = httpRequest.getRequestURI();
        String method = httpRequest.getMethod();

        // 判断是否需要过滤
        if (method.equalsIgnoreCase("POST") && uri.equals("/api/some/path")) {
            // 获取请求体
            String requestBody = httpRequest.getReader().lines().collect(Collectors.joining(System.lineSeparator()));
            Map<String, Object> requestMap = new Gson().fromJson(requestBody, Map.class);
            Map<String, Object> filteredMap = filter(requestMap);

            // 将过滤后的请求体重新设置到HttpServletRequest对象中
            String filteredBody = new Gson().toJson(filteredMap);
            final ByteArrayInputStream bais = new ByteArrayInputStream(filteredBody.getBytes());
            request = new HttpServletRequestWrapper(httpRequest) {
                @Override
                public ServletInputStream getInputStream() throws IOException {
                    return new ServletInputStreamImpl(bais);
                }

                @Override
                public int getContentLength() {
                    return filteredBody.length();
                }

                @Override
                public long getContentLengthLong() {
                    return filteredBody.length();
                }
            };
        }

        chain.doFilter(request, response);
    }

    private Map<String, Object> filter(Map<String, Object> objectMap) {
        Map<String, Object> filteredMap = new HashMap<>();
        for (Map.Entry<String, Object> entry : objectMap.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();
            if (value instanceof Map) {
                value = filter((Map<String, Object>) value);
            }
            if (!key.equals("nestedObjectFieldToFilter")) {
                filteredMap.put(key, value);
            }
        }
        return filteredMap;
    }

    static class ServletInputStreamImpl extends ServletInputStream {

        private InputStream inputStream;

        public ServletInputStreamImpl(InputStream inputStream) {
            this.inputStream = inputStream;
        }

        @Override
        public int read() throws IOException {
            return inputStream.read();
        }

        @Override
        public boolean isFinished() {
            return false;
        }

        @Override
        public boolean isReady() {
            return false;
        }

        @Override
        public void setReadListener(ReadListener readListener) {
        }
    }
}

在Spring Boot应用中配置自定义过滤器：

@Bean
public FilterRegistrationBean<NestedObjectFilter> nestedObjectFilter() {
    FilterRegistrationBean<NestedObjectFilter> registrationBean = new FilterRegistrationBean<>();
    registrationBean.setFilter(new NestedObjectFilter());
    registrationBean.addUrlPatterns("/api/*");
    return registrationBean;
}

以上示例代码中，过滤器只对POST请求的/api/some/path进行过滤，过滤掉nestedObjectFieldToFilter字段。如果需要对其他请求做过滤，可以根据实际情况进行修改。