MVC中的拦截器实现案例

MVC 拦截器

Spring MVC 拦截器对应HandlerInterctor接口，该接口位于org.springframework.web.servlet的包中，定义了三个方法，若要实现该接口，就要实现其三个方法：

• 前置处理（preHandle()方法）：该方法在执行控制器方法之前执行。返回值为Boolean类型，如果返回false，表示拦截请求，不再向下执行，如果返回true，表示放行，程序继续向下执行（如果后面没有其他Interceptor，就会执行controller方法）。所以此方法可对请求进行判断，决定程序是否继续执行，或者进行一些初始化操作及对请求进行预处理。
  
• 后置处理（postHandle()方法）：该方法在执行控制器方法调用之后，且在返回ModelAndView之前执行。由于该方法会在DispatcherServlet进行返回视图渲染之前被调用，所以此方法多被用于处理返回的视图，可通过此方法对请求域中的模型和视图做进一步的修改。
  
• 已完成处理（afterCompletion()方法）：该方法在执行完控制器之后执行，由于是在Controller方法执行完毕后执行该方法，所以该方法适合进行一些资源清理，记录日志信息等处理操作。
  

可以通过拦截器进行权限检验，参数校验，记录日志等操作
拦截器 (Interceptor) 实现案例

拦截器（Interceptor）依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。在实现上,基于Java的反射机制，属于面向切面编程（AOP）的一种运用。
就是在service或者一个方法前，调用一个方法，或者在方法后，调用一个方法，比如动态代理就是拦截器的简单实现，在调用方法前打印出字符串（或者做其它业务逻辑的操作）。
也可以在调用方法后打印出字符串，甚至在抛出异常的时候做业务逻辑的操作。由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。
但是缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。
自定义拦截器实现

1. import org.springframework.stereotype.Component;
2. import org.springframework.web.servlet.HandlerInterceptor;
3. import org.springframework.web.servlet.ModelAndView;
5. import javax.servlet.http.HttpServletRequest;
6. import javax.servlet.http.HttpServletResponse;
7. import java.util.Arrays;
8. import java.util.Map;
10. /**
11. * 自定义拦截器 - 实现HandlerInterceptor接口
12. * 适用于业务相关的预处理和后处理
13. */
14. @Component
15. public class CustomInterceptor implements HandlerInterceptor {
16.    
17.     private static final ThreadLocal<Long> startTimeThreadLocal = new ThreadLocal<>();
18.    
19.     /**
20.      * 预处理回调方法 - 在控制器执行之前调用
21.      * 返回true表示继续执行，false表示中断执行
22.      */
23.     @Override
24.     public boolean preHandle(HttpServletRequest request,
25.                            HttpServletResponse response,
26.                            Object handler) throws Exception {
27.         
28.         // 记录请求开始时间
29.         startTimeThreadLocal.set(System.currentTimeMillis());
30.         
31.         // 获取请求信息
32.         String requestURI = request.getRequestURI();
33.         String method = request.getMethod();
34.         String clientIP = getClientIP(request);
35.         
36.         System.out.println("【拦截器-preHandle】请求开始: " + method + " " + requestURI);
37.         System.out.println("【拦截器-preHandle】客户端IP: " + clientIP);
38.         
39.         // 1. 权限验证示例
40.         if (requiresAuth(requestURI) && !isAuthenticated(request)) {
41.             response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "未授权访问");
42.             return false; // 中断请求
43.         }
44.         
45.         // 2. 参数预处理示例
46.         Map<String, String[]> params = request.getParameterMap();
47.         if (!params.isEmpty()) {
48.             System.out.println("【拦截器-preHandle】请求参数: " + paramsToString(params));
49.         }
50.         
51.         // 3. 设置请求属性，供控制器使用
52.         request.setAttribute("requestStartTime", System.currentTimeMillis());
53.         
54.         return true; // 继续执行后续拦截器和控制器
55.     }
56.    
57.     /**
58.      * 后处理回调方法 - 在控制器执行之后，视图渲染之前调用（返回ModelAndView之前）
59.      */
60.     @Override
61.     public void postHandle(HttpServletRequest request,
62.                           HttpServletResponse response,
63.                           Object handler,
64.                           ModelAndView modelAndView) throws Exception {
65.         
66.         Long startTime = startTimeThreadLocal.get();
67.         if (startTime != null) {
68.             long costTime = System.currentTimeMillis() - startTime;
69.             System.out.println("【拦截器-postHandle】请求处理耗时: " + costTime + "ms");
70.             
71.             // 可以修改ModelAndView
72.             if (modelAndView != null) {
73.                 modelAndView.addObject("processTime", costTime);
74.                 modelAndView.addObject("interceptorMessage", "经过拦截器处理");
75.             }
76.         }
77.     }
78.    
79.     /**
80.      * 完成回调方法 - 在整个请求完成之后调用（视图渲染完成后）
81.      * 适合进行资源清理
82.      */
83.     @Override
84.     public void afterCompletion(HttpServletRequest request,
85.                                HttpServletResponse response,
86.                                Object handler,
87.                                Exception ex) throws Exception {
88.         
89.         Long startTime = startTimeThreadLocal.get();
90.         if (startTime != null) {
91.             long totalTime = System.currentTimeMillis() - startTime;
92.             int status = response.getStatus();
93.             
94.             System.out.println("【拦截器-afterCompletion】请求完成: " +
95.                 request.getRequestURI() + " 状态: " + status + " 总耗时: " + totalTime + "ms");
96.             
97.             if (ex != null) {
98.                 System.err.println("【拦截器-afterCompletion】异常信息: " + ex.getMessage());
99.             }
100.             
101.             // 清理ThreadLocal，防止内存泄漏
102.             startTimeThreadLocal.remove();
103.         }
104.     }
105.    
106.     // ========== 工具方法 ==========
107.    
108.     private String getClientIP(HttpServletRequest request) {
109.         String ip = request.getHeader("X-Forwarded-For");
110.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
111.             ip = request.getHeader("Proxy-Client-IP");
112.         }
113.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
114.             ip = request.getHeader("WL-Proxy-Client-IP");
115.         }
116.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
117.             ip = request.getRemoteAddr();
118.         }
119.         return ip;
120.     }
121.    
122.     private boolean requiresAuth(String uri) {
123.         // 需要认证的路径规则
124.         return uri.startsWith("/api/admin") || uri.startsWith("/api/user");
125.     }
126.    
127.     private boolean isAuthenticated(HttpServletRequest request) {
128.         // 简单的认证检查
129.         String token = request.getHeader("Authorization");
130.         return token != null && token.startsWith("Bearer ");
131.     }
132.    
133.     private String paramsToString(Map<String, String[]> params) {
134.         StringBuilder sb = new StringBuilder();
135.         for (Map.Entry<String, String[]> entry : params.entrySet()) {
136.             sb.append(entry.getKey()).append("=")
137.               .append(Arrays.toString(entry.getValue())).append("; ");
138.         }
139.         return sb.toString();
140.     }
141. }

