SpringBoot添加过滤器Filter

灰太狼 2024-02-24 08:09 44阅读 0赞

1. 拦截器和过滤器  
先说一下，过滤器和拦截器的区别和联系。

1.1 相同点  
首先过滤器和拦截器都能实现请求的筛选（过滤或者拦截），然后根据自己的业务需求，添加自己的逻辑，保证请求往后走的时候数据能满足自己的需求。同时呢，他们又都能终止请求流（过滤器只要不在过滤链中往后传request就形；拦截器返回false）。

1.2 不同点  
1.2.1 实现原理不同  
过滤器和拦截器 底层实现方式大不相同，过滤器 是基于函数回调的，拦截器 则是基于Java的反射机制（动态代理）实现的

1.2.2 使用范围不同  
过滤器 实现的是 javax.servlet.Filter 接口，而这个接口是在Servlet规范中定义的，也就是说过滤器Filter 的使用要依赖于Servlet的，生存与Tomcat等服务器容器中，导致它只能在web程序中使用  
拦截器(Interceptor) 它是一个Spring组件，并由Spring容器管理，并不依赖Tomcat等容器，是可以单独使用的。不仅能应用在web程序中，也可以用于Application、Swing等程序中。

1.2.3 触发时机不同  
由于过滤器和拦截器基于不同的容器，所以他们的触发时机和请求中经过容器的顺序有关，Filter作用于Servlet，Interceptor作用于Springmvc。

![de5839e522ec4c1ea8447afbbefde1b3.png][]

1.2.4 处理范围不同  
过滤器处理逻辑都在doFilter方法中，拦截器区分pre、post和after，划分粒度更细了，使用起来更灵活

![58a32dc4808546368eeed787b468380e.png][]

![dd779ebed1be4e97943f1b4e26586fdf.png][]

1.2.5 拦截器可以注入业务  
拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

2. Springboot添加拦截器  
项目当中使用过滤器还是拦截器，根据需求来定，一般用哪种都可以，我是要处理requestbody 中的数据（处理特殊字符，加密等）。由于数据还要往下继续传，所以选用filter。  
过滤器添加有2种方法：

2.1 通过@WebFilter注解添加  
1.写过滤器类，并实现Filter接口  
2.添加@WebFilter注解，属性filterName设置过滤器名称，urlPatterns匹配要过滤的url  
import java.io.IOException;  
  
import javax.servlet.Filter;  
import javax.servlet.FilterChain;  
import javax.servlet.ServletException;  
import javax.servlet.ServletRequest;  
import javax.servlet.ServletResponse;  
import javax.servlet.annotation.WebFilter;  
  
  
@WebFilter(filterName = "testFilter", urlPatterns = "/\*")  
public class TestFilter implements Filter \{  
  
@Override  
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
throws IOException, ServletException \{  
  
System.out.println("==过滤逻辑==");  
chain.doFilter(request, response);  
  
  
\}  
  
\}  
3.在启动类上添加@ServletComponentScan注解，添加这个注解后，@WebServlet、@WebFilter、@WebListener注解都可以被扫描到了。  
![689f7d6783954f92b72f9da4e4f47f42.png][]

2.2 使用FilterRegistrationBean对象，将过滤器添加到spring容器，需配合@Configuration和@Bean注解

1.写过滤器类，实现Filter接口，并添加 @Component注  
import java.io.IOException;  
import javax.servlet.Filter;  
import javax.servlet.FilterChain;  
import javax.servlet.ServletException;  
import javax.servlet.ServletRequest;  
import javax.servlet.ServletResponse;  
import javax.servlet.http.HttpServletRequest;  
  
import org.apache.http.entity.ContentType;  
import org.springframework.http.HttpMethod;  
import org.springframework.stereotype.Component;  
  
/\*\*  
\* gateway转发参数时，有特殊符号如 \* +等经过了urlencode，无法正确接收，  
\* 加过滤器将 body进行urldecode  
\*  
\* 注意的问题：RequestBody注解的数据，  
\* 要通过request的getReader和getInputStream()方法来获取流数据，然后转变为字符串的  
\* 但是流读取一次后就关闭了，在filter中读取了以后，controller中就拿不到数据了  
\* 为此，我们自定义一个HttpServletRequestWrapper对象，将拿到的数据在放到这个对象中，  
\* 并将这个对象从chain.doFilter()方法中继续传下去，后续就能继续读取了  
\*/  
@Component  
public class RequestBodyFilter implements Filter \{  
  
@Override  
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)  
throws IOException, ServletException \{  
HttpServletRequest req = (HttpServletRequest) request;  
String contextPath = request.getServletContext().getContextPath();  
boolean b1 = HttpMethod.POST.name().equals(req.getMethod());  
boolean b2 = ContentType.APPLICATION\_JSON.getMimeType().equals(request.getContentType());  
boolean b3 = request.getParameterMap().isEmpty();  
boolean b4 = contextPath.contains("/test");  
if (b1 && b2 && b3 && b4) \{  
MyHttpServletRequestWrapper requestWrapper = new MyHttpServletRequestWrapper(req);  
chain.doFilter(requestWrapper, response);  
\} else \{  
chain.doFilter(request, response);  
\}  
  
\}  
  
