springboot 使用filter过滤器对项目中的请求参数字符串类型前后空格进行去除

╰+哭是因爲堅強的太久メ 2021-10-13 03:43 366阅读 0赞

### **pom.xml：主要jar包 ** ###

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.4.RELEASE</version>
            <relativePath/> 
        </parent>
    
        <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>fastjson</artifactId>
          <version>1.2.45</version>
        </dependency>

### 1.写配置类，利用FilterRegistrationBean定义自定义过滤器 ###

import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.servlet.DispatcherType;
    
    /**
     * @author: lucifer
     * @date: 2019/8/21
     * @description:
     */
    @Configuration
    public class ParamsFilterConfig  {
        /**
         * 去除参数头尾空格过滤器
         * @return
         */
        @Bean
        public FilterRegistrationBean paramsFilterRegistration() {
            FilterRegistrationBean registration = new FilterRegistrationBean();
            registration.setDispatcherTypes(DispatcherType.REQUEST);
            registration.setFilter(new ParamsFilter());
            registration.addUrlPatterns("/*");
            registration.setName("paramsFilter");
            registration.setOrder(Integer.MAX_VALUE-1);
            return registration;
        }
    }

### 2.ParamsFilter类继承filter，并重写其中的方法。  ###

import org.springframework.stereotype.Component;
    
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import javax.servlet.http.HttpServletRequest;
    import java.io.IOException;
    
    /**
     * @author: lucifer
     * @date: 2019/8/21
     * @description:
     */
    @Component
    @WebFilter(urlPatterns = "/**", filterName = "ParamsFilter", dispatcherTypes = DispatcherType.REQUEST)
    public class ParamsFilter implements Filter {
    
        @Override
        public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2)
                throws IOException, ServletException {
            ParameterRequestWrapper parmsRequest = new ParameterRequestWrapper((HttpServletRequest) arg0);
            arg2.doFilter(parmsRequest, arg1);
        }
    
        @Override
        public void destroy() {
    
        }
    
        @Override
        public void init(FilterConfig arg0) {
    
        }
    
    
    }

### 3. 继承HttpServletRequestWrapper ，重写其中的方法 ###

import com.alibaba.fastjson.JSON;
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.http.HttpHeaders;
    import org.springframework.http.MediaType;
    
    import javax.servlet.ReadListener;
    import javax.servlet.ServletInputStream;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @author: lucifer
     * @date: 2019/8/21
     * @description:
     */
    public class ParameterRequestWrapper extends HttpServletRequestWrapper {
    
        private Map<String , String[]> params = new HashMap<>();
    
        public ParameterRequestWrapper(HttpServletRequest request) {
            // 将request交给父类，以便于调用对应方法的时候，将其输出，其实父亲类的实现方式和第一种new的方式类似
            super(request);
            //将参数表，赋予给当前的Map以便于持有request中的参数
            Map<String, String[]> requestMap=request.getParameterMap();
            System.out.println("转化前参数："+JSON.toJSONString(requestMap));
            this.params.putAll(requestMap);
            this.modifyParameterValues();
            System.out.println("转化后参数："+JSON.toJSONString(params));
        }
        /**
         * 重写getInputStream方法  post类型的请求参数必须通过流才能获取到值
         */
        @Override
        public ServletInputStream getInputStream() throws IOException {
          //非json类型，直接返回
           /* if(!super.getHeader(HttpHeaders.CONTENT_TYPE).equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)){
                return super.getInputStream();
            }*/
         if(!super.getHeader(HttpHeaders.CONTENT_TYPE).equalsIgnoreCase(MediaType.APPLICATION_JSON_UTF8_VALUE)){
                return super.getInputStream();
            }
            //为空，直接返回
            String json = IOUtils.toString(super.getInputStream(), "utf-8");
            if (StringUtils.isEmpty(json)) {
                return super.getInputStream();
            }
            System.out.println("转化前参数："+json);
            Map<String,Object> map=StringJsonUtils.jsonStringToMap(json);
            System.out.println("转化后参数："+JSON.toJSONString(map));
            ByteArrayInputStream bis = new ByteArrayInputStream(JSON.toJSONString(map).getBytes("utf-8"));
            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);
                values[0] = values[0].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. 将json串转化为map类型 ###

import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    
    import java.util.*;
    
    /**
     * @author: lucifer
     * @date: 2019/8/21
     * @description:
     */
    public class StringJsonUtils {
    
        public static Map<String, Object> jsonStringToMap(String jsonString) {
            Map<String, Object> map = new HashMap<>();
            JSONObject jsonObject = JSONObject.parseObject(jsonString);
            for (Object k : jsonObject.keySet()) {
                Object o = jsonObject.get(k);
                if (o instanceof JSONArray) {
                    List<Map<String, Object>> list = new ArrayList<>();
                    Iterator<Object> it = ((JSONArray) o).iterator();
                    while (it.hasNext()) {
                        Object obj = it.next();
                        list.add(jsonStringToMap(obj.toString()));
                    }
                    map.put(k.toString(), list);
                } else if (o instanceof JSONObject) {
                    // 如果内层是json对象的话，继续解析
                    map.put(k.toString(), jsonStringToMap(o.toString()));
                } else {
                    // 如果内层是普通对象的话，直接放入map中
                   // map.put(k.toString(), o.toString().trim()); 
                     if (o instanceof String) {
                       map.put(k.toString(), o.toString().trim());
                    } else {
                        map.put(k.toString(), o);
                    }   
                }
            }
            return map;
        }
    
    }

### 5.测试 ###

**        以下两种请求参数，均可以正常转化，并将其空格去除；**

**第一种：**

{
    	"cisBorderPassengers": [{
    		"itemReg": {
    			"safetySituation": "",
    			"phone": "",
    			"goodsNumber": "",
    			"goodsName": "          4536453453      ",
    			"remarks": ""
    		},
    		"hotelUid": "      21cd2c4b-821c-4297-b3d1-a1b141ff50ed    ",
    	}]
    }

**第二种：**

{
    	"orderNum":"4223cc9b6e4942fb825d6eec9bc46fcf1562650593578                 ",
    	"status":1,
    	"policeName":"李四              ",
    	"policeNumber":"666666                 ",
    	"auditRemark":"测试"
    }