复制代码

拦截器配置

1. import org.springframework.beans.factory.annotation.Autowired;
2. import org.springframework.context.annotation.Configuration;
3. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
4. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
6. import java.util.Arrays;
7. import java.util.List;
9. @Configuration
10. public class InterceptorConfig implements WebMvcConfigurer {
11.    
12.     @Autowired
13.     private CustomInterceptor customInterceptor;
14.    
15.     // 排除路径
16.     private static final List<String> EXCLUDE_PATHS = Arrays.asList(
17.         "/api/public/**",
18.         "/static/**",
19.         "/error",
20.         "/login",
21.         "/logout"
22.     );
23.    
24.     @Override
25.     public void addInterceptors(InterceptorRegistry registry) {
26.         // 注册自定义拦截器
27.         registry.addInterceptor(customInterceptor)
28.                 .addPathPatterns("/**")                    // 拦截所有路径
29.                 .excludePathPatterns(EXCLUDE_PATHS);        // 排除特定路径
30.         
31.         // 可以注册多个拦截器，按添加顺序执行
32.         registry.addInterceptor(new LoggingInterceptor())
33.                 .addPathPatterns("/api/**")
34.                 .order(1); // 设置执行顺序，数字越小优先级越高
35.     }
36. }
38. /**
39. * 另一个日志拦截器示例
40. */
41. class LoggingInterceptor implements HandlerInterceptor {
42.    
43.     @Override
44.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
45.         System.out.println("【日志拦截器】请求路径: " + request.getRequestURI());
46.         return true;
47.     }
48. }

复制代码

过滤器 (Filter) 实现案例

过滤器 (Filter) 依赖于servlet容器。在实现上，基于函数回调，它可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。
使用过滤器的目的，是用来做一些过滤操作，获取我们想要获取的数据。
比如：在Javaweb中，对传入的request、response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者Controller进行业务逻辑操作。
通常用的场景是：在过滤器中修改字符编码（CharacterEncodingFilter）、在过滤器中修改HttpServletRequest的一些参数（XSSFilter(自定义过滤器)）。
如：过滤低俗文字、危险字符等。
自定义过滤器实现

