《Spring 5 官方文档》18. Web MVC 框架

Spring MVC 3.2介绍了基于Servlet 3的异步请求处理。与往常一样，一个控制器方法现在可以返回一个java.util.concurrent.Callable并从Spring MVC管理的线程生成返回值，而不是返回一个 值。同时，主要的Servlet容器线程被退出并被释放并允许处理其他请求。Spring MVC Callable在一个单独的线程中调用一个单独的线程TaskExecutor，当Callable返回时，请求被分派回到Servlet容器，以使用返回的值来恢复处理Callable。这是一个这样一个控制器方法的例子：

@PostMapping
 public Callable <String> processUpload（ final MultipartFile文件）{

	返回 新的 Callable <String>（）{
		 public String call（）throws Exception {
			 // ... 
			return  “someView” ;
		}
	};

}

另一个选项是控制器方法返回一个实例DeferredResult。在这种情况下，返回值也将从任何线程生成，即不由Spring MVC管理的线程。例如，可以响应于诸如JMS消息，计划任务等的一些外部事件而产生结果。这是一个这样一个控制器方法的例子：

@RequestMapping（“/ quotes”）
@ResponseBody
 public DeferredResult <String> quotes（）{
	DeferredResult <String> deferredResult = new DeferredResult <String>（）;
	//将deferredResult保存在某个地方.. 
	return deferredResult;
}

//在其他一些线程中... 
deferredResult.setResult（data）;

没有任何Servlet 3.0异步请求处理功能的知识可能难以理解。这肯定有助于阅读。以下是有关基本机制的几个基本事实：

考虑到上述情况，以下是异步请求处理的事件的顺序Callable：

序列DeferredResult非常相似，除了由应用程序产生任何线程的异步结果：

有关异步请求处理的动机的进一步背景，何时或为什么使用它，请阅读 此博客文章系列。

@RequestMapping（“/ events”）
 public ResponseBodyEmitter handle（）{
	ResponseBodyEmitter emitter = new ResponseBodyEmitter（）;
	//保存发射的地方.. 
	返回发射器;
}

//在其他一些线程 
emit.send（“Hello once”）;

//再次在 
emitter.send（“Hello again”）;

//并在某个时候完成 
emitter.complete（）;

@RequestMapping（“/ download”）
 public StreamingResponseBody handle（）{
	 return  new StreamingResponseBody（）{@
		 Override
		 public  void writeTo（OutputStream outputStream） throws IOException {
			 // write ...
		}
	};
}

<web-app  xmlns = “http://java.sun.com/xml/ns/javaee” 
	xmlns：xsi = “http://www.w3.org/2001/XMLSchema-instance” 
			http：// java。 sun.com/xml/ns/javaee 
			http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd” 
	版本 = “3.0” >

	...

</ web的应用>

<web-app  xmlns = “http://java.sun.com/xml/ns/javaee” 
	xmlns：xsi = “http://www.w3.org/2001/XMLSchema-instance” 
	xsi：schemaLocation = “
			http://java.sun.com/xml/ns/javaee
			http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd” 
	版本 = “3.0” >

	<filter> 
		<filter-name> Spring OpenEntityManagerInViewFilter </ filter-name> 
		<filter-class> org.springframework。〜.OpenEntityManagerInViewFilter </ filter-class> 
		<async-supported> true </ async-supported> 
	</ filter>

	<滤波器映射> 
		<滤波器名称>春OpenEntityManagerInViewFilter </过滤器名称> 
		<URL模式> / * </ URL模式> 
		<调度> REQUEST </调度程序> 
		<调度> ASYNC </调度程序> 
	</过滤器-mapping>

</ web的应用>

该spring-test模块提供一流的支持，用于测试带注释的控制器。参见第11.6节“Spring MVC测试框架”。

Spring的处理程序映射机制包括处理程序拦截器，当您希望将特定功能应用于某些请求时，例如，检查主体，这是有用的。

位于处理程序映射中的拦截器必须HandlerInterceptor从 org.springframework.web.servlet包中实现。这个接口定义了三个方法： preHandle(..)被称为前被执行的实际处理程序; postHandle(..)被称为后执行的处理程序; 并在完成请求完成后afterCompletion(..)调用。这三种方法应提供足够的灵活性进行各种预处理和后处理。

该preHandle(..)方法返回一个布尔值。您可以使用此方法来中断或继续处理执行链。当此方法返回true时，处理程序执行链将继续; 当它返回false时，DispatcherServlet 假定拦截器本身已经处理了请求（并且例如呈现适当的视图），并且不会继续执行其他拦截器和执行链中的实际处理程序。

拦截器可以使用interceptors属性进行配置，该属性存在于所有HandlerMapping类中AbstractHandlerMapping。这在下面的示例中显示：

<bean> 
	<bean  id = “handlerMapping” 
			class = “org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping” > 
		<property  name = “interceptors” > 
			<list> 
				<ref  bean = “officeHoursInterceptor” /> 
			</ list> 
		</ property> 
	</ bean>

	<bean  id = “officeHoursInterceptor” 
			class = “samples.TimeBasedAccessInterceptor” > 
		<property  name = “openingTime”  value = “9” /> 
		<property  name = “closingTime”  value = “18” /> 
	</ bean> 
</ beans >

包装样品;

public  class TimeBasedAccessInterceptor extends HandlerInterceptorAdapter {

	private  int openingTime;
	private  int closingTime;

	public  void setOpeningTime（int openingTime）{
		 this .openingTime = openingTime;
	}

	public  void setClosingTime（int closingTime）{
		 this .closingTime = closingTime;
	}

	public  boolean preHandle（HttpServletRequest request，HttpServletResponse response，
			对象处理程序）throws Exception {
		日历cal = Calendar.getInstance（）;
		int hour = cal.get（HOUR_OF_DAY）;
		if（openingTime <= hour && hour <closingTime）{
			 return true;
		}
		response.sendRedirect（“http://host.com/outsideOfficeHours.html”）;
		返回假
	}
}

该映射处理的任何请求都被截取TimeBasedAccessInterceptor。如果当前时间在办公时间之外，用户将被重定向到静态HTML文件，例如，您只能在办公时间内访问该网站。

	当使用RequestMappingHandlerMapping实际处理程序时，HandlerMethod它的一个实例 标识将被调用的特定控制器方法。

您可以看到，Spring适配器类HandlerInterceptorAdapter可以更容易地扩展HandlerInterceptor接口。

	在上面的示例中，配置的拦截器将应用于使用注释控制器方法处理的所有请求。如果要缩小拦截器应用的URL路径，可以使用MVC命名空间或MVC Java配置，或声明类型的bean实例MappedInterceptor。请参见第18.16.1节“启用MVC Java配置或MVC XML命名空间”。

请注意，该postHandle方法HandlerInterceptor并不总是非常适用于@ResponseBody和ResponseEntity方法。在这种情况下HttpMessageConverter ，在postHandle调用之前写入并提交响应，这使得不可能更改响应，例如添加标题。相反，应用程序可以实现 ResponseBodyAdvice并将其声明为@ControllerAdvicebean或直接配置它RequestMappingHandlerAdapter。

正如在讨论第18.3节，“实施控制器”，在Spring Web MVC框架控制器的所有处理方法必须解析为一个逻辑视图名称，明确地（例如，通过返回 String，View或ModelAndView）或隐式（即基于惯例）。Spring中的视图由逻辑视图名称解析，并由视图解析器解析。春天有不少视角解析器。这张表列出了大部分; 以下几个例子。

例如，使用JSP作为视图技术，可以使用UrlBasedViewResolver。此视图解析器将视图名称转换为URL，并将请求转交给RequestDispatcher以呈现视图。

<bean  id = “viewResolver” 
		class = “org.springframework.web.servlet.view.UrlBasedViewResolver” > 
	<property  name = “viewClass”  value = “org.springframework.web.servlet.view.JstlView” /> 
	<property  name = “prefix”  value = “/ WEB-INF / jsp /” /> 
	<property  name = “suffix”  value = “.jsp” /> 
</ bean>

当test以逻辑视图名称返回时，此视图解析器将请求转发到RequestDispatcher将要发送的请求/WEB-INF/jsp/test.jsp。

当您在Web应用程序中组合不同的视图技术时，可以使用 ResourceBundleViewResolver：

<bean  id = “viewResolver” 
		class = “org.springframework.web.servlet.view.ResourceBundleViewResolver” > 
	<property  name = “basename”  value = “views” /> 
	<property  name = “defaultParentView”  value = “parentView” / > 
</ bean>

在ResourceBundleViewResolver考察ResourceBundle确定了基本名字和它应该解决每个视图，它使用属性的值 [viewname].(class)作为视图类和属性的值[viewname].url作为视图的URL。示例可以在下一章中找到，涵盖视图技术。您可以看到，您可以识别父视图，从属性文件中的所有视图“扩展”。这样，您可以指定默认视图类。

	AbstractCachingViewResolver他们解析的缓存视图实例的子类。缓存提高了某些视图技术的性能。可以通过将cache属性设置为关闭缓存false。此外，如果您必须在运行时刷新某个视图（例如，当FreeMarker模板被修改时），则可以使用该removeFromCache(String viewName, Locale loc)方法。

Spring支持多个视图解析器。因此，您可以链接解析器，并且在某些情况下例如覆盖特定视图。您可以通过在应用程序上下文中添加多个解析器来链接视图解析器，如有必要，可以通过设置 order属性来指定排序。记住，order属性越高，视图解析器在链中的位置越晚。

