去除空格

程序员文章站 2022-04-03 08:54:28

...

遇见的问题：
前台把参数通过报文或者使用表单、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 [email protected]
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”: “[email protected]”,
“userName”:“20181100”,
“age”:“18”
}

1
2
3
4
5
6
返回结果：

{
“email”: “[email protected]”,
“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

去除空格

Zend Studio去除编辑器的语法警告设置方法

如何能去除春笋涩味呢，你有什么好方法吗

Photoshop快速去除红眼方法

去除口臭的简单偏方让你拥有清新口气

痘印怎么快速去除九个小妙招让痘印全无

去除白头粉刺，6个生活小秘籍

粉刺生长的原因六步去除粉刺拥有漂亮容颜

黑眼圈的原因有哪些六种居家小方法去除黑眼圈

如何使用camtasia软件去除视频水印？

万兴神剪手怎么去除视频黑边

去除空格

Zend Studio去除编辑器的语法警告设置方法

如何能去除春笋涩味呢，你有什么好方法吗

Photoshop快速去除红眼方法

去除口臭的简单偏方 让你拥有清新口气

痘印怎么快速去除 九个小妙招让痘印全无

去除白头粉刺，6个生活小秘籍

粉刺生长的原因 六步去除粉刺拥有漂亮容颜

黑眼圈的原因有哪些 六种居家小方法去除黑眼圈

如何使用camtasia软件去除视频水印？

万兴神剪手怎么去除视频黑边

去除口臭的简单偏方让你拥有清新口气

痘印怎么快速去除九个小妙招让痘印全无

粉刺生长的原因六步去除粉刺拥有漂亮容颜

黑眼圈的原因有哪些六种居家小方法去除黑眼圈