后端Aes256加解密改变HttpServletRequest中请求参数，或添加请求参数

后端Aes256加解密改变HttpServletRequest中请求参数，或添加请求参数

因为项目中api交互需要进行接口加密，所以把请求参数统一解密，加解密方式就不细说网上很多工具类，详细讲一下如何改变前端或app端请求的参数。

首先我们我们接收请求参数的方式有两种，一种是直接拼接在url之后，另一种是@RequestBody的方式包在body中。我们需要重写一个ParameterRequestWrapper 继承HttpServletRequestWrapper

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.aer.util.AES256Util;
import com.aer.util.StringUtils;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import sun.security.krb5.internal.crypto.Aes256;

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.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class ParameterRequestWrapper extends HttpServletRequestWrapper {
    
    private Map<String , String[]> params = new HashMap<String, String[]>();
    private byte[] body;
 
    @SuppressWarnings("unchecked")
    public ParameterRequestWrapper(HttpServletRequest request) {
        // 将request交给父类，以便于调用对应方法的时候，将其输出，其实父亲类的实现方式和第一种new的方式类似
        super(request);
        //将参数表，赋予给当前的Map以便于持有request中的参数
        //由于request并没有提供现成的获取json字符串的方法，所以我们需要将body中的流转为字符串
        String json =getPostData(request);
        if(StringUtils.isNotEmpty(json)){
            this.body = getData(json).getBytes();
        }
        this.params.putAll(request.getParameterMap());
    }
    //重载一个构造方法
    public ParameterRequestWrapper(HttpServletRequest request , Map<String , Object> extendParams) {
        this(request);
        addAllParameters(extendParams);//这里将扩展参数写入参数表
    }
    
    @Override
    public String getParameter(String name) {//重写getParameter，代表参数从当前类中的map获取
        String[]values = params.get(name);
        if(values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }
    
    public String[] getParameterValues(String name) {//同上
         return params.get(name);
    }
 
   public void addAllParameters(Map<String , Object>otherParams) {//增加多个参数
        for(Map.Entry<String , Object>entry : otherParams.entrySet()) {
            addParameter(entry.getKey() , entry.getValue());
        }
    }
 
 
    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)});
            }
        }
    }


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

    /**
     * 在使用@RequestBody注解的时候，其实框架是调用了getInputStream()方法，所以我们要重写这个方法
     * @return
     * @throws IOException
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        if(body == null){
            body = new byte[0];
        }
        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();
            }
        };
    }


    //body中参数解密
    private String getData(String json){
        //加密，如果传过来的是加密数据，先解密，未加密直接返回原json
//        if(StringUtils.isNotEmpty(json)){
//            json = AES256Util.decode(json);
//            if(StringUtils.isEmpty(json)){
//                return "";
//            }
//            JSONObject object = JSONUtil.parseObj(json);
//            return JSONUtil.toJsonStr(object);
//        }
        //不加密
        return json;

    }



    public static String getPostData(HttpServletRequest request) {
        StringBuilder data = new StringBuilder();
        String line;
        BufferedReader reader;
        try {
            reader = request.getReader();
            while (null != (line = reader.readLine())) {
                data.append(line);
            }
        } catch (IOException e) {
            return null;
        }
        return data.toString();
    }
}

1.接收拼接的参数：

 ParameterRequestWrapper requestWrapper = new ParameterRequestWrapper(request);
                    // 请求的参数 拼接
                    Map<String, String> rtnMap = converMap(request.getParameterMap());
                    // 请求参数 body
                    Set<String> keySet = rtnMap.keySet();
                    //解密value
                    for (String str : keySet) {
                        String value = rtnMap.get(str);
                        requestWrapper.addParameter(str, value);
                    }




  /**
     * 转换request 请求参数
     *
     * @param paramMap request获取的参数数组
     */
    public Map<String, String> converMap(Map<String, String[]> paramMap) {
        Map<String, String> rtnMap = new HashMap<String, String>();

        //加密 前端传过来的参数是加密过的，这边做解密操作
        String encodeParam = "";
        for (String key : paramMap.keySet()) {
            if (StringUtils.isNotEmpty(key)) {
                for (int i = 0; i < key.length(); i++) {
                    //加密过来所有加号会变成空格，把空格全部替换成+
                    String index = String.valueOf(key.charAt(i));
                    if (index.equals(" ")) {
                        index = "+";
                    }
                    encodeParam += index;
                }
                break;
            }
        }
        if (StringUtils.isNotEmpty(encodeParam)) {
            String param = AES256Util.decode(encodeParam);
            String[] paramIndex = param.split("&&");
            for (int i = 0; i < paramIndex.length; i++) {
                String[] eachParam = paramIndex[i].split("=");
                rtnMap.put(eachParam[0], eachParam.length > 1 ? eachParam[1] : "");
            }
        }


        //不加密
        for (String key : paramMap.keySet()) {
            rtnMap.put(key, "");
        }
        return rtnMap;
    }

2.body中的参数：需要重写ServletInputStream ，已在ParameterRequestWrapper 处理完成，如上图代码。

3.最后在过滤器中new一个我们刚写好的的 ParameterRequestWrapper

 ParameterRequestWrapper requestWrapper = new ParameterRequestWrapper(request);
 filterChain.doFilter(requestWrapper, response);

4.注意*在接口中使用ParameterRequestWrapper request