\}  
2.将过滤器添加到FilterRegistrationBean，并交给spring容器  
import javax.servlet.Filter;  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.boot.web.servlet.FilterRegistrationBean;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
public class MyFilterConfig \{  
  
@Autowired  
private RequestBodyFilter requestBodyFilter;  
  
/\*\*  
\* 将过滤器注册到FilterRegistrationBean中  
\* 进行简单配置  
\*/  
@Bean  
public FilterRegistrationBean<Filter> someFilterRegistration() \{  
FilterRegistrationBean<Filter> registration = new FilterRegistrationBean<>();  
registration.setFilter(requestBodyFilter);  
registration.addUrlPatterns("/\*");  
registration.setName("requestBodyFilter");  
registration.setOrder(99);  
return registration;  
\}  
  
\}  
3.踩的坑，因为在过滤器中通过request的getReader和getInputStream()方法来获取了流数据，但是流读取一次后就关闭了，在filter中读取了以后，controller中就拿不到数据了。为此，我们自定义一个HttpServletRequestWrapper对象，将拿到的数据在放到这个对象中， 并将这个对象从chain.doFilter()方法中继续传下去，后续就能继续读取了。

import java.io.BufferedReader;  
import java.io.ByteArrayInputStream;  
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.io.UnsupportedEncodingException;  
import java.net.URLDecoder;  
import java.nio.CharBuffer;  
import java.nio.charset.Charset;  
  
import javax.servlet.ReadListener;  
import javax.servlet.ServletInputStream;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletRequestWrapper;  
  
/\*\*  
\* 自定义request对象，将body处理后，放到这个对象里面，  
\* 一定要重写getReader()和getInputStream()方法，将body放进去，  
\* 这样后面的controller才能从这个request的getReader()和getInputStream()  
\* 方法中拿到新的body对象  
\*/  
public class MyHttpServletRequestWrapper extends HttpServletRequestWrapper \{  
  
private byte\[\] body;  
  
public MyHttpServletRequestWrapper(HttpServletRequest request) \{  
super(request);  
  
final StringBuilder builder = new StringBuilder();  
// 缓存按 8192 大小  
final CharBuffer buffer = CharBuffer.allocate(2 << 12);  
BufferedReader reader = null;  
try \{  
reader = request.getReader();  
while (-1 != reader.read(buffer)) \{  
builder.append(buffer.flip());  
\}  
\} catch (Exception e) \{  
e.printStackTrace();  
\} finally \{  
try \{  
reader.close();  
\} catch (IOException e) \{  
e.printStackTrace();  
\}  
\}  
  
String bodyStr = builder.toString();  
try \{  
bodyStr = URLDecoder.decode(bodyStr, "UTF-8");  
\} catch (UnsupportedEncodingException e) \{  
e.printStackTrace();  
throw new RuntimeException("body解码出错！");  
\}  
body = bodyStr.getBytes(Charset.defaultCharset());  
\}  
  
  
  
public byte\[\] getBody() \{  
return body;  
\}  
  
  
  
@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 boolean isFinished() \{  
return bais.available() == 0;  
\}  
  
@Override  
public boolean isReady() \{  
return true;  
\}  
  
@Override  
public void setReadListener(ReadListener readListener) \{  
  
\}  
  
@Override  
public int read() throws IOException \{  
return bais.read();  
\}  
\};  
\}  
\}  
总结  
了解过滤器和拦截器的区别  
过滤器推荐使用第2种方法，使用spring管理，可以设置order  
过滤器中如果读取了body数据，需要回写回去，让后续操作能读取到body  
————————————————  
版权声明：本文为CSDN博主「程序员万京游」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/m0\_64355285/article/details/131735557

[de5839e522ec4c1ea8447afbbefde1b3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/24/8a677d065f0d4c10a3bf3613e089e228.png
[58a32dc4808546368eeed787b468380e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/24/a834d7b724e2477bb9b2d668617c2bcf.png
[dd779ebed1be4e97943f1b4e26586fdf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/24/ecb7a6cddb5d44f0b6b8a98ad1ccbdb4.png
[689f7d6783954f92b72f9da4e4f47f42.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/24/80c8ded0c34e42b193a9257fd27471e1.png