HttpServletRequest获取请求参数

	 /**
     * 获取客户端请求参数中所有的信息
     * @param request 请求
     * @param requestType 请求类型
     * @return 返回结果
     */
    private List<Map<String, Object>> getAllRequestParam(HttpServletRequest request, String requestType) {
        List<Map<String, Object>> resultList = new ArrayList<>();
        Map<String, Object> res = null;
        if (ServiceRealizationConstants.REQUEST_TYPE_GET.equalsIgnoreCase(requestType)){
            Enumeration<?> temp = request.getParameterNames();
            if (null != temp) {
                res = new HashMap<>();
                while (temp.hasMoreElements()) {
                    String en = (String) temp.nextElement();
                    String value = request.getParameter(en);
                    res.put(en, value);
                    //如果字段的值为空，判断若值为空，则删除这个字段>
                    if (null == res.get(en) || "".equals(res.get(en))) {
                        res.remove(en);
                    }
                }
                resultList.add(res);
            }
        }else if (ServiceRealizationConstants.REQUEST_TYPE_POST.equalsIgnoreCase(requestType)){
            resultList.addAll(getPostRequestParam(request));
        }
        return resultList;
    }

    /**
     * 获取application/json的请求参数
     * @param request 请求
     * @return 参数的map
     */
    private List<Map<String, Object>> getPostRequestParam(HttpServletRequest request){
        List<Map<String, Object>> result = new ArrayList<>();
        Map<String, Object> data = null;
        try {
            BufferedReader streamReader = new BufferedReader(new InputStreamReader(request.getInputStream(), "UTF-8"));
            StringBuilder responseStrBuilder = new StringBuilder();
            String inputStr;
            while ((inputStr = streamReader.readLine()) != null){
                responseStrBuilder.append(inputStr);
            }
            String str = responseStrBuilder.toString();
            if (JSONUtil.isJsonArray(str)){
                JSONArray re = JSONUtil.parseArray(str);
                for (int i = 0; i < re.size(); i++) {
                    JSONObject jsonObject = re.getJSONObject(i);
                    data = new HashMap<>();
                    convertJsonObject(result, data, jsonObject);
                }
            }else {
                JSONObject repsObject = JSONUtil.parseObj(str);
                data = new HashMap<>();
                convertJsonObject(result, data, repsObject);
            }
        }catch (Exception e){
            logger.error("获取post请求中的application/json中的内容时，出现异常:{}", e.getMessage());
            throw new ServiceException(ExceptionCodeEnum.PARAM_ERROR.getCode(), "post中内容获取时，出现异常");
        }
        return result;
    }

    /**
     * 将JsonObject数据转换成map
     * @param result map的集合
     * @param data 存放数据的map
     * @param repsObject JsonObject对象
     * @return map数据的集合
     */
    private List<Map<String, Object>> convertJsonObject(List<Map<String, Object>> result, Map<String, Object> data, JSONObject repsObject){
        Iterator it = repsObject.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Object> entry = (Map.Entry<String, Object>) it.next();
            data.put(entry.getKey(), entry.getValue());
        }
        result.add(data);
        return result;
    }

注意：
如果post请求获取后，在后续还需要重新从request.getInputStream()中获取数据，就需要将传递的HttpServletRequest对象修改为自定义的MyServletRequestWrapper对象，否则，会存在第二次获取不到数据。MyServletRequestWrapper代码如下：

import org.apache.commons.io.IOUtils;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @author: 
 * @date: 2023-02-07 10:33
 * @description: 自定义的requestWrapper，用于将接收的请求信息封装到body中，进行重复的使用。
 *              解决post请求中的参数只能获取一次的问题
 */
public class MyServletRequestWrapper extends HttpServletRequestWrapper {

    /**
     * 请求的内容的二进制数组
     */
    private final byte[] body;

    public MyServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        body = IOUtils.toByteArray(super.getInputStream());
    }

    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream(){
        return new RequestBodyCachingInputStream(body);
    }

    private static class RequestBodyCachingInputStream extends ServletInputStream {
        private byte[] body;
        private int lastIndexRetrieved = -1;
        private ReadListener listener;

        public RequestBodyCachingInputStream(byte[] body) {
            this.body = body;
        }

        @Override
        public int read() throws IOException {
            if (isFinished()) {
                return -1;
            }
            int i = body[lastIndexRetrieved + 1];
            lastIndexRetrieved++;
            if (isFinished() && listener != null) {
                try {
                    listener.onAllDataRead();
                } catch (IOException e) {
                    listener.onError(e);
                    throw e;
                }
            }
            return i;
        }

        @Override
        public boolean isFinished() {
            return lastIndexRetrieved == body.length - 1;
        }

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

        @Override
        public void setReadListener(ReadListener listener) {
            if (listener == null) {
                throw new IllegalArgumentException("listener cann not be null");
            }
            if (this.listener != null) {
                throw new IllegalArgumentException("listener has been set");
            }
            this.listener = listener;
            if (!isFinished()) {
                try {
                    listener.onAllDataRead();
                } catch (IOException e) {
                    listener.onError(e);
                }
            } else {
                try {
                    listener.onAllDataRead();
                } catch (IOException e) {
                    listener.onError(e);
                }
            }
        }

        @Override
        public int available() throws IOException {
            return body.length - lastIndexRetrieved - 1;
        }

        @Override
        public void close(){
            lastIndexRetrieved = body.length - 1;
            body = null;
        }
    }
}

依赖的pom:

<dependency>
   <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.7</version>
</dependency>