在以下示例中，视图解析器由两个解析器组成，一个 InternalResourceViewResolver始终自动定位为链中的最后一个解析器，另一个XmlViewResolver用于指定Excel视图。Excel不支持Excel视图InternalResourceViewResolver。

<bean  id = “jspViewResolver”  class = “org.springframework.web.servlet.view.InternalResourceViewResolver” > 
	<property  name = “viewClass”  value = “org.springframework.web.servlet.view.JstlView” /> 
	<property  name = “prefix”  value = “/ WEB-INF / jsp /” /> 
	<property  name = “suffix”  value = “.jsp” /> 
</ bean>

<bean  id = “excelViewResolver”  class = “org.springframework.web.servlet.view.XmlViewResolver” > 
	<property  name = “order”  value = “1” /> 
	<property  name = “location”  value = “/ WEB- INF / views.xml“ /> 
</ bean>

<！ -  in views.xml  - >

<bean> 
	<bean  name = “report”  class = “org.springframework.example.ReportExcelView” /> 
</ beans>

如果一个特定的视图解析器不会产生视图，Spring会检查其他视图解析器的上下文。如果存在另外的视图解析器，Spring会继续检查它们，直到视图解决。如果没有视图解析器返回一个视图，Spring会抛出一个 ServletException。

视图解析器的合同指定视图解析器可以返回null以指示无法找到视图。然而，并不是所有的视图解析器都这样做，因为在某些情况下，解析器根本无法检测视图是否存在。例如，内部InternalResourceViewResolver使用RequestDispatcher，分派是确定JSP是否存在的唯一方法，但此操作只能执行一次。对于FreeMarkerViewResolver其他一些人也是如此。检查特定视图解析器的javadoc以查看是否报告不存在的视图。因此，把一个InternalResourceViewResolver在链中比在链中的最后结果的其他地方没有得到充分检验，因为 InternalResourceViewResolver意志总是返回一个视图！

如前所述，控制器通常返回逻辑视图名称，视图解析器解析为特定视图技术。对于视图技术如JSP，其通过servlet或JSP引擎处理，此分辨率通常是通过组合处理InternalResourceViewResolver和 InternalResourceView，它发出一个内部正向或包括经由在Servlet API的RequestDispatcher.forward(..)方法或RequestDispatcher.include()方法。对于其他视图技术，如FreeMarker，XSLT等，视图本身将内容直接写入响应流。

在呈现视图之前，有时需要将HTTP重定向发回客户端。这是可取的，例如，当一个控制器已经被调用了 POST数据时，并且响应实际上是对另一个控制器的委派（例如，成功的表单提交）。在这种情况下，正常的内部向前将意味着另一个控制器也将看到相同的POST数据，如果它可能与其他预期数据混淆，这是潜在的问题。在显示结果之前执行重定向的另一个原因是消除用户多次提交表单数据的可能性。在这种情况下，浏览器将首先发送一个初始的POST; 然后会收到重定向到其他URL的响应; GET最后浏览器将为重定向响应中指定的URL执行后续操作。因此，从浏览器的角度来看，当前页面并不反映的结果POST，而是一个GET。最终的效果是用户无法POST通过执行刷新来意外重新获得相同的数据。刷新强制GET结果页面a，而不是重新发送初始POST数据。

@PostMapping（“/ files / {path}”）
 public String upload（...）{
	 // 
	返回 “redirect：files / {path}” ;
}

这ContentNegotiatingViewResolver不会解析视图本身，而是委托给其他视图解析器，选择类似于客户端请求的表示的视图。客户端可以从服务器请求表示方式存在两种策略：

	Accept标题的一个问题是，不可能在HTML中的Web浏览器中设置它。例如，在Firefox中，它被修改为： 接受：text / html，application / xhtml + xml，application / xml; q = 0.9，* / *; q = 0.8 因此，在开发基于浏览器的Web应用程序时，通常会看到每个表示使用不同的URI。

为了支持资源的多个表示，Spring提供了 ContentNegotiatingViewResolver根据AcceptHTTP请求的文件扩展名或头部来解析视图。ContentNegotiatingViewResolver不执行视图分辨率本身，而是委托给您通过bean属性指定的视图解析器的列表ViewResolvers。

在ContentNegotiatingViewResolver选择一个合适的View通过比较与所述媒体类型（也被称为媒体请求类型（一个或多个），以处理该请求 Content-Type由支持）的View与每个其相关联ViewResolvers。View具有兼容性的列表中的第一个将表示Content-Type返回给客户端。如果链条不能提供兼容的视图，则会查看ViewResolver通过DefaultViews属性指定的视图列表。后一个选项适用于Views可以呈现当前资源的适当表示的单例，而不管逻辑视图名称如何。的Accept 报头可以包括通配符，例如text/*，在这种情况下View，其内容类型是text/xml为相容的匹配。

要支持基于文件扩展名的视图的自定义解析，请使用 ContentNegotiationManager：请参见第18.16.6节“内容协商”。

以下是一个示例配置ContentNegotiatingViewResolver：

<bean  class = “org.springframework.web.servlet.view.ContentNegotiatingViewResolver” > 
	<property  name = “viewResolvers” > 
		<list> 
			<bean  class = “org.springframework.web.servlet.view.BeanNameViewResolver” /> 
			<bean  class = “org.springframework.web.servlet.view.InternalResourceViewResolver” > 
				<property  name = “prefix”  value = “/ WEB-INF / jsp /” /> 
				<property  name = “suffix” value = “.jsp” /> 
			</ bean> 
		</ list> 
	</ property> 
	<property  name = “defaultViews” > 
		<list> 
			<bean  class = “org.springframework.web.servlet.view.json.MappingJackson2JsonView” /> 
		</ list> 
	</ property> 
</ bean>web.servlet.view.json.MappingJackson2JsonView“ /> </ list> </ property> </ bean>web.servlet.view.json.MappingJackson2JsonView“ /> </ list> </ property> </ bean>

<bean  id = “content”  class = “com.foo.samples.rest.SampleContentAtomView” />

该InternalResourceViewResolver手柄视图名称和JSP页面的翻译，而BeanNameViewResolver返回基于bean的名称的视图。（有关Spring如何查找和实例化视图的更多详细信息，请参阅“ 使用ViewResolver界面解析视图”。）在此示例中，该content bean是继承的类，该类AbstractAtomFeedView返回Atom RSS提要。有关创建Atom Feed表示的更多信息，请参阅Atom视图。

在上述配置中，如果使用扩展名进行请求.html，视图解析器将查找与text/html媒体类型匹配的视图。在 InternalResourceViewResolver提供了用于匹配视图text/html。如果请求是使用文件扩展名.atom，视图解析器将查找与application/atom+xml媒体类型相匹配的视图。该视图由该 BeanNameViewResolver映射提供给SampleContentAtomView如果返回的视图名称是content。如果使用文件扩展名进行请求.json，则无论视图名称如何， MappingJackson2JsonView将从DefaultViews列表中选择实例。或者，客户端请求可以在没有文件扩展名的情况下进行，但是将Accept标题设置为首选媒体类型，并且将发生对视图请求的相同解析。

	如果“ContentNegotiatingViewResolver”的ViewResolver列表未被明确配置，它会自动使用应用程序上下文中定义的任何ViewResolvers。

相应的控制器代码返回表单的URI http://localhost/content.atom或http://localhost/content应用Accept程序/ atom + xml 的头部的Atom RSS提要 如下所示。

@Controller
 public  class ContentController {

	private List <SampleContent> contentList = new ArrayList <SampleContent>（）;

	@GetMapping（“/ content”）
	 public ModelAndView getContent（）{
		ModelAndView mav = new ModelAndView（）;
		mav.setViewName（“content”）;
		mav.addObject（“sampleContentList”，contentList）;
		返回 mav
	}

}

Spring MVC还提供了一种构建控制器方法链接的机制。例如，给出：

@Controller 
@RequestMapping（“/ hotels / {hotel}”）
 public  class BookingController {

	@GetMapping（“/ bookings / {booking}”）
	 public String getBooking（ @PathVariable Long booking）{

	// ...
       }
}

您可以通过名称参考方法来准备链接：

UriComponents uriComponents = MvcUriComponentsBuilder
	.fromMethodName（BookingController 类，“getBooking” ，21）.buildAndExpand（42）;

URI uri = uriComponents.encode（）。toUri（）;

在上面的例子中，我们提供了实际的方法参数值，在这种情况下是长值21，用作路径变量并插入到URL中。此外，我们提供了值42，以填充任何剩余的URI变量，例如从类型级请求映射继承的“hotel”变量。如果该方法有更多的参数，您可以为URL不需要的参数提供null。一般而言@PathVariable，@RequestParam参数与构造URL相关。

还有其他的使用方法MvcUriComponentsBuilder。例如，您可以使用类似于通过代理模拟测试的技术，以避免通过名称引用控制器方法（示例假定静态导入MvcUriComponentsBuilder.on）：

UriComponents uriComponents = MvcUriComponentsBuilder
	.fromMethodCall（上（BookingController。类）.getBooking（21））buildAndExpand（42）;

URI uri = uriComponents.encode（）。toUri（）;

上面的例子使用静态方法MvcUriComponentsBuilder。在内部，他们依靠ServletUriComponentsBuilder从当前请求的方案，主机，端口，上下文路径和servlet路径准备基本URL。这在大多数情况下运行良好，但有时可能不足。例如，您可能不在请求的上下文中（例如，准备链接的批处理），或者您可能需要插入路径前缀（例如，从请求路径中删除并需要重新插入到链接中的区域设置前缀）。

对于这种情况，您可以使用接受a UriComponentsBuilder使用基本URL 的静态“fromXxx”重载方法 。或者您可以MvcUriComponentsBuilder 使用基本URL 创建一个实例，然后使用基于实例的“withXxx”方法。例如：

UriComponentsBuilder base = ServletUriComponentsBuilder.fromCurrentContextPath（）。path（“/ en”）;
MvcUriComponentsBuilder builder = MvcUriComponentsBuilder.relativeTo（base）;
builder.withMethodCall（上（BookingController。类）.getBooking（21））buildAndExpand（42）;

URI uri = uriComponents.encode（）。toUri（）;

您还可以从JSP，Thymeleaf，FreeMarker等视图中构建带注释控制器的链接。这可以使用fromMappingName方法，MvcUriComponentsBuilder 其中指的是按名称映射。

每个都会@RequestMapping根据类的大写字母和完整的方法名称分配一个默认名称。例如，getFoo类FooController 中的方法被分配名称“FC＃getFoo”。该策略可以通过创建一个实例HandlerMethodMappingNamingStrategy并将其插入到您中 来进行替换或定制RequestMappingHandlerMapping。默认策略实现也会查看name属性@RequestMapping，如果存在，则使用该属性。这意味着如果分配的默认映射名称与另一个冲突（例如重载方法），则可以在该目录上明确指定一个名称@RequestMapping。

	分配的请求映射名称在启动时记录在TRACE级别。

Spring JSP标签库提供了一个名为mvcUrl该函数的函数，可用于根据此机制准备到控制器方法的链接。

例如：

@RequestMapping（“/ people / {id} / addresses”）
 public  class PersonAddressController {

    @RequestMapping（“/ {country}”）
     public HttpEntity getAddress（ @PathVariable String country）{...}
}

您可以从JSP准备一个链接，如下所示：

％@ taglib uri =“http://www.springframework.org/tags”prefix =“s”％>
...
<a href="${s:mvcUrl('PAC#getAddress').arg(0,'US').buildAndExpand('123')}">获取地址</a>

上述示例依赖于mvcUrl在Spring标签库（即META-INF / spring.tld）中声明的JSP函数。对于更高级的案例（例如上一节所述的自定义基本URL），可以轻松地定义自己的函数或使用自定义标记文件，以便使用MvcUriComponentsBuilder具有自定义基本URL 的特定实例。

除了获取客户的区域设置之外，了解他们的时区通常也是有用的。该LocaleContextResolver界面提供了一个扩展LocaleResolver，允许解析器提供更丰富LocaleContext，可能包括时区信息。

如果可用，TimeZone可以使用该RequestContext.getTimeZone()方法获得 用户。时区信息将自动被Date / Time Converter和FormatterSpring注册的对象使用ConversionService。

该语言环境解析器检查accept-language客户端发送的请求中的标题（例如，Web浏览器）。通常此标题字段包含客户端操作系统的区域设置。请注意，此解析器不支持时区信息。

这个本地化解析器检查一个Cookie可能的客户端中，看是否有 Locale或TimeZone指定。如果是这样，它使用指定的细节。使用此语言环境解析器的属性，您可以指定cookie的名称以及最大的年龄。在下面找到一个定义a的例子CookieLocaleResolver。

<bean  id = “localeResolver”  class = “org.springframework.web.servlet.i18n.CookieLocaleResolver” >

	<property  name = “cookieName”  value = “clientlanguage” />

	<！ - 以秒为单位。如果设置为-1，则cookie不会持久化（在浏览器关闭时删除） - > 
	<property  name = “cookieMaxAge”  value = “100000” />

</豆>

在SessionLocaleResolver可以检索Locale并TimeZone从可能与用户的请求相关的会话。相反 CookieLocaleResolver，该策略将本地选择的区域设置存储在Servlet容器中HttpSession。因此，这些设置对于每个会话都是临时的，因此在每个会话终止时丢失。

请注意，与Spring Session项目之类的外部会话管理机制没有直接关系。这SessionLocaleResolver将简单地根据HttpSession当前值来评估和修改相应的属性HttpServletRequest。

您可以通过添加LocaleChangeInterceptor到其中一个处理程序映射来启用更改区域设置（请参见第18.4节“处理程序映射”）。它将检测请求中的一个参数并更改区域设置。它呼吁setLocale()在LocaleResolver上下文中也存在。以下示例显示，对包含*.view名为的参数的所有资源的调用siteLanguage现在将更改语言环境。因此，例如，对以下URL的请求http://www.sf.net/home.view?siteLanguage=nl将会将站点语言更改为荷兰语。

<bean  id = “localeChangeInterceptor” 
		class = “org.springframework.web.servlet.i18n.LocaleChangeInterceptor” > 
	<property  name = “paramName”  value = “siteLanguage” /> 
</ bean>

<bean  id = “localeResolver” 
		class = “org.springframework.web.servlet.i18n.CookieLocaleResolver” />

<bean  id = “urlMapping” 
		class = “org.springframework.web.servlet.handler.SimpleUrlHandlerMapping” > 
	<property  name = “interceptors” > 
		<list> 
			<ref  bean = “localeChangeInterceptor” /> 
		</ list> 
	</ property > 
	<property  name = “mappings” > 
		<value> /**/*.view=someController </ value> 
	</ property> 
