使用筛选器和包装器时出现Spring错误

我正在使用筛选器检查用户权限。 将会话值与参数值进行比较时出现问题，并且使用包装器应用了解析负载

但是，出现了以下错误消息

List<Map<String,Object>> loginInfo = (List<Map<String,Object>>)session.getAttribute("loginSession");


            if loginInfo.get(0).get("user_type").equals("1") || loginInfo.get(0).get("user_type").equals("2")) 
            {
                chain.doFilter(req, res);

            }
            else 
            {
                RereadableRequestWrapper wrapperRequest = new RereadableRequestWrapper(request);

                String requestBody= IOUtils.toString(wrapperRequest.getInputStream(), "UTF-8");

                Enumeration<String> reqeustNames = request.getParameterNames();
                if(requestBody == null) {
                }

                Map<String,Object> param_map = new ObjectMapper().readValue(requestBody, HashMap.class);

                String userId_param = String.valueOf(param_map.get("customer_id"));
                System.out.println(userId_param);
                if( userId_param == null || userId_param.isEmpty()) {
                    logger.debug("error, customer_id  error");
                }

                if (!loginInfo.get(0).get("customer_id").equals(userId_param)) 
                {
                    logger.debug("error, customer_id  error");
                }
                chain.doFilter(wrapperRequest, res);
            }

List loginInfo=（List）session.getAttribute（“loginSession”）；
如果loginInfo.get（0.get（“用户类型”）等于（“1”）| | loginInfo.get（0.get（“用户类型”）等于（“2”））
{
链式过滤器（要求、恢复）；
}
其他的
{
RereadableRequestWrapper wrapperRequest=新的RereadableRequestWrapper（请求）；
String requestBody=IOUtils.toString（wrapperRequest.getInputStream（），“UTF-8”）；
枚举RequeustNames=request.getParameterNames（）；
if（requestBody==null）{
}
Map param_Map=new ObjectMapper（）.readValue（requestBody，HashMap.class）；
String userId_param=String.valueOf（param_map.get（“customer_id”）；
System.out.println（userId\u参数）；
if（userId_param==null | | userId_param.isEmpty（））{
调试（“错误，客户id错误”）；
}
如果（！loginInfo.get（0.get（“客户id”）等于（用户id\u参数））
{
调试（“错误，客户id错误”）；
}
doFilter（wrapperRequest，res）；
}

///////////////////////// 这是我的包装代码。 私有布尔参数sparsed=false

    private final Charset encoding;
    private final byte[] rawData;
    private final Map<String, ArrayList<String>> parameters = new LinkedHashMap<String, ArrayList<String>>();
    ByteChunk tmpName = new ByteChunk();
    ByteChunk tmpValue = new ByteChunk();

    private class ByteChunk {

        private byte[] buff;
        private int start = 0;
        private int end;

        public void setByteChunk(byte[] b, int off, int len) {
            buff = b;
            start = off;
            end = start + len;
        }

        public byte[] getBytes() {
            return buff;
        }

        public int getStart() {
            return start;
        }

        public int getEnd() {
            return end;
        }

        public void recycle() {
            buff = null;
            start = 0;
            end = 0;
        }
    }

public RereadableRequestWrapper(HttpServletRequest request) throws IOException {
    super(request);

    String characterEncoding = request.getCharacterEncoding();
    if (StringUtils.isBlank(characterEncoding)) {
        characterEncoding = StandardCharsets.UTF_8.name();
    }
    this.encoding = Charset.forName(characterEncoding);

    // Convert InputStream data to byte array and store it to this wrapper instance.
    try {
        InputStream inputStream = request.getInputStream();
        this.rawData = IOUtils.toByteArray(inputStream);
    } catch (IOException e) {
        throw e;
    }
}

@Override
public ServletInputStream getInputStream() throws IOException {
    final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(this.rawData);
    ServletInputStream servletInputStream = new ServletInputStream() {
        public int read() throws IOException {
            return byteArrayInputStream.read();
        }

        @Override
        public boolean isFinished() {
            // TODO Auto-generated method stub
            return false;
        }

        @Override
        public boolean isReady() {
            // TODO Auto-generated method stub
            return false;
        }

        @Override
        public void setReadListener(ReadListener listener) {
            // TODO Auto-generated method stub

        }
    };
    return servletInputStream;
}

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

