去除空格

最新推荐文章于 2022-09-13 21:59:48 发布

Ccroyances

最新推荐文章于 2022-09-13 21:59:48 发布

阅读量528

点赞数

分类专栏：过滤器文章标签：过滤器

原文链接：https://blog.csdn.net/Muscleheng/article/details/80067772

版权

过滤器专栏收录该内容

1 篇文章 0 订阅

订阅专栏

遇见的问题：
前台把参数通过报文或者使用表单、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<String , String[]> params = new HashMap<String, String[]>();  
 // 构造方法
 public MyHttpServletRequestWrapper1(HttpServletRequest request) throws IOException {    
     super(request);
     // 把请求参数添加到我们自己的map当中
     this.params.putAll(request.getParameterMap()); 
 }    
 
 
 /**
  * 添加参数到map中
  * @param extraParams
  */
 public void setParameterMap(Map<String, Object> extraParams) {
     for (Map.Entry<String, Object> 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);
 }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
通过建立这个类我们就能完成向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<String> 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 {
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
第三步：过滤器的配置
方法一、在web.xml文件里面进行简单的配置（一般项目）

把我们的过滤器在该文件中注册

  <filter>  
    <filter-name>ValidatorFilter1</filter-name>  
    <!--  我们写的过滤的地址   -->
    <filter-class>com.zhh.filter.ValidatorFilter1</filter-class>  
</filter>  
<filter-mapping>  
    <filter-name>ValidatorFilter1</filter-name>  
    <url-pattern>/*</url-pattern>  
</filter-mapping>

1
2
3
4
5
6
7
8
9
10
方法二、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;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
controller 接收参数代码：

/**
 * 过滤方法测试
 */
@RequestMapping("/filterCsF2")
public void filterCs22(String email,String userName){
	System.out.println("处理后的参数："+userName+"  "+email);
}

1
2
3
4
5
6
7
请求示例代码：

请求demo username：

email：

age：

    <input type="reset" value="重置"/>&nbsp;&nbsp;
    <input type="button" id ="sub" value="提交">
</form>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
处理结果：

处理后的参数：21088888 zhaoheng@163.com
1
从结果可以看出，我们成功的通过过滤器对请求的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;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
通过建立这个类我们就能完成向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 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<String> 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<String, Object> map = new HashMap<String, Object>();
		// 把json对象转换为Map集合
		map = JSON.toJavaObject(jsonObject, Map.class);
		for (Entry<String, Object> 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 {

}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
第三步：
方法一、
在web.xml文件里面进行简单的配置

把我们的过滤器在该文件中注册

  <filter>  
    <filter-name>ValidatorFilter</filter-name> 
     <!--  我们写的过滤的地址   --> 
    <filter-class>com.zhh.filter.ValidatorFilter</filter-class>  
</filter>  
<filter-mapping>  
    <filter-name>ValidatorFilter</filter-name>  
    <url-pattern>/*</url-pattern>  
</filter-mapping>

1
2
3
4
5
6
7
8
9
10
11
方法二、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;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
controller 接收参数代码：

/**
* 过滤方法测试
* @RequestBody User user 该注解用于接收json请求的参数
* @return
*/
@ResponseBody
@RequestMapping(value = “/filterCs”)
public User filterCs(@RequestBody User user){
System.out.println(user.toString());
return user;
}

1
2
3
4
5
6
7
8
9
10
11
12
请求报文示例：
我这里使用的是postman工具进行json参数请求

{
“email”: “zhaoHENG@163.com”,
“userName”:“20181100”,
“age”:“18”
}

1
2
3
4
5
6
返回结果：

{
“email”: “zhaoheng@163.com”,
“userName”:“20181100”,
“age”:“18”
}

1
2
3
4
5
6
通过该过滤器，把email转换从小写成功。
通过以上操作，我们就成功的创建了一个过滤器。

还有一种方式比较简单，可以根据需求选择：
背景：对外提供接口，为了数据安全，接口入参进行了数据加密，接口收到参数后需要进行解密；如果每一个接口都要对入参进行一一的解密操作，就大大增加了代码量和工作量；

所以，这里使用自定义注解加Aop进行无侵入式的操作；

第一步：自定义注解
package com.example.demo.common;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

自定义注解
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD}) // 表示该注解只能用来修饰在方法上
public @interface SystemAopAnnotation {

String value() default “自定义注解”;
}

