Spring MVC架构设计与核心组件深度解析

1. Spring MVC架构设计与核心组件概述

Spring MVC作为Java EE领域最主流的Web框架，其设计精妙之处在于通过清晰的组件分工实现了请求处理的高度可扩展性。在Spring Boot自动配置的便利背后，这套经典架构依然保持着完整的处理链条。让我们先看一个典型的HTTP请求在Spring MVC中的旅程：

1. 用户发起/api/users的GET请求
2. DispatcherServlet作为统一入口接收请求
3. HandlerMapping根据URL找到对应的Controller方法
4. HandlerAdapter适配执行目标方法
5. 参数解析器处理请求参数绑定
6. 实际业务逻辑执行
7. 返回值处理器处理响应数据
8. 视图渲染或直接返回数据

这个过程中最关键的抽象在于"适配器模式"的运用——无论Handler是哪种形式（传统Controller、@RequestMapping方法、函数式接口），最终都能被统一处理。这种设计使得Spring MVC既能兼容历史实现，又能优雅支持新特性。

提示：在Spring Boot 2.7+版本中，默认注册的HandlerMapping包括RequestMappingHandlerMapping（优先级0）、BeanNameUrlHandlerMapping（优先级1）和RouterFunctionMapping（优先级2）。了解这个顺序对解决路径冲突问题很重要。

2. DispatcherServlet初始化全流程解析

2.1 容器启动阶段的初始化时序

在传统Servlet容器中，DispatcherServlet的初始化遵循标准的Servlet生命周期：

java复制// 伪代码展示初始化时序
public class DispatcherServlet extends FrameworkServlet {
    
    // 1. Servlet容器调用此方法
    public void init(ServletConfig config) {
        // 2. 初始化父级上下文
        initWebApplicationContext();
        
        // 3. 初始化策略组件
        initStrategies(context);
    }
    
    protected void initStrategies(ApplicationContext context) {
        // 4. 初始化九大核心组件
        initHandlerMappings(context);
        initHandlerAdapters(context);
        // ...其他组件初始化
    }
}

而在Spring Boot环境中，这个流程通过自动配置变得更加简洁：

1. SpringBootServletInitializer启动时创建AnnotationConfigServletWebServerApplicationContext
2. 自动注册DispatcherServletRegistrationBean
3. 在Servlet容器准备就绪后触发DispatcherServlet初始化

2.2 九大核心组件的加载策略

每个策略组件的初始化都遵循"配置优先，默认兜底"的原则：

java复制protected void initHandlerMappings(ApplicationContext context) {
    // 1. 尝试从容器获取所有HandlerMapping类型的Bean
    Map<String, HandlerMapping> beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
        context, HandlerMapping.class, true, false);
    
    // 2. 如果容器中没有，使用默认策略
    if (beans.isEmpty()) {
        this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
    } else {
        // 3. 对获取到的HandlerMapping进行排序
        this.handlerMappings = new ArrayList<>(beans.values());
        AnnotationAwareOrderComparator.sort(this.handlerMappings);
    }
}

默认策略定义在DispatcherServlet.properties文件中：

code复制org.springframework.web.servlet.HandlerMapping=\
org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
org.springframework.web.servlet.function.support.RouterFunctionMapping

2.3 关键组件的默认实现类

3. 处理器映射机制深度剖析

3.1 HandlerMapping的三层查找逻辑

当请求到达时，DispatcherServlet会遍历所有HandlerMapping，其查找过程包含三个关键层次：

1. 路径匹配：根据请求URL找出候选Handler
2. 条件匹配：检查请求方法(GET/POST等)、头部、参数等条件
3. 跨域检查：验证CORS配置是否允许当前请求

以RequestMappingHandlerMapping为例，其匹配逻辑的核心代码：

java复制public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping {
    
    protected HandlerMethod getHandlerInternal(HttpServletRequest request) {
        // 1. 获取请求路径（考虑Servlet映射路径）
        String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
        
        // 2. 加读锁保证线程安全
        this.mappingRegistry.acquireReadLock();
        try {
            // 3. 查找匹配的HandlerMethod
            HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
            return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
        } finally {
            this.mappingRegistry.releaseReadLock();
        }
    }
}