</ bean>

您可以应用Spring Web MVC框架主题来设置应用程序的整体外观，从而增强用户体验。主题是影响应用程序视觉风格的静态资源（通常是样式表和图像）的集合。

要在Web应用程序中使用主题，您必须设置接口的 org.springframework.ui.context.ThemeSource实现。该WebApplicationContext 接口扩展ThemeSource，但其代表职责的专用实现。默认情况下，委托将是 org.springframework.ui.context.support.ResourceBundleThemeSource从类路径根目录加载属性文件的实现。要使用自定义ThemeSource 实现或配置基本名称前缀ResourceBundleThemeSource，可以在应用程序上下文中使用保留名称注册一个bean themeSource。Web应用程序上下文将自动检测具有该名称的bean并使用它。

使用时ResourceBundleThemeSource，在一个简单的属性文件中定义一个主题。属性文件列出构成主题的资源。这是一个例子：

=的styleSheet /主题/冷却/ style.css中
背景= /主题/冷却/ IMG / coolBg.jpg

属性的键是从视图代码引用主题元素的名称。对于JSP，您通常使用与spring:theme标记非常相似的自定义标签来执行此操作spring:message。以下JSP片段使用上一个示例中定义的主题来自定义外观：

<％@  taglib  prefix = “spring”  uri = “http://www.springframework.org/tags” ％> 
<html> 
	<head> 
		<link  rel = “stylesheet”  href = “<spring：theme code ='styleSheet '/>“  type = ”text / css“ /> 
	</ head> 
	<body  style = ”background = <spring：theme code ='background'/>“ >
		...
	</ body> 
</ html>

默认情况下，ResourceBundleThemeSource使用空的基本名称前缀。因此，属性文件从类路径的根目录加载。因此，您可以将 cool.properties主题定义放在类路径的根目录下，例如/WEB-INF/classes。它ResourceBundleThemeSource使用标准的Java资源包加载机制，允许主题的全面国际化。例如，我们可以有一个/WEB-INF/classes/cool_nl.properties引用一个特殊的背景图像与荷兰文本。

定义主题后，如上一节所述，您决定使用哪个主题。该 DispatcherServlet会寻找一个叫豆themeResolver，以找出 ThemeResolver使用实施。主题解析器的工作方式与a的方式大致相同 LocaleResolver。它检测到用于特定请求的主题，还可以更改请求的主题。以下主题解析器由Spring提供：

Spring还提供了一个ThemeChangeInterceptor允许使用简单请求参数对每个请求进行主题更改的功能。

Spring的内置多部分支持处理Web应用程序中的文件上传。您可以MultipartResolver使用org.springframework.web.multipart包中定义的可插入对象来 启用此multipart支持。Spring提供了一个MultipartResolver 用于Commons FileUpload的实现，另一个用于Servlet 3.0 multipart请求解析。

默认情况下，Spring没有多部门处理，因为一些开发人员想要自己处理多个部件。通过将多部分解析器添加到Web应用程序的上下文来启用Spring multipart处理。检查每个请求以查看它是否包含多部分。如果没有找到multipart，请求按预期方式继续。如果在请求中找到一个multipart，MultipartResolver则使用在上下文中声明的multipart 。之后，您的请求中的multipart属性被视为任何其他属性。

以下示例显示如何使用CommonsMultipartResolver：

<bean  id = “multipartResolver” 
		class = “org.springframework.web.multipart.commons.CommonsMultipartResolver” >

	<！ - 可用属性之一; 最大文件大小（以字节为单位） - > 
	<property  name = “maxUploadSize”  value = “100000” />

</豆>

当然，您还需要将适当的jar放在您的类路径中，以使多部分解析器工作。在这种情况下CommonsMultipartResolver，您需要使用 commons-fileupload.jar。

当Spring DispatcherServlet检测到多部分请求时，它会激活已经在上下文中声明的解析器，并交给请求。解析器然后将当前包装HttpServletRequest到MultipartHttpServletRequest支持多部分文件上传的内容中。使用它MultipartHttpServletRequest，您可以获取有关此请求所包含的多部分的信息，实际上可以在控制器中自己访问多部分文件。

