参数格式说明：1.reqmsg=业务数据 2.sign=MD5数字签名

接口实现思路：配置springboot过滤器然后在写一个自定义的MyRequestWrapper 类继承HttpServletRequestWrapper 重写三个方法getParameterNames、getParameter、getParameterValues

1.过滤器代码

@Component
@Order
@WebFilter(urlPatterns = "/*", filterName = "requestParamFilter")
public class RequestParamFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest)servletRequest;
        HttpServletResponse rsp = (HttpServletResponse)servletResponse;
        /**
         * 自定义request类
         */
        MyRequestWrapper myReq = new MyRequestWrapper(req);
        filterChain.doFilter(myReq,rsp);
        //filterChain.doFilter(req,rsp);
    }
   @Override
    public void destroy() {
    }
}

2.自定义request类

public class MyRequestWrapper extends HttpServletRequestWrapper{

    private HttpServletRequest request;

    //将request对象中的参数修改后，放在这个集合里，随后项目取的所有Parameter都是从这个集合中取数
    private Set<String> keySet = new HashSet();

    //所有业务数据的全部明文内容（包括json符号）的MD5数字签名
    private String sign;

    public MyRequestWrapper(HttpServletRequest request) {
        super(request);
        this.request = request;

        //先通过request原生的方法，遍历获取到的参数
        Enumeration enu = request.getParameterNames();
        while (enu.hasMoreElements()) {
            String paraName = (String) enu.nextElement();
            try {
                if ("reqmsg".equals(paraName)) {
                    String decrypt = DesUtil.decrypt(request.getParameter(paraName).toString().replace(" ","+"));
                    if (JSONUtil.isJsonObject(decrypt)) {
                        JSONObject jsonObject = JSON.parseObject(decrypt);
                        keySet = JSONUtil.getAllKeys(jsonObject.toJSONString());
                    }
                }
                keySet.add(paraName);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(request.getParameter("sign") != null){
            sign = request.getParameter("sign");
        }
    }

    /**
     * 获取所有参数
     *
     * @return
     */
    @Override
    public Enumeration<String> getParameterNames() {

        Vector<String> v = new Vector<String>();
        for (String key : keySet) {
            v.add(key);
        }
        Enumeration<String> en = v.elements();
        return en;
    }

    /**
     * 重写了父类的 getParameter 方法
     *
     * @param name
     * @return
     */
    @Override
    public String getParameter(String name) {

        if (StringUtils.isNotBlank(name)) {
            if (request.getParameter("reqmsg") != null) {
                String reqmsg = request.getParameter("reqmsg").toString();
                try {
                    String decrypt = DesUtil.decrypt(reqmsg);
                    if (JSONUtil.isJsonObject(decrypt) && sign.equals(Base64.getEncoder().encodeToString(MD5Util.md5(decrypt,null)))) {
                        JSONObject jsonObject = JSON.parseObject(decrypt);
                        if (jsonObject.containsKey(name)) return jsonObject.getString(name);
                        return request.getParameter(name);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return request.getParameter(name);
        }
        return null;
    }

    /**
     * 重写了父类的 getParameterValues 方法
     *
     * @param name
     * @return
     */
    @Override
    public String[] getParameterValues(String name) {

        if (StringUtils.isNotBlank(name)) {
            if (request.getParameter("reqmsg") != null) {
                String reqmsg = request.getParameter("reqmsg").toString();
                try {
                    String decrypt = DesUtil.decrypt(reqmsg);
                    JSONObject jsonObject = JSON.parseObject(decrypt);
                    if (jsonObject.containsKey(name)  && sign.equals(Base64.getEncoder().encodeToString(MD5Util.md5(decrypt,null)))) {
                        String value = jsonObject.getString(name);
                        //判断是否是json数组
                        if (JSONUtil.isJsonArray(value)) {

                            JSONArray jsonArray = JSONArray.parseArray(value);
                            return (String[]) jsonArray.toArray();
                        }
                        return StringUtils.isNotBlank(value) ? new String[]{value} :  new String[]{};
                    }
                    return request.getParameterValues(name);

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return request.getParameterValues(name);
        }
        return null;
    }
}

3.用到的DES解密工具类

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.io.IOException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;

/**
 * 解密请求参数
 * Created by Administrator on 2019/5/21.
 */
public class DesUtil {

    /**
     * 加密解密方式
     */
    private final static String DES = "DES";
    /**
     * 秘钥
     */
    private final static String DEFAULTKEY = "mOAmKLeRIFz15XOTE1PWjg==";
    /**
     * 字符编码
     */
    private final static String ENCODE = "UTF-8";
    /**
     * 解码
     */
    private final static Base64.Decoder DECODER = Base64.getDecoder();
    /**
     * 编码
     */
    private final static Base64.Encoder ENCODER = Base64.getEncoder();
    
    /**
     * 加密
     * @param data
     * @return
     * @throws Exception
     */
    public static String encrypt(String data) throws Exception {
        byte[] bt = encrypt(data.getBytes(ENCODE), DEFAULTKEY.getBytes(ENCODE));
        String strs = ENCODER.encodeToString(bt);
        return strs;
    }

    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
        // 生成一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密钥数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密钥初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

        return cipher.doFinal(data);
    }

    /**
     * 解密
     * @param data
     * @return
     * @throws IOException
     * @throws Exception
     */
    public static String decrypt(String data) throws IOException, Exception {
        if (data == null)
            return null;

        byte[] buf = DECODER.decode(data);
        byte[] bt = decrypt(buf, DEFAULTKEY.getBytes(ENCODE));
        return new String(bt, ENCODE);
    }

    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
        // 生成一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密钥数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密钥初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

        return cipher.doFinal(data);
    }


    public static void main(String[] args) throws Exception {
        String data = "{\"districtId\":\"412\",\"size\":\"6\"}";
        // System.err.println(encrypt(data, key));
        // System.err.println(decrypt(encrypt(data, key), key));
        System.out.println(encrypt(data));
        System.out.println(decrypt(encrypt(data)));


    }
}

4.用的JSON工具类

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.springframework.util.StringUtils;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * Created by Administrator on 2019/5/23.
 */
public class JSONUtil {


    /**
     * bean对象转json字符串
     *
     * @param obj
     * @param dataFormatString
     * @return
     */
    public static String beanToJson(Object obj, String dataFormatString) {
        if (obj != null) {
            if (StringUtils.isEmpty(dataFormatString)) {
                return JSONObject.toJSONString(obj);
            }
            return JSONObject.toJSONStringWithDateFormat(obj, dataFormatString);
        }
        return null;
    }

    /**
     * bean对象转json字符串
     *
     * @param obj
     * @return
     */
    public static String beanToJson(Object obj) {
        if (obj != null) {
            return JSONObject.toJSONString(obj);
        }
        return null;
    }

    /**
     * string字符串转成json字符串
     *
     * @param key
     * @param value
     * @return
     */
    public static String stringToJonByFastjson(String key, String value) {
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
            return null;
        }
        Map<String, String> map = new HashMap<>();
        map.put(key, value);
        return beanToJson(map);
    }

    /**
     * json字符串转bean对象
     *
     * @param json
     * @param clazz
     * @return
     */
    public static Object stringToBean(String json, Object clazz) {
        if (StringUtils.isEmpty(json) || clazz == null) {
            return null;
        }
        return JSONObject.parseObject(json, clazz.getClass());
    }

    /**
     * json字符串转换成map对象
     *
     * @param json
     * @return
     */
    public static Map<String, Object> jsonToMap(String json) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        return JSONObject.parseObject(json, Map.class);
    }


    /**
     * 判断字符串是否可以转化为JSON数组
     *
     * @param content
     * @return
     */
    public static boolean isJsonArray(String content) {
        if (StringUtils.isEmpty(content))
            return false;
        StringUtils.isEmpty(content);
        try {
            JSONArray jsonStr = JSONArray.parseArray(content);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断字符串是否可以转化为json对象
     *
     * @param content
     * @return
     */
    public static boolean isJsonObject(String content) {
        if (StringUtils.isEmpty(content))
            return false;
        try {
            JSONObject jsonStr = JSONObject.parseObject(content);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 获取json字符串中所有的key值
     *
     * @param jsonString
     * @return
     */
    public static Set<String> getAllKeys(String jsonString) {
        Set<String> set = new HashSet<>();
        //按照","将json字符串分割成String数组
        String[] keyValue = jsonString.split(",");
        for (int i = 0; i < keyValue.length; i++) {
            String s = keyValue[i];
            //找到":"所在的位置，然后截取
            int index = s.indexOf(":");
            if (index == -1) {
                return set;
            }
            //第一个字符串因带有json的"{"，需要特殊处理
            if (i == 0) {
                set.add(s.substring(2, index - 1));
            } else {
                set.add(s.substring(1, index - 1));
            }
        }
        return set;
    }
}