3.2 四种处理器类型的注册差异

3.2.1 传统Controller接口

java复制@Component("/oldController")
public class LegacyController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, 
                                     HttpServletResponse response) {
        // 实现逻辑
    }
}

注册特点：

• 通过BeanNameUrlHandlerMapping处理
• Bean名称必须以"/"开头
• 不支持方法级路径映射

3.2.2 @RequestMapping注解方法

java复制@RestController
@RequestMapping("/api")
public class ModernController {
    
    @GetMapping("/users")
    public List<User> listUsers() {
        // 实现逻辑
    }
}

注册特点：

• RequestMappingHandlerMapping处理
• 支持类级别和方法级别的组合路径
• 支持丰富的请求条件（consumes/produces等）

3.2.3 函数式端点

java复制@Configuration
public class WebConfig {
    
    @Bean
    public RouterFunction<ServerResponse> routerFunction() {
        return route()
            .GET("/user/{id}", this::getUser)
            .build();
    }
    
    private Mono<ServerResponse> getUser(ServerRequest request) {
        // 实现逻辑
    }
}

注册特点：

• RouterFunctionMapping处理
• 响应式编程风格
• 显式路由声明

3.3 路径匹配的进阶细节

Spring MVC 5.3+引入了AntPathMatcher的替代方案PathPatternParser，两者主要区别：

启用PathPatternParser的方式：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer.setPatternParser(new PathPatternParser());
    }
}

4. 处理器适配器精讲

4.1 适配器模式在Spring MVC中的应用

HandlerAdapter的设计完美体现了适配器模式的威力，它解决了不同处理器接口的统一调用问题。核心接口定义：

java复制public interface HandlerAdapter {
    
    // 是否支持该处理器
    boolean supports(Object handler);
    
    // 执行处理器并返回ModelAndView
    ModelAndView handle(HttpServletRequest request, 
                       HttpServletResponse response, 
                       Object handler) throws Exception;
    
    // 支持Last-Modified头处理
    long getLastModified(HttpServletRequest request, Object handler);
}

4.2 RequestMappingHandlerAdapter的执行流程

这是最复杂的适配器，其处理过程可分为三个阶段：

1. 准备阶段：

   • 初始化数据绑定器
   • 准备模型对象
   • 处理SessionAttributes

2. 执行阶段：

   • 解析并绑定方法参数
   • 反射调用目标方法
   • 处理返回值

3. 收尾阶段：

   • 更新模型状态
   • 处理@ModelAttribute方法
   • 处理同步操作

核心方法invokeHandlerMethod的简化逻辑：

java复制protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
        HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    
    // 1. 包装请求和响应
    ServletWebRequest webRequest = new ServletWebRequest(request, response);
    
    try {
        // 2. 创建数据绑定工厂
        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
        
        // 3. 创建模型工厂
        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
        
        // 4. 创建方法执行器
        ServletInvocableHandlerMethod invocableMethod = 
            createInvocableHandlerMethod(handlerMethod);
        
        // 5. 配置参数解析器
        invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
        
        // 6. 配置返回值处理器
        invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
        
        // 7. 执行方法
        invocableMethod.invokeAndHandle(webRequest, mavContainer);
        
        // 8. 返回处理结果
        return getModelAndView(mavContainer, modelFactory, webRequest);
    } finally {
        webRequest.requestCompleted();
    }
}

4.3 自定义HandlerAdapter实践

假设我们需要支持一种新的处理器类型：

java复制public interface JsonRpcHandler {
    Object handleJsonRpc(Map<String, Object> params);
}

实现对应的适配器：

