spring 重写请求对象

java

概要

1. 通过 HttpServletRequestWrapper 重写一个 HttpServletRequest
2. 通过过滤器提前吧 HttpServletRequest 换成自定义的 HttpServletRequestWrapper

一、重写 POST 请求体参数案例

1. 预定义一个继承 HttpServletRequestWrapper

• 重写 getReader()
• 重写 getInputStream()：@RequestBody 获取请求体时调用的方法

/**
 * 模拟请求对象类
 */
public class ParameterRequestWrapper extends HttpServletRequestWrapper {
    /**
     * 请求体容器
     */
    private byte[] body;
    /**
     * 实例化自定义的请求信息对象
     * @param request               原始请求信息
     * @param clazz                 请求参数映射类
     * @param unaryOperator         参数重置策略
     * @param <E>
     * @throws IOException
     */
    public <E> ParameterRequestWrapper(HttpServletRequest request, Class<E> clazz, UnaryOperator<E> unaryOperator) throws IOException {
        super(request);
        // 将 BufferedReader 装换成 json 字符串
        String json = StreamUtil.readText(request.getReader());
        // 赋予请求体内容
        body = getData(json,clazz,unaryOperator).getBytes();
    }
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }
    /**
     * 在使用@RequestBody注解的时候，其实框架是调用了getInputStream()方法
     * 重写获取请求体的方法
     * @return                  请求体输入流
     * @throws IOException
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bais = new ByteArrayInputStream(body);
        return 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 bais.read();
            }
        };
    }
    /**
     * 主要的参数替换逻辑
     * @param json                  请求体json字符串
     * @param clazz                 装载请求体的对象
     * @param unaryOperator         请求体参数替换策略
     * @return                      最终的请求体json字符串
     */
    private <E> String getData(String json, Class<E> clazz, UnaryOperator<E> unaryOperator){
        // 对象转json字符串
        return JSON.toJSONString(unaryOperator.apply(
                // json字符串转对象
                JSON.toJavaObject(JSON.parseObject(json), clazz)
        ));
    }
}

2. 在过滤器中修改请求对象参数

@Component
public class H5RequestFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // 重写request请求信息
        ParameterRequestWrapper parameterRequestWrapper = new ParameterRequestWrapper(
                // 最初的请求对象
                request,
                // 请求体装载对象
                User.class,
                // 重置策略
                user -> {
                    // 参数重写
                    user.setUserName("李大爷");
                    user.setAge(18);
                    return user;
                }
        );
        // 传入新的请求信息对象
        filterChain.doFilter(parameterRequestWrapper, response);
    }
}

二、重写普通参数案例

1. 预定义一个继承 HttpServletRequestWrapper

• 重写 getParameter()：取一个普通参数的方法
• 重写 getParameterValues()：取一个数组参数的方法
• 重写 getParameterMap()：取所有参数的方法

public class RequestWrapper extends HttpServletRequestWrapper {
    /**
     * 参数容器
     */
    private Map<String, String[]> params = new HashMap<>();
    public RequestWrapper(HttpServletRequest request) {
        super(request);
        //将现有parameter传递给params
        this.params.putAll(request.getParameterMap());
    }
    /**
     * 重写getParameter，代表参数从当前类中的map获取
     * @param name
     * @return
     */
    @Override
    public String getParameter(String name) {
        String[]values = params.get(name);
        if(values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }
    /**
     * 重写getParameterMap，代表参数从当前类中的map获取
     * @return
     */
    @Override
    public Map<String, String[]> getParameterMap() {
        return this.params;
    }
    /**
     * 同上
     * @param name          参数名
     * @return
     */
    @Override
    public String[] getParameterValues(String name) {
        return params.get(name);
    }
    /**
     * 批量修改参数
     * @param extraParams           参数map对象
     */
    public void addParameter(Map<String, Object> extraParams) {
        for (Map.Entry<String, Object> entry : extraParams.entrySet()) {
            addParameter(entry.getKey(), entry.getValue());
        }
    }
    /**
     * 添加参数，根据类型转换
     * @param name          参数名
     * @param value         参数值
     */
    public void addParameter(String name, Object value) {
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }
}