阅读量:1
目录
3.继承HandlerInterceptorAdapter类
一、 主要内容
| 过滤器(Filter) | 监听器(Listener) | 拦截器(Interceptor) | |
|---|---|---|---|
| 关注点 | web请求 | 系统级别参数、对象 | Action(部分Web请求) |
| 实现方式 | 函数回调 | 事件 | Java反射机制 |
| 应用场景 | 设置字符编码 | 统计网站在线人数 | 拦截未登录用户 |
| URL级别的权限访问控制 | 清楚过期session | 审计日志 | |
| 过滤敏感词汇 | |||
| 压缩响应信息 | |||
| 是否依赖Servlet容器 | 是 | 否 | |
| Servlet提供的支持 | Filter接口 | ServletRequestListener HttpSessionListener ServletContextListener | |
| Spring提供的支持 | HandlerInterceptor WebRequestInterceptor HandlerInterceptorAdapter | ||
| 级别 | 系统级别 | 系统级别 | 非系统级别 |
二、 过滤器
2.1 介绍
Filter 即为过滤，用于在 Servlet 之外对 Request或者 Response 进行修改。
它主要用于对用户请求进行预处理，也可以对 HtpServletResponse 进行后处理。
使用 Filter 的完整流程: Filter 对用户请求进行预处理，接着将请求交给 Servlet 进行处理并生成响应，最后 Filter 再对服务器响应进行后处理。
在一个 web 应用中，可以开发编写多个 Filter，这些 Filter 组合起来称之为一个 Filter 链。
若是一个过滤器链:先配置先执行(请求时的执行顺序);响应时:以相反的顺序执行
在 HttpServletRequest 到达 Servlet 之前，拦截客户的HttpServletRequest。根据需要检查 HttpServletRequest，也可修改 HttpServletRequest 头和数据。 在HttpServletResponse 到达客户端之前，拦截 HttpServletResponse。 根据需要检查HttpServletResponse，也可修改 HttpServletResponse头和数据
2.2 实现
通过实现javax.servlet.Fileter的接口来实现一个过滤器。
其中定义了 三个方法：init()，doFilter()，destroy()，分别在相应的时机执行。后期观察生命周期。
Filter 的实现只需要两步:
1：编写 java 类实现 Filter接口，并实现其 doFilter 方法
2：通过@WebFilter注解设置它所能拦截的资源。
filterChain.doFilter(servletRequest, servletResponse); 放行
/*和/**
在Spring MVC框架中，配置拦截器（Interceptor）的路径模式时，/*和/**这两个通配符有以下区别：
/*：匹配一级目录下的所有请求路径。
它只匹配直接跟在指定路径后面的第一级子路径。
例如，如果配置为 /user/*，那么它会匹配 /user/john 或 /user/admin，但不会匹配 /user/profile/edit。
/**：匹配任意多级目录下的所有请求路径。
它可以匹配任何深度的子路径。
例如，如果配置为 /user/，那么它会匹配 /user/john、/user/admin、/user/profile/edit 等等。
总结来说，
/*只匹配直接下一层的路径，而/**可以匹配所有层级的路径，包括直接下一层和更深层次的路径。在实际应用中，如果你想要对整个应用程序的所有请求进行拦截，通常会选择使用
/**，因为它提供了更全面的覆盖。而 /* 更适合需要精细控制某些特定一级目录下的请求的情况。
MyFilter01
package com.dev.filter; import javax.servlet.*; import javax.servlet.annotation.WebFilter; import java.io.IOException; /** * 实现过滤器 * 1. 实现javax.servlet.Filter接口 * 2. 重写方法 * 3. 在doFilter方法中编写过滤逻辑（控制资源访问） * 4，配置过滤器，设置拦截路径 */ // 拦截所有资源 @WebFilter("/myServlet01") public class MyFilter01 implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 处理请求数据 System.out.println("filter01start "); filterChain.doFilter(servletRequest, servletResponse); // 处理响应数据 System.out.println("filter01end"); } @Override public void destroy() { } }
MyFilter02
package com.dev.filter; import javax.servlet.*; import javax.servlet.annotation.WebFilter; import java.io.IOException; /** * 实现过滤器 * 1. 实现javax.servlet.Filter接口 * 2. 重写方法 * 3. 在doFilter方法中编写过滤逻辑（控制资源访问） * 4，配置过滤器，设置拦截路径 */ // 拦截所有资源 @WebFilter("/myServlet02") public class MyFilter01 implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 处理请求数据 System.out.println("filter02start "); filterChain.doFilter(servletRequest, servletResponse); // 处理响应数据 System.out.println("filter02end"); } @Override public void destroy() { } } MyServlet01
package com.dev.filter; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import java.io.IOException; @WebServlet("/myServlet01") public class MyServlet01 extends HttpServlet { @Override public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { System.out.println("servlet01......"); } } MyServlet02
package com.dev.filter; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import java.io.IOException; @WebServlet("/myServlet02") public class MyServlet02 extends HttpServlet { @Override public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { System.out.println("servlet02......"); } }
注意
定义两个拦截器
MyFilter01 @WebFilter("/myServlet")
MyFilter02 @WebFilter("/*)
定义两个Servlet：
MyServlet01 @WebServlet("/myServlet")
MyServlet02 @WebServlet("/myServlet02")
访问
/myServlet02 ------ filter02start ==>servlet02==>filter02end
/myServlet ------ filter01start ==>filter02start ==>servlet01==>filter02end==>filter01end
2.3 说明
过滤器
在请求到达资源之前，过滤器会进行预处理(处理request);在响应到达客户端之前，过滤器会进行后处理(处理response)
过滤器链
当存在多个过滤器时，先配置的先执行(如果没有配置文件，则按照字母排序)
过滤器1、过滤器2、过滤器3
当请求访问资源时，过滤器执行的顺序是1->2->3；
到达资源后，响应的顺序为 3->2->1;
2.4 执行顺序
1. 使用 web.xml
过滤器的执行顺序就是它们在web.xml中声明的顺序。最先声明的过滤器将最先执行，而最后声明的过滤器将在响应阶段最后执行
<!-- web.xml --> <filter> <filter-name>AuthFilter</filter-name> <filter-class>com.example.AuthFilter</filter-class> </filter> <filter-mapping> <filter-name>AuthFilter</filter-name> <url-pattern>/secure/*</url-pattern> </filter-mapping> <filter> <filter-name>LoggingFilter</filter-name> <filter-class>com.example.LoggingFilter</filter-class> </filter> <filter-mapping> <filter-name>LoggingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
执行顺序说明
对于所有请求，LoggingFilter都会被触发，因为它匹配所有URL模式。
对于以/secure/开头的请求，除了LoggingFilter之外，AuthFilter也会被触发。
因为AuthFilter在web.xml中先于LoggingFilter声明，所以对于匹配/secure/的请求，AuthFilter会先于LoggingFilter执行。
对于非/secure/的请求，仅LoggingFilter会被执行。
因此，即使过滤器处理不同的URL模式，它们的执行顺序仍然基于配置文件中的声明顺序。
2. 使用注解和@Order
在Spring框架中，可以使用@WebFilter注解结合@Order注解来指定过滤器的执行顺序。@Order注解需要一个整数参数，数值越小的过滤器将越早执行
@Order(1) @WebFilter(urlPatterns = "/*") public class FirstFilter implements Filter { // ... } @Order(2) @WebFilter(urlPatterns = "/*") public class SecondFilter implements Filter { // ... }3. 使用FilterRegistrationBean
在Spring Boot或Spring MVC中，你也可以通过FilterRegistrationBean在配置类中注册过滤器
@Configuration public class FilterConfig { @Bean public FilterRegistrationBean<FirstFilter> firstFilterRegistration() { FilterRegistrationBean<FirstFilter> registration = new FilterRegistrationBean<>(); registration.setFilter(new FirstFilter()); registration.addUrlPatterns("/*"); registration.setOrder(1); return registration; } @Bean public FilterRegistrationBean<SecondFilter> secondFilterRegistration() { FilterRegistrationBean<SecondFilter> registration = new FilterRegistrationBean<>(); registration.setFilter(new SecondFilter()); registration.addUrlPatterns("/*"); registration.setOrder(2); return registration; } }
2.5字符乱码
| 请求 | Tomcat7及以下版本 | Tomcat8及以上版本 |
|---|---|---|
| POST | 乱码，需要处理 | 乱码，需要处理 |
| GET | 乱码，需要处理 | 不会乱码，无需处理 |
处理
POST
request.setCharacterEncoding("UTF-8");
GET （服务器版本在 Tomcat7及以下版本）
得到请求类习惯
得到服务器版本信息
判断请求为GET且版本小于8
处理乱码
package com.dev.filter; import javax.servlet.*; import javax.servlet.annotation.WebFilter; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; /** * 请求乱码统一处理 * tomcat8及以上版本 POST请求乱码问题 * tomecat7以下版本 POST/GET请求乱码问题 */ @WebFilter("/**") public class AEncodingFilter implements Filter { public AEncodingFilter(){ } @Override public void init(FilterConfig filterConfig) throws ServletException { } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { // 基于HTTP HttpServletRequest request = (HttpServletRequest) servletRequest; HttpServletResponse response = (HttpServletResponse) servletResponse; // 处理请求乱码问题 request.setCharacterEncoding("UTF-8"); // 放行 filterChain.doFilter(request, response); } @Override public void destroy() { } }
三、监听器
3.1介绍
web 监听器是Servlet 中一种的特殊的类，能帮助开发者监听 web 中的特定事件，比如 ServletcontextHttpSession，ServletRequest 的创建和销毁；变量的创建、销毁和修改等。 可以在某些动作前后增加处理，实现监控。例如可以用来统计在线人数等。
3.2实现
监听器有三类8种:
监听生命周期
ServletRequestListener
HttpSessionListener
ServletContextListener
监听值的变化
ServletRequestAttributeListener
HttpSessionAttributeListener
ServletContextAttributeListener
针对 session 中的对象
监听 session 中的 java 对象(javaBean)，是javaBean 直接实现监听器 的接口
3.3在线人数统计
OnlineListener
package com.dev.listener; import javax.servlet.annotation.WebListener; import javax.servlet.http.HttpSessionEvent; import javax.servlet.http.HttpSessionListener; /** * 在线人数统计 */ @WebListener public class OnlineListener implements HttpSessionListener { // 得到在线人数 public static int onlineCount = 0; /** * 当有新的session创建时，在线人数加一 * @param httpSessionEvent */ @Override public void sessionCreated(HttpSessionEvent httpSessionEvent) { onlineCount++; // 将在线人数放入session作用域中 // httpSessionEvent.getSession().setAttribute("onlineCount", onlineCount); // 将在线任务放入application作用域中 httpSessionEvent.getSession().getServletContext().setAttribute("onlineCount", onlineCount); } /** * 当session销毁时，在线人数减一 * @param httpSessionEvent */ @Override public void sessionDestroyed(HttpSessionEvent httpSessionEvent) { onlineCount--; // 将在线人数放入session作用域中 // httpSessionEvent.getSession().setAttribute("onlineCount", onlineCount); // 将在线任务放入application作用域中 httpSessionEvent.getSession().getServletContext().setAttribute("onlineCount", onlineCount); } } OnlineServlet2
package com.dev.listener; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; /** * 在线任务统计 */ @WebServlet("/online") public class OnlineServlet2 extends HttpServlet { @Override public void service(HttpServletRequest req, HttpServletResponse res) throws IOException { //得到动作 String action = req.getParameter("action"); if ("logout".equals(action)) { // 退出 req.getSession().invalidate(); return; } // 得到当前访问的ip String ip = req.getRemoteAddr(); System.out.println("当前访问的ip为：" + ip ); // 获取session作用域中的在线人数 // Integer onlineCount =(Integer) req.getSession().getAttribute("onlineCount"); // 获取application作用域中的在线人数 Integer onlineCount =(Integer) req.getSession().getServletContext().getAttribute("onlineCount"); // 响应数据 在页面中显示人数 res.setContentType("text/html;charset=utf-8"); res.getWriter().write("当前在线人数为：" + onlineCount+"<a href='myServlet03?action=logout'>退出</a>"); res.getWriter().flush(); res.getWriter().close(); } }
四、拦截器
4.1介绍
拦截器（Interceptor）是Java Web应用中的一种设计模式，主要用于在请求到达目标组件（如控制器）之前或响应离开目标组件之后执行一些特定的逻辑。在Spring框架中，拦截器是AOP（面向切面编程）的一个应用，可以用来实现诸如权限验证、日志记录、事务管理、性能监控等功能。
4.2实现方式
1.实现HandlerInterceptor接口
在Spring MVC中，拦截器可以通过实现HandlerInterceptor接口来创建
该接口包含三个方法：
preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception: 在请求处理之前调用，可以用于权限验证、数据校验等。如果返回false，则请求处理停止，不会继续执行后续的拦截器或控制器方法。
postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception: 在请求处理之后，但在视图渲染之前调用，可以用于日志记录、缓存处理等。
afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception: 在视图渲染之后调用，可以用于资源清理等操作。
import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class CustomInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 在这里实现你的逻辑 return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { // 在这里实现你的逻辑 } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { // 在这里实现你的逻辑 } } 2.实现WebRequestInterceptor接口
这个接口与HandlerInterceptor类似，但是它在更早的阶段被调用，甚至在请求映射之前。这使得它适合做一些全局的初始化工作。实现WebRequestInterceptor接口需要重写以下方法：
preHandle(WebRequest request)：在请求处理之前调用。
postHandle(WebRequest request, ModelMap model)：在请求处理之后调用。
afterCompletion(WebRequest request, Exception ex)：在请求处理完成之后调用。
3.继承HandlerInterceptorAdapter类
如果你不想实现HandlerInterceptor接口中的所有方法，可以继承HandlerInterceptorAdapter类，这是一个适配器类，它为HandlerInterceptor接口提供了默认实现，你只需要重写你感兴趣的方法即可。
import org.springframework.web.servlet.HandlerInterceptorAdapter; public class CustomInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 在这里实现你的逻辑 return true; } }4.注册拦截器
一旦你创建了拦截器，就需要在Spring配置中注册它。这可以通过实现WebMvcConfigurer接口的addInterceptors方法来完成。
import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration public class WebConfig implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new CustomInterceptor()) .addPathPatterns("/**"); // 指定拦截器应用的所有请求 } } 4.3解决的问题
拦截器可以解决多种问题：
权限控制：在请求到达控制器之前验证用户权限。
日志记录：记录请求和响应的详细信息，有助于调试和审计。
性能监控：计算请求处理时间，监控应用性能。
数据校验：检查请求参数的有效性，防止非法请求。
资源清理：确保在请求处理完毕后释放资源。
4.4与Spring Boot的集成
在Spring Boot中使用拦截器，可以通过以下步骤：
创建拦截器类并实现HandlerInterceptor接口。
在Spring配置类中注册拦截器，通常通过实现WebMvcConfigurer接口的addInterceptors方法。
import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class MyInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("Pre-handle logic..."); return true; // 返回true表示继续处理请求 } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println("Post-handle logic..."); } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {java System.out.println("After completion logic..."); } } 接下来，在Spring配置类中注册这个拦截器：
import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration public class WebConfig implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new MyInterceptor()) .addPathPatterns("/**"); // 指定拦截器应用的所有请求 } } 4.4执行顺序控制
拦截器的执行顺序可以通过以下方式控制：
配置顺序：在addInterceptors方法中，拦截器的添加顺序决定了它们的执行顺序。
实现Ordered接口：让拦截器实现Ordered接口并重写getOrder()方法，返回一个整数，数值越小，优先级越高。
import org.springframework.core.Ordered; import org.springframework.web.servlet.HandlerInterceptor; public class MyInterceptor implements HandlerInterceptor, Ordered { @Override public int getOrder() { return 1; // 优先级高于其他返回值大于1的拦截器 } // 其他方法... }
4.5身份验证实例
假设我们有一个Spring Boot应用，其中某些资源是受保护的，只有经过身份验证的用户才能访问。我们可以使用拦截器来检查用户的会话状态，确保只有已登录的用户才能访问这些资源。
步骤一：创建拦截器
首先，我们需要创建一个拦截器类，实现HandlerInterceptor接口，并覆盖preHandle方法来执行身份验证逻辑。
import org.springframework.stereotype.Component; import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; @Component public class AuthenticationInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 从session中获取用户信息 HttpSession session = request.getSession(false); if (session != null) { Object user = session.getAttribute("user"); if (user != null) { // 用户已登录，允许请求继续 return true; } } // 用户未登录，重定向到登录页面 response.sendRedirect(request.getContextPath() + "/login"); return false; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { // 这里可以处理请求后的逻辑，例如日志记录 } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { // 这里可以处理请求完成后的清理工作 } }
步骤二：配置拦截器
接下来，我们需要在Spring配置类中注册这个拦截器，并指定它应该应用于哪些URL。
import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration public class WebConfig implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new AuthenticationInterceptor()) .addPathPatterns("/protected/*") // 指定拦截器应用于/protected下的所有请求 .excludePathPatterns("/protected/login", "/protected/logout"); // 排除登录和登出路经 } } 步骤三：测试
现在，每当有请求尝试访问/protected/*下的资源时，AuthenticationInterceptor都会被调用。如果用户没有登录，他们将被重定向到登录页面。如果已经登录，则请求将继续正常处理。
注意事项
确保登录和登出路由被排除在拦截器之外，否则用户将无法访问这些页面。
考虑到安全性，可能还需要在拦截器中加入更复杂的认证逻辑，例如检查JWT令牌等。
如果应用中有多个拦截器，它们的执行顺序可以通过实现Ordered接口并重写getOrder()方法来控制。
通过这种方式，拦截器可以帮助我们在Spring Boot应用中实现细粒度的访问控制，提高应用的安全性和健壮性。
五、过滤器和拦截器区别 (面试常问)
过滤器（Filter）和拦截器（Interceptor）在Java Web应用程序中扮演着重要的角色，它们用于在请求到达目标组件（如Servlet或JSP）之前或之后执行特定的逻辑。两者都可以在请求过程中介入并可能阻止请求。
尽管它们有相似的功能，但它们在实现机制、作用范围、依赖环境等方面存在显著差异。
实现机制:
过滤器是基于函数回调的，通常通过实现javax.servlet.Filter接口来创建。过滤器会拦截所有进入Servlet容器的请求和响应，并且可以访问HttpServletRequest和HttpServletResponse对象。
拦截器是基于Java的反射机制（动态代理）实现的，通常与框架如Spring MVC一起使用。拦截器可以访问更广泛的上下文信息，比如Spring MVC的ModelAndView对象，以及控制器方法的参数和返回值。
依赖环境:
过滤器依赖于Servlet容器，如Tomcat、Jetty等，因此只能在Web环境中使用。
拦截器不依赖于Servlet容器，可以在任何使用Spring MVC框架的应用中使用，即使是在非Web环境中也可以实现类似的功能。
作用范围:
过滤器可以拦截几乎所有的HTTP请求，包括对静态资源的请求。
拦截器通常只拦截那些由控制器处理的请求，即所谓的“action”请求，不会拦截静态资源请求。
生命周期:
过滤器在Servlet容器启动时初始化，在容器关闭时销毁，每个请求只调用一次doFilter()方法。
拦截器可以多次调用，取决于请求的路径和配置，每次请求可以调用多次拦截器的preHandle()、postHandle()和afterCompletion()方法。
配置方式:
过滤器通过web.xml文件或注解（如@WebFilter）配置。
拦截器通常通过Spring的配置类或XML文件配置。
六、如何理解"拦截器只能拦截部分web请求"
截器主要用于拦截和处理由控制器（Controller）处理的请求，而不是所有的Web请求。
这是因为拦截器的设计初衷是为了处理业务逻辑层面的请求，如权限检查、日志记录、数据预处理等，这些通常与具体的业务操作相关联。
1.拦截器的作用范围
控制器请求：拦截器主要针对由控制器处理的请求，即通过HTTP方法（GET、POST等）调用控制器方法的请求。拦截器可以访问控制器方法的参数、返回值、以及模型和视图对象。
静态资源请求：拦截器通常不会拦截静态资源（如CSS、JavaScript、图片等）的请求，因为这些请求不涉及业务逻辑，而是直接由Web服务器或Servlet容器处理。
非控制器路径：对于不通过控制器处理的请求，如直接指向特定资源或Servlet的请求，拦截器也不会进行拦截。
2.为什么拦截器不能拦截所有Web请求?
设计目的：拦截器的设计目的是为了在业务逻辑层面上进行干预，而并非处理底层的网络通信或静态资源的分发。
性能考虑：如果拦截器拦截所有请求，包括静态资源请求，可能会引入不必要的性能开销，因为静态资源的处理通常非常快速，而拦截器的介入可能会增加延迟。
框架限制：Spring MVC的拦截器机制是基于控制器的，因此它天然不适合处理那些不由控制器处理的请求。
3.如何拦截所有Web请求？
如果需要对所有Web请求进行处理，包括静态资源请求，那么应该使用过滤器（Filter）。过滤器是Servlet容器级别的，它可以拦截所有进入容器的请求，无论这些请求是针对控制器还是静态资源。
过滤器的实现和配置与拦截器不同，它通过实现javax.servlet.Filter接口来创建，并在web.xml文件或使用@WebFilter注解来配置。
总结来说，拦截器在Spring MVC中主要用于处理与业务逻辑相关的请求，而过滤器则可以用于处理所有类型的Web请求，包括静态资源请求。
