一、整体架构与执行流程

在 Spring Boot 中，一个 HTTP 请求会依次不统一。

HTTP 请求
|
v
┌─────────────────────────────────────────────────────────┐
│ Servlet 容器 │
│ ↓ │
│ Filter─── 可拦截请求和响应 │
│ ↓ │
│ DispatcherServlet │
│ ├──→ HandlerInterceptor.preHandle │
│ ├──→ HandlerMethodArgumentResolver │
│ ├──→ Controller 方法 │
│ │ └──→ AOP @Before / @Around │
│ ├──→ HandlerMethodReturnValueHandler │
│ ├──→ HandlerInterceptor.postHandle │
│ └──→ HandlerInterceptor.afterCompletion │
│ │
│ 异常分支：任何阶段抛出异常 → @RestControllerAdvice 捕获 │
│ │
│ 事件分支：ServletRequestListener / ApplicationEvent贯穿全程 │
└─────────────────────────────────────────────────────────┘
|
v HTTP 响应

六大组件定位

组件	所属层级	主要职责	一句话定位
Filter	Servlet 容器	请求/响应的过滤与包装	最外层的守门员
Interceptor	Spring MVC	Controller 前后拦截	Controller 的贴身保镖
AOP	Spring 容器	方法级别的横切逻辑	任意 Bean 方法的拦截器
Listener	Servlet / Spring 事件层	全局事件的观察者	全局事件的观察者
ControllerAdvice	Spring MVC	全局异常处理与数据绑定	Controller 的后勤保障
ArgumentResolver ReturnValueHandlerSpring MVC 自定义参数/返回值解析	-

二、Filter

原理

Filter 属于 Servlet 规范的一部分。运行在 {@link DispatcherServlet} 前后可拦截所有 HTTP 请求，包括静态资源。

请求 → FilterChain
Filter1.doFilter
Filter2.doFilter
DispatcherServlet
Filter2
Filter1
响应

用法示例 — 请求日志过滤器

import jakarta.servlet.*;import jakarta.servlet.http.HttpServletRequest;其实，import jakarta.servlet.http.HttpServletResponse;import org.springframework.core.annotation.Order;import org.springframework.stereotype.Component;import java.io.IOException;/** 请求日志过滤器 */
@Component
@Order
public class RequestLogFilter implements Filter {
@Override
public void doFilter(ServletRequest request。ServletResponse response,FilterChain chain) throws IOException,ServletException {
HttpServletRequest req = request;HttpServletResponse resp = response;long start = System.currentTimeMillis;System.out.println + " " + req.getRequestURI);// 放行到下一个 Filter 或 DispatcherServlet
chain.doFilter;long cost = System.currentTimeMillis - start;System.out.println
+ " 耗时 " + cost + "ms 状态码 " + resp.getStatus);怎么说呢，}
}

通过 {@link org.springframework.boot.web.servlet.FilterRegistrationBean} 手动注册：

import org.springframework.boot.web.servlet.FilterRegistrationBean;import org.springframework.context.annotation.Bean;怎么说呢，import org.springframework.context.annotation.Configuration;不过，@Configuration
public class FilterConfig {
@Bean
public FilterRegistrationBean requestLogFilter {
FilterRegistrationBean bean = new FilterRegistrationBean<>;bean.setFilter);说起来，bean.addUrlPatterns;bean.setOrder;bean.setName;return bean，}
}

特点对比表

特点 Description
拦截范围	所有请求，包括静态资源和非 Controller 方法
能否访问 Spring Bean	可以通过注入实现
能否获取 Controller 信息	不能。过滤阶段还不知道目标 Handler
能否修改请求/响应体	可以配合 {@link HttpServletRequestWrapper}/{@link HttpServletResponseWrapper}
执行时机	DispatcherServlet 前后

三、Interceptor

{@link org.springframework.web.servlet.HandlerInterceptor} 是 Spring MVC 提供的机制，运行在 {@link DispatcherServlet} 内部，可以感知到当前要执行的 {@link org.springframework.web.method.HandlerMethod}。

DispatcherServlet
├─ preHandle → Controller 执行前
├─ postHandle → Controller 返回后视图渲染前
└─ afterCompletion → 渲染完成后或出现异常时均会调用

登录校验拦截器示例

import jakarta.servlet.http.HttpServletRequest;import jakarta.servlet.http.HttpServletResponse;import org.springframework.stereotype.Component;import org.springframework.web.servlet.HandlerInterceptor;@Component
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request。HttpServletResponse response,Object handler) throws Exception {
String token = request.getHeader;if ) {
response.setStatus;
老实说，response.getWriter.write;return false;不过，// 中断请求链路
}
System.out.println;return true，// 放行继续向下走到 Controller 层
}
@Override
public void postHandle(HttpServletRequest request。HttpServletResponse response,Object handler,ModelAndView modelAndView) throws Exception {
System.out.println;其实，}
@Override
public void afterCompletion(HttpServletRequest request。HttpServletResponse response,Object handler,Exception ex) throws Exception {
System.out.println;}
}

注册并配置方法排除：

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 WebMvcConfig implements WebMvcConfigurer {
private final LoginInterceptor loginInterceptor;public WebMvcConfig {
this.loginInterceptor = loginInterceptor;}
@Override
public void addInterceptors {
registry.addInterceptor
.addPathPatterns
.excludePathPatterns;话说回来，}
}

特性对比表

特性	Description"
"拦截范围"	"仅限 Controller 请求。不包括静态资源"
"能否获取 Controller 信息"	"可以通过 handler 参数获取 Method 信息"
"能否中断请求"	"可以返回 false 即中止后续链路"
"postHandle 在异常时是否执行"	"不会；只有 afterCompletion 必定执行"

💡User Pain Point： “postHandle 好像没被调用”。注意的观点是，当业务方法抛出异常时仅 afterCompletion 能保证一定被触发。

.四、AOP

AOP 基于 Spring 动态代理，实现对任意 Bean 方法的横切。它不受 Servlet/MVC 层限制，可作用于 Service、Repository 等业务层。

调用 target.method
↓ proxy object
├─ @Before → 方法执行前
├─ @AfterReturning → 正常返回后
├─ @AfterThrowing → 抛异常后
├─ @After → 最终结束。无论成功失败
└─ @Around → 环绕通知，可完全控制是否继续执行

耗时统计切面示例 

import lombok.extern.slf4j.Slf4j;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.*;import org.springframework.stereotype.Component;

/** 接口耗时统计切面 */ @Slf4j @Aspect @Component public class TimeLogAspect {

/** 定义切入点：controller 包下所有 public 方法 */ @Pointcut)") public void controllerPointcut{}

/** 环绕通知：统计方法执行耗时 */ @Around") public Object around throws Throwable{ long start=System.currentTimeMillis;String methodName=pjp.getSignature.toShortString;log.info，try{ Object result=pjp.proceed;// 执行目标方法 long cost=System.currentTimeMillis-start;log.info，return result;} catch{ long cost=System.currentTimeMillis-start;log.error，throw e;} }

/* 前置通知 */ @Before") public void before{ / 在 @Around 的 proceed 前执行 */ } }

特性表 

特性

​

​​

Description

Apologies—re was a formatting error due to length constraints in this environment.

---