场景
实现
- 创建过滤器
```
package com.bderp.config;
import com.bderp.common.TrimFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.servlet.DispatcherType;
@Configuration
public class FilterConfig {
/**
* 去除参数头尾空格过滤器
*
* @return
*/
@Bean
public FilterRegistrationBean trimFilter() {
System.out.println("============过滤=================");
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setDispatcherTypes(DispatcherType.REQUEST);
registration.setFilter(new TrimFilter());
registration.addUrlPatterns("/*");
registration.setName("TrimFilter");
registration.setOrder(1);
return registration;
}
}
2. 创建过滤器类
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
public class TrimFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
filterChain.doFilter(new TrimHttpServletRequestWrapper((HttpServletRequest) servletRequest), servletResponse);
}
@Override
public void destroy() {
}
}
3. 创建请求参数过滤类
import com.bderp.utils.JsonTrimUtils;
import org.apache.commons.io.IOUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.util.StringUtils;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TrimHttpServletRequestWrapper extends javax.servlet.http.HttpServletRequestWrapper {
private Map<String , String[]> params = new HashMap<>();
public TrimHttpServletRequestWrapper(HttpServletRequest request) {
// 将request交给父类，以便于调用对应方法的时候，将其输出，其实父亲类的实现方式和第一种new的方式类似
super(request);
//将参数表，赋予给当前的Map以便于持有request中的参数
this.params.putAll(request.getParameterMap());
this.modifyParameterValues();
}
/**
* 重写getInputStream方法 post类型的请求参数必须通过流才能获取到值
*/
@Override
public ServletInputStream getInputStream() throws IOException {
System.out.println("data");
System.out.println("aaaaaaaaaaaaS");
//非json类型，直接返回
if(!super.getHeader(HttpHeaders.CONTENT_TYPE).contains(MediaType.APPLICATION_JSON_VALUE)){
return super.getInputStream();
}
//为空，直接返回
String json = IOUtils.toString(super.getInputStream(), "utf-8");
if (!StringUtils.hasLength(json)) {
return super.getInputStream();
}
ByteArrayInputStream bis = null;
try {
bis = new ByteArrayInputStream(JsonTrimUtils.jsonTrim(json).toJSONString().getBytes());
} catch (Exception e) {
throw new RuntimeException(e);
}
return new MyServletInputStream(bis);
}
/**
* 将parameter的值去除空格后重写回去
*/
public void modifyParameterValues(){
Set<String> set =params.keySet();
Iterator<String> it=set.iterator();
while(it.hasNext()){
String key= it.next();
String[] values = params.get(key);
for (int i = 0; i < values.length; i++) {
values[i] = values[i].trim();
}
params.put(key, values);
}
}
/**
* 重写getParameter 参数从当前类中的map获取
*/
@Override
public String getParameter(String name) {
String[]values = params.get(name);
if(values == null || values.length == 0) {
return null;
}
return values[0];
}
/**
* 重写getParameterValues
*/
@Override
public String[] getParameterValues(String name) {//同上
return params.get(name);
}
class MyServletInputStream extends ServletInputStream{
private ByteArrayInputStream bis;
public MyServletInputStream(ByteArrayInputStream bis){
this.bis=bis;
}
@Override
public boolean isFinished() {
return true;
}
@Override
public boolean isReady() {
return true;
}
@Override
public void setReadListener(ReadListener listener) {
}
@Override
public int read() {
return bis.read();
}
}
}
4. 创建过滤工具类
package com.bderp.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONValidator;
import java.util.Iterator;
import java.util.Map;
/**
// /*
// 去除json值前后空格
// @param json jsonStr
// @return
// */
// public static JSON jsonTrim(JSON json) throws Exception {
// if (json instanceof JSONObject) {
// return jsonTrim(json);
// } else if (json instanceof JSONArray) {
// jsonTrimArray((JSONArray) json);
// return json;
// }
// throw new Exception(“非JSON参数”);
// }
/**
* 去除value的空格
*
* @param jsonObject jsonObject
* @return
*/
public static JSONObject jsonTrim(JSONObject jsonObject) {
Iterator<Map.Entry<String, Object>> iterator = jsonObject.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Object> next = iterator.next();
Object value = next.getValue();
if (value != null) {
if (value instanceof String) {
//清空值前后空格
jsonObject.put(next.getKey(), ((String) value).trim());
} else if (value instanceof JSONObject) {
jsonTrim((JSONObject) value);
} else if (value instanceof JSONArray) {
jsonTrimArray((JSONArray) value);
}
}
}
return jsonObject;
}
/**
* 清空JSONArray 值前后空格
* @param array
*/
private static void jsonTrimArray(JSONArray array) {
if (array.size() > 0) {
for (int i = 0; i < array.size(); i++) {
Object object = array.get(i);
if (object != null) {
if (object instanceof String) {
array.set(i, ((String) object).trim());
} else if (object instanceof JSONObject) {
jsonTrim((JSONObject) object);
} else if (object instanceof JSONArray) {
jsonTrimArray((JSONArray) object);
}
}
}
}
}
}
```
参考
https://blog.csdn.net/L_fly_J/article/details/120991367
