某些时候，控制器需要在运行时 AOP 代理修饰一番。

In some cases a controller may need to be decorated with an AOP proxy at runtime. One example is if you choose to have @Transactional annotations directly on the controller. When this is the case, for controllers specifically, we recommend using class-based proxying. This is typically the default choice with controllers. However if a controller must implement an interface that is not a Spring Context callback (e.g. InitializingBean, *Aware, etc), you may need to explicitly configure class-based proxying. For example with <tx:annotation-driven />, change to <tx:annotation-driven proxy-target-class="true" />.

Spring 3.1 introduced a new set of support classes for @RequestMapping methods called RequestMappingHandlerMapping and RequestMappingHandlerAdapter respectively. They are recommended for use and even required to take advantage of new features in Spring MVC 3.1 and going forward. The new support classes are enabled by default by the MVC namespace and the MVC Java config but must be configured explicitly if using neither. This section describes a few important differences between the old and the new support classes.

Prior to Spring 3.1, type and method-level request mappings were examined in two separate stages — a controller was selected first by the DefaultAnnotationHandlerMapping and the actual method to invoke was narrowed down second by the AnnotationMethodHandlerAdapter.

With the new support classes in Spring 3.1, the RequestMappingHandlerMapping is the only place where a decision is made about which method should process the request. Think of controller methods as a collection of unique endpoints with mappings for each method derived from type and method-level @RequestMapping information.

This enables some new possibilities. For once a HandlerInterceptor or a HandlerExceptionResolver can now expect the Object-based handler to be a HandlerMethod, which allows them to examine the exact method, its parameters and associated annotations. The processing for a URL no longer needs to be split across different controllers.

There are also several things no longer possible:

The above features are still supported with the existing support classes. However to take advantage of new Spring MVC 3.1 features you’ll need to use the new support classes.

URI 模版能便捷访问 @RequestMapping 方法中 URL 的某些部分。

URI 模版是一个类似于 URI 的字符串，其中包含了一个或多个变量。当你将这些变量替换掉市，就变回了 URI。 URI 模版格式 proposed RFC 定义了如何参数化 URI。比如，URI 模版 http://www.example.com/users/{userId}，包含了变量 userId，设置此变量为 __fred，就会变成http://www.example.com/users/fred。

可在方法入参上使用注解 @PathVariable 绑定 URI 的模版参数：

@RequestMapping(value="/owners/{ownerId}", method=RequestMethod.GET)
public String findOwner(@PathVariable String ownerId, Model model) {
    Owner owner = ownerService.findOwner(ownerId);
    model.addAttribute("owner", owner);
    return "displayOwner";
}

URI 模版 " /owners/{ownerId}" 指定了参数 owernId。当控制器处理这个请求时，会将 URI 中匹配的部分赋值给 owernId 变量。如，当传入 /owners/fred 请求时，owernId 的值就是 fred。

[提示]

@RequestMapping(value="/owners/{ownerId}", method=RequestMethod.GET)
public String findOwner(@PathVariable("ownerId") String theOwner, Model model) {
    // implementation omitted
}

@RequestMapping(value="/owners/{ownerId}", method=RequestMethod.GET)
public String findOwner(@PathVariable String ownerId, Model model) {
    // implementation omitted
}

一个方法可以有任意个 @PathVariable 注解。

@RequestMapping(value="/owners/{ownerId}/pets/{petId}", method=RequestMethod.GET)
public String findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
    Owner owner = ownerService.findOwner(ownerId);
    Pet pet = owner.getPet(petId);
    model.addAttribute("pet", pet);
    return "displayPet";
}

当在 Map<String, String> 参数使用 @PathVariable 注解时，map 会填充所有 URI 模版变量。

URI 模版可以组合类型和参数路径的 @RequestMapping。因此，findPet 可以处理类似 /owners/42/pets/21 的URI 。

@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {

    @RequestMapping("/pets/{petId}")
    public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
        // implementation omitted
    }

}

@PathVariable 参数可以是任意的简单类型（如 int，long，Date 等），Spring 会自动将其进行类型转换，转换出错会抛出 TypeMismatchException。你可以注册支持解析其他数据类型，详情请看 the section called “方法参数和类型转换” 和 the section called “自定义 WebDataBinder 的初始化”.

偶尔，在URI 模版变量里，你会需要用到更加精确的控制。比如 "/spring-web/spring-web-3.0.5.jar" 这样的URI，该如何拆分成多个部分？

@RequestMapping 注解支持在 URI 模版变量里使用正则表达式。语法 {变量名:正则表达式}，第一个部分定义变量的名称，第二部分是正则表达式。如

@RequestMapping("/spring-web/{symbolicName:[a-z-]}-{version:\\d\\.\\d\\.\\d}{extension:\\.[a-z]}")
    public void handle(@PathVariable String version, @PathVariable String extension) {
        // ...
    }
}