1. import org.springframework.core.annotation.Order;
2. import org.springframework.stereotype.Component;
4. import javax.servlet.*;
5. import javax.servlet.http.HttpServletRequest;
6. import javax.servlet.http.HttpServletResponse;
7. import java.io.IOException;
9. /**
10. * 自定义过滤器 - 实现Filter接口
11. * 适用于通用的请求/响应处理
12. */
13. @Component
14. @Order(1) // 执行顺序，数字越小优先级越高
15. public class CustomFilter implements Filter {
16.    
17.     /**
18.      * 初始化方法
19.      */
20.     @Override
21.     public void init(FilterConfig filterConfig) throws ServletException {
22.         System.out.println("【过滤器】CustomFilter初始化完成");
23.     }
24.    
25.     /**
26.      * 过滤处理方法
27.      */
28.     @Override
29.     public void doFilter(ServletRequest request, ServletResponse response,
30.                         FilterChain chain) throws IOException, ServletException {
31.         
32.         HttpServletRequest httpRequest = (HttpServletRequest) request;
33.         HttpServletResponse httpResponse = (HttpServletResponse) response;
34.         
35.         long startTime = System.currentTimeMillis();
36.         System.out.println("【过滤器-doFilter】请求进入: " + httpRequest.getRequestURI());
37.         
38.         // 1. 设置字符编码
39.         httpRequest.setCharacterEncoding("UTF-8");
40.         httpResponse.setCharacterEncoding("UTF-8");
41.         httpResponse.setContentType("text/html;charset=UTF-8");
42.         
43.         // 2. 设置CORS头（跨域支持）
44.         httpResponse.setHeader("Access-Control-Allow-Origin", "*");
45.         httpResponse.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
46.         httpResponse.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
47.         
48.         // 3. 预处理逻辑
49.         if (isOptionsRequest(httpRequest)) {
50.             // 处理预检请求
51.             httpResponse.setStatus(HttpServletResponse.SC_OK);
52.             return;
53.         }
54.         
55.         // 4. 请求包装（可以修改请求参数）
56.         CustomHttpServletRequestWrapper wrappedRequest =
57.             new CustomHttpServletRequestWrapper(httpRequest);
58.         
59.         // 5. 响应包装（可以修改响应内容）
60.         CustomHttpServletResponseWrapper wrappedResponse =
61.             new CustomHttpServletResponseWrapper(httpResponse);
62.         
63.         try {
64.             // 继续执行过滤器链
65.             chain.doFilter(wrappedRequest, wrappedResponse);
66.             
67.             // 后处理逻辑
68.             long costTime = System.currentTimeMillis() - startTime;
69.             System.out.println("【过滤器-doFilter】请求完成: " +
70.                 httpRequest.getRequestURI() + " 耗时: " + costTime + "ms");
71.             
72.             // 可以在这里修改响应内容
73.             byte[] responseData = wrappedResponse.getData();
74.             if (responseData.length > 0) {
75.                 // 对响应数据进行处理
76.                 String modifiedResponse = modifyResponse(new String(responseData));
77.                 response.getOutputStream().write(modifiedResponse.getBytes());
78.             }
79.             
80.         } catch (Exception e) {
81.             // 异常处理
82.             System.err.println("【过滤器-doFilter】处理异常: " + e.getMessage());
83.             httpResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务器内部错误");
84.         }
85.     }
86.    
87.     /**
88.      * 销毁方法
89.      */
90.     @Override
91.     public void destroy() {
92.         System.out.println("【过滤器】CustomFilter销毁");
93.     }
94.    
95.     // ========== 工具方法 ==========
96.    
97.     private boolean isOptionsRequest(HttpServletRequest request) {
98.         return "OPTIONS".equalsIgnoreCase(request.getMethod());
99.     }
100.    
101.     private String modifyResponse(String originalResponse) {
102.         // 简单的响应内容修改示例
103.         return originalResponse.replace("旧内容", "新内容");
104.     }
105. }
107. /**
108. * 自定义请求包装器 - 用于修改请求参数
109. */
110. class CustomHttpServletRequestWrapper extends HttpServletRequestWrapper {
111.    
112.     public CustomHttpServletRequestWrapper(HttpServletRequest request) {
113.         super(request);
114.     }
115.    
116.     @Override
117.     public String getParameter(String name) {
118.         // 可以在这里修改请求参数
119.         String value = super.getParameter(name);
120.         if ("username".equals(name) && value != null) {
121.             return value.trim(); // 去除用户名前后空格
122.         }
123.         return value;
124.     }
125. }
127. /**
128. * 自定义响应包装器 - 用于捕获和修改响应内容
129. */
130. class CustomHttpServletResponseWrapper extends HttpServletResponseWrapper {
131.    
132.     private final CustomServletOutputStream outputStream;
133.     private final PrintWriter printWriter;
134.    
135.     public CustomHttpServletResponseWrapper(HttpServletResponse response) {
136.         super(response);
137.         this.outputStream = new CustomServletOutputStream();
138.         this.printWriter = new PrintWriter(outputStream);
139.     }
140.    
141.     @Override
142.     public ServletOutputStream getOutputStream() {
143.         return outputStream;
144.     }
145.    
146.     @Override
147.     public PrintWriter getWriter() {
148.         return printWriter;
149.     }
150.    
151.     public byte[] getData() {
152.         try {
153.             printWriter.flush();
154.             return outputStream.toByteArray();
155.         } catch (IOException e) {
156.             return new byte[0];
157.         }
158.     }
159. }
161. /**
162. * 自定义Servlet输出流
163. */
164. class CustomServletOutputStream extends ServletOutputStream {
165.    
166.     private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
167.    
168.     @Override
169.     public void write(int b) {
170.         buffer.write(b);
171.     }
172.    
173.     @Override
174.     public boolean isReady() {
175.         return true;
176.     }
177.    
178.     @Override
179.     public void setWriteListener(WriteListener listener) {
180.         // 不需要实现
181.     }
182.    
183.     public byte[] toByteArray() {
184.         return buffer.toByteArray();
185.     }
186. }

