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

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

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

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

public class RequestWrapper extends HttpServletRequestWrapper {

    private String body;

    
    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();
    }


    
    @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;
    }


    
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream(), Charsets.UTF_8));
    }


    
    public String getBody() {
        return this.body;
    }
}

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

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

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 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 parameterMap = request.getParameterMap();
                Set> entries = parameterMap.entrySet();
                Iterator> iterator = entries.iterator();
                while (iterator.hasNext()) {
                    Map.Entry 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;
    }
}