• Filter拦截过滤参数

     来自连接SpringBoot过滤器（过滤请求参数） - 简书

    获取http参数有两种方式，一种通过request.getParameter获取Get方式传递的参数，另外一种是通过request.getInputStream或reques.getReader获取通过POST/PUT/DELETE/PATCH传递的参数；

    • @PathVariable注解是REST风格url获取参数的方式，只能用在GET请求类型，通过getParameter获取参数
    • @RequestParam注解支持GET和POST/PUT/DELETE/PATCH方式，Get方式通过getParameter获取参数和post方式通过getInputStream或getReader获取参数
    • @RequestBody注解支持POST/PUT/DELETE/PATCH，可以通过getInputStream和getReader获取参数
    • HttpServletRequest参数可以通过getParameter和getInputStream或getReader获取参数

    上述通过getInputStream或getReader在拦截器中获取会导致控制器拿到的参数为空，这是因为流读取一次之后流的标志位已经发生了变化，无法多次读取参数；

    通过HttpServletRequestWrapper包装类每次读取参数后再回写参数

    1. 创建ParamsFilter实现Filter接口

    1. package com.example.filter;
    2.  
    3. import javax.servlet.*;
    4. import javax.servlet.http.HttpServletRequest;
    5. import java.io.IOException;
    6.  
    7. /**
    8.  * 
    9.  * @description: 请求参数过滤器
    10.  * 
    11.  */
    12. public class ParamsFilter implements Filter {
    13.  
    14.     @Override
    15.     public void init(FilterConfig filterConfig) throws ServletException {
    16.  
    17.     }
    18.  
    19.     @Override
    20.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    21.  
    22.         HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
    23.  
    24.         ParamsRequestWrapper requestWrapper = new ParamsRequestWrapper(httpRequest);
    25.         filterChain.doFilter(requestWrapper, servletResponse);
    26.  
    27.     }
    28.  
    29.     @Override
    30.     public void destroy() {
    31.  
    32.     }
    33.  
    34. }

    1. 过滤请求参数

      1. package com.example.filter;
      2.  
      3. import com.alibaba.fastjson.JSON;
      4. import org.apache.commons.io.IOUtils;
      5. import org.apache.commons.lang3.StringUtils;
      6. import org.springframework.http.HttpHeaders;
      7. import org.springframework.http.MediaType;
      8.  
      9. import javax.servlet.ServletInputStream;
      10. import javax.servlet.http.HttpServletRequest;
      11. import javax.servlet.http.HttpServletRequestWrapper;
      12. import java.io.ByteArrayInputStream;
      13. import java.io.IOException;
      14. import java.util.HashMap;
      15. import java.util.Iterator;
      16. import java.util.Map;
      17. import java.util.Set;
      18.  
      19. /**
      20.  * 
      21.  * @description: 对请求参数进行过滤
      22.  * 
      23.  */
      24. public class ParamsRequestWrapper extends HttpServletRequestWrapper {
      25.  
      26.     private Map params = new HashMap<>();
      27.     private static final String ENCODING = "UTF-8";
      28.     private static final String CLASSTYPE = "java.lang.String";
      29.  
      30.     public ParamsRequestWrapper(HttpServletRequest request) {
      31.         super(request);
      32.         // 将参数表，赋予给当前的Map以便于持有request中的参数
      33.         Map requestMap = request.getParameterMap();
      34.         System.out.println("转化前参数：" + JSON.toJSONString(requestMap));
      35.         this.params.putAll(requestMap);
      36.         this.modifyParameters();
      37.         System.out.println("转化后参数：" + JSON.toJSONString(params));
      38.     }
      39.  
      40.  
      41.     /**
      42.      * 重写getInputStream方法  post请求参数必须通过流才能获取到值
      43.      */
      44.     @Override
      45.     public ServletInputStream getInputStream() throws IOException {
      46.  
      47.         ServletInputStream stream = super.getInputStream();
      48.  
      49.         //非json类型，直接返回
      50.         if (!super.getHeader(HttpHeaders.CONTENT_TYPE).equalsIgnoreCase(MediaType.APPLICATION_JSON_VALUE)) {
      51.             return stream;
      52.         }
      53.         String json = IOUtils.toString(stream, ENCODING);
      54.  
      55.         if (StringUtils.isBlank(json)) {
      56.             return stream;
      57.         }
      58.  
      59.         System.out.println("转化前参数：" + json);
      60.         Map map = modifyParams(json);
      61.         System.out.println("转化后参数：" + JSON.toJSONString(map));
      62.  
      63.         ByteArrayInputStream bis = new ByteArrayInputStream(JSON.toJSONString(map).getBytes(ENCODING));
      64.  
      65.         return new ParamsServletInputStream(bis);
      66.     }
      67.  
      68.     private static Map modifyParams(String json) {
      69.  
      70.         Map params = JSON.parseObject(json);
      71.         Map maps = new HashMap<>(params.size());
      72.         for (String key : params.keySet()) {
      73.             Object value = getValue(params.get(key));
      74.             maps.put(key, value);
      75.         }
      76.         return maps;
      77.     }
      78.  
      79.     private static Object getValue(Object obj) {
      80.  
      81.         if (obj == null) {
      82.             return null;
      83.         }
      84.         String type = obj.getClass().getName();
      85.         // 对字符串的处理
      86.         if (CLASSTYPE.equals(type)) {
      87.             obj = obj.toString().trim();
      88.         }
      89.         return obj;
      90.     }
      91.  
      92.     /**
      93.      * 将parameter的值去除空格后重写回去
      94.      */
      95.     private void modifyParameters() {
      96.         Set set = params.keySet();
      97.         Iterator it = set.iterator();
      98.         while (it.hasNext()) {
      99.             String key = (String) it.next();
      100.             String[] values = params.get(key);
      101.             values[0] = values[0].trim();
      102.             params.put(key, values);
      103.         }
      104.     }
      105.  
      106.     /**
      107.      * 重写getParameter 参数从当前类中的map获取
      108.      */
      109.     @Override
      110.     public String getParameter(String name) {
      111.         String[] values = params.get(name);
      112.         if (values == null || values.length == 0) {
      113.             return null;
      114.         }
      115.         return values[0];
      116.     }
      117.  
      118. }

    3. 字节数据转换流（Map → ByteArrayInputStream → ServletInputStream ）

    1. package com.example.filter;
    2.  
    3. import javax.servlet.ReadListener;
    4. import javax.servlet.ServletInputStream;
    5. import java.io.ByteArrayInputStream;
    6. import java.io.IOException;
    7.  
    8. /**
    9.  * 
    10.  * @description: 请求参数输入流
    11.  * 
    12.  */
    13. public class ParamsServletInputStream extends ServletInputStream {
    14.  
    15.     private ByteArrayInputStream bis;
    16.  
    17.     public ParamsServletInputStream(ByteArrayInputStream bis) {
    18.         this.bis = bis;
    19.     }
    20.  
    21.     @Override
    22.     public boolean isFinished() {
    23.         return true;
    24.     }
    25.  
    26.     @Override
    27.     public boolean isReady() {
    28.         return true;
    29.     }
    30.  
    31.     @Override
    32.     public void setReadListener(ReadListener readListener) {
    33.  
    34.     }
    35.  
    36.     @Override
    37.     public int read() throws IOException {
    38.         return bis.read();
    39.     }
    40.  
    41. }
    1. 过滤器配置类
    1. package com.example.config;
    2.  
    3. import com.example.filter.ParamsFilter;
    4. import org.springframework.boot.web.servlet.FilterRegistrationBean;
    5. import org.springframework.context.annotation.Bean;
    6. import org.springframework.context.annotation.Configuration;
    7.  
    8. import javax.servlet.DispatcherType;
    9.  
    10. /**
    11.  * @description: 过滤器配置类
    13.  */
    14. @Configuration
    15. public class FilterConfig {
    16.  
    17.     @Bean
    18.     public FilterRegistrationBean parmsFilterRegistration() {
    19.         FilterRegistrationBean registration = new FilterRegistrationBean();
    20.         registration.setDispatcherTypes(DispatcherType.REQUEST);
    21.         registration.setFilter(new ParamsFilter());
    22.         registration.addUrlPatterns("/*");
    23.         registration.setName("ParamsFilter");
    24.         registration.setOrder(Integer.MAX_VALUE - 1);
    25.         return registration;
    26.     }
    27.  
    28. }

    过滤器过滤的请求为所有请求(/*)，排除部分请求

     

    1. 在配置类中添加不需要过滤的请求的url

     

    1. package com.example.config;
    2.  
    3. import com.example.filter.ParamsFilter;
    4. import org.apache.commons.lang3.StringUtils;
    5. import org.springframework.boot.web.servlet.FilterRegistrationBean;
    6. import org.springframework.context.annotation.Bean;
    7. import org.springframework.context.annotation.Configuration;
    8.  
    9. import javax.servlet.DispatcherType;
    10. import java.util.HashSet;
    11. import java.util.Set;
    12.  
    13. /**
    14.  * @description: 过滤器配置类
    16.  */
    17. @Configuration
    18. public class FilterConfig {
    19.  
    20.     @Bean
    21.     public FilterRegistrationBean parmsFilterRegistration() {
    22.         FilterRegistrationBean registration = new FilterRegistrationBean();
    23.         registration.setDispatcherTypes(DispatcherType.REQUEST);
    24.         registration.setFilter(new ParamsFilter());
    25.         registration.addUrlPatterns("/*");
    26.  
    27.         // 排除不需要过滤的请求
    28.         Set set = new HashSet<>();
    29.         set.add("/hello");
    30.         set.add("/testFilter");
    31.         String urls = StringUtils.join(set.toArray(), ",");
    32.         registration.addInitParameter("exclusions", urls);
    33.         registration.setName("ParamsFilter");
    34.         registration.setOrder(Integer.MAX_VALUE - 1);
    35.         return registration;
    36.     }
    37.  
    38. }
    1. package com.example.filter;
    2.  
    3. import javax.servlet.*;
    4. import javax.servlet.http.HttpServletRequest;
    5. import java.io.IOException;
    6. import java.util.Arrays;
    7. import java.util.HashSet;
    8. import java.util.Set;
    9.  
    10. /**
    12.  * @description: 请求参数过滤器
    14.  */
    15. public class ParamsFilter implements Filter {
    16.  
    17.     public static final String PARAM_NAME_EXCLUSIONS = "exclusions";
    18.     public static final String SEPARATOR = ",";
    19.     private Set excludesUrls;
    20.  
    21.     @Override
    22.     public void init(FilterConfig filterConfig) throws ServletException {
    23.         String param = filterConfig.getInitParameter(PARAM_NAME_EXCLUSIONS);
    24.         if (param != null && param.trim().length() != 0) {
    25.             this.excludesUrls = new HashSet(Arrays.asList(param.split(SEPARATOR)));
    26.         }
    27.     }
    28.  
    29.     @Override
    30.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    31.  
    32.         HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
    33.  
    34.         String requestURI = httpRequest.getRequestURI();
    35.  
    36.         if (this.isExclusion(requestURI)) {
    37.             // 不过滤
    38.             filterChain.doFilter(servletRequest, servletResponse);
    39.         } else {
    40.             // 过滤
    41.             ParamsRequestWrapper requestWrapper = new ParamsRequestWrapper(httpRequest);
    42.             filterChain.doFilter(requestWrapper, servletResponse);
    43.         }
    44.     }
    45.  
    46.     @Override
    47.     public void destroy() {
    48.  
    49.     }
    50.  
    51.     public boolean isExclusion(String requestURI) {
    52.  
    53.         if (this.excludesUrls == null) {
    54.             return false;
    55.         }
    56.  
    57.         for (String url : this.excludesUrls) {
    58.             if (url.equals(requestURI)) {
    59.                 return true;
    60.             }
    61.         }
    62.         return false;
    63.     }
    64.  
    65. }

  • 相关阅读:
    蓝桥杯：子串分值
    stl_stack_queue的使用及OJ题
    基于Basic auth 的一个C# 示例
    产品与技术的平衡
    Vue知识系列（2）每天10个小知识点
    浅谈Kube-OVN
    目前比较好用的LabVIEW架构及其选择
    2022-08-08 学习日记（28th day）Stream流
    曾仕强老师视频+音频+电子书合集百度网盘资源
    [附源码]计算机毕业设计疫情防控平台Springboot程序
  • 原文地址：https://blog.csdn.net/yuzheh521/article/details/128019264