为了使用的Servlet 3.0基于多解析，您需要标记 DispatcherServlet用"multipart-config"的部分web.xml，或用 javax.servlet.MultipartConfigElement在编程的Servlet注册，或在自定义Servlet类的情况下，可能与javax.servlet.annotation.MultipartConfig 你的Servlet类注解。需要在Servlet注册级别应用最大大小或存储位置等配置设置，因为Servlet 3.0不允许从MultipartResolver完成这些设置。

一旦使用上述方法之一启用了Servlet 3.0 multipart解析，您可以添加StandardServletMultipartResolver到Spring配置：

<bean  id = “multipartResolver” 
		class = “org.springframework.web.multipart.support.StandardServletMultipartResolver” > 
</ bean>

完成MultipartResolver工作后，请求像其他任何一样处理。首先，创建一个带有文件输入的表单，允许用户上传表单。编码属性（enctype="multipart/form-data"）允许浏览器知道如何将表单编码为多部分请求：

<html> 
	<head> 
		<title>上传文件请</ title> 
	</ head> 
	<body> 
		<h1>请上传文件</ h1> 
		<form  method = “post”  action = “/ form”  enctype = “multipart / form-data” > 
			<input  type = “text”  name = “name” /> 
			<input  type = “file”  name = “file” /> 
			<input  type = “submit”/> 
		</ form> 
	</ body> 
</ html>

下一步是创建一个处理文件上传的控制器。该控制器非常类似于正常注释@Controller，除了我们使用MultipartHttpServletRequest或MultipartFile在方法参数中：

@Controller
 public  class FileUploadController {

	@PostMapping（“/ form”）
	 public String handleFormUpload（ @RequestParam（“name”） String name，
			 @RequestParam（“file”） MultipartFile文件）{

		if（！file.isEmpty（））{
			 byte [] bytes = file.getBytes（）;
			//存储字节某处
			返回 “redirect：uploadSuccess” ;
		}

		返回 “redirect：uploadFailure” ;
	}

}

注意@RequestParam方法参数如何映射到表单中声明的​​输入元素。在这个例子中，没有什么是完成的byte[]，但实际上你可以将它保存在数据库中，将它存储在文件系统上，等等。

当使用Servlet 3.0多部分解析时，您也可以使用javax.servlet.http.Part方法参数：

@Controller
 public  class FileUploadController {

	@PostMapping（“/ form”）
	 public String handleFormUpload（ @RequestParam（“name”） String name，
			 @RequestParam（“file”）零件文件）{

		InputStream inputStream = file.getInputStream（）;
		//将上传文件的字节存储在某处

		返回 “redirect：uploadSuccess” ;
	}

}

也可以在RESTful服务方案中从非浏览器客户端提交多部分请求。所有上述示例和配置也适用于此。然而，与通常提交文件和简单表单字段的浏览器不同，编程客户端还可以发送特定内容类型的更复杂数据，例如具有文件的多部分请求，第二部分使用JSON格式的数据：

POST / someUrl
Content-Type：multipart / mixed

--edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp
内容处理：表单数据; NAME =“元数据”
Content-Type：application / json; 字符集= UTF-8
内容传输编码：8bit

{
	“名称”：“值”
}
--edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp
内容处理：表单数据; NAME =“文件的数据”; 文件名= “file.properties”
Content-Type：text / xml
内容传输编码：8bit
...文件数据...

您可以使用@RequestParam("meta-data") String metadatacontroller method参数访问名为“meta-data”的部分。但是，您可能更喜欢接受从请求部分正文中的JSON格式数据初始化的强类型对象，非常类似于@RequestBody在非帮助下将非多部分请求的正文转换为目标对象的方式HttpMessageConverter。

您可以使用@RequestPart注释而不是@RequestParam注释用于此目的。它允许您通过HttpMessageConverter考虑多部分的'Content-Type'标题来传递特定多部分的内容：

@PostMapping（“/ someUrl”）
 public String onSubmit（ @RequestPart（“meta-data”）MetaData元数据，
		@RequestPart（“file-data”）MultipartFile文件）{

	// ...

}

注意如何MultipartFile使用@RequestParam或 @RequestPart互换访问方法参数。但是，@RequestPart("meta-data") MetaData在这种情况下，该方法参数将被读取为基于其'Content-Type'头部的JSON内容，并在此帮助下进行转换MappingJackson2HttpMessageConverter。

Spring HandlerExceptionResolver实现处理控制器执行期间发生的意外异常。一个HandlerExceptionResolver有点象异常映射的，你可以在Web应用程序描述符定义web.xml。但是，它们提供了一种更灵活的方法。例如，它们提供有关在抛出异常时正在执行哪个处理程序的信息。此外，处理异常的编程方式可以在请求转发到另一个URL之前提供更多的响应选项（与使用Servlet特定的异常映射相同的最终结果）。

除了实现HandlerExceptionResolver接口，这只是一个实现resolveException(Exception, Handler)方法和返回的问题 ModelAndView，您还可以使用提供的SimpleMappingExceptionResolver或创建 @ExceptionHandler方法。将SimpleMappingExceptionResolver让您采取可能被抛出的异常的类名，并将它映射到视图名。这在功能上等同于Servlet API的异常映射功能，但也可以从不同的处理程序实现更精细的异常映射。@ExceptionHandler另一方面，注释可以用于应该调用来处理异常的方法。这样的方法可以定义在本地内部，@Controller或者可以在@Controller类中定义时应用于许多类 @ControllerAdvice。以下部分将对此进行更详细的解释。

HandlerExceptionResolver接口和SimpleMappingExceptionResolver 实现允许您在转发到这些视图之前将异常与声明性地映射到特定视图以及一些可选的Java逻辑。然而，在某些情况下，特别是在依赖于@ResponseBody方法而不是视图分辨率的情况下，直接设置响应的状态并可选地将错误内容写入响应主体可能会更为方便。

你可以用@ExceptionHandler方法来做到这一点。当在控制器内声明时，这种方法适用于由@RequestMapping该控制器（或其任何子类）的方法引发的异常。您也可以@ExceptionHandler在@ControllerAdvice类中声明一个方法， 在这种情况下，它可以处理@RequestMapping 来自多个控制器的方法的异常。下面是一个控制器局部@ExceptionHandler方法的例子 ：

@Controller
 public  class SimpleController {

	// @RequestMapping方法省略...

	@ExceptionHandler（IOException.class）
	 public ResponseEntity <String> handleIOException（IOException ex）{
		 // prepare responseEntity 
		return responseEntity;
	}

}

该@ExceptionHandler值可以设置为一个异常类型的数组。如果抛出与列表中的一个类型匹配的异常，@ExceptionHandler则将调用注释与匹配的方法。如果未设置注释值，则使用列为方法参数的异常类型。

与使用@RequestMapping注释注释的标准控制器方法非常相似，方法的方法参数和返回值@ExceptionHandler可以是灵活的。例如，HttpServletRequest可以在Servlet环境中访问。返回类型可以是一个String，它被解释为一个视图名称，一个ModelAndView对象，一个ResponseEntity或者你也可以添加@ResponseBody一个方法返回值转换为消息转换器并写入响应流。

Spring MVC可能会在处理请求时引发许多异常。根据需要， SimpleMappingExceptionResolver可以轻松地将任何异常映射到默认错误视图。但是，在使用以自动方式解释响应的客户端时，您将需要在响应中设置特定的状态代码。根据引发的异常，状态代码可能会指示客户端错误（4xx）或服务器错误（5xx）。

将DefaultHandlerExceptionResolverSpring MVC异常转换为特定的错误状态代码。它默认注册了MVC命名空间，MVC Java配置，还有DispatcherServlet（即不使用MVC命名空间或Java配置时）。下面列出了这个解析器处理的一些异常和相应的状态代码：

将DefaultHandlerExceptionResolver通过设置响应的状态透明地工作。但是，您的应用程序可能需要为每个错误响应添加开发人员友好的内容，例如提供REST API时，不会将任何错误内容写入响应正文。你可以准备一个ModelAndView 和渲染通过视图解析错误内容-通过配置，即ContentNegotiatingViewResolver，MappingJackson2JsonView，等等。但是，您可能更喜欢使用@ExceptionHandler方法。

如果您喜欢通过@ExceptionHandler方法编写错误内容，可以ResponseEntityExceptionHandler改为扩展 。这是提供处理标准Spring MVC异常和返回@ControllerAdvice的@ExceptionHandler方法的类的方便基础 ResponseEntity。这允许您自定义响应并使用消息转换器写入错误内容。有关ResponseEntityExceptionHandler详细信息，请参阅 javadocs。

一个@RestController可以使用@ExceptionHandler返回一个方法， ResponseEntity在响应的主体既提供响应状态和错误的详细信息。这些方法也可以被添加到@ControllerAdvice 用于子集或所有控制器的异常处理的类中。

一个常见的要求是在响应的正文中包含错误详细信息。Spring不会自动执行此操作（尽管Spring Boot），因为响应主体中的错误详细信息的表示是特定于应用程序的。

希望在响应体中实现具有错误详细信息的全局异常处理策略的应用程序应考虑扩展抽象基类ResponseEntityExceptionHandler，为Spring MVC引发的异常提供处理，并提供钩子来自定义响应体以及处理其他异常。只需将扩展类声明为一个Spring bean并用它进行注释@ControllerAdvice。有关详细信息，请参阅ResponseEntityExceptionHandler。

可以注释业务异常@ResponseStatus。当异常提出时，ResponseStatusExceptionResolver通过相应地设置响应的状态来处理它。默认情况下，DispatcherServlet寄存器 ResponseStatusExceptionResolver，它是可用。

