目的

最近遇到了一个问题，应需求需要在原有的web项目中加上全局的RSA加密解密。原有的项目为手机APP和Springboot的后端接口实现。需要在后端加上全局的加密解密处理。

分析

查看了项目当中的代码，和手机APP交互的接口多为GET请求和POST请求，并且POST请求传递的消息为JSON数据格式并且接口采用了@RequestBody注解实现对参数的接受。存在的问题，并不是所有的接口都需要进行加密解密处理，比如说一些对接第三方的接口（已经有了相应的加密和解密操作），以及返回数据为查询的列表的数据（列表数据比较大加密会热别的满），综上考虑创建自定义注解实现对接口加密解密的个性化设置。
所以分析得出我们需要做的事情:

• 能够得到请求访问接口的方法以及类上面的注解信息（需要对注解信息进行判断）。
• 能够才接口执行前实现对密文的解密操作，在接口返回的时候对密文进行加密

方案抉择

通过上面的分析可以之后我们需要在接口的方法的前后需要执行相应的方法，初始我考虑了采用spring的aop的方式来实现这个问题，在AOP当中可以实现对方法上面注解的获取，但是存在一个问题就是在AOP当中无法获得请求的参数并对参数进行解密加密操作，所以又考虑了使用SPringMVC的拦截器来进行处理发现，也没有办法对参数进行预处理，后来查看了源码发现进入到了SpringMVC之后就无法对参数进行处理了，所以采用Servlet过滤器来实现，这里可以重新定义请求参数，在这里添加对参数的获取和插入用以实现参数的参数的解密操作。所以最终方案决定采用Servlet过滤器加拦截器的方式实现全局的解密。

实现

采用过滤器自定义参数，采用拦截器实现方法的加密以及解密。

依赖

 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>

有这个依赖就可以了。

实现步骤

首先添加自定义参数，重写setParmeter方法，因为在spring里面使用到的request对象没有这个方法。代码实现：
创建自定义请求参数类

public class ParameterRequestWrapper extends HttpServletRequestWrapper {
private Map<String, String[]> params = new HashMap<>();/*** 通过一个请求对象 创建对象的构造器* @param request* @throws IllegalArgumentException if the request is null*/
public ParameterRequestWrapper(HttpServletRequest request) {super(request);//将参数表，赋予给当前的Map以便于持有request中的参数this.params.putAll(request.getParameterMap());
}/*** 重载构造方法*/
public ParameterRequestWrapper(HttpServletRequest request, Map<String, Object> extendParams) {this(request);//这里将扩展参数写入参数表addAllParameters(extendParams);
}/*** 自定义的set请求参数的方法，原始的request是不允许我们修改参数的。* @param params*/
public void setParams(Map<String, String[]> params) {this.params = params;
}/*** 在获取所有的参数名,必须重写此方法，否则对象中参数值映射不上*  @return*/
@Override
public Enumeration<String> getParameterNames() {return new Vector(params.keySet()).elements();
}/*** 重写getParameter方法 用于获取我们自定义的参数里面的值；* @param name 参数名* @return 返回参数值*/
@Override
public String getParameter(String name) {String[] values = params.get(name);if (values == null || values.length == 0) {return super.getParameter(name);}return values[0];
}/*** 获得 参数的值 通过参数的name* @param name* @return*/
@Override
public String[] getParameterValues(String name) {String[] values = params.get(name);if (values == null || values.length == 0) {return super.getParameterValues(name);}return values;
}/*** 增加多个参数* @param otherParams 增加的多个参数*/
public void addAllParameters(Map<String, Object> otherParams) {for (Map.Entry<String, Object> entry : otherParams.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)});}}
}

在过滤器中改变请求参数

@WebFilter(filterName = "InstanceFilter", urlPatterns = "/*")    //配置过滤器名称和拦截的路径
@Component
public class MyrequestFilterForDecryptionRequest extends OncePerRequestFilter {@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {log.info("MyHandlerInterceptor添加自定义请求对象:"+httpServletRequest.getRequestURL());/*** 把请求参数换成我们自定义的。*/ParameterRequestWrapper parameterRequestWrapper = new ParameterRequestWrapper(httpServletRequest);filterChain.doFilter(parameterRequestWrapper, httpServletResponse);
}
}

以上我们就完成了在过滤器中实现参数的自定义了。我们接下来就是在拦截器当中判断方法和类上的注解，然后决定是否请求需要解密，如果需要解密我们就执行相应的解密方法：

添加拦截器