@Override
public ServletRequest getRequest() {
    return super.getRequest();
}

@Override
public String getParameter(String name) {
    if (!parametersParsed) {
        parseParameters();
    }
    ArrayList<String> values = this.parameters.get(name);
    if (values == null || values.size() == 0)
        return null;
    return values.get(0);
}

public HashMap<String, String[]> getParameters() {
    if (!parametersParsed) {
        parseParameters();
    }
    HashMap<String, String[]> map = new HashMap<String, String[]>(this.parameters.size() * 2);
    for (String name : this.parameters.keySet()) {
        ArrayList<String> values = this.parameters.get(name);
        map.put(name, values.toArray(new String[values.size()]));
    }
    return map;
}

@SuppressWarnings("rawtypes")
@Override
public Map getParameterMap() {
    return getParameters();
}

@SuppressWarnings("rawtypes")
@Override
public Enumeration getParameterNames() {
    return new Enumeration<String>() {
        @SuppressWarnings("unchecked")
        private String[] arr = (String[])(getParameterMap().keySet().toArray(new String[0]));
        private int index = 0;

        @Override
        public boolean hasMoreElements() {
            return index < arr.length;
        }

        @Override
        public String nextElement() {
            return arr[index++];
        }
    };
}

@Override
public String[] getParameterValues(String name) {
    if (!parametersParsed) {
        parseParameters();
    }
    ArrayList<String> values = this.parameters.get(name);
    String[] arr = values.toArray(new String[values.size()]);
    if (arr == null) {
        return null;
    }
    return arr;
}

private void parseParameters() {
    parametersParsed = true;

    if (!("application/x-www-form-urlencoded".equalsIgnoreCase(super.getContentType()))) {
        return;
    }

    int pos = 0;
    int end = this.rawData.length;

    while (pos < end) {
        int nameStart = pos;
        int nameEnd = -1;
        int valueStart = -1;
        int valueEnd = -1;

        boolean parsingName = true;
        boolean decodeName = false;
        boolean decodeValue = false;
        boolean parameterComplete = false;

        do {
            switch (this.rawData[pos]) {
                case '=':
                    if (parsingName) {
                        // Name finished. Value starts from next character
                        nameEnd = pos;
                        parsingName = false;
                        valueStart = ++pos;
                    } else {
                        // Equals character in value
                        pos++;
                    }
                    break;
                case '&':
                    if (parsingName) {
                        // Name finished. No value.
                        nameEnd = pos;
                    } else {
                        // Value finished
                        valueEnd = pos;
                    }
                    parameterComplete = true;
                    pos++;
                    break;
                case '%':
                case '+':
                    // Decoding required
                    if (parsingName) {
                        decodeName = true;
                    } else {
                        decodeValue = true;
                    }
                    pos++;
                    break;
                default:
                    pos++;
                    break;
            }
        } while (!parameterComplete && pos < end);

        if (pos == end) {
            if (nameEnd == -1) {
                nameEnd = pos;
            } else if (valueStart > -1 && valueEnd == -1) {
                valueEnd = pos;
            }
        }

        if (nameEnd <= nameStart) {
            continue;
            // ignore invalid chunk
        }

        tmpName.setByteChunk(this.rawData, nameStart, nameEnd - nameStart);
        if (valueStart >= 0) {
            tmpValue.setByteChunk(this.rawData, valueStart, valueEnd - valueStart);
        } else {
            tmpValue.setByteChunk(this.rawData, 0, 0);
        }

        try {
            String name;
            String value;

            if (decodeName) {
                name = new String(URLCodec.decodeUrl(Arrays.copyOfRange(tmpName.getBytes(), tmpName.getStart(), tmpName.getEnd())), this.encoding);
            } else {
                name = new String(tmpName.getBytes(), tmpName.getStart(), tmpName.getEnd() - tmpName.getStart(), this.encoding);
            }

            if (valueStart >= 0) {
                if (decodeValue) {
                    value = new String(URLCodec.decodeUrl(Arrays.copyOfRange(tmpValue.getBytes(), tmpValue.getStart(), tmpValue.getEnd())), this.encoding);
                } else {
                    value = new String(tmpValue.getBytes(), tmpValue.getStart(), tmpValue.getEnd() - tmpValue.getStart(), this.encoding);
                }
            } else {
                value = "";
            }

            if (StringUtils.isNotBlank(name)) {
                ArrayList<String> values = this.parameters.get(name);
                if (values == null) {
                    values = new ArrayList<String>(1);
                    this.parameters.put(name, values);
                }
                if (StringUtils.isNotBlank(value)) {
                    values.add(value);
                }
            }
        } catch (DecoderException e) {
            // ignore invalid chunk
        }

        tmpName.recycle();
        tmpValue.recycle();
    }
}

  and Error Message is com.fasterxml.jackson.databind.JsonMappingException: No content to map due to end-of-input 