当响应的状态设置为错误状态代码并且响应的正文为空时，Servlet容器通常会呈现HTML格式的错误页面。要自定义容器的默认错误页面，可以在其中声明一个<error-page> 元素web.xml。直到Servlet 3，该元素必须映射到特定的状态代码或异常类型。从Servlet 3开始，不需要映射错误页面，这意味着指定的位置定制了默认的Servlet容器错误页面。

<error-page> 
	<location> / error </ location> 
</ error-page>

请注意，错误页面的实际位置可以是容器中的JSP页面或其他一些URL，包括通过一种@Controller方法处理的页面：

编写错误信息时，HttpServletResponse可通过控制器中的请求属性访问状态码和设置的错误信息 ：

@Controller
 public  class ErrorController {

	@RequestMapping（path =“/ error”，produce = MediaType.APPLICATION_JSON_UTF8_VALUE）
	@ResponseBody
	 public Map <String，Object> handle（HttpServletRequest request）{

		Map <String，Object> map = new HashMap <String，Object>（）;
		map.put（“status”，request.getAttribute（“javax.servlet.error.status_code”））;
		map.put（“reason”，request.getAttribute（“javax.servlet.error.message”））;

		返回地图;
	}

}

或在JSP中：

<％@  page  contentType = “application / json”  pageEncoding = “UTF-8” ％> 
{ 
	status：<％ = request.getAttribute（“javax.servlet.error.status_code”） ％>，
	reason：<％ = request。 getAttribute（“javax.servlet.error.message”） ％> 
}

该ControllerClassNameHandlerMapping班是一个HandlerMapping使用惯例来确定请求的URL和之间的映射实现Controller 是要处理这些请求的情况。

考虑以下简单的Controller实现。特别注意 课程名称。

public  class  ViewShoppingCartController  implements Controller {

	public ModelAndView handleRequest（HttpServletRequest request，HttpServletResponse response）{
		 //实现对于这个例子来说不是很重要...
	}

}

以下是相应的Spring Web MVC配置文件的代码段：

<bean  class = “org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping” />

<bean  id = “ viewShoppingCart ”class =“xyzViewShoppingCartController”>
	 <！ - 根据需要注入依赖关系...  - > 
</ bean>

在ControllerClassNameHandlerMapping找出所有的处理程序（或 Controller在其应用上下文定义的）豆和剥离Controller掉，以限定其处理程序映射的名称。因此，ViewShoppingCartController映射到 /viewshoppingcart*请求URL。

我们再来看一些更多的例子，使中心思想变得熟悉。（注意URL中的全部小写，与骆驼Controller类的类名相反）。

在MultiActionController处理程序类的情况下，生成的映射稍微复杂一点。以下Controller示例中的名称被假定为实现MultiActionController：

如果你按照你的命名的惯例Controller实现的 xxxController，将ControllerClassNameHandlerMapping节省您定义和维护一个潜在的沉闷一长串SimpleUrlHandlerMapping（或类似的东西）。

本ControllerClassNameHandlerMapping类扩展AbstractHandlerMapping基类，所以你可以定义HandlerInterceptor实例和一切，就像你与许多其他HandlerMapping的实现。

该ModelMap班本质上是一种荣耀Map，可以使补充说，是要显示（或上）一个对象View坚持一个共同的命名约定。考虑以下Controller实现; 注意对象被添加到ModelAndView没有指定的任何关联的名称。

public  class DisplayShoppingCartController implements Controller {

	public ModelAndView handleRequest（HttpServletRequest request，HttpServletResponse response）{

		列表cartItems = //获取CartItem对象的列表 
		User user = //让用户进行购物

		ModelAndView mav = new ModelAndView（“displayShoppingCart”）; < - 逻辑视图名称

		mav.addObject（cartItems）; < - 看ma，没有名字，只是对象
		mav.addObject（用户）;  - 再次！

		返回 mav
	}
}

的ModelAndView类使用一个ModelMap类，它是一个自定义的Map，可自动生成用于当对象被添加到它的对象的键实现。在标量对象的情况下，用于确定添加对象的名称的策略是User使用对象类的短类名。以下示例是为放置到ModelMap实例中的标量对象生成的名称。

在添加一个Set或一个之后生成名称的策略List是窥视集合，获取集合中第一个对象的短类名称，并将其List附加到名称后面。这同样适用于数组，尽管数组不需要窥视数组内容。几个例子将使得集合名称生成的语义更加清晰：

该RequestToViewNameTranslator接口确定的逻辑View当没有这样的逻辑视图名称被明确地提供的名称。它只有一个实现，DefaultRequestToViewNameTranslator类。

该DefaultRequestToViewNameTranslator请求的URL映射到逻辑视图的名称，与该实施例中：

public  class RegistrationController implements Controller {

	public ModelAndView handleRequest（HttpServletRequest request，HttpServletResponse response）{
		 //处理请求... 
		ModelAndView mav = new ModelAndView（）;
		//根据需要添加数据到模型... 
		return mav;
		//注意没有设置View或逻辑视图名称
	}

}

<？xml version =“1.0”encoding =“UTF-8”？> 
<beans  xmlns = “http://www.springframework.org/schema/beans” 
	xmlns：xsi = “http://www.w3.org / 2001 / XMLSchema-instance“ 
	xsi：schemaLocation = ”
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd“ >

	<！ - 这个具有众所周知的名称的bean为我们生成视图名称 - > 
	<bean  id = “viewNameTranslator” 
			class = “org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator” />

	<bean  class = “xyRegistrationController” > 
		<！ - 根据需要注入依赖项 - > 
	</ bean>

	<！ - 将请求URL映射到控制器名称 - > 
	<bean  class = “org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping” />

	<bean  id = “viewResolver”  class = “org.springframework.web.servlet.view.InternalResourceViewResolver” > 
		<property  name = “prefix”  value = “/ WEB-INF / jsp /” /> 
		<property  name = “suffix”  value = “.jsp” /> 
	</ bean>

</豆>

注意在执行handleRequest(..)方法no View或逻辑视图名称是否被设置ModelAndView返回的。该 DefaultRequestToViewNameTranslator任务是 从请求的URL 生成逻辑视图名称。另外，在上述的情况下RegistrationController，这是在与结合使用ControllerClassNameHandlerMapping的一个请求的URLhttp://localhost/registration.html中的一个逻辑视图名称结果registration 被生成的DefaultRequestToViewNameTranslator。该逻辑视图名称然后/WEB-INF/jsp/registration.jsp由InternalResourceViewResolverbean 解析为视图 。

	您不需要明确定义一个DefaultRequestToViewNameTranslatorbean。如果您喜欢默认设置DefaultRequestToViewNameTranslator，可以依靠Spring Web MVC DispatcherServlet实例化此类的实例，如果未明确配置。

当然，如果您需要更改默认设置，那么您需要明确配置自己的DefaultRequestToViewNameTranslatorbean。有关可配置DefaultRequestToViewNameTranslator的各种属性的详细信息，请查阅全面的 javadocs。

Spring Web MVC支持许多用例和方式为应用程序配置“Cache-Control”标头。虽然RFC 7234第5.2.2节 完全描述了标题及其可能的指令，但是有几种方法可以解决最常见的情况。

Spring Web MVC在其几个API中使用配置约定 setCachePeriod(int seconds)：

该CacheControl生成器类简单地描述了可用的“缓存控制”指令，并使其更容易建立自己的HTTP缓存策略。一旦构建，一个CacheControl实例就可以被接受为几个Spring Web MVC API中的参数。

//缓存一小时 - “Cache-Control：max-age = 3600” 
   CacheControl ccCacheOneHour = CacheControl.maxAge（1，TimeUnit.HOURS）;

   //防止缓存 - “Cache-Control：no-store”
   CacheControl ccNoStore = CacheControl.noStore（）;

   //在公共和私有缓存中缓存十天，
   //公共缓存不应该转换响应
   //“Cache-Control：max-age = 864000，public，no-transform” 
   CacheControl ccCustom = CacheControl.maxAge（10，TimeUnit 。天）
   									。.noTransform（）cachePublic（）;

应使用适当的'Cache-Control'条件标题来提供静态资源，以获得最佳性能。 配置一个ResourceHttpRequestHandler用于提供静态资源的功能不仅'Last-Modified'通过读取文件的元数据来定位'Cache-Control'头文件，而且还可以正确配置头文件。

您可以设置cachePeriod属性ResourceHttpRequestHandler或使用CacheControl实例，该实例支持更具体的指令：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void addResourceHandlers（ResourceHandlerRegistry registry）{
		registry.addResourceHandler（“/ resources / **”）
				.addResourceLocations（“/ public-resources /”）
				.setCacheControl（CacheControl.maxAge（1，TimeUnit.HOURS）.cachePublic（））;
	}

}

在XML中：

<mvc：resources  mapping = “/ resources / **”  location = “/ public-resources /” > 
	<mvc：cache-control  max-age = “3600”  cache-public = “true” /> 
</ mvc：resources >

控制器可以支持'Cache-Control'，'ETag'和/或'If-Modified-Since'HTTP请求; 如果'Cache-Control'要在响应中设置标题，则建议这样做。这涉及计算long给定请求的lastModified 和/或Etag值，将其与'If-Modified-Since'请求头值进行比较，并可能返回具有状态代码304（未修改）的响应。

如“使用HttpEntity”一节所述，控制器可以使用HttpEntity类型与请求/响应进行交互 。返回的控制器ResponseEntity可以包括响应中的HTTP缓存信息，如下所示：