java复制public class JsonRpcHandlerAdapter implements HandlerAdapter {
    
    @Override
    public boolean supports(Object handler) {
        return handler instanceof JsonRpcHandler;
    }
    
    @Override
    public ModelAndView handle(HttpServletRequest request, 
                             HttpServletResponse response, 
                             Object handler) throws Exception {
        
        // 1. 解析JSON-RPC请求
        Map<String, Object> params = parseJsonRequest(request);
        
        // 2. 调用处理器
        JsonRpcHandler jsonRpcHandler = (JsonRpcHandler) handler;
        Object result = jsonRpcHandler.handleJsonRpc(params);
        
        // 3. 返回JSON响应
        writeJsonResponse(response, result);
        return null; // 表示已直接处理响应
    }
    
    // 其他辅助方法...
}

注册自定义适配器：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void configureHandlerAdapters(List<HandlerAdapter> adapters) {
        adapters.add(new JsonRpcHandlerAdapter());
    }
}

5. 参数解析器的魔法

5.1 参数解析器的工作机制

Spring MVC提供了超过30种内置的参数解析器，它们被组织在HandlerMethodArgumentResolverComposite中。解析器的判断逻辑：

java复制public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
    
    private final List<HandlerMethodArgumentResolver> argumentResolvers = new ArrayList<>();
    
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return getArgumentResolver(parameter) != null;
    }
    
    @Override
    public Object resolveArgument(MethodParameter parameter, 
                                 ModelAndViewContainer mavContainer,
                                 NativeWebRequest webRequest, 
                                 WebDataBinderFactory binderFactory) throws Exception {
        
        HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
        return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
    }
    
    private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
        // 先查缓存
        HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
        if (result == null) {
            // 遍历所有解析器
            for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
                if (resolver.supportsParameter(parameter)) {
                    result = resolver;
                    this.argumentResolverCache.put(parameter, result);
                    break;
                }
            }
        }
        return result;
    }
}

5.2 常用参数解析器实现分析

5.2.1 @RequestParam解析器

核心逻辑：

java复制public class RequestParamMethodArgumentResolver implements HandlerMethodArgumentResolver {
    
    @Override
    public Object resolveArgument(MethodParameter parameter, 
                                 ModelAndViewContainer mavContainer,
                                 NativeWebRequest webRequest, 
                                 WebDataBinderFactory binderFactory) throws Exception {
        
        // 1. 获取参数名称
        String name = getParameterName(parameter);
        
        // 2. 获取请求参数值
        Object arg = resolveName(name, parameter, webRequest);
        
        // 3. 类型转换
        if (arg == null) {
            if (hasDefaultValue(parameter)) {
                arg = resolveDefaultValue(parameter.getDefaultValue());
            } else if (parameter.isOptional()) {
                arg = (parameter.getParameterType() == Optional.class ? Optional.empty() : null);
            }
        }
        
        // 4. 数据绑定和验证
        if (binderFactory != null) {
            WebDataBinder binder = binderFactory.createBinder(webRequest, null, name);
            arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
        }
        
        return arg;
    }
}

5.2.2 @RequestBody解析器

处理流程：

1. 根据Content-Type选择合适的HttpMessageConverter
2. 读取请求体并转换为Java对象
3. 执行JSR-303验证（如果有@Valid注解）

关键代码：

java复制public class RequestResponseBodyMethodProcessor implements HandlerMethodArgumentResolver {
    
    @Override
    public Object resolveArgument(MethodParameter parameter, 
                                 ModelAndViewContainer mavContainer,
                                 NativeWebRequest webRequest, 
                                 WebDataBinderFactory binderFactory) throws Exception {
        
        // 1. 获取请求体
        HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
        ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
        
        // 2. 选择消息转换器
        for (HttpMessageConverter<?> converter : this.messageConverters) {
            if (converter.canRead(parameter.getParameterType(), parameter.getContainingClass(), 
                                 inputMessage.getHeaders().getContentType())) {
                
                // 3. 读取并转换
                Object body = ((HttpMessageConverter<Object>) converter).read(
                    parameter.getParameterType(), inputMessage);
                
                // 4. 验证
                if (binderFactory != null) {
                    String name = Conventions.getVariableNameForParameter(parameter);
                    WebDataBinder binder = binderFactory.createBinder(webRequest, body, name);
                    if (body != null) {
                        validateIfApplicable(binder, parameter);
                        if (binder.getBindingResult().hasErrors()) {
                            throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
                        }
                    }
                }
                
                return body;
            }
        }
        
        throw new HttpMediaTypeNotSupportedException(...);
    }
}