第二步：参数处理
package com.example.demo.common;

import java.util.Arrays;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

/**

aop实现
@author zhaoheng
*/
@Aspect
@Component
public class DeInterceptor {
private static final Logger log = LoggerFactory.getLogger(DeInterceptor.class);

/**
- 在方法执行之前、后执行该方法
- 设置需要执行该方法的类路径和注解
  /
  @Around("execution( com.example.demo.biz..(…)) && (@annotation(SystemAopAnnotation))")
  public Object interceptor(ProceedingJoinPoint point) throws Throwable {
  // 获取请求参数
  Object[] args = point.getArgs();
  String reqestParam = Arrays.toString(args);
  log.info(“interceptor-入参：{}”,reqestParam);
  
  // 处理参数
  JSONObject jsonObject = (JSONObject) JSON.toJSON(args[0]);
  Map<String, Object> map = new HashMap<String, Object>();
  
  // 把json对象转换为Map集合便于遍历处理参数
  map = JSON.toJavaObject(jsonObject, Map.class);
  for (Entry<String, Object> entry : map.entrySet()) {
  /**
  * 入参是base64编码，这里进行解码；也可以是其他方式加密，这里进行解密
  */
  byte[] base64decodedBytes = Base64.getDecoder().decode(entry.getValue().toString());
  String valueString = new String(base64decodedBytes, “utf-8”);
  map.put(entry.getKey(), valueString);
  }
  
  // 获取接收参数的类全路径
  String classPath = args[0].getClass().getName();
  // 把处理后的参数放回去
  args[0] = JSONObject.parseObject(JSONObject.toJSONString(map), Class.forName(classPath));
  // 获取响应数据
  Object result = point.proceed(args);
  return result;
  }

}
第三步：测试
1.实体类
import java.io.Serializable;

public class User implements Serializable{
private static final long serialVersionUID = -1101509992831103288L;

private String id;
private String name;

public String getId() {
	return id;
}
public void setId(String id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}

public static long getSerialversionuid() {
	return serialVersionUID;
}
@Override
public String toString() {
	return "User [id=" + id + ", name=" + name + "]";
}

}
2.controller
import com.example.demo.common.SystemAopAnnotation;

@CrossOrigin(origins = “*”)// 允许跨越
@RestController
@RequestMapping(“test”)
public class TestController {
private static final Logger log = LoggerFactory.getLogger(TestController.class);

// 测试的方法
@RequestMapping("/saveUser")
@SystemAopAnnotation("添加用户接口") // 自定义的注解
public String saveUser(@RequestBody User user) {
	log.info("Controller-收到的请求参数：{}",user.toString());
	return user.toString();
}

}
测试结果：
请求之前对数据进行了base64加密，经过aop处理（解密），controller得到的是解密后的数据

在这里插入图片描述

————————————————
版权声明：本文为CSDN博主「Muscleheng」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Muscleheng/article/details/107494382
————————————————
版权声明：本文为CSDN博主「Muscleheng」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Muscleheng/article/details/80067772

Ccroyances

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
去除空格

遇见的问题：前台把参数通过报文或者使用表单、ajax提交到后台，如果我们的请求参数是加密的，那么我们在controller里面的每一个方法里都需要进行解密处理。如果方法太多，那就太麻烦了。设计方案：使用过滤器，在一个Filter中将 HttpServletRequest 里的所有参数都取出来分别进行过滤然后再放回到该HttpServletRequest 中行不行呢？通过测试后发现是不行的，因为HttpServletRequest 只提供了getParameter ，而没有提供setParame
复制链接

扫一扫