public class IntfaceSecurityInterceptor extends HandlerInterceptorAdapter {@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {log.info("IntfaceSecurityInterceptor:请求解密拦截器开始工作,这里解密");HandlerMethod handlerMethod = (HandlerMethod) handler;//获取类注解Class<?> beanType = handlerMethod.getBeanType();//用于重新编辑请求参数ParameterRequestWrapper requestWrapper = null;if(NeedEncryptionAndDecryptionUtil.hasClassAnnotation(beanType,DecryptRequest.class)){//存在解密的类注解并且他的value值为true 如果类为true 还需要判断方法是否也是trueif(NeedEncryptionAndDecryptionUtil.hasMethodAnnotation(handlerMethod,DecryptRequest.class)!=3){//方法中存在解密注解 并且注解值为truereturn super.preHandle(decryptRequestByMethod(request),response,handler);}}if(NeedEncryptionAndDecryptionUtil.hasMethodAnnotation(handlerMethod,DecryptRequest.class)==2){//方法中存在解密注解 并且注解值为truereturn super.preHandle(decryptRequestByMethod(request),response,handler);}//没有解密注解 直接走不解密了log.info("IntfaceSecurityInterceptor:不需要解密");return super.preHandle(request, response, handler);
}
/*** 通过请求的方式决定解密的方式 并解密* @param request* @return*/
private HttpServletRequest decryptRequestByMethod(HttpServletRequest request){//解密参数IntfaceSecurityParmeter securityParmeter = (IntfaceSecurityParmeter)SpringContextUtil.getBean("intfaceSecurityParmeter");//请求的方式（方式不同解密之后参数的组装就不同）String method=request.getMethod();//存储解密之后的新的请求参数ParameterRequestWrapper requestWrapper=(ParameterRequestWrapper)request;boolean result=false;String content = request.getParameter("content");if("GET".equals(method)){if (content==null){//单纯的GET请求，前端有一些接口访问接口的时候是没有参数的所以会存在这个情况result=true;}else{String decrypt = null;HashMap<String, String[]> map = new HashMap<>();try {content = content.replaceAll(" +","+");content = content.replaceAll("  ","++");content = content.replaceAll(" ","+");//使用别人的私钥进行解密decrypt = RSA.decryptByPrivateKey(content,securityParmeter.getMyPrivateKey());JSONObject jsonObject = isJSON(decrypt);//只能够是json对象，如果是数组不行if(jsonObject!=null){//组装使用JSON传递的参数Set<Map.Entry<String, Object>> set = jsonObject.entrySet();for (Map.Entry entry : jsonObject.entrySet()) {String key = entry.getKey().toString();String value = entry.getValue().toString();map.put(key,new String[]{value});}result=true;}else{//组装GET请求使用 key=value&key1=value1....的方式传递的时候map=getNoJsonParmeterMap(decrypt, map);result=true;}//把解密的参数加入到自定的请求参数当中去requestWrapper.setParams(map);} catch (Exception e) {result=false;log.error(request.getRequestURL()+"GET请求参数解密异常："+e.toString());throw new BussinessException("GET请求参数解密异常");}}}else if("POST".equals(method)){//对于POST请求,会出现这样的情况后台直接使用一个对象接受数据以及使用一个result=true;}if(result){return requestWrapper;}else{return request;}
}private HashMap getNoJsonParmeterMap(String decrypt, HashMap<String, String[]> map) {String[] split = decrypt.split("&");for (int i=0;i<split.length;i++){String[] split1 = split[i].split("=");if(split1.length==1){map.put(split1[0],new String[]{""});}else{map.put(split1[0],new String[]{split1[1]});}}return map;
}private JSONObject isJSON(String decrypt) {try {JSONObject object = JSONObject.parseObject(decrypt);return object;} catch (Exception e) {log.warn("当前的数据不是JSON,是作为一个判断存在的"+e.toString());return null;}
}
}

如上主要是针对GET请求的参数，当然也可以对POST请求的参数进行处理，但是因为在项目中的所有的POST请求都是采用了@RequestBody注解来接受JSON参数的，并且Spring为我们提供了一个在针对@RequestBody注解的这么一个注解@ControllerAdvice是一个Controller的增强器，以及RequestBodyAdvice接口。具体的使用：
采用@ControllerAdvice和RequestBodyAdvice实现解密POST请求传递JSON数据即被@RequestBody修饰的方法参数的解密