复制代码

过滤器配置（多种方式）

• 使用 @Component + @Order（推荐）： 上面的示例已经使用这种方式
  
• 使用 FilterRegistrationBean（更灵活）
  

1. import org.springframework.boot.web.servlet.FilterRegistrationBean;
2. import org.springframework.context.annotation.Bean;
3. import org.springframework.context.annotation.Configuration;
5. @Configuration
6. public class FilterConfig {
7.    
8.     @Bean
9.     public FilterRegistrationBean<CustomFilter> customFilterRegistration() {
10.         FilterRegistrationBean<CustomFilter> registration = new FilterRegistrationBean<>();
11.         registration.setFilter(new CustomFilter());
12.         registration.addUrlPatterns("/*"); // 过滤所有请求
13.         registration.setOrder(1); // 执行顺序
14.         registration.setName("customFilter");
15.         
16.         // 可以设置初始化参数
17.         registration.addInitParameter("param1", "value1");
18.         
19.         return registration;
20.     }
21.    
22.     @Bean
23.     public FilterRegistrationBean<LoggingFilter> loggingFilterRegistration() {
24.         FilterRegistrationBean<LoggingFilter> registration = new FilterRegistrationBean<>();
25.         registration.setFilter(new LoggingFilter());
26.         registration.addUrlPatterns("/api/*");
27.         registration.setOrder(2);
28.         return registration;
29.     }
30. }
32. /**
33. * 日志过滤器
34. */
35. class LoggingFilter implements Filter {
36.    
37.     @Override
38.     public void doFilter(ServletRequest request, ServletResponse response,
39.                         FilterChain chain) throws IOException, ServletException {
40.         
41.         HttpServletRequest httpRequest = (HttpServletRequest) request;
42.         System.out.println("【日志过滤器】请求: " + httpRequest.getMethod() + " " + httpRequest.getRequestURI());
43.         
44.         chain.doFilter(request, response);
45.     }
46. }

复制代码

• 使用 @WebFilter 注解
  

1. import javax.servlet.annotation.WebFilter;
2. import javax.servlet.annotation.WebInitParam;
4. @WebFilter(
5.     urlPatterns = "/*",
6.     initParams = {
7.         @WebInitParam(name = "encoding", value = "UTF-8"),
8.         @WebInitParam(name = "enableCors", value = "true")
9.     }
10. )
11. public class AnnotationFilter implements Filter {
12.     // 实现同上
13. }

复制代码

需要在启动类添加 @ServletComponentScan：

1. @SpringBootApplication
2. @ServletComponentScan // 扫描@WebFilter、@WebServlet等注解
3. public class Application {
4.     public static void main(String[] args) {
5.         SpringApplication.run(Application.class, args);
6.     }
7. }

复制代码

MVC 的Interctor和 Filter 过滤器的区别

• 功能相同：Interctor和 Filter 都能实现相应的功能
  
• 容器不同：Interctor构建在 Spring MVC 体系中；Filter 构建在 Servlet 容器之上
  