5.3 自定义参数解析器实战

实现一个从JWT令牌中解析用户信息的解析器：

java复制public class JwtUserArgumentResolver implements HandlerMethodArgumentResolver {
    
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(JwtUser.class) 
            && User.class.isAssignableFrom(parameter.getParameterType());
    }
    
    @Override
    public Object resolveArgument(MethodParameter parameter, 
                                 ModelAndViewContainer mavContainer,
                                 NativeWebRequest webRequest, 
                                 WebDataBinderFactory binderFactory) throws Exception {
        
        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
        String token = request.getHeader("Authorization");
        
        if (token != null && token.startsWith("Bearer ")) {
            String jwt = token.substring(7);
            return JwtUtils.parseUser(jwt); // 解析JWT获取用户信息
        }
        
        throw new MissingRequestHeaderException("Authorization", parameter);
    }
}

注册自定义解析器：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new JwtUserArgumentResolver());
    }
}

6. 返回值处理的艺术

6.1 返回值处理器的类型体系

Spring MVC的返回值处理采用责任链模式，主要处理器类型包括：

1. 视图名称处理器：处理返回String类型的视图名
2. 模型处理器：处理返回Model或Map类型
3. 响应体处理器：处理@ResponseBody注解的方法
4. HTTP实体处理器：处理ResponseEntity返回值
5. 异步处理器：处理DeferredResult等异步返回值

6.2 @ResponseBody的完整处理流程

当方法标注@ResponseBody时，RequestResponseBodyMethodProcessor会：

1. 根据Accept头选择合适HttpMessageConverter
2. 调用Converter将返回值写入响应
3. 设置适当的Content-Type头

关键代码：

java复制public class RequestResponseBodyMethodProcessor implements HandlerMethodReturnValueHandler {
    
    @Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
                                 ModelAndViewContainer mavContainer, 
                                 NativeWebRequest webRequest) throws Exception {
        
        // 1. 标记请求已处理
        mavContainer.setRequestHandled(true);
        
        // 2. 准备响应对象
        HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
        ServletServerHttpResponse outputMessage = new ServletServerHttpResponse(response);
        
        // 3. 选择消息转换器
        for (HttpMessageConverter<?> converter : this.messageConverters) {
            if (converter.canWrite(returnType.getParameterType(), 
                                 returnType.getContainingClass(), 
                                 outputMessage.getHeaders().getContentType())) {
                
                // 4. 写入响应
                ((HttpMessageConverter<Object>) converter).write(
                    returnValue, returnType.getParameterType(), 
                    outputMessage.getHeaders().getContentType(), 
                    outputMessage);
                return;
            }
        }
        
        throw new HttpMediaTypeNotAcceptableException(...);
    }
}

6.3 自定义返回值处理器示例

实现一个处理Markdown文本的返回值处理器：

java复制public class MarkdownReturnValueHandler implements HandlerMethodReturnValueHandler {
    
    @Override
    public boolean supportsReturnType(MethodParameter returnType) {
        return returnType.getMethodAnnotation(MarkdownResponse.class) != null;
    }
    
    @Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
                                 ModelAndViewContainer mavContainer, 
                                 NativeWebRequest webRequest) throws Exception {
        
        // 1. 标记请求已处理
        mavContainer.setRequestHandled(true);
        
        // 2. 转换Markdown为HTML
        String html = MarkdownUtils.toHtml(returnValue.toString());
        
        // 3. 写入响应
        HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
        response.setContentType("text/html;charset=UTF-8");
        response.getWriter().write(html);
    }
}

