通过filter过滤器对请求参数进行处理-完整
遇见的问题：
前台把参数通过报文或者使用表单、ajax提交到后台，如果我们的请求参数是加密的，那么我们在controller里面的每一个方法里都需要进行解密处理。如果方法太多，那就太麻烦了。
设计方案：
使用过滤器，在一个Filter中将 HttpServletRequest 里的所有参数都取出来分别进行过滤然后再放回到该HttpServletRequest 中行不行呢？通过测试后发现是不行的，因为HttpServletRequest 只提供了getParameter ，而没有提供setParameter；所以，我们只能自己写一个HttpServletRequest 方法继承HttpServletRequestWrapper，然后覆盖里面的方法，并且增加我们自己的setParameters方法，这样我们就可以为所欲为了，最后再在filter中调用该类的方法对参数进行处理（获取、修改、存储等等）。
还有一种比较简单的方式：使用aop加自定义注解来实现（点击跳转）
解决方案：
在请求参数到达controller之前，在filter里面进行解密；这样，通过简单的过滤器处理，把需要处理的请求都在过滤器里进行解密操作，这样就等于实现了自动化处理。
这里我们针对两种不同的请求方式进行讲解：1.普通的表单、ajax请求；2.json格式的报文请求。（三步搞定）
1.普通的表单、ajax请求；
第一步：新建一个类
这个类继承自HttpServletRequestWrapper
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
/**
* 重写 HttpServletRequestWrapper
* 处理表单、ajax请求
* @author zhaoheng
*
*/
public class MyHttpServletRequestWrapper1 extends HttpServletRequestWrapper{
// 用于存储请求参数
private Map params = new HashMap();
// 构造方法
public MyHttpServletRequestWrapper1(HttpServletRequest request) throws IOException {
super(request);
// 把请求参数添加到我们自己的map当中
this.params.putAll(request.getParameterMap());
}
/**
* 添加参数到map中
* @param extraParams
*/
public void setParameterMap(Map extraParams) {
for (Map.Entry entry : extraParams.entrySet()) {
setParameter(entry.getKey(), entry.getValue());
}
}
/**
* 添加参数到map中
* @param name
* @param value
*/
public void setParameter(String name, Object value) {
if (value != null) {
System.out.println(value);
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)});
}
}
}
/**
* 重写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];
}
/**
* 重写getParameterValues方法，从当前类的 map中取值
* @param name
* @return
*/
@Override
public String[] getParameterValues(String name) {
return params.get(name);
}
}
通过建立这个类我们就能完成向request对象添加我们处理之后的参数了。
第二步：通过实现filter接口建一个过滤器
package com.zhh.filter;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.apache.log4j.Logger;
import com.zhh.util.request.MyHttpServletRequestWrapper1;
/**
* 参数处理验过滤器（针对ajax、表单等请求） 1.获取请求参数； 2.对获取到的请求参数进行处理（解密、字符串替、请求参数分类截取等等）； 3.把处理后的参数放回到请求列表里面
*
* @author zhaoheng
*
*/
public class ValidatorFilter1 implements Filter {
private static final Logger log = Logger.getLogger(ValidatorFilter1.class);
/**
* 需要过滤的地址
*/
private static List urlList = Arrays.asList("/pastOrder/filterCsF");
/**
* 是否不需要过滤
*
* @param requestUrl
* 请求的url
* @return
*/
public boolean isPast(String requestUrl) {
for (String url : urlList) {
if (requestUrl.equals(url)) {
return true;
}
}
return false;
}
@Override
public void destroy() {
}
@SuppressWarnings("unchecked")
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
log.info("过滤器2执行开始");
String url = ((HttpServletRequest) request).getRequestURI().substring(((HttpServletRequest)request).getContextPath().length());
//通过地址对特定的请求进行处理，如果不需要可以不用，如果不用，就会对使用的请求进行过滤
if (isPast(url)) {
MyHttpServletRequestWrapper1 requestWrapper1 = new MyHttpServletRequestWrapper1(
(HttpServletRequest) request);
// 1.获取需要处理的参数
String email = requestWrapper1.getParameter("email");
// 2.把处理后的参数放回去（这里是大小转小写处理）
requestWrapper1.setParameter("email", email.toLowerCase());
// 3.放行，把我们的requestWrapper1放到方法当中
chain.doFilter(requestWrapper1, response);
} else {
chain.doFilter(request, response);
}
}
@Override
public void init(FilterConfig arg0) throws ServletException {
}
}
第三步：过滤器的配置
方法一、在web.xml文件里面进行简单的配置（一般项目）
把我们的过滤器在该文件中注册
ValidatorFilter1
com.zhh.filter.ValidatorFilter1
ValidatorFilter1
/*
方法二、springboot项目的配置
新建一个配置类，加上@Configuration注解，在方法头加上@Bean注解
@Configuration
public class WebFileterConfig {
/**
* 配置过滤器
* order属性:控制过滤器加载顺序：数字越小，加载越早
* @return
*/
@Bean
public FilterRegistrationBean ValidatorFilterRegistration() {
//新建过滤器注册类
FilterRegistrationBean registration = new FilterRegistrationBean();
// 添加我们写好的过滤器
registration.setFilter( new ValidatorFilter1());
// 设置过滤器的URL模式
registration.addUrlPatterns("/*");
registration.setOrder(Integer.MAX_VALUE-10);
return registration;
}
}
controller 接收参数代码：
/**
* 过滤方法测试
*/
@RequestMapping("/filterCsF2")
public void filterCs22(String email,String userName){
System.out.println("处理后的参数："+userName+" "+email);
}
请求示例代码：
请求demo
处理结果：
处理后的参数：21088888 [email protected]
从结果可以看出，我们成功的通过过滤器对请求的email进行大写转小写处理
2.json格式的报文请求；
第一步：新建一个类
这个类继承自HttpServletRequestWrapper
package com.zhh.util.request;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import jodd.io.StreamUtil;
/**
* 重写 HttpServletRequestWrapper
* 处理json报文请求
* @author zhaoheng
*
*/
public class MyHttpServletRequestWrapper extends HttpServletRequestWrapper{
private byte[] body; //用于保存读取body中数据
public MyHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
//读取请求的数据保存到本类当中
body = StreamUtil.readBytes(request.getReader(), "UTF-8");
}
//覆盖（重写）父类的方法
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
//覆盖（重写）父类的方法
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream bais = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public int read() throws IOException {
return bais.read();
}
};
}
/**
* 获取body中的数据
* @return
*/
public byte[] getBody() {
return body;
}
/**
* 把处理后的参数放到body里面
* @param body
*/
public void setBody(byte[] body) {
this.body = body;
}
}
通过建立这个类我们就能完成向request对象添加我们处理之后的参数了。
第二步：通过实现filter接口建一个过滤器
package com.zhh.filter;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.apache.log4j.Logger;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zhh.util.request.MyHttpServletRequestWrapper;
/**
* 参数校验过滤器（针对json报文请求） 1.获取请求参数； 2.对获取到的请求参数进行处理（解密、字符串替、请求参数分类截取等等）； 3.把处理后的参数放回到请求列表里面
*
* @author zhaoheng
*
*/
public class ValidatorFilter implements Filter {
private static final Logger log = Logger.getLogger(ValidatorFilter.class);
/**
* 需要过滤的地址
*/
private static List urlList = Arrays.asList("/pastOrder/filterCs");
/**
* 是否需要过滤
*
* @param requestUrl
* 请求的url
* @return
*/
public boolean isPast(String requestUrl) {
for (String url : urlList) {
if (requestUrl.equals(url)) {
return true;
}
}
return false;
}
@Override
public void destroy() {
log.info("过滤器执行结束");
}
@SuppressWarnings("unchecked")
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
log.info("过滤器1执行开始");
String url0 = ((HttpServletRequest) request).getRequestURI();
String url1 = ((HttpServletRequest) request).getContextPath();
System.out.println("完整地址："+url0);
System.out.println("返回当前页面所在的应用的名字："+url1);
System.out.println("返回当前页面所在的应用的名字长度："+url1.length());
// 获取请求地址
String url = ((HttpServletRequest) request).getRequestURI().substring(((HttpServletRequest)request).getContextPath().length());
System.out.println("截取后的地址："+url);
if (isPast(url)) {
//处理json报文请求
MyHttpServletRequestWrapper requestWrapper = new MyHttpServletRequestWrapper(
(HttpServletRequest) request);
// 读取请求内容
BufferedReader br;
br = requestWrapper.getReader();
String line = null;
StringBuilder sb = new StringBuilder();
while ((line = br.readLine()) != null) {
sb.append(line);
}
// 将json字符串转换为json对象
JSONObject jsonObject = JSONObject.parseObject(sb.toString());
Map map = new HashMap();
// 把json对象转换为Map集合
map = JSON.toJavaObject(jsonObject, Map.class);
for (Entry entry : map.entrySet()) {
// 把邮箱地址转换为小写
if (entry.getKey().equals("email")) {
map.put(entry.getKey(), entry.getValue().toString()
.toLowerCase());
}
}
// 把参数转换之后放到我们的body里面
String json = JSON.toJSONString(map);
requestWrapper.setBody(json.getBytes("UTF-8"));
// 放行
chain.doFilter(requestWrapper, response);
} else {
chain.doFilter(request, response);
}
}
@Override
public void init(FilterConfig arg0) throws ServletException {
}
}
第三步：
方法一、
在web.xml文件里面进行简单的配置
把我们的过滤器在该文件中注册
ValidatorFilter
com.zhh.filter.ValidatorFilter
ValidatorFilter
/*
方法二、springboot项目的配置
新建一个配置类，加上@Configuration注解，在方法头加上@Bean注解
@Configuration
public class WebFileterConfig {
/**
* 配置过滤器
* order属性:控制过滤器加载顺序：数字越小，加载越早
* @return
*/
@Bean
public FilterRegistrationBean ValidatorFilterRegistration() {
//新建过滤器注册类
FilterRegistrationBean registration = new FilterRegistrationBean();
// 添加我们写好的过滤器
registration.setFilter( new ValidatorFilter());
// 设置过滤器的URL模式
registration.addUrlPatterns("/*");
registration.setOrder(Integer.MAX_VALUE-10);
return registration;
}
}
controller 接收参数代码：
/**
* 过滤方法测试
* @RequestBody User user 该注解用于接收json请求的参数
* @return
*/
@ResponseBody
@RequestMapping(value = "/filterCs")
public User filterCs(@RequestBody User user){
System.out.println(user.toString());
return user;
}
请求报文示例：
我这里使用的是postman工具进行json参数请求
{
"email": "[email protected]",
"userName":"20181100",
"age":"18"
}
返回结果：
{
"email": "[email protected]",
"userName":"20181100",
"age":"18"
}
通过该过滤器，把email转换从小写成功。
通过以上操作，我们就成功的创建了一个过滤器。
还有一种方式比较简单，可以根据需求选择：
使用aop加自定义注解来实现（点击跳转）