@ControllerAdvice
public class DecryptionRequestBodyControllerAdvice implements RequestBodyAdvice {
@Override
public boolean supports(MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {return true;
}@Override
public HttpInputMessage beforeBodyRead(HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) throws IOException {log.info("开始处理@RequestBody的请求并且解密");RequestAttributes attributes = RequestContextHolder.getRequestAttributes();HttpServletRequest request=null;if(attributes!=null){request= ((ServletRequestAttributes) attributes).getRequest();}String decryptBody=null;if( NeedEncryptionAndDecryptionUtil.needDecrypt(methodParameter) ){return new HttpInputMessageHandler(httpInputMessage, "UTF-8");}if(request!=null){log.info(request.getRequestURL()+"@RequestBody不需要解密");}
//        new HttpInputMessage();return httpInputMessage;
}@Override
public Object afterBodyRead(Object o, HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {return o;
}@Override
public Object handleEmptyBody(Object o, HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {return o;
}
}

当请求POST请求进来之后如果接口是被@RequestBody修饰的方法，那么就会在方法调用之前执行这个方法 beforeBodyRead，当然我们还需要自定义我们自己的HttpInputMessage类：如下

public class HttpInputMessageHandler implements HttpInputMessage {
private HttpInputMessage httpInputMessage;
private HttpInputMessage inputMessage;
private String charset;public HttpInputMessageHandler(HttpInputMessage inputMessage, String charset) {this.inputMessage = inputMessage;this.charset = charset;
}@Override
public InputStream getBody() {IntfaceSecurityParmeter securityParmeter = (IntfaceSecurityParmeter)SpringContextUtil.getBean("intfaceSecurityParmeter");InputStream result=null;try {String content = IoUtil.read(inputMessage.getBody() , charset);JSONObject jsonObject=null;try{jsonObject = JSON.parseObject(content);}catch(Exception e){log.error("POST请求参数格式错误");throw new BussinessException();}//获得的POST请求参数String content1 = (String)jsonObject.get("content");content1 = content1.replaceAll(" +","+");String decryptBody = RSA.decryptByPrivateKey(content1, securityParmeter.getMyPrivateKey());result = new ByteArrayInputStream(decryptBody.getBytes(charset));log.info("@RequestBody解密成功=========");} catch (Exception e) {RequestAttributes attributes = RequestContextHolder.getRequestAttributes();HttpServletRequest request=null;if(attributes!=null){request= ((ServletRequestAttributes) attributes).getRequest();log.error(request.getRequestURL()+"请求解密出现异常:",e.toString());}else{log.error("请求解密出现异常:",e.toString());}throw new BussinessException("POST请求解密失败或请求格式错误");}return result;
}@Override
public HttpHeaders getHeaders() {return inputMessage.getHeaders();
}
}

如上我项目中的所有的GET请求以及POST请求的解密就可以实现了。

实现返回信息加密
因为项目当中都是采用@ResponseBody的方式返回的JSON数据给前端，那么我就采用了和上面解决@RequestBody的方式来为返回数据进行加密操作：

@ControllerAdvice
public class EncryptionResponseBodyAdvice implements ResponseBodyAdvice {
@Override
public boolean supports(MethodParameter methodParameter, Class aClass) {return true;
}@Override
public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {log.info("@ResponseBody加密");IntfaceSecurityParmeter intfaceSecurityParmeter = (IntfaceSecurityParmeter)SpringContextUtil.getBean("intfaceSecurityParmeter");if(NeedEncryptionAndDecryptionUtil.needEncryption(methodParameter)){try {String resultString=null;if(o instanceof String){JSONObject resultJson= JSON.parseObject((String)o);resultString=resultJson.toString();}else{String jsonString = JSON.toJSONString(o);resultString=jsonString;}String encrypt = RSA.encryptByPublicKey(resultString, intfaceSecurityParmeter.getOtherPublicKey());log.info("@ResponseBody的相应加密成功");return new EncryptDto(encrypt);} catch (Exception e) {RequestAttributes attributes = RequestContextHolder.getRequestAttributes();HttpServletRequest request=null;if(attributes!=null){request= ((ServletRequestAttributes) attributes).getRequest();log.error(request.getRequestURL()+"@ResponseBody的相应加密失败:",e.toString());}else{log.error(serverHttpRequest.getURI()+"@ResponseBody的相应加密失败："+e.toString());}throw new BussinessException("相应加密失败");}}log.info("@ResponseBody不需要加密");return o;
}
}

总结

通过以上的方式可以实现我自己项目当中的统一加密解密操作，但是在和前端的交互过程当中也存在这比较多的问题。但基本上通过协调修改基本都是可以解决的。（这个也需要和前端协调好密文的传递格式等参数的组装等）
参考博客：
https://blog.csdn.net/xxssyyyyssxx/article/details/88219298.
https://blog.csdn.net/u013089490/article/details/84878319.
https://blog.csdn.net/jingYang07/article/details/102596100.