@RequestMapping 注解处理支持 URI 模版，也支持使用 Ant 风格模式(如：/myPath/*.do)。同时支持组合使用 URI 模版和 Ant 风格模式（如：e.g. `/owners/*/pets/{petId}）。

当一个 URL 与多个模式匹配时，会设法找出最具体的那一个路径。

当模式中的 URI 模版变量和通配符的数量相对较少，会认为其相对具体。如：/hotels/{hotel}/* 相对 /hotels/{hotel}/** 更加合适，因为 /hotels/{hotel}/* 只有一个URI 模版变量和一个通配符，而 hotels/{hotel}/**` 有一个 URI 模版变量和两个通配符。

当两个模式中的 URI 模版变量和通配符数量相同时，更详细的那一个会认为相对适合。如 /foo/bar* 比 /foo/* 更为详细。

当两个模式中变量个数详细程度相同时，使用更少通配符的那一个会相对具体。如 /hotels/{hotel} 比 /hotels/{hotel} 更加具体。

一些额外的特别规定：

For the full details see AntPatternComparator in AntPathMatcher. Note that the PathMatcher can be customized (see Section 16.16.9, “Path Matching” in the section on configuring Spring MVC).

全部细节信息可查看 AntPathMatcher 的 AntPatternComparator。注意，PathMatcher 是可以自定义的。（可查看 Section 16.16.9, “Path Matching” 的 Spring MVC 配置）

在 @RequestMapping 注解中，模式支持使用占位符来代替本地属性 和/或者 系统属性和环境变量。当路径需要通过配置文件来自定义时，适合使用占位符。占位符的详细信息，可以查看 PropertyPlaceholderConfigurer 的 javadoc。

Spring MVC 默认自动执行 ".*" 的后缀匹配，所以当一个控制器匹配 /person 时，其也隐式匹配 /person.*。这样的设计允许通过文件扩展名来说明内容的类型名比如 /person.pdf, /person.xml 等。然而，这里会有一个常犯的陷阱，当路径最后的片段是 URI 模版变量时（如 /person/{id}），请求 /person/1.json 可以正确匹配路径,变量 id=1，拓展名为 json，可当 id 自身包含 . (如 /person/joe@email.com)，那匹配结果就不是我们所期望的，显然 ".com" 不是文件扩展名。

解决这个问题的正确方法是配置 Spring MVC 只对注册的文件扩展名做后缀匹配，这要求内容(扩展名)协商好。想做更多的了解，可以先看 Section 16.16.4, “Content Negotiation” 后看 Section 16.16.9, “Path Matching”，这里展示里如何启用后缀模式和如何只使用注册的后缀模式。

The URI specification RFC 3986 defines the possibility of including name-value pairs within path segments. There is no specific term used in the spec. The general "URI path parameters" could be applied although the more unique "Matrix URIs", originating from an old post by Tim Berners-Lee, is also frequently used and fairly well known. Within Spring MVC these are referred to as matrix variables.

Matrix variables can appear in any path segment, each matrix variable separated with a ";" (semicolon). For example: "/cars;color=red;year=2012". Multiple values may be either "," (comma) separated "color=red,green,blue" or the variable name may be repeated "color=red;color=green;color=blue".

If a URL is expected to contain matrix variables, the request mapping pattern must represent them with a URI template. This ensures the request can be matched correctly regardless of whether matrix variables are present or not and in what order they are provided.

Below is an example of extracting the matrix variable "q":

// GET /pets/42;q=11;r=22

@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET)
public void findPet(@PathVariable String petId, @MatrixVariable int q) {

    // petId == 42
    // q == 11

}

Since all path segments may contain matrix variables, in some cases you need to be more specific to identify where the variable is expected to be:

// GET /owners/42;q=11/pets/21;q=22

@RequestMapping(value = "/owners/{ownerId}/pets/{petId}", method = RequestMethod.GET)
public void findPet(
        @MatrixVariable(value="q", pathVar="ownerId") int q1,
        @MatrixVariable(value="q", pathVar="petId") int q2) {

    // q1 == 11
    // q2 == 22

}

A matrix variable may be defined as optional and a default value specified:

// GET /pets/42

@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET)
public void findPet(@MatrixVariable(required=false, defaultValue="1") int q) {

    // q == 1

}

All matrix variables may be obtained in a Map:

// GET /owners/42;q=11;r=12/pets/21;q=22;s=23

@RequestMapping(value = "/owners/{ownerId}/pets/{petId}", method = RequestMethod.GET)
public void findPet(
        @MatrixVariable Map<String, String> matrixVars,
        @MatrixVariable(pathVar="petId"") Map<String, String> petMatrixVars) {

    // matrixVars: ["q" : [11,22], "r" : 12, "s" : 23]
    // petMatrixVars: ["q" : 11, "s" : 23]

}

Note that to enable the use of matrix variables, you must set the removeSemicolonContent property of RequestMappingHandlerMapping to false. By default it is set to true.

Tip

The MVC Java config and the MVC namespace both provide options for enabling the use of matrix variables. If you are using Java config, The Advanced Customizations with MVC Java Config section describes how the RequestMappingHandlerMapping can be customized. In the MVC namespace, the <mvc:annotation-driven> element has an enable-matrix-variables attribute that should be set to true. By default it is set to false. <?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 enable-matrix-variables="true"/> </beans>

你可以指定一系列可消费的媒体类型来压缩主要映射。这样只用当 Content-Type 请求头匹配可消费的媒体类型，才认为这个请求是可映射的。如：

@Controller
@RequestMapping(value = "/pets", method = RequestMethod.POST, consumes="application/json")
public void addPet(@RequestBody Pet pet, Model model) {
    // 实现省略
}

Consumable media type expressions can also be negated as in !text/plain to match to all requests other than those with Content-Type of text/plain.

	Tip
	consumes 条件支持在类和方法上使用。与大多数情况不一样的是，方法中 consumes 会覆盖类上使用 的consumes，而不是继承 类上使用 的consumes。

你可以指定一系列可消费的媒体类型来压缩主要映射。当 Accept 请求头匹配可消费的媒体类型，才认为这个请求是可映射的。此外，使用 produces 条件可以保证实际类容的类型，produces 用于形成 response 方面的媒体类型，如：

@Controller
@RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, produces="application/json")
@ResponseBody
public Pet getPet(@PathVariable String petId, Model model) {
    // 省略实现
}

Just like with consumes, producible media type expressions can be negated as in !text/plain to match to all requests other than those with an Accept header value of text/plain.

	Tip
	produces 条件支持在类和方法上使用。与大多数情况不一样的是，方法中 produces 会覆盖类上使用 的produces ，而不是继承 类上使用 的produces 。

你可以通过请求参数条件来压缩请求匹配范围，如使用 "myParam", "!myParam", 或 "myParam=myValue"。前两种情况表示 存在/不存在，第三种指定了参数值。如下给出指定参数值的例子：

@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {

    @RequestMapping(value = "/pets/{petId}", method = RequestMethod.GET, params="myParam=myValue")
    public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
        // 省略实现
    }

}

类似的，头字段也支持 存在/不存在 和基于指定头字段值的匹配：

@Controller
@RequestMapping("/owners/{ownerId}")
public class RelativePathUriTemplateController {

    @RequestMapping(value = "/pets", method = RequestMethod.GET, headers="myHeader=myValue")
    public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {
        // 省略实现
    }

}

	Tip
	尽管你可以使用媒体类型通配符来匹配 Content-Type 和 Accept 头字段（如 "content-type=text/*" 可以匹配 "text/plain" 和 "text/html"），还是建议使用 consumes 和 produces 条件，因为 consumes 和 produces 专门为此而使用的。

如下是可以支持的方法参数：

	Note
	Session 访问可能是非线程安全的，特别是在 Servlet 环境。当允许多个请求并发访问 session 时，可以考虑设置 RequestMappingHandlerAdapter 的 "synchronizeOnSession" 值为 "true"。

Errors 或 BindingResult 参数必须跟随所绑定的模型对象，如果方法签名有超过一个模型对象的，Spring 会为其分别创建 BindingResult 实例。因此，如下例子没有效果：

BindingResult and @ModelAttribute 的无效顺序. 

@RequestMapping(method = RequestMethod.POST)
public String processSubmit(@ModelAttribute("pet") Pet pet, Model model, BindingResult result) { ... }

注意，因为 Pet 和 BindingResult 之间存在参数 Model。要其有效，你需要重新排序参数等我位置，如下：

@RequestMapping(method = RequestMethod.POST)
public String processSubmit(@ModelAttribute("pet") Pet pet, BindingResult result, Model model) { ... }

	Note
	JDK 1.8’s java.util.Optional is supported as a method parameter type with annotations that have a required attribute (e.g. @RequestParam, @RequestHeader, etc. The use of java.util.Optional in those cases is equivalent to having required=false.

以下是可支持的返回类型：

在控制器里，使用 @RequestParam 将请求参数绑定到方法参数。

如下代码片段演示了其用法：

@Controller
@RequestMapping("/pets")
@SessionAttributes("pet")
public class EditPetForm {

    // ...

    @RequestMapping(method = RequestMethod.GET)
    public String setupForm(@RequestParam("petId") int petId, ModelMap model) {
        Pet pet = this.clinic.loadPet(petId);
        model.addAttribute("pet", pet);
        return "petForm";
    }

    // ...

}

使用 @RequestParam 的参数默认是必须提供的，当然，你可以指定其为可选的，将 @RequestParam 的 reqired 属性设置 false 即可。(如, @RequestParam(value="id", required=false)).

如果方法参数的类型不是 String,类型转换会自动执行，可查看 the section called “方法参数和类型转换”。

如果将 @RequestParam 用于 Map<String, String> 或 MultiValueMap<String, String> 参数，此参数 map 会填充所有的请求参数。

@RequestBody 注解参数表示该参数将与 HTTP 请求体绑定。例子：

@RequestMapping(value = "/something", method = RequestMethod.PUT)
public void handle(@RequestBody String body, Writer writer) throws IOException {
    writer.write(body);
}

你使用 HttpMessageConverter 将请求体转换为方法参数。HttpMessageConverter 负责将请求信息转换为指定对象和将指定对象转换为请求体。RequestMappingHandlerAdapter 默认支持 @RequestBody 使用以下 HttpMessageConverters。

转换起的详细信息，可查看 Message Converters。也提醒一下，当使用 MVC 命名空间 或 MVC Java 配置时，默认注册了一系列转换器，详细信息可查看 Section 16.16.1, “Enabling the MVC Java Config or the MVC XML Namespace”。

如果你想读写 XML 的，需要注册 MarshallingHttpMessageConverter，MarshallingHttpMessageConverter 包含了 org.springframework.oxm 包中的 Marshaller 和 Unmarshaller 实现。如下例子演示了直接在配置文件注册 MarshallingHttpMessageConverter，如果你的应用通过 MVC 命名空间或 MVC Java 配置的，可查看 Section 16.16.1, “Enabling the MVC Java Config or the MVC XML Namespace”。

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <util:list id="beanList">
            <ref bean="stringHttpMessageConverter"/>
            <ref bean="marshallingHttpMessageConverter"/>
        </util:list>
    </property
</bean>

<bean id="stringHttpMessageConverter"
        class="org.springframework.http.converter.StringHttpMessageConverter"/>

<bean id="marshallingHttpMessageConverter"
        class="org.springframework.http.converter.xml.MarshallingHttpMessageConverter">
    <property name="marshaller" ref="castorMarshaller" />
    <property name="unmarshaller" ref="castorMarshaller" />
</bean>

<bean id="castorMarshaller" class="org.springframework.oxm.castor.CastorMarshaller"/>

@RequestBody 方法参数可添加 @Valid 注解，被注解的参数会使用配置的 Validator 来验证。当使用 MVC 命名空间或 mvc Java 配置时，应用会自动配置 JSR-303 验证器（前提是在类路径能找到 JSR-303 的实现）。

类似于 @ModelAttribute 参数，Errors 参数也可用来检测错误。当 Errore 参数没有声明时，或抛出 MethodArgumentNotValidException。此异常会被 DefaultHandlerExceptionResolver 处理 —— 向客户端发送 400 错误。

	Note
	可以查看 Section 16.16.1, “Enabling the MVC Java Config or the MVC XML Namespace”，了解如何使用 MVC 命名空间和 MVC Java 配置来配置信息转换器和验证器。

@ResponseBody 的使用类似于 @RequestBody。此注解用在方法上，用来表示直接将返回数据写到 HTTP 响应体里。注意，不是将数据放到 Model 中，或解析为视图名称。例子：

@RequestMapping(value = "/something", method = RequestMethod.PUT)
@ResponseBody
public String helloWorld() {
    return "Hello World";
}

上述例子会将 Hello World 文本写到 HTTP 响应流中。

与 @RequestBody 一样，Spring 使用 HttpMessageConverter 将返回对象转换为响应体。转换的详细信息可以查看上一节信息转换器。

一种比较常见的场景，控制器实现 REST API，只会返回 JSON、XML 或其他自定义媒体类型。为了方便，你可以在控制器上添加 @RestController 注解，而不是在每一个 @RequestMapping 上使用 @ResponseBody。

@RestController 是一个结合了 @ResponseBody 和 @Controller 的注解。不仅如此，@RestController 赋予了控制器更多的意义，在未来的版本中可能会携带额外的语义。。

与常规 @Controller 一样，@RestController 可以协助 @ControllerAdvice bean。详细信息可查看the section called “使用 @ControllerAdvice 注解增强控制器”。

HttpEntity 的用法类似于 @RequestBody 和 @ResponseBody 注解。除了可以访问请求/响应体，HttpEntity(和特用与响应的子类 ResponseEntity) 还可以访问 request 和 response 的头字段。例子：

@RequestMapping("/something")
public ResponseEntity<String> handle(HttpEntity<byte[]> requestEntity) throws UnsupportedEncodingException {
    String requestHeader = requestEntity.getHeaders().getFirst("MyRequestHeader"));
    byte[] requestBody = requestEntity.getBody();

    // do something with request header and body

    HttpHeaders responseHeaders = new HttpHeaders();
    responseHeaders.set("MyResponseHeader", "MyValue");
    return new ResponseEntity<String>("Hello World", responseHeaders, HttpStatus.CREATED);
}

上述例子获取了 MyRequestHeader 头字段的值，以字节数组的形式读取了请求体，随后将 MyRequestHeader 添加到 response，将 Hello World 写到响应流和设置响应状态码为 201(Created).

与 @RequestBody 和 @ResponseBody 一样，Srping 使用 HttpMessageConverter 将数据与请求/响应流互转，可查看上一节信息转换器

@ModelAttribute 可用欲方法或方法参数中。这一部分将介绍 @ModelAttribute 在方法中的使用，下一部分介绍其在方法啊参数中的使用。

在方法上使用 @ModelAttribute 注解，表示此方法的目的在于添加一个或多个模型属性。这种方法所支持的参数类型与 @RequestMapping 一样，不同的是，其不能直接映射到 request。另外，在同一个控制器里，@ModelAttribute 会在 @RequestMapping 之前调用。举几个例子：

// 添加一个属性
// 方法的返回值会以 "account" 键添加到 model
// 可通过 @ModelAttribute("myAccount") 自定义

@ModelAttribute
public Account addAccount(@RequestParam String number) {
    return accountManager.findAccount(number);
}

// 添加多个属性

@ModelAttribute
public void populateModel(@RequestParam String number, Model model) {
    model.addAttribute(accountManager.findAccount(number));
    // 再添加多个……
}

@ModelAttribute 用来将常用属性填充到模型里。如：填充下拉框陈述、宠物类型、或命令对象（如 Account，用于表示 HTML 表单数据）。最后一种情况会在下一部分深入谈论。

留意一下 @ModelAttribute 方法的两种使用方式。第一种，在方法里隐式添加一个属性并返回；第二种，方法里接收 Model 参数，并将任意个属性添加到 Model中。你可以根据自身需要选择其中一种使用方式。

一个控制器可以有多个 @ModelAttribute 方法。在同一个控制器中，所有 @ModelAttribute 方法都会在 @RequestMapping 方法之前调用。

@ModelAttribute 方法也可以在 @ControllerAdvice 注解的类中使用，类似的可应用于其他控制器，详细信息可查看 the section called “使用 @ControllerAdvice 注解增强控制器”。

	Tip
	当模型属性名称没有显式定义，会是一种什么样的情况？在这种情况下，默认使用参数类型名称作为模型属性名称。如，当方法返回 Account 对象时，其默认的模型属性名称是 "account"。你可以通过设置@ModelAttribute 注解的 "value" 属性来自定义。当直接往 Model 添加属性时，请正确使用 addAttribute(..) 的重载方法 —— 如，是否在方法中带属性名。

@ModelAttribute 注解也可用在 @RequestMapping 方法中。这种情况下，@RequestMapping 方法的返回值将解析为模型属性，而不是视图名称。相反，视图名称来源于视图名称的约定，就类似于方法返回 void，可查看Section 16.13.3, “The View - RequestToViewNameTranslator”。

如前文所述，@ModelAttribute 也可以用在方法或方法参数上。这一部分将介绍其在方法参数上的使用。

@ModelAttribute 注解的方法参数，表示该参数会从模型中检索。如果该参数不在模型中，此参数会先执行初始化或后添加到模型里；如果参数存在模型里，此参数字段会填充所有匹配其名称的请求参数。这就是大家熟知的 Spring MVC 数据绑定 —— 一个可以免除你逐个解析表单属性而又非常有用的机制。

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)
public String processSubmit(@ModelAttribute Pet pet) { }

上述所给例子，Pet 实例可以在哪里获取？有以下几种选择：

@ModelAttribute 方法是一种从数据库检索索性的常用方式，所检索到的属性可以使用 @SessionAttributes 在请求之间存储。在某些情况下，使用 URI 模版变量和类型转化器可能会方便一些，举个例子：

@RequestMapping(value="/accounts/{account}", method = RequestMethod.PUT)
public String save(@ModelAttribute("account") Account account) {

}

上面这个例子，模型属性名称（这里为 "account") 可以映射 URI 模版模版变量。如果你注册了 Converter<String, Account>（一个可将 String 类型的 account 值转换为 Account实例），那上述例子在没有 @ModelAttribute 方法下，也是可工作的。

下一步是数据绑定。WebDataBinder 类映射请求参数名 —— 包括查询字符参数和表单属性 —— 根据名称添加模型属性。在类型转换之后，如果需要，映射属性会被填充。数据绑定在验证在 Chapter 7, 数据校验、数据绑定和类型转换 有介绍，在控制器层自定义数据绑定的处理方法，在 the section called “自定义 WebDataBinder 的初始化” 有介绍。

在处理数据绑定中，可能会抛出错误（如缺失必要属性或类型转换错误）。如要检查这些错误，可在 @ModelAttribute 参数后添加 BindingResult 参数。

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)
public String processSubmit(@ModelAttribute("pet") Pet pet, BindingResult result) {

    if (result.hasErrors()) {
        return "petForm";
    }

    // ...

}

使用 BindingResult， 你可以判断是否存在数据绑定错误。当存在错误时，通常会渲染此表单 —— 通过 Spring 的 <errors> 表单标签展示这些错误。

除了数据绑定，你也可以通过自定以验证器传递 BindingResult 来执行验证。当中 BindingResult 保存了数据绑定的错误。这样可以允许数据绑定和验证错误统一收集，随后回馈给用户。

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)
public String processSubmit(@ModelAttribute("pet") Pet pet, BindingResult result) {

    new PetValidator().validate(pet, result);
    if (result.hasErrors()) {
        return "petForm";
    }

    // ...

}

你也可以自动执行验证，配置 JSR-303 `@Valid 注解即可。

@RequestMapping(value="/owners/{ownerId}/pets/{petId}/edit", method = RequestMethod.POST)
public String processSubmit(@Valid @ModelAttribute("pet") Pet pet, BindingResult result) {

    if (result.hasErrors()) {
        return "petForm";
    }

    // ...

}

至于如何配置和使用验证，可查看 Section 7.8, “Spring Validation” 和 Chapter 7, 数据校验、数据绑定和类型转换。

类上的 @SessionAttributes 注解，声明了 session 属性可以被指定 hadler 使用。这通常会列出需要透明存储到 session 或其他会话存储的模型属性或模型属性的类型，作为后续请求的 form-backing beam。

如下代码片段展示了 @SessionAttributes 的用法，其指定了模型属性名称：

@Controller
@RequestMapping("/editPet.do")
@SessionAttributes("pet")
public class EditPetForm {
    // ...
}

在重定向 URL 中，所有模型属性默认暴露给 URI 模版变量，剩下的属性(原始类型或原始类型集合/数组)会自动拼接到查询参数中。

然而，在一个带注解的控制器中，模型也许包含了额外的属性（用于渲染，如下拉框属性）。在重定向场景中，要准确控制这些属性，可在 @RequestMapping 方法中声明 RedirectAttributes 类型参数，并往其添加 RedirectView 使用的属性。如果这个控制方法没有重定向，将使用 RedirectAttributes 的内容，否则使用默认 Model 的内容。

RequestMappingHandlerAdapter 提供了一个 "ignoreDefaultModelOnRedirect" 标志，用来设置在控制方法重定向时，默认Model 的内容是否从不使用。相反，控制器方法应该声明 RedirectAttributes 类型属性，否则会没有任何属性传递给 RedirectView。为了向后兼容，MVC 命名空间和 MVC Java 配置都将 "ignoreDefaultModelOnRedirect" 设置为 false。可我们还是建议你在新应用里将其设置为 true。

RedirectAttributes 接口也可以用来添加 flash 属性。与其他重定向属性（在重定向 URL 中销毁）不同的是，flash 属性会保存到 HTTP session（因此 flash 属性也不会在 URL 上出现）。作用于重定向 URL 的控制器里的模型会自动接收这些 flash 属性，之后，flash 属性会从 session 中移除。可查看 Section 16.6, “使用 flash 属性”，了解 Spring MVC 对 flash 属性的常规支持。

前一节节介绍了 @ModelAttribute 在客户端浏览器表单提交的使用。同时也推荐使用 @ModelAttribute 处理非浏览器提交的请求。然而，在处理 HTTP PUT 请求时，这里存在了一个明显的不同。浏览器支持通过 HTTP GET 或 HTTP POST 方法提交表单数据。非浏览器也支持通过 HTTP PUT 方法提交表单。这里提出了一个挑战 —— 因为 Servlet 规范要求 ServletRequest.getParameter*() 方法需要支持表单属性访问，而这只适用于 HTTP POST，不适用于 HTTP PUT。

为了支持 HTTP PUT 和 PATCH 请求，spring-web 模块提供了 HttpPutFormContentFilter 过滤器，此过滤器可 web.xml 配置：

<filter>
    <filter-name>httpPutFormFilter</filter-name>
    <filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>httpPutFormFilter</filter-name>
    <servlet-name>dispatcherServlet</servlet-name>
</filter-mapping>

<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>

HttpPutFormContentFilter 过滤器拦截了content 类型为 application/x-www-form-urlencoded 的 HTTP PUT 和 PATCH 请求，它从请求体中读取表单数据并将其封装为 ServletRequest，以便后续使用 ServletRequest.getParameter*() 方法获取表单数据。

	Note
	由于HttpPutFormContentFilter已经处理了请求体，所以不应该再给PUT和PATCH的请求配置其他依赖于处理"application/x-www-form-urlencoded"的转换器。这里包括了 @RequestBody MultiValueMap<String, String> 和 HttpEntity<MultiValueMap<String, String>>。

@CookieValue 注解允许将方法参数与HTTP cookie 值绑定。

假设下面这个 cookie 值已经从 http 请求获得。 Let us consider that the following cookie has been received with an http request:

JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84

一下例子演示了如何获取 JSESSIONID cookie 值。

@RequestMapping("/displayHeaderInfo.do")
public void displayHeaderInfo(@CookieValue("JSESSIONID") String cookie) {
    //...
}

如果方法参数不是 String 类型，类型转换会自动执行，可查看 the section called “方法参数和类型转换”。

@CookieValue 注解支持在 Servlet 和 Portlet 环境中注解 handler 方法。

@RequestHeader 注解允许将方法参数与请求头字段绑定。

如下一个请求头字段值的样例：

Host                    localhost:8080
Accept                  text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language         fr,en-gb;q=0.7,en;q=0.3
Accept-Encoding         gzip,deflate
Accept-Charset          ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive              300

如下代码演示了如何获取 Accept-Encoding 和 Keep-Alive 头字段值：

@RequestMapping("/displayHeaderInfo.do")
public void displayHeaderInfo(@RequestHeader("Accept-Encoding") String encoding,
        @RequestHeader("Keep-Alive") long keepAlive) {
    //...
}

如果方法参数不是 String 类型，类型转换会自动执行，可查看 the section called “方法参数和类型转换”。

将注解 @RequestHeader 用于 Map<String, String>,MultiValueMap<String, String>, 或 HttpHeaders 参数，map 会填充所有头字段值。

	Tip
	内置支持将逗号分隔的字符串转换为数组/集合 或 系统其他熟知的类型。比如，带有 @RequestHeader("Accept") 的方法参数，可以 String 类型，也可以是 String[] 或 List<String> 类型。

@RequestHeader 注解支持在 Servlet 和 Portlet 环境中注解 handler 方法。

从请求(包括请求参数、路径参数、请求头和cookie)里提取的字符串，基本上都需要转换为方法参数或类属性的目标类型，如将请求参数绑定到 @ModelAttribute 参数属性。如果目标类型不是 String，Spring 自动将其转换为合适的类型。支持所有简单类型的转换（如 int、long、Date等）。你可以进一步通过 WebDataBinder 自定义处理过程(可查看the section called “自定义 WebDataBinder 的初始化”)或使用 FormattingConversionService 注册 Formatters（可查看 Section 7.6, “Spring Field Formatting”）。

To customize request parameter binding with PropertyEditors through Spring’s WebDataBinder, you can use @InitBinder-annotated methods within your controller, @InitBinder methods within an @ControllerAdvice class, or provide a custom WebBindingInitializer. See the the section called “使用 @ControllerAdvice 注解增强控制器” section for more details.

@Controller
public class MyFormController {

    @InitBinder
    public void initBinder(WebDataBinder binder) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        dateFormat.setLenient(false);
        binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));
    }

    // ...

}

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="cacheSeconds" value="0" />
    <property name="webBindingInitializer">
        <bean class="org.springframework.samples.petclinic.web.ClinicBindingInitializer" />
    </property>
</bean>

依据 Servlet API 对 getLastModified 方法的定义，@RequestMapping 方法也可以支持 'Last-Modified' HTTP 请求，以方便内容缓存，加快响应。getLastModified 方法的调用，需要计算给定请求的 lastModified 值（long 类型），并将其与请求头 'If-Modified-Since' 相互比较，若认为其没有更新，返回状态码为 304 的 response。注解控制器可如此实现这一需求：

@RequestMapping
public String myHandleMethod(WebRequest webRequest, Model model) {

    long lastModified = // 1. 应用指定的计算值

    if (request.checkNotModified(lastModified)) {
        // 2. 快速退出 —— 不作进一步处理
        return null;
    }
    // 3. 否则，进一步处理请求，本质是准备内容
    model.addAttribute(...);
    return "myViewName";
}

注意两个关键点：调用 request.checkNotModified(lastModified) 和 返回 null。前者将 response 的状态设置为 304 后才返回 true。后者，与前者的使用结合，告知 Spring MVC 不对请求作进一步的处理。

@ControllerAdvice 注解可以让实现类通过类路径自动检测出来。当使用 MVC 命名空间或 MVC Java 配置时，此此功能是默认启动的。

带有 @ControllerAdvice 注解的类，可以包含 @ExceptionHandler、@InitBinder, 和 @ModelAttribute 注解的方法，并且这些注解的方法会通过控制器层次应用到所有 @RequestMapping 方法中，而不用一一在控制器内部声明。

Classes annotated with @ControllerAdvice can contain @ExceptionHandler, @InitBinder, and @ModelAttribute annotated methods, and these methods will apply to @RequestMapping methods across all controller hierarchies as opposed to the controller hierarchy within which they are declared.

@ControllerAdvice 注解也可在属性中注明，将应用到哪些目标控制器：

// 应用到所有 @RestController 控制器
@ControllerAdvice(annotations = RestController.class)
public class AnnotationAdvice {}

// 应用到指定包下的控制器
@ControllerAdvice("org.example.controllers")
public class BasePackageAdvice {}

// 应用到指定类型的控制器
@ControllerAdvice(assignableTypes = {ControllerInterface.class, AbstractController.class})
public class AssignableTypesAdvice {}

希望加深了解的，可以 Check out @ControllerAdvice 文档。

在将对象序列化到响应体时，偶尔需要过滤敏感的数据。为了提供这一功能，Spring MVC 内置支持使用 Jackson 序列化视图。

可在带有 @ResponseBody 注解的方法或返回ResponseEntity 的方法中使用Jackson 序列化视图，只需要添加一个带 class 参数的@JsonView即可（class 参数指定所使用的视图类或接口）。

@RestController
public class UserController {

    @RequestMapping(value = "/user", method = RequestMethod.GET)
    @JsonView(User.WithoutPasswordView.class)
    public User getUser() {
        return new User("eric", "7!jd#h23");
    }
}

public class User {

    public interface WithoutPasswordView {};
    public interface WithPasswordView extends WithoutPasswordView {};

    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @JsonView(WithoutPasswordView.class)
    public String getUsername() {
        return this.username;
    }

    @JsonView(WithPasswordView.class)
    public String getPassword() {
        return this.password;
    }
}

	Note
	注意：尽管 @JsonView 支持序列化多个类，但控制器方法只支持 @JsonView 序列化一个类。如果需要序列化多个视图，可以使用多个接口组合的方式。

对于控制器依赖于视图解析的情况，只需将序列化的视图类添加到模型里，即可。

@Controller
public class UserController extends AbstractController {

    @RequestMapping(value = "/user", method = RequestMethod.GET)
    public String getUser(Model model) {
        model.addAttribute("user", new User("eric", "7!jd#h23"));
        model.addAttribute(JsonView.class.getName(), User.WithoutPasswordView.class);
        return "userView";
    }
}

若需要支持在 @ResponseBody 和 ResponseEntity 方法中支持 JSONP 的使用，可以定一个 @ControllerAdvice bean 并继承 AbstractJsonpResponseBodyAdvice 类。AbstractJsonpResponseBodyAdvice 的构造器说明 JSONP 的查询参数。具体例子如下：

@ControllerAdvice
public class JsonpAdvice extends AbstractJsonpResponseBodyAdvice {

    public JsonpAdvice() {
        super("callback");
    }
}

对于控制器依赖于视图解析的情况，只需要请求带有 jsonp 或 callback 查询参数，JSONP 会自动激活。JSONP 查询参数可以通过 jsonpParameterNames 属性自定义。

当控制器返回的 Callable 在执行时反生了异常，会出现什么情况？这种情况类似于控制器发生异常时的情况。所出现的异常会由同一控制器里的 @ExceptionHandler 方法处理，或由所配置的 HandlerExceptionResolver 实例来处理。

	Note
	在后台，当 Callable 执行发生了异常时，Spring MVC 仍然会就将其转发会 Servlet 容器，继续器后续处理。唯一不同的是，执行 Callable 返回的结果是一个异常，此异常必须有所配置的 HandlerExceptionResolver 实例来处理。

如果是执行 DeferredResult 时出现异常，你可以选择调用 DeferredResult 提供的 setErrorResult(Object) 方法，该方法须提供一个异常或其他你设置设置的对象。 当结果是一个 Exception 时，会由同一控制器里的 @ExceptionHandler 方法处理，或由所配置的 HandlerExceptionResolver 实例来处理。

HandlerInterceptor 可以实现 AsyncHandlerInterceptor 接口，此接口额外提供一个 afterConcurrentHandlingStarted 方法。该方法会在初始请求处线程退出 和 异步处理开始之后调用。详细信息可参考 AsyncHandlerInterceptor javadocs 。

也可以选择使用 DeferredResult 直接提供的异步请求生命周期回调函数，当中包括了 onTimeout(Runnable) 和 onCompletion(Runnable) 方法。这两个方法会分别在异步请求超时或完成时调用。超时事件可通过设置 DeferredResult 部分值来处理，然而，完成时的回调意味着结束，即不能再设置返回结果。

Callable 也可以使用类似的回调功能。可是，你需要将 Callable 封装成 WebAsyncTask 实例，接着使用这个实例注册超时和完成时事件。如此便可像 DeferredResult 那样，处理超时时间和在完成时返回一个值。

你可以通过 MVC Java 配置或 MVC 命名空间，注册全局性的 CallableProcessingInterceptor 或 DeferredResultProcessingInterceptor。这两个拦截器提供了完成的回调机制，而且每次使用 Callable 或 DeferredResult 都会应用这两个拦截器。