@GetMapping（“/ book / {id}”）
 public ResponseEntity <Book> showBook（ @PathVariable Long id）{

	Book book = findBook（id）;
	String version = book.getVersion（）;

	返回 ResponseEntity
				。好（）
				.cacheControl（CacheControl.maxAge（30，TimeUnit.DAYS））
				.eTag（version）// lastModified也可用
				。体（书）;
}

如果客户端发送的条件标头与控制器设置的缓存信息匹配，这样做将不仅包括响应中的头'ETag'和'Cache-Control'头，还会将响应转换HTTP 304 Not Modified为空体。

一种@RequestMapping方法也不妨支持相同的行为。这可以实现如下：

@RequestMapping
 public String myHandleMethod（WebRequest webRequest，Model model）{

	long lastModified = // 1.应用程序特定的计算

	if（request.checkNotModified（lastModified））{
		 // 2.快捷方式退出 - 无需进一步处理必需
		返回 null;
	}

	// 3.否则进一步请求处理，实际准备内容
	model.addAttribute（...）;
	返回 “myViewName” ;
}

这里有两个关键元素：呼叫request.checkNotModified(lastModified)和返回null。前者在返回之前设置适当的响应状态和标题true。后者与前者相结合，导致Spring MVC不再进一步处理请求。

请注意，有3种变体：

当接收到条件'GET'/ 'HEAD'请求时，checkNotModified将检查资源是否未被修改，如果是这样，它将导致HTTP 304 Not Modified 响应。在有条件的'POST'/ 'PUT'/ 'DELETE'请求的情况下，checkNotModified 将检查资源是否尚未被修改，如果已经被修改，它将导致 HTTP 409 Precondition Failed响应以防止并发修改。

支持ETag由Servlet过滤器提供ShallowEtagHeaderFilter。它是一个简单的Servlet过滤器，因此可以与任何Web框架结合使用。该 ShallowEtagHeaderFilter滤波器产生所谓的浅ETag的（相对于深的ETag，稍后详细说明）。该过滤器缓存呈现JSP（或其他内容）的内容，产生超过其MD5哈希，并返回作为ETag头在回应中。下一次客户端发送对同一资源的请求时，它将使用该哈希作为该If-None-Match值。过滤器检测到这一点，再次渲染视图，并比较两个散列。如果它们相等，304则返回a。

请注意，此策略可节省网络带宽但不节省CPU，因为必须为每个请求计算完整的响应。控制器级别的其他策略（如上所述）可以节省网络带宽并避免计算。

此过滤器具有一个writeWeakETag参数，可将过滤器配置为写入弱符号ETags，如RFC 7232第2.3节W/"02a2d595e6ed9a0b24f027f2b63b134d6"中所定义 。

您配置ShallowEtagHeaderFilter的web.xml：

<filter> 
	<filter-name> etagFilter </ filter-name> 
	<filter-class> org.springframework.web.filter.ShallowEtagHeaderFilter </ filter-class> 
	<！ - 配置过滤器写入弱ETag的可选参数
	<INIT-PARAM>
       	<PARAM名称> writeWeakETag </ PARAM名称>
       	<PARAM值>真</ PARAM值>
	</ INIT-param>
	- > 
</ filter>

<filter-mapping> 
	<filter-name> etagFilter </ filter-name> 
	<servlet-name> petclinic </ servlet-name> 
</ filter-mapping>

或者在Servlet 3.0+环境中，

public  class MyWebAppInitializer extends AbstractDispatcherServletInitializer {

	// ...

	@Override
	 protected Filter [] getServletFilters（）{
		 return  new Filter [] { new ShallowEtagHeaderFilter（）};
	}

}

有关详细信息，请参见第18.15节“基于代码的Servlet容器初始化”。

要启用MVC Java配置，请将注释添加@EnableWebMvc到您的一个 @Configuration类中：

@Configuration 
@EnableWebMvc
 public  class WebConfig {

}

要在XML中实现相同的使用mvc:annotation-drivenDispatcherServlet上下文中的元素（如果您没有定义DispatcherServlet上下文，则在根上下文中）：

<？xml version =“1.0”encoding =“UTF-8”？> 
<beans  xmlns = “http://www.springframework.org/schema/beans” 
	xmlns：mvc = “http://www.springframework.org / schema / mvc“ 
	xmlns：xsi = ”http://www.w3.org/2001/XMLSchema-instance“ 
	xsi：schemaLocation = ”
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/mvc
		http://www.springframework.org/schema/mvc/spring-mvc.xsd“ >

	<MVC：注释驱动/>

</豆>

在上述寄存器一RequestMappingHandlerMapping，一个RequestMappingHandlerAdapter，和ExceptionHandlerExceptionResolver在支持带注释控制器方法的处理请求（等等）使用注释诸如@RequestMapping， @ExceptionHandler和其他。

它还支持以下功能：

有关如何自定义这些默认转换器的更多信息，请参见第18.16.12节“消息转换器”。

使用ObjectMapper创建的实例创建 Jackson JSON和XML转换器Jackson2ObjectMapperBuilder ，以提供更好的默认配置。此构建器使用以下命令自定义Jackson的默认属性： DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES 被禁用。 MapperFeature.DEFAULT_VIEW_INCLUSION 被禁用。 如果在类路径中检测到它们，它也会自动注册以下众所周知的模块： jackson-datatype-jdk7：支持Java 7类型java.nio.file.Path。 jackson-datatype-joda：支持Joda-Time类型。 jackson-datatype-jsr310：支持Java 8 Date＆Time API类型。 jackson-datatype-jdk8：支持其他Java 8类型Optional。

要定制Java中的默认配置，您只需实现该 WebMvcConfigurer接口，或者更有可能扩展该类WebMvcConfigurerAdapter 并覆盖所需的方法：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	//覆盖配置方法...

}

要自定义默认配置，<mvc:annotation-driven/>检查它支持哪些属性和子元素。您可以查看 Spring MVC XML模式或使用IDE的代码完成功能来发现哪些属性和子元素可用。

默认情况下，已安装格式化程序Number和Date类型，包括对@NumberFormat和@DateTimeFormat注释的支持。如果Joda时间存在于类路径上，则还将完全支持Joda Time格式化库。要注册自定义格式化程序和转换器，请覆盖该addFormatters方法：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void addFormatters（FormatterRegistry registry）{
		 //添加格式化程序和/或转换器
	}

}

在MVC命名空间<mvc:annotation-driven>中，添加相同的默认值。注册自定义格式化器和转换器只需提供一个ConversionService：

<？xml version =“1.0”encoding =“UTF-8”？> 
<beans  xmlns = “http://www.springframework.org/schema/beans” 
	xmlns：mvc = “http://www.springframework.org / schema / mvc“ 
	xmlns：xsi = ”http://www.w3.org/2001/XMLSchema-instance“ 
	xsi：schemaLocation = ”
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/mvc
		http://www.springframework.org/schema/mvc/spring-mvc.xsd“ >

	<mvc：annotation-driven  conversion-service = “conversionService” />

	<豆 ID = “conversionService” 
			类 = “org.springframework.format.support.FormattingConversionServiceFactoryBean” > 
		<属性 名 = “转换器” > 
			<设定> 
				<豆 类 = “org.example.MyConverter” /> 
			</设定> 
		< / property> 
		<property  name = “formatters” > 
			<set> 
				<bean  class = “org.example.MyFormatter” /> 
				<bean  class = “org.example。MyAnnotationFormatterFactory“ /> 
			</ set> 
		</ property> 
		<property  name = ”formatterRegistrars“ > 
			<set> 
				<bean  class = ”org.example.MyFormatterRegistrar“ /> 
			</ set> 
		</ property> 
	</ bean>

</豆>

	参见5.6.4节，“FormatterRegistrar SPI”和FormattingConversionServiceFactoryBean 关于何时使用FormatterRegistrars更多的信息。

Spring提供了一个验证器接口，可用于在应用程序的所有层中进行验证。在Spring MVC中，您可以将其配置为用作全局Validator实例，以在遇到@Valid或@Validated控制器方法参数时使用，和/或Validator通过@InitBinder方法作为控制器中的本地 使用。可以组合全局和本地验证器实例以提供复合验证。

Spring还支持JSR-303 / JSR-349 Bean验证，通过LocalValidatorFactoryBean它可以将Spring org.springframework.validation.Validator 界面适应Bean验证javax.validation.Validator合同。这个类可以插入Spring MVC作为下面描述的全局验证器。

默认情况下，通过在类路径中检测到一个Bean验证提供程序（如Hibernate Validator）时，可以在Spring MVC中使用@EnableWebMvc或<mvc:annotation-driven>自动注册Bean验证支持LocalValidatorFactoryBean。

	有时，将LocalValidatorFactoryBean注入到控制器或其他类中是很方便的。最简单的方法是声明自己的@Bean，并且标记它，@Primary以避免与MVC Java配置提供的冲突。如果你喜欢使用MVC的Java的配置之一，你需要重写 mvcValidator的方法WebMvcConfigurationSupport，并声明明确回报的方法LocalValidatorFactory，而不是Validator。有关 如何切换扩展提供的配置的信息，请参见第18.16.13节“使用MVC Java Config进行高级定制”。

或者，您可以配置自己的全局Validator实例：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public Validator getValidator（）; {
		 //返回“全局”验证器
	}

}

和XML：

