Springboot 过虑器统一处理参数空格

废话不多说，代码仅供参考！

过滤器添加使用注解@WebFilter，需要使用@ServletComponentScan开启扫描

package com.xyz.reports.configuration.filter;

import cn.hutool.http.Header;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.entity.ContentType;
import org.apache.poi.util.IOUtils;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

/**
 * @Description 对所有请求拦截处理参数空格
 * @Author zhouqibing
 * @Create 2021-09-03 16:36
 */
@Slf4j
@WebFilter(urlPatterns = {"/*"})
public class ParameterTrimFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
        chain.doFilter(new ParameterTrimRequest((HttpServletRequest) servletRequest), servletResponse);
    }
}

/**
 * 1,从request中取值处理空格</br>
 * 2,重写request的取值方法和getInputStream(),
 *  因为parameterMap不能修改，getInputStream()只能调用一次，后续操作无法取值
 * @author zhouqibing
 * @Description 参数空格字符处理
 * @date 2021/9/3 17:01
 */
@Slf4j
class ParameterTrimRequest extends HttpServletRequestWrapper {
    // 用于存放去年空格的数据
    private Map<String, String[]> params = new HashMap<>();
    private byte[] content;

    public ParameterTrimRequest(HttpServletRequest request) {
        super(request);
        // 普通参数
        handleParameterTrim(request.getParameterMap());
        // json参数
        handleJsonTrim(request);
    }

    @Override
    public Enumeration<String> getParameterNames() {//重写getParameterNames()
        return new Vector<String>(params.keySet()).elements();
    }

    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }

    @Override
    public String[] getParameterValues(String name) {//重写getParameterValues()
        return params.get(name);
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        return this.params;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        // 只处理JSON类型数据
        if (!super.getHeader(Header.CONTENT_TYPE.getValue()).equalsIgnoreCase(ContentType.APPLICATION_JSON.getMimeType())) {
            return super.getInputStream();
        }

        ByteArrayInputStream inputStream = new ByteArrayInputStream(this.content);
        return new ServletInputStream() {
            @Override
            public int read() throws IOException {
                return inputStream.read();
            }

            @Override
            public int read(byte[] b, int off, int len) throws IOException {
                return inputStream.read(b, off, len);
            }

            @Override
            public int read(byte[] b) throws IOException {
                return inputStream.read(b);
            }

            @Override
            public void setReadListener(ReadListener listener) {
            }

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

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

            @Override
            public long skip(long n) throws IOException {
                return inputStream.skip(n);
            }

            @Override
            public void close() throws IOException {
                inputStream.close();
            }

            @Override
            public synchronized void mark(int readlimit) {
                inputStream.mark(readlimit);
            }

            @Override
            public synchronized void reset() throws IOException {
                inputStream.reset();
            }
        };
    }

    /**
     * 处理普通参数空格
     *
     * @param originalMap
     * @author zhouqibing
     * @date 2021/9/3 17:12
     */
    private void handleParameterTrim(Map<String, String[]> originalMap) {
        params.putAll(originalMap);
        params.entrySet().forEach(entry -> {
            String[] values = entry.getValue();
            for (int i = 0; i < values.length; i++) {
                values[i] = values[i].trim();
            }
            entry.setValue(values);
        });
    }

    /**
     * 处理json格式数据
     *
     * @param request
     * @author zhouqibing
     * @date 2021/9/3 17:19
     */
    private void handleJsonTrim(HttpServletRequest request) {
        try {
            if (ContentType.APPLICATION_JSON.getMimeType().equals(request.getContentType())) {
                content = IOUtils.toByteArray(request.getInputStream());
                JSONObject json = JSONObject.parseObject(content, JSONObject.class);
                parse(json);
                content = json.toJSONString().getBytes(); // 重置content
            }
        } catch (Exception e) {
            log.error("处理Json数据空格异常", e);
        }
    }

    /**
     * 处理JSON数据
     * @author zhouqibing
     * @date 2021/9/3 17:51
     * @param obj
     */
    private void parse(Object obj) {
        if (obj instanceof JSONArray) {
            JSONArray jsonArray = (JSONArray) obj;
            for (int index = 0; index < jsonArray.size(); index++) {
                parse(jsonArray.get(0));
            }
        } else if (obj instanceof JSONObject) {
            JSONObject jsonObject = (JSONObject) obj;
            for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
                if (entry.getValue() instanceof String) {
                    entry.setValue(((String) entry.getValue()).trim());
                } else {
                    parse(entry.getValue());
                }
            }
        }
    }
}