Appearance
Spring Web
Spring-Web实现了从 Servlet 到 RESTful 的全链路功能。它是 Spring Framework 的核心 Web 模块，构建在标准 Servlet API 之上，提供了完整的 RESTful 开发支持。
plain
Spring-Web
├── spring-web # 基础 Web 支持（HTTP、客户端、工具类）
├── spring-webmvc # Spring MVC 框架
├── spring-webflux # 响应式 Web 框架（Spring 5+）
└── spring-websocket # WebSocket 支持MVC 架构支持
- 提供 Spring MVC（Model-View-Controller）框架
- 分离业务逻辑、数据和界面展示
- 通过
@Controller、@RestController、@RequestMapping等注解处理 HTTP 请求
RESTful Web 服务
- 原生支持构建 REST API
- 提供
@GetMapping、@PostMapping、@PutMapping、@DeleteMapping等注解 - 自动处理 JSON/XML 数据转换（通过
HttpMessageConverter）
请求处理与响应
- 请求映射：将 URL 映射到处理方法
- 参数绑定：自动将请求参数绑定到方法参数（
@RequestParam、@PathVariable、@RequestBody） - 响应处理：支持多种返回类型（
String、View、ResponseEntity、对象自动转 JSON 等）
与 Servlet 容器集成
- 基于 Servlet API 构建
- 支持传统 Servlet 容器（Tomcat、Jetty、Undertow）
- 提供
DispatcherServlet作为前端控制器
Web 基础功能
| 功能 | 说明 |
|---|---|
| 文件上传 | 通过 MultipartFile 支持 |
| 静态资源处理 | 处理 CSS、JS、图片等静态文件 |
| 拦截器 | HandlerInterceptor 实现请求拦截 |
| 异常处理 | @ControllerAdvice 全局异常处理 |
| 国际化 | 支持多语言消息资源 |
HTTP 请求流程
plain
┌─────────────────────────────────────────────────────────────────────────────┐
│ 客户端 (浏览器/APP/第三方) │
│ 发送 HTTP 请求 (GET/POST/PUT/DELETE 等) │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 网络传输层 (TCP/IP) │
│ • DNS 解析 → TCP 三次握手 → TLS/SSL 握手(HTTPS) → 发送 HTTP 报文 │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ Web 服务器 (Nginx/Apache/IIS) │
│ • 监听端口 (80/443) │
│ • 负载均衡、静态资源缓存、SSL 终止、反向代理 │
│ • 转发到应用服务器: proxy_pass http://localhost:8080 │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ Servlet 容器 / Web 服务器 (Tomcat/Jetty/Undertow) │
│ • 监听端口 (8080等) │
│ • 解析 HTTP 协议，封装为 HttpServletRequest 对象 │
│ • 管理 Servlet 生命周期，线程池处理并发请求 │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 过滤器链 (Filter Chain) │
│ • CharacterEncodingFilter (编码设置) │
│ • CORSFilter (跨域处理) │
│ • JwtAuthenticationFilter (JWT认证) │
│ • RateLimitFilter (限流) │
│ • ... 自定义过滤器 │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 前端控制器 (Spring MVC: DispatcherServlet) │
│ • 接收所有请求，统一入口 │
│ • 调用 HandlerMapping 查找处理器 │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 请求映射处理 (HandlerMapping) │
│ • @RequestMapping / @GetMapping / @PostMapping 等注解解析 │
│ • URL 路径匹配: /api/users/{id} → UserController.getUser(id) │
│ • 提取路径变量、请求参数、请求头等信息 │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 拦截器 (HandlerInterceptor) │
│ • preHandle(): 权限校验、日志记录、签名验证 │
│ • postHandle(): 修改模型数据 │
│ • afterCompletion(): 资源清理 │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 参数解析与数据绑定 (HandlerMethodArgumentResolver) │
│ • @PathVariable → 从 URL 提取 id │
│ • @RequestParam → 从 Query String 提取参数 │
│ • @RequestBody → JSON 反序列化为 Java 对象 (Jackson) │
│ • @RequestHeader → 提取请求头 │
│ • 数据校验: @Valid + Hibernate Validator │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ RESTful Controller │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 业务处理 │
└─────────────────────────────────────────────────────────────────────────────┘
↓ (逆向流程)
┌─────────────────────────────────────────────────────────────────────────────┐
│ 响应处理 (ReturnValueHandler) │
│ • 将返回值转换为 HTTP 响应 │
│ • UserDTO → JSON (Jackson 序列化) │
│ • 设置 Content-Type: application/json │
│ • 设置 HTTP 状态码: 200 OK, 201 Created, 404 Not Found 等 │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 异常处理 (@ControllerAdvice + @ExceptionHandler) │
│ • 全局异常捕获 → 统一错误响应格式 │
│ • BusinessException → { "code": 1001, "message": "用户不存在" } │
│ • ValidationException → { "code": 1002, "errors": [...] } │
└─────────────────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────────────────┐
│ 响应返回路径 │
│ Controller → HandlerInterceptor.postHandle() → Filter Chain → Web 服务器 │
│ → Nginx → 客户端 │
└─────────────────────────────────────────────────────────────────────────────┘DispatcherServlet（前端处理器）
javax.servlet.Servletorg.springframework.web.servlet.DispacherServlet extends HttpServletBean
过滤器与拦截器
| 维度 | 过滤器 (Filter) | 拦截器 (Interceptor) |
|---|---|---|
| 规范来源 | Servlet 规范（javax.servlet.Filter） | Spring 框架（HandlerInterceptor） |
| 工作层级 | Web 层（Servlet 容器） | 应用层（Spring MVC） |
| 执行时机 | 请求进入 Servlet 容器时，在 Servlet 之前 | DispatcherServlet 之后，Controller 之前 |
| 处理范围 | 所有请求（包括静态资源、JSP、错误页面） | 仅 Spring 管理的请求（Controller 方法） |
| 依赖关系 | 依赖 Servlet 容器，与 Spring 无关 | 依赖 Spring 容器，可注入 Bean |
| 执行顺序控制 | 通过 web.xml 或 @Order 注解 | 通过 InterceptorRegistry 注册顺序 |
| 中断能力 | 可中断，不继续后续 Filter 和 Servlet | 可中断，但 preHandle 返回 false 后需自行处理响应 |
| 获取 Controller 信息 | ❌ 无法获取 | ✅ 可获取目标 Controller 和方法信息 |
plain
HTTP Request
↓
[Filter 1] → [Filter 2] → ... → [Filter N] ← Servlet 层
↓
DispatcherServlet (Spring)
↓
[Interceptor preHandle]
↓
[Controller 方法]
↓
[Interceptor postHandle]
↓
[Interceptor afterCompletion]
↓
[Filter ...] ← 响应返回
↓
HTTP ResponseSpring Interceptor = 责任链模式 + AOP 思想 ：
- 责任链：多个拦截器顺序执行，可中断链条
- AOP：在 Controller 方法前后织入逻辑
java
public interface HandlerInterceptor {
// Controller 前，权限校验、预处理
default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
return true;
}
// Controller 后，视图渲染前 修改 ModelAndView
default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
}
// 视图渲染后，请求完成 资源清理、异常记录
default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
}
}
// DispatcherServlet 中的核心逻辑（简化版）
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) {
// 1. 获取处理器执行链（包含 Controller 和 Interceptor 列表）
HandlerExecutionChain mappedHandler = getHandler(request);
// 2. 顺序执行所有 Interceptor 的 preHandle()
if (!mappedHandler.applyPreHandle(request, response)) {
return; // 任一拦截器返回 false，链条中断
}
// 3. 执行 Controller 方法
mv = ha.handle(request, response, mappedHandler.getHandler());
// 4. 逆序执行 postHandle()
mappedHandler.applyPostHandle(request, response, mv);
// 5. 逆序执行 afterCompletion()
mappedHandler.triggerAfterCompletion(request, response, null);
}
// HandlerExecutionChain.applyPreHandle()
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response)
throws Exception {
// 正向遍历：Interceptor1 → Interceptor2 → Interceptor3
for (int i = 0; i < this.interceptorList.size(); i++) {
HandlerInterceptor interceptor = this.interceptorList.get(i);
// 关键：任一拦截器返回 false，链条中断
if (!interceptor.preHandle(request, response, this.handler)) {
triggerAfterCompletion(request, response, null);
return false;
}
this.interceptorIndex = i; // 记录执行位置
}
return true;
}
// postHandle 和 afterCompletion 是逆序执行（类似出栈）
void applyPostHandle(...) {
// 逆向遍历：Interceptor3 → Interceptor2 → Interceptor1
for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
this.interceptorList.get(i).postHandle(...);
}
}