注册处理器：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> handlers) {
        handlers.add(new MarkdownReturnValueHandler());
    }
}

7. 异常处理的统一架构

7.1 异常处理的三层防御

1. HandlerExceptionResolver：Spring MVC核心异常处理机制
2. @ExceptionHandler：控制器级别的异常处理
3. 全局异常处理：@ControllerAdvice定义的全局处理器

7.2 ExceptionHandlerExceptionResolver的工作流程

这是处理@ExceptionHandler注解的核心解析器：

1. 查找匹配的异常处理方法
2. 使用参数解析器处理方法参数
3. 使用返回值处理器处理方法返回值
4. 返回包含错误信息的ModelAndView

关键代码：

java复制public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver {
    
    @Override
    protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod, Exception exception) {
        
        // 1. 查找异常处理方法
        Method exceptionHandlerMethod = findExceptionHandlerMethod(handlerMethod, exception);
        
        if (exceptionHandlerMethod != null) {
            try {
                // 2. 创建方法执行器
                ServletInvocableHandlerMethod invocableMethod = 
                    new ServletInvocableHandlerMethod(
                        handlerMethod.getBean(), exceptionHandlerMethod);
                
                // 3. 设置参数解析器
                invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
                
                // 4. 设置返回值处理器
                invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
                
                // 5. 执行异常处理方法
                ModelAndViewContainer mavContainer = new ModelAndViewContainer();
                invocableMethod.invokeAndHandle(request, response, mavContainer, exception);
                
                // 6. 返回处理结果
                return getModelAndView(mavContainer, request);
            } catch (Throwable invocationEx) {
                logger.error("Failed to invoke @ExceptionHandler method", invocationEx);
            }
        }
        
        return null;
    }
}

7.3 自定义异常解析器实践

实现一个将业务异常转换为特定JSON响应的解析器：

java复制public class BusinessExceptionResolver implements HandlerExceptionResolver {
    
    private final ObjectMapper objectMapper = new ObjectMapper();
    
    @Override
    public ModelAndView resolveException(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex) {
        
        if (ex instanceof BusinessException) {
            try {
                BusinessException bex = (BusinessException) ex;
                ErrorResponse error = new ErrorResponse(bex.getCode(), bex.getMessage());
                
                response.setContentType("application/json;charset=UTF-8");
                response.setStatus(HttpStatus.BAD_REQUEST.value());
                response.getWriter().write(objectMapper.writeValueAsString(error));
                
                return new ModelAndView(); // 空表示已处理
            } catch (IOException e) {
                return null;
            }
        }
        
        return null; // 返回null让其他解析器处理
    }
}

注册解析器：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        resolvers.add(new BusinessExceptionResolver());
    }
}

8. 视图解析机制揭秘

8.1 ViewResolver的层次结构

Spring MVC支持多种视图技术，常见的视图解析器包括：

1. InternalResourceViewResolver：用于JSP视图
2. ThymeleafViewResolver：Thymeleaf模板引擎
3. FreeMarkerViewResolver：FreeMarker模板
4. ContentNegotiatingViewResolver：根据Accept头协商视图

8.2 视图解析流程

DispatcherServlet的视图解析过程：

java复制public class DispatcherServlet extends FrameworkServlet {
    
    private void render(ModelAndView mv, HttpServletRequest request, 
                       HttpServletResponse response) throws Exception {
        
        // 1. 解析视图名称
        View view;
        if (mv.isReference()) {
            view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);
        } else {
            view = mv.getView();
        }
        
        // 2. 渲染视图
        view.render(mv.getModelInternal(), request, response);
    }
    
    protected View resolveViewName(String viewName, Map<String, Object> model,
                                  Locale locale, HttpServletRequest request) throws Exception {
        
        for (ViewResolver viewResolver : this.viewResolvers) {
            View view = viewResolver.resolveViewName(viewName, locale);
            if (view != null) {
                return view;
            }
        }
        return null;
    }
}

8.3 内容协商视图解析

