SpringMVC九大高频面试题深度拆解与实战剖析
最近几年,Java后端开发岗位的面试,SpringMVC几乎成了必考项。很多朋友在准备时,往往陷入两个极端:要么死记硬背官方文档里的概念,要么只停留在“会用”的层面,一旦面试官深入追问设计原理和对比细节,就容易卡壳。这篇文章,我想从一个面试官和一线开发者的双重角度,和你聊聊SpringMVC面试中最常被问到的九个核心问题。我不会照本宣科地复述流程,而是会结合我这些年面试别人和被别人面试的经验,拆解问题背后的设计思想、实战中的“坑”,以及与Struts2这类“前辈”框架的关键差异。希望这份深度解析,能帮你不仅“答对”,更能“答透”,在面试中展现出真正的技术深度。
1. 从请求到响应:SpringMVC的核心工作流程到底是怎么跑的?
面试官抛出这个问题,绝不仅仅是让你背出那“九步”或“十步”。他真正想考察的,是你对请求生命周期和组件协作的理解深度。很多候选人能说出DispatcherServlet、HandlerMapping这些名词,但一旦追问“为什么这么设计?”或者“某个环节出错了会怎样?”,就露怯了。
我们先抛开复杂的时序图,想象一个真实的场景:用户在你的电商网站点击了“加入购物车”按钮。这个点击动作,触发了一个HTTP请求。这个请求的“奇幻漂流”之旅,正是SpringMVC工作流程的缩影。
第一步,请求的“总入口”:DispatcherServlet。
这可不是一个普通的Servlet。在web.xml里,我们通常会把它映射到/,意味着所有请求(除了静态资源)都先经过它。你可以把它理解为一个公司的前台接待或者调度中心。它自己不处理具体业务,但手握所有部门的联系方式(组件列表)。它的核心职责是流程控制与协调。
注意:很多初级开发者会混淆
DispatcherServlet和Spring的ContextLoaderListener。后者负责加载根应用上下文(比如Service、DAO层的Bean),而DispatcherServlet会创建自己的子应用上下文(专管Controller、ViewResolver等Web层组件),并继承根上下文。这是父子容器设计,面试时能点明这一点会很加分。
第二步,寻找“对口部门”:HandlerMapping。
前台接到“加入购物车”的请求,得知道该派给哪个部门(哪个Controller的哪个方法)处理。HandlerMapping就是公司的通讯录或路由表。它维护着请求URL与具体处理器(HandlerMethod)之间的映射关系。现在主流是基于@RequestMapping注解的RequestMappingHandlerMapping,它会在应用启动时扫描所有@Controller注解的类,建立一张映射表。
// 一个典型的Controller方法,其映射信息会被HandlerMapping记录
@Controller
@RequestMapping("/cart")
public class CartController {
@PostMapping("/add")
@ResponseBody
public ResponseEntity<String> addItem(@RequestBody AddItemRequest request) {
// 业务逻辑
return ResponseEntity.ok("添加成功");
}
}
第三步,适配与执行:HandlerAdapter。
找到对口的“开发部”(Controller)后,发现他们用的工作语言(方法签名、参数类型)可能五花八门。有的方法参数用@RequestParam,有的用@RequestBody,还有的直接用HttpServletRequest。HandlerAdapter就是翻译官或适配器。它的核心作用是以统一的方式调用目标处理器方法,并处理复杂的参数绑定、数据转换、返回值处理等。最常用的是RequestMappingHandlerAdapter。
这里有个关键细节:参数解析器(HandlerMethodArgumentResolver)和返回值处理器(HandlerMethodReturnValueHandler)是HandlerAdapter工作的基石。SpringMVC的强大灵活性,很大程度上源于它那几十个内置的解析器和处理器。
第四步,业务逻辑执行与结果封装。
“翻译官”调用目标方法后,我们写的业务代码真正执行。方法执行后返回的结果,可能是String(视图名)、ModelAndView、ResponseEntity,或者一个普通的POJO对象。HandlerAdapter会将这些结果统一包装或处理,最终通常会形成一个包含**模型数据(Model)和视图信息(View)**的ModelAndView对象(即使返回的是JSON,其内部逻辑也类似)。
第五步与第六步,视图的解析与渲染:ViewResolver & View。
如果返回的结果指示需要渲染一个页面(比如JSP、Thymeleaf模板),流程就进入视图环节。ViewResolver根据返回的逻辑视图名(如"success"),结合配置的前缀后缀(如/WEB-INF/views/和.jsp),解析出具体的物理视图对象(View)。最后,View对象接手,将模型数据(第二步放入Model的数据)与模板结合,生成最终的HTML响应。
如果方法标注了@ResponseBody或者返回ResponseEntity,流程会在这里“短路”。RequestResponseBodyMethodProcessor这个返回值处理器会直接接管,利用HttpMessageConverter(如MappingJackson2HttpMessageConverter)将对象转换为JSON/XML,直接写入响应体,不再走视图解析和渲染。
整个流程中,还有两个重要的“幕后角色”:HandlerExceptionResolver负责处理整个过程中抛出的异常,将其转换为友好的错误响应;LocaleResolver、ThemeResolver等则处理国际化、主题等交叉关注点。
把这个流程理解成一个高度可插拔的管道,每个环节的组件都可以被定制或替换,你就能真正把握SpringMVC设计的精髓,而不仅仅是背诵步骤。
2. 为什么说SpringMVC是方法级别的拦截,而Struts2是类级别的?这带来了什么本质区别?
这个问题是SpringMVC vs Struts2对比的经典开场,它直接指向了两个框架在设计哲学和使用范式上的根本不同。理解这一点,就能理解它们后续的很多差异。
Struts2的“类拦截”世界
在Struts2中,核心的处理单元是Action类。一个Action类对应一个请求上下文。你在配置中(无论是XML还是注解)将请求URL映射到一个Action类。当请求到来时,Struts2会:
- 为这个请求创建一个新的
Action实例(默认是多例的)。 - 将请求参数通过
setter方法注入到这个Action实例的属性中。 - 调用
Action类中指定的execute方法(或通过method属性指定的其他方法)。
关键在于,Action类的所有属性(成员变量)在方法调用前就已经被注入值。这意味着,如果你在Action类中定义了多个处理不同请求的方法(通过@Action注解指定不同方法),这些方法共享同一个请求注入的成员变量。这种设计使得Action类更像一个“请求处理器”的容器,但方法间的隔离性较弱,容易引发线程安全问题(虽然Struts2通过每次请求创建新实例来规避,但编程模型上仍给人以“类级别”的感知)。
SpringMVC的“方法拦截”范式
SpringMVC则截然不同。它的核心处理单元是HandlerMethod,即Controller中的某一个具体方法。@RequestMapping注解直接映射到方法上。当请求到来时:
- SpringMVC容器中的Controller是单例的(默认情况下),由Spring IoC容器管理生命周期。
DispatcherServlet通过HandlerMapping找到对应的HandlerMethod。HandlerAdapter会动态解析该方法的参数(通过HandlerMethodArgumentResolver),从请求中提取数据并绑定,然后调用这个方法。- 方法的参数、局部变量都是线程安全的,因为它们存在于每个线程的调用栈中。
这种“方法级别”的拦截,带来了几个深远影响:
| 特性对比 | Struts2 (类级别) | SpringMVC (方法级别) |
|---|---|---|
| 映射粒度 | 较粗,以类为单位,方法通过额外配置指定 | 极细,直接映射到具体方法,更直观 |
| 默认作用域 | Action类多例(每次请求新实例) | Controller类单例(Spring Bean) |
| 线程安全关注点 | 类属性被所有方法共享,需注意(尽管实例不同) | 方法参数和局部变量天然线程安全 |
| RESTful支持 | 相对繁琐,需通过配置或约定区分HTTP方法 | 天然友好,@GetMapping, @PostMapping等注解直接支持 |
| 参数绑定 | 主要依赖OGNL表达式和类属性的setter注入 | 灵活多样,支持@RequestParam, @PathVariable, @RequestBody等注解,更符合Java习惯 |
| 与Spring集成 | 需要额外整合,是两个独立的框架 | 无缝集成,是Spring生态系统的一部分,可方便使用AOP、事务等 |
最直观的体验就是编写RESTful API。在SpringMVC里,你可以这样清晰地表达:
@RestController
@RequestMapping("/api/users")
public class UserController {
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) { ... } // GET 获取
@PostMapping
public User createUser(@RequestBody User user) { ... } // POST 创建
@PutMapping("/{id}")
public User updateUser(@PathVariable Long id, @RequestBody User user) { ... } // PUT 更新
@DeleteMapping("/{id}")
public void deleteUser(@PathVariable Long id) { ... } // DELETE 删除
}
同一个URL路径/api/users,通过不同的HTTP方法和路径变量,映射到同一个Controller类的不同方法上,结构清晰,意图明确。而在Struts2中实现同样的效果,配置或注解会显得更冗长,风格上也不够统一。
所以,“方法级别拦截”不仅仅是技术实现的不同,它推动了一种更现代、更清晰、更贴近HTTP协议本身的Web服务开发风格。这也是SpringMVC能成为主流的重要原因之一。
3. 核心控制器:为什么SpringMVC用Servlet,Struts2用Filter?这仅仅是技术选型问题吗?
这又是一个触及架构设计根本的问题。选择Servlet还是Filter作为核心控制器,背后是对请求处理链的定位和与Servlet容器集成方式的差异。
Struts2的Filter选择:前置拦截与包装
Struts2的核心控制器是StrutsPrepareAndExecuteFilter。Filter在Servlet规范中,是位于Servlet之前的组件,它可以对请求(ServletRequest)和响应(ServletResponse)进行包装和修改。
Struts2选择Filter,主要基于以下考虑:
- 更早的介入点:Filter可以在请求到达任何Servlet之前就进行处理,这使得Struts2能够完全掌控请求的入口,方便实现自己的请求处理流水线。
- 请求/响应包装能力:Struts2的很多功能,如通过拦截器(Interceptor)栈处理参数、验证、文件上传等,都需要对原生的
HttpServletRequest进行装饰(例如,将请求参数解析到ActionContext中)。Filter天生适合做这件事。 - 与Servlet解耦:理论上,Struts2的Filter可以处理所有请求,不依赖于后端具体的Servlet,框架的自主性更强。
但这种设计也带来了复杂性。开发者需要理解Struts2自己构建的一套上下文(ActionContext, ValueStack),这与标准的Servlet API有所隔离,学习成本和调试复杂度相应增加。
SpringMVC的Servlet选择:标准与集成
SpringMVC的核心控制器是DispatcherServlet,它是一个标准的HttpServlet。这意味着:
- 遵循Servlet标准:
DispatcherServlet完全在Servlet规范内工作。它接收的是标准的HttpServletRequest和HttpServletResponse,框架内的大部分操作都基于标准API或在其基础上进行简单扩展。这对熟悉Servlet的开发者和现有Servlet基础设施(如Filter、Listener)更友好。 - 清晰的职责边界:Servlet是请求处理的终点(在Filter之后)。SpringMVC将自己定位为一个请求分发器,而不是一个请求包装器。它的主要职责是“找到正确的处理器方法并调用它”,至于参数解析、数据绑定等功能,是通过
HandlerAdapter及其背后的解析器组件以插件化方式完成的,而不是通过包装请求对象。 - 无缝利用Spring容器:作为Servlet,它可以很方便地在
web.xml中配置,并由Servlet容器初始化。其对应的Spring Web应用上下文(WebApplicationContext)可以完美地集成父上下文(由ContextLoaderListener加载),享受完整的Spring IoC和AOP能力。 - 更自然的REST支持:对于返回JSON/XML的REST API,最终需要将数据写入
HttpServletResponse的输出流。基于Servlet的实现更直接,HttpMessageConverter可以直接操作原生的响应对象。
本质区别:架构哲学 这不仅仅是技术选型,更体现了架构哲学:
- Struts2更像一个独立的、重量级的Web框架,它构建了一个相对封闭的处理环境,通过Filter接管一切,提供一套完整的、自包含的解决方案。
- SpringMVC则更像一个轻量的、集成于Spring生态的MVC适配层。它尊重并利用现有的Servlet标准和Spring基础设施,通过高度可扩展的组件模型(如各种
Resolver和Converter)来提供MVC能力,更强调“约定优于配置”和与Spring其他模块的无缝融合。
从现代应用开发,特别是微服务和云原生趋势来看,SpringMVC这种更标准、更轻量、更易集成和扩展的设计,显然更具优势。Struts2的Filter架构虽然强大,但也带来了更多的复杂性和历史包袱。
4. 参数绑定魔法:@RequestParam、@PathVariable、@RequestBody究竟如何工作?
参数绑定是SpringMVC日常开发中使用最频繁的特性,也是面试官考察你对框架理解深度的绝佳切入点。很多人只是停留在“这么用就行”的层面,但一旦遇到复杂场景(如嵌套对象、集合、自定义格式)就容易抓瞎。我们来揭开这层魔法面纱。
@RequestParam:查询参数与表单数据的提取者
这是处理GET请求查询字符串(?name=value&age=20)和application/x-www-form-urlencoded格式POST表单的利器。
@GetMapping("/user")
public User getUser(@RequestParam("id") Long userId,
@RequestParam(value = "name", required = false, defaultValue = "Guest") String userName) {
// ...
}
- 工作原理:
RequestParamMethodArgumentResolver负责处理它。它会从ServletRequest.getParameter(name)中获取值。对于简单类型(String,int,Long等),Spring使用内置的PropertyEditor或Converter进行类型转换。required属性控制参数是否必须,defaultValue提供默认值。 - 常见坑点:
- 参数名默认与方法参数名一致,若不一致需用
value或name指定。 - 当请求参数值为空字符串
""时,对于required=false的非字符串类型(如Integer),绑定会失败并抛出TypeMismatchException,因为空字符串无法转换为数字。这需要额外处理。 - 不支持直接绑定复杂的嵌套对象。
- 参数名默认与方法参数名一致,若不一致需用
@PathVariable:RESTful风格的URL参数捕获器 这是实现RESTful API的关键,用于从URI模板中提取变量。
@GetMapping("/users/{userId}/orders/{orderId}")
public Order getOrder(@PathVariable Long userId, @PathVariable("orderId") Long orderNo) {
// ...
}
- 工作原理:
PathVariableMethodArgumentResolver处理。它从匹配到的URI模板变量(由RequestMappingHandlerMapping解析后存放在请求属性中)取值。同样会进行类型转换。 - 注意:
@PathVariable的值默认也是方法参数名,但通常建议显式指定,因为编译后的字节码可能丢失参数名信息(除非使用-parameters编译参数)。
@RequestBody:拥抱JSON/XML的现代方式
用于将请求体(通常是application/json或application/xml)的内容,绑定到方法参数对象上。
@PostMapping("/users")
public User createUser(@RequestBody @Valid CreateUserRequest request) {
// ...
}
- 工作原理:这是
RequestResponseBodyMethodProcessor的舞台。它根据请求的Content-Type头,选择合适的HttpMessageConverter。对于JSON,默认使用MappingJackson2HttpMessageConverter(如果Jackson库在类路径上)。转换器将请求体的输入流反序列化为Java对象。 - 关键点:
- 一个方法只能有一个
@RequestBody参数。 - 常与
@Valid或@Validated结合进行数据校验。 - 对于
GET请求,由于没有请求体,使用@RequestBody会报错。
- 一个方法只能有一个
深入对比与组合使用
| 注解 | 数据来源 | 主要Content-Type | 是否必须 | 典型场景 |
|---|---|---|---|---|
@RequestParam | URL查询字符串或表单数据 | application/x-www-form-urlencoded | 可选 (required=false) | 搜索过滤、分页参数 |
@PathVariable | URI路径片段 | 任何 | 是 (路径的一部分) | RESTful资源标识,如 /users/{id} |
@RequestBody | 请求体 (Body) | application/json, application/xml | 是 (除非对象可为空) | 创建或更新资源的复杂数据 |
在实际项目中,它们经常组合使用:
@PutMapping("/products/{id}/inventory")
public void updateInventory(@PathVariable Long id,
@RequestParam String operation, // 操作类型,如 "increase", "decrease"
@RequestBody InventoryUpdateDto updateDto) {
// 根据id找到产品,根据operation决定逻辑,用updateDto更新库存
}
背后的功臣:HandlerMethodArgumentResolver
所有这些绑定魔法,都依赖于SpringMVC强大的参数解析器体系。HandlerAdapter(如RequestMappingHandlerAdapter)内部维护了一个HandlerMethodArgumentResolver的列表。在处理每个方法时,它会遍历这个列表,找到第一个支持该参数类型的解析器来执行绑定。
你可以通过实现HandlerMethodArgumentResolver接口并注册到Spring容器,来创建自定义的参数解析器,处理那些框架不直接支持的参数类型(例如,从自定义的请求头中提取用户信息并绑定到UserContext对象)。这是SpringMVC扩展性的一大体现。
理解这些,你就能在遇到复杂的参数绑定需求时,不仅知道用什么注解,更知道其原理和边界,甚至能进行定制化扩展。
5. 拦截器(Interceptor) vs 过滤器(Filter):职责边界与执行顺序详解
在Web应用中,我们经常需要在请求处理前后执行一些通用逻辑,如日志记录、权限校验、性能监控等。SpringMVC提供了拦截器(Interceptor),而Servlet规范提供了过滤器(Filter)。它们功能相似,但定位和职责有清晰边界,混淆使用会导致问题。
过滤器(Filter):Servlet规范的“门卫” Filter是Java EE/Servlet规范的一部分,它的工作层面更底层,作用于Servlet容器级别。
- 作用对象:
ServletRequest和ServletResponse。它可以读取和修改请求/响应的内容、头信息等。 - 生命周期:随Web应用启动而初始化,在
doFilter方法中处理逻辑。 - 执行时机:在请求到达
DispatcherServlet之前,以及在响应离开DispatcherServlet之后(如果Filter链后续还有Filter的话)。 - 配置方式:在
web.xml中配置,或使用@WebFilter注解(Servlet 3.0+)。 - 典型用途:
- 字符编码设置(
CharacterEncodingFilter) - 压缩响应内容(
GzipFilter) - 跨域请求处理(
CorsFilter) - 实现XSS防护(对请求参数进行过滤)
- 字符编码设置(
// 一个简单的日志Filter
@WebFilter("/*")
public class LoggingFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
long startTime = System.currentTimeMillis();
chain.doFilter(request, response); // 放行,执行后续Filter和Servlet
long duration = System.currentTimeMillis() - startTime;
System.out.println("请求处理耗时: " + duration + "ms");
}
}
拦截器(Interceptor):SpringMVC的“流程监督员” Interceptor是SpringMVC框架层面的概念,它的工作层面更上层,作用于SpringMVC的请求处理流程内部。
- 作用对象:
Handler(即我们的Controller方法)的执行过程。它无法直接获取原始的ServletRequest/ServletResponse,但可以获取到Handler、ModelAndView等SpringMVC的抽象对象。 - 生命周期:作为Spring Bean管理,受Spring IoC容器控制。
- 执行时机:在
DispatcherServlet内部,HandlerAdapter实际调用Controller方法之前、之后以及渲染视图之后(afterCompletion)。它围绕的是“处理器方法”这个核心。 - 配置方式:实现
HandlerInterceptor接口,并在MVC配置中注册。 - 典型用途:
- 用户身份认证与授权(检查是否有权限访问某个Controller方法)
- 日志记录(记录Controller方法的入参、出参、执行时间)
- 通用数据处理(如将用户信息放入
Model供所有视图使用) - 性能监控(记录方法执行时间)
@Component
public class AuthInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 在Controller方法执行前调用
String token = request.getHeader("Authorization");
if (!isValidToken(token)) {
response.sendError(HttpStatus.UNAUTHORIZED.value(), "未授权");
return false; // 中断执行链,不会调用Controller方法
}
return true; // 继续执行
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
// Controller方法执行后,视图渲染前调用
if (modelAndView != null) {
modelAndView.addObject("currentTime", System.currentTimeMillis());
}
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
// 整个请求完成(视图渲染完毕)后调用,常用于资源清理、异常日志记录
if (ex != null) {
log.error("请求处理异常", ex);
}
}
}
核心区别与执行顺序
| 维度 | 过滤器 (Filter) | 拦截器 (Interceptor) |
|---|---|---|
| 规范/框架 | Servlet 规范 (J2EE) | Spring MVC 框架 |
| 作用范围 | 所有Web资源 (Servlet, JSP, 静态文件) | 仅Spring MVC处理的请求 (DispatcherServlet) |
| 依赖 | 仅依赖Servlet API | 依赖Spring MVC上下文 |
| 获取对象 | ServletRequest, ServletResponse | Handler, ModelAndView, Exception |
| 执行时机 | 在Servlet处理之前和之后 | 在Handler方法执行之前、之后、完成后 |
当一个请求到来时,它们的执行顺序是:
HTTP Request
|
v
[Filter Chain] (字符编码Filter、日志Filter、安全Filter等)
|
v
DispatcherServlet
|
v
[Interceptor.preHandle()] (多个Interceptor按配置顺序执行)
|
v
HandlerAdapter执行Controller方法
|
v
[Interceptor.postHandle()] (多个Interceptor按配置逆序执行)
|
v
视图渲染 (如果返回视图)
|
v
[Interceptor.afterCompletion()] (多个Interceptor按配置逆序执行)
|
v
[Filter Chain] (后续Filter处理响应)
|
v
HTTP Response
如何选择?
- 如果你的逻辑需要处理所有请求(包括静态资源),或者需要操作原始的请求/响应对象(如包装
HttpServletRequest),用Filter。 - 如果你的逻辑只关心Spring MVC处理的动态请求,并且需要与Spring上下文(如获取Bean)、Controller方法、
ModelAndView等交互,用Interceptor。
在实践中,两者可以协同工作。例如,用一个Filter来解析JWT token并将用户信息放入请求属性,再用一个Interceptor从请求属性中取出用户信息进行细粒度的权限校验。
6. 视图解析:InternalResourceViewResolver、JSP、Thymeleaf如何协作?
虽然现在RESTful API和前后端分离是主流,但理解SpringMVC的视图技术对于维护遗留项目或开发服务端渲染的应用仍然重要。视图解析的核心是ViewResolver和View接口。
视图解析流程回顾
当Controller方法返回一个字符串(如"user/list")或一个ModelAndView对象时,DispatcherServlet会调用配置的ViewResolver来解析这个逻辑视图名。
ViewResolver根据前缀、后缀等配置,将逻辑视图名("user/list")解析为一个具体的View对象(如InternalResourceView对应JSP,ThymeleafView对应Thymeleaf模板)。DispatcherServlet将模型数据(Model)传递给View对象。View对象负责渲染,将模型数据与模板结合,生成最终的响应内容(如HTML)。
InternalResourceViewResolver与JSP:经典的组合 这是最传统的方式,将JSP作为视图技术。
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
@Bean
public ViewResolver viewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/"); // JSP文件存放目录
resolver.setSuffix(".jsp"); // 文件后缀
resolver.setViewClass(JstlView.class); // 支持JSTL的视图类
return resolver;
}
}
- 工作原理:
InternalResourceViewResolver解析出的InternalResourceView(或JstlView),其render方法最终会通过RequestDispatcher.forward(request, response)将请求转发到指定的JSP页面。模型数据被设置为HttpServletRequest的属性(request.setAttribute),供JSP中的EL表达式使用。 - 特点:简单直接,性能尚可,但JSP需要编译,且与Java代码耦合较紧,不利于前后端分离。
ThymeleafViewResolver与Thymeleaf:现代模板引擎 Thymeleaf是当前更流行的服务端模板引擎,它支持HTML5,模板本身就是有效的HTML文件。
@Configuration
public class ThymeleafConfig {
@Bean
public SpringResourceTemplateResolver templateResolver() {
SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
resolver.setPrefix("classpath:/templates/");
resolver.setSuffix(".html");
resolver.setTemplateMode(TemplateMode.HTML);
resolver.setCharacterEncoding("UTF-8");
resolver.setCacheable(false); // 开发时关闭缓存
return resolver;
}
@Bean
public SpringTemplateEngine templateEngine() {
SpringTemplateEngine engine = new SpringTemplateEngine();
engine.setTemplateResolver(templateResolver());
engine.setEnableSpringELCompiler(true);
return engine;
}
@Bean
public ThymeleafViewResolver viewResolver() {
ThymeleafViewResolver resolver = new ThymeleafViewResolver();
resolver.setTemplateEngine(templateEngine());
resolver.setCharacterEncoding("UTF-8");
return resolver;
}
}
- 工作原理:
ThymeleafViewResolver解析出ThymeleafView。ThymeleafView使用SpringTemplateEngine来解析和渲染模板文件。模型数据在Thymeleaf模板中通过${...}、*{...}、@{...}等表达式访问。 - 优势:
- 自然模板:模板是纯HTML,可在浏览器直接预览。
- 强表达式语言:支持Spring EL,功能强大。
- 良好的Spring集成:与Spring Security、Spring Internationalization等模块集成方便。
- 更适合现代Web开发:易于与前端框架(如Vue.js、React)的部分特性结合。
多视图解析器共存
SpringMVC支持配置多个ViewResolver,并通过order属性设置优先级。DispatcherServlet会按顺序询问每个ViewResolver是否能解析给定的视图名,直到有一个成功返回View对象。
@Bean
public ViewResolver thymeleafViewResolver() {
ThymeleafViewResolver resolver = new ThymeleafViewResolver();
// ... 配置
resolver.setOrder(1); // 优先级高,先尝试用Thymeleaf解析
return resolver;
}
@Bean
public ViewResolver jspViewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/old-views/");
resolver.setSuffix(".jsp");
resolver.setOrder(2); // 优先级低,Thymeleaf解析不了再尝试JSP
return resolver;
}
这种配置允许你在项目中逐步迁移,新的模块用Thymeleaf,老的模块暂时保留JSP。
视图解析的扩展
除了上述两种,SpringMVC还支持其他视图技术,如FreeMarker、Velocity、Groovy Markup等,原理类似,都是通过特定的ViewResolver和View实现。在前后端分离架构中,Controller方法常返回JSON/XML,这时视图解析环节实际上被“短路”了,由HttpMessageConverter直接处理响应体。
理解视图解析机制,能帮助你在需要服务端渲染时,选择合适的模板引擎,并灵活配置。即使在API开发中,这个概念也有助于理解ContentNegotiatingViewResolver(内容协商视图解析器)等高级特性。
7. 全局异常处理:@ControllerAdvice + @ExceptionHandler 最佳实践
在Web应用中,异常处理是保证系统健壮性和用户体验的关键。SpringMVC提供了强大而灵活的全局异常处理机制,核心就是@ControllerAdvice注解与@ExceptionHandler注解的组合。
为什么需要全局异常处理? 如果没有全局处理,异常会沿着调用栈向上抛出,最终可能被Servlet容器捕获,返回一个不友好的默认错误页面(如Tomcat的500错误页)。这暴露了内部细节,对用户不友好,也不利于统一记录错误日志。我们需要一种方式,能够:
- 捕获Controller层抛出的所有特定类型的异常。
- 根据异常类型,返回结构化的错误信息(如JSON)或跳转到定制错误页。
- 统一记录日志,便于排查问题。
@ExceptionHandler:方法级别的异常捕手
首先,你可以在单个@Controller类内部使用@ExceptionHandler注解一个方法,用于处理该Controller内部抛出的指定异常。
@Controller
@RequestMapping("/users")
public class UserController {
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
// ... 可能抛出 UserNotFoundException
}
// 处理本Controller中抛出的UserNotFoundException
@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<String> handleUserNotFound(UserNotFoundException ex) {
return ResponseEntity.status(HttpStatus.NOT_FOUND).body("用户不存在: " + ex.getMessage());
}
}
这种方式的好处是针对性强,但缺点也很明显:作用域仅限于当前Controller。如果多个Controller都需要处理同一种异常,代码就会重复。
@ControllerAdvice:全局的“异常建议”
@ControllerAdvice是一个组件注解(@Component的特殊化)。被它注解的类,可以包含@ExceptionHandler、@InitBinder、@ModelAttribute注解的方法,并且这些方法会应用于所有@Controller(或更窄的范围)。
@RestControllerAdvice // 等同于 @ControllerAdvice + @ResponseBody,专用于REST API
@Slf4j
public class GlobalExceptionHandler {
// 处理业务异常
@ExceptionHandler(BusinessException.class)
public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException ex) {
log.warn("业务异常: ", ex);
ErrorResponse error = new ErrorResponse("BUSINESS_ERROR", ex.getMessage());
return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error);
}
// 处理数据校验异常 (如@Valid失败)
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ErrorResponse> handleValidationException(MethodArgumentNotValidException ex) {
log.warn("参数校验失败: ", ex);
// 提取详细的字段错误信息
List<String> errors = ex.getBindingResult()
.getFieldErrors()
.stream()
.map(error -> error.getField() + ": " + error.getDefaultMessage())
.collect(Collectors.toList());
ErrorResponse error = new ErrorResponse("VALIDATION_ERROR", "参数校验失败", errors);
return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error);
}
// 处理系统未知异常 (兜底)
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleGenericException(Exception ex) {
log.error("系统异常: ", ex); // 未知异常需要记录error级别日志
ErrorResponse error = new ErrorResponse("INTERNAL_SERVER_ERROR", "系统内部错误,请稍后再试");
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
}
// 定义一个统一的错误响应体
@Data
@AllArgsConstructor
@NoArgsConstructor
public static class ErrorResponse {
private String code;
private String message;
private Object details; // 可选的详细信息,如校验错误列表
public ErrorResponse(String code, String message) {
this.code = code;
this.message = message;
}
}
}
关键特性与最佳实践
- 异常处理顺序:
@ExceptionHandler方法可以处理指定异常类及其子类。当多个方法都能匹配抛出的异常时,最精确匹配(即异常类最接近)的方法会被调用。因此,通常把最通用的Exception.class处理放在最后。 - 方法签名灵活:
@ExceptionHandler注解的方法可以拥有非常灵活的参数,如:Exception或特定异常类型的参数(用于获取异常信息)。HttpServletRequest,HttpServletResponse,WebRequest(用于获取请求信息)。Model(用于向视图传递数据,在返回视图时有用)。- 返回值类型多样:
String(视图名)、ModelAndView、ResponseEntity、@ResponseBody注解的任意对象等。
- @RestControllerAdvice:这是
@ControllerAdvice和@ResponseBody的组合注解。在纯REST API项目中,使用@RestControllerAdvice可以确保所有异常处理方法返回的都是JSON响应体,无需在每个方法上再加@ResponseBody。 - 区分异常类型:
- 业务异常(如
UserNotFoundException,InsufficientBalanceException):通常由开发者主动抛出,预期内的错误。应返回清晰的错误码和提示信息(HTTP 400/409等状态)。 - 参数校验异常(
MethodArgumentNotValidException,ConstraintViolationException):由数据校验框架(如Hibernate Validator)抛出。应返回详细的字段级错误信息(HTTP 400状态)。 - 权限/安全异常(
AccessDeniedException,AuthenticationException):通常由Spring Security抛出。应返回HTTP 401/403状态。 - 系统异常(
NullPointerException,SQLException等):未预期的运行时错误。不应暴露内部细节给用户,应记录完整错误日志,返回统一的“系统繁忙”类提示(HTTP 500状态)。
- 业务异常(如
- 日志记录:在异常处理器中统一记录日志至关重要。对于业务异常,记录
WARN级别即可;对于未知的系统异常,必须记录ERROR级别日志,并尽可能包含请求ID、用户信息等上下文,方便排查。
通过@ControllerAdvice进行全局异常处理,使得错误处理逻辑与业务逻辑分离,代码更清晰,也更容易维护统一的错误响应格式,是构建健壮RESTful服务的标配。
8. 异步处理:@Async、DeferredResult、Callable的应用场景与陷阱
在高并发场景下,同步阻塞的请求处理模型会迅速耗尽服务器线程资源。SpringMVC提供了多种异步处理机制,允许释放容器线程去处理其他请求,待长时间任务完成后再响应原请求。理解它们的区别和适用场景很重要。
Servlet 3.0+ 异步支持基础
SpringMVC的异步功能建立在Servlet 3.0规范引入的异步处理之上。核心是ServletRequest.startAsync()方法,它开启异步模式,返回一个AsyncContext对象,允许在另一个线程中完成请求处理。
@Async:方法级别的异步执行
@Async是Spring框架的注解,用于声明一个方法是异步执行的。它通常用在Service层,让一个耗时方法(如调用外部API、复杂计算)在单独的线程池中运行,不阻塞调用者。
@Service
public class ReportService {
@Async // 该方法将在单独的线程中执行
public CompletableFuture<Report> generateReport(Long userId) {
// 模拟耗时操作
Thread.sleep(5000);
Report report = new Report(...);
return CompletableFuture.completedFuture(report);
}
}
@RestController
public class ReportController {
@Autowired
private ReportService reportService;
@GetMapping("/report/{userId}")
public CompletableFuture<ResponseEntity<Report>> getReport(@PathVariable Long userId) {
return reportService.generateReport(userId)
.thenApply(ResponseEntity::ok); // 当异步任务完成时,将结果转换为ResponseEntity
}
}
- 特点:
@Async本身不直接处理HTTP请求的异步响应。在上面的例子中,Controller方法虽然返回了CompletableFuture,但SpringMVC会等待这个Future完成,然后才发送响应。它并没有释放Servlet容器线程。真正的异步响应需要结合DeferredResult或Callable。
Callable:简单的异步返回值
Callable是Java标准库的接口。在Controller方法中返回Callable,SpringMVC会立即释放容器线程(如Tomcat的worker线程),并使用一个TaskExecutor(任务执行器)在后台线程中执行这个Callable。当Callable返回结果后,SpringMVC会重新派发请求,完成后续处理(如拦截器的postHandle)并发送响应。
@GetMapping("/async/callable")
public Callable<String> processAsync() {
return () -> {
// 这个call方法在后台线程执行
Thread.sleep(3000); // 模拟耗时操作
return "异步处理完成";
};
}
- 适用场景:适用于单个后台任务,且任务逻辑相对简单、自包含的情况。例如,一个需要查询多个独立数据源并聚合结果的请求。
- 注意:虽然释放了容器线程,但整个请求生命周期(从接收到最终响应)并没有缩短,只是提高了服务器的并发处理能力。
DeferredResult:更灵活的手动结果设置
DeferredResult是Spring提供的类,它代表一个“延迟的结果”。Controller方法返回DeferredResult后立即返回,SpringMVC会保存这个DeferredResult对象。你可以在任何线程(例如,一个消息监听器、一个定时任务、另一个HTTP回调)中,通过调用setResult()或setErrorResult()来设置最终结果。一旦结果被设置,SpringMVC会接管并完成响应。
@GetMapping("/async/deferred")
public DeferredResult<ResponseEntity<String>> longRunningTask() {
DeferredResult<ResponseEntity<String>> deferredResult = new DeferredResult<>(5000L); // 可设置超时时间
deferredResult.onTimeout(() -> {
deferredResult.setErrorResult(ResponseEntity.status(HttpStatus.REQUEST_TIMEOUT).body("请求超时"));
});
// 模拟在另一个线程(如消息队列消费者)中处理
CompletableFuture.runAsync(() -> {
try {
Thread.sleep(4000); // 模拟耗时处理
String result = "处理成功,结果: " + System.currentTimeMillis();
deferredResult.setResult(ResponseEntity.ok(result));
} catch (InterruptedException e) {
deferredResult.setErrorResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("处理中断"));
}
});
return deferredResult;
}
- 核心优势:解耦了请求线程和结果生产线程。结果的产生可以来自任何地方、任何时间。
- 典型应用场景:
- 长轮询(Long Polling):客户端发起请求,服务器持有连接,直到有数据更新或超时才返回。
- 响应外部事件:例如,等待一个消息队列的响应、等待一个WebSocket消息、等待一个第三方系统的回调。
- 批量处理后的通知:提交一个批量任务,立即返回一个任务ID。任务在后台执行,完成后通过另一个接口或消息通知客户端,客户端可以用任务ID查询结果(这需要配合其他机制如WebSocket或轮询)。
- 关键操作:
setResult(T result):设置成功结果。setErrorResult(Object result):设置错误结果。onTimeout(Runnable callback):设置超时回调。onCompletion(Runnable callback):设置完成回调(无论成功或错误)。
对比与选择
| 特性 | Callable | DeferredResult |
|---|---|---|
| 控制权 | Spring管理,自动执行和回调 | 开发者手动控制结果的设置 |
| 结果来源 | 必须在Callable.call()方法内产生 | 可在任何线程、任何时间、任何地点产生 |
| 适用场景 | 逻辑简单、自包含的后台任务 | 需要等待外部事件、长轮询、高度解耦的场景 |
| 复杂度 | 较低 | 较高,需要手动管理结果和超时 |
与@Async结合 | 可以在Callable内部调用@Async方法 | 可以在设置结果的线程中调用@Async方法 |
异步处理的陷阱
- 线程池配置:异步处理会使用线程池。务必配置合理的线程池参数(核心线程数、最大线程数、队列容量、拒绝策略),避免资源耗尽。Spring Boot中可以通过
TaskExecutionProperties配置@Async的线程池,通过MvcAsyncTaskExecutor配置Callable/DeferredResult的线程池。 - 上下文丢失:当请求处理切换到另一个线程时,原始的
ServletRequest、ServletResponse、LocaleContext、SecurityContext等可能无法自动传递。Spring提供了RequestContextHolder和DelegatingSecurityContextRunnable等工具来传递上下文,但需要小心处理。 - 异常处理:异步任务中抛出的异常,默认不会触发Controller中的
@ExceptionHandler。需要通过AsyncUncaughtExceptionHandler接口来自定义全局的异步异常处理。 - 超时管理:务必为
DeferredResult设置合理的超时时间,并处理onTimeout回调,防止连接长期挂起。Servlet容器本身也有异步超时设置(如Tomcat的async-timeout)。 - 资源清理:确保异步操作完成后,相关的资源(如数据库连接、文件句柄)被正确释放。
异步编程能显著提升应用的吞吐量和资源利用率,但也引入了复杂性。在选择方案时,务必权衡场景需求、开发成本和运维复杂度。对于大多数IO密集型的服务端渲染场景,Callable可能就够了;而对于需要高度解耦、响应外部事件的实时交互场景,DeferredResult是更强大的武器。
9. Spring Boot对SpringMVC的“约定大于配置”改造
Spring Boot的出现,极大地简化了Spring应用的搭建和配置。对于SpringMVC而言,Spring Boot并非引入新功能,而是通过自动配置(Auto-Configuration)和 starter 依赖,将原本繁琐的XML或Java配置变成了“开箱即用”的体验。理解这套自动化机制,能让你在享受便利的同时,也能在需要时进行精准定制。
核心:spring-boot-starter-web
只需在pom.xml中引入这一个依赖,Spring Boot就会为你自动配置一个完整的、生产就绪的Web应用环境,包括:
- 内嵌的Servlet容器(默认Tomcat)。
- Spring MVC的所有核心组件(
DispatcherServlet,HandlerMapping,ViewResolver等)。 - 默认的JSON支持(Jackson)。
- 静态资源处理规则。
- 错误处理机制。
自动配置了哪些关键组件?
-
DispatcherServlet自动注册与映射:在非Spring Boot项目中,你需要在
web.xml中手动配置DispatcherServlet及其映射。Spring Boot自动将其注册到Servlet容器,并默认映射到根路径/。你可以在application.properties中轻松修改:server.servlet.context-path=/myapp # 应用上下文路径 spring.mvc.servlet.path=/api # DispatcherServlet的映射路径,默认为 / -
视图解析器:如果你引入了Thymeleaf starter (
spring-boot-starter-thymeleaf),Spring Boot会自动配置ThymeleafViewResolver,并设置默认的模板位置(classpath:/templates/)和后缀(.html)。无需再写@Bean配置。 -
静态资源处理:Spring Boot预定义了一系列静态资源路径(
classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/)。放在这些目录下的js、css、images等文件,可以直接通过浏览器访问。这通过ResourceHttpRequestHandler自动配置实现。 -
HttpMessageConverter:自动配置了
MappingJackson2HttpMessageConverter(处理JSON)、StringHttpMessageConverter等。这意味着你的Controller方法返回POJO对象时,会自动转换为JSON响应。 -
错误处理:提供了默认的
/error映射和BasicErrorController,返回包含错误信息的HTML或JSON响应(取决于请求的Accept头)。你可以通过创建自定义的错误页面(如error/404.html,error/5xx.html)或使用@ControllerAdvice来覆盖默认行为。 -
配置属性:几乎所有MVC相关的行为都可以通过
application.properties或application.yml文件进行外部化配置,例如:spring: mvc: format: date: yyyy-MM-dd # 日期格式化 static-path-pattern: /resources/** # 静态资源访问模式 jackson: date-format: yyyy-MM-dd HH:mm:ss # Jackson日期格式 time-zone: GMT+8
如何自定义配置? 自动配置并不意味着失去控制。Spring Boot提供了多种方式让你覆盖默认行为:
- 使用配置属性:这是最简单的方式。查阅官方文档的
spring.mvc.*和spring.web.*属性,大部分常见需求都能满足。 - 编写自定义的WebMvcConfigurer:这是最强大、最常用的方式。创建一个配置类实现
WebMvcConfigurer接口(在Spring Boot 2.x+中,不推荐直接继承WebMvcConfigurationSupport,这会禁用大部分自动配置)。@Configuration public class MyWebMvcConfig implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**"); } @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { // 添加自定义的静态资源路径 registry.addResourceHandler("/files/**") .addResourceLocations("file:/opt/uploads/"); } @Override public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { // 添加或自定义HttpMessageConverter FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter(); // ... 配置FastJson converters.add(0, converter); // 添加到首位 } } - 完全控制(谨慎使用):如果你需要完全掌控Spring MVC的配置,可以创建一个配置类并标注
@EnableWebMvc。但这会禁用Spring Boot的所有MVC自动配置,你需要自己配置所有组件。通常不建议这么做,除非你有非常特殊的需求。
与Spring MVC传统配置的对比
以前,我们需要在XML中配置一大堆bean,或者写很多@Bean方法。现在,Spring Boot通过条件化配置(@ConditionalOnClass, @ConditionalOnMissingBean等),只在类路径存在特定jar包且用户没有提供自定义bean时,才自动配置默认bean。这实现了“约定大于配置”的理念。
例如,当你添加了Thymeleaf依赖,Spring Boot检测到TemplateMode等类存在,就会自动配置Thymeleaf相关的Bean。如果你自己定义了一个ThymeleafViewResolver的@Bean,那么自动配置的版本就不会生效。
实战建议
对于大多数项目,遵循Spring Boot的约定,在application.yml中做简单配置,并结合实现WebMvcConfigurer接口进行拦截器、资源处理器等定制,是最佳实践。只有在遇到自动配置无法满足的极端场景时,才考虑更复杂的定制方案。理解这套自动配置机制,能让你在遇到问题时快速定位是哪个自动配置类在起作用,并通过排除(@SpringBootApplication(exclude = {...}))或覆盖的方式来解决问题。
1248



被折叠的 条评论
为什么被折叠?