<？xml version =“1.0”encoding =“UTF-8”？> 
<beans  xmlns = “http://www.springframework.org/schema/beans” 
	xmlns：mvc = “http://www.springframework.org / schema / mvc“ 
	xmlns：xsi = ”http://www.w3.org/2001/XMLSchema-instance“ 
	xsi：schemaLocation = ”
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/mvc
		http://www.springframework.org/schema/mvc/spring-mvc.xsd“ >

	<mvc：annotation-driven  validator = “globalValidator” />

</豆>

要将全局和本地验证结合起来，只需添加一个或多个本地验证器：

@Controller
 public  class MyController {

	@InitBinder
	 protected  void initBinder（WebDataBinder binder）{
		binder.addValidators（new FooValidator（））;
	}

}

使用这个最小配置，任何时候遇到一个@Valid或@Validated方法参数，它将被配置的验证器验证。任何验证违规将自动BindingResult作为方法参数可访问的错误公开，并且也可以在Spring MVC HTML视图中呈现。

您可以配置HandlerInterceptors或WebRequestInterceptors应用于所有传入的请求或限制在特定的URL路径模式。

在Java中注册拦截器的示例：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void addInterceptors（InterceptorRegistry registry）{
		registry.addInterceptor（new LocaleInterceptor（））;
		registry.addInterceptor（new ThemeInterceptor（））。addPathPatterns（“/ **”）.excludePathPatterns（“/ admin / **”）;
		registry.addInterceptor（new SecurityInterceptor（））。addPathPatterns（“/ secure / *”）;
	}

}

而在XML中使用<mvc:interceptors>元素：

<mvc：interceptors> 
	<bean  class = “org.springframework.web.servlet.i18n.LocaleChangeInterceptor” /> 
	<mvc：interceptor> 
		<mvc：mapping  path = “/ **” /> 
		<mvc：exclude-mapping  path = “/ admin / **” /> 
		<bean  class = “org.springframework.web.servlet.theme.ThemeChangeInterceptor” /> 
	</ mvc：interceptor> 
	<mvc：interceptor> 
		<mvc：mapping  path = “/ secure / “ /> 
		<bean  class = ”org.example.SecurityInterceptor“/> 
	</ mvc：interceptor> 
</ mvc：interceptors>

You can configure how Spring MVC determines the requested media types from the request. The available options are to check the URL path for a file extension, check the “Accept” header, a specific query parameter, or to fall back on a default content type when nothing is requested. By default the path extension in the request URI is checked first and the “Accept” header is checked second.

The MVC Java config and the MVC namespace register json, xml, rss, atom by default if corresponding dependencies are on the classpath. Additional path extension-to-media type mappings may also be registered explicitly and that also has the effect of whitelisting them as safe extensions for the purpose of RFD attack detection (see the section called “Suffix Pattern Matching and RFD” for more detail).

Below is an example of customizing content negotiation options through the MVC Java config:

@Configuration
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
		configurer.mediaType("json", MediaType.APPLICATION_JSON);
	}
}

In the MVC namespace, the <mvc:annotation-driven> element has a content-negotiation-manager attribute, which expects a ContentNegotiationManagerthat in turn can be created with a ContentNegotiationManagerFactoryBean:

<mvc:annotation-driven content-negotiation-manager="contentNegotiationManager"/>

<bean id="contentNegotiationManager" class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
	<property name="mediaTypes">
		<value>
			json=application/json
			xml=application/xml
		</value>
	</property>
</bean>

If not using the MVC Java config or the MVC namespace, you’ll need to create an instance of ContentNegotiationManager and use it to configure RequestMappingHandlerMapping for request mapping purposes, and RequestMappingHandlerAdapter and ExceptionHandlerExceptionResolver for content negotiation purposes.

Note that ContentNegotiatingViewResolver now can also be configured with a ContentNegotiationManager, so you can use one shared instance throughout Spring MVC.

In more advanced cases, it may be useful to configure multiple ContentNegotiationManager instances that in turn may contain customContentNegotiationStrategy implementations. For example you could configure ExceptionHandlerExceptionResolver with a ContentNegotiationManagerthat always resolves the requested media type to "application/json". Or you may want to plug a custom strategy that has some logic to select a default content type (e.g. either XML or JSON) if no content types were requested.

This is a shortcut for defining a ParameterizableViewController that immediately forwards to a view when invoked. Use it in static cases when there is no Java controller logic to execute before the view generates the response.

An example of forwarding a request for "/" to a view called "home" in Java:

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void addViewController（ViewControllerRegistry registry）{
		registry.addViewController（“/”）.setViewName（“home”）;
	}

}

而且在XML中使用相同的<mvc:view-controller>元素：

<mvc：view-controller  path = “/”  view-name = “home” />

MVC配置简化了视图解析器的注册。

以下是一个Java配置示例，它使用FreeMarker HTML模板配置内容协商视图分辨率，并将Jackson作为ViewJSON渲染的默认值：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void configureViewResolvers（ViewResolverRegistry registry）{
		registry.enableContentNegotiation（new MappingJackson2JsonView（））;
		registry.jsp（）;
	}

}

和XML一样：

<mvc：view-resolvers> 
	<mvc：content-negotiation> 
		<mvc：default-views> 
			<bean  class = “org.springframework.web.servlet.view.json.MappingJackson2JsonView” /> 
		</ mvc：default-views> 
	</ mvc：content-negotiation> 
	<mvc：jsp /> 
</ mvc：view-resolvers>

不过请注意，FreeMarker，Tiles，Groovy Markup和脚本模板也需要配置底层视图技术。

MVC命名空间提供专用元素。例如与FreeMarker：

<mvc：view-resolvers> 
	<mvc：content-negotiation> 
		<mvc：default-views> 
			<bean  class = “org.springframework.web.servlet.view.json.MappingJackson2JsonView” /> 
		</ mvc：default-views> 
	</ mvc：content-negotiation> 
	<mvc：freemarker  cache = “false” /> 
</ mvc：view-resolvers>

<mvc：freemarker-configurer> 
	<mvc：template-loader-path  location = “/ freemarker” /> 
</ mvc：freemarker-configurer>

在Java配置中，只需添加相应的“Configurer”bean：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void configureViewResolvers（ViewResolverRegistry registry）{
		registry.enableContentNegotiation（new MappingJackson2JsonView（））;
		。registry.freeMarker（）高速缓存（假）;
	}

	@Bean
	 public FreeMarkerConfigurer freeMarkerConfigurer（）{
		FreeMarkerConfigurer configurer = new FreeMarkerConfigurer（）;
		configurer.setTemplateLoaderPath（“/ WEB-INF /”）;
		return configurer;
	}

}