• 拦截内容不同：Filter对所有访问进行增强，Interctor仅对MVC访问进行增强
  
• 使用便利性不同：Interctor提供了三个方法，分别在不同的时机执行；过滤器仅提供一个方法
  

使用场景区别

• 使用拦截器的场景：
  
  
  
  • 业务逻辑处理：权限验证、日志记录、参数预处理
    
  • 需要访问Spring上下文：需要注入Spring Bean的业务
    
  • 控制器相关处理：只需要对Spring MVC管理的请求进行处理
    
  • 需要修改ModelAndView：在视图渲染前修改模型数据
    
  
  
• 使用过滤器的场景：
  
  
  
  • 通用请求处理：字符编码、CORS支持、压缩处理
    
  • 静态资源处理：需要对所有请求（包括静态资源）进行处理
    
  • 底层请求处理：需要在DispatcherServlet之前执行的逻辑
    
  • 请求/响应包装：需要修改请求参数或响应内容
    
  
  

组合使用示例

1. /**
2. * 完整的请求处理链示例
3. * 过滤器(通用处理) → 拦截器(业务处理) → 控制器
4. */
6. // 1. 过滤器：处理字符编码、CORS等通用逻辑
7. @Component
8. @Order(1)
9. public class GlobalFilter implements Filter {
10.     // 处理所有请求的通用逻辑
11. }
13. // 2. 拦截器：处理业务相关的逻辑
14. @Component  
15. public class AuthInterceptor implements HandlerInterceptor {
16.     // 处理需要认证的业务逻辑
17. }
19. // 3. 控制器：处理具体业务
20. @RestController
21. public class BusinessController {
22.     // 业务实现
23. }

复制代码

过滤器和拦截器执行顺序

请求进入 → 过滤器预处理 → Spring MVC 核心处理 → 拦截器预处理 → 控制器执行 → 拦截器后处理 → 拦截器完成处理 → 过滤器后处理 → 响应返回

详细执行步骤分解：
第一阶段：过滤器预处理（Filter Pre-processing）

• 进入过滤器：客户端请求首先到达 Servlet 容器
  
• 执行 chain.doFilter(request, response)之前的逻辑：
  
  
  
  • 对请求进行通用预处理
    
  • 常见操作：设置字符编码、添加 CORS 头部、安全检查、请求日志记录
    
  • 此时尚未进入 Spring MVC 框架
    
  
  

第二阶段：Spring MVC 核心分发

• Servlet 的 service()方法：请求进入 Servlet 容器处理流程
  
• Spring MVC 的 doService()方法：Spring MVC 框架开始接管请求
  
• Spring MVC 请求分发方法：DispatcherServlet根据 URL 映射确定对应的处理器（Handler）
  

第三阶段：拦截器预处理

• 进入拦截器：请求正式进入 Spring MVC 的拦截器链
  
• 执行 Controller之前调用 preHandle()：
  
  
  
  • 进行业务相关的预处理
    
  • 常见操作：用户认证、权限检查、参数验证、业务日志
    
  • 返回值控制：
    
    
    
    • true：继续执行后续拦截器和控制器
      
    • false：中断请求，直接返回
      
    
    
  
  

第四阶段：控制器执行

• 执行具体的业务逻辑
  
• 准备模型数据（Model）
  
• 确定视图信息（View）
  

第五阶段：拦截器后处理

• postHandle()方法执行：
  
  
  
  • 时机：控制器逻辑执行完毕，但在返回 ModelAndView之前
    
  • 能力：可以查看和修改控制器返回的 ModelAndView对象
    
  • 常见操作：添加全局模型数据、记录处理结果、统一响应格式
    
  
  

第六阶段：拦截器完成处理，afterCompletion()方法执行：

• 时机：控制器已经返回 ModelAndView，但在过滤器将响应返回给客户端之前
  
• 特点：无论请求成功还是异常，都会执行（类似 finally块）
  
• 常见操作：清理 ThreadLocal 资源、记录最终处理状态、性能监控
  

第七阶段：过滤器后处理，FilterAfter逻辑执行：

• 时机：服务器端所有逻辑执行完成，准备将响应返回给客户端之前
  
• 常见操作：响应压缩、添加安全头部、响应日志记录、编码最后确认
  

多拦截器执行顺序

• 当配置多个拦截器时，会形成拦截器链
  
• 拦截器的运行顺序参照拦截器添加顺序为准，即addInterctor的顺序（过滤器同理）
  
• 当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行
  
• 当拦截器运行中断，仅运行配置在前面的拦截器afterCompletion
  

流程解析看下图：

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！