ContentNegotiatingViewResolver的工作流程：

1. 获取客户端支持的媒体类型（从Accept头或路径扩展名）
2. 遍历所有候选视图
3. 选择最匹配的视图实现

配置示例：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Bean
    public ViewResolver contentNegotiatingViewResolver(ContentNegotiationManager manager) {
        ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
        resolver.setContentNegotiationManager(manager);
        
        List<ViewResolver> resolvers = new ArrayList<>();
        resolvers.add(thymeleafViewResolver());
        resolvers.add(jsonViewResolver());
        
        resolver.setViewResolvers(resolvers);
        return resolver;
    }
    
    @Bean
    public ViewResolver jsonViewResolver() {
        return (viewName, locale) -> {
            if (viewName.startsWith("json:")) {
                return new MappingJackson2JsonView();
            }
            return null;
        };
    }
}

9. Spring MVC性能调优指南

9.1 组件缓存优化

Spring MVC内部有多处缓存设计：

1. HandlerMapping缓存：路径到处理器的映射
2. 参数解析器缓存：方法参数到解析器的映射
3. 视图解析缓存：视图名称到视图实例的映射

优化建议：

• 保持HandlerMapping数量最少
• 避免频繁修改@RequestMapping配置
• 对自定义解析器实现缓存支持

9.2 并发处理优化

关键配置参数：

9.3 静态资源处理

最佳实践：

1. 使用ResourceHttpRequestHandler处理静态资源
2. 配置缓存头提高性能
3. 启用gzip压缩

配置示例：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
            .addResourceLocations("classpath:/static/")
            .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS))
            .resourceChain(true)
            .addResolver(new GzipResourceResolver())
            .addResolver(new VersionResourceResolver().addContentVersionStrategy("/**"));
    }
}

10. Spring MVC测试全攻略

10.1 控制器单元测试

使用MockMvc进行隔离测试：

java复制@WebMvcTest(UserController.class)
public class UserControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Test
    public void testGetUser() throws Exception {
        given(userService.getUser(1L)).willReturn(new User(1L, "test"));
        
        mockMvc.perform(get("/users/1")
                .accept(MediaType.APPLICATION_JSON))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.name").value("test"));
    }
}

10.2 集成测试

使用SpringBootTest进行完整上下文测试：

java复制@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class UserControllerIntegrationTest {
    
    @LocalServerPort
    private int port;
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    public void testGetUser() {
        ResponseEntity<User> response = restTemplate.getForEntity(
            "http://localhost:" + port + "/users/1", User.class);
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody().getName()).isEqualTo("test");
    }
}

10.3 测试自定义组件

测试自定义参数解析器：

java复制public class JwtUserArgumentResolverTest {
    
    private JwtUserArgumentResolver resolver = new JwtUserArgumentResolver();
    private MockHttpServletRequest request = new MockHttpServletRequest();
    private NativeWebRequest webRequest = new ServletWebRequest(request);
    
    @Test
    public void testResolveArgument() throws Exception {
        request.addHeader("Authorization", "Bearer valid.token");
        
        MethodParameter parameter = new MethodParameter(
            TestController.class.getMethod("testMethod", User.class), 0);
        
        User user = (User) resolver.resolveArgument(
            parameter, null, webRequest, null);
        
        assertThat(user.getName()).isEqualTo("testUser");
    }
    
    @Controller
    static class TestController {
        public void testMethod(@JwtUser User user) {}
    }
}

11. Spring MVC与WebFlux对比

11.1 架构差异

11.2 性能考量

11.3 迁移策略

从MVC迁移到WebFlux的建议步骤：

1. 先迁移边缘服务（如网关、代理）
2. 逐步替换Controller为RouterFunction
3. 将Service层改为返回Publisher类型
4. 最后考虑DAO层的响应式改造

12. 常见问题深度解析

12.1 中文乱码问题全解

问题现象：

• 响应中的中文变成问号
• 请求参数中的中文乱码

解决方案：

1. 请求乱码：