此选项允许在特定URL模式之后的静态资源请求由位置ResourceHttpRequestHandler列表中的任何一个Resource提供。这提供了一种方便的方式来从除Web应用程序根以外的位置（包括类路径上的位置）提供静态资源。该cache-period属性可用于设置远期未来的到期标头（1年是优化工具的推荐，如Page Speed和YSlow），以便客户端更有效地利用它们。处理程序也正确地评估Last-Modified标题（如果存在），以便适当地304返回状态代码，避免客户端已经缓存的资源的不必要的开销。例如，/resources/**public-resources

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void addResourceHandlers（ResourceHandlerRegistry registry）{
		registry.addResourceHandler（“/ resources / **”）.addResourceLocations（“/ public-resources /”）;
	}

}

和XML一样：

<mvc：resources  mapping = “/ resources / **”  location = “/ public-resources /” />

为了在未来1年的时间内为这些资源提供服务，以确保最大限度地利用浏览器缓存并减少浏览器发出的HTTP请求：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void addResourceHandlers（ResourceHandlerRegistry registry）{
		registry.addResourceHandler（“/资源/ **”）.addResourceLocations（“/公共资源/”）.setCachePeriod（31556926）;
	}

}

在XML中：

<mvc：resources  mapping = “/ resources / **”  location = “/ public-resources /”  cache-period = “31556926” />

有关详细信息，请参阅静态资源的HTTP缓存支持。

该mapping属性必须是可以被使用的蚂蚁图案 SimpleUrlHandlerMapping，并且location属性必须指定一个或多个有效的资源目录位置。可以使用逗号分隔的值列表来指定多个资源位置。指定的位置将按照指定的顺序检查是否存在任何给定请求的资源。例如，要启用来自Web应用程序根目录和类路径/META-INF/public-web-resources/中任何jar中已知路径 的资源的使用，请执行以下操作：

@EnableWebMvc 
@Configuration
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void addResourceHandlers（ResourceHandlerRegistry registry）{
		registry.addResourceHandler（“/ resources / **”）
				.addResourceLocations（“/”，“classpath：/ META-INF / public-web-resources /”）;
	}

}

在XML中：

<mvc：resources  mapping = “/ resources / **”  location = “/，classpath：/ META-INF / public-web-resources /” />

当部署新版本的应用程序时可能会更改的资源时，建议您将版本字符串合并到用于请求资源的映射模式中，以便您可以强制客户端请求新部署的应用程序资源版本。版本化URL的支持内置在框架中，可以通过在资源处理程序上配置资源链来启用。该链由ResourceResolver 一个或多个ResourceTransformer实例之后的一个实例组成。他们一起可以提供任意解决和资源转型。

内置VersionResourceResolver可配置不同的策略。例如，FixedVersionStrategy可以使用属性，日期或其他作为版本。A ContentVersionStrategy使用从资源的内容计算的MD5哈希（称为“指纹识别”URL）。请注意，VersionResourceResolver在服务资源时，会自动将解析的版本字符串用作HTTP ETag标头值。

ContentVersionStrategy是一个很好的默认选择，除非不能使用（例如使用JavaScript模块加载器）的情况。您可以针对不同的模式配置不同的版本策略，如下所示。请记住，计算基于内容的版本是昂贵的，因此在生产中应该启用资源链缓存。

Java配置示例

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void addResourceHandlers（ResourceHandlerRegistry registry）{
		registry.addResourceHandler（“/ resources / **”）
				.addResourceLocations（“/ public-resources /”）
				.resourceChain（真）.addResolver（
					new VersionResourceResolver（）。addContentVersionStrategy（“/ **”））;
	}

}

XML示例：

<MVC：资源 映射 = “/资源/ **”  位置 = “/公共资源/” > 
	<MVC：资源链> 
		<MVC：资源高速缓存/> 
		<MVC：解析器> 
			<MVC：版本-解析器> 
				<mvc：content-version-strategy  patterns = “/ **” /> 
			</ mvc：version-resolver> 
		</ mvc：resolvers> 
	</ mvc：resource-chain> 
</ mvc：resources>

为了使上述工作，应用程序还必须使用版本来呈现URL。最简单的方法是配置 ResourceUrlEncodingFilter其中包含响应并覆盖其encodeURL方法。这将在JSP，FreeMarker以及调用响应encodeURL方法的任何其他视图技术中起作用 。或者，应用程序还可以直接注入和使用 ResourceUrlProviderbean，该bean将自动使用MVC Java配置和MVC命名空间声明。

还支持Webjars WebJarsResourceResolver，当"org.webjars:webjars-locator"库位于类路径时，Webjars会自动注册。该解析器允许资源链从HTTP GET请求中解析版本不可知库 "GET /jquery/jquery.min.js"将返回资源"/jquery/1.2.0/jquery.min.js"。它也可以通过在模板中重写资源URL来实现<script src="/jquery/jquery.min.js"/> → <script src="/jquery/1.2.0/jquery.min.js"/>。

这允许映射DispatcherServlet到“/”（从而覆盖容器的默认Servlet的映射），同时仍允许静态资源请求由容器的默认Servlet处理。它DefaultServletHttpRequestHandler使用“/ **”的URL映射和相对于其他URL映射的最低优先级来配置。

该处理程序将所有请求转发到默认Servlet。因此，重要的是按照所有其他URL的顺序保持最后HandlerMappings。如果您使用<mvc:annotation-driven>或者如果您正在设置自己的自定义HandlerMapping实例，请确保将其order属性设置为低于该值的值DefaultServletHttpRequestHandler，否则将是这种情况Integer.MAX_VALUE。

要使用默认设置启用该功能，请使用：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void configureDefaultServletHandling（DefaultServletHandlerConfigurer configurer）{
		configurer.enable（）;
	}

}

或在XML中：

<MVC：默认servlet的处理程序/>

覆盖“/”Servlet映射的注意事项是，RequestDispatcher默认的Servlet必须通过名称而不是路径检索。该 DefaultServletHttpRequestHandler会尝试自动检测在启动时容器中的默认的Servlet，使用大多数主要的Servlet容器（包括软件Tomcat，Jetty的GlassFish，JBoss和树脂中，WebLogic和WebSphere）已知名称的列表。如果默认的Servlet已经使用不同的名称自定义配置，或者如果使用了默认Servlet名称未知的其他Servlet容器，那么必须明确地提供默认的Servlet名称，如下例所示：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void configureDefaultServletHandling（DefaultServletHandlerConfigurer configurer）{
		configurer.enable（“myCustomDefaultServlet”）;
	}

}

或在XML中：

<mvc：default-servlet-handler  default-servlet-name = “myCustomDefaultServlet” />

这允许自定义与URL映射和路径匹配相关的各种设置。有关各个选项的详细信息，请查看 PathMatchConfigurer API。

以下是Java配置中的一个示例：

@Configuration 
@EnableWebMvc
 public  class WebConfig extends WebMvcConfigurerAdapter {

	@Override
	 public  void configurePathMatch（PathMatchConfigurer configurer）{
		配置者
		    .setUseSuffixPatternMatch（真）
		    .setUseTrailingSlashMatch（假）
		    .setUseRegisteredSuffixPatternMatch（真）
		    .setPathMatcher（antPathMatcher（））
		    .setUrlPathHelper（urlPathHelper（））;
	}

	@Bean
	 public UrlPathHelper urlPathHelper（）{
	     // ...
	}

	@Bean
	 public PathMatcher antPathMatcher（）{
	     // ...
	}

}

和XML一样，使用<mvc:path-matching>元素：

<mvc:annotation-driven>
    <mvc:path-matching
        suffix-pattern="true"
        trailing-slash="false"
        registered-suffixes-only="true"
        path-helper="pathHelper"
        path-matcher="pathMatcher"/>
</mvc:annotation-driven>

<bean id="pathHelper" class="org.example.app.MyPathHelper"/>
<bean id="pathMatcher" class="org.example.app.MyPathMatcher"/>

如果要替换由Spring MVC创建的默认转换器，或者 如果您只想自定义它们或将额外的转换器添加到默认转换器，HttpMessageConverter则可以通过重写Java配置来实现 定制。configureMessageConverters()extendMessageConverters()

以下是使用自定义ObjectMapper而不是默认值添加Jackson JSON和XML转换器的示例 ：

@Configuration
@EnableWebMvc
public class WebConfiguration extends WebMvcConfigurerAdapter {

	@Override
	public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
		Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder()
				.indentOutput(true)
				.dateFormat(new SimpleDateFormat("yyyy-MM-dd"))
				.modulesToInstall(new ParameterNamesModule());
		converters.add(new MappingJackson2HttpMessageConverter(builder.build()));
		converters.add(new MappingJackson2XmlHttpMessageConverter(builder.xml().build()));
	}在此示例中，Jackson2ObjectMapperBuilder用于为两者创建通用配置，MappingJackson2HttpMessageConverter并MappingJackson2XmlHttpMessageConverter启用缩进，自定义日期格式以及 jackson-module-parameter-name的注册 ，以增加对访问参数名称的支持（Java 8中添加的功能）。ngJackson2XmlHttpMessageConverter with indentation enabled, a customized date format and the registration of jackson-module-parameter-names that adds support for accessing parameter names (feature added in Java 8).

	使用Jackson XML支持启用缩进功能需要 woodstox-core-asl 除依赖之外jackson-dataformat-xml。

其他有趣的杰克逊模块可用：

也可以在XML中执行相同的操作：

<mvc：annotation-driven> 
    <mvc：message-converters> 
        <bean  class = “org.springframework.http.converter.json.MappingJackson2HttpMessageConverter” > 
            <property  name = “objectMapper”  ref = “objectMapper” /> 
        </ bean> 
        <bean  class = “org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter” > 
            <property  name = “objectMapper”  ref = “xmlMapper” /> 
        </ bean> 
    </ mvc：message-converters> 
</ mvc：注解驱动>

<bean  id = “objectMapper”  class = “org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean” 
      p：indentOutput = “true” 
      p：simpleDateFormat = “yyyy-MM-dd” 
      p：modulesToInstall = “com.fasterxml.jackson .module.paramnames.ParameterNamesModule“ />

<bean  id = “xmlMapper”  parent = “objectMapper”  p：createXmlMapper = “true” />

从上述示例可以看出，MVC Java配置和MVC命名空间提供了不需要深入了解为您创建的基础bean的更高级别的构造。相反，它可以帮助您专注于您的应用程序需求。但是，在某些时候，您可能需要更细致的控制，或者您可能只想了解底层配置。

更精细控制的第一步是查看为您创建的基础bean。在MVC Java配置中，您可以看到javadoc和其中的@Bean方法 WebMvcConfigurationSupport。此类中的配置通过注释自动导入@EnableWebMvc。其实如果你打开@EnableWebMvc你可以看到@Import声明。

更精细控制的下一步是定制一个在其中创建的bean之一WebMvcConfigurationSupport或可能提供您自己的实例的属性。这需要两件事情 – 删除@EnableWebMvc注释，以防止导入，然后从DelegatingWebMvcConfiguration一个子类 扩展WebMvcConfigurationSupport。这是一个例子：

@Configuration
 public  class WebConfig extends DelegatingWebMvcConfiguration {

	@Override
	 public  void addInterceptors（InterceptorRegistry registry）{
		 // ...
	}

	@Override 
	@Bean
	 public RequestMappingHandlerAdapter requestMappingHandlerAdapter（）{
		 //创建或让“超级”创建适配器
		//然后自定义其属性之一
	}

}

	应用程序应该只有一个配置扩展DelegatingWebMvcConfiguration 或单个@EnableWebMvc注释类，因为它们都注册了相同的底层bean。以这种方式修改bean不会阻止您使用本节前面显示的任何更高级别的构造。WebMvcConfigurerAdapter子类和 WebMvcConfigurer实现仍在使用中。

对您创建的配置的细粒度控制对于MVC命名空间来说有点困难。

如果您确实需要这样做，而不是复制其提供的配置，请考虑配置一个BeanPostProcessor检测要按类型自定义的bean，然后根据需要修改其属性。例如：

@Component
 public  class MyPostProcessor实现 BeanPostProcessor {

	public Object postProcessBeforeInitialization（Object bean，String name）throws BeansException {
		 if（Bean instanceof RequestMappingHandlerAdapter）{
			 //修改适配器的属性
		}
	}

}

请注意，MyPostProcessor需要将其包含在其中<component scan/>以便检测到它，或者如果您喜欢，可以使用XML bean声明明确声明它。