拦截器中获取传递参数（解决post请求参数问题）

1. GET中传递的参数可以直接通过request.getParameter获取。
2. Post 传递的产生不能过直接从request.getInputStream() 读取，必须要进行重新写。（request.getInputStream()只能够读取一次）

方式： 通过重写 HttpServletRequestWrapper 类 获取getInputStream中的流数据，然后在将body数据进行重新写入传递下去。

继承 HttpServletRequestWrapper

通过重写 HttpServletRequestWrapper 类 获取getInputStream中的流数据，然后在将body数据进行重新写入传递下去。

/**
 * @author fuwenshen
 * @version 1.0.0
 * @ClassName RequestWrapper.java
 * @Description RequestWrapper封装类，
 * @createTime 2022年01月18日 13:57:00
 */
public class RequestWrapper extends HttpServletRequestWrapper {

    private String body;

    /**
     * Constructs a request object wrapping the given request.
     *
     * @param request The request to wrap
     * @throws IllegalArgumentException if the request is null
     */
    public RequestWrapper(HttpServletRequest request) throws IOException{
        super(request);

        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;
        try {
            InputStream inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream,"UTF-8"));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            } else {
                stringBuilder.append("");
            }
        } catch (IOException ex) {
            throw ex;
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException ex) {
                    throw ex;
                }
            }
        }
        body = stringBuilder.toString();
    }


    /**
     * 重写getInputStream， 从body中获取请求参数
     * @return
     * @throws IOException
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes("UTF-8"));
        ServletInputStream servletInputStream = new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

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

            @Override
            public void setReadListener(ReadListener readListener) {

            }

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


    /**
     * 重写获取 字符流的方式
     * @return
     * @throws IOException
     */
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream(), Charsets.UTF_8));
    }


    /**
     * 直接返回获取 body
     * @return
     */
    public String getBody() {
        return this.body;
    }
}

继承HandlerInterceptorAdapter

通过继承HandlerInterceptorAdapter实现SpringBoot 拦截器功能

• GET中传递的参数可以直接通过request.getParameter获取。
• Post 传递的产生不能过直接从request.getInputStream() 读取，必须要进行重新写。（request.getInputStream()只能够读取一次）

/**
 * @author fuwenshen
 * @version 1.0.0
 * @ClassName TokenValidateIntercepter.java
 * @Description token 校验拦截器
 * @createTime 2022年01月18日 13:47:00
 */
public class TokenValidateInterceptor extends HandlerInterceptorAdapter {
    private Logger logger = LoggerFactory.getLogger(TokenValidateInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String token = request.getHeader("token");

        if(StrUtil.isBlank(token)){
             response.getWriter().print("token is not null");
             return false;
        }

        // 参数集合 初始化
        Map<String, Object> paramsMaps = new TreeMap();

        try {
            if ("POST".equals(request.getMethod().toUpperCase())) {
                // 防止流读取一次后就没有了, 所以需要将流继续写出去
                RequestWrapper requestWrapper = new RequestWrapper(request);
                String body = requestWrapper.getBody();
                paramsMaps = JSONObject.parseObject(body, TreeMap.class);
                logger.debug("parameterMap:" + paramsMaps.toString());
            } else {
                Map<String, String[]> parameterMap = request.getParameterMap();
                Set<Map.Entry<String, String[]>> entries = parameterMap.entrySet();
                Iterator<Map.Entry<String, String[]>> iterator = entries.iterator();
                while (iterator.hasNext()) {
                    Map.Entry<String, String[]> next = iterator.next();
                    paramsMaps.put(next.getKey(), next.getValue()[0]);
                }
                logger.debug("parameterMap:" + paramsMaps.toString());
            }


         // checkTokenSign
            


        }catch (Exception e){
            logger.error("token 验签失败！",e);
            return false;
        }

        return true;
    }
}