私有最终字符集编码；
私有最终字节[]原始数据；
私有最终映射参数=新LinkedHashMap（）；
ByteChunk tmpName=新的ByteChunk（）；
ByteChunk tmpValue=新的ByteChunk（）；
私有类ByteChunk{
私有字节[]buff；
私有int start=0；
私人互联网终端；
公共无效setByteChunk（字节[]b，int off，int len）{
buff=b；
启动=关闭；
结束=开始+长度；
}
公共字节[]getBytes（）{
返回buff；
}
public int getStart（）{
返回启动；
}
公共int getEnd（）{
返回端；
}
公共空间回收（）{
buff=null；
开始=0；
结束=0；
}
}
公共RereadableRequestWrapper（HttpServletRequest请求）引发IOException{
超级（请求）；
String characterEncoding=request.getCharacterEncoding（）；
if（StringUtils.isBlank（characterEncoding））{
characterEncoding=StandardCharsets.UTF_8.name（）；
}
this.encoding=Charset.forName（characterEncoding）；
//将InputStream数据转换为字节数组并将其存储到此包装器实例。
试一试{
InputStream InputStream=request.getInputStream（）；
this.rawData=IOUtils.toByteArray（inputStream）；
}捕获（IOE异常）{
投掷e；
}
}
@凌驾
公共ServletiInputStream getInputStream（）引发IOException{
final ByteArrayInputStream ByteArrayInputStream=新的ByteArrayInputStream（this.rawData）；
ServletInputStream ServletInputStream=新ServletInputStream（）{
public int read（）引发IOException{
返回byteArrayInputStream.read（）；
}
@凌驾
公共布尔值已完成（）{
//TODO自动生成的方法存根
返回false；
}
@凌驾
公共布尔值isReady（）{
//TODO自动生成的方法存根
返回false；
}
@凌驾
公共void setReadListener（ReadListener listener）{
//TODO自动生成的方法存根
}
};
返回servletInputStream；
}
@凌驾
public BufferedReader getReader（）引发IOException{
返回新的BufferedReader（新的InputStreamReader（this.getInputStream（），this.encoding））；
}
@凌驾
公共ServletRequest getRequest（）{
返回super.getRequest（）；
}
@凌驾
公共字符串getParameter（字符串名称）{
如果（！参数已设置）{
解析参数（）；
}
ArrayList values=this.parameters.get（name）；
if（values==null | | values.size（）==0）
返回null；
返回值。get（0）；
}
公共HashMap getParameters（）{
如果（！参数已设置）{
解析参数（）；
}
HashMap=newHashMap（this.parameters.size（）*2）；
for（字符串名称：this.parameters.keySet（））{
ArrayList values=this.parameters.get（name）；
map.put（name，values.toArray（新字符串[values.size（）]）；
}
返回图；
}
@抑制警告（“原始类型”）
@凌驾
公共映射getParameterMap（）{
返回getParameters（）；
}
@抑制警告（“原始类型”）
@凌驾
公共枚举getParameterNames（）{
返回新枚举（）{
@抑制警告（“未选中”）
私有字符串[]arr=（字符串[]）（getParameterMap（）.keySet（）.toArray（新字符串[0]）；
私有整数指数=0；
@凌驾
公共布尔值hasMoreElements（）{
返回指数