Spring MVC请求处理流程深度解析：从源码到实战的架构剖析
序章：一场关于Spring MVC的技术面试
面试官老王翘着二郎腿，悠然地品着茶，突然抬起头：
老王：“小李啊，听说你对Spring MVC很熟悉？那我问你个简单的问题：当用户在浏览器输入一个URL，比如 http://localhost:8080/user/123，这个请求到达我们的Spring应用后，是怎么一步步处理的？”
小李（胸有成竹）：“这个我知道！首先DispatcherServlet接收请求，然后找到对应的Controller…”
老王（打断）：“慢着慢着，你这是背书啊！我想听的是你真正理解的流程。比如说，DispatcherServlet怎么知道这个请求应该交给哪个Controller？它又是怎么调用Controller的方法的？Controller返回的结果又是如何变成用户看到的页面的？”
小李（额头冒汗）：“这个…我需要好好整理一下思路…”
老王（笑了笑）：“哈哈，看来你还需要深入了解一下Spring MVC的内部机制。今天我们就来彻底剖析一下这个经典的请求处理流程吧！”
一、Spring MVC架构概述
Spring MVC是Spring Framework的一个重要模块，它基于经典的MVC（Model-View-Controller）设计模式，为Web应用开发提供了优雅的解决方案。
1.1 核心组件介绍
Spring MVC的核心组件就像一个精密的乐队，每个组件都有自己的职责：
- DispatcherServlet（前端控制器）：指挥家，统筹整个请求处理流程
- HandlerMapping（处理器映射器）：地图导航，负责找到请求对应的处理器
- HandlerAdapter（处理器适配器）：翻译官，适配不同类型的处理器
- Controller（控制器）：演奏者，处理具体的业务逻辑
- ViewResolver（视图解析器）：舞台设计师，解析视图名称
- View（视图）：舞台，最终展示给用户的界面
1.2 请求处理流程图
客户端 DispatcherServlet MultipartResolver HandlerMapping HandlerInterceptor HandlerAdapter Controller ViewResolver View Spring MVC 请求处理详细流程 1. 发送HTTP请求 2. 记录请求日志 3a. checkMultipart() 3b. MultipartHttpServletRequest 3c. 使用原始request alt [文件上传请求] [普通请求] 4. getHandler(request) 遍历所有HandlerMapping 查找匹配的处理器 5. HandlerExecutionChain noHandlerFound() 404 Not Found 6. applyPreHandle() 按顺序执行所有拦截器 的preHandle方法 false 请求被拦截 true 7. getHandlerAdapter() 适配器实例 8. handle(request, response, handler) 9. 调用控制器方法 执行业务逻辑 处理请求参数 调用Service层 10. 返回结果 11. ModelAndView 12. applyDefaultViewName() 13. applyPostHandle() 按逆序执行所有拦截器 的postHandle方法 处理完成 检查异步处理状态 异步响应 14. resolveViewName() 15. View对象 16. render(model, request, response) 渲染模板 填充模型数据 生成HTML/JSON 17. 渲染完成 18. HTTP响应 18. 直接返回数据 alt [视图渲染] [直接响应] 19. triggerAfterCompletion() 执行所有拦截器的 afterCompletion方法 进行资源清理 清理完成 alt [异步处理] [同步处理] alt [拦截器返回false] [拦截器通过] alt [未找到处理器] [找到处理器] 20. 请求处理完成 客户端 DispatcherServlet MultipartResolver HandlerMapping HandlerInterceptor HandlerAdapter Controller ViewResolver View
当一个HTTP请求到达Spring MVC应用时，整个处理流程如下：
- 客户端发送HTTP请求到DispatcherServlet
- DispatcherServlet查找合适的HandlerMapping
- HandlerMapping返回HandlerExecutionChain（包含Handler和Interceptor）
- DispatcherServlet通过HandlerAdapter调用Handler
- Handler处理业务逻辑并返回ModelAndView
- DispatcherServlet通过ViewResolver解析视图
- View渲染模型数据并返回响应
二、DispatcherServlet：请求处理的总指挥
DispatcherServlet是Spring MVC的心脏，继承自FrameworkServlet，是整个请求处理流程的入口点。
2.1 核心方法：doDispatch()
让我们深入分析DispatcherServlet.doDispatch()方法的源码：
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
// 1. 检查是否为文件上传请求
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
// 2. 查找当前请求的处理器
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
// 3. 执行拦截器的前置方法
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// 4. 获取处理器适配器并执行处理器
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
// 5. 应用默认视图名称
applyDefaultViewName(processedRequest, mv);
// 6. 执行拦截器的后置方法
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
dispatchException = new ServletException("Handler dispatch failed: " + err, err);
}
// 7. 处理分发结果（渲染视图或处理异常）
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
// ... 异常处理和资源清理
}
2.2 关键处理步骤详解
步骤1：文件上传检查
protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
// 处理文件上传请求，包装为MultipartHttpServletRequest
return this.multipartResolver.resolveMultipart(request);
}
return request;
}
步骤2：查找处理器
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
if (this.handlerMappings != null) {
for (HandlerMapping mapping : this.handlerMappings) {
HandlerExecutionChain handler = mapping.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}
三、HandlerMapping：请求的智能路由器
HandlerMapping负责将请求URL映射到具体的处理器。Spring MVC提供了多种实现：
3.1 HandlerMapping接口定义
public interface HandlerMapping {
/**
* 返回请求的处理器和拦截器链
*/
@Nullable
HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
/**
* 是否使用PathPattern进行路径匹配
*/
default boolean usesPathPatterns() {
return false;
}
}
3.2 常用实现类
- RequestMappingHandlerMapping：处理
@RequestMapping注解 - BeanNameUrlHandlerMapping：根据Bean名称进行URL映射
- SimpleUrlHandlerMapping：简单的URL模式映射
3.3 映射过程示例
以@RequestMapping("/user/{id}")为例：
@Controller
public class UserController {
@RequestMapping("/user/{id}")
public ModelAndView getUser(@PathVariable Long id) {
// 业务逻辑处理
ModelAndView mv = new ModelAndView("user-detail");
mv.addObject("user", userService.findById(id));
return mv;
}
}
当请求/user/123到达时，RequestMappingHandlerMapping会：
- 解析URL模式匹配
- 提取路径变量
{id} = 123 - 返回包含Controller方法的
HandlerExecutionChain
四、HandlerAdapter：处理器的万能适配器
HandlerAdapter采用适配器模式，使DispatcherServlet能够调用任何类型的处理器。
4.1 HandlerAdapter接口
public interface HandlerAdapter {
/**
* 判断是否支持给定的处理器
*/
boolean supports(Object handler);
/**
* 使用给定的处理器处理请求
*/
@Nullable
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception;
}
4.2 主要实现类
- RequestMappingHandlerAdapter：处理
@RequestMapping注解的方法 - SimpleControllerHandlerAdapter：处理实现Controller接口的类
- HttpRequestHandlerAdapter：处理实现HttpRequestHandler接口的类
4.3 RequestMappingHandlerAdapter的处理流程
@Override
protected ModelAndView handleInternal(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ModelAndView mav;
// 检查请求方法
checkRequest(request);
// 调用处理器方法
mav = invokeHandlerMethod(request, response, handlerMethod);
// 处理缓存控制
if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
}
else {
prepareResponse(response);
}
}
return mav;
}
五、Controller：业务逻辑的处理中心
Controller是业务逻辑的载体，Spring MVC支持多种Controller编写方式。
5.1 基于注解的Controller
@RestController
@RequestMapping("/api/users")
@Slf4j
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/{id}")
public ResponseEntity<User> getUserById(@PathVariable Long id) {
log.info("获取用户信息：{}", id);
User user = userService.findById(id);
return ResponseEntity.ok(user);
}
@PostMapping
public ResponseEntity<User> createUser(@RequestBody @Valid User user) {
log.info("创建用户：{}", user);
User savedUser = userService.save(user);
return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
}
}
5.2 参数解析和返回值处理
Spring MVC通过HandlerMethodArgumentResolver和HandlerMethodReturnValueHandler来处理方法参数和返回值：
// 参数解析器示例
public class PathVariableMethodArgumentResolver implements HandlerMethodArgumentResolver {
@Override
public boolean supportsParameter(MethodParameter parameter) {
return parameter.hasParameterAnnotation(PathVariable.class);
}
@Override
public Object resolveArgument(MethodParameter parameter,
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest,
WebDataBinderFactory binderFactory) throws Exception {
PathVariable pathVar = parameter.getParameterAnnotation(PathVariable.class);
String name = pathVar.value();
// 从请求中提取路径变量值
Map<String, String> uriTemplateVars =
(Map<String, String>) webRequest.getAttribute(
HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
return uriTemplateVars.get(name);
}
}
六、视图解析与渲染：展示层的精彩演出
6.1 ViewResolver：视图名称解析
ViewResolver负责将逻辑视图名解析为具体的View对象：
public interface ViewResolver {
/**
* 根据视图名称和区域信息解析视图
*/
@Nullable
View resolveViewName(String viewName, Locale locale) throws Exception;
}
6.2 常用ViewResolver实现
- InternalResourceViewResolver：解析JSP视图
- ThymeleafViewResolver：解析Thymeleaf模板
- ContentNegotiatingViewResolver：内容协商视图解析
6.3 视图解析过程
// DispatcherServlet中的视图解析逻辑
protected void render(ModelAndView mv, HttpServletRequest request,
HttpServletResponse response) throws Exception {
// 确定区域信息
Locale locale = (this.localeResolver != null ?
this.localeResolver.resolveLocale(request) : request.getLocale());
response.setLocale(locale);
View view;
String viewName = mv.getViewName();
if (viewName != null) {
// 解析视图名称
view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
if (view == null) {
throw new ServletException("Could not resolve view with name '" +
mv.getViewName() + "' in servlet with name '" + getServletName() + "'");
}
}
else {
// 直接使用View对象
view = mv.getView();
if (view == null) {
throw new ServletException("ModelAndView [" + mv +
"] neither contains a view name nor a View object");
}
}
// 渲染视图
try {
if (mv.getStatus() != null) {
request.setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, mv.getStatus());
response.setStatus(mv.getStatus().value());
}
view.render(mv.getModelInternal(), request, response);
}
catch (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug("Error rendering view [" + view + "]", ex);
}
throw ex;
}
}
6.4 View接口和实现
public interface View {
/**
* 渲染视图
*/
void render(@Nullable Map<String, ?> model, HttpServletRequest request,
HttpServletResponse response) throws Exception;
/**
* 获取内容类型
*/
@Nullable
default String getContentType() {
return null;
}
}
七、异常处理机制：优雅的错误处理
7.1 HandlerExceptionResolver
Spring MVC提供了统一的异常处理机制：
// DispatcherServlet中的异常处理逻辑
protected ModelAndView processHandlerException(HttpServletRequest request,
HttpServletResponse response, @Nullable Object handler, Exception ex) throws Exception {
ModelAndView exMv = null;
if (this.handlerExceptionResolvers != null) {
for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
exMv = resolver.resolveException(request, response, handler, ex);
if (exMv != null) {
break;
}
}
}
if (exMv != null) {
if (exMv.isEmpty()) {
request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
return null;
}
// 应用默认视图名称
if (!exMv.hasView()) {
String defaultViewName = getDefaultViewName(request);
if (defaultViewName != null) {
exMv.setViewName(defaultViewName);
}
}
WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
return exMv;
}
throw ex;
}
7.2 全局异常处理示例
@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
@ExceptionHandler(UserNotFoundException.class)
public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException ex) {
log.error("用户未找到：{}", ex.getMessage());
ErrorResponse error = new ErrorResponse("USER_NOT_FOUND", ex.getMessage());
return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
}
@ExceptionHandler(ValidationException.class)
public ResponseEntity<ErrorResponse> handleValidation(ValidationException ex) {
log.error("参数验证失败：{}", ex.getMessage());
ErrorResponse error = new ErrorResponse("VALIDATION_ERROR", ex.getMessage());
return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(error);
}
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleGeneral(Exception ex) {
log.error("系统异常：", ex);
ErrorResponse error = new ErrorResponse("INTERNAL_ERROR", "系统内部错误");
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
}
}
八、拦截器：请求处理的守护者
8.1 HandlerInterceptor接口
public interface HandlerInterceptor {
/**
* 前置处理：在Controller方法执行前调用
*/
default boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
return true;
}
/**
* 后置处理：在Controller方法执行后，视图渲染前调用
*/
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 {
}
}
8.2 拦截器实现示例
@Component
@Slf4j
public class AuthenticationInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
String token = request.getHeader("Authorization");
if (StringUtils.isEmpty(token)) {
log.warn("请求缺少认证令牌：{}", request.getRequestURI());
response.setStatus(HttpStatus.UNAUTHORIZED.value());
return false;
}
// 验证令牌
if (!isValidToken(token)) {
log.warn("无效的认证令牌：{}", token);
response.setStatus(HttpStatus.UNAUTHORIZED.value());
return false;
}
// 设置用户上下文
User user = getUserFromToken(token);
UserContext.setCurrentUser(user);
log.info("用户认证成功：{}", user.getUsername());
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
// 清理用户上下文
UserContext.clear();
}
private boolean isValidToken(String token) {
// 令牌验证逻辑
return true;
}
private User getUserFromToken(String token) {
// 从令牌中解析用户信息
return new User();
}
}
九、实战应用：完整的请求处理示例
9.1 配置类
@Configuration
@EnableWebMvc
public class WebMvcConfig implements WebMvcConfigurer {
@Bean
public InternalResourceViewResolver viewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
return resolver;
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new AuthenticationInterceptor())
.addPathPatterns("/api/**")
.excludePathPatterns("/api/login", "/api/register");
}
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
converters.add(new MappingJackson2HttpMessageConverter());
}
}
9.2 完整的Controller示例
@RestController
@RequestMapping("/api/users")
@Validated
@Slf4j
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/{id}")
public ResponseEntity<User> getUserById(
@PathVariable @Min(1) Long id,
@RequestParam(required = false) String fields) {
log.info("查询用户信息 - ID: {}, Fields: {}", id, fields);
User user = userService.findById(id);
if (user == null) {
throw new UserNotFoundException("用户不存在: " + id);
}
return ResponseEntity.ok(user);
}
@PostMapping
public ResponseEntity<User> createUser(
@RequestBody @Valid CreateUserRequest request) {
log.info("创建用户 - Request: {}", request);
User user = new User();
BeanUtils.copyProperties(request, user);
User savedUser = userService.save(user);
return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
}
@PutMapping("/{id}")
public ResponseEntity<User> updateUser(
@PathVariable Long id,
@RequestBody @Valid UpdateUserRequest request) {
log.info("更新用户 - ID: {}, Request: {}", id, request);
User existingUser = userService.findById(id);
if (existingUser == null) {
throw new UserNotFoundException("用户不存在: " + id);
}
BeanUtils.copyProperties(request, existingUser);
User updatedUser = userService.update(existingUser);
return ResponseEntity.ok(updatedUser);
}
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
log.info("删除用户 - ID: {}", id);
if (!userService.existsById(id)) {
throw new UserNotFoundException("用户不存在: " + id);
}
userService.deleteById(id);
return ResponseEntity.noContent().build();
}
}
十、性能优化与最佳实践
10.1 性能优化策略
- 合理配置连接池
server:
tomcat:
max-connections: 8192
accept-count: 1000
max-threads: 800
min-spare-threads: 100
- 启用压缩
server:
compression:
enabled: true
mime-types: text/html,text/css,application/javascript,application/json
min-response-size: 1024
- 缓存策略
@GetMapping("/users/{id}")
@Cacheable(value = "users", key = "#id")
public User getUserById(@PathVariable Long id) {
return userService.findById(id);
}
10.2 最佳实践
- 统一异常处理：使用
@ControllerAdvice进行全局异常处理 - 参数验证：使用Bean Validation进行参数校验
- 日志记录：合理使用slf4j记录关键操作日志
- API文档：使用Swagger生成API文档
- 测试覆盖：编写单元测试和集成测试
尾声：技术面试的完美收官
经过详细的分析，小李终于明白了Spring MVC请求处理流程的精髓。
老王（满意地点头）：“不错不错！现在你能完整地描述一下这个流程了吗？”
小李（信心满满）："当然可以！当用户请求 http://localhost:8080/user/123 时：
- DispatcherServlet接收请求，首先检查是否为文件上传请求
- HandlerMapping查找处理器，
RequestMappingHandlerMapping会根据@RequestMapping("/user/{id}")找到对应的Controller方法 - HandlerAdapter适配执行，
RequestMappingHandlerAdapter解析路径参数id=123，调用Controller方法 - Controller处理业务逻辑，返回ModelAndView或直接返回数据
- ViewResolver解析视图，如果返回视图名称，则解析为具体的View对象
- View渲染响应，最终生成HTML或JSON响应返回给客户端
整个过程中，拦截器在适当的时机执行前置、后置和完成方法，异常处理器负责处理各种异常情况。"
老王（拍手叫好）：“Perfect！这就是我想听到的答案。Spring MVC的设计真正体现了面向对象的精髓：单一职责、开闭原则、依赖倒置。每个组件各司其职，通过接口进行协作，既保证了灵活性，又确保了可扩展性。”
小李：“是的，这种设计让我们可以很容易地自定义各个组件，比如自定义HandlerMapping来支持特殊的URL规则，或者自定义ViewResolver来支持新的模板引擎。”
老王（欣慰地笑了）：“看来你不仅理解了流程，更理解了设计思想。这样的理解才是真正的技术功底！记住，作为一名优秀的Java工程师，不仅要知其然，更要知其所以然。Spring MVC的源码就是最好的教科书，多读源码，多思考设计模式的应用，你会受益无穷的！”
从这场面试中可以看出，真正掌握Spring MVC不仅仅是会使用注解，而是要深入理解其内部机制、设计思想和最佳实践。只有这样，我们才能在遇到复杂问题时游刃有余，在系统设计时胸有成竹。
总结：Spring MVC通过精巧的组件设计和清晰的职责分离，为我们提供了一个强大而灵活的Web开发框架。理解其请求处理流程不仅有助于更好地使用框架，更能提升我们的架构设计能力。正如老王所说，知其然更要知其所以然，这才是技术成长的正确道路。