Spring MVC配置文件详解从基础到进阶掌握Web应用开发核心技巧
引言
Spring MVC是Spring框架中的一个重要模块，用于开发Web应用程序。它提供了一种基于模型-视图-控制器（MVC）架构的方式来构建Web应用，使得开发人员能够创建灵活、松耦合的Web应用程序。在Spring MVC中，配置文件起着至关重要的作用，它们定义了应用程序的结构、行为和组件之间的关系。本文将深入探讨Spring MVC配置文件的各个方面，从基础到进阶，帮助读者全面掌握Web应用开发的核心技巧。
Spring MVC基础概念
在深入配置文件之前，我们需要了解一些Spring MVC的基础概念：
DispatcherServlet
DispatcherServlet是Spring MVC的核心，它作为前端控制器（Front Controller）负责接收所有HTTP请求并将它们分发到相应的处理器。在传统的Servlet开发中，我们需要为每个功能创建一个Servlet，而在Spring MVC中，我们只需要配置一个DispatcherServlet，它将处理所有的请求并委托给适当的组件。
Controller
Controller是处理用户请求并返回响应的组件。在Spring MVC中，控制器通常使用@Controller或@RestController注解进行标记，并使用@RequestMapping或其变体（如@GetMapping、@PostMapping等）来映射请求。
Model
Model负责存储数据并将数据传递给视图。在Spring MVC中，Model是一个接口，它定义了添加模型属性的方法。控制器可以将数据添加到Model中，然后视图可以使用这些数据来渲染响应。
View
View负责渲染模型数据并生成用户界面。Spring MVC支持多种视图技术，如JSP、Thymeleaf、FreeMarker等。视图解析器（View Resolver）负责将逻辑视图名称解析为实际的视图对象。
ModelAndView
ModelAndView是一个容器，它同时包含了模型数据和视图信息。控制器可以返回ModelAndView对象，其中包含要显示的数据和要渲染的视图。
基于XML的Spring MVC配置
在早期的Spring MVC版本中，XML配置是最主要的配置方式。虽然现在Java配置更为流行，但了解XML配置仍然很重要，特别是在维护遗留项目时。
web.xml配置
在传统的Spring MVC应用中，我们需要在web.xml文件中配置DispatcherServlet：
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!-- 配置DispatcherServlet --> <servlet> <servlet-name>dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/spring/dispatcher-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>dispatcher</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <!-- 配置字符编码过滤器 --> <filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> <init-param> <param-name>forceEncoding</param-name> <param-value>true</param-value> </init-param> </filter> <filter-mapping> <filter-name>characterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> </web-app> 在这个配置中，我们定义了一个名为dispatcher的DispatcherServlet，并指定了它的配置文件位置为/WEB-INF/spring/dispatcher-servlet.xml。我们还配置了一个字符编码过滤器，以确保请求和响应都使用UTF-8编码。
Spring MVC配置文件
接下来，我们来看Spring MVC的配置文件dispatcher-servlet.xml：
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- 启用Spring MVC注解驱动 --> <mvc:annotation-driven/> <!-- 扫描控制器组件 --> <context:component-scan base-package="com.example.controller"/> <!-- 配置视图解析器 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/views/"/> <property name="suffix" value=".jsp"/> </bean> <!-- 配置静态资源处理 --> <mvc:resources mapping="/resources/**" location="/resources/"/> <!-- 配置拦截器 --> <mvc:interceptors> <mvc:interceptor> <mvc:mapping path="/**"/> <bean class="com.example.interceptor.LoggingInterceptor"/> </mvc:interceptor> </mvc:interceptors> <!-- 配置文件上传解析器 --> <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <property name="maxUploadSize" value="10485760"/> <!-- 10MB --> </bean> <!-- 配置国际化资源文件 --> <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource"> <property name="basename" value="classpath:messages"/> <property name="defaultEncoding" value="UTF-8"/> </bean> <!-- 配置本地化解析器 --> <bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver"> <property name="defaultLocale" value="zh_CN"/> </bean> </beans> 这个配置文件包含了Spring MVC应用的基本配置：
<mvc:annotation-driven/>：启用Spring MVC的注解驱动，支持@Controller、@RequestMapping等注解。<context:component-scan>：指定要扫描的包，Spring会自动注册带有@Controller、@Service等注解的组件。InternalResourceViewResolver：配置视图解析器，将逻辑视图名称解析为实际的JSP文件。<mvc:resources>：配置静态资源处理，将匹配的URL映射到指定的资源位置。<mvc:interceptors>：配置拦截器，用于在请求处理前后执行一些操作。CommonsMultipartResolver：配置文件上传解析器，支持文件上传功能。ReloadableResourceBundleMessageSource：配置国际化资源文件，支持多语言。SessionLocaleResolver：配置本地化解析器，根据会话确定用户的语言环境。
基于Java的Spring MVC配置
从Spring 3.1开始，我们可以使用Java配置来替代XML配置。这种方式更加类型安全，并且可以利用IDE的代码补全功能。
WebApplicationInitializer配置
首先，我们需要创建一个类来实现WebApplicationInitializer接口，以替代web.xml：
import org.springframework.web.WebApplicationInitializer; import org.springframework.web.context.ContextLoaderListener; import org.springframework.web.context.support.AnnotationConfigWebApplicationContext; import org.springframework.web.filter.CharacterEncodingFilter; import org.springframework.web.servlet.DispatcherServlet; import javax.servlet.FilterRegistration; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.ServletRegistration; public class MyWebAppInitializer implements WebApplicationInitializer { @Override public void onStartup(ServletContext servletContext) throws ServletException { // 创建根应用上下文 AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext(); rootContext.register(RootConfig.class); // 管理根应用上下文生命周期 servletContext.addListener(new ContextLoaderListener(rootContext)); // 创建DispatcherServlet的上下文 AnnotationConfigWebApplicationContext dispatcherContext = new AnnotationConfigWebApplicationContext(); dispatcherContext.register(WebConfig.class); // 注册并配置DispatcherServlet ServletRegistration.Dynamic dispatcher = servletContext.addServlet("dispatcher", new DispatcherServlet(dispatcherContext)); dispatcher.setLoadOnStartup(1); dispatcher.addMapping("/"); // 配置字符编码过滤器 FilterRegistration.Dynamic characterEncodingFilter = servletContext.addFilter("characterEncodingFilter", new CharacterEncodingFilter()); characterEncodingFilter.setInitParameter("encoding", "UTF-8"); characterEncodingFilter.setInitParameter("forceEncoding", "true"); characterEncodingFilter.addMappingForUrlPatterns(null, false, "/*"); } } 根配置类
接下来，我们创建根配置类RootConfig，用于配置非Web相关的组件：
import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.FilterType; import org.springframework.web.servlet.config.annotation.EnableWebMvc; @Configuration @ComponentScan(basePackages = "com.example", excludeFilters = { @ComponentScan.Filter(type = FilterType.ANNOTATION, value = EnableWebMvc.class) }) public class RootConfig { // 配置非Web相关的组件，如服务层、数据访问层等 } Web配置类
然后，我们创建Web配置类WebConfig，用于配置Web相关的组件：
import com.example.interceptor.LoggingInterceptor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.web.multipart.commons.CommonsMultipartResolver; import org.springframework.web.servlet.config.annotation.EnableWebMvc; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import org.springframework.web.servlet.i18n.SessionLocaleResolver; import org.springframework.web.servlet.view.InternalResourceViewResolver; import java.util.Locale; @Configuration @EnableWebMvc @ComponentScan("com.example.controller") public class WebConfig implements WebMvcConfigurer { // 配置视图解析器 @Bean public InternalResourceViewResolver viewResolver() { InternalResourceViewResolver resolver = new InternalResourceViewResolver(); resolver.setPrefix("/WEB-INF/views/"); resolver.setSuffix(".jsp"); return resolver; } // 配置静态资源处理 @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/resources/**").addResourceLocations("/resources/"); } // 配置拦截器 @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new LoggingInterceptor()).addPathPatterns("/**"); } // 配置文件上传解析器 @Bean public CommonsMultipartResolver multipartResolver() { CommonsMultipartResolver resolver = new CommonsMultipartResolver(); resolver.setMaxUploadSize(10485760); // 10MB return resolver; } // 配置本地化解析器 @Bean public SessionLocaleResolver localeResolver() { SessionLocaleResolver resolver = new SessionLocaleResolver(); resolver.setDefaultLocale(Locale.CHINA); return resolver; } } 这个Java配置与之前的XML配置是等效的，但更加简洁和类型安全。@EnableWebMvc注解等同于XML中的<mvc:annotation-driven/>，它启用了Spring MVC的注解驱动功能。
Spring MVC核心组件配置详解
现在，让我们详细解析Spring MVC中的核心组件配置。
视图解析器配置
视图解析器负责将控制器返回的逻辑视图名称解析为实际的视图对象。Spring MVC提供了多种视图解析器，我们可以根据需要选择或组合使用。
InternalResourceViewResolver
InternalResourceViewResolver是最常用的视图解析器，它用于解析JSP等内部资源视图：
@Bean public InternalResourceViewResolver viewResolver() { InternalResourceViewResolver resolver = new InternalResourceViewResolver(); resolver.setPrefix("/WEB-INF/views/"); resolver.setSuffix(".jsp"); resolver.setViewClass(JstlView.class); // 支持JSTL resolver.setContentType("text/html;charset=UTF-8"); // 设置内容类型 return resolver; } 对应的XML配置：
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/views/"/> <property name="suffix" value=".jsp"/> <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/> <property name="contentType" value="text/html;charset=UTF-8"/> </bean> ContentNegotiatingViewResolver
ContentNegotiatingViewResolver是一个非常有用的视图解析器，它可以根据请求的内容类型（如Accept头）或文件扩展名来选择最适合的视图：
@Bean public ViewResolver contentNegotiatingViewResolver(ContentNegotiationManager manager) { ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver(); resolver.setContentNegotiationManager(manager); // 定义默认视图 List<View> defaultViews = new ArrayList<>(); defaultViews.add(new MappingJackson2JsonView()); resolver.setDefaultViews(defaultViews); return resolver; } @Bean public ContentNegotiationManager contentNegotiationManager() { ContentNegotiationManagerFactoryBean factory = new ContentNegotiationManagerFactoryBean(); factory.setFavorPathExtension(true); factory.setIgnoreAcceptHeader(false); factory.setDefaultContentType(MediaType.TEXT_HTML); factory.setMediaTypes(Collections.singletonMap("json", MediaType.APPLICATION_JSON)); return factory.getObject(); } 对应的XML配置：
<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver"> <property name="contentNegotiationManager" ref="contentNegotiationManager"/> <property name="defaultViews"> <list> <bean class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/> </list> </property> </bean> <bean id="contentNegotiationManager" class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean"> <property name="favorPathExtension" value="true"/> <property name="ignoreAcceptHeader" value="false"/> <property name="defaultContentType" value="text/html"/> <property name="mediaTypes"> <map> <entry key="json" value="application/json"/> </map> </property> </bean> 拦截器配置
拦截器（Interceptor）类似于Servlet中的过滤器（Filter），但它们是Spring MVC框架的一部分，可以更精确地控制拦截的范围。拦截器可以用于日志记录、权限检查、性能监控等场景。
创建拦截器
首先，我们需要创建一个拦截器类，实现HandlerInterceptor接口：
import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class LoggingInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { long startTime = System.currentTimeMillis(); request.setAttribute("startTime", startTime); System.out.println("Request URL::" + request.getRequestURL().toString() + ":: Start Time=" + System.currentTimeMillis()); return true; // 返回true继续处理请求，返回false中断请求 } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println("Request URL::" + request.getRequestURL().toString() + ":: Sent to Handler :: Current Time=" + System.currentTimeMillis()); } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { long startTime = (Long) request.getAttribute("startTime"); long endTime = System.currentTimeMillis(); System.out.println("Request URL::" + request.getRequestURL().toString() + ":: End Time=" + endTime); System.out.println("Request URL::" + request.getRequestURL().toString() + ":: Time Taken=" + (endTime - startTime)); } } 配置拦截器
然后，我们需要在Spring MVC配置中注册这个拦截器：
Java配置：
@Override public void addInterceptors(InterceptorRegistry registry) { // 注册日志拦截器，应用于所有请求 registry.addInterceptor(new LoggingInterceptor()).addPathPatterns("/**"); // 注册权限检查拦截器，应用于特定路径 registry.addInterceptor(new AuthorizationInterceptor()) .addPathPatterns("/secure/**") .excludePathPatterns("/secure/login", "/secure/logout"); } XML配置：
<mvc:interceptors> <!-- 日志拦截器，应用于所有请求 --> <mvc:interceptor> <mvc:mapping path="/**"/> <bean class="com.example.interceptor.LoggingInterceptor"/> </mvc:interceptor> <!-- 权限检查拦截器，应用于特定路径 --> <mvc:interceptor> <mvc:mapping path="/secure/**"/> <mvc:exclude-mapping path="/secure/login"/> <mvc:exclude-mapping path="/secure/logout"/> <bean class="com.example.interceptor.AuthorizationInterceptor"/> </mvc:interceptor> </mvc:interceptors> 文件上传配置
Spring MVC提供了对文件上传的支持，我们需要配置一个MultipartResolver来处理文件上传请求。
CommonsMultipartResolver
CommonsMultipartResolver是基于Apache Commons FileUpload的文件上传解析器：
Java配置：
@Bean public MultipartResolver multipartResolver() { CommonsMultipartResolver resolver = new CommonsMultipartResolver(); resolver.setMaxUploadSize(10485760); // 设置最大上传文件大小，单位是字节（10MB） resolver.setMaxInMemorySize(4096); // 设置在内存中的最大大小，单位是字节（4KB） resolver.setDefaultEncoding("UTF-8"); // 设置默认编码 return resolver; } XML配置：
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <property name="maxUploadSize" value="10485760"/> <!-- 10MB --> <property name="maxInMemorySize" value="4096"/> <!-- 4KB --> <property name="defaultEncoding" value="UTF-8"/> </bean> StandardServletMultipartResolver
StandardServletMultipartResolver是基于Servlet 3.0 Part API的文件上传解析器，不需要额外的依赖：
Java配置：
@Bean public MultipartResolver multipartResolver() { StandardServletMultipartResolver resolver = new StandardServletMultipartResolver(); return resolver; } XML配置：
<bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver"/> 使用StandardServletMultipartResolver时，还需要在Servlet配置中启用multipart支持：
// 在WebApplicationInitializer中 MultipartConfigElement multipartConfigElement = new MultipartConfigElement("/tmp", 10485760, 10485760 * 2, 0); dispatcher.setMultipartConfig(multipartConfigElement); 或者在web.xml中：
<servlet> <servlet-name>dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <multipart-config> <location>/tmp</location> <max-file-size>10485760</max-file-size> <!-- 10MB --> <max-request-size>20971520</max-request-size> <!-- 20MB --> <file-size-threshold>0</file-size-threshold> </multipart-config> </servlet> 国际化配置
Spring MVC提供了强大的国际化支持，可以根据用户的语言环境显示不同的消息。
消息源配置
首先，我们需要配置消息源，加载不同语言的资源文件：
Java配置：
@Bean public MessageSource messageSource() { ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource(); messageSource.setBasename("classpath:messages"); messageSource.setDefaultEncoding("UTF-8"); messageSource.setCacheSeconds(10); // 缓存时间，单位秒 return messageSource; } XML配置：
<bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource"> <property name="basename" value="classpath:messages"/> <property name="defaultEncoding" value="UTF-8"/> <property name="cacheSeconds" value="10"/> </bean> 本地化解析器配置
然后，我们需要配置本地化解析器，用于确定用户的语言环境：
SessionLocaleResolver
SessionLocaleResolver将用户的语言环境存储在HTTP会话中：
Java配置：
@Bean public LocaleResolver localeResolver() { SessionLocaleResolver resolver = new SessionLocaleResolver(); resolver.setDefaultLocale(Locale.CHINA); return resolver; } XML配置：
<bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver"> <property name="defaultLocale" value="zh_CN"/> </bean> CookieLocaleResolver
CookieLocaleResolver将用户的语言环境存储在Cookie中：
Java配置：
@Bean public LocaleResolver localeResolver() { CookieLocaleResolver resolver = new CookieLocaleResolver(); resolver.setCookieName("lang"); resolver.setCookieMaxAge(3600); // Cookie过期时间，单位秒 resolver.setDefaultLocale(Locale.CHINA); return resolver; } XML配置：
<bean id="localeResolver" class="org.springframework.web.servlet.i18n.CookieLocaleResolver"> <property name="cookieName" value="lang"/> <property name="cookieMaxAge" value="3600"/> <property name="defaultLocale" value="zh_CN"/> </bean> AcceptHeaderLocaleResolver
AcceptHeaderResolver根据HTTP请求的Accept-Language头确定用户的语言环境：
Java配置：
@Bean public LocaleResolver localeResolver() { AcceptHeaderLocaleResolver resolver = new AcceptHeaderLocaleResolver(); resolver.setDefaultLocale(Locale.CHINA); return resolver; } XML配置：
<bean id="localeResolver" class="org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver"> <property name="defaultLocale" value="zh_CN"/> </bean> 本地化拦截器配置
为了能够根据用户的请求更改语言环境，我们可以配置一个本地化拦截器：
Java配置：
@Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new LocaleChangeInterceptor()).addPathPatterns("/**"); } XML配置：
<mvc:interceptors> <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"> <property name="paramName" value="lang"/> </bean> </mvc:interceptors> 这样，我们可以通过在URL中添加lang参数来更改语言环境，例如：http://example.com?lang=en。
高级配置技巧
在掌握了基础配置之后，让我们来看一些高级的配置技巧，这些技巧可以帮助我们更好地使用Spring MVC。
自定义参数解析器
参数解析器（HandlerMethodArgumentResolver）用于将请求参数解析为控制器方法的参数。Spring MVC提供了许多内置的参数解析器，但我们也可以自定义参数解析器来满足特殊需求。
创建自定义参数解析器
假设我们有一个自定义的注解@CurrentUser，用于注入当前登录的用户：
import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) public @interface CurrentUser { } 然后，我们创建一个参数解析器来处理这个注解：
import org.springframework.core.MethodParameter; import org.springframework.web.bind.support.WebDataBinderFactory; import org.springframework.web.context.request.NativeWebRequest; import org.springframework.web.method.support.HandlerMethodArgumentResolver; import org.springframework.web.method.support.ModelAndViewContainer; public class CurrentUserMethodArgumentResolver implements HandlerMethodArgumentResolver { @Override public boolean supportsParameter(MethodParameter parameter) { return parameter.getParameterAnnotation(CurrentUser.class) != null && parameter.getParameterType().equals(User.class); } @Override public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { // 从会话中获取当前用户 HttpSession session = webRequest.getNativeRequest(HttpServletRequest.class).getSession(); return session.getAttribute("currentUser"); } } 注册自定义参数解析器
然后，我们需要在Spring MVC配置中注册这个参数解析器：
Java配置：
@Configuration @EnableWebMvc @ComponentScan("com.example.controller") public class WebConfig implements WebMvcConfigurer { @Override public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) { resolvers.add(new CurrentUserMethodArgumentResolver()); } // 其他配置... } XML配置：
<mvc:annotation-driven> <mvc:argument-resolvers> <bean class="com.example.resolver.CurrentUserMethodArgumentResolver"/> </mvc:argument-resolvers> </mvc:annotation-driven> 使用自定义参数解析器
现在，我们可以在控制器方法中使用@CurrentUser注解：
@Controller public class UserController { @GetMapping("/profile") public String profile(@CurrentUser User user, Model model) { model.addAttribute("user", user); return "profile"; } } 自定义返回值处理器
返回值处理器（HandlerMethodReturnValueHandler）用于处理控制器方法的返回值，并将其转换为响应。Spring MVC提供了许多内置的返回值处理器，但我们也可以自定义返回值处理器来满足特殊需求。
创建自定义返回值处理器
假设我们想要创建一个返回值处理器，将返回的ApiResponse对象转换为JSON响应：
public class ApiResponse { private int code; private String message; private Object data; // 构造方法、getter和setter... } 然后，我们创建一个返回值处理器：
import org.springframework.core.MethodParameter; import org.springframework.web.context.request.NativeWebRequest; import org.springframework.web.method.support.HandlerMethodReturnValueHandler; import org.springframework.web.method.support.ModelAndViewContainer; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.io.PrintWriter; public class ApiResponseReturnValueHandler implements HandlerMethodReturnValueHandler { @Override public boolean supportsReturnType(MethodParameter returnType) { return ApiResponse.class.isAssignableFrom(returnType.getParameterType()); } @Override public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws IOException { mavContainer.setRequestHandled(true); // 表示已经处理了响应 HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class); response.setContentType("application/json;charset=UTF-8"); try (PrintWriter writer = response.getWriter()) { // 使用Jackson将ApiResponse对象转换为JSON字符串 ObjectMapper mapper = new ObjectMapper(); String json = mapper.writeValueAsString(returnValue); writer.write(json); } } } 注册自定义返回值处理器
然后，我们需要在Spring MVC配置中注册这个返回值处理器：
Java配置：
@Configuration @EnableWebMvc @ComponentScan("com.example.controller") public class WebConfig implements WebMvcConfigurer { @Override public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> handlers) { handlers.add(new ApiResponseReturnValueHandler()); } // 其他配置... } XML配置：
<mvc:annotation-driven> <mvc:return-value-handlers> <bean class="com.example.handler.ApiResponseReturnValueHandler"/> </mvc:return-value-handlers> </mvc:annotation-driven> 使用自定义返回值处理器
现在，我们可以在控制器方法中返回ApiResponse对象：
@Controller public class UserController { @GetMapping("/users/{id}") @ResponseBody public ApiResponse getUser(@PathVariable Long id) { User user = userService.findById(id); if (user != null) { return new ApiResponse(200, "Success", user); } else { return new ApiResponse(404, "User not found", null); } } } 自定义异常处理器
异常处理器（Exception Handler）用于处理控制器方法抛出的异常，并返回适当的响应。Spring MVC提供了@ExceptionHandler注解来定义异常处理方法，但我们也可以全局异常处理器。
创建全局异常处理器
import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.servlet.ModelAndView; @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(UserNotFoundException.class) public ModelAndView handleUserNotFoundException(UserNotFoundException ex) { ModelAndView mav = new ModelAndView(); mav.addObject("errorMessage", ex.getMessage()); mav.setViewName("error/userNotFound"); return mav; } @ExceptionHandler(Exception.class) public ModelAndView handleException(Exception ex) { ModelAndView mav = new ModelAndView(); mav.addObject("errorMessage", "An error occurred: " + ex.getMessage()); mav.setViewName("error/genericError"); return mav; } } 创建REST风格的全局异常处理器
对于REST API，我们可以创建一个返回JSON响应的全局异常处理器：
import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ExceptionHandler; @ControllerAdvice public class RestGlobalExceptionHandler { @ExceptionHandler(UserNotFoundException.class) public ResponseEntity<ApiResponse> handleUserNotFoundException(UserNotFoundException ex) { ApiResponse response = new ApiResponse(404, ex.getMessage(), null); return new ResponseEntity<>(response, HttpStatus.NOT_FOUND); } @ExceptionHandler(Exception.class) public ResponseEntity<ApiResponse> handleException(Exception ex) { ApiResponse response = new ApiResponse(500, "An error occurred: " + ex.getMessage(), null); return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR); } } 自定义消息转换器
消息转换器（HttpMessageConverter）用于将HTTP请求消息转换为Java对象，或将Java对象转换为HTTP响应消息。Spring MVC提供了许多内置的消息转换器，但我们也可以自定义消息转换器来满足特殊需求。
创建自定义消息转换器
假设我们想要创建一个消息转换器，用于处理YAML格式的请求和响应：
import org.springframework.http.HttpInputMessage; import org.springframework.http.HttpOutputMessage; import org.springframework.http.MediaType; import org.springframework.http.converter.AbstractHttpMessageConverter; import org.springframework.http.converter.HttpMessageNotReadableException; import org.springframework.http.converter.HttpMessageNotWritableException; import org.yaml.snakeyaml.Yaml; import org.yaml.snakeyaml.constructor.Constructor; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.nio.charset.Charset; public class YamlHttpMessageConverter extends AbstractHttpMessageConverter<Object> { private final Yaml yaml; public YamlHttpMessageConverter() { super(new MediaType("application", "yaml", Charset.forName("UTF-8"))); this.yaml = new Yaml(); } public YamlHttpMessageConverter(Class<?> type) { this(); this.yaml = new Yaml(new Constructor(type)); } @Override protected boolean supports(Class<?> clazz) { return true; } @Override protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException { try (InputStreamReader reader = new InputStreamReader(inputMessage.getBody(), "UTF-8")) { return yaml.load(reader); } } @Override protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException { try (OutputStreamWriter writer = new OutputStreamWriter(outputMessage.getBody(), "UTF-8")) { yaml.dump(o, writer); } } } 注册自定义消息转换器
然后，我们需要在Spring MVC配置中注册这个消息转换器：
Java配置：
@Configuration @EnableWebMvc @ComponentScan("com.example.controller") public class WebConfig implements WebMvcConfigurer { @Override public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { converters.add(new YamlHttpMessageConverter()); } // 其他配置... } XML配置：
<mvc:annotation-driven> <mvc:message-converters> <bean class="com.example.converter.YamlHttpMessageConverter"/> </mvc:message-converters> </mvc:annotation-driven> 使用自定义消息转换器
现在，我们可以在控制器方法中使用YAML格式的请求和响应：
@RestController @RequestMapping("/api/users") public class UserController { @PostMapping(consumes = "application/yaml", produces = "application/yaml") public User createUser(@RequestBody User user) { return userService.save(user); } } 常见问题与解决方案
在使用Spring MVC配置文件时，我们可能会遇到一些常见问题。下面，我将介绍一些常见问题及其解决方案。
静态资源访问问题
问题描述：在配置Spring MVC后，静态资源（如CSS、JavaScript、图片等）无法访问。
解决方案：
- 使用
<mvc:resources>标签配置静态资源处理：
<mvc:resources mapping="/resources/**" location="/resources/"/> - 或者使用Java配置：
@Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/resources/**").addResourceLocations("/resources/"); } - 如果使用默认的Servlet处理静态资源，可以添加以下配置：
<mvc:default-servlet-handler/> 或者使用Java配置：
@Configuration @EnableWebMvc public class WebConfig implements WebMvcConfigurer { @Override public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { configurer.enable(); } // 其他配置... } 字符编码问题
问题描述：在处理中文请求和响应时，出现乱码。
解决方案：
- 配置字符编码过滤器：
<filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> <init-param> <param-name>forceEncoding</param-name> <param-value>true</param-value> </init-param> </filter> <filter-mapping> <filter-name>characterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> - 或者使用Java配置：
@Bean public FilterRegistrationBean<CharacterEncodingFilter> characterEncodingFilter() { CharacterEncodingFilter filter = new CharacterEncodingFilter(); filter.setEncoding("UTF-8"); filter.setForceEncoding(true); FilterRegistrationBean<CharacterEncodingFilter> registration = new FilterRegistrationBean<>(); registration.setFilter(filter); registration.addUrlPatterns("/*"); return registration; } - 配置视图解析器的内容类型：
@Bean public InternalResourceViewResolver viewResolver() { InternalResourceViewResolver resolver = new InternalResourceViewResolver(); resolver.setPrefix("/WEB-INF/views/"); resolver.setSuffix(".jsp"); resolver.setContentType("text/html;charset=UTF-8"); return resolver; } 文件上传问题
问题描述：文件上传功能无法正常工作，或者上传大文件时出现错误。
解决方案：
- 确保已配置
MultipartResolver：
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <property name="maxUploadSize" value="10485760"/> <!-- 10MB --> <property name="maxInMemorySize" value="4096"/> <!-- 4KB --> <property name="defaultEncoding" value="UTF-8"/> </bean> - 或者使用Java配置：
@Bean public MultipartResolver multipartResolver() { CommonsMultipartResolver resolver = new CommonsMultipartResolver(); resolver.setMaxUploadSize(10485760); // 10MB resolver.setMaxInMemorySize(4096); // 4KB resolver.setDefaultEncoding("UTF-8"); return resolver; } - 如果使用
StandardServletMultipartResolver，确保在Servlet配置中启用了multipart支持：
// 在WebApplicationInitializer中 MultipartConfigElement multipartConfigElement = new MultipartConfigElement("/tmp", 10485760, 10485760 * 2, 0); dispatcher.setMultipartConfig(multipartConfigElement); - 确保表单的
enctype属性设置为multipart/form-data：
<form method="POST" action="/upload" enctype="multipart/form-data"> <input type="file" name="file"/> <input type="submit" value="Upload"/> </form> 控制器方法参数绑定问题
问题描述：控制器方法的参数无法正确绑定，或者日期类型无法正确转换。
解决方案：
- 对于日期类型，可以注册自定义的编辑器：
@InitBinder public void initBinder(WebDataBinder binder) { SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); dateFormat.setLenient(false); binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true)); } - 或者使用
@DateTimeFormat注解：
public class User { @DateTimeFormat(pattern = "yyyy-MM-dd") private Date birthDate; // getter和setter... } - 对于自定义对象，确保提供了正确的getter和setter方法，或者使用
@ModelAttribute注解：
@PostMapping("/users") public String createUser(@ModelAttribute User user) { userService.save(user); return "redirect:/users"; } 视图解析问题
问题描述：控制器返回的视图名称无法正确解析为实际的视图。
解决方案：
- 确保已正确配置视图解析器：
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/views/"/> <property name="suffix" value=".jsp"/> </bean> - 或者使用Java配置：
@Bean public InternalResourceViewResolver viewResolver() { InternalResourceViewResolver resolver = new InternalResourceViewResolver(); resolver.setPrefix("/WEB-INF/views/"); resolver.setSuffix(".jsp"); return resolver; } 确保视图文件存在于指定的位置，并且文件名与控制器返回的逻辑视图名称匹配。
如果使用多个视图解析器，确保它们的优先级设置正确：
<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver"> <property name="order" value="0"/> <!-- 其他配置... --> </bean> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="order" value="1"/> <!-- 其他配置... --> </bean> 或者使用Java配置：
@Bean public ViewResolver contentNegotiatingViewResolver() { ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver(); resolver.setOrder(0); // 其他配置... return resolver; } @Bean public ViewResolver internalResourceViewResolver() { InternalResourceViewResolver resolver = new InternalResourceViewResolver(); resolver.setOrder(1); // 其他配置... return resolver; } 最佳实践
在使用Spring MVC配置文件时，遵循一些最佳实践可以帮助我们构建更加健壮、可维护的应用程序。
使用Java配置而非XML配置
虽然XML配置在过去是Spring框架的主要配置方式，但现在Java配置已经成为主流。Java配置具有以下优势：
- 类型安全：Java配置在编译时就可以检查错误，而XML配置只能在运行时发现错误。
- 更好的IDE支持：IDE可以为Java配置提供代码补全、重构等功能。
- 更易于理解：Java配置更加直观，特别是对于Java开发人员来说。
- 更强大的灵活性：Java配置可以利用Java的所有特性，如条件配置、循环等。
示例：
@Configuration @EnableWebMvc @ComponentScan("com.example.controller") public class WebConfig implements WebMvcConfigurer { @Bean public InternalResourceViewResolver viewResolver() { InternalResourceViewResolver resolver = new InternalResourceViewResolver(); resolver.setPrefix("/WEB-INF/views/"); resolver.setSuffix(".jsp"); return resolver; } @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler("/resources/**").addResourceLocations("/resources/"); } // 其他配置... } 分离配置
将配置分离到多个类中，每个类负责特定的功能，可以提高代码的可读性和可维护性。
示例：
// Web配置 @Configuration @EnableWebMvc @ComponentScan("com.example.controller") public class WebConfig implements WebMvcConfigurer { // Web相关配置... } // 安全配置 @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { // 安全相关配置... } // 数据源配置 @Configuration @EnableTransactionManagement public class DataSourceConfig { // 数据源相关配置... } // 应用配置 @Configuration @ComponentScan(basePackages = "com.example.service", excludeFilters = { @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class) }) public class AppConfig { // 应用相关配置... } 使用条件配置
Spring 4.0引入了条件配置功能，可以根据特定条件决定是否加载某个配置或Bean。这可以帮助我们创建更加灵活的应用程序。
示例：
@Configuration public class AppConfig { @Bean @ConditionalOnProperty(name = "app.cache.type", havingValue = "redis") public CacheManager redisCacheManager() { // 创建Redis缓存管理器 return new RedisCacheManager(redisTemplate()); } @Bean @ConditionalOnProperty(name = "app.cache.type", havingValue = "ehcache") public CacheManager ehCacheCacheManager() { // 创建EhCache缓存管理器 return new EhCacheCacheManager(ehCacheManagerFactory().getObject()); } // 其他配置... } 使用Profile
Spring的Profile功能允许我们根据不同的环境（如开发、测试、生产）加载不同的配置。这对于管理不同环境的配置非常有用。
示例：
@Configuration @Profile("dev") public class DevConfig { @Bean public DataSource dataSource() { // 开发环境数据源 return new EmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.H2) .addScript("classpath:schema.sql") .addScript("classpath:data.sql") .build(); } } @Configuration @Profile("prod") public class ProdConfig { @Bean public DataSource dataSource() { // 生产环境数据源 BasicDataSource dataSource = new BasicDataSource(); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/mydb"); dataSource.setUsername("username"); dataSource.setPassword("password"); return dataSource; } } 使用外部化配置
将配置外部化，而不是硬编码在代码中，可以提高应用程序的灵活性和可维护性。Spring提供了多种外部化配置的方式，如属性文件、环境变量、JNDI等。
示例：
@Configuration @PropertySource("classpath:application.properties") public class AppConfig { @Value("${app.name}") private String appName; @Value("${app.version}") private String appVersion; @Bean public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() { return new PropertySourcesPlaceholderConfigurer(); } // 其他配置... } 使用合理的包结构
合理的包结构可以提高代码的组织性和可维护性。通常，我们可以按照功能或层次来组织包结构。
按照功能组织：
com.example ├── user │ ├── UserController.java │ ├── UserService.java │ ├── UserRepository.java │ └── User.java ├── product │ ├── ProductController.java │ ├── ProductService.java │ ├── ProductRepository.java │ └── Product.java └── common ├── BaseController.java ├── BaseService.java └── BaseRepository.java 按照层次组织：
com.example ├── controller │ ├── UserController.java │ └── ProductController.java ├── service │ ├── UserService.java │ └── ProductService.java ├── repository │ ├── UserRepository.java │ └── ProductRepository.java ├── model │ ├── User.java │ └── Product.java └── config ├── WebConfig.java └── SecurityConfig.java 使用合理的命名规范
使用合理的命名规范可以提高代码的可读性和可维护性。以下是一些常用的命名规范：
- 类名：使用大驼峰命名法（PascalCase），如
UserController、UserService。 - 方法名：使用小驼峰命名法（camelCase），如
getUserById、saveUser。 - 变量名：使用小驼峰命名法（camelCase），如
userName、userList。 - 常量名：使用全大写字母，单词之间用下划线分隔，如
MAX_USER_COUNT。 - 包名：使用全小写字母，单词之间用点号分隔，如
com.example.controller。
使用注解简化配置
Spring提供了许多注解来简化配置，使用这些注解可以减少XML配置或Java配置的代码量。
示例：
@RestController @RequestMapping("/api/users") public class UserController { @Autowired private UserService userService; @GetMapping("/{id}") public ResponseEntity<User> getUser(@PathVariable Long id) { User user = userService.findById(id); if (user != null) { return ResponseEntity.ok(user); } else { return ResponseEntity.notFound().build(); } } @PostMapping public ResponseEntity<User> createUser(@Valid @RequestBody User user) { User savedUser = userService.save(user); return ResponseEntity.created(URI.create("/api/users/" + savedUser.getId())).body(savedUser); } @PutMapping("/{id}") public ResponseEntity<User> updateUser(@PathVariable Long id, @Valid @RequestBody User user) { if (!userService.existsById(id)) { return ResponseEntity.notFound().build(); } user.setId(id); User updatedUser = userService.save(user); return ResponseEntity.ok(updatedUser); } @DeleteMapping("/{id}") public ResponseEntity<Void> deleteUser(@PathVariable Long id) { if (!userService.existsById(id)) { return ResponseEntity.notFound().build(); } userService.deleteById(id); return ResponseEntity.noContent().build(); } } 使用合理的异常处理
合理的异常处理可以提高应用程序的健壮性和用户体验。Spring MVC提供了多种异常处理方式，如@ExceptionHandler、@ControllerAdvice等。
示例：
@ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(UserNotFoundException.class) public ResponseEntity<ErrorResponse> handleUserNotFoundException(UserNotFoundException ex) { ErrorResponse error = new ErrorResponse("USER_NOT_FOUND", ex.getMessage()); return new ResponseEntity<>(error, HttpStatus.NOT_FOUND); } @ExceptionHandler(MethodArgumentNotValidException.class) public ResponseEntity<ErrorResponse> handleValidationExceptions(MethodArgumentNotValidException ex) { List<String> errors = ex.getBindingResult() .getAllErrors() .stream() .map(DefaultMessageSourceResolvable::getDefaultMessage) .collect(Collectors.toList()); ErrorResponse error = new ErrorResponse("VALIDATION_FAILED", "Validation failed", errors); return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST); } @ExceptionHandler(Exception.class) public ResponseEntity<ErrorResponse> handleException(Exception ex) { ErrorResponse error = new ErrorResponse("INTERNAL_ERROR", "An internal error occurred"); return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR); } } 使用合理的日志记录
合理的日志记录可以帮助我们更好地了解应用程序的运行情况，并在出现问题时快速定位问题。Spring Boot默认使用SLF4J和Logback作为日志框架。
示例：
@RestController @RequestMapping("/api/users") public class UserController { private static final Logger logger = LoggerFactory.getLogger(UserController.class); @Autowired private UserService userService; @GetMapping("/{id}") public ResponseEntity<User> getUser(@PathVariable Long id) { logger.debug("Getting user with ID: {}", id); try { User user = userService.findById(id); if (user != null) { logger.info("User found with ID: {}", id); return ResponseEntity.ok(user); } else { logger.warn("User not found with ID: {}", id); return ResponseEntity.notFound().build(); } } catch (Exception e) { logger.error("Error getting user with ID: " + id, e); return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build(); } } // 其他方法... } 总结
Spring MVC是一个强大的Web框架，它提供了丰富的功能和灵活的配置选项。通过本文的学习，我们了解了Spring MVC配置文件的各个方面，从基础到进阶，包括：
- Spring MVC的基础概念，如DispatcherServlet、Controller、Model、View等。
- 基于XML的Spring MVC配置，包括web.xml和Spring MVC配置文件。
- 基于Java的Spring MVC配置，包括WebApplicationInitializer、根配置类和Web配置类。
- Spring MVC核心组件的详细配置，如视图解析器、拦截器、文件上传、国际化等。
- 高级配置技巧，如自定义参数解析器、自定义返回值处理器、自定义异常处理器、自定义消息转换器等。
- 常见问题与解决方案，如静态资源访问问题、字符编码问题、文件上传问题、控制器方法参数绑定问题、视图解析问题等。
- 最佳实践，如使用Java配置而非XML配置、分离配置、使用条件配置、使用Profile、使用外部化配置、使用合理的包结构、使用合理的命名规范、使用注解简化配置、使用合理的异常处理、使用合理的日志记录等。
通过掌握这些知识和技巧，我们可以更加高效地使用Spring MVC框架，构建出更加健壮、可维护的Web应用程序。希望本文能够帮助读者深入理解Spring MVC配置文件，并在实际开发中应用这些知识。
支付宝扫一扫
微信扫一扫 |