java复制@Bean
public Filter characterEncodingFilter() {
    CharacterEncodingFilter filter = new CharacterEncodingFilter();
    filter.setEncoding("UTF-8");
    filter.setForceEncoding(true);
    return filter;
}

2. 响应乱码：

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        StringHttpMessageConverter converter = new StringHttpMessageConverter(StandardCharsets.UTF_8);
        converters.add(0, converter);
    }
}

12.2 跨域问题解决方案

方案一：全局配置

java复制@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
            .allowedOrigins("https://example.com")
            .allowedMethods("GET", "POST")
            .allowCredentials(true);
    }
}

方案二：注解配置

java复制@RestController
@RequestMapping("/api")
@CrossOrigin(origins = "https://example.com", maxAge = 3600)
public class ApiController {
    // 控制器方法
}

12.3 文件上传问题

常见问题：

• 文件大小限制
• 临时目录权限
• 内存溢出

完整配置：

properties复制# application.properties
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=20MB
spring.servlet.multipart.location=/tmp/uploads

处理示例：

java复制@PostMapping("/upload")
public String handleUpload(@RequestParam MultipartFile file) {
    if (!file.isEmpty()) {
        String fileName = file.getOriginalFilename();
        Path path = Paths.get("/uploads", fileName);
        Files.copy(file.getInputStream(), path, StandardCopyOption.REPLACE_EXISTING);
        return "Upload success";
    }
    return "Upload failed";
}

13. Spring MVC扩展开发指南

13.1 自定义HandlerMapping实现

实现一个基于数据库配置的路由映射：

java复制public class DatabaseHandlerMapping extends AbstractHandlerMapping {
    
    private final RouteRepository routeRepository;
    
    public DatabaseHandlerMapping(RouteRepository routeRepository) {
        this.routeRepository = routeRepository;
    }
    
    @Override
    protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
        String path = getUrlPathHelper().getLookupPathForRequest(request);
        Route route = routeRepository.findByPath(path);
        
        if (route != null) {
            return new DatabaseHandler(route);
        }
        return null;
    }
    
    private static class DatabaseHandler {
        private final Route route;
        
        public DatabaseHandler(Route route) {
            this.route = route;
        }
        
        public String handle() {
            return route.getResponse();
        }
    }
}

13.2 自定义HandlerAdapter实现

适配上述DatabaseHandler：

java复制public class DatabaseHandlerAdapter implements HandlerAdapter {
    
    @Override
    public boolean supports(Object handler) {
        return handler instanceof DatabaseHandler;
    }
    
    @Override
    public ModelAndView handle(HttpServletRequest request, 
                             HttpServletResponse response, 
                             Object handler) throws Exception {
        
        DatabaseHandler dbHandler = (DatabaseHandler) handler;
        String result = dbHandler.handle();
        
        response.getWriter().write(result);
        return null;
    }
    
    @Override
    public long getLastModified(HttpServletRequest request, Object handler) {
        return -1;
    }
}

13.3 完整扩展点列表

14. Spring MVC最佳实践

14.1 控制器设计原则

1. 单一职责：每个控制器只负责一个业务领域
2. 瘦控制器：将业务逻辑移到Service层
3. 明确异常：定义清晰的异常层次结构
4. 统一响应：使用统一响应包装器

14.2 RESTful API设计指南

资源命名：

• 使用名词复数形式
• 避免动词出现在路径中
• 层次关系使用嵌套路径

HTTP方法使用：

响应状态码：

14.3 安全防护措施

1. 输入验证：

   • 使用Bean Validation注解
   • 对文件上传检查内容和扩展名

2. 输出编码：

   • 防止XSS攻击
   • 使用HtmlUtils.htmlEscape()

3. CSRF防护：

   • 启用Spring Security的CSRF保护
   • 对敏感操作使用POST请求

4. 安全头配置：

java复制@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.headers()
            .contentSecurityPolicy("default-src 'self'")
            .and()
            .xssProtection()
            .and()
            .httpStrictTransportSecurity();
    }
}