# Servlet 堆栈上的 Web

文档的这一部分涵盖了对构建在 Servlet API 上并部署到 Servlet 容器上的 Servlet 堆栈 Web 应用程序的支持。个别章节包括[Spring MVC](#mvc)、[查看技术](#mvc-view)、[CORS 支持](#mvc-cors)和[WebSocket Support](#websocket)。有关反应式堆栈 Web 应用程序，请参见[反应式堆栈上的 Web](web-reactive.html#spring-web-reactive)。

## 1. Spring Web MVC

Spring Web MVC 是建立在 Servlet API 上的原始 Web 框架，并且从一开始就包含在 Spring 框架中。正式名称“ Spring Web MVC”来自其源模块的名称（[`spring-webmvc`]（https://github.com/ Spring-projects/ Spring-framework/tree/main/ Spring-webmvc）），但更常见的名称是“ Spring MVC”。

与 Spring Web MVC 并行， Spring Framework5.0 引入了一种反应式堆栈 Web 框架，其名称为“ Spring WebFlux”，也基于其源模块（[`spring-webflux`]（https://github.com/ Spring-projects/ Spring-framework/tree/main/ Spring-WebFlux））。本节涵盖 Spring Web MVC。[下一节](web-reactive.html#spring-web-reactive)覆盖了 Spring WebFlux。

有关基线信息以及与 Servlet 容器和 爪哇 EE 版本范围的兼容性，请参见 Spring 框架[Wiki](https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Versions)。

### 1.1.DispatcherServlet

[WebFlux](web-reactive.html#webflux-dispatcher-handler)

Spring 与许多其他 Web 框架一样，MVC 是围绕前控制器模式设计的，其中中央、，提供用于请求处理的共享算法，而实际工作是通过可配置的委托组件来执行的。这个模型是灵活的，并支持不同的工作流程。

`DispatcherServlet`，就像任何`Servlet`一样，需要通过使用 爪哇 配置或在`web.xml`中根据 Servlet 规范进行声明和映射。反过来，`DispatcherServlet`使用 Spring 配置来发现它在请求映射、视图解析、异常处理、[and more](#mvc-servlet-special-bean-types)中需要的委托组件。

下面的 爪哇 配置示例注册并初始化了`DispatcherServlet`，这是由 Servlet 容器自动检测的（参见[Servlet Config](#mvc-container-config)）：

爪哇

```
public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) {

        // Load Spring web application configuration
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfig.class);

        // Create and register the DispatcherServlet
        DispatcherServlet servlet = new DispatcherServlet(context);
        ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
        registration.setLoadOnStartup(1);
        registration.addMapping("/app/*");
    }
}
```

Kotlin

```
class MyWebApplicationInitializer : WebApplicationInitializer {

    override fun onStartup(servletContext: ServletContext) {

        // Load Spring web application configuration
        val context = AnnotationConfigWebApplicationContext()
        context.register(AppConfig::class.java)

        // Create and register the DispatcherServlet
        val servlet = DispatcherServlet(context)
        val registration = servletContext.addServlet("app", servlet)
        registration.setLoadOnStartup(1)
        registration.addMapping("/app/*")
    }
}
```

|   |除了直接使用 ServletContext API 之外，你还可以扩展`AbstractAnnotationConfigDispatcherServletInitializer`并覆盖特定的方法<br/>（请参见[上下文层次结构](#mvc-servlet-context-hierarchy)下的示例）。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

|   |对于编程用例，`GenericWebApplicationContext`可以用作<br/>的`AnnotationConfigWebApplicationContext`的替代。详情见[`GenericWebApplicationContext`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/context/support/genericwebapplicationcontext.html）爪哇doc。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

以下`web.xml`配置寄存器和初始化`DispatcherServlet`的示例：

```
<web-app>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/app-context.xml</param-value>
    </context-param>

    <servlet>
        <servlet-name>app</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>

</web-app>
```

|   |Spring 启动遵循不同的初始化顺序。 Spring boot 使用 Spring 配置来<br/>bootstrap 本身和嵌入的 Servlet 容器，而不是连接到 Servlet 容器的生命周期<br/>。`Filter`和`Servlet`声明<br/>在 Spring 配置中检测到并在 Servlet 容器中注册。<br/>有关更多详细信息，请参见[Spring Boot documentation](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-embedded-container)。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.1.1.上下文层次结构

`DispatcherServlet`对其自身的配置期望`WebApplicationContext`（普通`ApplicationContext`的扩展）。`WebApplicationContext`具有指向`ServletContext`和与其关联的`Servlet`的链接。它还绑定到`ServletContext`，使得应用程序可以在`RequestContextUtils`上使用静态方法来查找`WebApplicationContext`，如果他们需要访问它。

对于许多应用程序，具有一个`WebApplicationContext`是简单且足够的。还可以有一个上下文层次结构，其中一个根`WebApplicationContext`在多个`DispatcherServlet`（或其他`Servlet`）实例之间共享，每个实例都有自己的子实例`WebApplicationContext`配置。有关上下文层次结构特性的更多信息，请参见[`ApplicationContext`]（core.html#context-introduction）。

根`WebApplicationContext`通常包含基础设施 bean，例如需要跨多个`Servlet`实例共享的数据存储库和业务服务。这些 bean 被有效地继承，并且可以在 Servlet 特定的子`WebApplicationContext`中被重写（即重新声明），该子`Servlet`通常包含给定的`Servlet`本地的 bean。下图显示了这种关系：

![MVC 上下文层次结构](images/mvc-context-hierarchy.png)

下面的示例配置了`WebApplicationContext`层次结构：

爪哇

```
public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[] { RootConfig.class };
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { App1Config.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/app1/*" };
    }
}
```

Kotlin

```
class MyWebAppInitializer : AbstractAnnotationConfigDispatcherServletInitializer() {

    override fun getRootConfigClasses(): Array<Class<*>> {
        return arrayOf(RootConfig::class.java)
    }

    override fun getServletConfigClasses(): Array<Class<*>> {
        return arrayOf(App1Config::class.java)
    }

    override fun getServletMappings(): Array<String> {
        return arrayOf("/app1/*")
    }
}
```

|   |如果不需要应用程序上下文层次结构，则应用程序可以通过`getRootConfigClasses()`和`null`从`getServletConfigClasses()`返回所有<br/>配置。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

下面的示例显示了`web.xml`的等价值：

```
<web-app>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/root-context.xml</param-value>
    </context-param>

    <servlet>
        <servlet-name>app1</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/app1-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app1</servlet-name>
        <url-pattern>/app1/*</url-pattern>
    </servlet-mapping>

</web-app>
```

|   |如果不需要应用程序上下文层次结构，则应用程序可以仅配置<br/>“root”上下文，并将`contextConfigLocation` Servlet 参数保留为空。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.1.2.特殊 Bean 型

[WebFlux](web-reactive.html#webflux-special-bean-types)

`DispatcherServlet`将委托给特殊的 bean 来处理请求并呈现适当的响应。“特殊 bean”指的是实现框架契约的 Spring-managed`Object`实例。这些通常带有内置契约，但你可以自定义它们的属性并扩展或替换它们。

下表列出了`DispatcherServlet`检测到的特殊 bean:

|                                   Bean type                                   |解释|
|-------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                               `HandlerMapping`                                |将请求与[拦截器](#mvc-handlermapping-interceptor)的列表一起映射到处理程序，以进行前处理和后处理。<br/>映射基于某些条件，其中的细节取决于`HandlerMapping`实现。<br/><br/>两个主要的`HandlerMapping`实现是`RequestMappingHandlerMapping`（它支持`@RequestMapping`注释的方法）和`SimpleUrlHandlerMapping`（它维护对处理程序的 URI 路径模式的显式注册）。|
|                               `HandlerAdapter`                                |帮助`DispatcherServlet`调用映射到请求的处理程序，而不考虑<br/>实际调用处理程序的方式。例如，调用带注释的控制器<br/>需要解析注释。a`HandlerAdapter`的主要目的是<br/>使`DispatcherServlet`不受这些细节的影响。|
|             [`HandlerExceptionResolver`](#mvc-exceptionhandlers)              |解决异常的策略，可能将异常映射到处理程序、HTML 错误<br/>视图或其他目标。见[Exceptions](#mvc-exceptionhandlers)。|
|                      [`ViewResolver`](#mvc-viewresolver)                      |将从处理程序返回的基于逻辑`String`的视图名称解析为实际的`View`，并使用该视图将其呈现给响应。见[视图分辨率](#mvc-viewresolver)和[查看技术](#mvc-view)。|
|[`LocaleResolver`](#mvc-localeresolver), [LocaleContextResolver](#mvc-timezone)|解析客户端正在使用的`Locale`以及可能的时区，以便能够<br/>提供国际化的视图。见[Locale](#mvc-localeresolver)。|
|                     [`ThemeResolver`](#mvc-themeresolver)                     |解析 Web 应用程序可以使用的主题——例如，提供个性化的布局。<br/>参见[Themes](#mvc-themeresolver)。|
|                     [`MultipartResolver`](#mvc-multipart)                     |用于解析具有<br/>的多部分请求（例如，浏览器表单文件上传）的抽象，需要借助一些多部分解析库。见[多部分旋转变压器](#mvc-multipart)。|
|                  [`FlashMapManager`](#mvc-flash-attributes)                   |存储和检索“输入”和“输出”`FlashMap`，它们可以用于将<br/>属性从一个请求传递到另一个请求，通常是通过重定向。<br/>参见[flash 属性](#mvc-flash-attributes)。|

#### 1.1.3.Web MVC 配置

[WebFlux](web-reactive.html#webflux-framework-config)

应用程序可以声明[Special Bean Types](#mvc-servlet-special-bean-types)中列出的处理请求所需的基础设施 bean。`DispatcherServlet`检查每个特殊 Bean 的`WebApplicationContext`。如果没有匹配的 Bean 类型，它将返回到[`DispatcherServlet.properties`]（https://github.com/ Spring-projects/ Spring-framework/tree/main/ Spring-webmvc/SRC/main/resources/org/springframework/web/ Servlet/dispatcherservlet.properties）中列出的默认类型。

在大多数情况下，[MVC Config](#mvc-config)是最好的起点。它用 爪哇 或 XML 声明所需的 bean，并提供一个更高级别的配置回调 API 来定制它。

|   |Spring Boot 依赖于 MVC 爪哇 配置来配置 Spring MVC，并且<br/>提供了许多额外的方便选项。|
|---|------------------------------------------------------------------------------------------------------------------------|

#### 1.1.4. Servlet 配置

在 Servlet 3.0+ 环境中，你可以选择以编程方式配置 Servlet 容器作为替代方案，或者与`web.xml`文件组合。下面的示例注册了`DispatcherServlet`:

爪哇

```
import org.springframework.web.WebApplicationInitializer;

public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext container) {
        XmlWebApplicationContext appContext = new XmlWebApplicationContext();
        appContext.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");

        ServletRegistration.Dynamic registration = container.addServlet("dispatcher", new DispatcherServlet(appContext));
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    }
}
```

Kotlin

```
import org.springframework.web.WebApplicationInitializer

class MyWebApplicationInitializer : WebApplicationInitializer {

    override fun onStartup(container: ServletContext) {
        val appContext = XmlWebApplicationContext()
        appContext.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml")

        val registration = container.addServlet("dispatcher", DispatcherServlet(appContext))
        registration.setLoadOnStartup(1)
        registration.addMapping("/")
    }
}
```

`WebApplicationInitializer`是由 Spring MVC 提供的一个接口，该接口确保检测到你的实现并自动用于初始化任何 Servlet 3 容器。名为`AbstractDispatcherServletInitializer`的`WebApplicationInitializer`的抽象基类实现使得通过覆盖方法来指定 Servlet 映射和`DispatcherServlet`配置的位置来注册`DispatcherServlet`变得更加容易。

对于使用基于 爪哇 的 Spring 配置的应用程序，推荐这样做，如下例所示：

爪哇

```
public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { MyWebConfig.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }
}
```

Kotlin

```
class MyWebAppInitializer : AbstractAnnotationConfigDispatcherServletInitializer() {

    override fun getRootConfigClasses(): Array<Class<*>>? {
        return null
    }

    override fun getServletConfigClasses(): Array<Class<*>>? {
        return arrayOf(MyWebConfig::class.java)
    }

    override fun getServletMappings(): Array<String> {
        return arrayOf("/")
    }
}
```

如果使用基于 XML 的 Spring 配置，则应该从`AbstractDispatcherServletInitializer`直接扩展，如下例所示：

爪哇

```
public class MyWebAppInitializer extends AbstractDispatcherServletInitializer {

    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }

    @Override
    protected WebApplicationContext createServletApplicationContext() {
        XmlWebApplicationContext cxt = new XmlWebApplicationContext();
        cxt.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");
        return cxt;
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }
}
```

Kotlin

```
class MyWebAppInitializer : AbstractDispatcherServletInitializer() {

    override fun createRootApplicationContext(): WebApplicationContext? {
        return null
    }

    override fun createServletApplicationContext(): WebApplicationContext {
        return XmlWebApplicationContext().apply {
            setConfigLocation("/WEB-INF/spring/dispatcher-config.xml")
        }
    }

    override fun getServletMappings(): Array<String> {
        return arrayOf("/")
    }
}
```

`AbstractDispatcherServletInitializer`还提供了一种方便的方式来添加`Filter`实例，并将它们自动映射到`DispatcherServlet`，如下例所示：

爪哇

```
public class MyWebAppInitializer extends AbstractDispatcherServletInitializer {

    // ...

    @Override
    protected Filter[] getServletFilters() {
        return new Filter[] {
            new HiddenHttpMethodFilter(), new CharacterEncodingFilter() };
    }
}
```

Kotlin

```
class MyWebAppInitializer : AbstractDispatcherServletInitializer() {

    // ...

    override fun getServletFilters(): Array<Filter> {
        return arrayOf(HiddenHttpMethodFilter(), CharacterEncodingFilter())
    }
}
```

每个过滤器都会根据其具体类型添加一个默认名称，并自动映射到`DispatcherServlet`。

`isAsyncSupported`的`AbstractDispatcherServletInitializer`保护方法提供了一个位置，可以在`DispatcherServlet`和映射到它的所有过滤器上启用异步支持。默认情况下，此标志设置为`true`。

最后，如果需要进一步自定义`DispatcherServlet`本身，则可以重写`createDispatcherServlet`方法。

#### 1.1.5.处理

[WebFlux](web-reactive.html#webflux-dispatcher-handler-sequence)

`DispatcherServlet`按以下方式处理请求：

* 在请求中搜索并绑定`WebApplicationContext`，将其作为控制器和流程中的其他元素可以使用的属性。默认情况下，它在`DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE`键下绑定。

* Locale 解析器绑定到请求，以让流程中的元素解析在处理请求（呈现视图、准备数据等）时使用的 Locale。如果不需要区域设置解析，则不需要区域设置解析程序。

* 主题解析程序绑定到请求，以便让视图等元素决定使用哪个主题。如果你不使用主题，你可以忽略它。

* 如果指定了多部分文件解析器，则会检查请求的多部分。如果发现了多个部分，则将请求包装在`MultipartHttpServletRequest`中，以便由流程中的其他元素进行进一步处理。有关多部件处理的更多信息，请参见[多部分旋转变压器](#mvc-multipart)。

* 将搜索一个合适的处理程序。如果找到了一个处理程序，则运行与该处理程序（预处理器、后处理器和控制器）相关联的执行链，以便为呈现准备一个模型。或者，对于带注释的控制器，可以呈现响应（在`HandlerAdapter`内），而不是返回视图。

* 如果返回了一个模型，则呈现该视图。如果没有返回模型（可能是由于预处理器或后处理器拦截了请求，可能是出于安全原因），则不呈现视图，因为该请求可能已经满足。

在`WebApplicationContext`中声明的`HandlerExceptionResolver`bean 用于解决请求处理过程中抛出的异常。这些异常解析器允许定制逻辑来处理异常。有关更多详细信息，请参见[Exceptions](#mvc-exceptionhandlers)。

对于 HTTP 缓存支持，处理程序可以使用`checkNotModified`的`WebRequest`方法，以及[控制器的 HTTP 缓存](#mvc-caching-etag-lastmodified)中描述的注释控制器的其他选项。

可以通过在`web.xml`文件中的 Servlet 声明中添加 Servlet 初始化参数（`init-param`元素）来定制单个`DispatcherServlet`实例。下表列出了支持的参数：

|           Parameter            |解释|
|--------------------------------| |
|         `contextClass`         |实现`ConfigurableWebApplicationContext`的类，将其实例化并由此 Servlet 本地配置<br/>。默认情况下，使用`XmlWebApplicationContext`。|
|    `contextConfigLocation`     |传递到上下文实例（由`contextClass`指定）到<br/>的字符串表示可以在哪里找到上下文。字符串可能由多个<br/>字符串组成（使用逗号作为分隔符），以支持多个上下文。在<br/>具有两次定义的 bean 的多个上下文位置的情况下，最新的位置<br/>优先。|
|          `namespace`           |`WebApplicationContext`的命名空间。默认值为`[servlet-name]-servlet`。|
|`throwExceptionIfNoHandlerFound`|当没有为请求找到处理程序时，是否抛出`NoHandlerFoundException`。<br/>然后可以使用`HandlerExceptionResolver`（例如，通过使用`@ExceptionHandler`控制器方法）捕获异常，并将其作为任何其他方法处理。<br/><br/>默认情况下，此异常被设置为`false`，在这种情况下，`DispatcherServlet`将<br/>响应状态设置为 404（不 \_found），而不会引发异常。<br/><br/>注意，如果[default servlet handling](#mvc-default-servlet-handler)也配置了<br/>，则未解决的请求总是被转发到默认的 Servlet <br/>，并且永远不会引发 404。|

#### 1.1.6.路径匹配

Servlet API 将完整的请求路径公开为`requestURI`，并进一步将其细分为`contextPath`、`servletPath`和`pathInfo`，其值随 Servlet 映射的方式而变化。 Spring MVC 需要从这些输入中确定要用于处理程序映射的查找路径，这是`DispatcherServlet`本身的映射内的路径，不包括`contextPath`和任何`servletMapping`前缀（如果存在的话）。

对`servletPath`和`pathInfo`进行了解码，这使得它们不可能直接与完整的`requestURI`进行比较，从而得出查找路径，这使得有必要对`requestURI`进行解码。然而，这引入了它自己的问题，因为路径可能包含编码的保留字符，例如`"/"`或`";"`，这些字符在解码后可能会反过来改变路径的结构，这也可能导致安全问题。此外， Servlet 容器可以在不同程度上归一化`servletPath`，这使得进一步不可能针对`startsWith`执行`requestURI`的比较。

这就是为什么最好避免依赖基于前缀的`servletPath`映射类型所附带的`servletPath`。如果`DispatcherServlet`被映射为带有`"/"`的缺省 Servlet，或者以其他方式不使用带有`"/*"`的前缀，并且 Servlet 容器是 4.0+，那么 Spring MVC 能够检测 Servlet 映射类型并完全避免使用`servletPath`和`pathInfo`。在 3.1 Servlet 容器上，假设具有相同的 Servlet 映射类型，可以通过在 MVC 配置中通过[路径匹配](#mvc-config-path-matching)提供带有`alwaysUseFullPath=true`的`UrlPathHelper`来实现等效。

幸运的是，默认的 Servlet 映射`"/"`是一个不错的选择。然而，仍然存在一个问题，即需要对`requestURI`进行解码，以便能够与控制器映射进行比较。这也是不希望的，因为有可能对保留的字符进行解码，从而改变路径结构。如果这样的字符不是预期的，那么你可以拒绝它们（如 Spring Security HTTP 防火墙），或者你可以配置`UrlPathHelper`和`urlDecode=false`，但是控制器映射将需要与编码路径匹配，这可能并不总是很好地工作。此外，有时`DispatcherServlet`需要与另一个 Servlet 共享 URL 空间，并且可能需要通过前缀进行映射。

上述问题可以通过从`PathMatcher`切换到解析的`PathPattern`在 5.3 或更高版本中可用，来更全面地解决，请参见[模式比较](#mvc-ann-requestmapping-pattern-comparison)。与`AntPathMatcher`（需要对查找路径进行解码或对控制器映射进行编码）不同，解析的`PathPattern`与解析的路径表示（称为`RequestPath`）匹配，一次只有一个路径段。这允许单独地对路径段值进行解码和消毒，而不存在更改路径结构的风险。解析的`PathPattern`还支持使用`servletPath`前缀映射，只要前缀保持简单，并且没有任何需要编码的字符。

#### 1.1.7.拦截

所有`HandlerMapping`实现都支持处理程序拦截器，当你想要将特定功能应用于某些请求时，这些功能非常有用——例如，检查主体。拦截器必须使用三种方法从`org.springframework.web.servlet`包中实现`HandlerInterceptor`，这些方法应该提供足够的灵活性来执行各种预处理和后处理：

* `preHandle(..)`:在实际处理程序运行之前

* `postHandle(..)`:运行处理程序之后

* `afterCompletion(..)`:在完成完整的请求之后

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

有关如何配置拦截器的示例，请参见 MVC 配置一节中的[拦截器](#mvc-config-interceptors)。你还可以在单独的`HandlerMapping`实现上使用 setter 直接注册它们。

请注意，`postHandle`对于`@ResponseBody`和`ResponseEntity`方法不那么有用，因为它们的响应是在`HandlerAdapter`和`postHandle`之前编写和提交的。这意味着对响应进行任何更改都为时已晚，例如添加一个额外的标头。对于这样的场景，你可以实现`ResponseBodyAdvice`，并将其声明为[财务总监建议](#mvc-ann-controller-advice) Bean，或者直接在`RequestMappingHandlerAdapter`上配置它。

#### 1.1.8.例外

[WebFlux](web-reactive.html#webflux-dispatcher-exceptions)

如果在请求映射期间发生异常，或者从请求处理程序（例如`@Controller`）抛出异常，则`DispatcherServlet`将委托给`HandlerExceptionResolver`bean 的链来解决异常并提供替代处理，这通常是错误响应。

下表列出了可用的`HandlerExceptionResolver`实现：

|                                                                             `HandlerExceptionResolver`                                                                              |说明|
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                                                          `SimpleMappingExceptionResolver`                                                                           |异常类名和错误视图名之间的映射。用于在浏览器应用程序中呈现<br/>错误页面。|
|[`DefaultHandlerExceptionResolver`](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/web/servlet/mvc/support/DefaultHandlerExceptionResolver.html)|解析由 Spring MVC 引发的异常，并将它们映射到 HTTP 状态代码。<br/>另请参见备选方案`ResponseEntityExceptionHandler`和[REST API 异常](#mvc-ann-rest-exceptions)。|
|                                                                          `ResponseStatusExceptionResolver`                                                                          |用`@ResponseStatus`注释解决异常，并根据注释中的值将它们映射到 HTTP 状态<br/>代码。|
|                                                                         `ExceptionHandlerExceptionResolver`                                                                         |通过在`@Controller`或`@ControllerAdvice`类中调用`@ExceptionHandler`方法来解决异常。见[@ExceptionHandler 方法](#mvc-ann-exceptionhandler)。|

##### 解析器链

通过在 Spring 配置中声明多个`HandlerExceptionResolver`bean 并根据需要设置它们的`order`属性，可以形成异常解决器链。Order 属性越高，异常解析器的定位就越晚。

`HandlerExceptionResolver`的契约指定它可以返回：

* 指向错误视图的`ModelAndView`。

* 如果异常是在解析程序中处理的，则为空`ModelAndView`。

* `null`如果异常仍然未解决，则供后续的解析器尝试，并且，如果异常仍然在最后，则允许将其冒泡到 Servlet 容器。

[MVC Config](#mvc-config)自动声明用于默认 Spring MVC 异常、用于`@ResponseStatus`注释异常和用于支持`@ExceptionHandler`方法的内置解析器。你可以自定义该列表或替换它。

##### 容器错误页

如果异常仍然被任何`HandlerExceptionResolver`未解决，并且因此被留给传播，或者如果响应状态被设置为错误状态（即，4xx，5xx）， Servlet 容器可以在 HTML 中呈现默认的错误页。要定制容器的默认错误页，可以在`web.xml`中声明一个错误页映射。下面的示例展示了如何做到这一点：

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

给出了前面的示例，当出现异常或者响应具有错误状态时， Servlet 容器在容器内对配置的 URL 进行错误分派（例如，`/error`）。然后由`DispatcherServlet`对此进行处理，可能将其映射到`@Controller`，该实现可用于返回带有模型的错误视图名称或呈现 JSON 响应，如下例所示：

爪哇

```
@RestController
public class ErrorController {

    @RequestMapping(path = "/error")
    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"));
        return map;
    }
}
```

Kotlin

```
@RestController
class ErrorController {

    @RequestMapping(path = ["/error"])
    fun handle(request: HttpServletRequest): Map<String, Any> {
        val map = HashMap<String, Any>()
        map["status"] = request.getAttribute("javax.servlet.error.status_code")
        map["reason"] = request.getAttribute("javax.servlet.error.message")
        return map
    }
}
```

|   |Servlet API 不提供在 爪哇 中创建错误页映射的方法。但是，你可以同时使用<br/>和极小值`web.xml`。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.1.9.视图分辨率

[WebFlux](web-reactive.html#webflux-viewresolution)

Spring MVC 定义了`ViewResolver`和`View`接口，这些接口允许你在浏览器中呈现模型，而无需将你绑定到特定的视图技术。`ViewResolver`提供了视图名称和实际视图之间的映射。`View`处理在将数据移交给特定视图技术之前的准备工作。

下表提供了关于`ViewResolver`层次结构的更多详细信息：

|          ViewResolver          |说明|
|--------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `AbstractCachingViewResolver`  |它们解析的`AbstractCachingViewResolver`缓存视图实例的子类。<br/>缓存提高了某些视图技术的性能。通过将`cache`属性设置为`false`，可以关闭<br/>缓存。此外，如果你必须在运行时刷新<br/>某个视图（例如，当修改自由标记模板时），<br/>你可以使用`removeFromCache(String viewName, Locale loc)`方法。|
|     `UrlBasedViewResolver`     |`ViewResolver`接口的简单实现，它在没有显式映射定义的情况下实现逻辑视图名称到 URL 的直接<br/>解析。<br/>如果你的逻辑名称以一种简单的方式匹配视图资源的名称<br/>，而不需要任意映射，那么这是合适的。|
| `InternalResourceViewResolver` |方便的`UrlBasedViewResolver`子类，支持`InternalResourceView`（在<br/>effect 中，servlet 和 JSP）和`JstlView`和`TilesView`等子类。通过使用`setViewClass(..)`，可以<br/>为这个解析器生成的所有视图指定视图类。<br/>参见[`UrlBasedViewResolver`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/SpringFramework/web/reactive/result/view/urlbasedviewresolver.html）爪哇doc 获取详细信息。|
|    `FreeMarkerViewResolver`    |`UrlBasedViewResolver`的方便的子类，它支持`FreeMarkerView`和<br/>它们的自定义子类。|
|`ContentNegotiatingViewResolver`|实现`ViewResolver`接口，该接口根据<br/>请求文件名或`Accept`报头解析视图。见[内容协商](#mvc-multiple-representations)。|
|     `BeanNameViewResolver`     |`ViewResolver`接口的实现，该接口在当前应用程序上下文中将视图名称解释为<br/> Bean 名称。这是一个非常灵活的变体，其<br/>允许基于不同的视图名称混合和匹配不同的视图类型。<br/>每个这样的`View`都可以被定义为 Bean，例如在 XML 中或在配置类中。|

##### 处理

[WebFlux](web-reactive.html#webflux-viewresolution-handling)

你可以通过声明多个解析器 Bean 并在必要时通过设置`order`属性来指定顺序来链接视图解析器 Bean。请记住，Order 属性越高，视图解析器在链中的定位就越晚。

`ViewResolver`的契约指定它可以返回 null 来表示找不到视图。但是，在 JSP 和`InternalResourceViewResolver`的情况下，要确定 JSP 是否存在，唯一的方法是通过`RequestDispatcher`执行分派。因此，你必须始终将`InternalResourceViewResolver`配置为在视图解析程序的总体顺序中的最后一个。

配置视图分辨率就像在 Spring 配置中添加`ViewResolver`bean 一样简单。[MVC Config](#mvc-config)为[视图解析器](#mvc-config-view-resolvers)和添加无逻辑[视图控制器](#mvc-config-view-controller)提供了专用的配置 API，这些 API 对于没有控制器逻辑的 HTML 模板呈现非常有用。

##### 重定向

[WebFlux](web-reactive.html#webflux-redirecting-redirect-prefix)

视图名称中的特殊`redirect:`前缀允许你执行重定向。`UrlBasedViewResolver`（及其子类）将其视为需要重定向的指令。视图名称的其余部分是重定向 URL。

净效果与控制器返回`RedirectView`相同，但现在控制器本身可以根据逻辑视图名称进行操作。逻辑视图名称（例如`redirect:/myapp/some/resource`）相对于当前 Servlet 上下文重定向，而名称（例如`redirect:https://myhost.com/some/arbitrary/path`）重定向到绝对 URL。

请注意，如果控制器方法使用`@ResponseStatus`进行注释，则注释值优先于`RedirectView`设置的响应状态。

##### 转发

你还可以使用一个特殊的`forward:`前缀来表示最终由`UrlBasedViewResolver`和子类解析的视图名称。这将创建一个`InternalResourceView`，它执行一个`RequestDispatcher.forward()`。因此，对于`InternalResourceViewResolver`和`InternalResourceView`（对于 JSP），这个前缀是没有用的，但是如果你使用另一种视图技术，但是仍然希望强制由 Servlet/JSP 引擎处理一个资源的转发，那么这个前缀是有帮助的。请注意，你也可以链接多个视图解析程序。

##### 内容协商

[WebFlux](web-reactive.html#webflux-multiple-representations)

[`ContentNegotiatingViewResolver`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet/view/contentlegatingviewresolver.html）并不解析视图本身，而是将视图委托给其他视图解析器，并选择与客户机请求的表示类似的视图。表示可以从`Accept`头或从查询参数（例如，`"/path?format=pdf"`）确定。

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

有关配置细节，请参见[视图解析器](#mvc-config-view-resolvers)下的[MVC Config](#mvc-config)。

#### 1.1.10.场所

Spring 体系结构的大多数部分都支持国际化，就像 Spring Web MVC 框架所做的那样。`DispatcherServlet`允许你通过使用客户机的区域设置自动解析消息。这是用`LocaleResolver`对象完成的。

当收到请求时，`DispatcherServlet`会查找一个区域设置解析器，如果找到一个，它会尝试使用它来设置区域设置。通过使用`RequestContext.getLocale()`方法，你始终可以检索由区域解析程序解析的区域设置。

除了自动解析语言环境外，还可以将拦截器附加到处理程序映射（有关处理程序映射拦截器的更多信息，请参见[拦截](#mvc-handlermapping-interceptor)），以在特定情况下（例如，基于请求中的参数）更改语言环境。

Locale 解析器和拦截器是在`org.springframework.web.servlet.i18n`包中定义的，并以正常的方式在应用程序上下文中进行配置。 Spring 中包括了对区域设置解析器的以下选择。

* [时区](#mvc-timezone)

* [报头解析器](#mvc-localeresolver-acceptheader)

* [Cookie 解析器](#mvc-localeresolver-cookie)

* [会话解析器](#mvc-localeresolver-session)

* [Locale 拦截器](#mvc-localeresolver-interceptor)

##### Time Zone

除了获取客户端的语言环境，了解它的时区通常是有用的。`LocaleContextResolver`接口提供了`LocaleResolver`的扩展，使解析器提供更丰富的`LocaleContext`，其中可能包括时区信息。

当可用时，可以使用`RequestContext.getTimeZone()`方法获得用户的`TimeZone`。时区信息被注册在 Spring 的`ConversionService`中的任何日期/时间`Converter`和`Formatter`对象自动使用。

##### 报头解析器

此 Locale 解析器检查客户机（例如，Web 浏览器）发送的请求中的`accept-language`头。通常，这个头字段包含客户端操作系统的区域设置。请注意，此解析器不支持时区信息。

##### Cookie 解析器

此区域解析程序检查客户端上可能存在的`Cookie`，以查看是否指定了`Locale`或`TimeZone`。如果是，则使用指定的细节。通过使用此区域设置解析程序的属性，你可以指定 cookie 的名称以及最长期限。下面的示例定义了`CookieLocaleResolver`:

```
<bean id="localeResolver" class="org.springframework.web.servlet.i18n.CookieLocaleResolver">

    <property name="cookieName" value="clientlanguage"/>

    <!-- in seconds. If set to -1, the cookie is not persisted (deleted when browser shuts down) -->
    <property name="cookieMaxAge" value="100000"/>

</bean>
```

下表描述了属性`CookieLocaleResolver`:

|   Property   |         Default         |说明|
|--------------|-------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `cookieName` |   classname + LOCALE    |饼干的名字|
|`cookieMaxAge`|Servlet container default|cookie 在客户机上持续存在的最长时间。如果指定了`-1`，则不会持久保存<br/>cookie。它仅在客户端关闭<br/>浏览器之前可用。|
| `cookiePath` |            /            |将 cookie 的可见性限制在网站的特定部分。当`cookiePath`被指定为<br/>时，cookie 仅对该路径及其下方的路径可见。|

##### 会话解析器

`SessionLocaleResolver`允许你从可能与用户请求关联的会话中检索`Locale`和`TimeZone`。与`CookieLocaleResolver`相反，该策略将本地选择的语言环境设置存储在 Servlet 容器的`HttpSession`中。因此，这些设置是每个会话的临时设置，因此在每个会话结束时都会丢失。

注意，与外部会话管理机制没有直接关系，例如 Spring 会话项目。这个`SessionLocaleResolver`针对当前的`HttpServletRequest`计算并修改相应的`HttpSession`属性。

##### Locale 拦截器

你可以通过将`LocaleChangeInterceptor`添加到`HandlerMapping`定义中的一个来启用更改区域设置。它在请求中检测一个参数，并相应地更改区域设置，在 Dispatcher 的应用程序上下文中调用`LocaleResolver`上的`setLocale`方法。下一个示例显示，对所有包含名为`siteLanguage`的参数的`*.view`资源的调用现在会更改区域设置。因此，例如，对 URL 的请求`[https://www.sf.net/home.view?siteLanguage=nl](https://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>
```

#### 1.1.11.主题

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

##### 定义主题

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

当你使用`ResourceBundleThemeSource`时，将在一个简单的属性文件中定义一个主题。Properties 文件列出了构成主题的资源，如下例所示：

```
styleSheet=/themes/cool/style.css
background=/themes/cool/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`使用一个空的基名前缀。因此，属性文件是从 Classpath 的根目录加载的。因此，你将把`cool.properties`主题定义放在 Classpath 根目录中（例如，在`/WEB-INF/classes`中）。`ResourceBundleThemeSource`使用标准的 爪哇 资源包加载机制，允许主题的完全国际化。例如，我们可以有一个`/WEB-INF/classes/cool_nl.properties`，它引用了一个特殊的背景图像，上面有荷兰语文本。

##### 解决主题

在定义主题（如[前一节](#mvc-themeresolver-defining)中所述）之后，你将决定使用哪个主题。`DispatcherServlet`查找名为`themeResolver`的 Bean，以找出要使用的`ThemeResolver`实现。主题解析器的工作方式与`LocaleResolver`几乎相同。它会检测用于特定请求的主题，还可以更改请求的主题。下表描述了 Spring 提供的主题解析器：

|        Class         |说明|
|----------------------|--------------------------------------------------------------------------------------------------------------------------------------------|
| `FixedThemeResolver` |选择一个固定的主题，通过使用`defaultThemeName`属性进行设置。|
|`SessionThemeResolver`|该主题在用户的 HTTP 会话中进行维护。对于<br/>每个会话只需要设置一次，但在会话之间不会持久化。|
|`CookieThemeResolver` |选定的主题存储在客户端的 cookie 中。|

Spring 还提供了一个`ThemeChangeInterceptor`，它允许使用一个简单的请求参数在每个请求上更改主题。

#### 1.1.12.多部分旋转变压器

[WebFlux](web-reactive.html#webflux-multipart)

来自`org.springframework.web.multipart`包的`MultipartResolver`是一种解析包括文件上传在内的多部分请求的策略。存在一种基于[Commons 文件上传](https://commons.apache.org/proper/commons-fileupload)的实现方式和另一种基于 Servlet 3.0 的多部分请求解析的实现方式。

要启用多部分处理，你需要在你的`DispatcherServlet` Bean 配置中声明一个名为`multipartResolver`的`MultipartResolver` Bean 配置。`DispatcherServlet`检测到它并将其应用于传入请求。当接收到内容类型为`multipart/form-data`的帖子时，解析器将当前`HttpServletRequest`的内容包装解析为`MultipartHttpServletRequest`，以提供对已解析文件的访问，此外还将部分作为请求参数公开。

##### Apache Commons`FileUpload`

要使用 Apache Commons`FileUpload`，你可以配置类型为`CommonsMultipartResolver`的 Bean，名称为`multipartResolver`。你还需要将`commons-fileupload` jar 作为 Classpath 的依赖项。

这个解析器变体将委托给应用程序中的一个本地库，从而在 Servlet 容器中提供了最大的可移植性。作为一种替代方案，考虑通过容器自己的解析器实现标准的 Servlet 多部分解析，如下所述。

|   |Commons FileUpload 传统上只适用于 POST 请求，但接受任何`multipart/`内容类型。有关详细信息和配置选项，请参见[`CommonsMultipartResolver`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/multipart/commons/commonsmultipartresolver.html）爪哇doc。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

##### Servlet 3.0

Servlet 3.0 需要通过 Servlet 容器配置来启用多部分解析。这样做：

* 在 爪哇 中，在 Servlet 注册上设置`MultipartConfigElement`。

* 在`web.xml`中，在 Servlet 声明中添加`"<multipart-config>"`部分。

下面的示例显示了如何在 Servlet 注册上设置`MultipartConfigElement`:

爪哇

```
public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    // ...

    @Override
    protected void customizeRegistration(ServletRegistration.Dynamic registration) {

        // Optionally also set maxFileSize, maxRequestSize, fileSizeThreshold
        registration.setMultipartConfig(new MultipartConfigElement("/tmp"));
    }

}
```

Kotlin

```
class AppInitializer : AbstractAnnotationConfigDispatcherServletInitializer() {

    // ...

    override fun customizeRegistration(registration: ServletRegistration.Dynamic) {

        // Optionally also set maxFileSize, maxRequestSize, fileSizeThreshold
        registration.setMultipartConfig(MultipartConfigElement("/tmp"))
    }

}
```

一旦 Servlet 3.0 配置到位，就可以添加 Bean 类型的`StandardServletMultipartResolver`，其名称为`multipartResolver`。

|   |这个解析器变体按原样使用 Servlet 容器的多部分解析器，<br/>可能会使应用程序暴露于容器实现的差异中。<br/>默认情况下，它将尝试使用任何 HTTP`multipart/`方法解析任何<br/>内容类型，但这可能不会在所有 Servlet 容器中得到支持。有关详细信息和配置选项，请参见[`StandardServletMultipartResolver`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/multipart/support/standardservletmultipartresolver.html）爪哇doc。|
|---| |

#### 1.1.13.伐木

[WebFlux](web-reactive.html#webflux-logging)

Spring MVC 中的调试级日志被设计为紧凑、最小且对人友好的。它关注的是一次又一次有用的高价值信息，而不是仅在调试特定问题时有用的其他信息。

跟踪级日志记录通常遵循与调试相同的原则（例如，也不应该是消防水龙带），但可以用于调试任何问题。此外，一些日志消息在跟踪和调试时可能会显示不同级别的详细信息。

良好的日志记录来自于使用日志的经验。如果你发现任何不符合规定的目标，请告诉我们。

##### 敏感数据

[WebFlux](web-reactive.html#webflux-logging-sensitive-data)

调试和跟踪日志记录可能会记录敏感信息。这就是为什么请求参数和头在默认情况下被屏蔽，并且必须通过`DispatcherServlet`上的`enableLoggingRequestDetails`属性显式地启用它们的完整日志记录。

下面的示例展示了如何通过使用 爪哇 配置来实现这一点：

爪哇

```
public class MyInitializer
        extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return ... ;
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return ... ;
    }

    @Override
    protected String[] getServletMappings() {
        return ... ;
    }

    @Override
    protected void customizeRegistration(ServletRegistration.Dynamic registration) {
        registration.setInitParameter("enableLoggingRequestDetails", "true");
    }

}
```

Kotlin

```
class MyInitializer : AbstractAnnotationConfigDispatcherServletInitializer() {

    override fun getRootConfigClasses(): Array<Class<*>>? {
        return ...
    }

    override fun getServletConfigClasses(): Array<Class<*>>? {
        return ...
    }

    override fun getServletMappings(): Array<String> {
        return ...
    }

    override fun customizeRegistration(registration: ServletRegistration.Dynamic) {
        registration.setInitParameter("enableLoggingRequestDetails", "true")
    }
}
```

### 1.2.过滤器

[WebFlux](web-reactive.html#webflux-filters)

`spring-web`模块提供了一些有用的过滤器：

* [Form Data](#filters-http-put)

* [转发头](#filters-forwarded-headers)

* [浅层 ETAG](#filters-shallow-etag)

* [CORS](#filters-cors)

#### 1.2.1.表单数据

浏览器只能通过 HTTP GET 或 HTTP POST 提交表单数据，但非浏览器客户端也可以使用 HTTP PUT、补丁和 DELETE。 Servlet API 要求`ServletRequest.getParameter*()`方法只支持用于 HTTP POST 的表单字段访问。

`spring-web`模块提供`FormContentFilter`来拦截内容类型为`application/x-www-form-urlencoded`的 HTTP PUT、修补和删除请求，从请求的主体中读取表单数据，并包装`ServletRequest`以使表单数据通过`ServletRequest.getParameter*()`系列方法可用。

#### 1.2.2.转发头

[WebFlux](web-reactive.html#webflux-forwarded-headers)

当请求通过代理（例如负载均衡器）时，主机、端口和方案可能会发生变化，这使得创建从客户端角度指向正确的主机、端口和方案的链接成为一个挑战。

[RFC 7239](https://tools.ietf.org/html/rfc7239)定义了`Forwarded`HTTP 报头，代理可以使用该报头来提供有关原始请求的信息。还有其他非标准标题，包括`X-Forwarded-Host`，`X-Forwarded-Port`，`X-Forwarded-Proto`，`X-Forwarded-Ssl`，和`X-Forwarded-Prefix`。

`ForwardedHeaderFilter`是一个 Servlet 过滤器，它修改请求，以便 a）基于`Forwarded`头来更改主机、端口和方案，以及 b）删除那些头来消除进一步的影响。过滤器依赖于包装请求，因此它必须在其他过滤器（例如`RequestContextFilter`）之前进行排序，这些过滤器应该与修改后的请求（而不是原始请求）一起工作。

转发头的安全性需要考虑，因为应用程序不能知道头是由代理添加的，还是由恶意客户机添加的。这就是为什么在信任边界上的代理应该被配置为删除来自外部的不受信任的`Forwarded`头。你还可以将`ForwardedHeaderFilter`配置为`removeOnly=true`，在这种情况下，它会删除但不使用头。

为了支持[异步请求](#mvc-ann-async)和错误分派，这个过滤器应该映射为`DispatcherType.ASYNC`和`DispatcherType.ERROR`。如果使用 Spring Framework 的`AbstractAnnotationConfigDispatcherServletInitializer`（请参见[Servlet Config](#mvc-container-config)），所有过滤器都会自动为所有分派类型注册。但是，如果通过`web.xml`或在 Spring 引导中通过`FilterRegistrationBean`注册过滤器，请确保除`DispatcherType.ASYNC`和`DispatcherType.ERROR`外还包括`DispatcherType.REQUEST`。

#### 1.2.3.浅层 ETAG

`ShallowEtagHeaderFilter`过滤器通过缓存写到响应的内容并从中计算 MD5 散列来创建一个“浅”ETag。下一次客户端发送时，它也会执行相同的操作，但是它也会将计算的值与`If-None-Match`请求头进行比较，如果两者相等，则返回 304（不是 \_modified）。

这种策略节省了网络带宽，但不节省 CPU，因为必须为每个请求计算完整的响应。前面描述的控制器级别的其他策略可以避免计算。见[HTTP 缓存](#mvc-caching)。

这个过滤器有一个`writeWeakETag`参数，该参数将过滤器配置为写入类似于以下内容的弱 ETags:`W/"02a2d595e6ed9a0b24f027f2b63b134d6"`（在[RFC7232 第 2.3 节](https://tools.ietf.org/html/rfc7232#section-2.3)中定义）。

为了支持[异步请求](#mvc-ann-async)，这个过滤器必须与`DispatcherType.ASYNC`映射，这样过滤器就可以延迟并成功地生成一个 ETag 到最后一个异步调度的结束。如果使用 Spring Framework 的`AbstractAnnotationConfigDispatcherServletInitializer`（请参见[Servlet Config](#mvc-container-config)），所有过滤器都会自动为所有分派类型注册。但是，如果通过`web.xml`或在 Spring 引导中通过`FilterRegistrationBean`注册过滤器，请确保包含`DispatcherType.ASYNC`。

#### 1.2.4.科尔斯

[WebFlux](web-reactive.html#webflux-filters-cors)

Spring MVC 通过控制器上的注释为 CORS 配置提供了细粒度的支持。然而，当与 Spring Security 一起使用时，我们建议依赖于内置的`CorsFilter`，这必须在 Spring Security 的过滤器链之前订购。

有关更多详细信息，请参见[CORS](#mvc-cors)和[CORS 过滤器](#mvc-cors-filter)部分。

### 1.3.带注释的控制器

[WebFlux](web-reactive.html#webflux-controller)

Spring MVC 提供了一种基于注释的编程模型，其中`@Controller`和`@RestController`组件使用注释来表示请求映射、请求输入、异常处理等。带注释的控制器具有灵活的方法签名，不需要扩展基类，也不需要实现特定的接口。下面的示例显示了由注释定义的控制器：

爪哇

```
@Controller
public class HelloController {

    @GetMapping("/hello")
    public String handle(Model model) {
        model.addAttribute("message", "Hello World!");
        return "index";
    }
}
```

Kotlin

```
import org.springframework.ui.set

@Controller
class HelloController {

    @GetMapping("/hello")
    fun handle(model: Model): String {
        model["message"] = "Hello World!"
        return "index"
    }
}
```

在前面的示例中，该方法接受`Model`并以`String`的形式返回视图名称，但是存在许多其他选项，并在本章后面进行解释。

|   |[spring.io](https://spring.io/guides)上的指南和教程使用本节中描述的基于注释的<br/>编程模型。|
|---|---------------------------------------------------------------------------------------------------------------------------------------|

#### 1.3.1.声明

[WebFlux](web-reactive.html#webflux-ann-controller)

你可以使用 Servlet 的`WebApplicationContext`中的标准 Spring  Bean 定义来定义控制器 bean。该原型允许自动检测，与 Spring 用于检测 Classpath 中的类的通用支持保持一致并为它们自动注册 Bean 定义。它还充当带注释的类的原型，指示其作为 Web 组件的角色。

要启用对此类`@Controller`bean 的自动检测，可以将组件扫描添加到 爪哇 配置中，如下例所示：

爪哇

```
@Configuration
@ComponentScan("org.example.web")
public class WebConfig {

    // ...
}
```

Kotlin

```
@Configuration
@ComponentScan("org.example.web")
class WebConfig {

    // ...
}
```

下面的示例展示了与前面示例类似的 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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="org.example.web"/>

    <!-- ... -->

</beans>
```

`@RestController`是一个[组合注释](core.html#beans-meta-annotations)，它本身用`@Controller`和`@ResponseBody`进行了元注释，以指示控制器，其每个方法都继承了类型级`@ResponseBody`注释，因此，直接写到响应主体与视图解析之间，并使用 HTML 模板进行呈现。

##### AOP 代理

在某些情况下，你可能需要在运行时使用 AOP 代理来装饰控制器。一个例子是，如果你选择在控制器上直接使用`@Transactional`注释。在这种情况下，特别是对于控制器，我们建议使用基于类的代理。这通常是控制器的默认选择。但是，如果控制器必须实现不是 Spring 上下文回调的接口（例如`InitializingBean`、`*Aware`等），则可能需要显式地配置基于类的代理。例如，使用`<tx:annotation-driven/>`可以更改为`<tx:annotation-driven proxy-target-class="true"/>`，使用`@EnableTransactionManagement`可以更改为`@EnableTransactionManagement(proxyTargetClass = true)`。

#### 1.3.2.请求映射

[WebFlux](web-reactive.html#webflux-ann-requestmapping)

可以使用`@RequestMapping`注释将请求映射到控制器方法。它具有各种属性，可以通过 URL、HTTP 方法、请求参数、标头和媒体类型进行匹配。你可以在类级别上使用它来表示共享映射，或者在方法级别上使用它来缩小到特定的端点映射。

还有`@RequestMapping`的特定于 HTTP 方法的快捷方式变体：

* `@GetMapping`

* `@PostMapping`

* `@PutMapping`

* `@DeleteMapping`

* `@PatchMapping`

提供的快捷方式是[自定义注释](#mvc-ann-requestmapping-composed)，因为可以说，大多数控制器方法都应该映射到特定的 HTTP 方法，而不是使用`@RequestMapping`，后者默认情况下与所有 HTTP 方法匹配。在类级别上仍然需要一个`@RequestMapping`来表示共享映射。

下面的示例具有类型和方法级别的映射：

爪哇

```
@RestController
@RequestMapping("/persons")
class PersonController {

    @GetMapping("/{id}")
    public Person getPerson(@PathVariable Long id) {
        // ...
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public void add(@RequestBody Person person) {
        // ...
    }
}
```

Kotlin

```
@RestController
@RequestMapping("/persons")
class PersonController {

    @GetMapping("/{id}")
    fun getPerson(@PathVariable id: Long): Person {
        // ...
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    fun add(@RequestBody person: Person) {
        // ...
    }
}
```

##### URI 模式

[WebFlux](web-reactive.html#webflux-ann-requestmapping-uri-templates)

`@RequestMapping`方法可以使用 URL 模式进行映射。有两种选择：

* `PathPattern`——与 URL 路径匹配的预解析模式也预解析为`PathContainer`。该解决方案是为网络应用而设计的，能够有效地处理编码和路径参数，并能有效地进行匹配。

* `{varName:regex}`—将字符串模式与字符串路径匹配。这也是在 Spring 配置中使用的原始解决方案，用于在 Classpath、文件系统上和其他位置上选择资源。它的效率较低，并且字符串路径输入对于有效地处理编码和 URL 的其他问题是一个挑战。

`PathPattern`是 Web 应用程序的推荐解决方案，也是 Spring WebFlux 中的唯一选择。在版本 5.3 之前，`AntPathMatcher`是 Spring MVC 中的唯一选择，并且仍然是默认的。但是`PathPattern`可以在[MVC config](#mvc-config-path-matching)中启用。

`PathPattern`支持与`AntPathMatcher`相同的模式语法。此外，它还支持捕获模式，例如`{*spring}`，用于在路径的末端匹配 0 个或更多个路径段。`PathPattern`还限制了`**`用于匹配多个路径段的使用，因此只允许在模式的末尾使用。在为给定的请求选择最佳匹配模式时，这消除了许多模棱两可的情况。有关完整模式语法，请参阅[路径模式](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/web/util/pattern/PathPattern.html)和[Antpathmatcher](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/util/AntPathMatcher.html)。

一些示例模式：

* `"/resources/ima?e.png"`-匹配路径段中的一个字符

* `"/resources/*.png"`-匹配路径段中的零个或多个字符

* `"/resources/**"`-匹配多个路径段

* `"/projects/{project}/versions"`-匹配路径段并将其捕获为变量

* `"/projects/{project:[a-z]+}/versions"`-匹配并捕获带有正则表达式的变量

捕获的 URI 变量可以通过`@PathVariable`访问。例如：

Java

```
@GetMapping("/owners/{ownerId}/pets/{petId}")
public Pet findPet(@PathVariable Long ownerId, @PathVariable Long petId) {
    // ...
}
```

Kotlin

```
@GetMapping("/owners/{ownerId}/pets/{petId}")
fun findPet(@PathVariable ownerId: Long, @PathVariable petId: Long): Pet {
    // ...
}
```

可以在类和方法级别声明 URI 变量，如下例所示：

Java

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

    @GetMapping("/pets/{petId}")
    public Pet findPet(@PathVariable Long ownerId, @PathVariable Long petId) {
        // ...
    }
}
```

Kotlin

```
@Controller
@RequestMapping("/owners/{ownerId}")
class OwnerController {

    @GetMapping("/pets/{petId}")
    fun findPet(@PathVariable ownerId: Long, @PathVariable petId: Long): Pet {
        // ...
    }
}
```

URI 变量将自动转换为适当的类型，或者生成`TypeMismatchException`。默认情况下支持简单类型（`int`，`long`，`Date`，等等），你可以注册对任何其他数据类型的支持。参见[类型转换](#mvc-ann-typeconversion)和[`DataBinder`]。

你可以显式地命名 URI 变量（例如，`@PathVariable("customId")`），但是如果名称相同，并且你的代码是使用调试信息或 Java8 上的`-parameters`编译器标志编译的，则可以忽略该详细信息。

语法`{varName:regex}`声明一个 URI 变量，其正则表达式的语法为`{varName:regex}`。例如，给定的 URL`"/spring-web-3.0.5.jar"`，下面的方法会提取名称、版本和文件扩展名：

Java

```
@GetMapping("/{name:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{ext:\\.[a-z]+}")
public void handle(@PathVariable String name, @PathVariable String version, @PathVariable String ext) {
    // ...
}
```

Kotlin

```
@GetMapping("/{name:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{ext:\\.[a-z]+}")
fun handle(@PathVariable name: String, @PathVariable version: String, @PathVariable ext: String) {
    // ...
}
```

URI 路径模式还可以嵌入`${…​}`占位符，这些占位符在启动时通过针对本地、系统、环境和其他属性源使用`PropertyPlaceHolderConfigurer`进行解析。例如，你可以使用它来基于某些外部配置参数化基本 URL。

##### 模式比较

[WebFlux](web-reactive.html#webflux-ann-requestmapping-pattern-comparison)

当多个模式匹配一个 URL 时，必须选择最佳匹配。根据解析的`PathPattern`的使用是否被启用，可以使用以下方法之一来完成此操作：

* [`PathPattern.SPECIFICITY_COMPARATOR`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/util/pattern/pathpattern.html#specificity_comparator）

* [`AntPathMatcher.getPatternComparator(String path)`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/util/antpathmatcher.html#getpatterncomparator-java.lang.string-）

这两种方法都有助于在顶部使用更具体的模式对模式进行排序。如果一个模式的 URI 变量（计为 1）、单通配符（计为 1）和双通配符（计为 2）的数量较少，那么它就不那么具体。给定一个相等的分数，选择较长的模式。在相同的分数和长度下，将选择 URI 变量多于通配符的模式。

默认的映射模式（`/**`）被排除在评分之外，并且总是排在最后。另外，前缀模式（如`/public/**`）被认为不如其他没有双通配符的模式具体。

有关详细信息，请按照上面的链接查看模式比较器。

##### 后缀匹配

从 5.3 开始，默认情况下 Spring MVC 不再执行`.*`后缀模式匹配，其中映射到`/person`的控制器也隐式映射到`/person.*`。因此，路径扩展不再用于解释响应所请求的内容类型——例如，`/person.pdf`，`/person.xml`，以此类推。

在浏览器发送`Accept`头文件时，以这种方式使用文件扩展名是必要的，因为这种头文件很难一致地进行解释。目前，这已不再是必要的，使用`Accept`头应该是首选的选择。

随着时间的推移，文件扩展名的使用在很多方面都被证明是有问题的。当使用 URI 变量、路径参数和 URI 编码时，它可能会造成歧义。关于基于 URL 的授权和安全性的推理（更多详细信息请参见下一节）也变得更加困难。

要在 5.3 之前的版本中完全禁用路径扩展的使用，请设置以下内容：

* `useSuffixPatternMatching(false)`，见[路径匹配配置器](#mvc-config-path-matching)

* `favorPathExtension(false)`，见[内容协商配置器](#mvc-config-content-negotiation)

有一种方法来请求内容类型，而不是通过`HttpServletRequest#getUserPrincipal`头仍然是有用的，例如，当在浏览器中输入 URL 时。路径扩展的一种安全替代方法是使用查询参数策略。如果必须使用文件扩展名，请考虑通过[内容协商配置器](#mvc-config-content-negotiation)的`mediaTypes`属性将它们限制为显式注册的扩展名列表。

##### 后缀匹配和 RFD

反射文件下载攻击类似于 XSS，因为它依赖于响应中反映的请求输入（例如，查询参数和 URI 变量）。然而，RFD 攻击不是将 JavaScript 插入 HTML，而是依靠浏览器切换来执行下载，并在稍后双击时将响应视为可执行脚本。

Spring MVC 中，`@ResponseBody`和`ResponseEntity`方法存在风险，因为它们可以呈现不同的内容类型，客户端可以通过 URL 路径扩展来请求这些内容类型。禁用后缀模式匹配和使用路径扩展进行内容协商降低了风险，但不足以防止 RFD 攻击。

为了防止 RFD 攻击，在呈现响应体之前， Spring MVC 添加了一个`Content-Disposition:inline;filename=f.txt`头，以建议一个固定且安全的下载文件。只有当 URL 路径包含一个文件扩展名，而该文件扩展名既不被允许为安全的，也没有显式地注册用于内容协商时，才会执行此操作。然而，当 URL 被直接输入到浏览器中时，它可能会产生副作用。

默认情况下，许多常见的路径扩展都是安全的。具有自定义`HttpMessageConverter`实现的应用程序可以显式地注册用于内容协商的文件扩展名，以避免为这些扩展名添加`Content-Disposition`头。见[内容类型](#mvc-config-content-negotiation)。

有关 RFD 的其他建议，请参见[CVE-2015-5211](https://pivotal.io/security/cve-2015-5211)。

##### 可消费媒体类型

[WebFlux](web-reactive.html#webflux-ann-requestmapping-consumes)

你可以基于请求的`Content-Type`缩小请求映射范围，如下例所示：

Java

```
@PostMapping(path = "/pets", consumes = "application/json") (1)
public void addPet(@RequestBody Pet pet) {
    // ...
}
```

|**1**|使用`consumes`属性通过内容类型缩小映射范围。|
|-----|-----------------------------------------------------------------------|

Kotlin

```
@PostMapping("/pets", consumes = ["application/json"]) (1)
fun addPet(@RequestBody pet: Pet) {
    // ...
}
```

|**1**|使用`consumes`属性通过内容类型缩小映射范围。|
|-----|-----------------------------------------------------------------------|

`consumes`属性还支持否定表达式——例如，`!text/plain`表示除`text/plain`以外的任何内容类型。

你可以在类级别声明一个共享的`consumes`属性。然而，与大多数其他请求映射属性不同的是，当在类级别使用时，方法级别`consumes`属性覆盖而不是扩展类级声明。

|   |`MediaType`为常用的媒体类型提供常量，例如`APPLICATION_JSON_VALUE`和`APPLICATION_XML_VALUE`。|
|---|--------------------------------------------------------------------------------------------------------------------------|

##### 可生产媒体类型

[WebFlux](web-reactive.html#webflux-ann-requestmapping-produces)

你可以基于`Accept`请求头和控制器方法产生的内容类型列表来缩小请求映射的范围，如下例所示：

Java

```
@GetMapping(path = "/pets/{petId}", produces = "application/json") (1)
@ResponseBody
public Pet getPet(@PathVariable String petId) {
    // ...
}
```

|**1**|使用`produces`属性通过内容类型缩小映射范围。|
|-----|-----------------------------------------------------------------------|

Kotlin

```
@GetMapping("/pets/{petId}", produces = ["application/json"]) (1)
@ResponseBody
fun getPet(@PathVariable petId: String): Pet {
    // ...
}
```

|**1**|使用`produces`属性通过内容类型缩小映射范围。|
|-----|-----------------------------------------------------------------------|

媒体类型可以指定字符集。支持否定表达式——例如，`!text/plain`表示除“text/plain”以外的任何内容类型。

你可以在类级别声明一个共享的`produces`属性。然而，与大多数其他请求映射属性不同的是，当在类级别使用时，方法级别`removeSemicolonContent=false`属性覆盖而不是扩展类级声明。

|   |`MediaType`为常用的媒体类型提供常量，例如`APPLICATION_JSON_VALUE`和`APPLICATION_XML_VALUE`。|
|---|--------------------------------------------------------------------------------------------------------------------------|

##### 参数、标头

[WebFlux](web-reactive.html#webflux-ann-requestmapping-params-and-headers)

你可以根据请求参数条件缩小请求映射的范围。你可以测试是否存在请求参数（`myParam`），是否没有请求参数（`!myParam`），或者是否存在特定值（[内容类型](#mvc-config-content-negotiation)）。下面的示例展示了如何测试一个特定值：

Java

```
@GetMapping(path = "/pets/{petId}", params = "myParam=myValue") (1)
public void findPet(@PathVariable String petId) {
    // ...
}
```

|**1**|测试`myParam`是否等于`myValue`。|
|-----|-------------------------------------------|

Kotlin

```
@GetMapping("/pets/{petId}", params = ["myParam=myValue"]) (1)
fun findPet(@PathVariable petId: String) {
    // ...
}
```

|**1**|测试`myParam`是否等于`myValue`。|
|-----|-------------------------------------------|

你也可以在请求头条件中使用相同的方法，如下例所示：

Java

```
@GetMapping(path = "/pets", headers = "myHeader=myValue") (1)
public void findPet(@PathVariable String petId) {
    // ...
}
```

|**1**|测试`myHeader`是否等于`myValue`。|
|-----|--------------------------------------------|

Kotlin

```
@GetMapping("/pets", headers = ["myHeader=myValue"]) (1)
fun findPet(@PathVariable petId: String) {
    // ...
}
```

|   |你可以将`Content-Type`和`Accept`与 headers 条件匹配，但最好使用[consumes](#mvc-ann-requestmapping-consumes)和[produces](#mvc-ann-requestmapping-produces)。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

##### HTTP 头，选项

[WebFlux](web-reactive.html#webflux-ann-requestmapping-head-options)

`@GetMapping`（和`@RequestMapping(method=HttpMethod.GET)`）透明地支持用于请求映射的 HTTP head。控制器的方法不需要更改。在`javax.servlet.http.HttpServlet`中应用的响应包装程序确保将`Content-Length`头设置为写入的字节数（而不实际写入响应）。

`@GetMapping`（和`@RequestMapping(method=HttpMethod.GET)`）隐式映射到并支持 HTTPHEAD。HTTP head 请求的处理方式就像 HTTP GET 一样，除了不写正文，而是计算字节数并设置`Content-Length`头。

默认情况下，HTTP 选项是通过将`Allow`响应头设置为具有匹配的 URL 模式的所有`@RequestMapping`方法中列出的 HTTP 方法列表来处理的。

对于不带 HTTP 方法声明的`@RequestMapping`，`Allow`头被设置为`@RequestMapping`。控制器方法应该总是声明支持的 HTTP 方法（例如，通过使用 HTTP 方法特定的变体：`@GetMapping`，`@PostMapping`，以及其他）。

你可以显式地将`@RequestMapping`方法映射到 HTTPHead 和 HTTPOptions，但在常见的情况下，这是不必要的。

##### 自定义注释

[WebFlux](web-reactive.html#mvc-ann-requestmapping-head-options)

Spring MVC 支持使用[组合注释](core.html#beans-meta-annotations)进行请求映射。这些注释本身是用`@RequestMapping`进行元注释的，并且是为了重新声明`@RequestMapping`属性的子集（或全部）而组成的，具有更窄、更具体的目的。

`@GetMapping`，`@PostMapping`，`@PutMapping`，`@DeleteMapping`和`@PatchMapping`是复合注释的例子。提供它们是因为，可以说，大多数控制器方法都应该映射到特定的 HTTP 方法，而不是使用`@RequestMapping`，后者默认情况下与所有 HTTP 方法匹配。如果你需要一个组合注释的示例，请查看这些注释是如何声明的。

Spring MVC 还支持具有自定义请求匹配逻辑的自定义请求映射属性。这是一个更高级的选项，它需要子类化`RequestMappingHandlerMapping`并覆盖`getCustomMethodCondition`方法，在该方法中，你可以检查自定义属性并返回你自己的`RequestCondition`。

##### 显式注册

[WebFlux](web-reactive.html#webflux-ann-requestmapping-registration)

你可以以编程方式注册处理程序方法，你可以将其用于动态注册或高级情况，例如同一处理程序在不同 URL 下的不同实例。下面的示例注册了一个处理程序方法：

Java

```
@Configuration
public class MyConfig {

    @Autowired
    public void setHandlerMapping(RequestMappingHandlerMapping mapping, UserHandler handler) (1)
            throws NoSuchMethodException {

        RequestMappingInfo info = RequestMappingInfo
                .paths("/user/{id}").methods(RequestMethod.GET).build(); (2)

        Method method = UserHandler.class.getMethod("getUser", Long.class); (3)

        mapping.registerMapping(info, handler, method); (4)
    }
}
```

|**1**|为控制器注入目标处理程序和处理程序映射。|
|-----|------------------------------------------------------------------|
|**2**|准备请求映射元数据。|
|**3**|获取 handler 方法。|
|**4**|添加注册。|

Kotlin

```
@Configuration
class MyConfig {

    @Autowired
    fun setHandlerMapping(mapping: RequestMappingHandlerMapping, handler: UserHandler) { (1)
        val info = RequestMappingInfo.paths("/user/{id}").methods(RequestMethod.GET).build() (2)
        val method = UserHandler::class.java.getMethod("getUser", Long::class.java) (3)
        mapping.registerMapping(info, handler, method) (4)
    }
}
```

|**1**|为控制器注入目标处理程序和处理程序映射。|
|-----|------------------------------------------------------------------|
|**2**|准备请求映射元数据。|
|**3**|获取 handler 方法。|
|**4**|添加注册。|

#### 1.3.3.处理程序方法

[WebFlux](web-reactive.html#webflux-ann-methods)

`@RequestMapping`处理程序方法具有灵活的签名，并且可以从受支持的控制器方法参数和返回值的范围中进行选择。

##### 方法参数

[WebFlux](web-reactive.html#webflux-ann-arguments)

下一个表描述了受支持的控制器方法参数。任何参数都不支持反应式类型。

JDK8 的`java.util.Optional`作为方法参数与具有`required`属性（例如，`@RequestParam`，`@RequestParam`，以及其他）并且与`required=false`等价的注释组合在一起，并被支持。

|                            Controller method argument                            |说明|
|----------------------------------------------------------------------------------| |
|                         `WebRequest`, `NativeWebRequest`                         |对请求参数以及请求和会话属性的通用访问，而不需要直接使用<br/>的 Servlet API。|
|         `javax.servlet.ServletRequest`, `javax.servlet.ServletResponse`          |选择任何特定的请求或响应类型——例如，`ServletRequest`，`HttpServletRequest`，<br/>或 Spring 的`ServletRequest`，`MultipartHttpServletRequest`。|
|                         `javax.servlet.http.HttpSession`                         |强制执行会话的存在。因此，这样的参数永远不是`null`。<br/>注意，会话访问不是线程安全的。考虑将`RequestMappingHandlerAdapter`实例的`synchronizeOnSession`标志设置为`true`，如果允许多个<br/>请求并发访问会话。|
|                         `javax.servlet.http.PushBuilder`                         |Servlet 4.0Push Builder API 用于程序化的 HTTP/2 资源推送。注意，根据 Servlet 规范，如果客户机不支持该 HTTP/2 功能，则注入的实例可以为空。|
|                            `java.security.Principal`                             |当前经过身份验证的用户——如果已知的话，可能是特定的`Principal`实现类。<br/><br/>注意，如果为了允许自定义解析器在通过`HttpServletRequest#getUserPrincipal`恢复默认解析之前对该参数进行注释，则该参数不会急于解析，例如，<br/>， Spring security`Principal`实现了`Principal`，并且将通过`HttpServletRequest#getUserPrincipal`这样注入，除非它也被注释为`@AuthenticationPrincipal`，在这种情况下，它`LocaleResolver`由自定义 Spring security resolver 通过`Authentication#getPrincipal`解析。|
|                                   `HttpMethod`                                   |请求的 HTTP 方法。|
|                                `java.util.Locale`                                |当前的请求区域设置，由最具体的`LocaleResolver`确定（在<br/>效果中，配置的`LocaleResolver`或`LocaleContextResolver`）。|
|                    `java.util.TimeZone` + `java.time.ZoneId`                     |与当前请求相关联的时区，由`LocaleContextResolver`确定。|
|                     `java.io.InputStream`, `java.io.Reader`                      |用于访问由 Servlet API 公开的原始请求主体。|
|                     `java.io.OutputStream`, `java.io.Writer`                     |用于访问由 Servlet API 公开的原始响应体。|
|                                 `@PathVariable`                                  |用于访问 URI 模板变量。见[URI 模式](#mvc-ann-requestmapping-uri-templates)。|
|                                `@MatrixVariable`                                 |用于访问 URI 路径段中的名称-值对。见<br/>。|
|                                 `@RequestParam`                                  |用于访问 Servlet 请求参数，包括多部分文件。参数值<br/>被转换为声明的方法参数类型。参见[`@RequestParam`]（#mvc-ann-requestparam）以及<br/>as[Multipart](#mvc-multipart-forms)。<br/><br/>注意，对于简单参数值，`@RequestParam`的使用是可选的。<br/>参见本表末尾的“任何其他参数”。|
|                                 `@RequestHeader`                                 |用于访问请求头。标头值被转换为声明的方法参数<br/>type。参见[`@RequestHeader`]。|
|                                  `@CookieValue`                                  |获取 cookie 的权限。Cookie 值被转换为声明的方法参数<br/>type。参见[`@CookieValue`]。|
|                                  `@RequestBody`                                  |用于访问 HTTP 请求主体。通过使用`HttpMessageConverter`实现，主体内容被转换为声明的方法<br/>参数类型。参见[`@RequestBody`]。|
|                                 `HttpEntity<B>`                                  |用于访问请求头和主体。体被转换为`HttpMessageConverter`。<br/>见[HttpEntity](#mvc-ann-httpentity)。|
|                                  `@RequestPart`                                  |为了访问`multipart/form-data`请求中的一个部件，将该部件的主体<br/>转换为`HttpMessageConverter`。见[Multipart](#mvc-multipart-forms)。|
|`java.util.Map`, `org.springframework.ui.Model`, `org.springframework.ui.ModelMap`|用于访问 HTML 控制器中使用的模型，并将其作为<br/>视图呈现的一部分暴露于模板中。|
|                               `RedirectAttributes`                               |指定在重定向情况下使用的属性（即要追加到查询<br/>字符串中）和要临时存储的 flash 属性，直到重定向后的请求。<br/>参见[重定向属性](#mvc-redirecting-passing-data)和[flash 属性](#mvc-flash-attributes)。|
|                                `@ModelAttribute`                                 |用于访问模型中的现有属性（如果不存在则实例化），并应用<br/>数据绑定和验证。参见[`@ModelAttribute`]（#mvc-ann-modelattrib-method-args）以及[Model](#mvc-ann-modelattrib-methods)和[`DataBinder`]（#mvc-ann-initbinder）。<br/><br/>注意，`@ModelAttribute`的使用是可选的（例如，设置其属性）。<br/>参见本表末尾的“任何其他参数”。|
|                            `Errors`, `BindingResult`                             |用于访问来自命令对象<br/>的验证和数据绑定的错误（即`@ModelAttribute`参数）或来自`@RequestBody`或`@RequestPart`参数的验证的错误。你必须在验证方法参数之后立即声明`Errors`或`BindingResult`参数<br/>。|
|                `SessionStatus` + class-level `@SessionAttributes`                |用于标记表单处理完成，这将触发清除通过类级`@SessionAttributes`注释声明的会话属性<br/>。有关更多详细信息，请参见[`@SessionAttributes`]。|
|                              `UriComponentsBuilder`                              |用于准备相对于当前请求的主机、端口、方案、上下文路径的 URL，以及 Servlet 映射的文字部分<br/>。见[URI Links](#mvc-uri-building)。|
|                               `@SessionAttribute`                                |对于任何会话属性的访问，与存储在会话<br/>中的模型属性形成对比的是类级别`@SessionAttributes`声明的结果。有关更多详细信息，请参见[`@SessionAttribute`]。|
|                               `@RequestAttribute`                                |用于访问请求属性。有关更多详细信息，请参见[`@RequestAttribute`]。|
|                                Any other argument                                |如果方法参数不匹配此表中的任何早期值，并且它是<br/>一个简单的类型（由[Beanutils#IsSimpleProperty](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-)确定，<br/>，则将其解析为`@RequestParam`。否则，它被解析为`@ModelAttribute`。|

##### 返回值

[WebFlux](web-reactive.html#webflux-ann-return-types)

下一个表描述了受支持的控制器方法的返回值。所有返回值都支持反应性类型。

|                                      Controller method return value                                       |说明|
|-----------------------------------------------------------------------------------------------------------| |
|                                              `@ResponseBody`                                              |返回值通过`HttpMessageConverter`实现进行转换，并写入<br/>响应。参见[`@ResponseBody`]。|
|                                   `HttpEntity<B>`, `ResponseEntity<B>`                                    |指定完整响应（包括 HTTP 头和主体）的返回值将通过`HttpMessageConverter`实现被转换<br/>并写入响应。<br/>参见[负责实体](#mvc-ann-responseentity)。|
|                                               `HttpHeaders`                                               |返回带有标题而没有正文的响应。|
|                                                 `String`                                                  |要用`ViewResolver`实现来解析的视图名称，并与隐式<br/>模型一起使用——通过命令对象和`@ModelAttribute`方法确定。处理程序<br/>方法还可以通过声明`Model`参数<br/>（参见[显式注册](#mvc-ann-requestmapping-registration)）以编程方式丰富模型。|
|                                                  `View`                                                   |通过命令对象和`@ModelAttribute`方法确定用于与隐式模型一起呈现的<br/>实例。处理程序方法还可以通过声明一个`Model`参数<br/>（参见`Model`）以编程方式丰富模型。|
|                              `java.util.Map`, `org.springframework.ui.Model`                              |要添加到隐式模型的属性，通过`RequestToViewNameTranslator`隐式确定视图名称<br/>。|
|                                             `@ModelAttribute`                                             |要添加到模型中的一个属性，其视图名称通过<br/>a`RequestToViewNameTranslator`隐式确定。<br/><br/>注意，`@ModelAttribute`是可选的。请参阅<br/>本表末尾的“任何其他返回值”。|
|                                           `ModelAndView` object                                           |要使用的视图和模型属性，以及可选的响应状态。|
|                                                  `void`                                                   |具有`void`返回类型（或`null`返回值）的方法被认为具有完全的<br/>处理响应，如果它还具有`ServletResponse`，`OutputStream`参数，或<br/>`@ResponseStatus`注释。如果控制器进行了正的`ETag`或`lastModified`时间戳检查（详见[控制器](#mvc-caching-etag-lastmodified)），也是如此。`ServletResponse`如果以上都不是真的，`void`返回类型还可以指示<br/>REST 控制器的“无响应主体”或 HTML 控制器的默认视图名称选择。|
|                                            `DeferredResult<V>`                                            |从任何线程异步生成前面的任何返回值——例如，作为某个事件或回调的结果<br/>。参见[异步请求](#mvc-ann-async)和[`DeferredResult`]。|
|                                               `Callable<V>`                                               |在 Spring MVC 管理的线程中异步地产生上述任一返回值。<br/>参见[异步请求](#mvc-ann-async)和[`Callable`]（#mvc-ann-async-callable）。|
|`ListenableFuture<V>`,`java.util.concurrent.CompletionStage<V>`,`java.util.concurrent.CompletableFuture<V>`|替代`DeferredResult`，作为一种方便（例如，当底层服务<br/>返回其中之一时）。|
|                                    `ResponseBodyEmitter`, `SseEmitter`                                    |用`MultiValueMap<String, String>`实现异步地发出对象流以写入响应。也支持作为`ResponseEntity`的主体。<br/>参见[异步请求](#mvc-ann-async)和[HTTP 流媒体](#mvc-ann-async-http-streaming)。|
|                                          `StreamingResponseBody`                                          |异步写入响应`OutputStream`。也支持作为`ResponseEntity`的主体。见[异步请求](#mvc-ann-async)和[HTTP 流媒体](#mvc-ann-async-http-streaming)。|
|               Reactive types — Reactor, RxJava, or others through `ReactiveAdapterRegistry`               |对于具有多值流的`DeferredResult`（例如，`Flux`，`Observable`）<br/>收集到`List`。<br/>用于流场景（例如，使用`text/event-stream`，`application/json+stream`和`ResponseBodyEmitter`，其中`SseEmitter`在 Spring MVC 管理的线程上执行阻塞 I/O，并且在每次写操作完成时施加背压<br/>。<br/><br/>参见[异步请求](#mvc-ann-async)和[反应类型](#mvc-ann-async-reactive-types)。|
|                                          Any other return value                                           |如果返回值与此表中的任何早期值不匹配，并且<br/>是`String`或`void`，则将其作为视图名处理（如果不是简单的类型，则通过`RequestToViewNameTranslator`进行默认视图名选择），由[Beanutils#IsSimpleProperty](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-)确定。<br/>是简单类型的值仍未解决。|

##### 类型转换

[WebFlux](web-reactive.html#webflux-ann-typeconversion)

一些表示`String`的基于请求输入的带注释的控制器方法参数（例如`@RequestParam`，`@RequestHeader`，`@PathVariable`，`@MatrixVariable`，以及`@CookieValue`）可以要求类型转换，如果参数被声明为`String`以外的内容。

对于这样的情况，类型转换是基于配置的转换器自动应用的。默认情况下，支持简单类型（`int`、`long`、`Date`等）。你可以通过`WebDataBinder`（参见[`DataBinder`]（#mvc-ann-initbinder））或通过使用`FormattingConversionService`注册`Formatters`来定制类型转换。见[Spring Field Formatting](core.html#format)。

类型转换中的一个实际问题是空字符串源值的处理。如果类型转换的结果是`null`，那么这样的值将被视为丢失。这可能是`Long`、`UUID`和其他目标类型的情况。如果要允许注入`null`，可以在参数注释上使用`required`标志，或者将参数声明为`@Nullable`。

|   |从 5.3 开始，即使在类型转换之后，也将强制执行非空参数。如果你的处理程序<br/>方法也打算接受空值，那么可以将参数声明为`@Nullable`，或者在相应的`@RequestParam`注释中将其标记为`required=false`。这是<br/>在 5.3 升级中遇到的回归的最佳实践和推荐解决方案。<br/><br/>或者，你可以具体地处理例如在所需[“old post”](https://www.w3.org/DesignIssues/MatrixURIs.html)的情况下产生的`@PathVariable`。转换后的空值将被处理为像<br/>一个空的原始值一样，因此相应的`Missing…​Exception`变量将被抛出。|
|---| |

##### 矩阵变量

[WebFlux](web-reactive.html#webflux-ann-matrix-variables)

[RFC 3986](https://tools.ietf.org/html/rfc3986#section-3.3)讨论路径段中的名称-值对。在 Spring MVC 中，我们将那些称为基于 Tim Berners-Lee 的[“old post”](https://www.w3.org/DesignIssues/MatrixURIs.html)的“矩阵变量”，但它们也可以称为 URI 路径参数。

矩阵变量可以出现在任何路径段中，每个变量用分号分隔，多个值用逗号分隔（例如，`/cars;color=red,green;year=2012`）。还可以通过重复的变量名指定多个值（例如，`@RequestParam`）。

如果一个 URL 预期包含矩阵变量，那么控制器方法的请求映射必须使用一个 URI 变量来掩盖该变量内容，并确保请求可以独立于矩阵变量的顺序和存在而成功匹配。下面的示例使用了一个矩阵变量：

Java

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

@GetMapping("/pets/{petId}")
public void findPet(@PathVariable String petId, @MatrixVariable int q) {

    // petId == 42
    // q == 11
}
```

Kotlin

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

@GetMapping("/pets/{petId}")
fun findPet(@PathVariable petId: String, @MatrixVariable q: Int) {

    // petId == 42
    // q == 11
}
```

考虑到所有的路径段都可能包含矩阵变量，你有时可能需要消除矩阵变量预期在哪个路径变量中的歧义。下面的示例展示了如何做到这一点：

Java

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

@GetMapping("/owners/{ownerId}/pets/{petId}")
public void findPet(
        @MatrixVariable(name="q", pathVar="ownerId") int q1,
        @MatrixVariable(name="q", pathVar="petId") int q2) {

    // q1 == 11
    // q2 == 22
}
```

Kotlin

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

@GetMapping("/owners/{ownerId}/pets/{petId}")
fun findPet(
        @MatrixVariable(name = "q", pathVar = "ownerId") q1: Int,
        @MatrixVariable(name = "q", pathVar = "petId") q2: Int) {

    // q1 == 11
    // q2 == 22
}
```

矩阵变量可以定义为可选的，并指定默认值，如下例所示：

Java

```
// GET /pets/42

@GetMapping("/pets/{petId}")
public void findPet(@MatrixVariable(required=false, defaultValue="1") int q) {

    // q == 1
}
```

Kotlin

```
// GET /pets/42

@GetMapping("/pets/{petId}")
fun findPet(@MatrixVariable(required = false, defaultValue = "1") q: Int) {

    // q == 1
}
```

要获得所有矩阵变量，可以使用`MultiValueMap`，如下例所示：

Java

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

@GetMapping("/owners/{ownerId}/pets/{petId}")
public void findPet(
        @MatrixVariable MultiValueMap<String, String> matrixVars,
        @MatrixVariable(pathVar="petId") MultiValueMap<String, String> petMatrixVars) {

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

Kotlin

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

@GetMapping("/owners/{ownerId}/pets/{petId}")
fun findPet(
        @MatrixVariable matrixVars: MultiValueMap<String, String>,
        @MatrixVariable(pathVar="petId") petMatrixVars: MultiValueMap<String, String>) {

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

请注意，你需要启用矩阵变量的使用。在 MVC Java 配置中，你需要通过[路径匹配](#mvc-config-path-matching)设置`UrlPathHelper`和`removeSemicolonContent=false`。在 MVC XML 命名空间中，可以设置`<mvc:annotation-driven enable-matrix-variables="true"/>`。

##### `@RequestParam`

[WebFlux](web-reactive.html#webflux-ann-requestparam)

可以使用`@RequestParam`注释将 Servlet 请求参数（即查询参数或表单数据）绑定到控制器中的方法参数。

下面的示例展示了如何做到这一点：

Java

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

    // ...

    @GetMapping
    public String setupForm(@RequestParam("petId") int petId, Model model) { (1)
        Pet pet = this.clinic.loadPet(petId);
        model.addAttribute("pet", pet);
        return "petForm";
    }

    // ...

}
```

|**1**|使用`@RequestParam`绑定`petId`。|
|-----|--------------------------------------|

Kotlin

```
import org.springframework.ui.set

@Controller
@RequestMapping("/pets")
class EditPetForm {

    // ...

    @GetMapping
    fun setupForm(@RequestParam("petId") petId: Int, model: Model): String { (1)
        val pet = this.clinic.loadPet(petId);
        model["pet"] = pet
        return "petForm"
    }

    // ...

}
```

|**1**|使用`@RequestParam`绑定`petId`。|
|-----|--------------------------------------|

默认情况下，使用该注释的方法参数是必需的，但是你可以通过将`@RequestParam`注释的`required`标志设置为`false`或使用`java.util.Optional`包装器声明参数来指定方法参数是可选的。

如果目标方法参数类型不是`String`，则自动应用类型转换。见[类型转换](#mvc-ann-typeconversion)。

将参数类型声明为数组或列表，可以为相同的参数名称解析多个参数值。

当`@RequestParam`注释被声明为`Map<String, String>`或`MultiValueMap<String, String>`时，如果注释中没有指定参数名称，那么映射将被填充为每个给定参数名称的请求参数值。

请注意，`@RequestParam`的使用是可选的（例如，用于设置其属性）。默认情况下，任何参数是一个简单的值类型（由[Beanutils#IsSimpleProperty](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-)确定）且不是由任何其他参数解析器解析的，都将被视为用`@RequestParam`进行了注释。

##### `@RequestHeader`

[WebFlux](web-reactive.html#webflux-ann-requestheader)

可以使用`ResponseEntity`注释将请求头绑定到控制器中的方法参数。

考虑以下带有标题的请求：

```
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`标题的值：

Java

```
@GetMapping("/demo")
public void handle(
        @RequestHeader("Accept-Encoding") String encoding, (1)
        @RequestHeader("Keep-Alive") long keepAlive) { (2)
    //...
}
```

|**1**|获取`Accept-Encoding`标头的值。|
|-----|----------------------------------------------|
|**2**|获取`Keep-Alive`标头的值。|

Kotlin

```
@GetMapping("/demo")
fun handle(
        @RequestHeader("Accept-Encoding") encoding: String, (1)
        @RequestHeader("Keep-Alive") keepAlive: Long) { (2)
    //...
}
```

|**1**|获取`Accept-Encoding`标头的值。|
|-----|----------------------------------------------|
|**2**|获取`Keep-Alive`标头的值。|

如果目标方法参数类型不是`String`，则自动应用类型转换。见[类型转换](#mvc-ann-typeconversion)。

当在`@RequestHeader`、`MultiValueMap<String, String>`或`HttpHeaders`参数上使用`@RequestHeader`注释时，映射将填充所有头值。

|   |内置支持用于将逗号分隔的字符串转换为<br/>数组或字符串集合或类型转换系统已知的其他类型。对于<br/>示例，用`@RequestHeader("Accept")`注释的方法参数可以是类型`String`但也可以是`String[]`或`List<String>`。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

##### `@CookieValue`

[WebFlux](web-reactive.html#webflux-ann-cookievalue)

可以使用`@CookieValue`注释将 HTTP cookie 的值绑定到控制器中的方法参数。

考虑使用以下 cookie 的请求：

```
JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84
```

下面的示例展示了如何获得 Cookie 值：

Java

```
@GetMapping("/demo")
public void handle(@CookieValue("JSESSIONID") String cookie) { (1)
    //...
}
```

|**1**|获取`JSESSIONID`cookie 的值。|
|-----|-----------------------------------------|

Kotlin

```
@GetMapping("/demo")
fun handle(@CookieValue("JSESSIONID") cookie: String) { (1)
    //...
}
```

|**1**|获取`JSESSIONID`cookie 的值。|
|-----|-----------------------------------------|

如果目标方法参数类型不是`String`，则自动应用类型转换。见[类型转换](#mvc-ann-typeconversion)。

##### `@ModelAttribute`

[WebFlux](web-reactive.html#webflux-ann-modelattrib-method-args)

你可以在方法参数上使用`@ModelAttribute`注释来访问模型中的一个属性，或者如果不存在该属性，则将其实例化。模型属性还覆盖了来自 HTTP Servlet 请求参数的值，这些参数的名称与字段名匹配。这被称为数据绑定，它使你不必处理解析和转换单个查询参数和窗体字段的问题。下面的示例展示了如何做到这一点：

爪哇

```
@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
public String processSubmit(@ModelAttribute Pet pet) {
    // method logic...
}
```

Kotlin

```
@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
fun processSubmit(@ModelAttribute pet: Pet): String {
    // method logic...
}
```

上面的`Pet`实例的来源如下：

* 从可能由[@ModelAttribute 方法](#mvc-ann-modelattrib-methods)添加的模型中检索。

* 如果模型属性在类级[`@SessionAttributes`]（#mvc-ann-sessionAttributes）注释中列出，则从 HTTP 会话中检索。

* 通过`Converter`获得，其中模型属性名与请求值（如路径变量或请求参数）的名称匹配（参见下一个示例）。

* 使用其默认构造函数实例化。

* 通过具有与 Servlet 请求参数匹配的参数的“主构造函数”实例化。参数名称是通过 爪哇Beans`@ConstructorProperties`或通过字节码中的运行时保留参数名称确定的。

除了使用[@ModelAttribute 方法](#mvc-ann-modelattrib-methods)来提供它，或者依靠框架来创建模型属性之外，另一种选择是使用`Converter<String, T>`来提供实例。当模型属性名称与请求值（例如路径变量或请求参数）的名称匹配时，并且存在`Converter`到模型属性类型的`String`时，将应用此方法。在下面的示例中，模型属性名为`account`，它与 URI 路径变量`account`匹配，并且有一个已注册的`Converter<String, Account>`，它可以从数据存储加载`Account`:

爪哇

```
@PutMapping("/accounts/{account}")
public String save(@ModelAttribute("account") Account account) {
    // ...
}
```

Kotlin

```
@PutMapping("/accounts/{account}")
fun save(@ModelAttribute("account") account: Account): String {
    // ...
}
```

在获得模型属性实例之后，再进行数据绑定。`WebDataBinder`类将 Servlet 请求参数名称（查询参数和窗体字段）与目标`Object`上的字段名称匹配。在应用了类型转换之后（如有必要）填充匹配字段。有关数据绑定（和验证）的更多信息，请参见[验证](core.html#validation)。有关自定义数据绑定的更多信息，请参见[`DataBinder`]。

数据绑定可能会导致错误。默认情况下，将引发`BindException`。但是，要检查控制器方法中的此类错误，可以在`@ModelAttribute`旁边立即添加一个`BindingResult`参数，如下例所示：

爪哇

```
@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
public String processSubmit(@ModelAttribute("pet") Pet pet, BindingResult result) { (1)
    if (result.hasErrors()) {
        return "petForm";
    }
    // ...
}
```

|**1**|在`@ModelAttribute`旁边添加一个`BindingResult`。|
|-----|-------------------------------------------------------|

Kotlin

```
@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
fun processSubmit(@ModelAttribute("pet") pet: Pet, result: BindingResult): String { (1)
    if (result.hasErrors()) {
        return "petForm"
    }
    // ...
}
```

|**1**|在`@ModelAttribute`旁边添加一个`BindingResult`。|
|-----|-------------------------------------------------------|

在某些情况下，你可能希望访问没有数据绑定的模型属性。对于这种情况，你可以将`Model`注入控制器并直接访问它，或者设置`@ModelAttribute(binding=false)`，如下例所示：

爪哇

```
@ModelAttribute
public AccountForm setUpForm() {
    return new AccountForm();
}

@ModelAttribute
public Account findAccount(@PathVariable String accountId) {
    return accountRepository.findOne(accountId);
}

@PostMapping("update")
public String update(@Valid AccountForm form, BindingResult result,
        @ModelAttribute(binding=false) Account account) { (1)
    // ...
}
```

|**1**|设置`@ModelAttribute(binding=false)`。|
|-----|-----------------------------------------|

Kotlin

```
@ModelAttribute
fun setUpForm(): AccountForm {
    return AccountForm()
}

@ModelAttribute
fun findAccount(@PathVariable accountId: String): Account {
    return accountRepository.findOne(accountId)
}

@PostMapping("update")
fun update(@Valid form: AccountForm, result: BindingResult,
           @ModelAttribute(binding = false) account: Account): String { (1)
    // ...
}
```

|**1**|设置`@ModelAttribute(binding=false)`。|
|-----|-----------------------------------------|

通过添加`javax.validation.Valid`注释或 Spring 的`@Validated`注释（[Bean Validation](core.html#validation-beanvalidation)和[Spring validation](core.html#validation)），可以在数据绑定后自动应用验证。下面的示例展示了如何做到这一点：

爪哇

```
@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
public String processSubmit(@Valid @ModelAttribute("pet") Pet pet, BindingResult result) { (1)
    if (result.hasErrors()) {
        return "petForm";
    }
    // ...
}
```

|**1**|验证`Pet`实例。|
|-----|----------------------------|

Kotlin

```
@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
fun processSubmit(@Valid @ModelAttribute("pet") pet: Pet, result: BindingResult): String { (1)
    if (result.hasErrors()) {
        return "petForm"
    }
    // ...
}
```

请注意，使用`@ModelAttribute`是可选的（例如，用于设置其属性）。默认情况下，任何不是简单值类型（由[Beanutils#IsSimpleProperty](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-)确定）且未由任何其他参数解析器解析的参数都将被视为已用`@ModelAttribute`注释。

##### `@SessionAttributes`

[WebFlux](web-reactive.html#webflux-ann-sessionattributes)

`@SessionAttributes`用于在请求之间的 HTTP Servlet 会话中存储模型属性。它是一种类型级别的注释，用于声明特定控制器使用的会话属性。这通常会列出模型属性的名称或模型属性的类型，这些属性应该透明地存储在会话中，以供后续的访问请求使用。

下面的示例使用`@SessionAttributes`注释：

爪哇

```
@Controller
@SessionAttributes("pet") (1)
public class EditPetForm {
    // ...
}
```

|**1**|使用`@SessionAttributes`注释。|
|-----|------------------------------------------|

Kotlin

```
@Controller
@SessionAttributes("pet") (1)
class EditPetForm {
    // ...
}
```

|**1**|使用`@SessionAttributes`注释。|
|-----|------------------------------------------|

在第一个请求中，当将名称为`pet`的模型属性添加到模型中时，将自动将其提升到 HTTP Servlet 会话中并将其保存。在另一个控制器方法使用`SessionStatus`方法参数清除存储之前，它一直保持不变，如下例所示：

爪哇

```
@Controller
@SessionAttributes("pet") (1)
public class EditPetForm {

    // ...

    @PostMapping("/pets/{id}")
    public String handle(Pet pet, BindingResult errors, SessionStatus status) {
        if (errors.hasErrors) {
            // ...
        }
        status.setComplete(); (2)
        // ...
    }
}
```

|**1**|在 Servlet 会话中存储`Pet`值。|
|-----|--------------------------------------------------|
|**2**|清除 Servlet 会话中的`Pet`值。|

Kotlin

```
@Controller
@SessionAttributes("pet") (1)
class EditPetForm {

    // ...

    @PostMapping("/pets/{id}")
    fun handle(pet: Pet, errors: BindingResult, status: SessionStatus): String {
        if (errors.hasErrors()) {
            // ...
        }
        status.setComplete() (2)
        // ...
    }
}
```

|**1**|在 Servlet 会话中存储`Pet`值。|
|-----|--------------------------------------------------|
|**2**|清除 Servlet 会话中的`Pet`值。|

##### `@SessionAttribute`

[WebFlux](web-reactive.html#webflux-ann-sessionattribute)

如果你需要访问已存在的会话属性，这些属性是全局管理的（也就是说，在控制器之外——例如，由过滤器管理），并且可能存在，也可能不存在，那么你可以在方法参数上使用`@SessionAttribute`注释，如下例所示：

爪哇

```
@RequestMapping("/")
public String handle(@SessionAttribute User user) { (1)
    // ...
}
```

|**1**|使用`@SessionAttribute`注释。|
|-----|---------------------------------------|

Kotlin

```
@RequestMapping("/")
fun handle(@SessionAttribute user: User): String { (1)
    // ...
}
```

对于需要添加或删除会话属性的用例，可以考虑将`org.springframework.web.context.request.WebRequest`或`javax.servlet.http.HttpSession`注入到控制器方法中。

对于将会话中的模型属性临时存储为控制器工作流的一部分，可以考虑使用`@SessionAttributes`，如[`@SessionAttributes`]中所述。

##### `@RequestAttribute`

[WebFlux](web-reactive.html#webflux-ann-requestattrib)

与`@SessionAttribute`类似，你可以使用`@RequestAttribute`注释来访问先前创建的预先存在的请求属性（例如，通过 Servlet `Filter`或`HandlerInterceptor`）：

爪哇

```
@GetMapping("/")
public String handle(@RequestAttribute Client client) { (1)
    // ...
}
```

|**1**|使用`@RequestAttribute`注释。|
|-----|-----------------------------------------|

Kotlin

```
@GetMapping("/")
fun handle(@RequestAttribute client: Client): String { (1)
    // ...
}
```

|**1**|使用`@RequestAttribute`注释。|
|-----|-----------------------------------------|

##### 重定向属性

默认情况下，所有模型属性都被认为是作为重定向 URL 中的 URI 模板变量公开的。在剩余的属性中，那些是基元类型或基元类型的集合或数组的属性将自动附加为查询参数。

如果模型实例是专门为重定向准备的，那么将原始类型属性追加为查询参数可能是期望的结果。然而，在带注释的控制器中，模型可以包含为呈现目的而添加的附加属性（例如，下拉字段值）。为了避免这种属性出现在 URL 中的可能性，`@RequestMapping`方法可以声明类型`RedirectAttributes`的参数，并使用它来指定使`RedirectView`可用的确切属性。如果方法确实重定向，则使用`RedirectAttributes`的内容。否则，将使用模型的内容。

`RequestMappingHandlerAdapter`提供了一个名为`ignoreDefaultModelOnRedirect`的标志，你可以使用它来指示，如果控制器方法重定向，则不应使用默认的`Model`的内容。相反，Controller 方法应该声明一个类型为`RedirectAttributes`的属性，或者，如果不这样做，则不应该将任何属性传递到`RedirectView`。MVC 名称空间和 MVC 爪哇 配置都将此标志设置为`false`，以保持向后兼容性。但是，对于新的应用程序，我们建议将其设置为`true`。

请注意，当展开重定向 URL 时，当前请求中的 URI 模板变量将自动可用，并且你不需要通过`Model`或`RedirectAttributes`显式地添加它们。下面的示例展示了如何定义重定向：

爪哇

```
@PostMapping("/files/{path}")
public String upload(...) {
    // ...
    return "redirect:files/{path}";
}
```

Kotlin

```
@PostMapping("/files/{path}")
fun upload(...): String {
    // ...
    return "redirect:files/{path}"
}
```

另一种将数据传递给重定向目标的方法是使用 flash 属性。与其他重定向属性不同，flash 属性保存在 HTTP 会话中（因此不会出现在 URL 中）。有关更多信息，请参见[flash 属性](#mvc-flash-attributes)。

##### flash 属性

Flash 属性为一个请求提供了一种方式，用于存储打算在另一个请求中使用的属性。这是重定向时最常见的需求——例如，后重定向-get 模式。在重定向之前（通常是在会话中）临时保存 flash 属性，以便在重定向之后使请求可用，并立即删除。

Spring MVC 有两个主要的抽象来支持 Flash 属性。`FlashMap`用于保存 flash 属性，而`FlashMapManager`用于存储、检索和管理`FlashMap`实例。

flash 属性支持始终是“打开”的，并且不需要显式地启用。但是，如果不使用，它永远不会导致 HTTP 会话的创建。在每个请求中，都有一个“input”`FlashMap`，其中包含从上一个请求（如果有的话）传递的属性，以及一个“output”`FlashMap`，其中包含用于保存后续请求的属性。这两个`FlashMap`实例都可以通过`RequestContextUtils`中的静态方法从 Spring MVC 中的任何地方访问。

带注释的控制器通常不需要直接使用`FlashMap`。相反，`@RequestMapping`方法可以接受类型为`RedirectAttributes`的参数，并使用它为重定向场景添加 flash 属性。通过`RedirectAttributes`添加的 flash 属性将自动传播到“输出”flashmap。类似地，在重定向之后，来自“input”`FlashMap`的属性将自动添加到提供目标 URL 的控制器的`Model`中。

将请求与 flash 属性匹配

flash 属性的概念存在于许多其他 Web 框架中，并已被证明有时会遇到并发问题。这是因为，根据定义，flash 属性将被存储到下一个请求为止。然而，“下一个”请求可能不是预期的接收者，而是另一个异步请求（例如，轮询或资源请求），在这种情况下，flash 属性被过早地删除。

为了减少此类问题的可能性，`RedirectView`自动“stamps”`FlashMap`实例具有重定向 URL 的路径和查询参数的目标。反过来，当它查找“input”`FlashMap`时，默认的`FlashMapManager`将该信息与传入请求匹配。

这并不能完全消除并发问题的可能性，但可以通过重定向 URL 中已有的信息大大减少并发问题。因此，我们建议你主要在重定向场景中使用 Flash 属性。

##### 多部分

[WebFlux](web-reactive.html#webflux-multipart-forms)

在`MultipartResolver`已[enabled](#mvc-multipart)之后，对带有`multipart/form-data`的 POST 请求的内容进行解析，并将其作为常规的请求参数进行访问。以下示例访问一个常规窗体字段和一个上载文件：

爪哇

```
@Controller
public class FileUploadController {

    @PostMapping("/form")
    public String handleFormUpload(@RequestParam("name") String name,
            @RequestParam("file") MultipartFile file) {

        if (!file.isEmpty()) {
            byte[] bytes = file.getBytes();
            // store the bytes somewhere
            return "redirect:uploadSuccess";
        }
        return "redirect:uploadFailure";
    }
}
```

Kotlin

```
@Controller
class FileUploadController {

    @PostMapping("/form")
    fun handleFormUpload(@RequestParam("name") name: String,
                        @RequestParam("file") file: MultipartFile): String {

        if (!file.isEmpty) {
            val bytes = file.bytes
            // store the bytes somewhere
            return "redirect:uploadSuccess"
        }
        return "redirect:uploadFailure"
    }
}
```

将参数类型声明为`List<MultipartFile>`允许为相同的参数名称解析多个文件。

当`@RequestParam`注释被声明为`Map<String, MultipartFile>`或`MultiValueMap<String, MultipartFile>`时，如果注释中没有指定参数名称，那么映射将被填充每个给定参数名称的多部分文件。

|   |通过 Servlet 3.0 多部分解析，你还可以声明`javax.servlet.http.Part`而不是 Spring 的`MultipartFile`，作为方法参数或集合值类型。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|

还可以使用多部分内容作为与[命令对象](#mvc-ann-modelattrib-method-args)的数据绑定的一部分。例如，前面示例中的表单字段和文件可以是表单对象上的字段，如下例所示：

爪哇

```
class MyForm {

    private String name;

    private MultipartFile file;

    // ...
}

@Controller
public class FileUploadController {

    @PostMapping("/form")
    public String handleFormUpload(MyForm form, BindingResult errors) {
        if (!form.getFile().isEmpty()) {
            byte[] bytes = form.getFile().getBytes();
            // store the bytes somewhere
            return "redirect:uploadSuccess";
        }
        return "redirect:uploadFailure";
    }
}
```

Kotlin

```
class MyForm(val name: String, val file: MultipartFile, ...)

@Controller
class FileUploadController {

    @PostMapping("/form")
    fun handleFormUpload(form: MyForm, errors: BindingResult): String {
        if (!form.file.isEmpty) {
            val bytes = form.file.bytes
            // store the bytes somewhere
            return "redirect:uploadSuccess"
        }
        return "redirect:uploadFailure"
    }
}
```

在 RESTful 服务场景中，还可以从非浏览器客户端提交多部分请求。下面的示例显示了一个使用 JSON 的文件：

```
POST /someUrl
Content-Type: multipart/mixed

--edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp
Content-Disposition: form-data; name="meta-data"
Content-Type: application/json; charset=UTF-8
Content-Transfer-Encoding: 8bit

{
    "name": "value"
}
--edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp
Content-Disposition: form-data; name="file-data"; filename="file.properties"
Content-Type: text/xml
Content-Transfer-Encoding: 8bit
... File Data ...
```

你可以使用`@RequestParam`作为`String`访问“元数据”部分，但你可能希望它从 JSON 反序列化（类似于`@RequestBody`）。在使用[HtpMessageConverter](integration.html#rest-message-conversion)转换多个部分后，使用`@RequestPart`注释访问多个部分：

爪哇

```
@PostMapping("/")
public String handle(@RequestPart("meta-data") MetaData metadata,
        @RequestPart("file-data") MultipartFile file) {
    // ...
}
```

Kotlin

```
@PostMapping("/")
fun handle(@RequestPart("meta-data") metadata: MetaData,
        @RequestPart("file-data") file: MultipartFile): String {
    // ...
}
```

你可以将`@RequestPart`与`javax.validation.Valid`组合使用，或者使用 Spring 的`@Validated`注释，这两种方法都会导致应用标准 Bean 验证。默认情况下，验证错误会导致`MethodArgumentNotValidException`，并将其转换为 400（bad\_request）响应。或者，你可以通过`Errors`或`BindingResult`参数在控制器内部本地处理验证错误，如下例所示：

爪哇

```
@PostMapping("/")
public String handle(@Valid @RequestPart("meta-data") MetaData metadata,
        BindingResult result) {
    // ...
}
```

Kotlin

```
@PostMapping("/")
fun handle(@Valid @RequestPart("meta-data") metadata: MetaData,
        result: BindingResult): String {
    // ...
}
```

##### `@RequestBody`

[WebFlux](web-reactive.html#webflux-ann-requestbody)

你可以使用`@RequestBody`注释，通过[`HttpMessageConverter`]（integration.html#rest-message-conversion）将请求主体读取并反序列化为`Object`。下面的示例使用了`@RequestBody`参数：

爪哇

```
@PostMapping("/accounts")
public void handle(@RequestBody Account account) {
    // ...
}
```

Kotlin

```
@PostMapping("/accounts")
fun handle(@RequestBody account: Account) {
    // ...
}
```

你可以使用[MVC Config](#mvc-config)的[消息转换器](#mvc-config-message-converters)选项来配置或自定义消息转换。

你可以将`@RequestBody`与`javax.validation.Valid`或 Spring 的`@Validated`注释结合使用，这两种方法都会导致应用标准 Bean 验证。默认情况下，验证错误会导致`MethodArgumentNotValidException`，并将其转换为 400（bad\_request）响应。或者，你可以通过`Errors`或`BindingResult`参数在控制器内部本地处理验证错误，如下例所示：

爪哇

```
@PostMapping("/accounts")
public void handle(@Valid @RequestBody Account account, BindingResult result) {
    // ...
}
```

Kotlin

```
@PostMapping("/accounts")
fun handle(@Valid @RequestBody account: Account, result: BindingResult) {
    // ...
}
```

##### HttpEntity

[WebFlux](web-reactive.html#webflux-ann-httpentity)

`HttpEntity`与使用[`@RequestBody`]（#mvc-ann-requestBody）或多或少相同，但基于一个容器对象，该对象公开了请求头和主体。下面的清单展示了一个示例：

爪哇

```
@PostMapping("/accounts")
public void handle(HttpEntity<Account> entity) {
    // ...
}
```

Kotlin

```
@PostMapping("/accounts")
fun handle(entity: HttpEntity<Account>) {
    // ...
}
```

##### `@ResponseBody`

[WebFlux](web-reactive.html#webflux-ann-responsebody)

你可以在方法上使用`@ResponseBody`注释，通过[HtpMessageConverter](integration.html#rest-message-conversion)将返回序列化到响应主体。下面的清单展示了一个示例：

爪哇

```
@GetMapping("/accounts/{id}")
@ResponseBody
public Account handle() {
    // ...
}
```

Kotlin

```
@GetMapping("/accounts/{id}")
@ResponseBody
fun handle(): Account {
    // ...
}
```

`@ResponseBody`在类级别上也受到支持，在这种情况下，所有控制器方法都会继承它。这是`@RestController`的效果，它不过是一个标记有`@Controller`和`@ResponseBody`的元注释。

你可以将`@ResponseBody`用于反应类型。有关更多详细信息，请参见[异步请求](#mvc-ann-async)和[反应类型](#mvc-ann-async-reactive-types)。

你可以使用[MVC Config](#mvc-config)的[消息转换器](#mvc-config-message-converters)选项来配置或自定义消息转换。

你可以将`@ResponseBody`方法与 JSON 序列化视图合并。详见[JacksonJSON](#mvc-ann-jackson)。

##### 负责实体

[WebFlux](web-reactive.html#webflux-ann-responseentity)

`ResponseEntity`类似于[`@ResponseBody`]（#mvc-ann-responsebody），但具有状态和标题。例如：

爪哇

```
@GetMapping("/something")
public ResponseEntity<String> handle() {
    String body = ... ;
    String etag = ... ;
    return ResponseEntity.ok().eTag(etag).build(body);
}
```

Kotlin

```
@GetMapping("/something")
fun handle(): ResponseEntity<String> {
    val body = ...
    val etag = ...
    return ResponseEntity.ok().eTag(etag).build(body)
}
```

Spring MVC 支持使用单个值[反应型](#mvc-ann-async-reactive-types)来异步地产生`ResponseEntity`，和/或用于主体的单个值和多个值的反应类型。这允许以下类型的异步响应：

* `ResponseEntity<Mono<T>>`或`ResponseEntity<Flux<T>>`在稍后异步提供主体时，立即使响应状态和头为已知。如果主体由 0.1 个值组成，则使用`Mono`；如果可以产生多个值，则使用`Flux`。

* `Mono<ResponseEntity<T>>`在稍后的时间点异步提供了所有这三个方面——响应状态、头和主体。这允许响应状态和头根据异步请求处理的结果而变化。

##### JacksonJSON

Spring 提供对 JacksonJSON 库的支持。

###### JSON 视图

[WebFlux](web-reactive.html#webflux-ann-jsonview)

Spring MVC 提供了对[Jackson 的序列化视图](https://www.baeldung.com/jackson-json-view-annotation)的内置支持，其仅允许在`Object`中呈现所有字段的子集。要与`@ResponseBody`或`ResponseEntity`控制器方法一起使用它，你可以使用 Jackson 的`@JsonView`注释来激活序列化视图类，如下例所示：

爪哇

```
@RestController
public class UserController {

    @GetMapping("/user")
    @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;
    }
}
```

Kotlin

```
@RestController
class UserController {

    @GetMapping("/user")
    @JsonView(User.WithoutPasswordView::class)
    fun getUser() = User("eric", "7!jd#h23")
}

class User(
        @JsonView(WithoutPasswordView::class) val username: String,
        @JsonView(WithPasswordView::class) val password: String) {

    interface WithoutPasswordView
    interface WithPasswordView : WithoutPasswordView
}
```

|   |`@JsonView`允许一个视图类的数组，但是每个<br/>控制器方法只能指定一个。如果需要激活多个视图，可以使用复合接口。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

如果你希望以编程方式执行上述操作，而不是声明`@JsonView`注释，请将返回值包装为`MappingJacksonValue`，并使用它来提供序列化视图：

爪哇

```
@RestController
public class UserController {

    @GetMapping("/user")
    public MappingJacksonValue getUser() {
        User user = new User("eric", "7!jd#h23");
        MappingJacksonValue value = new MappingJacksonValue(user);
        value.setSerializationView(User.WithoutPasswordView.class);
        return value;
    }
}
```

Kotlin

```
@RestController
class UserController {

    @GetMapping("/user")
    fun getUser(): MappingJacksonValue {
        val value = MappingJacksonValue(User("eric", "7!jd#h23"))
        value.serializationView = User.WithoutPasswordView::class.java
        return value
    }
}
```

对于依赖于视图分辨率的控制器，可以将序列化视图类添加到模型中，如下例所示：

爪哇

```
@Controller
public class UserController extends AbstractController {

    @GetMapping("/user")
    public String getUser(Model model) {
        model.addAttribute("user", new User("eric", "7!jd#h23"));
        model.addAttribute(JsonView.class.getName(), User.WithoutPasswordView.class);
        return "userView";
    }
}
```

Kotlin

```
import org.springframework.ui.set

@Controller
class UserController : AbstractController() {

    @GetMapping("/user")
    fun getUser(model: Model): String {
        model["user"] = User("eric", "7!jd#h23")
        model[JsonView::class.qualifiedName] = User.WithoutPasswordView::class.java
        return "userView"
    }
}
```

#### 1.3.4.模型

[WebFlux](web-reactive.html#webflux-ann-modelattrib-methods)

你可以使用`@ModelAttribute`注释：

* 在[方法参数](#mvc-ann-modelattrib-method-args)中的`@RequestMapping`方法上从模型创建或访问`Object`，并通过`WebDataBinder`将其绑定到请求。

* 作为`@Controller`或`@ControllerAdvice`类中的方法级注释，它有助于在任何`@RequestMapping`方法调用之前初始化模型。

* 在`@RequestMapping`方法上标记其返回值是一个模型属性。

本节讨论`@ModelAttribute`方法——前面列表中的第二项。控制器可以有任意数量的`@ModelAttribute`方法。所有这些方法都是在同一个控制器中的`@RequestMapping`方法之前调用的。还可以通过`@ControllerAdvice`在控制器之间共享`@ModelAttribute`方法。有关更多详细信息，请参见[财务总监建议](#mvc-ann-controller-advice)一节。

`@ModelAttribute`方法具有灵活的方法签名。它们支持许多与`@RequestMapping`方法相同的参数，但`@ModelAttribute`本身或与请求主体相关的任何参数除外。

下面的示例显示了`@ModelAttribute`方法：

爪哇

```
@ModelAttribute
public void populateModel(@RequestParam String number, Model model) {
    model.addAttribute(accountRepository.findAccount(number));
    // add more ...
}
```

Kotlin

```
@ModelAttribute
fun populateModel(@RequestParam number: String, model: Model) {
    model.addAttribute(accountRepository.findAccount(number))
    // add more ...
}
```

下面的示例只添加了一个属性：

爪哇

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

Kotlin

```
@ModelAttribute
fun addAccount(@RequestParam number: String): Account {
    return accountRepository.findAccount(number)
}
```

|   |当未显式指定名称时，将根据`Object`类型选择缺省名称，正如在 爪哇doc 中对[`Conventions`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/core/core/conventions.html）所解释的那样。<br/>通过`name`上的`name`属性“/>（用于返回值），始终可以使用重载的`addAttribute`方法或<br/>指定一个显式名称。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

你也可以使用`@ModelAttribute`作为`@RequestMapping`方法的方法级注释，在这种情况下，`@RequestMapping`方法的返回值被解释为一个模型属性。这通常不是必需的，因为这是 HTML 控制器中的默认行为，除非返回值是`String`，否则将被解释为视图名称。`@ModelAttribute`还可以自定义模型属性名称，如下例所示：

爪哇

```
@GetMapping("/accounts/{id}")
@ModelAttribute("myAccount")
public Account handle() {
    // ...
    return account;
}
```

Kotlin

```
@GetMapping("/accounts/{id}")
@ModelAttribute("myAccount")
fun handle(): Account {
    // ...
    return account
}
```

#### 1.3.5.`DataBinder`

[WebFlux](web-reactive.html#webflux-ann-initbinder)

`@Controller`或`@ControllerAdvice`类可以具有初始化`@InitBinder`实例的`@InitBinder`方法，而这些方法可以：

* 将请求参数（即窗体或查询数据）绑定到模型对象。

* 将基于字符串的请求值（例如请求参数、路径变量、头、cookie 和其他）转换为控制器方法参数的目标类型。

* 在呈现 HTML 窗体时，将模型对象值格式化为`String`值。

`@InitBinder`方法可以注册控制器特定的`java.beans.PropertyEditor`或 Spring `Converter`和`Formatter`组件。此外，可以使用[MVC config](#mvc-config-conversion)在全局共享的`FormattingConversionService`中注册`Converter`和`Formatter`类型。

`@InitBinder`方法支持许多与`@RequestMapping`方法相同的参数，但`@ModelAttribute`（命令对象）参数除外。通常，它们是用`WebDataBinder`参数（用于注册）和`void`返回值声明的。下面的清单展示了一个示例：

爪哇

```
@Controller
public class FormController {

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

    // ...
}
```

|**1**|定义`@InitBinder`方法。|
|-----|---------------------------------|

Kotlin

```
@Controller
class FormController {

    @InitBinder (1)
    fun initBinder(binder: WebDataBinder) {
        val dateFormat = SimpleDateFormat("yyyy-MM-dd")
        dateFormat.isLenient = false
        binder.registerCustomEditor(Date::class.java, CustomDateEditor(dateFormat, false))
    }

    // ...
}
```

|**1**|定义`@InitBinder`方法。|
|-----|---------------------------------|

或者，当你通过共享的`FormattingConversionService`使用基于`Formatter`的设置时，你可以重新使用相同的方法并注册特定于控制器的`Formatter`实现，如下例所示：

爪哇

```
@Controller
public class FormController {

    @InitBinder (1)
    protected void initBinder(WebDataBinder binder) {
        binder.addCustomFormatter(new DateFormatter("yyyy-MM-dd"));
    }

    // ...
}
```

|**1**|在自定义格式化程序上定义`@InitBinder`方法。|
|-----|-------------------------------------------------------|

Kotlin

```
@Controller
class FormController {

    @InitBinder (1)
    protected fun initBinder(binder: WebDataBinder) {
        binder.addCustomFormatter(DateFormatter("yyyy-MM-dd"))
    }

    // ...
}
```

|**1**|在自定义格式化程序上定义`@InitBinder`方法。|
|-----|-------------------------------------------------------|

#### 1.3.6.例外

[WebFlux](web-reactive.html#webflux-ann-controller-exceptions)

`@Controller`和[@controlleradvice](#mvc-ann-controller-advice)类可以有`@ExceptionHandler`方法来处理来自控制器方法的异常，如下例所示：

爪哇

```
@Controller
public class SimpleController {

    // ...

    @ExceptionHandler
    public ResponseEntity<String> handle(IOException ex) {
        // ...
    }
}
```

Kotlin

```
@Controller
class SimpleController {

    // ...

    @ExceptionHandler
    fun handle(ex: IOException): ResponseEntity<String> {
        // ...
    }
}
```

异常可能与正在传播的顶级异常（例如，直接的`IOException`被抛出）或包装异常中的嵌套原因（例如，`IOException`包装在`IllegalStateException`中）相匹配。截至 5.3，这可以匹配在任意的原因水平，而以前只考虑一个直接原因。

为了匹配异常类型，最好将目标异常声明为方法参数，如前面的示例所示。当多个异常方法匹配时，根异常匹配通常优于原因异常匹配。更具体地说，`ExceptionDepthComparator`用于根据抛出的异常类型的深度对异常进行排序。

或者，注释声明可以缩小异常类型的范围以进行匹配，如下例所示：

爪哇

```
@ExceptionHandler({FileSystemException.class, RemoteException.class})
public ResponseEntity<String> handle(IOException ex) {
    // ...
}
```

Kotlin

```
@ExceptionHandler(FileSystemException::class, RemoteException::class)
fun handle(ex: IOException): ResponseEntity<String> {
    // ...
}
```

你甚至可以使用带有非常通用的参数签名的特定异常类型列表，如下例所示：

爪哇

```
@ExceptionHandler({FileSystemException.class, RemoteException.class})
public ResponseEntity<String> handle(Exception ex) {
    // ...
}
```

Kotlin

```
@ExceptionHandler(FileSystemException::class, RemoteException::class)
fun handle(ex: Exception): ResponseEntity<String> {
    // ...
}
```

|   |根和原因异常匹配之间的区别可能是令人惊讶的。<br/><br/>在前面显示的`IOException`变体中，该方法通常以<br/>实际的`FileSystemException`或`RemoteException`实例作为参数，<br/>因为它们都从`IOException`扩展。但是，如果任何这样的匹配<br/>异常是在包装异常中传播的，而包装异常本身是`IOException`，<br/>传递的异常实例是该包装异常。<br/><br/>在`handle(Exception)`变体中，行为甚至更简单。在包装场景中，这是<br/>总是与包装异常一起调用的，在这种情况下，<br/>实际上匹配通过`ex.getCause()`发现的异常。<br/>只有当这些作为顶级异常抛出时，传入的异常才是实际的`FileSystemException`或`RemoteException`实例。|
|---| |

我们通常建议你在参数签名中尽可能地具体，以减少根异常类型和原因异常类型之间不匹配的可能性。考虑将多个匹配方法分解为单独的`@ExceptionHandler`方法，每个方法通过其签名匹配单个特定的异常类型。

在 multi-`@ControllerAdvice`安排中，我们建议在`@ControllerAdvice`上声明主根异常映射，并按相应的顺序进行优先排序。虽然根异常匹配比原因更受欢迎，但这是在给定控制器或`@ControllerAdvice`类的方法之间定义的。这意味着在较高优先级`@ControllerAdvice` Bean 上的原因匹配要优于在较低优先级`@ControllerAdvice` Bean 上的任何匹配（例如，根）。

最后但并非最不重要的一点是，`@ExceptionHandler`方法实现可以通过以其原始形式重抛给定的异常实例来选择退出处理该异常实例。这在只对根级别匹配感兴趣或对无法静态确定的特定上下文中的匹配感兴趣的场景中很有用。一个重新抛出的异常将通过剩余的解析链传播，就好像给定的`@ExceptionHandler`方法首先不会匹配一样。

Spring MVC 中对`@ExceptionHandler`方法的支持是建立在`DispatcherServlet`级别的[HandleRexCeptionResolver](#mvc-exceptionhandlers)机制上的。

##### 方法参数

`@ExceptionHandler`方法支持以下参数：

|                                 Method argument                                  |说明|
|----------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                  Exception type                                  |访问提出的异常。|
|                                 `HandlerMethod`                                  |用于访问引发异常的控制器方法。|
|                         `WebRequest`, `NativeWebRequest`                         |在不直接使用<br/> Servlet API 的情况下，对请求参数以及请求和会话属性进行通用访问。|
|         `javax.servlet.ServletRequest`, `javax.servlet.ServletResponse`          |选择任何特定的请求或响应类型（例如，`ServletRequest`或`HttpServletRequest`或 Spring 的`MultipartRequest`或`MultipartHttpServletRequest`）。|
|                         `javax.servlet.http.HttpSession`                         |强制执行会话的存在。因此，这样的参数永远不是`null`。<br/>注意，会话访问不是线程安全的。考虑将`RequestMappingHandlerAdapter`实例的`synchronizeOnSession`标志设置为`true`，如果允许多个<br/>请求并发访问会话。|
|                            `java.security.Principal`                             |当前经过身份验证的用户——如果已知的话，可能是特定的`Principal`实现类。|
|                                   `HttpMethod`                                   |请求的 HTTP 方法。|
|                                `java.util.Locale`                                |当前的请求区域设置，由可用的最具体的`LocaleResolver`确定—在<br/>效果中，配置的`LocaleResolver`或`LocaleContextResolver`。|
|                     `java.util.TimeZone`, `java.time.ZoneId`                     |与当前请求相关联的时区，由`LocaleContextResolver`确定。|
|                     `java.io.OutputStream`, `java.io.Writer`                     |用于访问原始响应体，如 Servlet API 所公开的那样。|
|`java.util.Map`, `org.springframework.ui.Model`, `org.springframework.ui.ModelMap`|用于访问用于错误响应的模型。总是空的。|
|                               `RedirectAttributes`                               |指定在重定向的情况下使用的属性—（即附加到查询<br/>字符串中）和要临时存储的 flash 属性，直到重定向后的请求为止。<br/>参见[重定向属性](#mvc-redirecting-passing-data)和[flash 属性](#mvc-flash-attributes)。|
|                               `@SessionAttribute`                                |对于任何会话属性的访问，与存储在<br/>会话中的模型属性形成对比的是，它是一个类级`@SessionAttributes`声明的结果。<br/>有关更多详细信息，请参见[`@SessionAttribute`]（#mvc-ann-sessionAttribute）。|
|                               `@RequestAttribute`                                |用于访问请求属性。有关更多详细信息，请参见[`@RequestAttribute`]。|

##### 返回值

`@ExceptionHandler`方法支持以下返回值：

|                 Return value                  |说明|
|-----------------------------------------------| |
|                `@ResponseBody`                |返回值通过`HttpMessageConverter`实例进行转换，并写入<br/>响应。参见[`@ResponseBody`]。|
|     `HttpEntity<B>`, `ResponseEntity<B>`      |返回值指定通过`HttpMessageConverter`实例转换完整的响应（包括 HTTP 头和正文）<br/>并将其写入响应。<br/>参见[负责实体](#mvc-ann-responseentity)。|
|                   `String`                    |要用`ViewResolver`实现来解析的视图名称，并与<br/>隐式模型一起使用——通过命令对象和`@ModelAttribute`方法确定。<br/>处理程序方法还可以通过声明`Model`参数（前面已经描述过）以编程方式丰富模型。|
|                    `View`                     |一个`View`实例用于与隐式模型一起进行渲染——通过命令对象和`@ModelAttribute`方法确定<br/>。处理程序方法还可以通过声明一个`Model`参数（前面已经描述过）以编程方式丰富模型。|
|`java.util.Map`, `org.springframework.ui.Model`|要添加到隐式模型的属性，其视图名称通过`RequestToViewNameTranslator`隐式确定<br/>。|
|               `@ModelAttribute`               |通过<br/>a`RequestToViewNameTranslator`隐式确定的视图名称要添加到模型中的属性。<br/><br/>注意，`@ModelAttribute`是可选的。请参阅<br/>本表末尾的“任何其他返回值”。|
|             `ModelAndView` object             |要使用的视图和模型属性，以及可选的响应状态。|
|                    `void`                     |返回类型（或`null`返回值）为`null`的方法被认为具有完全的<br/>处理响应，如果它还具有`ServletResponse``OutputStream`参数，或<br/>`@ResponseStatus`注释。如果控制器进行了正的`ETag`或`lastModified`时间戳检查（详见[控制器](#mvc-caching-etag-lastmodified)），也是如此。<br/><br/>如果上述各项都不是真的，`void`返回类型还可以表示<br/>REST 控制器的“无响应体”或 HTML 控制器的默认视图名称选择。|
|            Any other return value             |如果一个返回值与上述任一项不匹配且不是简单类型（由[Beanutils#IsSimpleProperty](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-)确定），则默认情况下<br/>将其视为要添加到模型中的模型属性。如果它是一个简单的类型，<br/>它仍然是未解决的。|

##### REST API 异常

[WebFlux](web-reactive.html#webflux-ann-rest-exceptions)

REST 服务的一个常见要求是在响应主体中包含错误详细信息。 Spring 框架不会自动做到这一点，因为响应主体中的错误详细信息的表示是特定于应用程序的。但是，`@RestController`可以使用带有`@ExceptionHandler`返回值的`ResponseEntity`方法来设置响应的状态和主体。这样的方法也可以在`@ControllerAdvice`类中声明，以在全局范围内应用它们。

在响应体中实现带有错误详细信息的全局异常处理的应用程序应该考虑扩展[`ResponseEntityExceptionHandler`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet/mvc/method/annotation/responseentyExceptionHandler.html），它为 Spring MVC 引发的异常提供处理，并提供钩子来定制响应体。为了利用这一点，创建一个`ResponseEntityExceptionHandler`的子类，用`@ControllerAdvice`对其进行注释，覆盖必要的方法，并将其声明为 Spring  Bean。

#### 1.3.7.财务总监建议

[WebFlux](web-reactive.html#webflux-ann-controller-advice)

`@ExceptionHandler`、`@InitBinder`和`@ModelAttribute`方法仅适用于在其中声明它们的`@Controller`类或类层次结构。如果它们是在`@ControllerAdvice`或`@RestControllerAdvice`类中声明的，则它们适用于任何控制器。此外，截至 5.3，`@ExceptionHandler`中的`@ControllerAdvice`方法可用于处理来自任何`@Controller`或任何其他处理程序的异常。

`@ControllerAdvice`是用`@Component`进行元注释的，因此可以通过[组件扫描](core.html#beans-java-instantiating-container-scan)注册为 Spring  Bean。`@RestControllerAdvice`是用`@ControllerAdvice`和`@ResponseBody`进行元注释的，这意味着`@ExceptionHandler`方法的返回值将通过响应体消息转换呈现，而不是通过 HTML 视图呈现。

在启动时，`RequestMappingHandlerMapping`和`ExceptionHandlerExceptionResolver`检测控制器建议 bean 并在运行时应用它们。全局`@ExceptionHandler`方法，来自于`@ControllerAdvice`，应用于*之后*局部方法，来自于`@Controller`。相比之下，全局`@ModelAttribute`和`@InitBinder`方法则应用于局部方法*在此之前*。

`@ControllerAdvice`注释的属性允许你缩小它们所应用的控制器和处理程序的集合。例如：

爪哇

```
// Target all Controllers annotated with @RestController
@ControllerAdvice(annotations = RestController.class)
public class ExampleAdvice1 {}

// Target all Controllers within specific packages
@ControllerAdvice("org.example.controllers")
public class ExampleAdvice2 {}

// Target all Controllers assignable to specific classes
@ControllerAdvice(assignableTypes = {ControllerInterface.class, AbstractController.class})
public class ExampleAdvice3 {}
```

Kotlin

```
// Target all Controllers annotated with @RestController
@ControllerAdvice(annotations = [RestController::class])
class ExampleAdvice1

// Target all Controllers within specific packages
@ControllerAdvice("org.example.controllers")
class ExampleAdvice2

// Target all Controllers assignable to specific classes
@ControllerAdvice(assignableTypes = [ControllerInterface::class, AbstractController::class])
class ExampleAdvice3
```

前面示例中的选择器是在运行时进行评估的，如果广泛使用，可能会对性能产生负面影响。有关更多详细信息，请参见[`@ControllerAdvice`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/bind/annotation/controlleradvice.html）爪哇doc。

### 1.4.功能端点

[WebFlux](web-reactive.html#webflux-fn)

Spring Web MVC 包括 WebMVC.FN，这是一种轻量级函数编程模型，其中函数被用来路由和处理请求，而契约被设计为具有不可变性。它是基于注释的编程模型的一种替代方案，但在其他情况下运行在相同的[DispatcherServlet](#mvc-servlet)上。

#### 1.4.1.概述

[WebFlux](web-reactive.html#webflux-fn-overview)

在 Webmvc.FN 中，HTTP 请求是用`HandlerFunction`处理的：一个函数接受`ServerRequest`并返回`ServerResponse`。请求和响应对象都具有不可更改的契约，这些契约提供对 HTTP 请求和响应的 JDK8 友好访问。`HandlerFunction`相当于基于注释的编程模型中的`@RequestMapping`方法的主体。

传入的请求被路由到带有`RouterFunction`的处理程序函数：该函数接受`ServerRequest`并返回可选的`HandlerFunction`（即`Optional<HandlerFunction>`）。当路由器函数匹配时，将返回一个处理程序函数；否则将返回一个空的可选函数。`RouterFunction`相当于`@RequestMapping`注释，但与此的主要区别是，路由器函数不仅提供数据，还提供行为。

`RouterFunctions.route()`提供了一个路由器构建器，该构建器有利于路由器的创建，如下例所示：

爪哇

```
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.servlet.function.RequestPredicates.*;
import static org.springframework.web.servlet.function.RouterFunctions.route;

PersonRepository repository = ...
PersonHandler handler = new PersonHandler(repository);

RouterFunction<ServerResponse> route = route()
    .GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson)
    .GET("/person", accept(APPLICATION_JSON), handler::listPeople)
    .POST("/person", handler::createPerson)
    .build();

public class PersonHandler {

    // ...

    public ServerResponse listPeople(ServerRequest request) {
        // ...
    }

    public ServerResponse createPerson(ServerRequest request) {
        // ...
    }

    public ServerResponse getPerson(ServerRequest request) {
        // ...
    }
}
```

Kotlin

```
import org.springframework.web.servlet.function.router

val repository: PersonRepository = ...
val handler = PersonHandler(repository)

val route = router { (1)
    accept(APPLICATION_JSON).nest {
        GET("/person/{id}", handler::getPerson)
        GET("/person", handler::listPeople)
    }
    POST("/person", handler::createPerson)
}

class PersonHandler(private val repository: PersonRepository) {

    // ...

    fun listPeople(request: ServerRequest): ServerResponse {
        // ...
    }

    fun createPerson(request: ServerRequest): ServerResponse {
        // ...
    }

    fun getPerson(request: ServerRequest): ServerResponse {
        // ...
    }
}
```

|**1**|使用路由器 DSL 创建路由器。|
|-----|-----------------------------------|

如果你将`RouterFunction`注册为 Bean，例如通过在`@Configuration`类中将其公开，则 Servlet 将自动检测它，如[运行服务器](#webmvc-fn-running)中所解释的那样。

#### 1.4.2.handlerfunction

[WebFlux](web-reactive.html#webflux-fn-handler-functions)

`ServerRequest`和`ServerResponse`是不可变的接口，它们提供对 HTTP 请求和响应的 JDK8 友好访问，包括头、主体、方法和状态代码。

##### ServerRequest

`ServerRequest`提供对 HTTP 方法、URI、标头和查询参数的访问，而对正文的访问是通过`body`方法提供的。

下面的示例将请求主体提取到`String`:

爪哇

```
String string = request.body(String.class);
```

Kotlin

```
val string = request.body<String>()
```

下面的示例将主体提取到`List<Person>`，其中`Person`对象是从序列化形式（例如 JSON 或 XML）中解码的：

爪哇

```
List<Person> people = request.body(new ParameterizedTypeReference<List<Person>>() {});
```

Kotlin

```
val people = request.body<Person>()
```

下面的示例展示了如何访问参数：

爪哇

```
MultiValueMap<String, String> params = request.params();
```

Kotlin

```
val map = request.params()
```

##### ServerResponse

`ServerResponse`提供对 HTTP 响应的访问，由于它是不可变的，你可以使用`build`方法来创建它。你可以使用构建器设置响应状态、添加响应头或提供主体。下面的示例使用 JSON 内容创建一个 200（OK）响应：

爪哇

```
Person person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person);
```

Kotlin

```
val person: Person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person)
```

下面的示例展示了如何使用`Location`标头构建 201（已创建）响应，而不包含正文：

爪哇

```
URI location = ...
ServerResponse.created(location).build();
```

Kotlin

```
val location: URI = ...
ServerResponse.created(location).build()
```

你也可以使用异步结果作为主体，其形式为`CompletableFuture`，`Publisher`，或`ReactiveAdapterRegistry`所支持的任何其他类型。例如：

爪哇

```
Mono<Person> person = webClient.get().retrieve().bodyToMono(Person.class);
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person);
```

Kotlin

```
val person = webClient.get().retrieve().awaitBody<Person>()
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person)
```

如果不只是主体，而且状态或头也是基于异步类型的，则可以在`ServerResponse`上使用静态`async`方法，该方法接受`CompletableFuture<ServerResponse>`、`Publisher<ServerResponse>`或`ReactiveAdapterRegistry`支持的任何其他异步类型。例如：

爪哇

```
Mono<ServerResponse> asyncResponse = webClient.get().retrieve().bodyToMono(Person.class)
  .map(p -> ServerResponse.ok().header("Name", p.name()).body(p));
ServerResponse.async(asyncResponse);
```

[服务器发送的事件](https://www.w3.org/TR/eventsource/)可以通过`sse`上的静态`sse`方法提供。该方法提供的构建器允许你以 JSON 的形式发送字符串或其他对象。例如：

爪哇

```
public RouterFunction<ServerResponse> sse() {
    return route(GET("/sse"), request -> ServerResponse.sse(sseBuilder -> {
                // Save the sseBuilder object somewhere..
            }));
}

// In some other thread, sending a String
sseBuilder.send("Hello world");

// Or an object, which will be transformed into JSON
Person person = ...
sseBuilder.send(person);

// Customize the event by using the other methods
sseBuilder.id("42")
        .event("sse event")
        .data(person);

// and done at some point
sseBuilder.complete();
```

Kotlin

```
fun sse(): RouterFunction<ServerResponse> = router {
    GET("/sse") { request -> ServerResponse.sse { sseBuilder ->
        // Save the sseBuilder object somewhere..
    }
}

// In some other thread, sending a String
sseBuilder.send("Hello world")

// Or an object, which will be transformed into JSON
val person = ...
sseBuilder.send(person)

// Customize the event by using the other methods
sseBuilder.id("42")
        .event("sse event")
        .data(person)

// and done at some point
sseBuilder.complete()
```

##### 处理程序类

我们可以将处理程序函数编写为 lambda，如下例所示：

爪哇

```
HandlerFunction<ServerResponse> helloWorld =
  request -> ServerResponse.ok().body("Hello World");
```

Kotlin

```
val helloWorld: (ServerRequest) -> ServerResponse =
  { ServerResponse.ok().body("Hello World") }
```

这很方便，但在一个应用程序中，我们需要多个功能，而多个内联 lambda 可能会变得混乱。因此，将相关的处理程序函数组合到一个处理程序类中是有用的，该处理程序类在基于注释的应用程序中具有与`@Controller`类似的作用。例如，下面的类公开了一个反应性`Person`存储库：

爪哇

```
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.reactive.function.server.ServerResponse.ok;

public class PersonHandler {

    private final PersonRepository repository;

    public PersonHandler(PersonRepository repository) {
        this.repository = repository;
    }

    public ServerResponse listPeople(ServerRequest request) { (1)
        List<Person> people = repository.allPeople();
        return ok().contentType(APPLICATION_JSON).body(people);
    }

    public ServerResponse createPerson(ServerRequest request) throws Exception { (2)
        Person person = request.body(Person.class);
        repository.savePerson(person);
        return ok().build();
    }

    public ServerResponse getPerson(ServerRequest request) { (3)
        int personId = Integer.parseInt(request.pathVariable("id"));
        Person person = repository.getPerson(personId);
        if (person != null) {
            return ok().contentType(APPLICATION_JSON).body(person);
        }
        else {
            return ServerResponse.notFound().build();
        }
    }

}
```

|**1**|`listPeople`是一个处理函数，它将存储库中找到的所有`Person`对象作为<br/>json 返回。|
|-----|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|**2**|`createPerson`是一个处理函数，它存储了一个包含在请求主体中的新`Person`。|
|**3**|`getPerson`是一个处理函数，它返回一个人，由`id`路径<br/>变量标识。我们从存储库中检索`Person`并创建一个 JSON 响应，如果找到了<br/>。如果没有找到它，我们将返回 404Not Found 响应。|

Kotlin

```
class PersonHandler(private val repository: PersonRepository) {

    fun listPeople(request: ServerRequest): ServerResponse { (1)
        val people: List<Person> = repository.allPeople()
        return ok().contentType(APPLICATION_JSON).body(people);
    }

    fun createPerson(request: ServerRequest): ServerResponse { (2)
        val person = request.body<Person>()
        repository.savePerson(person)
        return ok().build()
    }

    fun getPerson(request: ServerRequest): ServerResponse { (3)
        val personId = request.pathVariable("id").toInt()
        return repository.getPerson(personId)?.let { ok().contentType(APPLICATION_JSON).body(it) }
                ?: ServerResponse.notFound().build()

    }
}
```

|**1**|`listPeople`是一个处理函数，它将存储库中找到的所有`Person`对象作为<br/>json 返回。|
|-----|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|**2**|`createPerson`是一个处理函数，它存储了一个包含在请求主体中的新`Person`。|
|**3**|`getPerson`是一个处理函数，它返回一个人，由`id`路径<br/>变量标识。我们从存储库中检索`Person`并创建一个 JSON 响应，如果找到了<br/>。如果没有找到它，我们将返回 404Not Found 响应。|

##### Validation

功能端点可以使用 Spring 的[验证设施](core.html#validation)将验证应用于请求主体。例如，给定一个针对`Person`的自定义 Spring [Validator](core.html#validation)实现：

爪哇

```
public class PersonHandler {

    private final Validator validator = new PersonValidator(); (1)

    // ...

    public ServerResponse createPerson(ServerRequest request) {
        Person person = request.body(Person.class);
        validate(person); (2)
        repository.savePerson(person);
        return ok().build();
    }

    private void validate(Person person) {
        Errors errors = new BeanPropertyBindingResult(person, "person");
        validator.validate(person, errors);
        if (errors.hasErrors()) {
            throw new ServerWebInputException(errors.toString()); (3)
        }
    }
}
```

|**1**|创建`Validator`实例。|
|-----|-----------------------------------|
|**2**|应用验证。|
|**3**|提出 400 响应的例外情况。|

Kotlin

```
class PersonHandler(private val repository: PersonRepository) {

    private val validator = PersonValidator() (1)

    // ...

    fun createPerson(request: ServerRequest): ServerResponse {
        val person = request.body<Person>()
        validate(person) (2)
        repository.savePerson(person)
        return ok().build()
    }

    private fun validate(person: Person) {
        val errors: Errors = BeanPropertyBindingResult(person, "person")
        validator.validate(person, errors)
        if (errors.hasErrors()) {
            throw ServerWebInputException(errors.toString()) (3)
        }
    }
}
```

|**1**|创建`Validator`实例。|
|-----|-----------------------------------|
|**2**|应用验证。|
|**3**|提出 400 响应的例外情况。|

处理程序还可以使用标准 Bean 验证 API（JSR-303），方法是基于`LocalValidatorFactoryBean`创建并注入一个全局`Validator`实例。见[Spring Validation](core.html#validation-beanvalidation)。

#### 1.4.3.`RouterFunction`

[WebFlux](web-reactive.html#webflux-fn-router-functions)

路由器函数用于将请求路由到相应的`HandlerFunction`。通常，你不会自己编写路由器函数，而是使用`RouterFunctions`实用程序类上的一个方法来创建一个。`RouterFunctions.route()`（无参数）为你提供了用于创建路由器函数的 Fluent 构建器，而`RouterFunctions.route(RequestPredicate, HandlerFunction)`提供了一种直接创建路由器的方法。

通常，建议使用`route()`Builder，因为它为典型的映射场景提供了方便的快捷方式，而不需要很难发现的静态导入。例如，Router Function Builder 提供了方法`GET(String, HandlerFunction)`来创建 GET 请求的映射；以及`POST(String, HandlerFunction)`用于 POST。

除了基于 HTTP 方法的映射，Route Builder 还提供了一种在映射到请求时引入额外谓词的方法。对于每个 HTTP 方法，都有一个重载变量，它将`RequestPredicate`作为参数，通过该参数可以表示额外的约束。

##### 谓词

你可以编写自己的`RequestPredicate`，但是`RequestPredicates`实用程序类提供了基于请求路径、HTTP 方法、Content-type 等的常用实现。下面的示例使用一个请求谓词来基于`Accept`头创建一个约束：

爪哇

```
RouterFunction<ServerResponse> route = RouterFunctions.route()
    .GET("/hello-world", accept(MediaType.TEXT_PLAIN),
        request -> ServerResponse.ok().body("Hello World")).build();
```

Kotlin

```
import org.springframework.web.servlet.function.router

val route = router {
    GET("/hello-world", accept(TEXT_PLAIN)) {
        ServerResponse.ok().body("Hello World")
    }
}
```

你可以使用以下方法将多个请求谓词组合在一起：

* `RequestPredicate.and(RequestPredicate)`—两者必须匹配。

* `RequestPredicate.or(RequestPredicate)`——两者都可以匹配。

来自`RequestPredicates`的许多谓词都是组成的。例如，`RequestPredicates.GET(String)`是由`RequestPredicates.method(HttpMethod)`和`RequestPredicates.path(String)`组成的。上面显示的示例还使用两个请求谓词，因为构建器在内部使用`RequestPredicates.GET`，并将其与`accept`谓词组合在一起。

##### 路线

对路由器的功能按顺序进行评估：如果第一条路由不匹配，则对第二条路由进行评估，依此类推。因此，在一般路线之前声明更具体的路线是有意义的。当将路由器功能注册为 Spring bean 时，这一点也很重要，后面将对此进行说明。请注意，这种行为与基于注释的编程模型不同，在该模型中，“最特定的”控制器方法是自动选择的。

当使用 Router 函数 builder 时，所有定义的路由都被组合成一个`RouterFunction`，从`build()`返回。还有其他方法可以将多个路由器功能组合在一起：

* `add(RouterFunction)`上的`RouterFunctions.route()`构建器

* `RouterFunction.and(RouterFunction)`

* `RouterFunction.andRoute(RequestPredicate, HandlerFunction)`—带有嵌套`RouterFunctions.route()`的`RouterFunction.and()`的快捷方式。

下面的示例显示了四条路线的组成：

爪哇

```
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.servlet.function.RequestPredicates.*;

PersonRepository repository = ...
PersonHandler handler = new PersonHandler(repository);

RouterFunction<ServerResponse> otherRoute = ...

RouterFunction<ServerResponse> route = route()
    .GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) (1)
    .GET("/person", accept(APPLICATION_JSON), handler::listPeople) (2)
    .POST("/person", handler::createPerson) (3)
    .add(otherRoute) (4)
    .build();
```

|**1**|带有与 JSON 匹配的`Accept`标头的`GET /person/{id}`被路由到`PersonHandler.getPerson`|
|-----|--------------------------------------------------------------------------------------------------|
|**2**|带有与 JSON 匹配的`GET /person`头的`Accept`被路由到`PersonHandler.listPeople`|
|**3**|没有附加谓词的`POST /person`映射到`PersonHandler.createPerson`，并且|
|**4**|`otherRoute`是在其他地方创建的路由器功能，并将其添加到所构建的路由中。|

Kotlin

```
import org.springframework.http.MediaType.APPLICATION_JSON
import org.springframework.web.servlet.function.router

val repository: PersonRepository = ...
val handler = PersonHandler(repository);

val otherRoute = router {  }

val route = router {
    GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) (1)
    GET("/person", accept(APPLICATION_JSON), handler::listPeople) (2)
    POST("/person", handler::createPerson) (3)
}.and(otherRoute) (4)
```

|**1**|带有与 JSON 匹配的`GET /person/{id}`头的`Accept`被路由到`PersonHandler.getPerson`|
|-----|--------------------------------------------------------------------------------------------------|
|**2**|带有与 JSON 匹配的`Accept`标头的`GET /person`被路由到`PersonHandler.listPeople`|
|**3**|没有附加谓词的`POST /person`映射到`PersonHandler.createPerson`，并且|
|**4**|`otherRoute`是在其他地方创建的路由器功能，并将其添加到所构建的路由中。|

##### 嵌套路线

一组路由器函数通常有一个共享谓词，例如共享路径。在上面的示例中，共享谓词将是一个匹配`/person`的路径谓词，由三个路由使用。在使用注释时，可以使用映射到`/person`的类型级别`@RequestMapping`注释来删除这种重复。在 WebMVC.FN 中，路径谓词可以通过路由器函数生成器上的`path`方法进行共享。例如，通过使用嵌套路由，可以通过以下方式改进上面示例的最后几行：

爪哇

```
RouterFunction<ServerResponse> route = route()
    .path("/person", builder -> builder (1)
        .GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
        .GET(accept(APPLICATION_JSON), handler::listPeople)
        .POST("/person", handler::createPerson))
    .build();
```

|**1**|注意，`path`的第二个参数是接受路由器生成器的消费者。|
|-----|---------------------------------------------------------------------------------|

Kotlin

```
import org.springframework.web.servlet.function.router

val route = router {
    "/person".nest {
        GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
        GET(accept(APPLICATION_JSON), handler::listPeople)
        POST("/person", handler::createPerson)
    }
}
```

尽管基于路径的嵌套是最常见的，但你可以通过在构建器上使用`nest`方法在任何类型的谓词上进行嵌套。上面仍然包含一些以共享`Accept`-header 谓词形式出现的重复。我们可以通过使用`nest`方法和`accept`方法进一步改进：

爪哇

```
RouterFunction<ServerResponse> route = route()
    .path("/person", b1 -> b1
        .nest(accept(APPLICATION_JSON), b2 -> b2
            .GET("/{id}", handler::getPerson)
            .GET(handler::listPeople))
        .POST("/person", handler::createPerson))
    .build();
```

Kotlin

```
import org.springframework.web.servlet.function.router

val route = router {
    "/person".nest {
        accept(APPLICATION_JSON).nest {
            GET("/{id}", handler::getPerson)
            GET("", handler::listPeople)
            POST("/person", handler::createPerson)
        }
    }
}
```

#### 1.4.4.运行服务器

[WebFlux](web-reactive.html#webflux-fn-running)

你通常通过[MVC Config](#mvc-config)在基于[`DispatcherHandler`]（#MVC- Servlet）的设置中运行路由器函数，该设置使用 Spring 配置来声明处理请求所需的组件。MVC 爪哇 配置声明以下基础设施组件以支持功能端点：

* `RouterFunctionMapping`:在 Spring 配置中检测一个或多个`RouterFunction<?>`bean，[命令他们](core.html#beans-factory-ordered)，通过`RouterFunction.andOther`对它们进行组合，并将请求路由到结果组合的`RouterFunction`。

* `HandlerFunctionAdapter`:允许`DispatcherHandler`调用映射到请求的`HandlerFunction`的简单适配器。

前面的组件让功能端点适合`DispatcherServlet`请求处理生命周期，并且（可能）与带注释的控制器（如果声明了任何控制器的话）并排运行。这也是 Spring 引导 Web 启动器启用功能端点的方式。

下面的示例展示了一个 WebFlux 爪哇 配置：

爪哇

```
@Configuration
@EnableMvc
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public RouterFunction<?> routerFunctionA() {
        // ...
    }

    @Bean
    public RouterFunction<?> routerFunctionB() {
        // ...
    }

    // ...

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        // configure message conversion...
    }

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        // configure CORS...
    }

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        // configure view resolution for HTML rendering...
    }
}
```

Kotlin

```
@Configuration
@EnableMvc
class WebConfig : WebMvcConfigurer {

    @Bean
    fun routerFunctionA(): RouterFunction<*> {
        // ...
    }

    @Bean
    fun routerFunctionB(): RouterFunction<*> {
        // ...
    }

    // ...

    override fun configureMessageConverters(converters: List<HttpMessageConverter<*>>) {
        // configure message conversion...
    }

    override fun addCorsMappings(registry: CorsRegistry) {
        // configure CORS...
    }

    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        // configure view resolution for HTML rendering...
    }
}
```

#### 1.4.5.过滤处理程序函数

[WebFlux](web-reactive.html#webflux-fn-handler-filter-function)

你可以使用路由函数生成器上的`before`、`after`或`filter`方法来过滤处理程序函数。对于注释，你可以通过使用`@ControllerAdvice`、`ServletFilter`或同时使用这两种方法来实现类似的功能。筛选器将应用于由构建器构建的所有路由。这意味着嵌套路由中定义的筛选器不适用于“顶层”路由。例如，考虑以下示例：

爪哇

```
RouterFunction<ServerResponse> route = route()
    .path("/person", b1 -> b1
        .nest(accept(APPLICATION_JSON), b2 -> b2
            .GET("/{id}", handler::getPerson)
            .GET(handler::listPeople)
            .before(request -> ServerRequest.from(request) (1)
                .header("X-RequestHeader", "Value")
                .build()))
        .POST("/person", handler::createPerson))
    .after((request, response) -> logResponse(response)) (2)
    .build();
```

|**1**|添加自定义请求头的`before`过滤器仅应用于两个 GET 路由。|
|-----|----------------------------------------------------------------------------------------------|
|**2**|记录响应的`after`过滤器应用于所有路由，包括嵌套的路由。|

Kotlin

```
import org.springframework.web.servlet.function.router

val route = router {
    "/person".nest {
        GET("/{id}", handler::getPerson)
        GET(handler::listPeople)
        before { (1)
            ServerRequest.from(it)
                    .header("X-RequestHeader", "Value").build()
        }
    }
    POST("/person", handler::createPerson)
    after { _, response -> (2)
        logResponse(response)
    }
}
```

|**1**|添加自定义请求头的`before`过滤器仅应用于两个 GET 路由。|
|-----|----------------------------------------------------------------------------------------------|
|**2**|记录响应的`after`过滤器应用于所有路由，包括嵌套的路由。|

路由器构建器上的`filter`方法接受`HandlerFilterFunction`:一个函数接受`ServerRequest`和`HandlerFunction`并返回`ServerResponse`。处理程序函数参数表示链中的下一个元素。这通常是路由到的处理程序，但是如果应用了多个，它也可以是另一个过滤器。

现在，我们可以在路由中添加一个简单的安全过滤器，假设我们有一个`SecurityManager`，它可以确定是否允许特定的路径。下面的示例展示了如何做到这一点：

爪哇

```
SecurityManager securityManager = ...

RouterFunction<ServerResponse> route = route()
    .path("/person", b1 -> b1
        .nest(accept(APPLICATION_JSON), b2 -> b2
            .GET("/{id}", handler::getPerson)
            .GET(handler::listPeople))
        .POST("/person", handler::createPerson))
    .filter((request, next) -> {
        if (securityManager.allowAccessTo(request.path())) {
            return next.handle(request);
        }
        else {
            return ServerResponse.status(UNAUTHORIZED).build();
        }
    })
    .build();
```

Kotlin

```
import org.springframework.web.servlet.function.router

val securityManager: SecurityManager = ...

val route = router {
    ("/person" and accept(APPLICATION_JSON)).nest {
        GET("/{id}", handler::getPerson)
        GET("", handler::listPeople)
        POST("/person", handler::createPerson)
        filter { request, next ->
            if (securityManager.allowAccessTo(request.path())) {
                next(request)
            }
            else {
                status(UNAUTHORIZED).build();
            }
        }
    }
}
```

前面的示例演示了调用`next.handle(ServerRequest)`是可选的。我们只允许在允许访问的情况下运行处理程序函数。

除了在路由器功能构建器上使用`filter`方法外，还可以通过`RouterFunction.filter(HandlerFilterFunction)`对现有的路由器功能应用过滤器。

|   |CORS 对功能端点的支持是通过专用的[`CorsFilter`]提供的。|
|---|----------------------------------------------------------------------------------------------------------------------|

### 1.5.URI 链接

[WebFlux](web-reactive.html#webflux-uri-building)

本节描述了 Spring 框架中可用来处理 URI 的各种选项。

#### 1.5.1.尿酸成分

Spring MVC 和 Spring WebFlux

`UriComponentsBuilder`有助于从具有变量的 URI 模板构建 URI，如下例所示：

爪哇

```
UriComponents uriComponents = UriComponentsBuilder
        .fromUriString("https://example.com/hotels/{hotel}")  (1)
        .queryParam("q", "{q}")  (2)
        .encode() (3)
        .build(); (4)

URI uri = uriComponents.expand("Westin", "123").toUri();  (5)
```

|**1**|带有 URI 模板的静态工厂方法。|
|-----|-----------------------------------------------------------|
|**2**|添加或替换 URI 组件。|
|**3**|请求对 URI 模板和 URI 变量进行编码。|
|**4**|建立`UriComponents`。|
|**5**|展开变量并获得`URI`。|

Kotlin

```
val uriComponents = UriComponentsBuilder
        .fromUriString("https://example.com/hotels/{hotel}")  (1)
        .queryParam("q", "{q}")  (2)
        .encode() (3)
        .build() (4)

val uri = uriComponents.expand("Westin", "123").toUri()  (5)
```

|**1**|带有 URI 模板的静态工厂方法。|
|-----|-----------------------------------------------------------|
|**2**|添加或替换 URI 组件。|
|**3**|请求对 URI 模板和 URI 变量进行编码。|
|**4**|建立`UriComponents`。|
|**5**|展开变量并获得`URI`。|

前面的示例可以合并为一个链，并用`buildAndExpand`将其缩短，如下例所示：

爪哇

```
URI uri = UriComponentsBuilder
        .fromUriString("https://example.com/hotels/{hotel}")
        .queryParam("q", "{q}")
        .encode()
        .buildAndExpand("Westin", "123")
        .toUri();
```

Kotlin

```
val uri = UriComponentsBuilder
        .fromUriString("https://example.com/hotels/{hotel}")
        .queryParam("q", "{q}")
        .encode()
        .buildAndExpand("Westin", "123")
        .toUri()
```

你可以通过直接访问一个 URI（这意味着编码）来进一步缩短它，如下例所示：

爪哇

```
URI uri = UriComponentsBuilder
        .fromUriString("https://example.com/hotels/{hotel}")
        .queryParam("q", "{q}")
        .build("Westin", "123");
```

Kotlin

```
val uri = UriComponentsBuilder
        .fromUriString("https://example.com/hotels/{hotel}")
        .queryParam("q", "{q}")
        .build("Westin", "123")
```

可以使用完整的 URI 模板进一步缩短它，如下例所示：

爪哇

```
URI uri = UriComponentsBuilder
        .fromUriString("https://example.com/hotels/{hotel}?q={q}")
        .build("Westin", "123");
```

Kotlin

```
val uri = UriComponentsBuilder
        .fromUriString("https://example.com/hotels/{hotel}?q={q}")
        .build("Westin", "123")
```

#### 1.5.2.UriBuilder

Spring MVC 和 Spring WebFlux

[`UriComponentsBuilder`]实现`UriBuilder`。你可以创建`UriBuilder`，然后使用`UriBuilderFactory`。同时，`UriBuilderFactory`和`UriBuilder`提供了一种基于共享配置（例如基本 URL、编码首选项和其他细节）的可插入机制，用于从 URI 模板构建 URI。

可以使用`UriBuilderFactory`配置`RestTemplate`和`WebClient`来定制 URI 的准备。`DefaultUriBuilderFactory`是`UriBuilderFactory`的默认实现，它在内部使用`UriComponentsBuilder`并公开共享配置选项。

下面的示例展示了如何配置`RestTemplate`:

爪哇

```
// import org.springframework.web.util.DefaultUriBuilderFactory.EncodingMode;

String baseUrl = "https://example.org";
DefaultUriBuilderFactory factory = new DefaultUriBuilderFactory(baseUrl);
factory.setEncodingMode(EncodingMode.TEMPLATE_AND_VALUES);

RestTemplate restTemplate = new RestTemplate();
restTemplate.setUriTemplateHandler(factory);
```

Kotlin

```
// import org.springframework.web.util.DefaultUriBuilderFactory.EncodingMode

val baseUrl = "https://example.org"
val factory = DefaultUriBuilderFactory(baseUrl)
factory.encodingMode = EncodingMode.TEMPLATE_AND_VALUES

val restTemplate = RestTemplate()
restTemplate.uriTemplateHandler = factory
```

下面的示例配置`WebClient`:

爪哇

```
// import org.springframework.web.util.DefaultUriBuilderFactory.EncodingMode;

String baseUrl = "https://example.org";
DefaultUriBuilderFactory factory = new DefaultUriBuilderFactory(baseUrl);
factory.setEncodingMode(EncodingMode.TEMPLATE_AND_VALUES);

WebClient client = WebClient.builder().uriBuilderFactory(factory).build();
```

Kotlin

```
// import org.springframework.web.util.DefaultUriBuilderFactory.EncodingMode

val baseUrl = "https://example.org"
val factory = DefaultUriBuilderFactory(baseUrl)
factory.encodingMode = EncodingMode.TEMPLATE_AND_VALUES

val client = WebClient.builder().uriBuilderFactory(factory).build()
```

此外，还可以直接使用`DefaultUriBuilderFactory`。它类似于使用`UriComponentsBuilder`，但是，它是一个实际的实例，它保存了配置和首选项，而不是静态工厂方法，如下例所示：

爪哇

```
String baseUrl = "https://example.com";
DefaultUriBuilderFactory uriBuilderFactory = new DefaultUriBuilderFactory(baseUrl);

URI uri = uriBuilderFactory.uriString("/hotels/{hotel}")
        .queryParam("q", "{q}")
        .build("Westin", "123");
```

Kotlin

```
val baseUrl = "https://example.com"
val uriBuilderFactory = DefaultUriBuilderFactory(baseUrl)

val uri = uriBuilderFactory.uriString("/hotels/{hotel}")
        .queryParam("q", "{q}")
        .build("Westin", "123")
```

#### 1.5.3.URI 编码

Spring MVC 和 Spring WebFlux

`UriComponentsBuilder`在两个级别上公开编码选项：

* [uricomponentsbuilder#encode（）](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/web/util/UriComponentsBuilder.html#encode--):先对 URI 模板进行预编码，然后在展开时对 URI 变量进行严格编码。

* [uricomponents#encode（）](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/web/util/UriComponents.html#encode--):编码 URI 组件*之后*URI 变量被展开。

这两个选项都用转义的八进制替换非 ASCII 和非法字符。然而，第一个选项也用 URI 变量中出现的保留意义替换字符。

|   |考虑一下“；”，它在某种程度上是合法的，但具有保留的含义。第一个选项在 URI 变量中用“%3b”替换<br/>；"；，但不在 URI 模板中。相比之下，第二个选项永远不会<br/>取代“；”，因为它是路径中的法律字符。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

在大多数情况下，第一个选项可能会给出预期的结果，因为它将 URI 变量视为不透明的数据来进行完全编码，而如果 URI 变量故意包含保留字符，则第二个选项是有用的。当完全不展开 URI 变量时，第二个选项也很有用，因为这也会对任何看起来像 URI 变量的内容进行编码。

下面的示例使用了第一个选项：

爪哇

```
URI uri = UriComponentsBuilder.fromPath("/hotel list/{city}")
        .queryParam("q", "{q}")
        .encode()
        .buildAndExpand("New York", "foo+bar")
        .toUri();

// Result is "/hotel%20list/New%20York?q=foo%2Bbar"
```

Kotlin

```
val uri = UriComponentsBuilder.fromPath("/hotel list/{city}")
        .queryParam("q", "{q}")
        .encode()
        .buildAndExpand("New York", "foo+bar")
        .toUri()

// Result is "/hotel%20list/New%20York?q=foo%2Bbar"
```

可以通过直接访问 URI（这意味着编码）来缩短前面的示例，如下例所示：

爪哇

```
URI uri = UriComponentsBuilder.fromPath("/hotel list/{city}")
        .queryParam("q", "{q}")
        .build("New York", "foo+bar");
```

Kotlin

```
val uri = UriComponentsBuilder.fromPath("/hotel list/{city}")
        .queryParam("q", "{q}")
        .build("New York", "foo+bar")
```

可以使用完整的 URI 模板进一步缩短它，如下例所示：

Java

```
URI uri = UriComponentsBuilder.fromUriString("/hotel list/{city}?q={q}")
        .build("New York", "foo+bar");
```

Kotlin

```
val uri = UriComponentsBuilder.fromUriString("/hotel list/{city}?q={q}")
        .build("New York", "foo+bar")
```

`WebClient`和`RestTemplate`通过`UriBuilderFactory`策略在内部扩展和编码 URI 模板。两者都可以使用自定义策略进行配置，如下例所示：

Java

```
String baseUrl = "https://example.com";
DefaultUriBuilderFactory factory = new DefaultUriBuilderFactory(baseUrl)
factory.setEncodingMode(EncodingMode.TEMPLATE_AND_VALUES);

// Customize the RestTemplate..
RestTemplate restTemplate = new RestTemplate();
restTemplate.setUriTemplateHandler(factory);

// Customize the WebClient..
WebClient client = WebClient.builder().uriBuilderFactory(factory).build();
```

Kotlin

```
val baseUrl = "https://example.com"
val factory = DefaultUriBuilderFactory(baseUrl).apply {
    encodingMode = EncodingMode.TEMPLATE_AND_VALUES
}

// Customize the RestTemplate..
val restTemplate = RestTemplate().apply {
    uriTemplateHandler = factory
}

// Customize the WebClient..
val client = WebClient.builder().uriBuilderFactory(factory).build()
```

`DefaultUriBuilderFactory`实现在内部使用`UriComponentsBuilder`来扩展和编码 URI 模板。作为工厂，它提供了一个单独的位置来配置编码方法，该方法基于以下编码模式之一：

* `TEMPLATE_AND_VALUES`:使用`UriComponentsBuilder#encode()`（对应于前面列表中的第一个选项）来预编码 URI 模板，并在展开时严格编码 URI 变量。

* `VALUES_ONLY`:不对 URI 模板进行编码，而是通过`UriUtils#encodeUriVariables`对 URI 变量进行严格编码，然后再将它们扩展到模板中。

* `URI_COMPONENT`:使用`UriComponents#encode()`，对应于前面列表中的第二个选项，来对 URI 组件值的编码*之后*URI 变量进行展开。

* `NONE`:不应用任何编码。

由于历史原因和向后兼容，`RestTemplate`被设置为`EncodingMode.URI_COMPONENT`。`WebClient`依赖于`DefaultUriBuilderFactory`中的默认值，该默认值从 5.0.x 中的`EncodingMode.URI_COMPONENT`更改为 5.1 中的`EncodingMode.TEMPLATE_AND_VALUES`。

#### 1.5.4.相对 Servlet 请求

可以使用`ServletUriComponentsBuilder`创建相对于当前请求的 URI，如下例所示：

Java

```
HttpServletRequest request = ...

// Re-uses scheme, host, port, path, and query string...

URI uri = ServletUriComponentsBuilder.fromRequest(request)
        .replaceQueryParam("accountId", "{id}")
        .build("123");
```

Kotlin

```
val request: HttpServletRequest = ...

// Re-uses scheme, host, port, path, and query string...

val uri = ServletUriComponentsBuilder.fromRequest(request)
        .replaceQueryParam("accountId", "{id}")
        .build("123")
```

你可以创建相对于上下文路径的 URI，如下例所示：

Java

```
HttpServletRequest request = ...

// Re-uses scheme, host, port, and context path...

URI uri = ServletUriComponentsBuilder.fromContextPath(request)
        .path("/accounts")
        .build()
        .toUri();
```

Kotlin

```
val request: HttpServletRequest = ...

// Re-uses scheme, host, port, and context path...

val uri = ServletUriComponentsBuilder.fromContextPath(request)
        .path("/accounts")
        .build()
        .toUri()
```

你可以创建相对于 Servlet 的 URI（例如，`/main/*`），如下例所示：

Java

```
HttpServletRequest request = ...

// Re-uses scheme, host, port, context path, and Servlet mapping prefix...

URI uri = ServletUriComponentsBuilder.fromServletMapping(request)
        .path("/accounts")
        .build()
        .toUri();
```

Kotlin

```
val request: HttpServletRequest = ...

// Re-uses scheme, host, port, context path, and Servlet mapping prefix...

val uri = ServletUriComponentsBuilder.fromServletMapping(request)
        .path("/accounts")
        .build()
        .toUri()
```

|   |截至 5.1，`ServletUriComponentsBuilder`忽略来自`Forwarded`和`X-Forwarded-*`头的信息，这两个头指定了客户机发起的地址。考虑使用[`ForwardedHeaderFilter`]（#filters-forwarded-header）来提取和使用或丢弃<br/>这样的 header。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.5.5.与控制器的链接

Spring MVC 提供了一种用于准备连接到控制器的机制的方法。例如，下面的 MVC 控制器允许创建链接：

Java

```
@Controller
@RequestMapping("/hotels/{hotel}")
public class BookingController {

    @GetMapping("/bookings/{booking}")
    public ModelAndView getBooking(@PathVariable Long booking) {
        // ...
    }
}
```

Kotlin

```
@Controller
@RequestMapping("/hotels/{hotel}")
class BookingController {

    @GetMapping("/bookings/{booking}")
    fun getBooking(@PathVariable booking: Long): ModelAndView {
        // ...
    }
}
```

你可以通过按名称引用方法来准备链接，如下例所示：

爪哇

```
UriComponents uriComponents = MvcUriComponentsBuilder
    .fromMethodName(BookingController.class, "getBooking", 21).buildAndExpand(42);

URI uri = uriComponents.encode().toUri();
```

Kotlin

```
val uriComponents = MvcUriComponentsBuilder
    .fromMethodName(BookingController::class.java, "getBooking", 21).buildAndExpand(42)

val uri = uriComponents.encode().toUri()
```

在前面的示例中，我们提供了实际的方法参数值（在本例中，长值：`21`），将其用作路径变量并插入到 URL 中。此外，我们提供了值`42`来填充任何剩余的 URI 变量，例如从类型级请求映射继承的`hotel`变量。如果该方法有更多的参数，我们可以为 URL 不需要的参数提供 NULL。通常，只有`@PathVariable`和`@RequestParam`参数与构造 URL 有关。

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

爪哇

```
UriComponents uriComponents = MvcUriComponentsBuilder
    .fromMethodCall(on(BookingController.class).getBooking(21)).buildAndExpand(42);

URI uri = uriComponents.encode().toUri();
```

Kotlin

```
val uriComponents = MvcUriComponentsBuilder
    .fromMethodCall(on(BookingController::class.java).getBooking(21)).buildAndExpand(42)

val uri = uriComponents.encode().toUri()
```

|   |控制器方法签名在其设计中受到限制，因为它们应该可用于<br/>与`fromMethodCall`的链接创建。除了需要适当的参数签名外，<br/>在返回类型上还有一个技术限制（即，为链接生成器调用生成运行时代理<br/>），因此返回类型不能是`final`。特别是，<br/>视图名称的常见`String`返回类型在此不工作。你应该使用`ModelAndView`，甚至使用普通的`Object`（带有`String`返回值）。|
|---| |

较早的示例使用`MvcUriComponentsBuilder`中的静态方法。在内部，它们依赖`ServletUriComponentsBuilder`从当前请求的方案、主机、端口、上下文路径和 Servlet 路径准备一个基本 URL。这在大多数情况下都很有效。然而，有时候，这可能是不够的。例如，你可能在请求的上下文之外（例如准备链接的批处理过程），或者你可能需要插入路径前缀（例如从请求路径中删除并需要重新插入到链接中的区域设置前缀）。

对于这种情况，你可以使用静态`fromXxx`重载方法，该方法接受`UriComponentsBuilder`来使用基本 URL。或者，你可以使用基本 URL 创建`MvcUriComponentsBuilder`的实例，然后使用基于实例的`withXxx`方法。例如，下面的列表使用`withMethodCall`:

爪哇

```
UriComponentsBuilder base = ServletUriComponentsBuilder.fromCurrentContextPath().path("/en");
MvcUriComponentsBuilder builder = MvcUriComponentsBuilder.relativeTo(base);
builder.withMethodCall(on(BookingController.class).getBooking(21)).buildAndExpand(42);

URI uri = uriComponents.encode().toUri();
```

Kotlin

```
val base = ServletUriComponentsBuilder.fromCurrentContextPath().path("/en")
val builder = MvcUriComponentsBuilder.relativeTo(base)
builder.withMethodCall(on(BookingController::class.java).getBooking(21)).buildAndExpand(42)

val uri = uriComponents.encode().toUri()
```

|   |截至 5.1，`MvcUriComponentsBuilder`忽略来自`Forwarded`和`X-Forwarded-*`头的信息，这些头指定了源自客户端的地址。考虑使用[ForwardedHeaderFilter](#filters-forwarded-headers)来提取和使用或丢弃<br/>这样的标题。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.5.6.视图中的链接

在 ThymeLeaf、Freemarker 或 JSP 等视图中，你可以通过引用每个请求映射的隐式或显式分配的名称来构建到带注释的控制器的链接。

考虑以下示例：

爪哇

```
@RequestMapping("/people/{id}/addresses")
public class PersonAddressController {

    @RequestMapping("/{country}")
    public HttpEntity<PersonAddress> getAddress(@PathVariable String country) { ... }
}
```

Kotlin

```
@RequestMapping("/people/{id}/addresses")
class PersonAddressController {

    @RequestMapping("/{country}")
    fun getAddress(@PathVariable country: String): HttpEntity<PersonAddress> { ... }
}
```

给定上述控制器，你可以从 JSP 准备一个链接，如下所示：

```
<%@ taglib uri="http://www.springframework.org/tags" prefix="s" %>
...
<a href="${s:mvcUrl('PAC#getAddress').arg(0,'US').buildAndExpand('123')}">Get Address</a>
```

前面的示例依赖于 Spring 标记库（即 meta-inf/ Spring.tld）中声明的`mvcUrl`函数，但是很容易定义自己的函数或为其他模板技术准备类似的函数。

这就是它的工作原理。在启动时，每个`@RequestMapping`都通过`HandlerMethodMappingNamingStrategy`分配一个默认名称，其默认实现使用类的大写字母和方法名称（例如，`getThing`中的`getThing`方法变成“tc#getthing”）。如果存在名称冲突，可以使用`@RequestMapping(name="..")`分配显式名称或实现自己的`HandlerMethodMappingNamingStrategy`。

### 1.6.异步请求

[与 WebFlux 相比](#mvc-ann-async-vs-webflux)

Spring MVC 与 Servlet 3.0 异步请求[processing](#mvc-ann-async-processing)具有广泛的集成：

* [`DeferredResult`]（#mvc-ann-async-deferredresult）和[`Callable`]（#mvc-ann-async-callable）在控制器方法中的返回值为单个异步返回值提供了基本支持。

* 控制器可以[stream](#mvc-ann-async-http-streaming)多个值，包括[SSE](#mvc-ann-async-sse)和[raw data](#mvc-ann-async-output-stream)。

* 控制器可以使用反应式客户端并返回[反应类型](#mvc-ann-async-reactive-types)进行响应处理。

#### 1.6.1.`DeferredResult`

[与 WebFlux 相比](#mvc-ann-async-vs-webflux)

一旦异步请求处理特性在 Servlet 容器中[enabled](#mvc-ann-async-configuration)，控制器方法就可以用`DeferredResult`包装任何受支持的控制器方法返回值，如下例所示：

爪哇

```
@GetMapping("/quotes")
@ResponseBody
public DeferredResult<String> quotes() {
    DeferredResult<String> deferredResult = new DeferredResult<String>();
    // Save the deferredResult somewhere..
    return deferredResult;
}

// From some other thread...
deferredResult.setResult(result);
```

Kotlin

```
@GetMapping("/quotes")
@ResponseBody
fun quotes(): DeferredResult<String> {
    val deferredResult = DeferredResult<String>()
    // Save the deferredResult somewhere..
    return deferredResult
}

// From some other thread...
deferredResult.setResult(result)
```

控制器可以异步地从不同的线程产生返回值——例如，响应外部事件（JMS 消息）、计划任务或其他事件。

#### 1.6.2.`Callable`

[与 WebFlux 相比](#mvc-ann-async-vs-webflux)

控制器可以用`java.util.concurrent.Callable`包装任何受支持的返回值，如下例所示：

爪哇

```
@PostMapping
public Callable<String> processUpload(final MultipartFile file) {

    return new Callable<String>() {
        public String call() throws Exception {
            // ...
            return "someView";
        }
    };
}
```

Kotlin

```
@PostMapping
fun processUpload(file: MultipartFile) = Callable<String> {
    // ...
    "someView"
}
```

然后可以通过[configured](#mvc-ann-async-configuration-spring-mvc)`TaskExecutor`运行给定任务来获得返回值。

#### 1.6.3.处理

[与 WebFlux 相比](#mvc-ann-async-vs-webflux)

下面是 Servlet 异步请求处理的一个非常简明的概述：

* 可以通过调用`request.startAsync()`将`ServletRequest`置于异步模式。这样做的主要效果是， Servlet（以及任何过滤器）都可以退出，但响应仍然是开放的，以便稍后完成处理。

* 对`request.startAsync()`的调用返回`AsyncContext`，你可以使用它来进一步控制异步处理。例如，它提供了`dispatch`方法，它类似于来自 Servlet API 的转发，只是它允许应用程序在 Servlet 容器线程上恢复请求处理。

* `ServletRequest`提供对当前`DispatcherType`的访问，你可以使用它来区分处理初始请求、异步分派、转发和其他 Dispatcher 类型。

`DeferredResult`处理工作如下：

* 控制器返回一个`DeferredResult`，并将其保存在内存队列或列表中，以便访问它。

* Spring MVC 调用`request.startAsync()`。

* 同时，`DispatcherServlet`和所有配置的过滤器退出请求处理线程，但响应仍然是打开的。

* 应用程序设置来自某个线程的`DeferredResult`，然后 Spring MVC 将请求分派回 Servlet 容器。

* 将再次调用`DispatcherServlet`，并继续使用异步产生的返回值进行处理。

`Callable`处理工作如下：

* 控制器返回`Callable`。

* Spring MVC 调用`request.startAsync()`，并将`Callable`提交给`TaskExecutor`，以便在单独的线程中进行处理。

* 同时，`DispatcherServlet`和所有过滤器退出 Servlet 容器线程，但响应仍然是打开的。

* 最终，`Callable`产生一个结果， Spring MVC 将请求分派回 Servlet 容器以完成处理。

* 将再次调用`DispatcherServlet`，并使用来自`Callable`的异步产生的返回值恢复处理。

对于进一步的背景和上下文，你还可以阅读 Spring MVC3.2 中引入了异步请求处理支持的[博客文章](https://spring.io/blog/2012/05/07/spring-mvc-3-2-preview-introducing-servlet-3-async-support)。

##### 异常处理

当使用`DeferredResult`时，可以选择是否调用`setResult`或`setErrorResult`，但有例外。在这两种情况下， Spring MVC 将请求分派回 Servlet 容器以完成处理。然后将其视为控制器方法返回给定的值或产生给定的异常。然后，异常将通过常规的异常处理机制（例如，调用`@ExceptionHandler`方法）。

当使用`Callable`时，会出现类似的处理逻辑，主要的区别是从`Callable`返回结果，或者由它引发异常。

##### 拦截

`HandlerInterceptor`实例可以是类型`AsyncHandlerInterceptor`的，以便在开始异步处理的初始请求上接收`afterConcurrentHandlingStarted`回调（而不是`postHandle`和`afterCompletion`）。

`HandlerInterceptor`实现还可以注册`CallableProcessingInterceptor`或`DeferredResultProcessingInterceptor`，以更深入地与异步请求的生命周期集成（例如，处理超时事件）。详见[`AsyncHandlerInterceptor`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet/asynchandlerinterceptor.html）。

`DeferredResult`提供`onTimeout(Runnable)`和`onCompletion(Runnable)`回调。有关更多详细信息，请参见`DeferredResult`的[javadoc]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/context/request/async/deferredresult.html）。`Callable`可以替代`WebAsyncTask`，后者公开了用于超时和完成回调的其他方法。

##### 与 WebFlux 相比

Servlet API 最初是为通过过滤器- Servlet 链而构建的。 Servlet 3.0 中添加的异步请求处理允许应用程序退出 Filter- Servlet 链，但允许响应开放以进行进一步的处理。 Spring MVC 异步支持是围绕该机制构建的。当控制器返回`DeferredResult`时，退出 filter- Servlet 链，并释放 Servlet 容器线程。稍后，当设置`DeferredResult`时，将执行`ASYNC`调度（发送到相同的 URL），在此期间将再次映射控制器，但是将使用`DeferredResult`值（就像控制器返回了它一样）来恢复处理。

相比之下， Spring WebFlux 既不是建立在 Servlet API 上的，也不需要这样的异步请求处理特性，因为它在设计上是异步的。异步处理被内置在所有框架契约中，并且在请求处理的所有阶段都得到了本质上的支持。

从编程模型的角度来看， Spring MVC 和 Spring WebFlux 都支持异步和作为控制器方法中的返回值。 Spring MVC 甚至支持流媒体，包括反压力反应。然而，对响应的单独写仍然是阻塞的（并且在单独的线程上执行），这与 WebFlux 不同，后者依赖于非阻塞的 I/O，并且不需要为每个写增加一个线程。

另一个根本的区别是 Spring MVC 不支持控制器方法参数中的异步或反应类型（例如，`@RequestBody`，`@RequestPart`，以及其他），也不明确支持异步和反应类型作为模型属性。 Spring WebFlux 确实支持这一切。

#### 1.6.4.HTTP 流媒体

[WebFlux](web-reactive.html#webflux-codecs-streaming)

对于单个异步返回值，可以使用`DeferredResult`和`Callable`。如果你想要产生多个异步值并将其写入响应中，该怎么办？这一节描述了如何做到这一点。

##### 对象

你可以使用`ResponseBodyEmitter`返回值来生成一个对象流，其中每个对象都使用[`HttpMessageConverter`]（integration.html#rest-message-conversion）序列化并写入响应，如下例所示：

爪哇

```
@GetMapping("/events")
public ResponseBodyEmitter handle() {
    ResponseBodyEmitter emitter = new ResponseBodyEmitter();
    // Save the emitter somewhere..
    return emitter;
}

// In some other thread
emitter.send("Hello once");

// and again later on
emitter.send("Hello again");

// and done at some point
emitter.complete();
```

Kotlin

```
@GetMapping("/events")
fun handle() = ResponseBodyEmitter().apply {
    // Save the emitter somewhere..
}

// In some other thread
emitter.send("Hello once")

// and again later on
emitter.send("Hello again")

// and done at some point
emitter.complete()
```

你还可以使用`ResponseBodyEmitter`作为`ResponseEntity`中的主体，让你自定义响应的状态和标题。

当`emitter`抛出`IOException`时（例如，如果远程客户端消失了），应用程序不负责清理连接，并且不应调用`emitter.complete`或`emitter.completeWithError`。相反， Servlet 容器自动发起`AsyncListener`错误通知，其中 Spring MVC 进行`completeWithError`调用。然后，这个调用执行对应用程序的最后一次`ASYNC`分派，在此期间， Spring MVC 调用配置的异常解析器并完成请求。

##### SSE

`SseEmitter`（`ResponseBodyEmitter`的子类）提供对[服务器发送的事件](https://www.w3.org/TR/eventsource/)的支持，其中从服务器发送的事件是根据 W3C SSE 规范进行格式化的。要从控制器生成 SSE 流，请返回`SseEmitter`，如下例所示：

爪哇

```
@GetMapping(path="/events", produces=MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter handle() {
    SseEmitter emitter = new SseEmitter();
    // Save the emitter somewhere..
    return emitter;
}

// In some other thread
emitter.send("Hello once");

// and again later on
emitter.send("Hello again");

// and done at some point
emitter.complete();
```

Kotlin

```
@GetMapping("/events", produces = [MediaType.TEXT_EVENT_STREAM_VALUE])
fun handle() = SseEmitter().apply {
    // Save the emitter somewhere..
}

// In some other thread
emitter.send("Hello once")

// and again later on
emitter.send("Hello again")

// and done at some point
emitter.complete()
```

虽然 SSE 是流媒体进入浏览器的主要选项，但请注意，Internet Explorer 不支持服务器发送的事件。考虑使用 Spring 的[WebSocket messaging](#websocket)和[Sockjs 后援](#websocket-fallback)传输（包括 SSE），这些传输针对广泛的浏览器。

另请参见[上一节](#mvc-ann-async-objects)有关异常处理的说明。

##### 原始数据

有时，绕过消息转换并直接流到响应`OutputStream`是有用的（例如，用于文件下载）。你可以使用`StreamingResponseBody`返回值类型来执行此操作，如下例所示：

爪哇

```
@GetMapping("/download")
public StreamingResponseBody handle() {
    return new StreamingResponseBody() {
        @Override
        public void writeTo(OutputStream outputStream) throws IOException {
            // write...
        }
    };
}
```

Kotlin

```
@GetMapping("/download")
fun handle() = StreamingResponseBody {
    // write...
}
```

你可以使用`StreamingResponseBody`作为`ResponseEntity`中的主体来定制响应的状态和标题。

#### 1.6.5.反应类型

[WebFlux](web-reactive.html#webflux-codecs-streaming)

Spring MVC 支持在控制器中使用反应式客户端库（在 WebFlux 部分中也读）。这包括来自`WebClient`的`spring-webflux`和其他的，例如 Spring 数据反应性数据存储库。在这样的场景中，能够从控制器方法返回无功类型是很方便的。

反应性返回值的处理如下：

* 对单值 promise 进行了调整，类似于使用`DeferredResult`。例如`Mono`或`Single`。

* 具有流媒体类型的多值流（例如`application/x-ndjson`或`text/event-stream`）被适配，类似于使用`ResponseBodyEmitter`或`SseEmitter`。例如`Flux`或`Observable`。应用程序还可以返回`Flux<ServerSentEvent>`或`Observable<ServerSentEvent>`。

* 具有任意其他媒体类型（例如`application/json`）的多值流被适配，类似于使用`DeferredResult<List<?>>`。

|   |Spring MVC 通过[`ReactiveAdapterRegistry`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/core/reactiveadapterregistry.html）从`spring-core`支持 reactor 和 rxjava，这使得它能够适应多个反应库。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

对于流到响应，支持反应背压，但是写到响应仍然是阻塞的，并且是通过[configured](#mvc-ann-async-configuration-spring-mvc)`TaskExecutor`在单独的线程上运行的，以避免阻塞上游的源（例如从`Flux`返回的`WebClient`）。默认情况下，`SimpleAsyncTaskExecutor`用于阻塞写操作，但这在加载时不适用。如果计划使用反应式类型的流，则应该使用[MVC 配置](#mvc-ann-async-configuration-spring-mvc)来配置任务执行器。

#### 1.6.6.断开连接

[WebFlux](web-reactive.html#webflux-codecs-streaming)

Servlet 当远程客户端消失时，API 不提供任何通知。因此，在流到响应的同时，无论是通过[SseEmitter](#mvc-ann-async-sse)还是[反应类型](#mvc-ann-async-reactive-types)，定期发送数据是很重要的，因为如果客户端已断开连接，则写操作就会失败。发送可以采取空（仅限注释）SSE 事件的形式，或者任何其他数据，而另一方必须将其解释为心跳并忽略这些数据。

或者，考虑使用具有内置心跳机制的 Web 消息传递解决方案（例如[STOMP over WebSocket](#websocket-stomp)或 WebSocket with[SockJS](#websocket-fallback)）。

#### 1.6.7.配置

[与 WebFlux 相比](#mvc-ann-async-vs-webflux)

异步请求处理特性必须在 Servlet 容器级别上启用。MVC 配置还为异步请求公开了几个选项。

##### Servlet 集装箱

Filter 和 Servlet 声明有一个`asyncSupported`标志，需要将其设置为`true`，以启用异步请求处理。此外，应该声明过滤器映射来处理`ASYNC``javax.servlet.DispatchType`。

在 爪哇 配置中，当你使用`AbstractAnnotationConfigDispatcherServletInitializer`初始化 Servlet 容器时，这是自动完成的。

在`web.xml`配置 中，可以将`<async-supported>true</async-supported>`添加到`DispatcherServlet`声明和`Filter`声明中，并添加`<dispatcher>ASYNC</dispatcher>`以过滤映射。

##### Spring MVC

MVC 配置公开了以下与异步请求处理相关的选项：

* 爪哇 配置：在`WebMvcConfigurer`上使用`configureAsyncSupport`回调。

* XML 命名空间：使用`<mvc:annotation-driven>`下的`<async-support>`元素。

你可以配置以下内容：

* 异步请求的默认超时值（如果未设置该超时值）取决于底层 Servlet 容器。

* `AsyncTaskExecutor`用于在使用[反应类型](#mvc-ann-async-reactive-types)进行流式传输时阻止写操作，以及用于执行从控制器方法返回的`Callable`实例。我们强烈建议配置此属性，如果你使用无反应类型的流或具有返回`Callable`的控制器方法，因为默认情况下，它是`SimpleAsyncTaskExecutor`。

* `DeferredResultProcessingInterceptor`实现和`CallableProcessingInterceptor`实现。

请注意，你还可以在`DeferredResult`、`ResponseBodyEmitter`和`SseEmitter`上设置默认的超时值。对于`Callable`，可以使用`WebAsyncTask`来提供超时值。

### 1.7.科尔斯

[WebFlux](web-reactive.html#webflux-cors)

Spring MVC 允许你处理 CORS（跨源资源共享）。这一节描述了如何做到这一点。

#### 1.7.1.导言

[WebFlux](web-reactive.html#webflux-cors-intro)

出于安全原因，浏览器禁止对当前来源以外的资源进行 Ajax 调用。例如，你可以在一个标签中设置你的银行帐户，而在另一个标签中设置 Evil.com。来自 Evil.com 的脚本不应该能够使用你的凭据向你的银行 API 发出 Ajax 请求——例如，从你的帐户中取款！

跨源资源共享是由[大多数浏览器](https://caniuse.com/#feat=cors)实现的[W3C 规范](https://www.w3.org/TR/cors/)，它允许你指定授权哪种类型的跨域请求，而不是使用基于 IFRAME 或 JSONP 的安全性较低、功能较弱的解决方案。

#### 1.7.2.处理

[WebFlux](web-reactive.html#webflux-cors-processing)

CORS 规范区分了飞行前、简单和实际请求。要了解 CORS 的工作原理，你可以阅读[这篇文章](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)等，或者查看规范以获得更多详细信息。

Spring MVC实现方式提供了对 CORS 的内置支持。在成功地将一个请求映射到一个处理程序之后，`HandlerMapping`实现将检查 CORS 配置中给定的请求和处理程序，并采取进一步的操作。前置请求是直接处理的，而简单和实际的 CORS 请求是截获、验证的，并且设置了所需的 CORS 响应头。

为了启用跨源请求（即存在`Origin`头并与请求的主机不同），你需要有一些显式声明的 CORS 配置。如果没有找到匹配的 CORS 配置，则拒绝预航前请求。没有 CORS 头被添加到简单的和实际的 CORS 请求的响应中，因此，浏览器会拒绝它们。

每个`HandlerMapping`都可以单独使用基于 URL 模式的[configured](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/web/servlet/handler/AbstractHandlerMapping.html#setCors配置s-java.util.Map-)映射`CorsConfiguration`。在大多数情况下，应用程序使用 MVC 爪哇 配置或 XML 命名空间来声明这样的映射，这会导致将单个全局映射传递给所有`HandlerMapping`实例。

你可以将`HandlerMapping`级别的全局 CORS 配置与更细粒度的、处理程序级别的 CORS 配置结合起来。例如，带注释的控制器可以使用类或方法级别的`@CrossOrigin`注释（其他处理程序可以实现`CorsConfigurationSource`）。

结合全局和局部配置的规则通常是累加的——例如，所有全局配置和所有局部配置。对于那些只能接受单个值的属性，例如。`allowCredentials`和`maxAge`，局部重写全局值。详见[`CorsConfiguration#combine(CorsConfiguration)`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/cors/corsconfiguration.html#combine-org.springframework.web.cors.corsconfiguration-）。

|   |要从源代码中了解更多信息或进行高级定制，请检查后面的代码：<br/><br/>*`CorsConfiguration`<br/><br/>*`CorsProcessor`，`DefaultCorsProcessor`<br/>`AbstractHandlerMapping`|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.7.3.`@CrossOrigin`

[WebFlux](web-reactive.html#webflux-cors-controller)

[`@CrossOrigin`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/bind/annotation/crossorigin.html）注解可以在带注释的控制器方法上实现跨源请求，如下例所示：

爪哇

```
@RestController
@RequestMapping("/account")
public class AccountController {

    @CrossOrigin
    @GetMapping("/{id}")
    public Account retrieve(@PathVariable Long id) {
        // ...
    }

    @DeleteMapping("/{id}")
    public void remove(@PathVariable Long id) {
        // ...
    }
}
```

Kotlin

```
@RestController
@RequestMapping("/account")
class AccountController {

    @CrossOrigin
    @GetMapping("/{id}")
    fun retrieve(@PathVariable id: Long): Account {
        // ...
    }

    @DeleteMapping("/{id}")
    fun remove(@PathVariable id: Long) {
        // ...
    }
}
```

默认情况下，`@CrossOrigin`允许：

* 所有的起源。

* 所有标题。

* 将控制器方法映射到的所有 HTTP 方法。

`allowCredentials`默认情况下不启用，因为这建立了一个信任级别，该级别公开敏感的特定于用户的信息（例如 Cookie 和 CSRF 令牌），并且只应在适当的情况下使用。当启用`allowOrigins`时，要么必须将`allowOrigins`设置为一个或多个特定的域（但不是特殊值`"*"`），要么将`allowOriginPatterns`属性替换为可用于匹配到源集的动态。

`maxAge`设置为 30 分钟。

`@CrossOrigin`在类级别上也是支持的，并且所有方法都会继承它，如下例所示：

爪哇

```
@CrossOrigin(origins = "https://domain2.com", maxAge = 3600)
@RestController
@RequestMapping("/account")
public class AccountController {

    @GetMapping("/{id}")
    public Account retrieve(@PathVariable Long id) {
        // ...
    }

    @DeleteMapping("/{id}")
    public void remove(@PathVariable Long id) {
        // ...
    }
}
```

Kotlin

```
@CrossOrigin(origins = ["https://domain2.com"], maxAge = 3600)
@RestController
@RequestMapping("/account")
class AccountController {

    @GetMapping("/{id}")
    fun retrieve(@PathVariable id: Long): Account {
        // ...
    }

    @DeleteMapping("/{id}")
    fun remove(@PathVariable id: Long) {
        // ...
    }
```

可以在类级别和方法级别使用`@CrossOrigin`，如下例所示：

爪哇

```
@CrossOrigin(maxAge = 3600)
@RestController
@RequestMapping("/account")
public class AccountController {

    @CrossOrigin("https://domain2.com")
    @GetMapping("/{id}")
    public Account retrieve(@PathVariable Long id) {
        // ...
    }

    @DeleteMapping("/{id}")
    public void remove(@PathVariable Long id) {
        // ...
    }
}
```

Kotlin

```
@CrossOrigin(maxAge = 3600)
@RestController
@RequestMapping("/account")
class AccountController {

    @CrossOrigin("https://domain2.com")
    @GetMapping("/{id}")
    fun retrieve(@PathVariable id: Long): Account {
        // ...
    }

    @DeleteMapping("/{id}")
    fun remove(@PathVariable id: Long) {
        // ...
    }
}
```

#### 1.7.4.全局配置

[WebFlux](web-reactive.html#webflux-cors-global)

除了细粒度的控制器方法级配置外，你可能还需要定义一些全局 CORS 配置。你可以在任何`HandlerMapping`上单独设置基于 URL 的`CorsConfiguration`映射。然而，大多数应用程序使用 MVC 爪哇 配置或 MVC XML 命名空间来实现这一点。

默认情况下，全局配置启用以下功能：

* 所有的起源。

* 所有标题。

* `GET`，`HEAD`，和`POST`方法。

`allowCredentials`默认情况下不启用，因为这建立了一个信任级别，该级别公开敏感的特定于用户的信息（例如 Cookie 和 CSRF 令牌），并且只应在适当的情况下使用。当启用`allowOrigins`时，要么必须将`allowOrigins`设置为一个或多个特定的域（但不是特殊值`"*"`），要么可选择将`allowOriginPatterns`属性用于匹配到源集的动态。

`maxAge`设置为 30 分钟。

##### 爪哇 配置

[WebFlux](web-reactive.html#webflux-cors-global)

要在 MVC 爪哇 配置中启用 CORS，可以使用`CorsRegistry`回调，如下例所示：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {

        registry.addMapping("/api/**")
            .allowedOrigins("https://domain2.com")
            .allowedMethods("PUT", "DELETE")
            .allowedHeaders("header1", "header2", "header3")
            .exposedHeaders("header1", "header2")
            .allowCredentials(true).maxAge(3600);

        // Add more mappings...
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun addCorsMappings(registry: CorsRegistry) {

        registry.addMapping("/api/**")
                .allowedOrigins("https://domain2.com")
                .allowedMethods("PUT", "DELETE")
                .allowedHeaders("header1", "header2", "header3")
                .exposedHeaders("header1", "header2")
                .allowCredentials(true).maxAge(3600)

        // Add more mappings...
    }
}
```

##### XML 配置

要在 XML 名称空间中启用 COR，可以使用`<mvc:cors>`元素，如下例所示：

```
<mvc:cors>

    <mvc:mapping path="/api/**"
        allowed-origins="https://domain1.com, https://domain2.com"
        allowed-methods="GET, PUT"
        allowed-headers="header1, header2, header3"
        exposed-headers="header1, header2" allow-credentials="true"
        max-age="123" />

    <mvc:mapping path="/resources/**"
        allowed-origins="https://domain1.com" />

</mvc:cors>
```

#### 1.7.5.CORS 过滤器

[WebFlux](webflux-cors.html#webflux-cors-webfilter)

你可以通过内置的[`CorsFilter`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/filter/corsfilter.html）应用 CORS 支持。

|   |如果尝试使用带有 Spring 安全性的`CorsFilter`，请记住，对于 CORS，<br/> Spring 安全性具有[内置支持](https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#cors)。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

要配置过滤器，请将`CorsConfigurationSource`传递到其构造函数，如下例所示：

爪哇

```
CorsConfiguration config = new CorsConfiguration();

// Possibly...
// config.applyPermitDefaultValues()

config.setAllowCredentials(true);
config.addAllowedOrigin("https://domain1.com");
config.addAllowedHeader("*");
config.addAllowedMethod("*");

UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", config);

CorsFilter filter = new CorsFilter(source);
```

Kotlin

```
val config = CorsConfiguration()

// Possibly...
// config.applyPermitDefaultValues()

config.allowCredentials = true
config.addAllowedOrigin("https://domain1.com")
config.addAllowedHeader("*")
config.addAllowedMethod("*")

val source = UrlBasedCorsConfigurationSource()
source.registerCorsConfiguration("/**", config)

val filter = CorsFilter(source)
```

### 1.8.网络安全

[WebFlux](web-reactive.html#webflux-web-security)

[Spring Security](https://projects.spring.io/spring-security/)项目提供了保护 Web 应用程序免受恶意攻击的支持。请参阅 Spring 安全参考文档，包括：

* [Spring MVC Security](https://docs.spring.io/spring-security/site/docs/current/reference/html5/#mvc)

* [Spring MVC Test Support](https://docs.spring.io/spring-security/site/docs/current/reference/html5/#test-mockmvc)

* [CSRF 保护](https://docs.spring.io/spring-security/site/docs/current/reference/html5/#csrf)

* [安全响应标头](https://docs.spring.io/spring-security/site/docs/current/reference/html5/#headers)

[HDIV](https://hdiv.org/)是与 Spring MVC 集成的另一种 Web 安全框架。

### 1.9.HTTP 缓存

[WebFlux](web-reactive.html#webflux-caching)

HTTP 缓存可以显著提高 Web 应用程序的性能。HTTP 缓存围绕`Cache-Control`响应头，随后是条件请求头（例如`Last-Modified`和`ETag`）。`Cache-Control`建议私有（例如，浏览器）和公共（例如，代理）缓存如何缓存和重用响应。`ETag`报头用于发出条件请求，如果内容没有更改，则该请求可能在没有正文的情况下导致 304（未 \_modified）。`ETag`可以看作是`Last-Modified`标头的更复杂的继承。

本节描述了 Spring Web MVC 中可用的与 HTTP 缓存相关的选项。

#### 1.9.1.`CacheControl`

[WebFlux](web-reactive.html#webflux-caching-cachecontrol)

[`CacheControl`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/http/cachecontrol.html）提供了对配置`Cache-Control`标头相关设置的支持，并在许多地方被接受为参数：

* [`WebContentInterceptor`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet/mvc/webcontentinterceptor.html）

* [`WebContentGenerator`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet/support/webcontentgenerator.html）

* [控制器](#mvc-caching-etag-lastmodified)

* [静态资源](#mvc-caching-static-resources)

虽然[RFC 7234](https://tools.ietf.org/html/rfc7234#section-5.2.2)描述了`Cache-Control`响应头的所有可能的指令，但`CacheControl`类型采用了一种面向用例的方法，该方法关注于常见的场景：

爪哇

```
// Cache for an hour - "Cache-Control: max-age=3600"
CacheControl ccCacheOneHour = CacheControl.maxAge(1, TimeUnit.HOURS);

// Prevent caching - "Cache-Control: no-store"
CacheControl ccNoStore = CacheControl.noStore();

// Cache for ten days in public and private caches,
// public caches should not transform the response
// "Cache-Control: max-age=864000, public, no-transform"
CacheControl ccCustom = CacheControl.maxAge(10, TimeUnit.DAYS).noTransform().cachePublic();
```

Kotlin

```
// Cache for an hour - "Cache-Control: max-age=3600"
val ccCacheOneHour = CacheControl.maxAge(1, TimeUnit.HOURS)

// Prevent caching - "Cache-Control: no-store"
val ccNoStore = CacheControl.noStore()

// Cache for ten days in public and private caches,
// public caches should not transform the response
// "Cache-Control: max-age=864000, public, no-transform"
val ccCustom = CacheControl.maxAge(10, TimeUnit.DAYS).noTransform().cachePublic()
```

`WebContentGenerator`还接受一个更简单的`cachePeriod`属性（以秒为单位定义），其工作方式如下：

* `-1`值不会生成`Cache-Control`响应报头。

* 通过使用`'Cache-Control: no-store'`指令，`0`值可以防止缓存。

* 通过使用`'Cache-Control: max-age=n'`指令，`n > 0`值将给定的响应缓存为`n`秒。

#### 1.9.2.控制器

[WebFlux](web-reactive.html#webflux-caching-etag-lastmodified)

控制器可以添加对 HTTP 缓存的显式支持。我们建议这样做，因为资源的`lastModified`或`ETag`值需要在与条件请求头进行比较之前进行计算。控制器可以将`ETag`标头和`Cache-Control`设置添加到`ResponseEntity`中，如下例所示：

爪哇

```
@GetMapping("/book/{id}")
public ResponseEntity<Book> showBook(@PathVariable Long id) {

    Book book = findBook(id);
    String version = book.getVersion();

    return ResponseEntity
            .ok()
            .cacheControl(CacheControl.maxAge(30, TimeUnit.DAYS))
            .eTag(version) // lastModified is also available
            .body(book);
}
```

Kotlin

```
@GetMapping("/book/{id}")
fun showBook(@PathVariable id: Long): ResponseEntity<Book> {

    val book = findBook(id);
    val version = book.getVersion()

    return ResponseEntity
            .ok()
            .cacheControl(CacheControl.maxAge(30, TimeUnit.DAYS))
            .eTag(version) // lastModified is also available
            .body(book)
}
```

如果与条件请求标题的比较表明内容没有更改，则前面的示例发送带有空主体的 304（not\_modified）响应。否则，将`ETag`和`Cache-Control`头添加到响应中。

你还可以检查控制器中的条件请求头，如下例所示：

爪哇

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

    long eTag = ... (1)

    if (request.checkNotModified(eTag)) {
        return null; (2)
    }

    model.addAttribute(...); (3)
    return "myViewName";
}
```

|**1**|应用程序特定的计算。|
|-----|-------------------------------------------------------------------------|
|**2**|响应已设置为 304（未修改）——没有进一步的处理。|
|**3**|继续处理请求。|

Kotlin

```
@RequestMapping
fun myHandleMethod(request: WebRequest, model: Model): String? {

    val eTag: Long = ... (1)

    if (request.checkNotModified(eTag)) {
        return null (2)
    }

    model[...] = ... (3)
    return "myViewName"
}
```

|**1**|应用程序特定的计算。|
|-----|-------------------------------------------------------------------------|
|**2**|响应已设置为 304（未修改）——没有进一步的处理。|
|**3**|继续处理请求。|

针对`eTag`值、`lastModified`值或两者检查条件请求有三种变体。对于条件`GET`和`HEAD`请求，可以将响应设置为 304（不是 \_modified）。对于条件`POST`、`PUT`和`DELETE`，你可以将响应设置为 412（前提条件 \_ 失败），以防止并发修改。

#### 1.9.3.静态资源

[WebFlux](web-reactive.html#webflux-caching-static-resources)

为了获得最佳性能，你应该使用`Cache-Control`和条件响应头来服务静态资源。请参见配置[静态资源](#mvc-config-static-resources)一节。

#### 1.9.4.`ETag`过滤器

你可以使用`ShallowEtagHeaderFilter`来添加“shallow”`eTag`值，这些值是从响应内容计算出来的，因此，可以节省带宽，但不会节省 CPU 时间。见[浅层 ETAG](#filters-shallow-etag)。

### 1.10.查看技术

[WebFlux](web-reactive.html#webflux-view)

Spring MVC 中视图技术的使用是可插入的。是否决定使用 ThymeLeaf、Groovy 标记模板、JSP 或其他技术主要是配置更改的问题。本章介绍与 Spring MVC 集成的视图技术。我们假设你已经熟悉[视图分辨率](#mvc-viewresolver)。

|   |Spring MVC 应用程序的视图位于该应用程序的内部信任边界<br/>内。视图可以访问应用程序上下文中的所有 bean。正如<br/>这样，不建议在应用程序中使用 Spring MVC 的模板支持，因为<br/>模板可以由外部源进行编辑，因为这可能具有安全含义。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.10.1.百里香叶

[WebFlux](web-reactive.html#webflux-view-thymeleaf)

ThymeLeaf 是一个现代的服务器端 爪哇 模板引擎，强调自然的 HTML 模板，可以通过双击在浏览器中预览，这对于在 UI 模板上独立工作（例如，由设计师）非常有帮助，而不需要运行的服务器。如果你想要替换 JSP，ThymeLeaf 提供了最广泛的一组特性，可以使这种转换变得更容易。麝香草叶得到了积极的开发和维护。有关更完整的介绍，请参见[Thymeleaf](https://www.thymeleaf.org/)项目主页。

ThymeLeaf 与 Spring MVC 的集成由 ThymeLeaf 项目管理。配置涉及一些 Bean 声明，例如`ServletContextTemplateResolver`、`SpringTemplateEngine`和`ThymeleafViewResolver`。有关更多详细信息，请参见[Thymeleaf+Spring](https://www.thymeleaf.org/documentation.html)。

#### 1.10.2.自由标记

[WebFlux](web-reactive.html#webflux-view-freemarker)

[Apache Freemarker](https://freemarker.apache.org/)是一个模板引擎，用于生成从 HTML 到电子邮件等任何类型的文本输出。 Spring 框架具有用于使用 Spring MVC 和 Freemarker 模板的内置集成。

##### 视图配置

[WebFlux](web-reactive.html#webflux-view-freemarker-contextconfig)

下面的示例展示了如何将 Freemarker 配置为一种视图技术：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.freeMarker();
    }

    // Configure FreeMarker...

    @Bean
    public FreeMarkerConfigurer freeMarkerConfigurer() {
        FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
        configurer.setTemplateLoaderPath("/WEB-INF/freemarker");
        return configurer;
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        registry.freeMarker()
    }

    // Configure FreeMarker...

    @Bean
    fun freeMarkerConfigurer() = FreeMarkerConfigurer().apply {
        setTemplateLoaderPath("/WEB-INF/freemarker")
    }
}
```

下面的示例展示了如何在 XML 中配置相同的内容：

```
<mvc:annotation-driven/>

<mvc:view-resolvers>
    <mvc:freemarker/>
</mvc:view-resolvers>

<!-- Configure FreeMarker... -->
<mvc:freemarker-configurer>
    <mvc:template-loader-path location="/WEB-INF/freemarker"/>
</mvc:freemarker-configurer>
```

或者，你也可以声明`FreeMarkerConfigurer` Bean 以完全控制所有属性，如下例所示：

```
<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
    <property name="templateLoaderPath" value="/WEB-INF/freemarker/"/>
</bean>
```

你的模板需要存储在前面示例中所示的`FreeMarkerConfigurer`指定的目录中。给定上述配置，如果控制器返回`welcome`的视图名称，则解析器将查找`/WEB-INF/freemarker/welcome.ftl`模板。

##### 自由标记配置

[WebFlux](web-reactive.html#webflux-views-freemarker)

通过在`FreeMarkerConfigurer` Bean 上设置适当的 Bean 属性，可以将自由标记’settings’和’sharedvariets’直接传递给自由标记`Configuration`对象（由 Spring 管理）。`freemarkerSettings`属性需要一个`java.util.Properties`对象，而`freemarkerVariables`属性需要一个`java.util.Map`。下面的示例展示了如何使用`FreeMarkerConfigurer`:

```
<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
    <property name="templateLoaderPath" value="/WEB-INF/freemarker/"/>
    <property name="freemarkerVariables">
        <map>
            <entry key="xml_escape" value-ref="fmXmlEscape"/>
        </map>
    </property>
</bean>

<bean id="fmXmlEscape" class="freemarker.template.utility.XmlEscape"/>
```

有关应用于`Configuration`对象的设置和变量的详细信息，请参见 Freemarker 文档。

##### 表单处理

Spring 提供了用于 JSP 的标记库，该标记库包括`<spring:bind/>`元素。这个元素主要允许表单显示来自表单支持对象的值，并显示来自 Web 或业务层中`Validator`的失败验证的结果。 Spring 在 Freemarker 中还具有对相同功能的支持，具有用于生成表单输入元素本身的附加方便宏。

###### BIND 宏

[WebFlux](web-reactive.html#webflux-view-bind-macros)

在`spring-webmvc.jar`freemarker 文件中维护了一组标准的宏，因此对于适当配置的应用程序，它们总是可用的。

Spring 模板库中定义的一些宏被认为是内部的（私有的），但是在宏定义中不存在这样的范围，这使得所有的宏对于调用代码和用户模板都是可见的。下面的部分只关注你需要从模板中直接调用的宏。如果你希望直接查看宏代码，那么该文件被称为`spring.ftl`，并且位于`org.springframework.web.servlet.view.freemarker`包中。

###### 简单绑定

在基于作为 Spring MVC 控制器的窗体视图的自由标记模板的 HTML 表单中，可以使用类似于下一个示例的代码绑定到字段值，并以类似于 JSP 的方式显示每个输入字段的错误消息。下面的示例显示了`personForm`视图：

```
<!-- FreeMarker macros have to be imported into a namespace.
    We strongly recommend sticking to 'spring'. -->
<#import "/spring.ftl" as spring/>
<html>
    ...
    <form action="" method="POST">
        Name:
        <@spring.bind "personForm.name"/>
        <input type="text"
            name="${spring.status.expression}"
            value="${spring.status.value?html}"/><br />
        <#list spring.status.errorMessages as error> <b>${error}</b> <br /> </#list>
        <br />
        ...
        <input type="submit" value="submit"/>
    </form>
    ...
</html>
```

`<@spring.bind>`需要一个’path’参数，该参数包括命令对象的名称（除非在控制器配置中更改了它，否则它是’command’），后面是句号和你希望绑定到的命令对象上的字段的名称。你也可以使用嵌套字段，例如`command.address.street`。`bind`宏在`web.xml`中假定了由`ServletContext`参数`defaultHtmlEscape`指定的默认 HTML 转义行为。

宏的另一种形式`<@spring.bindEscaped>`接受第二个参数，该参数显式地指定在状态错误消息或值中是否应该使用 HTML 转义。你可以根据需要将其设置为`true`或`false`。额外的表单处理宏简化了 HTML 转义的使用，你应该尽可能使用这些宏。它们将在下一节中进行解释。

###### 输入宏

FreeMarker 的附加方便宏简化了绑定和表单生成（包括验证错误显示）。从来没有必要使用这些宏来生成表单输入字段，你可以将它们与简单的 HTML 或直接调用 Spring BIND 宏进行混合和匹配，我们在前面强调了这些宏。

下面的可用宏的表格显示了 Freemarker Template 的定义和每个定义所接受的参数列表：

|宏|                         FTL definition                          |
|------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------|
|`message`（根据代码参数从资源包输出字符串）|                    \<@spring.message code/\>                    |
|`messageText`（根据代码参数从资源包输出字符串，<br/>返回到默认参数的值）|               \<@spring.messageText code, text/\>               |
|`url`（用应用程序的上下文根作为相对 URL 的前缀）|                  \<@spring.url relativeUrl/\>                   |
|`formInput`（收集用户输入的标准输入字段）|       \<@spring.formInput path, attributes, fieldType/\>        |
|`formHiddenInput`（用于提交非用户输入的隐藏输入字段）|          \<@spring.formHiddenInput path, attributes/\>          |
|`formPasswordInput`（收集密码的标准输入字段。请注意，在这种类型的字段中没有填充<br/>值。）|         \<@spring.formPasswordInput path, attributes/\>         |
|`formTextarea`（用于收集长的、自由形式的文本输入的大型文本字段）|           \<@spring.formTextarea path, attributes/\>            |
|`formSingleSelect`（下拉框中的选项，可以让单个所需的值被<br/>选中）|     \<@spring.formSingleSelect path, options, attributes/\>     |
|`formMultiSelect`（允许用户选择 0 个或更多值的选项列表框）|     \<@spring.formMultiSelect path, options, attributes/\>      |
|`formRadioButtons`（一组单选按钮，可以从可用的选项中进行单个选择<br/>）|\<@spring.formRadioButtons path, options separator, attributes/\>|
|`formCheckboxes`（一组复选框，可以选择 0 个或更多的值）|\<@spring.formCheckboxes path, options, separator, attributes/\> |
|`formCheckbox`（一个复选框）|           \<@spring.formCheckbox path, attributes/\>            |
|`showErrors`（简化绑定字段的验证错误显示）|         \<@spring.showErrors separator, classOrStyle/\>         |

|   |在自由标记模板中，`formHiddenInput`和`formPasswordInput`实际上不是<br/>所需的，因为你可以使用正常的`formInput`宏，指定`hidden`或`password`作为`fieldType`参数的值。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

上述任何宏的参数都具有一致的含义：

* `path`:要绑定到的字段的名称（即“command.name”）

* `options`:一个`Map`在输入字段中可以选择的所有可用值。映射的键表示从表单发回并绑定到命令对象的值。相对于键存储的映射对象是在表单上向用户显示的标签，并且可以不同于由表单发回的对应值。通常，这样的映射由控制器提供作为参考数据。你可以使用任何`Map`实现，这取决于所需的行为。对于严格排序的映射，可以使用带有适当`Comparator`的`SortedMap`（例如`TreeMap`），对于应该以插入顺序返回值的任意映射，可以使用`LinkedHashMap`或`LinkedMap`的`commons-collections`。

* `separator`:当多个选项作为独立元素（单选按钮或复选框）可用时，用于分隔列表中每个元素的字符序列（例如`<br>`）。

* `attributes`:在 HTML 标记本身中包含的任意标记或文本的附加字符串。这个字符串在宏的字面上得到了呼应。例如，在`textarea`字段中，可以提供属性（例如“rows=”5“cols=”60“”），也可以传递样式信息，例如“style=”border:1px solid silver"。

* `classOrStyle`:对于`showErrors`宏，表示封装每个错误的`span`元素所使用的 CSS 类的名称。如果没有提供任何信息（或者值为空），则将错误包装在`<b></b>`标记中。

下面的小节概述了宏的示例。

## 输入字段

`formInput`宏接受`path`参数（`command.name`）和一个额外的`attributes`参数（在接下来的示例中为空）。 Spring 宏与所有其他形式的生成宏一起，在路径参数上执行隐式绑定。在发生新的绑定之前，绑定一直有效，因此`showErrors`宏不需要再次传递路径参数——它在上次创建绑定的字段上进行操作。

`showErrors`宏接受一个分隔符参数（用于分隔给定字段上的多个错误的字符），还接受第二个参数——这次是一个类名或样式属性。请注意，Freemarker 可以为属性参数指定默认值。下面的示例展示了如何使用`formInput`和`showErrors`宏：

```
<@spring.formInput "command.name"/>
<@spring.showErrors "<br>"/>
```

下一个示例显示了表单片段的输出，生成了 Name 字段，并在提交了该字段中没有值的表单之后显示了一个验证错误。验证通过 Spring 的验证框架进行。

生成的 HTML 类似于以下示例：

```
Name:
<input type="text" name="name" value="">
<br>
    <b>required</b>
<br>
<br>
```

`formTextarea`宏的工作方式与`formInput`宏相同，并接受相同的参数列表。通常，第二个参数（`attributes`）用于为`textarea`传递样式信息或`rows`和`cols`属性。

## 选择字段

你可以使用四个选择字段宏在 HTML 表单中生成常见的 UI 值选择输入：

* `formSingleSelect`

* `formMultiSelect`

* `formRadioButtons`

* `formCheckboxes`

这四个宏中的每一个都接受`Map`选项，这些选项包含窗体字段的值和对应于该值的标签。值和标签可以是相同的。

下一个例子是 FTL 中的单选按钮。表单支持对象为该字段指定了默认值“london”，因此不需要验证。当呈现表单时，可供选择的整个城市列表将作为模型中的参考数据提供，名称为“CityMap”。下面的清单展示了这个示例：

```
...
Town:
<@spring.formRadioButtons "command.address.town", cityMap, ""/><br><br>
```

前面的列表呈现了一行单选按钮，在`cityMap`中每个值对应一个单选按钮，并使用`""`的分隔符。不提供其他属性（缺少宏的最后一个参数）。对于映射中的每个键值对，`cityMap`使用相同的`String`。映射的键是表单实际提交的`POST`请求参数。映射值是用户看到的标签。在前面的示例中，给出了三个著名城市的列表和表单支持对象中的默认值，HTML 类似于以下内容：

```
Town:
<input type="radio" name="address.town" value="London">London</input>
<input type="radio" name="address.town" value="Paris" checked="checked">Paris</input>
<input type="radio" name="address.town" value="New York">New York</input>
```

如果你的应用程序希望通过内部代码（例如）处理城市，则可以创建带有合适密钥的代码映射，如下例所示：

爪哇

```
protected Map<String, ?> referenceData(HttpServletRequest request) throws Exception {
    Map<String, String> cityMap = new LinkedHashMap<>();
    cityMap.put("LDN", "London");
    cityMap.put("PRS", "Paris");
    cityMap.put("NYC", "New York");

    Map<String, Object> model = new HashMap<>();
    model.put("cityMap", cityMap);
    return model;
}
```

Kotlin

```
protected fun referenceData(request: HttpServletRequest): Map<String, *> {
    val cityMap = linkedMapOf(
            "LDN" to "London",
            "PRS" to "Paris",
            "NYC" to "New York"
    )
    return hashMapOf("cityMap" to cityMap)
}
```

该代码现在产生输出，其中无线电值是相关的代码，但用户仍然可以看到更方便用户的城市名称，如下所示：

```
Town:
<input type="radio" name="address.town" value="LDN">London</input>
<input type="radio" name="address.town" value="PRS" checked="checked">Paris</input>
<input type="radio" name="address.town" value="NYC">New York</input>
```

###### HTML 转义

前面描述的表格宏的默认使用会导致 HTML 元素与 HTML4.01 兼容，并且使用在`web.xml`文件中定义的 HTML 转义的默认值，正如 Spring 的 BIND 支持所使用的那样。要使元素与 XHTML 兼容或覆盖默认的 HTML 转义值，你可以在模板中指定两个变量（或者在模型中，它们对模板是可见的）。在模板中指定它们的优点是，它们可以在以后的模板处理中更改为不同的值，从而为表单中的不同字段提供不同的行为。

要为标记切换到 XHTML 遵从性，请为名为`true`的模型或上下文变量指定一个值`xhtmlCompliant`，如下例所示：

```
<#-- for FreeMarker -->
<#assign xhtmlCompliant = true>
```

在处理此指令之后，由 Spring 宏生成的任何元素现在都与 XHTML 兼容。

以类似的方式，你可以指定每个字段的 HTML 转义，如下例所示：

```
<#-- until this point, default HTML escaping is used -->

<#assign htmlEscape = true>
<#-- next field will use HTML escaping -->
<@spring.formInput "command.name"/>

<#assign htmlEscape = false in spring>
<#-- all future fields will be bound with HTML escaping off -->
```

#### 1.10.3.Groovy 标记

[Groovy 标记模板引擎](http://groovy-lang.org/templating.html#_the_markuptemplateengine)主要用于生成类似 XML 的标记（XML、XHTML、HTML5 和其他标记），但你可以使用它生成任何基于文本的内容。 Spring 框架具有用于使用带有 Groovy 标记的 Spring MVC 的内置集成。

|   |Groovy 标记模板引擎需要 Groovy2.3.1+。|
|---|---------------------------------------------------------|

##### Configuration

下面的示例展示了如何配置 Groovy 标记模板引擎：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.groovy();
    }

    // Configure the Groovy Markup Template Engine...

    @Bean
    public GroovyMarkupConfigurer groovyMarkupConfigurer() {
        GroovyMarkupConfigurer configurer = new GroovyMarkupConfigurer();
        configurer.setResourceLoaderPath("/WEB-INF/");
        return configurer;
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        registry.groovy()
    }

    // Configure the Groovy Markup Template Engine...

    @Bean
    fun groovyMarkupConfigurer() = GroovyMarkupConfigurer().apply {
        resourceLoaderPath = "/WEB-INF/"
    }
}
```

下面的示例展示了如何在 XML 中配置相同的内容：

```
<mvc:annotation-driven/>

<mvc:view-resolvers>
    <mvc:groovy/>
</mvc:view-resolvers>

<!-- Configure the Groovy Markup Template Engine... -->
<mvc:groovy-configurer resource-loader-path="/WEB-INF/"/>
```

##### 例子

与传统的模板引擎不同，Groovy Markup 依赖于使用 Builder 语法的 DSL。下面的示例展示了 HTML 页面的示例模板：

```
yieldUnescaped '<!DOCTYPE html>'
html(lang:'en') {
    head {
        meta('http-equiv':'"Content-Type" content="text/html; charset=utf-8"')
        title('My page')
    }
    body {
        p('This is an example of HTML contents')
    }
}
```

#### 1.10.4.脚本视图

[WebFlux](web-reactive.html#webflux-view-script)

Spring 框架具有用于使用 Spring MVC 和任何模板库的内置集成，这些模板库可以在[JSR-223](https://www.jcp.org/en/jsr/detail?id=223)Java 脚本引擎之上运行。我们在不同的脚本引擎上测试了以下模板库：

|脚本库|                  Scripting Engine                   |
|----------------------------------------------------------------------------------|-----------------------------------------------------|
|[Handlebars](https://handlebarsjs.com/)|[Nashorn](https://openjdk.java.net/projects/nashorn/)|
|[Mustache](https://mustache.github.io/)|[Nashorn](https://openjdk.java.net/projects/nashorn/)|
|[React](https://facebook.github.io/react/)|[Nashorn](https://openjdk.java.net/projects/nashorn/)|
|[EJS](https://www.embeddedjs.com/)|[Nashorn](https://openjdk.java.net/projects/nashorn/)|
|[ERB](https://www.stuartellis.name/articles/erb/)|           [JRuby](https://www.jruby.org)            |
|[字符串模板](https://docs.python.org/2/library/string.html#template-strings)|          [Jython](https://www.jython.org/)          |
|[Kotlin Script templating](https://github.com/sdeleuze/kotlin-script-templating)|          [Kotlin](https://kotlinlang.org/)          |

|   |集成任何其他脚本引擎的基本规则是，它必须实现`ScriptEngine`和`Invocable`接口。|
|---|------------------------------------------------------------------------------------------------------------------------------|

##### 所需经费

[WebFlux](web-reactive.html#webflux-view-script-dependencies)

你需要在 Classpath 上有脚本引擎，其细节因脚本引擎而异：

* [Nashorn](https://openjdk.java.net/projects/nashorn/)JavaScript 引擎由 Java8+ 提供。强烈推荐使用最新的可用更新版本。

* [JRuby](https://www.jruby.org)应该作为 Ruby 支持的依赖项添加。

* [Jython](https://www.jython.org)应该作为 Python 支持的依赖项添加。

* 对于 Kotlin 脚本支持，应该添加`org.jetbrains.kotlin:kotlin-script-util`依赖项和一个`META-INF/services/javax.script.ScriptEngineFactory`文件，该文件包含`org.jetbrains.kotlin.script.jsr223.KotlinJsr223JvmLocalScriptEngineFactory`行。有关更多详细信息，请参见[这个例子](https://github.com/sdeleuze/kotlin-script-templating)。

你需要有脚本模板库。JavaScript 的一种方法是通过[WebJars](https://www.webjars.org/)。

##### 脚本模板

[WebFlux](web-reactive.html#webflux-script-integrate)

你可以声明一个`ScriptTemplateConfigurer` Bean 来指定要使用的脚本引擎、要加载的脚本文件、调用什么函数来呈现模板，等等。下面的示例使用了 Mustache 模板和 Nashorn JavaScript 引擎：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.scriptTemplate();
    }

    @Bean
    public ScriptTemplateConfigurer configurer() {
        ScriptTemplateConfigurer configurer = new ScriptTemplateConfigurer();
        configurer.setEngineName("nashorn");
        configurer.setScripts("mustache.js");
        configurer.setRenderObject("Mustache");
        configurer.setRenderFunction("render");
        return configurer;
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        registry.scriptTemplate()
    }

    @Bean
    fun configurer() = ScriptTemplateConfigurer().apply {
        engineName = "nashorn"
        setScripts("mustache.js")
        renderObject = "Mustache"
        renderFunction = "render"
    }
}
```

下面的示例用 XML 展示了相同的排列方式：

```
<mvc:annotation-driven/>

<mvc:view-resolvers>
    <mvc:script-template/>
</mvc:view-resolvers>

<mvc:script-template-configurer engine-name="nashorn" render-object="Mustache" render-function="render">
    <mvc:script location="mustache.js"/>
</mvc:script-template-configurer>
```

对于 Java 和 XML 配置，控制器看起来没有什么不同，如下例所示：

Java

```
@Controller
public class SampleController {

    @GetMapping("/sample")
    public String test(Model model) {
        model.addAttribute("title", "Sample title");
        model.addAttribute("body", "Sample body");
        return "template";
    }
}
```

Kotlin

```
@Controller
class SampleController {

    @GetMapping("/sample")
    fun test(model: Model): String {
        model["title"] = "Sample title"
        model["body"] = "Sample body"
        return "template"
    }
}
```

下面的示例展示了小胡子模板：

```
<html>
    <head>
        <title>{{title}}</title>
    </head>
    <body>
        <p>{{body}}</p>
    </body>
</html>
```

使用以下参数调用呈现函数：

* `String template`:模板内容

* `Map model`:视图模型

* `RenderingContext renderingContext`:[`RenderingContext`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet/view/script/renderingcontext.html），它提供了对应用程序上下文、区域设置、模板装入器和 URL（自 5.0 起）的访问权限

`Mustache.render()`与此签名原生兼容，因此你可以直接调用它。

如果模板技术需要进行一些定制，那么可以提供一个实现定制呈现功能的脚本。例如，[Handlerbars](https://handlebarsjs.com)在使用模板之前需要对其进行编译，并且需要[polyfill](https://en.wikipedia.org/wiki/Polyfill)来模拟服务器端脚本引擎中不可用的一些浏览器功能。

下面的示例展示了如何做到这一点：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.scriptTemplate();
    }

    @Bean
    public ScriptTemplateConfigurer configurer() {
        ScriptTemplateConfigurer configurer = new ScriptTemplateConfigurer();
        configurer.setEngineName("nashorn");
        configurer.setScripts("polyfill.js", "handlebars.js", "render.js");
        configurer.setRenderFunction("render");
        configurer.setSharedEngine(false);
        return configurer;
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        registry.scriptTemplate()
    }

    @Bean
    fun configurer() = ScriptTemplateConfigurer().apply {
        engineName = "nashorn"
        setScripts("polyfill.js", "handlebars.js", "render.js")
        renderFunction = "render"
        isSharedEngine = false
    }
}
```

|   |当使用非线程安全的<br/>脚本引擎时，需要将`sharedEngine`属性设置为`false`，该脚本引擎的模板库不是为并发而设计的，例如在 Nashorn 上运行的手柄或<br/>React。在那种情况下，由于[this bug](https://bugs.openjdk.java.net/browse/JDK-8076099)，Java SE8Update60 是必需的，但是一般情况下<br/>推荐在任何情况下使用最近发布的 Java SE 补丁。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

`polyfill.js`只定义了处理栏正常运行所需的`window`对象，如下所示：

```
var window = {};
```

这个基本的`render.js`实现在使用模板之前对其进行编译。生产就绪的实现还应该存储任何重用的缓存模板或预编译模板。你可以在脚本端这样做（并处理你需要的任何定制——例如，管理模板引擎配置）。下面的示例展示了如何做到这一点：

```
function render(template, model) {
    var compiledTemplate = Handlebars.compile(template);
    return compiledTemplate(model);
}
```

查看 Spring Framework Unit 测试，[Java](https://github.com/spring-projects/spring-framework/tree/main/spring-webmvc/src/test/java/org/springframework/web/servlet/view/script)和[resources](https://github.com/spring-projects/spring-framework/tree/main/spring-webmvc/src/test/resources/org/springframework/web/servlet/view/script)，以获得更多配置示例。

#### 1.10.5.JSP 和 JSTL

Spring 框架具有用于使用 Spring MVC 与 JSP 和 JSTL 的内置集成。

##### 视图解析器

在使用 JSP 进行开发时，通常声明`InternalResourceViewResolver` Bean。

`InternalResourceViewResolver`可用于向任何 Servlet 资源进行调度，但特别是用于 JSP。作为一种最佳实践，我们强烈建议将你的 JSP 文件放置在`'WEB-INF'`目录下的目录中，这样客户端就不能直接访问它。

```
<bean id="viewResolver" 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>
```

##### JSP 与 JSTL

当使用 JSP 标准标记库时，你必须使用一个特殊的视图类`JstlView`，因为 JSTL 需要在诸如 i18n 特性之类的功能工作之前进行一些准备。

##### Spring 的 JSP 标记库

Spring 提供请求参数到命令对象的数据绑定，如前面几章所描述的。 Spring 为了促进结合那些数据绑定特性的 JSP 页面的开发，提供了一些使事情变得更容易的标记。 Spring 所有标记都具有 HTML 转义功能，以启用或禁用字符的转义。

`spring.tld`标记库描述符包含在`spring-webmvc.jar`中。有关单个标记的全面引用，请浏览[API 参考](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/web/servlet/tags/package-summary.html#package.description)或查看标记库描述。

##### Spring 的表单标记库

在版本 2.0 中， Spring 提供了一组全面的数据绑定感知标记，用于在使用 JSP 和 Spring Web MVC 时处理表单元素。每个标记都提供了对其对应的 HTML 标记对应物的属性集的支持，使标记变得熟悉且使用起来直观。标记生成的 HTML 兼容 HTML4.01/XHTML1.0。

与其他表单/输入标记库不同， Spring 的表单标记库与 Spring Web MVC 集成在一起，使标记能够访问你的控制器处理的命令对象和引用数据。正如我们在下面的示例中所示，表单标记使 JSP 更易于开发、读取和维护。

我们通过表单标记，并查看每个标记如何使用的示例。我们已经包含了生成的 HTML 片段，其中某些标记需要进一步的注释。

###### Configuration

表单标记库捆绑在`spring-webmvc.jar`中。库描述符称为`spring-form.tld`。

要使用这个库中的标记，请在 JSP 页面的顶部添加以下指令：

```
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
```

其中`form`是你要为这个库中的标记使用的标记名称前缀。

###### 表单标签

此标记呈现 HTML“Form”元素，并将绑定路径公开给内部标记以进行绑定。它将命令对象放在`PageContext`中，以便可以通过内部标记访问命令对象。这个库中的所有其他标记都是`form`标记的嵌套标记。

假设我们有一个名为`User`的域对象。它是一个 JavaBean，具有`firstName`和`lastName`等属性。我们可以使用它作为表单控制器的表单支持对象，它返回`form.jsp`。下面的示例显示了`form.jsp`可能是什么样子的：

```
<form:form>
    <table>
        <tr>
            <td>First Name:</td>
            <td><form:input path="firstName"/></td>
        </tr>
        <tr>
            <td>Last Name:</td>
            <td><form:input path="lastName"/></td>
        </tr>
        <tr>
            <td colspan="2">
                <input type="submit" value="Save Changes"/>
            </td>
        </tr>
    </table>
</form:form>
```

由页面控制器从放置在`PageContext`中的命令对象检索`firstName`和`lastName`值。继续阅读，以查看更多关于内部标记如何与`form`标记一起使用的复杂示例。

下面的清单显示了生成的 HTML，它看起来像一个标准表单：

```
<form method="POST">
    <table>
        <tr>
            <td>First Name:</td>
            <td><input name="firstName" type="text" value="Harry"/></td>
        </tr>
        <tr>
            <td>Last Name:</td>
            <td><input name="lastName" type="text" value="Potter"/></td>
        </tr>
        <tr>
            <td colspan="2">
                <input type="submit" value="Save Changes"/>
            </td>
        </tr>
    </table>
</form>
```

前面的 JSP 假设表单支持对象的变量名为`command`。如果你已将表单备份对象以另一个名称（肯定是最佳实践）放入模型中，则可以将表单绑定到已命名的变量，如下例所示：

```
<form:form modelAttribute="user">
    <table>
        <tr>
            <td>First Name:</td>
            <td><form:input path="firstName"/></td>
        </tr>
        <tr>
            <td>Last Name:</td>
            <td><form:input path="lastName"/></td>
        </tr>
        <tr>
            <td colspan="2">
                <input type="submit" value="Save Changes"/>
            </td>
        </tr>
    </table>
</form:form>
```

###### `input`标签

默认情况下，此标记呈现带有绑定值和`type='text'`元素的 HTML`input`。有关此标记的示例，请参见[表单标签](#mvc-view-jsp-formtaglib-formtag)。你也可以使用 HTML5 特定的类型，例如`email`、`tel`、`date`和其他类型。

###### `checkbox`标签

此标记呈现 HTML`input`标记，其`type`设置为`checkbox`。

假设我们的`User`具有首选项，例如订阅时事通讯和列出兴趣爱好。下面的示例显示了`Preferences`类：

Java

```
public class Preferences {

    private boolean receiveNewsletter;
    private String[] interests;
    private String favouriteWord;

    public boolean isReceiveNewsletter() {
        return receiveNewsletter;
    }

    public void setReceiveNewsletter(boolean receiveNewsletter) {
        this.receiveNewsletter = receiveNewsletter;
    }

    public String[] getInterests() {
        return interests;
    }

    public void setInterests(String[] interests) {
        this.interests = interests;
    }

    public String getFavouriteWord() {
        return favouriteWord;
    }

    public void setFavouriteWord(String favouriteWord) {
        this.favouriteWord = favouriteWord;
    }
}
```

Kotlin

```
class Preferences(
        var receiveNewsletter: Boolean,
        var interests: StringArray,
        var favouriteWord: String
)
```

相应的`form.jsp`可能如下所示：

```
<form:form>
    <table>
        <tr>
            <td>Subscribe to newsletter?:</td>
            <%-- Approach 1: Property is of type java.lang.Boolean --%>
            <td><form:checkbox path="preferences.receiveNewsletter"/></td>
        </tr>

        <tr>
            <td>Interests:</td>
            <%-- Approach 2: Property is of an array or of type java.util.Collection --%>
            <td>
                Quidditch: <form:checkbox path="preferences.interests" value="Quidditch"/>
                Herbology: <form:checkbox path="preferences.interests" value="Herbology"/>
                Defence Against the Dark Arts: <form:checkbox path="preferences.interests" value="Defence Against the Dark Arts"/>
            </td>
        </tr>

        <tr>
            <td>Favourite Word:</td>
            <%-- Approach 3: Property is of type java.lang.Object --%>
            <td>
                Magic: <form:checkbox path="preferences.favouriteWord" value="Magic"/>
            </td>
        </tr>
    </table>
</form:form>
```

对于`checkbox`标记，有三种方法可以满足你的所有复选框需求。

* 方法一：当绑定值类型为`java.lang.Boolean`时，如果绑定值为`checked`，则将`input(checkbox)`标记为`checked`。`value`属性对应于`setValue(Object)`值属性的解析值。

* 方法二：当绑定值类型为`array`或`java.util.Collection`时，如果配置的`checked`值存在于绑定值`Collection`中，则将`input(checkbox)`标记为`checked`。

* 方法三：对于任何其他绑定值类型，如果配置的`setValue(Object)`等于绑定值，则将`checked`标记为`checked`。

请注意，无论采用哪种方法，都会生成相同的 HTML 结构。以下 HTML 片段定义了一些复选框：

```
<tr>
    <td>Interests:</td>
    <td>
        Quidditch: <input name="preferences.interests" type="checkbox" value="Quidditch"/>
        <input type="hidden" value="1" name="_preferences.interests"/>
        Herbology: <input name="preferences.interests" type="checkbox" value="Herbology"/>
        <input type="hidden" value="1" name="_preferences.interests"/>
        Defence Against the Dark Arts: <input name="preferences.interests" type="checkbox" value="Defence Against the Dark Arts"/>
        <input type="hidden" value="1" name="_preferences.interests"/>
    </td>
</tr>
```

你可能不希望在每个复选框之后看到额外的隐藏字段。当 HTML 页面中的复选框未被选中时，其值不会在表单提交后作为 HTTP 请求参数的一部分发送到服务器，因此我们需要在 HTML 中解决此问题，以使 Spring 表单数据绑定工作。`checkbox`标记遵循现有的 Spring 约定，即为每个复选框包含一个以下划线（`_`）为前缀的隐藏参数。通过这样做，你可以有效地告诉 Spring“复选框在表单中是可见的，并且我希望表单数据绑定到的对象能够反映复选框的状态，无论发生什么情况。”

###### `checkboxes`标签

此标记将呈现多个 HTML`input`标记，并将`type`设置为`checkbox`。

本节以前面`checkbox`标记部分的示例为基础。有时，你不希望在 JSP 页面中列出所有可能的爱好。你更愿意在运行时提供一个可用选项的列表，并将其传递给标记。这就是`checkboxes`标记的目的。可以传入`Array`、`List`或`Map`属性中包含可用选项的`items`。通常，绑定属性是一个集合，以便它可以保存用户选择的多个值。下面的示例展示了使用此标记的 JSP:

```
<form:form>
    <table>
        <tr>
            <td>Interests:</td>
            <td>
                <%-- Property is of an array or of type java.util.Collection --%>
                <form:checkboxes path="preferences.interests" items="${interestList}"/>
            </td>
        </tr>
    </table>
</form:form>
```

这个示例假设`interestList`是一个`List`，作为包含要从中选择的值的字符串的模型属性可用。如果使用`Map`，则使用 map entry 键作为值，并使用 map entry 的值作为要显示的标签。你还可以使用自定义对象，在该对象中，你可以通过使用`itemValue`提供该值的属性名称，并通过使用`itemLabel`提供标签。

###### `radiobutton`标签

此标记呈现 HTML`input`元素，其`type`设置为`radio`。

典型的使用模式涉及绑定到相同属性但具有不同值的多个标记实例，如下例所示：

```
<tr>
    <td>Sex:</td>
    <td>
        Male: <form:radiobutton path="sex" value="M"/> <br/>
        Female: <form:radiobutton path="sex" value="F"/>
    </td>
</tr>
```

###### `radiobuttons`标签

此标记呈现多个 HTML`input`元素，并将`type`设置为`radio`。

与[`checkboxes`标记]（#mvc-view-jsp-formtaglib-checkboxestag）一样，你可能希望将可用选项作为运行时变量传递。对于这种用法，你可以使用`radiobuttons`标记。你传入一个`Array`、一个`List`或一个`Map`，它包含`items`属性中的可用选项。如果使用`Map`，则使用 map entry 键作为值，并使用 map entry 的值作为要显示的标签。你还可以使用自定义对象，在该对象中，你可以通过使用`itemValue`提供该值的属性名称，并通过使用`itemLabel`提供标签，如下例所示：

```
<tr>
    <td>Sex:</td>
    <td><form:radiobuttons path="sex" items="${sexOptions}"/></td>
</tr>
```

###### `password`标签

这个标记呈现一个 HTML`input`标记，其类型设置为`password`，并具有绑定值。

```
<tr>
    <td>Password:</td>
    <td>
        <form:password path="password"/>
    </td>
</tr>
```

请注意，默认情况下，不会显示密码值。如果确实希望显示密码值，可以将`showPassword`属性的值设置为`true`，如下例所示：

```
<tr>
    <td>Password:</td>
    <td>
        <form:password path="password" value="^76525bvHGq" showPassword="true"/>
    </td>
</tr>
```

###### `select`标签

此标记呈现 HTML“select”元素。它支持与所选选项的数据绑定，以及使用嵌套的`option`和`options`标记。

假设`User`有一个技能列表。相应的 HTML 可以如下所示：

```
<tr>
    <td>Skills:</td>
    <td><form:select path="skills" items="${skills}"/></td>
</tr>
```

如果`User’s`技能是草药学的，那么“技能”行的 HTML 源可以如下所示：

```
<tr>
    <td>Skills:</td>
    <td>
        <select name="skills" multiple="true">
            <option value="Potions">Potions</option>
            <option value="Herbology" selected="selected">Herbology</option>
            <option value="Quidditch">Quidditch</option>
        </select>
    </td>
</tr>
```

###### `option`标签

此标记呈现 HTML`option`元素。它基于绑定值设置`selected`。下面的 HTML 显示了它的典型输出：

```
<tr>
    <td>House:</td>
    <td>
        <form:select path="house">
            <form:option value="Gryffindor"/>
            <form:option value="Hufflepuff"/>
            <form:option value="Ravenclaw"/>
            <form:option value="Slytherin"/>
        </form:select>
    </td>
</tr>
```

如果`User’s`house 位于 Gryffindor，则“house”行的 HTML 源代码如下：

```
<tr>
    <td>House:</td>
    <td>
        <select name="house">
            <option value="Gryffindor" selected="selected">Gryffindor</option> (1)
            <option value="Hufflepuff">Hufflepuff</option>
            <option value="Ravenclaw">Ravenclaw</option>
            <option value="Slytherin">Slytherin</option>
        </select>
    </td>
</tr>
```

|**1**|注意添加了一个`selected`属性。|
|-----|--------------------------------------------|

###### tag`options`

此标记呈现 HTML`option`元素的列表。它基于绑定值设置`selected`属性。下面的 HTML 显示了它的典型输出：

```
<tr>
    <td>Country:</td>
    <td>
        <form:select path="country">
            <form:option value="-" label="--Please Select"/>
            <form:options items="${countryList}" itemValue="code" itemLabel="name"/>
        </form:select>
    </td>
</tr>
```

如果`User`存在于 UK 中，则“country”行的 HTML 源代码如下：

```
<tr>
    <td>Country:</td>
    <td>
        <select name="country">
            <option value="-">--Please Select</option>
            <option value="AT">Austria</option>
            <option value="UK" selected="selected">United Kingdom</option> (1)
            <option value="US">United States</option>
        </select>
    </td>
</tr>
```

|**1**|注意添加了一个`selected`属性。|
|-----|--------------------------------------------|

正如前面的示例所示，将`option`标记与`options`标记合并使用，会生成相同的标准 HTML，但允许你在 JSP 中显式地指定一个值，该值仅用于显示（在它所属的位置），例如示例中的默认字符串：“--请选择”。

`items`属性通常填充有条目对象的集合或数组。`itemValue`和`itemLabel`引用那些条目对象的 Bean 属性（如果指定的话）。否则，项目对象本身就会变成字符串。或者，你可以指定项目的`Map`，在这种情况下，映射键被解释为选项值，映射值对应于选项标签。如果`itemValue`或`itemLabel`（或两者兼而有之）恰好也被指定，则 Item Value 属性将应用于 map 键，而 Item Label 属性将应用于 map 值。

###### tag`textarea`

此标记呈现 HTML`textarea`元素。下面的 HTML 显示了它的典型输出：

```
<tr>
    <td>Notes:</td>
    <td><form:textarea path="notes" rows="3" cols="20"/></td>
    <td><form:errors path="notes"/></td>
</tr>
```

###### `hidden`标签

此标记将呈现一个 HTML`input`标记，该标记的`type`设置为`hidden`，并具有绑定值。要提交未绑定的隐藏值，请使用 HTML`input`标记，并将`type`设置为`hidden`。下面的 HTML 显示了它的典型输出：

```
<form:hidden path="house"/>
```

如果我们选择将`house`值作为隐藏的值提交，则 HTML 将如下所示：

```
<input name="house" type="hidden" value="Gryffindor"/>
```

###### `errors`标签

此标记在 HTML`span`元素中呈现字段错误。它提供对在控制器中创建的错误或由与控制器关联的任何验证器创建的错误的访问。

假设我们希望在提交表单后显示`firstName`和`lastName`字段的所有错误消息。对于`User`类的实例，我们有一个名为`UserValidator`的验证器，如下例所示：

Java

```
public class UserValidator implements Validator {

    public boolean supports(Class candidate) {
        return User.class.isAssignableFrom(candidate);
    }

    public void validate(Object obj, Errors errors) {
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "required", "Field is required.");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "lastName", "required", "Field is required.");
    }
}
```

Kotlin

```
class UserValidator : Validator {

    override fun supports(candidate: Class<*>): Boolean {
        return User::class.java.isAssignableFrom(candidate)
    }

    override fun validate(obj: Any, errors: Errors) {
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "required", "Field is required.")
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "lastName", "required", "Field is required.")
    }
}
```

`form.jsp`可以如下：

```
<form:form>
    <table>
        <tr>
            <td>First Name:</td>
            <td><form:input path="firstName"/></td>
            <%-- Show errors for firstName field --%>
            <td><form:errors path="firstName"/></td>
        </tr>

        <tr>
            <td>Last Name:</td>
            <td><form:input path="lastName"/></td>
            <%-- Show errors for lastName field --%>
            <td><form:errors path="lastName"/></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes"/>
            </td>
        </tr>
    </table>
</form:form>
```

如果我们提交一个在`firstName`和`lastName`字段中具有空值的表单，则 HTML 将如下所示：

```
<form method="POST">
    <table>
        <tr>
            <td>First Name:</td>
            <td><input name="firstName" type="text" value=""/></td>
            <%-- Associated errors to firstName field displayed --%>
            <td><span name="firstName.errors">Field is required.</span></td>
        </tr>

        <tr>
            <td>Last Name:</td>
            <td><input name="lastName" type="text" value=""/></td>
            <%-- Associated errors to lastName field displayed --%>
            <td><span name="lastName.errors">Field is required.</span></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes"/>
            </td>
        </tr>
    </table>
</form>
```

如果我们想要显示给定页面的整个错误列表，该怎么办？下一个示例显示`errors`标记还支持一些基本的通配符功能。

* `path="*"`:显示所有错误。

* `path="lastName"`:显示与`lastName`字段关联的所有错误。

* 如果省略`path`，则只显示对象错误。

下面的示例在页面顶部显示错误列表，然后在字段旁边显示特定于字段的错误：

```
<form:form>
    <form:errors path="*" cssClass="errorBox"/>
    <table>
        <tr>
            <td>First Name:</td>
            <td><form:input path="firstName"/></td>
            <td><form:errors path="firstName"/></td>
        </tr>
        <tr>
            <td>Last Name:</td>
            <td><form:input path="lastName"/></td>
            <td><form:errors path="lastName"/></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes"/>
            </td>
        </tr>
    </table>
</form:form>
```

HTML 将如下所示：

```
<form method="POST">
    <span name="*.errors" class="errorBox">Field is required.<br/>Field is required.</span>
    <table>
        <tr>
            <td>First Name:</td>
            <td><input name="firstName" type="text" value=""/></td>
            <td><span name="firstName.errors">Field is required.</span></td>
        </tr>

        <tr>
            <td>Last Name:</td>
            <td><input name="lastName" type="text" value=""/></td>
            <td><span name="lastName.errors">Field is required.</span></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes"/>
            </td>
        </tr>
    </table>
</form>
```

`spring-form.tld`标记库描述符包含在`spring-webmvc.jar`中。有关单个标记的全面参考，请浏览[API 参考](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/web/servlet/tags/form/package-summary.html#package.description)或查看标记库描述。

###### HTTP 方法转换

REST 的一个关键原则是使用“统一接口”。这意味着所有资源（URL）都可以通过使用相同的四种 HTTP 方法进行操作：GET、PUT、POST 和 DELETE。对于每种方法，HTTP 规范都定义了确切的语义。例如，get 应该始终是一个安全的操作，这意味着它没有副作用，而 put 或 delete 应该是幂等的，这意味着你可以一遍又一遍地重复这些操作，但最终结果应该是相同的。虽然 HTTP 定义了这四种方法，但 HTML 只支持两种：GET 和 POST。幸运的是，有两种可能的解决方法：你可以使用 JavaScript 来执行 PUT 或 DELETE，或者你可以使用“Real”方法作为附加参数（以 HTML 形式的隐藏输入字段建模）来执行 POST。 Spring 的`HiddenHttpMethodFilter`使用了后一种技巧。 Servlet 该过滤器是一个普通的过滤器，因此，它可以与任何 Web 框架（而不仅仅是 Spring MVC）组合使用。将此筛选器添加到你的 web.xml 中，带有隐藏`method`参数的 POST 将被转换为相应的 HTTP 方法请求。

为了支持 HTTP 方法转换，更新了 Spring MVC 表单标记以支持设置 HTTP 方法。例如，以下片段来自宠物诊所样本：

```
<form:form method="delete">
    <p class="submit"><input type="submit" value="Delete Pet"/></p>
</form:form>
```

前面的示例执行 HTTP POST，在请求参数后面隐藏“real”delete 方法。下面的示例显示了在 web.xml 中定义的`HiddenHttpMethodFilter`来选择它：

```
<filter>
    <filter-name>httpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>httpMethodFilter</filter-name>
    <servlet-name>petclinic</servlet-name>
</filter-mapping>
```

下面的示例显示了相应的`@Controller`方法：

Java

```
@RequestMapping(method = RequestMethod.DELETE)
public String deletePet(@PathVariable int ownerId, @PathVariable int petId) {
    this.clinic.deletePet(petId);
    return "redirect:/owners/" + ownerId;
}
```

Kotlin

```
@RequestMapping(method = [RequestMethod.DELETE])
fun deletePet(@PathVariable ownerId: Int, @PathVariable petId: Int): String {
    clinic.deletePet(petId)
    return "redirect:/owners/$ownerId"
}
```

###### HTML5 标签

Spring 表单标记库允许输入动态属性，这意味着可以输入任何 HTML5 特定的属性。

表单`input`标记支持输入`text`以外的类型属性。这旨在允许呈现新的 HTML5 特定的输入类型，例如`email`，`date`，`range`，以及其他类型。请注意，不需要输入`type='text'`，因为`text`是默认类型。

#### 1.10.6.瓦片

你可以在使用 Spring 的 Web 应用程序中集成图块——就像任何其他视图技术一样。这一节以一种宽泛的方式描述了如何做到这一点。

|   |本节重点介绍 Spring 对`org.springframework.web.servlet.view.tiles3`包中的磁贴版本 3 的支持。|
|---|-------------------------------------------------------------------------------------------------------------------------|

##### 依赖关系

为了能够使用磁贴，你必须在项目中添加对磁贴版本 3.0.1 或更高版本和[它的传递依赖关系](https://tiles.apache.org/framework/dependency-management.html)的依赖关系。

##### 配置

为了能够使用磁贴，你必须使用包含定义的文件来配置它（有关定义和其他磁贴概念的基本信息，请参见[https://tiles.apache.org](https://tiles.apache.org)）。在 Spring 中，这是通过使用`TilesConfigurer`来完成的。下面的`ApplicationContext`配置示例展示了如何这样做：

```
<bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles3.TilesConfigurer">
    <property name="definitions">
        <list>
            <value>/WEB-INF/defs/general.xml</value>
            <value>/WEB-INF/defs/widgets.xml</value>
            <value>/WEB-INF/defs/administrator.xml</value>
            <value>/WEB-INF/defs/customer.xml</value>
            <value>/WEB-INF/defs/templates.xml</value>
        </list>
    </property>
</bean>
```

前面的示例定义了五个包含定义的文件。这些文件都位于`WEB-INF/defs`目录中。在初始化`WebApplicationContext`时，文件被加载，定义工厂被初始化。完成此操作后，定义文件中包含的磁贴可以用作 Spring Web 应用程序中的视图。为了能够使用这些视图，与 Spring 中的任何其他视图技术一样，你必须有一个`ViewResolver`:通常是一个方便的`TilesViewResolver`。

你可以通过添加下划线和区域设置来指定特定于区域设置的磁贴定义，如下例所示：

```
<bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles3.TilesConfigurer">
    <property name="definitions">
        <list>
            <value>/WEB-INF/defs/tiles.xml</value>
            <value>/WEB-INF/defs/tiles_fr_FR.xml</value>
        </list>
    </property>
</bean>
```

在前面的配置中，`tiles_fr_FR.xml`用于使用`fr_FR`语言环境的请求，默认情况下使用`tiles.xml`。

|   |由于下划线是用来指示区域设置的，因此我们建议不要在文件名中使用<br/>，否则将其用于瓷砖定义。|
|---|------------------------------------------------------------------------------------------------------------------------------------|

###### `UrlBasedViewResolver`

`UrlBasedViewResolver`为它必须解析的每个视图实例化给定的`viewClass`。下面的 Bean 定义了`UrlBasedViewResolver`:

```
<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.tiles3.TilesView"/>
</bean>
```

###### `SimpleSpringPreparerFactory`和`SpringBeanPreparerFactory`

作为一种高级特性， Spring 还支持两种特殊的贴片`PreparerFactory`实现方式。有关如何在磁贴定义文件中使用`ViewPreparer`引用的详细信息，请参见磁贴文档。

你可以根据指定的准备程序类，将`SimpleSpringPreparerFactory`指定为 AutoWire`ViewPreparer`实例，应用 Spring 的容器回调以及应用已配置的 Spring BeanPostProcessors。如果 Spring 的上下文范围注释配置已被激活，`ViewPreparer`类中的注释将被自动检测并应用。请注意，这需要在磁贴定义文件中的准备程序类，就像默认的`PreparerFactory`所做的那样。

你可以指定`SpringBeanPreparerFactory`来对指定的编制者名称（而不是类）进行操作，从而从 DispatcherServlet 的应用程序上下文中获得相应的 Spring  Bean。在这种情况下，完整的 Bean 创建过程处于 Spring 应用程序上下文的控制中，允许使用显式依赖注入配置、作用域 bean 等。请注意，你需要为每个准备者名称定义一个 Spring  Bean 定义（如你的磁贴定义中所使用的）。下面的示例展示了如何在`TilesConfigurer` Bean 上定义`SpringBeanPreparerFactory`属性：

```
<bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles3.TilesConfigurer">
    <property name="definitions">
        <list>
            <value>/WEB-INF/defs/general.xml</value>
            <value>/WEB-INF/defs/widgets.xml</value>
            <value>/WEB-INF/defs/administrator.xml</value>
            <value>/WEB-INF/defs/customer.xml</value>
            <value>/WEB-INF/defs/templates.xml</value>
        </list>
    </property>

    <!-- resolving preparer names as Spring bean definition names -->
    <property name="preparerFactoryClass"
            value="org.springframework.web.servlet.view.tiles3.SpringBeanPreparerFactory"/>

</bean>
```

#### 1.10.7.RSS 和 Atom

`AbstractAtomFeedView`和`AbstractRssFeedView`都继承自`AbstractFeedView`基类，并分别用于提供 Atom 和 RSS 提要视图。它们基于[ROME](https://rometools.github.io/rome/)项目，位于包`org.springframework.web.servlet.view.feed`中。

`AbstractAtomFeedView`要求你实现`buildFeedEntries()`方法，并可选地覆盖`buildFeedMetadata()`方法（默认实现为空）。下面的示例展示了如何做到这一点：

爪哇

```
public class SampleContentAtomView extends AbstractAtomFeedView {

    @Override
    protected void buildFeedMetadata(Map<String, Object> model,
            Feed feed, HttpServletRequest request) {
        // implementation omitted
    }

    @Override
    protected List<Entry> buildFeedEntries(Map<String, Object> model,
            HttpServletRequest request, HttpServletResponse response) throws Exception {
        // implementation omitted
    }
}
```

Kotlin

```
class SampleContentAtomView : AbstractAtomFeedView() {

    override fun buildFeedMetadata(model: Map<String, Any>,
            feed: Feed, request: HttpServletRequest) {
        // implementation omitted
    }

    override fun buildFeedEntries(model: Map<String, Any>,
            request: HttpServletRequest, response: HttpServletResponse): List<Entry> {
        // implementation omitted
    }
}
```

类似的要求也适用于实现`AbstractRssFeedView`，如下例所示：

爪哇

```
public class SampleContentRssView extends AbstractRssFeedView {

    @Override
    protected void buildFeedMetadata(Map<String, Object> model,
            Channel feed, HttpServletRequest request) {
        // implementation omitted
    }

    @Override
    protected List<Item> buildFeedItems(Map<String, Object> model,
            HttpServletRequest request, HttpServletResponse response) throws Exception {
        // implementation omitted
    }
}
```

Kotlin

```
class SampleContentRssView : AbstractRssFeedView() {

    override fun buildFeedMetadata(model: Map<String, Any>,
                                feed: Channel, request: HttpServletRequest) {
        // implementation omitted
    }

    override fun buildFeedItems(model: Map<String, Any>,
            request: HttpServletRequest, response: HttpServletResponse): List<Item> {
        // implementation omitted
    }
}
```

如果你需要访问区域设置，`buildFeedItems()`和`buildFeedEntries()`方法将传入 HTTP 请求。HTTP 响应仅在设置 Cookie 或其他 HTTP 头时传入。方法返回后，提要将自动写入响应对象。

有关创建 Atom 视图的示例，请参见 ALEFArendsen Spring 团队博客[entry](https://spring.io/blog/2009/03/16/adding-an-atom-view-to-an-application-using-spring-s-rest-support)。

#### 1.10.8.PDF 和 Excel

Spring 提供了返回 HTML 以外的输出的方法，包括 PDF 和 Excel 电子表格。本节描述如何使用这些特性。

##### 文档视图介绍

HTML 页面并不总是用户查看模型输出的最佳方式， Spring 使得从模型数据动态生成 PDF 文档或 Excel 电子表格变得简单。该文档是视图，并从服务器以正确的内容类型进行流媒体传输，以（希望）使客户端 PC 能够运行其电子表格或 PDF 查看器应用程序作为响应。

为了使用 Excel 视图，你需要将 Apache POI 库添加到 Classpath 中。为了生成 PDF，你需要添加（最好是）OpenPDF 库。

|   |如果可能的话，你应该使用底层文档生成库的最新版本<br/>。特别是，我们强烈推荐 OpenPDF（例如，OpenPDF1.2.12）<br/>而不是过时的原始 iText2.1.7，因为 OpenPDF 是积极维护的，<br/>修复了不可信 PDF 内容的一个重要漏洞。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

##### PDF 视图

一个用于单词列表的简单 PDF 视图可以扩展`org.springframework.web.servlet.view.document.AbstractPdfView`并实现`buildPdfDocument()`方法，如下例所示：

爪哇

```
public class PdfWordList extends AbstractPdfView {

    protected void buildPdfDocument(Map<String, Object> model, Document doc, PdfWriter writer,
            HttpServletRequest request, HttpServletResponse response) throws Exception {

        List<String> words = (List<String>) model.get("wordList");
        for (String word : words) {
            doc.add(new Paragraph(word));
        }
    }
}
```

Kotlin

```
class PdfWordList : AbstractPdfView() {

    override fun buildPdfDocument(model: Map<String, Any>, doc: Document, writer: PdfWriter,
            request: HttpServletRequest, response: HttpServletResponse) {

        val words = model["wordList"] as List<String>
        for (word in words) {
            doc.add(Paragraph(word))
        }
    }
}
```

控制器可以从外部视图定义（通过名称引用它）返回这样的视图，也可以从处理程序方法返回`View`实例。

##### Excel 视图

Spring Framework4.2 以来，`org.springframework.web.servlet.view.document.AbstractXlsView`被提供为 Excel 视图的基类。它是基于 Apache POI 的，具有专门的子类（`AbstractXlsxView`和`AbstractXlsxStreamingView`）来取代过时的`AbstractExcelView`类。

编程模型类似于`AbstractPdfView`，以`buildExcelDocument()`作为中心模板方法，控制器能够从外部定义（通过名称）返回这样的视图，或者作为处理程序方法的`View`实例。

#### 1.10.9.Jackson

[WebFlux](web-reactive.html#webflux-view-httpmessagewriter)

Spring 提供对 JacksonJSON 库的支持。

##### 基于 Jackson 的 JSON MVC 视图

[WebFlux](web-reactive.html#webflux-view-httpmessagewriter)

`MappingJackson2JsonView`使用 Jackson 库的`ObjectMapper`将响应内容呈现为 JSON。默认情况下，模型映射的全部内容（除了特定于框架的类）都被编码为 JSON。对于需要对映射的内容进行筛选的情况，可以指定一组特定的模型属性来使用`modelKeys`属性进行编码。你还可以使用`extractValueFromSingleKeyModel`属性，将单键模型中的值直接提取和序列化，而不是作为模型属性的映射。

你可以根据需要使用 Jackson 提供的注释来定制 JSON 映射。当你需要进一步的控制时，你可以通过`ObjectMapper`属性注入一个自定义的`ObjectMapper`，用于需要为特定类型提供自定义 JSON 序列化器和反序列化器的情况。

##### 基于 Jackson 的 XML 视图

[WebFlux](web-reactive.html#webflux-view-httpmessagewriter)

`MappingJackson2XmlView`使用[JacksonXML 扩展的](https://github.com/FasterXML/jackson-dataformat-xml)`XmlMapper`将响应内容呈现为 XML。如果模型包含多个条目，你应该使用`modelKey` Bean 属性显式地设置要序列化的对象。如果模型包含单个条目，则自动对其进行序列化。

你可以根据需要使用 JAXB 或 Jackson 提供的注释来定制 XML 映射。当需要进一步的控制时，可以通过`ObjectMapper`属性注入自定义`XmlMapper`，用于需要为特定类型提供序列化器和反序列化器的自定义 XML。

#### 1.10.10.XML 编组

`MarshallingView`使用 XML`Marshaller`（在`org.springframework.oxm`包中定义）将响应内容呈现为 XML。可以使用`MarshallingView`实例的`modelKey` Bean 属性显式地设置要编组的对象。或者，该视图对所有模型属性进行迭代，并封送`Marshaller`支持的第一个类型。有关`org.springframework.oxm`包中的功能的更多信息，请参见[使用 O/X 映射器编组 XML](data-access.html#oxm)。

#### 1.10.11.XSLT 视图

XSLT 是一种 XML 转换语言，在 Web 应用程序中作为一种视图技术很受欢迎。如果你的应用程序自然地处理 XML，或者你的模型可以很容易地转换为 XML，那么 XSLT 作为一种视图技术是一个很好的选择。下面的部分展示了如何生成 XML 文档作为模型数据，并在 Spring Web MVC 应用程序中使用 XSLT 对其进行转换。

Spring 这个示例是一个简单的应用程序，它在`控制器`中创建一个单词列表，并将它们添加到模型映射中。将返回映射以及 XSLT 视图的视图名称。有关 Spring Web MVC 的`Controller`接口的详细信息，请参见[带注释的控制器](#mvc-controller)。XSLT 控制器将单词列表转换为一个简单的 XML 文档，以便进行转换。

##### 豆子

对于简单的 Spring Web 应用程序，配置是标准的：MVC 配置必须定义`XsltViewResolver` Bean 和常规的 MVC 注释配置。下面的示例展示了如何做到这一点：

爪哇

```
@EnableWebMvc
@ComponentScan
@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public XsltViewResolver xsltViewResolver() {
        XsltViewResolver viewResolver = new XsltViewResolver();
        viewResolver.setPrefix("/WEB-INF/xsl/");
        viewResolver.setSuffix(".xslt");
        return viewResolver;
    }
}
```

Kotlin

```
@EnableWebMvc
@ComponentScan
@Configuration
class WebConfig : WebMvcConfigurer {

    @Bean
    fun xsltViewResolver() = XsltViewResolver().apply {
        setPrefix("/WEB-INF/xsl/")
        setSuffix(".xslt")
    }
}
```

##### Controller

我们还需要一个封装我们的字生成逻辑的控制器。

控制器逻辑封装在`@Controller`类中，处理程序方法定义如下：

爪哇

```
@Controller
public class XsltController {

    @RequestMapping("/")
    public String home(Model model) throws Exception {
        Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        Element root = document.createElement("wordList");

        List<String> words = Arrays.asList("Hello", "Spring", "Framework");
        for (String word : words) {
            Element wordNode = document.createElement("word");
            Text textNode = document.createTextNode(word);
            wordNode.appendChild(textNode);
            root.appendChild(wordNode);
        }

        model.addAttribute("wordList", root);
        return "home";
    }
}
```

Kotlin

```
import org.springframework.ui.set

@Controller
class XsltController {

    @RequestMapping("/")
    fun home(model: Model): String {
        val document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()
        val root = document.createElement("wordList")

        val words = listOf("Hello", "Spring", "Framework")
        for (word in words) {
            val wordNode = document.createElement("word")
            val textNode = document.createTextNode(word)
            wordNode.appendChild(textNode)
            root.appendChild(wordNode)
        }

        model["wordList"] = root
        return "home"
    }
}
```

到目前为止，我们只创建了一个 DOM 文档并将其添加到模型映射中。请注意，你也可以将 XML 文件加载为`Resource`，并使用它来代替自定义 DOM 文档。

有一些软件包可以自动对对象图进行“domify”，但是，在 Spring 之内，你可以完全灵活地以你选择的任何方式从你的模型中创建 DOM。这可以防止 XML 转换在模型数据的结构中起到太大的作用，这在使用工具管理 Domification 过程时是一种危险。

##### 转换

最后，`XsltViewResolver`解析“home”XSLT 模板文件，并将 DOM 文档合并到其中以生成视图。如`XsltViewResolver`配置中所示，XSLT 模板位于`war`目录中的`war`文件中，并以`WEB-INF/xsl`文件扩展名结束。

下面的示例展示了一个 XSLT 转换：

```
<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

    <xsl:output method="html" omit-xml-declaration="yes"/>

    <xsl:template match="/">
        <html>
            <head><title>Hello!</title></head>
            <body>
                <h1>My First Words</h1>
                <ul>
                    <xsl:apply-templates/>
                </ul>
            </body>
        </html>
    </xsl:template>

    <xsl:template match="word">
        <li><xsl:value-of select="."/></li>
    </xsl:template>

</xsl:stylesheet>
```

前面的转换呈现为以下 HTML:

```
<html>
    <head>
        <META http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Hello!</title>
    </head>
    <body>
        <h1>My First Words</h1>
        <ul>
            <li>Hello</li>
            <li>Spring</li>
            <li>Framework</li>
        </ul>
    </body>
</html>
```

### 1.11.MVC 配置

[WebFlux](web-reactive.html#webflux-config)

MVC 爪哇 配置和 MVC XML 命名空间提供了适用于大多数应用程序的默认配置，并提供了一个配置 API 来对其进行定制。

有关配置 API 中没有的更高级的定制，请参见[高级 爪哇 配置](#mvc-config-advanced-java)和[高级 XML 配置](#mvc-config-advanced-xml)。

你不需要理解由 MVC 爪哇 配置和 MVC 名称空间创建的底层 bean。如果你想了解更多信息，请参见[Special Bean Types](#mvc-servlet-special-bean-types)和[Web MVC 配置](#mvc-servlet-config)。

#### 1.11.1.启用 MVC 配置

[WebFlux](web-reactive.html#webflux-config-enable)

在 爪哇 配置中，可以使用`@EnableWebMvc`注释来启用 MVC 配置，如下例所示：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig {
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig
```

在 XML 配置中，可以使用`<mvc:annotation-driven>`元素来启用 MVC 配置，如下例所示：

```
<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <mvc:annotation-driven/>

</beans>
```

前面的示例注册了 Spring MVC的数量，并适应于 Classpath 上可用的依赖关系（例如，用于 JSON、XML 和其他的有效负载转换器）。

#### 1.11.2.MVC 配置 API

[WebFlux](web-reactive.html#webflux-config-customize)

在 爪哇 配置中，你可以实现`WebMvcConfigurer`接口，如下例所示：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    // Implement configuration methods...
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    // Implement configuration methods...
}
```

在 XML 中，你可以检查`<mvc:annotation-driven/>`的属性和子元素。你可以查看[Spring MVC XML schema](https://schema.spring.io/mvc/spring-mvc.xsd)，或者使用 IDE 的代码完成功能来发现哪些属性和子元素是可用的。

#### 1.11.3.类型转换

[WebFlux](web-reactive.html#webflux-config-conversion)

默认情况下，安装了各种数字和日期类型的格式化程序，并支持在字段上通过`@NumberFormat`和`@DateTimeFormat`进行定制。

要在 爪哇 Config 中注册自定义格式化程序和转换器，请使用以下方法：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        // ...
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun addFormatters(registry: FormatterRegistry) {
        // ...
    }
}
```

要在 XML Config 中执行相同的操作，请使用以下方法：

```
<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <mvc:annotation-driven conversion-service="conversionService"/>

    <bean id="conversionService"
            class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="org.example.MyConverter"/>
            </set>
        </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>

</beans>
```

Spring 默认情况下，MVC 在解析和格式化日期值时会考虑请求区域设置。这适用于将日期表示为带有“输入”窗体字段的字符串的窗体。但是，对于“日期”和“时间”表单字段，浏览器使用 HTML 规范中定义的固定格式。对于这种情况，日期和时间格式可以定制如下：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
        registrar.setUseIsoFormat(true);
        registrar.registerFormatters(registry);
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun addFormatters(registry: FormatterRegistry) {
        val registrar = DateTimeFormatterRegistrar()
        registrar.setUseIsoFormat(true)
        registrar.registerFormatters(registry)
    }
}
```

|   |参见[the`FormatterRegistrar`SPI]和`FormattingConversionServiceFactoryBean`有关何时使用<br/>FormatterRegistrar 实现的更多信息。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.11.4.验证

[WebFlux](web-reactive.html#webflux-config-validation)

默认情况下，如果[Bean Validation](core.html#validation-beanvalidation-overview)存在于 Classpath（例如， Hibernate 验证器）上，则`LocalValidatorFactoryBean`注册为全局[Validator](core.html#validator)，用于控制器方法参数上的`@Valid`和`Validated`。

在 爪哇 配置中，你可以自定义全局`Validator`实例，如下例所示：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public Validator getValidator() {
        // ...
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun getValidator(): Validator {
        // ...
    }
}
```

下面的示例展示了如何用 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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <mvc:annotation-driven validator="globalValidator"/>

</beans>
```

请注意，你也可以在本地注册`Validator`实现，如下例所示：

爪哇

```
@Controller
public class MyController {

    @InitBinder
    protected void initBinder(WebDataBinder binder) {
        binder.addValidators(new FooValidator());
    }
}
```

Kotlin

```
@Controller
class MyController {

    @InitBinder
    protected fun initBinder(binder: WebDataBinder) {
        binder.addValidators(FooValidator())
    }
}
```

|   |如果需要将`LocalValidatorFactoryBean`注入到某个地方，请创建一个 Bean 并将<br/>标记为`@Primary`，以避免与 MVC 配置中声明的值发生冲突。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.11.5.拦截器

在 爪哇 配置中，你可以注册拦截器以应用于传入的请求，如下例所示：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LocaleChangeInterceptor());
        registry.addInterceptor(new ThemeChangeInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**");
        registry.addInterceptor(new SecurityInterceptor()).addPathPatterns("/secure/*");
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun addInterceptors(registry: InterceptorRegistry) {
        registry.addInterceptor(LocaleChangeInterceptor())
        registry.addInterceptor(ThemeChangeInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**")
        registry.addInterceptor(SecurityInterceptor()).addPathPatterns("/secure/*")
    }
}
```

下面的示例展示了如何用 XML 实现相同的配置：

```
<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>
```

#### 1.11.6.内容类型

[WebFlux](web-reactive.html#webflux-config-content-negotiation)

你可以配置 Spring MVC 如何从请求中确定所请求的媒体类型（例如，`Accept`报头、URL 路径扩展、查询参数和其他）。

默认情况下，只检查`Accept`标头。

如果必须使用基于 URL 的内容类型解析，请考虑在路径扩展上使用查询参数策略。有关更多详细信息，请参见[后缀匹配](#mvc-ann-requestmapping-suffix-pattern-match)和[后缀匹配和 RFD](#mvc-ann-requestmapping-rfd)。

在 爪哇 配置中，你可以自定义所请求的内容类型分辨率，如下例所示：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

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

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureContentNegotiation(configurer: ContentNegotiationConfigurer) {
        configurer.mediaType("json", MediaType.APPLICATION_JSON)
        configurer.mediaType("xml", MediaType.APPLICATION_XML)
    }
}
```

下面的示例展示了如何用 XML 实现相同的配置：

```
<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>
```

#### 1.11.7.消息转换器

[WebFlux](web-reactive.html#webflux-config-message-codecs)

你可以通过覆盖[`configureMessageConverters()`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet//config/annotation/webmvccconfigurer.html#configureMessageConverters-java.util.util.list-）（以取代由 Spring MVC 创建的默认转换器），或者通过覆盖[https:///moverwomfrandframework=“2677”/DOCS:/[56.mframework:/jumframework:/

下面的示例使用定制的`ObjectMapper`来添加 XML 和 JacksonJSON 转换器，而不是默认的转换器：

爪哇

```
@Configuration
@EnableWebMvc
public class WebConfiguration implements WebMvcConfigurer {

    @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.createXmlMapper(true).build()));
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfiguration : WebMvcConfigurer {

    override fun configureMessageConverters(converters: MutableList<HttpMessageConverter<*>>) {
        val builder = Jackson2ObjectMapperBuilder()
                .indentOutput(true)
                .dateFormat(SimpleDateFormat("yyyy-MM-dd"))
                .modulesToInstall(ParameterNamesModule())
        converters.add(MappingJackson2HttpMessageConverter(builder.build()))
        converters.add(MappingJackson2XmlHttpMessageConverter(builder.createXmlMapper(true).build()))
```

在前面的示例中，[`Jackson2ObjectMapperBuilder`]（https://DOCS. Spring.io/ Spring-framework/5.3.16/javadoc-api/org/springframework/http/converter/json/Jackson2objectmapperbuilder.html）用于为`MappingJackson2HttpMessageConverter`和`MappingJackson2XmlHttpMessageConverter`创建一个通用配置，并启用了缩进、自定义的日期格式，以及注册[<`jackson-module-parameter-names`]（https://gitHub.com/gitHub-module-module-names-names），这为访问参数添加了参数

这个构建器自定义 Jackson 的默认属性如下：

* [`DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES`]（https://fasterxml.github.io/Jackson-databind/javadoc/2.6/com/fasterxml/Jackson/databind/deserializationfeature.html#fail_on_unknown_properties）被禁用。

* [`MapperFeature.DEFAULT_VIEW_INCLUSION`]（https://fasterxml.github.io/Jackson-databind/javadoc/2.6/com/fasterxml/Jackson/databind/mapperfeature.html#default_view_inclusion）被禁用。

如果在 Classpath 上检测到以下已知模块，它还会自动注册这些模块：

* [Jackson-数据类型-Joda](https://github.com/FasterXML/jackson-datatype-joda):支持 Joda-time 类型。

* [Jackson-数据类型-JSR310](https://github.com/FasterXML/jackson-datatype-jsr310):支持 爪哇8 日期和时间 API 类型。

* [Jackson-数据类型-JDK8](https://github.com/FasterXML/jackson-datatype-jdk8):支持其他 Java8 类型，例如`Optional`。

* [`jackson-module-kotlin`]（https://github.com/fasterxml/Jackson-module- Kotlin）：支持 Kotlin 类和数据类。

|   |在 JacksonXML 支持下启用缩进需要[`woodstox-core-asl`]（https://search. Maven.org/#search%7CGAv%7c1%7cg%3a%22org.codehaus.woodstox%22%20and%20a%3a%22woodstox-core-asl%22）的依赖性，此外还需要[`jackson-dataformat-xml`]（https://search. Maven.xml%7c1%7caga%7ca%3a%22%xml-dataformat-22%22%22）的依赖性。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

还有其他有趣的 Jackson 模块可供选择：

* [Jackson-数据类型-货币](https://github.com/zalando/jackson-datatype-money):支持`javax.money`类型（非官方模块）。

* [jackson-datatype-hibernate](https://github.com/FasterXML/jackson-datatype-hibernate):支持 Hibernate 特定的类型和属性（包括惰性加载方面）。

下面的示例展示了如何用 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:annotation-driven>

<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"/>
```

#### 1.11.8.视图控制器

这是一个用于定义`ParameterizableViewController`的快捷方式，该快捷方式在调用时立即转发到视图。如果在视图生成响应之前没有要运行的 Java 控制器逻辑，则可以在静态情况下使用它。

下面的 Java 配置示例将对`/`的请求转发到一个名为`home`的视图：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("home");
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun addViewControllers(registry: ViewControllerRegistry) {
        registry.addViewController("/").setViewName("home")
    }
}
```

下面的示例通过使用`<mvc:view-controller>`元素，实现了与前面示例相同的功能，但是使用了 XML:

```
<mvc:view-controller path="/" view-name="home"/>
```

如果`@RequestMapping`方法被映射到任何 HTTP 方法的 URL，则不能使用视图控制器来处理相同的 URL。这是因为 URL 与带注释的控制器的匹配被认为是对端点所有权的足够强的指示，因此可以将 405（方法 \_ 不允许）、415（不支持 \_media\_type）或类似的响应发送到客户机，以帮助进行调试。出于这个原因，建议避免在带注释的控制器和视图控制器之间分割 URL 处理。

#### 1.11.9.视图解析器

[WebFlux](web-reactive.html#webflux-config-view-resolvers)

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

下面的 Java 配置示例通过使用 JSP 和 Jackson 作为 JSON 呈现的默认`View`配置内容协商视图解析：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.enableContentNegotiation(new MappingJackson2JsonView());
        registry.jsp();
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        registry.enableContentNegotiation(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>
```

但是，请注意，自由标记、磁贴、Groovy 标记和脚本模板也需要配置底层视图技术。

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，如下例所示：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.enableContentNegotiation(new MappingJackson2JsonView());
        registry.freeMarker().cache(false);
    }

    @Bean
    public FreeMarkerConfigurer freeMarkerConfigurer() {
        FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
        configurer.setTemplateLoaderPath("/freemarker");
        return configurer;
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureViewResolvers(registry: ViewResolverRegistry) {
        registry.enableContentNegotiation(MappingJackson2JsonView())
        registry.freeMarker().cache(false)
    }

    @Bean
    fun freeMarkerConfigurer() = FreeMarkerConfigurer().apply {
        setTemplateLoaderPath("/freemarker")
    }
}
```

#### 1.11.10.静态资源

[WebFlux](web-reactive.html#webflux-config-static-resources)

此选项提供了一种方便的方式来从[`Resource`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/core/io/resource.html）-based 位置的列表中提供静态资源。

在下一个示例中，给定一个以`/resources`开头的请求，相对路径用于在 Web 应用程序根目录下或在`/static`下的 Classpath 上查找和服务相对于`/public`的静态资源。这些资源将在一年后到期，以确保最大程度地使用浏览器缓存，并减少浏览器发出的 HTTP 请求。`Last-Modified`信息是从`Resource#lastModified`推导出来的，因此`"Last-Modified"`头支持 HTTP 条件请求。

下面的清单展示了如何使用 Java 配置来实现这一点：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**")
                .addResourceLocations("/public", "classpath:/static/")
                .setCacheControl(CacheControl.maxAge(Duration.ofDays(365)));
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun addResourceHandlers(registry: ResourceHandlerRegistry) {
        registry.addResourceHandler("/resources/**")
                .addResourceLocations("/public", "classpath:/static/")
                .setCacheControl(CacheControl.maxAge(Duration.ofDays(365)))
    }
}
```

下面的示例展示了如何用 XML 实现相同的配置：

```
<mvc:resources mapping="/resources/**"
    location="/public, classpath:/static/"
    cache-period="31556926" />
```

另见[对静态资源的 HTTP 缓存支持](#mvc-caching-static-resources)。

资源处理程序还支持[`ResourceResolver`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet/resource/resourceresolver.html）实现和[`ResourceTransformer`]（https://DOCS. Spring.io/ Spring.io/ Spring-framework/DOCS/5.3.16/javoc-api/org/org/web/ Servlet/resource/resourcefork/resourcer.html）实现，你可以使用这些实现来创建一个优化的工具链，以便使用

你可以使用`VersionResourceResolver`来实现基于从内容、固定应用程序版本或其他版本计算的 MD5 散列的版本管理的资源 URL。`ContentVersionStrategy`（md5hash）是一个很好的选择——除了一些明显的例外，例如与模块加载程序一起使用的 JavaScript 资源。

下面的示例展示了如何在 Java 配置中使用`VersionResourceResolver`:

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**")
                .addResourceLocations("/public/")
                .resourceChain(true)
                .addResolver(new VersionResourceResolver().addContentVersionStrategy("/**"));
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun addResourceHandlers(registry: ResourceHandlerRegistry) {
        registry.addResourceHandler("/resources/**")
                .addResourceLocations("/public/")
                .resourceChain(true)
                .addResolver(VersionResourceResolver().addContentVersionStrategy("/**"))
    }
}
```

下面的示例展示了如何用 XML 实现相同的配置：

```
<mvc:resources mapping="/resources/**" location="/public/">
    <mvc:resource-chain resource-cache="true">
        <mvc:resolvers>
            <mvc:version-resolver>
                <mvc:content-version-strategy patterns="/**"/>
            </mvc:version-resolver>
        </mvc:resolvers>
    </mvc:resource-chain>
</mvc:resources>
```

然后，你可以使用`ResourceUrlProvider`重写 URL，并应用整个解析器和变压器链——例如，用于插入版本。MVC 配置提供了`ResourceUrlProvider` Bean，这样就可以将其注入到其他配置中。你还可以使用`ResourceUrlEncodingFilter`对 ThymeLeaf、JSP、Freemarker 和其他具有依赖于`HttpServletResponse#encodeURL`的 URL 标记的文件进行透明的重写。

请注意，当同时使用`EncodedResourceResolver`（例如，用于服务 gzipped 或 brotli 编码的资源）和`VersionResourceResolver`时，必须按此顺序注册它们。这确保了基于内容的版本总是基于未编码的文件进行可靠的计算。

[WebJars](https://www.webjars.org/documentation)也通过`WebJarsResourceResolver`支持，这是在 Classpath 上存在`org.webjars:webjars-locator-core`库时自动注册的。解析器可以重写 URL 以包括 jar 的版本，也可以匹配没有版本的传入 URL——例如，从`/jquery/jquery.min.js`到`/jquery/1.2.0/jquery.min.js`。

|   |基于`ResourceHandlerRegistry`的 Java 配置为细粒度控制提供了进一步的选项<br/>，例如，上次修改行为和优化的资源解析。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 1.11.11.默认值 Servlet

Spring MVC 允许将`DispatcherServlet`映射到`/`（从而覆盖容器的默认值 Servlet 的映射），同时仍然允许由容器的默认值处理静态资源请求 Servlet。它使用`DefaultServletHttpRequestHandler`的 URL 映射配置`/**`，并且相对于其他 URL 映射的优先级最低。

此处理程序将所有请求转发到缺省 Servlet。因此，它必须以所有其他 URL`HandlerMappings`的顺序保持在最后。如果使用`<mvc:annotation-driven>`，就是这种情况。或者，如果你设置了自己定制的`HandlerMapping`实例，请确保将其`order`属性设置为一个低于`DefaultServletHttpRequestHandler`的值，即`Integer.MAX_VALUE`。

下面的示例展示了如何通过使用默认设置来启用该功能：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureDefaultServletHandling(configurer: DefaultServletHandlerConfigurer) {
        configurer.enable()
    }
}
```

下面的示例展示了如何用 XML 实现相同的配置：

```
<mvc:default-servlet-handler/>
```

要重写`/` Servlet 映射的注意事项是，默认 Servlet 的`RequestDispatcher`必须按名称而不是按路径检索。`DefaultServletHttpRequestHandler`尝试在启动时自动检测容器的默认 Servlet，使用大多数主要 Servlet 容器（包括 Tomcat、 Jetty、GlassFish、JBoss、Resin、WebLogic 和 WebSphere）的已知名称列表。如果默认值 Servlet 已被定制配置为不同的名称，或者在默认值 Servlet 名称未知的情况下正在使用不同的 Servlet 容器，那么你必须显式地提供默认值 Servlet 的名称，如下例所示：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable("myCustomDefaultServlet");
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configureDefaultServletHandling(configurer: DefaultServletHandlerConfigurer) {
        configurer.enable("myCustomDefaultServlet")
    }
}
```

下面的示例展示了如何用 XML 实现相同的配置：

```
<mvc:default-servlet-handler default-servlet-name="myCustomDefaultServlet"/>
```

#### 1.11.12.路径匹配

[WebFlux](web-reactive.html#webflux-config-path-matching)

你可以自定义与路径匹配和 URL 处理相关的选项。有关单个选项的详细信息，请参见[`PathMatchConfigurer`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/ Servlet/config/annotation/pathmatchconfigrer.html）Javadoc。

下面的示例展示了如何在 Java 配置中定制路径匹配：

Java

```
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer
            .setPatternParser(new PathPatternParser())
            .addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController.class));
    }

    private PathPatternParser patternParser() {
        // ...
    }
}
```

Kotlin

```
@Configuration
@EnableWebMvc
class WebConfig : WebMvcConfigurer {

    override fun configurePathMatch(configurer: PathMatchConfigurer) {
        configurer
            .setPatternParser(patternParser)
            .addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
    }

    fun patternParser(): PathPatternParser {
        //...
    }
}
```

下面的示例展示了如何用 XML 实现相同的配置：

```
<mvc:annotation-driven>
    <mvc:path-matching
        trailing-slash="false"
        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"/>
```

#### 1.11.13.高级 Java 配置

[WebFlux](web-reactive.html#webflux-config-advanced-java)

`@EnableWebMvc`imports`DelegatingWebMvcConfiguration`，其中：

* 为 Spring MVC 应用程序提供默认的 Spring 配置

* 检测并委托`WebMvcConfigurer`实现来定制该配置。

对于高级模式，可以删除`@EnableWebMvc`并直接从`DelegatingWebMvcConfiguration`进行扩展，而不是实现`WebMvcConfigurer`，如下例所示：

Java

```
@Configuration
public class WebConfig extends DelegatingWebMvcConfiguration {

    // ...
}
```

Kotlin

```
@Configuration
class WebConfig : DelegatingWebMvcConfiguration() {

    // ...
}
```

你可以将现有的方法保留在`WebConfig`中，但是你现在也可以重写 Bean 来自基类的声明，并且你仍然可以在 Classpath 上拥有任何数量的其他`WebMvcConfigurer`实现。

#### 1.11.14.高级 XML 配置

MVC 命名空间没有高级模式。如果你需要在 Bean 上自定义一个你无法以其他方式更改的属性，那么你可以使用 Spring `BeanPostProcessor`生命周期钩子`ApplicationContext`，如下例所示：

Java

```
@Component
public class MyPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String name) throws BeansException {
        // ...
    }
}
```

Kotlin

```
@Component
class MyPostProcessor : BeanPostProcessor {

    override fun postProcessBeforeInitialization(bean: Any, name: String): Any {
        // ...
    }
}
```

请注意，你需要将`MyPostProcessor`声明为 Bean，可以在 XML 中显式地声明，也可以通过`<component-scan/>`声明来检测它。

### 1.12.http/2

[WebFlux](web-reactive.html#webflux-http2)

Servlet 需要 4 个容器来支持 HTTP/2，并且 Spring Framework5 与 Servlet API4 兼容。从编程模型的角度来看，应用程序不需要做任何特定的事情。但是，有一些与服务器配置相关的考虑因素。有关更多详细信息，请参见[HTTP/2Wiki 页面](https://github.com/spring-projects/spring-framework/wiki/HTTP-2-support)。

Servlet API 确实公开了一个与 HTTP/2 相关的构造。你可以使用`javax.servlet.http.PushBuilder`来主动地将资源推送到客户端，并且它被支持为[方法参数](#mvc-ann-arguments)到`@RequestMapping`的方法。

## 2. REST 客户

本节描述客户端访问 REST 端点的选项。

### 2.1.`RestTemplate`

`RestTemplate`是执行 HTTP 请求的同步客户端。 Spring 它是最初的 REST 客户机，在底层 HTTP 客户库上公开了一个简单的模板方法 API。

|   |截至 5.0，`RestTemplate`处于维护模式，只有少量的<br/>更改请求和 bug 被接受。请考虑使用[WebClient](web-reactive.html#webflux-client)，它提供了一个更现代的 API，并且<br/>支持同步、异步和流场景。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

详见[REST 端点](integration.html#rest-client-access)。

### 2.2.`WebClient`

`WebClient`是执行 HTTP 请求的非阻塞、反应式客户端。它是在 5.0 中引入的，并提供了`RestTemplate`的现代替代方案，有效地支持同步和异步以及流场景。

与`RestTemplate`相反，`WebClient`支持以下内容：

* 非阻塞 I/O。

* 反应性气流反压。

* 高并发性与较少的硬件资源.

* 功能风格的、流畅的 API，充分利用了 Java8Lambdas。

* 同步和异步交互。

* 从服务器往上流或往下流。

有关更多详细信息，请参见[WebClient](web-reactive.html#webflux-client)。

## 3. 测试

[Same in Spring WebFlux](web-reactive.html#webflux-test)

本节总结了用于 Spring MVC 应用程序的`spring-test`中可用的选项。

* Servlet API 模拟：用于单元测试控制器、过滤器和其他 Web 组件的 Servlet API 合同的模拟实现。有关更多详细信息，请参见[Servlet API](testing.html#mock-objects-servlet)模拟对象。

* TestContext Framework:支持在 JUnit 和 TestNG 测试中加载 Spring 配置，包括跨测试方法对加载的配置进行有效缓存，以及支持用`MockServletContext`加载`WebApplicationContext`。有关更多详细信息，请参见[TestContext 框架](testing.html#testcontext-framework)。

* Spring MVC 测试：一种框架，也称为`MockMvc`，用于通过`DispatcherServlet`测试带注释的控制器（即，支持注释），用 Spring MVC 基础设施完成，但没有 HTTP 服务器。有关更多详细信息，请参见[Spring MVC Test](testing.html#spring-mvc-test-framework)。

* 客户端 REST:`spring-test`提供了一个`MockRestServiceServer`，你可以将其用作模拟服务器，用于测试内部使用`RestTemplate`的客户端代码。有关更多详细信息，请参见[客户机 REST 测试](testing.html#spring-mvc-test-client)。

* `WebTestClient`:用于测试 WebFlux 应用程序，但也可以用于通过 HTTP 连接对任何服务器进行端到端集成测试。它是一个非阻塞的、反应性的客户机，非常适合于测试异步和流媒体场景。

## 4. WebSockets

[WebFlux](web-reactive.html#webflux-websocket)

参考文档的这一部分涵盖了对 Servlet 堆栈、 WebSocket 消息传递的支持，这些消息传递包括原始 WebSocket 交互、 WebSocket 通过 Sockjs 的模拟，以及通过 STOMP 作为 WebSocket 上的子协议的发布-订阅消息传递。

### 4.1. WebSocket 介绍

WebSocket 协议[RFC 6455](https://tools.ietf.org/html/rfc6455)提供了一种标准化的方式，通过单个 TCP 连接在客户机和服务器之间建立全双工、双向通信通道。它是一种与 HTTP 不同的 TCP 协议，但其设计是通过 HTTP 工作的，使用端口 80 和 443，并允许重用现有的防火墙规则。

WebSocket 交互以一个 HTTP 请求开始，该 HTTP 请求使用 HTTP头来升级或在这种情况下切换到 WebSocket 协议。下面的示例展示了这样的交互：

```
GET /spring-websocket-portfolio/portfolio HTTP/1.1
Host: localhost:8080
Upgrade: websocket (1)
Connection: Upgrade (2)
Sec-WebSocket-Key: Uc9l9TMkWGbHFD2qnFHltg==
Sec-WebSocket-Protocol: v10.stomp, v11.stomp
Sec-WebSocket-Version: 13
Origin: http://localhost:8080
```

|**1**|`Upgrade`标头。|
|-----|-------------------------------|
|**2**|使用`Upgrade`连接。|

具有 WebSocket 支持的服务器将返回类似于以下内容的输出，而不是通常的 200 状态代码：

```
HTTP/1.1 101 Switching Protocols (1)
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: 1qVdfYHU9hPOl4JYYNXF623Gzn0=
Sec-WebSocket-Protocol: v10.stomp
```

|**1**|协议转换|
|-----|---------------|

在成功握手之后，HTTP 升级请求中的 TCP 套接字仍然是开放的，以便客户机和服务器继续发送和接收消息。

关于 WebSockets 如何工作的完整介绍超出了本文的范围。参见 RFC6455，HTML5 的 WebSocket 章，或 Web 上的许多介绍和教程中的任何一个。

注意，如果 WebSocket 服务器运行在 Web 服务器（例如 Nginx）的后面，则可能需要将其配置为将 WebSocket 升级请求传递到 WebSocket 服务器。同样，如果应用程序在云环境中运行，则检查与 WebSocket 支持相关的云提供商的指令。

#### 4.1.1.HTTP 与 WebSocket

WebSocket 即使被设计为与 HTTP 兼容并且以 HTTP 请求开始，重要的是要理解这两个协议导致非常不同的体系结构和应用程序编程模型。

在 HTTP 和 REST 中，应用程序被建模为许多 URL。为了与应用程序交互，客户端访问这些 URL，请求-响应样式。服务器根据 HTTP URL、方法和标头将请求路由到适当的处理程序。

相比之下，在 WebSockets 中，初始连接通常只有一个 URL。随后，所有应用程序消息都在相同的 TCP 连接上流动。这指向了一种完全不同的异步、事件驱动的消息传递体系结构。

WebSocket 也是一种低级传输协议，其与 HTTP 不同，不对消息的内容规定任何语义。这意味着，除非客户机和服务器在消息语义上达成一致，否则就没有路由或处理消息的方法。

WebSocket 客户端和服务器可以协商使用更高级别的消息传递协议（例如，STOMP），通过头上的 HTTP 握手请求。如果不能做到这一点，他们就需要拿出自己的惯例。

#### 4.1.2.何时使用 WebSockets

WebSockets 可以使 Web 页面具有动态性和交互性。然而，在许多情况下，Ajax 和 HTTP 流或长轮询的组合可以提供简单有效的解决方案。

例如，新闻、邮件和社交提要需要动态更新，但每隔几分钟更新一次可能完全没问题。另一方面，协作、游戏和金融应用程序需要更接近实时。

延迟本身并不是一个决定因素。如果消息量相对较低（例如，监视网络故障），则 HTTP 流或轮询可以提供有效的解决方案。 WebSocket 是低延迟、高频率和大容量的组合，这是使用 WebSocket 的最佳情况。

还请记住，在 Internet 上，超出你控制范围的限制性代理可能会阻止 WebSocket 交互，这是因为它们未被配置为传递`Upgrade`头，或者是因为它们关闭了似乎空闲的长期连接。这意味着对防火墙内的内部应用程序使用 WebSocket 比对面向公共的应用程序使用 WebSocket 是一个更直接的决定。

### 4.2. WebSocket API

[WebFlux](web-reactive.html#webflux-websocket-server)

Spring 框架提供了一个 WebSocket API，你可以使用该 API 来编写处理 WebSocket 消息的客户端和服务器端应用程序。

#### 4.2.1.`WebSocketHandler`

[WebFlux](web-reactive.html#webflux-websocket-server-handler)

创建 WebSocket 服务器就像实现`WebSocketHandler`一样简单，或者更有可能的是，扩展`TextWebSocketHandler`或`BinaryWebSocketHandler`。下面的示例使用`TextWebSocketHandler`:

```
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.TextMessage;

public class MyHandler extends TextWebSocketHandler {

    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
        // ...
    }

}
```

有专门的 WebSocket Java 配置和 XML 命名空间支持，用于将前面的 WebSocket 处理程序映射到特定的 URL，如下例所示：

```
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/myHandler");
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new MyHandler();
    }

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:handlers>
        <websocket:mapping path="/myHandler" handler="myHandler"/>
    </websocket:handlers>

    <bean id="myHandler" class="org.springframework.samples.MyHandler"/>

</beans>
```

前面的示例是用于 Spring MVC 应用程序中的，并且应该包括在[]（#MVC- Servlet）的配置中。然而， Spring 的 WebSocket 支持并不依赖于 Spring MVC。在[`WebSocketHttpRequestHandler`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/socket/server/support/websockettprequesthandler.html）的帮助下，将`WebSocketHandler`集成到其他 HTTP 服务环境中是相对简单的。

当直接 VS 间接地使用`WebSocketHandler`API 时，例如通过[STOMP](#websocket-stomp)消息传递时，应用程序必须同步消息的发送，因为底层标准 WebSocket 会话（JSR-356）不允许并发。一个选项是将`WebSocketSession`与[`ConcurrentWebSocketSessionDecorator`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/socket/handler/concurrentwebsocketsessiondecorator.html）包装在一起。

#### 4.2.2. WebSocket 握手

[WebFlux](web-reactive.html#webflux-websocket-server-handshake)

定制初始 HTTP WebSocket 握手请求的最简单方法是通过`HandshakeInterceptor`，该方法公开了握手之前和之后的方法。你可以使用这样的拦截器来阻止握手或使`WebSocketSession`的任何属性可用。下面的示例使用内置的拦截器将 HTTP 会话属性传递给 WebSocket 会话：

```
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyHandler(), "/myHandler")
            .addInterceptors(new HttpSessionHandshakeInterceptor());
    }

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:handlers>
        <websocket:mapping path="/myHandler" handler="myHandler"/>
        <websocket:handshake-interceptors>
            <bean class="org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor"/>
        </websocket:handshake-interceptors>
    </websocket:handlers>

    <bean id="myHandler" class="org.springframework.samples.MyHandler"/>

</beans>
```

一个更高级的选项是扩展执行 WebSocket 握手步骤的`DefaultHandshakeHandler`，包括验证客户机原点、协商子协议和其他细节。如果应用程序需要配置自定义`RequestUpgradeStrategy`以适应 WebSocket 服务器引擎和尚未支持的版本，则可能还需要使用此选项（有关此主题的更多信息，请参见[Deployment](#websocket-server-deployment)）。Java 配置和 XML 命名空间都使配置自定义`HandshakeHandler`成为可能。

|   |Spring 提供了一个`WebSocketHandlerDecorator`基类，你可以使用它来使用附加行为来装饰<br/>a`WebSocketHandler`。当使用 WebSocket Java 配置<br/>或 XML 命名空间时，默认提供并添加日志记录和异常处理<br/>实现。`ExceptionWebSocketHandlerDecorator`捕获由任何`WebSocketHandler`方法产生的所有未捕获的<br/>异常，并关闭 WebSocket <br/>具有状态`1011`的会话，这表示服务器错误。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 4.2.3.部署

Spring  WebSocket API 很容易集成到 Spring MVC 应用程序中，其中`DispatcherServlet`同时服务于 HTTP WebSocket 握手和其他 HTTP 请求。通过调用`WebSocketHttpRequestHandler`，也很容易集成到其他 HTTP 处理场景中。这很方便，也很容易理解。但是，对于 JSR-356 运行时，需要进行特殊的考虑。

Java WebSocket API（JSR-356）提供了两种部署机制。第一个涉及启动时的 Servlet 容器 Classpath 扫描（ Servlet 3 特征）。另一种是在 Servlet 容器初始化时使用的注册 API。这两种机制都不可能对所有 HTTP 处理（包括 WebSocket 握手和所有其他 HTTP 请求）使用单一的“前置控制器”，例如 Spring MVC 的。

这是 JSR-356 的一个重大限制，即 Spring 的 WebSocket 支持具有特定于服务器的`RequestUpgradeStrategy`实现的地址，即使在 JSR-356 运行时也是如此。此类策略目前存在于 Tomcat、 Jetty、GlassFish、WebLogic、WebSphere 和 Undertow（以及 Wildfly）。

|   |在 Java WebSocket API 中克服前面的限制的请求已被<br/>创建，并且可以在[eclipse-ee4j/websocket-api#211](https://github.com/eclipse-ee4j/websocket-api/issues/211)处被遵循。<br/> Tomcat， Undertow，和 WebSphere 提供了它们自己的 API 替代方案，使其能够做到这一点，并且与 Jetty 一起也是可能的。我们希望<br/>更多的服务器也能做到这一点。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

第二个考虑因素是，支持 JSR-356 的 Servlet 容器预计将执行`ServletContainerInitializer`扫描，这可能会大大减慢应用程序的启动速度——在某些情况下。如果在升级到具有 JSR-356 支持的 Servlet 容器版本后观察到重大影响，则应该可以通过使用`<absolute-ordering />`中的`<absolute-ordering />`元素选择性地启用或禁用 Web 片段（和 SCI 扫描），如下例所示：

```
<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
        https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">

    <absolute-ordering/>

</web-app>
```

然后，你可以根据名称选择性地启用 Web 片段，例如 Spring 自己的`SpringServletContainerInitializer`，它为 Servlet 3Java 初始化 API 提供了支持。下面的示例展示了如何做到这一点：

```
<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
        https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">

    <absolute-ordering>
        <name>spring_web</name>
    </absolute-ordering>

</web-app>
```

#### 4.2.4.服务器配置

[WebFlux](web-reactive.html#webflux-websocket-server-config)

WebSocket 每个底层引擎都公开了控制运行时特性的配置属性，例如消息缓冲区大小、空闲超时等。

对于 Tomcat、Wildfly 和 GlassFish，可以在 WebSocket Java 配置中添加`ServletServerContainerFactoryBean`，如下例所示：

```
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Bean
    public ServletServerContainerFactoryBean createWebSocketContainer() {
        ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
        container.setMaxTextMessageBufferSize(8192);
        container.setMaxBinaryMessageBufferSize(8192);
        return container;
    }

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <bean class="org.springframework...ServletServerContainerFactoryBean">
        <property name="maxTextMessageBufferSize" value="8192"/>
        <property name="maxBinaryMessageBufferSize" value="8192"/>
    </bean>

</beans>
```

|   |对于客户端 WebSocket 配置，你应该使用`WebSocketContainerFactoryBean`或`ContainerProvider.getWebSocketContainer()`（Java 配置）。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|

对于 Jetty，你需要提供一个预先配置的 Jetty `WebSocketServerFactory`，并通过 WebSocket Java 配置将其插入 Spring 的`DefaultHandshakeHandler`。下面的示例展示了如何做到这一点：

```
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(echoWebSocketHandler(),
            "/echo").setHandshakeHandler(handshakeHandler());
    }

    @Bean
    public DefaultHandshakeHandler handshakeHandler() {

        WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
        policy.setInputBufferSize(8192);
        policy.setIdleTimeout(600000);

        return new DefaultHandshakeHandler(
                new JettyRequestUpgradeStrategy(new WebSocketServerFactory(policy)));
    }

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:handlers>
        <websocket:mapping path="/echo" handler="echoHandler"/>
        <websocket:handshake-handler ref="handshakeHandler"/>
    </websocket:handlers>

    <bean id="handshakeHandler" class="org.springframework...DefaultHandshakeHandler">
        <constructor-arg ref="upgradeStrategy"/>
    </bean>

    <bean id="upgradeStrategy" class="org.springframework...JettyRequestUpgradeStrategy">
        <constructor-arg ref="serverFactory"/>
    </bean>

    <bean id="serverFactory" class="org.eclipse.jetty...WebSocketServerFactory">
        <constructor-arg>
            <bean class="org.eclipse.jetty...WebSocketPolicy">
                <constructor-arg value="SERVER"/>
                <property name="inputBufferSize" value="8092"/>
                <property name="idleTimeout" value="600000"/>
            </bean>
        </constructor-arg>
    </bean>

</beans>
```

#### 4.2.5.允许的来源

[WebFlux](web-reactive.html#webflux-websocket-server-cors)

在 Spring Framework4.1.5 中， WebSocket 和 Sockjs 的默认行为是仅接受同源请求。也可以允许所有或指定的源列表。这种检查主要是为浏览器客户端设计的。没有什么可以阻止其他类型的客户机修改`Origin`标头值（有关更多详细信息，请参见[RFC6454:Web Origin 概念](https://tools.ietf.org/html/rfc6454)）。

这三种可能的行为是：

* 只允许同源请求（默认）：在这种模式下，当启用 Sockjs 时，IFRAME HTTP 响应头设置为，并且禁用 JSONP 传输，因为它不允许检查请求的源。因此，当启用此模式时，IE6 和 IE7 将不受支持。

* 允许指定的源列表：每个允许的源列表必须以`http://`或`https://`开头。在这种模式下，当启用 Sockjs 时，iframe 传输将被禁用。因此，当启用此模式时，IE6 到 IE9 将不受支持。

* 允许所有原点：要启用此模式，你应该提供`*`作为允许的原点值。在这种模式下，所有的传输都是可用的。

你可以配置 WebSocket 和 Sockjs 允许的起源，如下例所示：

```
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/myHandler").setAllowedOrigins("https://mydomain.com");
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new MyHandler();
    }

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:handlers allowed-origins="https://mydomain.com">
        <websocket:mapping path="/myHandler" handler="myHandler" />
    </websocket:handlers>

    <bean id="myHandler" class="org.springframework.samples.MyHandler"/>

</beans>
```

### 4.3.Sockjs 后援

在公共互联网上，不受你控制的限制性代理可能会阻止 WebSocket 交互，要么是因为它们未被配置为传递`Upgrade`头，要么是因为它们关闭了似乎处于空闲状态的长期连接。

这个问题的解决方案是 WebSocket 仿真——即，尝试先使用 WebSocket，然后再使用基于 HTTP 的技术，该技术模拟 WebSocket 交互并公开相同的应用程序级 API。

在 Servlet 栈上， Spring 框架为 Sockjs 协议提供了服务器（以及客户端）支持。

#### 4.3.1.概述

SockJS 的目标是让应用程序使用 WebSocket API，但在运行时在必要时退回到非 WebSocket 替代方案，而不需要更改应用程序代码。

Sockjs 包括：

* 将[Sockjs 协议](https://github.com/sockjs/sockjs-protocol)定义为可执行文件[叙述测试](https://sockjs.github.io/sockjs-protocol/sockjs-protocol-0.3.3.html)的形式。

* [Sockjs JavaScript 客户端](https://github.com/sockjs/sockjs-client/)——用于浏览器的客户库。

* Sockjs 服务器实现，包括在 Spring 框架`spring-websocket`模块中的一个。

* `spring-websocket`模块中的 Sockjs Java 客户端（自版本 4.1 起）。

Sockjs 是为在浏览器中使用而设计的。它使用各种技术来支持各种浏览器版本。有关 Sockjs 传输类型和浏览器的完整列表，请参见[Sockjs 客户端](https://github.com/sockjs/sockjs-client/)页面。传输可分为三大类： WebSocket、HTTP 流和 HTTP 长轮询。有关这些类别的概述，请参见[这篇博文](https://spring.io/blog/2012/05/08/spring-mvc-3-2-preview-techniques-for-real-time-updates/)。

Sockjs 客户机通过发送`GET /info`开始从服务器获取基本信息。在那之后，它必须决定使用什么交通工具。如果可能，使用 WebSocket。如果没有，在大多数浏览器中，至少有一个 HTTP 流媒体选项。如果不是，则使用 HTTP（长）轮询。

所有传输请求都具有以下 URL 结构：

```
https://host:port/myApp/myEndpoint/{server-id}/{session-id}/{transport}
```

地点：

* `{server-id}`对于群集中的路由请求很有用，但不用于其他方式。

* `{session-id}`关联属于 Sockjs 会话的 HTTP 请求。

* `{transport}`表示传输类型（例如，`websocket`，`xhr-streaming`等）。

WebSocket 传输只需要一个 HTTP 请求就可以完成 WebSocket 握手。此后的所有消息都在该套接字上交换。

HTTP 传输需要更多的请求。例如，Ajax/XHR 流依赖于对服务器到客户端消息的一个长时间运行的请求，以及对客户端到服务器消息的额外 HTTP POST 请求。长轮询是类似的，只是它在每个服务器到客户端发送后结束当前请求。

Sockjs 添加了最小的消息框架。例如，服务器最初发送字母`o`（“打开”框架），消息被发送为`a["message1","message2"]`（JSON 编码的数组），如果 25 秒内没有消息流（默认情况下），则发送字母`h`（“心跳”框架），并将字母`c`（“关闭”框架）关闭会话。

要了解更多信息，请在浏览器中运行一个示例，并观察 HTTP 请求。Sockjs 客户机允许固定传输列表，因此可以一次查看每个传输。Sockjs 客户机还提供了一个调试标志，可以在浏览器控制台中启用有用的消息。在服务器端，你可以启用`TRACE`的`org.springframework.web.socket`日志记录。有关更多详细信息，请参见 Sockjs 协议[旁白测试](https://sockjs.github.io/sockjs-protocol/sockjs-protocol-0.3.3.html)。

#### 4.3.2.启用 Sockjs

你可以通过 Java 配置启用 Sockjs，如下例所示：

```
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(myHandler(), "/myHandler").withSockJS();
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new MyHandler();
    }

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:handlers>
        <websocket:mapping path="/myHandler" handler="myHandler"/>
        <websocket:sockjs/>
    </websocket:handlers>

    <bean id="myHandler" class="org.springframework.samples.MyHandler"/>

</beans>
```

前面的示例是用于 Spring MVC 应用程序中的，并且应该包括在[]（#MVC- Servlet）的配置中。然而， Spring 的 WebSocket 和 Sockjs 支持并不依赖于 Spring MVC。在[`SockJsHttpRequestHandler`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/socket/sockkjs/support/sockjshtprequesthandler.html）的帮助下，集成到其他 HTTP 服务环境是相对简单的。

在浏览器方面，应用程序可以使用[`sockjs-client`]（https://github.com/sockjs/sockjs-client/）（版本 1.0.x）。它模拟 W3C WebSocket API，并与服务器通信以根据其运行的浏览器选择最佳传输选项。请参阅[Sockjs-客户端](https://github.com/sockjs/sockjs-client/)页面和浏览器支持的传输类型列表。客户机还提供了几个配置选项——例如，指定要包含哪些传输。

#### 4.3.3.IE8 和 IE9

Internet Explorer8 和 9 仍在使用中。它们是拥有袜子的一个关键原因。本节介绍了在这些浏览器中运行的重要注意事项。

Sockjs 客户机通过使用微软的[`XDomainRequest`]（https://blogs.msdn.com/b/ieinnals/archive/2010/05/13/xdomainRequest-Restrictions-Limitions-and-Workarounds.ASPX），在 IE8 和 9 中支持 Ajax/XHR 流媒体。它可以跨域工作，但不支持发送 cookie。对于 Java 应用程序来说，Cookie 通常是必不可少的。然而，由于 Sockjs 客户机可以用于许多服务器类型（而不仅仅是 Java 类型），因此它需要知道 Cookie 是否重要。如果是这样的话，Sockjs 客户机更喜欢 Ajax/XHR。否则，它依赖于一种基于 iframe 的技术。

来自 Sockjs 客户机的第一个`/info`请求是对可能影响客户机选择传输方式的信息的请求。这些细节之一是服务器应用程序是否依赖 Cookie（例如，出于身份验证目的或使用粘性会话进行集群）。 Spring 的 Sockjs 支持包括一个名为`sessionCookieNeeded`的属性。默认情况下，它是启用的，因为大多数 Java 应用程序依赖于`JSESSIONID`cookie。如果你的应用程序不需要它，你可以关闭此选项，然后 Sockjs 客户端应该在 IE8 和 IE9 中选择`xdr-streaming`。

如果确实使用基于 iframe 的传输，请记住，可以通过将 HTTP 响应头`X-Frame-Options`设置为`DENY`、`SAMEORIGIN`或`ALLOW-FROM <origin>`，指示浏览器阻止在给定页面上使用 iframes。这是用来防止[点击劫持](https://www.owasp.org/index.php/Clickjacking)。

|   |Spring Security3.2+ 为在每个<br/>响应上设置`X-Frame-Options`提供了支持。默认情况下， Spring Security Java 配置将其设置为`DENY`。<br/>在 3.2 中， Spring Security XML 命名空间默认情况下不设置该标头<br/>，但可以配置为这样做。在将来，它可能会默认设置它。<br/><br/>有关如何配置[默认安全标头](https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#headers)标题`X-Frame-Options`的设置的详细信息，请参见 Spring 安全文档的[默认安全标头](https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#headers)。你还可以查看[SEC-2501](https://jira.spring.io/browse/SEC-2501)以获取更多背景信息。|
|---| |

如果你的应用程序添加了`X-Frame-Options`响应报头（应该如此！）并依赖于基于 iframe 的传输，则需要将报头值设置为`SAMEORIGIN`或`ALLOW-FROM <origin>`。 Spring Sockjs 支持还需要知道 Sockjs 客户机的位置，因为它是从 iframe 加载的。默认情况下，iframe 被设置为从 CDN 位置下载 Sockjs 客户端。将此选项配置为使用来自与应用程序相同来源的 URL 是一个好主意。

下面的示例展示了如何在 Java 配置中实现这一点：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio").withSockJS()
                .setClientLibraryUrl("http://localhost:8080/myapp/js/sockjs-client.js");
    }

    // ...

}
```

XML 名称空间通过`<websocket:sockjs>`元素提供了类似的选项。

|   |在最初的开发过程中，启用 Sockjs 客户机`devel`模式，该模式可以防止<br/>浏览器缓存原本会缓存<br/>的 Sockjs 请求（如 iframe）。有关如何启用它的详细信息，请参见[Sockjs 客户端](https://github.com/sockjs/sockjs-client/)页面。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 4.3.4.心跳

Sockjs 协议要求服务器发送心跳消息，以防止代理得出连接已挂起的结论。 Spring Sockjs 配置具有一个名为`heartbeatTime`的属性，你可以使用该属性来定制频率。默认情况下，假设在该连接上没有发送其他消息，则会在 25 秒后发送心跳。对于公共互联网应用程序，这个 25 秒的值与下面的[IETF 推荐](https://tools.ietf.org/html/rfc6202)一致。

|   |在使用 STOMP over WebSocket 和 Sockjs 时，如果 STOMP 客户机和服务器协商<br/>要交换的心跳，则禁用 Sockjs 心跳。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------|

Spring Sockjs 支持还允许你配置`TaskScheduler`来调度心跳任务。任务计划程序由线程池支持，并根据可用处理器的数量进行默认设置。你应该考虑根据你的特定需求自定义设置。

#### 4.3.5.客户端断开连接

HTTP 流和 HTTP 长轮询 Sockjs 传输要求连接的打开时间比通常更长。有关这些技术的概述，请参见[这篇博文](https://spring.io/blog/2012/05/08/spring-mvc-3-2-preview-techniques-for-real-time-updates/)。

在 Servlet 容器中，这是通过 Servlet 3 异步支持完成的，该异步支持允许退出 Servlet 容器线程，处理请求，并继续写入来自另一个线程的响应。

一个具体的问题是， Servlet API 不为已经消失的客户机提供通知。见[eclipse-ee4j/servlet-api#44](https://github.com/eclipse-ee4j/servlet-api/issues/44)。然而， Servlet 容器在随后尝试写入响应时会引发异常。由于 Spring 的 SockJS 服务支持服务器发送的心跳（默认情况下为每 25 秒），这意味着通常会在该时间段内（如果发送消息的频率更高，则会更早）检测到客户端断开连接。

|   |结果，由于客户端已断开连接，可能会发生网络 I/O 故障，而<br/>会用不必要的堆栈跟踪来填充日志。 Spring 尽最大努力通过使用专用日志类别来标识<br/>表示客户端断开连接（特定于每个服务器）和日志<br/>的这样的网络故障，`DISCONNECTED_CLIENT_LOG_CATEGORY`（在`AbstractSockJsSession`中定义）。如果需要查看堆栈跟踪，可以将<br/>日志类别设置为跟踪。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 4.3.6.Sockjs 和 CORS

如果允许跨源请求（参见[允许的来源](#websocket-server-allowed-origins)），那么 Sockjs 协议在 XHR 流和轮询传输中使用 CORS 提供跨域支持。因此，CORS 头是自动添加的，除非检测到响应中存在 CORS 头。因此，如果应用程序已经被配置为提供 CORS 支持（例如，通过 Servlet 过滤器），则 Spring 的`SockJsService`跳过了这一部分。

还可以通过在 Spring 的 SockjsService 中设置`suppressCors`属性来禁用这些 CORS 头的添加。

Sockjs 期望以下标题和值：

* `Access-Control-Allow-Origin`:从`Origin`请求头的值初始化。

* `Access-Control-Allow-Credentials`:总是设置为`true`。

* `Access-Control-Request-Headers`:从等效请求头的值初始化。

* `Access-Control-Allow-Methods`:传输支持的 HTTP 方法（参见`TransportType`枚举）。

* `Access-Control-Max-Age`:设置为 31536000（1 年）。

有关确切的实现，请参见`addCorsHeaders`中的`AbstractSockJsService`和源代码中的`TransportType`枚举。

或者，如果 CORS 配置允许，可以考虑排除具有 Sockjs 端点前缀的 URL，从而让 Spring 的`SockJsService`处理它。

#### 4.3.7.`SockJsClient`

Spring 提供了一种 Sockjs Java 客户端，以在不使用浏览器的情况下连接到远程 Sockjs 端点。当需要在公共网络上的两个服务器之间进行双向通信时（即，在网络代理可以排除使用 WebSocket 协议的情况下），这可能是特别有用的。对于测试目的（例如，模拟大量并发用户），Sockjs Java 客户机也非常有用。

Sockjs Java 客户端支持`websocket`、`xhr-streaming`和`xhr-polling`传输。剩下的那些只有在浏览器中使用才有意义。

你可以将`WebSocketTransport`配置为：

* `StandardWebSocketClient`在 JSR-356 运行时中。

* `JettyWebSocketClient`通过使用 Jetty 9+ 本机 WebSocket API。

* Spring 的`WebSocketClient`的任意实现。

根据定义，`XhrTransport`同时支持`xhr-streaming`和`xhr-polling`，因为从客户机的角度来看，除了用于连接到服务器的 URL 之外，没有其他区别。目前有两种实现方式：

* `RestTemplateXhrTransport`将 Spring 的`RestTemplate`用于 HTTP 请求。

* `JettyXhrTransport`将 Jetty 的`HttpClient`用于 HTTP 请求。

下面的示例展示了如何创建 Sockjs 客户机并连接到 Sockjs 端点：

```
List<Transport> transports = new ArrayList<>(2);
transports.add(new WebSocketTransport(new StandardWebSocketClient()));
transports.add(new RestTemplateXhrTransport());

SockJsClient sockJsClient = new SockJsClient(transports);
sockJsClient.doHandshake(new MyWebSocketHandler(), "ws://example.com:8080/sockjs");
```

|   |Sockjs 使用 JSON 格式化的数组来处理消息。默认情况下，使用 Jackson2 并且需要<br/>才能在 Classpath 上。或者，你可以配置`SockJsMessageCodec`的自定义实现，并在`SockJsClient`上配置它。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

要使用`SockJsClient`来模拟大量并发用户，你需要配置底层 HTTP 客户端（用于 XHR 传输）以允许足够数量的连接和线程。下面的示例展示了如何使用 Jetty 来实现这一点：

```
HttpClient jettyHttpClient = new HttpClient();
jettyHttpClient.setMaxConnectionsPerDestination(1000);
jettyHttpClient.setExecutor(new QueuedThreadPool(1000));
```

下面的示例显示了你还应该考虑定制的服务器端 Sockjs 相关属性（详细信息请参见 Javadoc）：

```
@Configuration
public class WebSocketConfig extends WebSocketMessageBrokerConfigurationSupport {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/sockjs").withSockJS()
            .setStreamBytesLimit(512 * 1024) (1)
            .setHttpMessageCacheSize(1000) (2)
            .setDisconnectDelay(30 * 1000); (3)
    }

    // ...
}
```

|**1**|将`streamBytesLimit`属性设置为 512KB（默认值为 128KB—`128 * 1024`）。|
|-----|-----------------------------------------------------------------------------------------------------|
|**2**|将`httpMessageCacheSize`属性设置为 1,000（默认值为`100`）。|
|**3**|将`disconnectDelay`属性设置为 30 个属性秒（默认值为 5 秒—`5 * 1000`）。|

### 4.4.跺脚

WebSocket 协议定义了两种类型的消息（文本和二进制），但它们的内容是未定义的。该协议定义了一种机制，用于客户端和服务器协商在 WebSocket 之上使用的子协议（即更高级别的消息传递协议）来定义各自可以发送什么样的消息、格式是什么、每个消息的内容等等。子协议的使用是可选的，但无论哪种方式，客户机和服务器都需要在定义消息内容的某些协议上达成一致。

#### 4.4.1.概述

[STOMP](https://stomp.github.io/stomp-specification-1.2.html#Abstract)（简单的文本消息传递协议）最初是为脚本语言（例如 Ruby、Python 和 Perl）创建的，用于连接到 Enterprise 消息代理。它旨在解决常用消息传递模式的最小子集。Stomp 可以在任何可靠的双向流网络协议上使用，例如 TCP 和 WebSocket。尽管 STOMP 是一种面向文本的协议，但消息负载可以是文本的，也可以是二进制的。

STOMP 是一种基于帧的协议，其帧是以 HTTP 为模型的。下面的清单显示了 Stomp 框架的结构：

```
COMMAND
header1:value1
header2:value2

Body^@
```

客户端可以使用`SEND`或`SUBSCRIBE`命令发送或订阅消息，以及一个`destination`头，该头描述消息的内容以及应该由谁接收。这启用了一个简单的发布-订阅机制，你可以使用该机制通过代理向其他连接的客户机发送消息，或者向服务器发送消息，以请求执行某些工作。

当你使用 Spring 的 STOMP 支持时， Spring  WebSocket 应用程序充当客户的 STOMP 代理。消息被路由到`@Controller`消息处理方法或简单的内存代理，该代理跟踪订阅并向订阅的用户广播消息。还可以配置 Spring 来使用专用的 Stomp 代理（例如 RabbitMQ、ActiveMQ 和其他代理）来实际广播消息。在这种情况下， Spring 维护到代理的 TCP 连接，将消息中继到代理，并将消息从代理向下传递到已连接的 WebSocket 客户端。因此， Spring Web 应用程序可以依赖统一的基于 HTTP 的安全性、公共验证和熟悉的编程模型来进行消息处理。

下面的示例显示了订阅接收股票报价的客户机，服务器可能会定期发送该报价（例如，通过调度任务通过`SimpMessagingTemplate`向经纪人发送消息）：

```
SUBSCRIBE
id:sub-1
destination:/topic/price.stock.*

^@
```

下面的示例显示了一个发送交易请求的客户机，服务器可以通过`@MessageMapping`方法处理该请求：

```
SEND
destination:/queue/trade
content-type:application/json
content-length:44

{"action":"BUY","ticker":"MMM","shares",44}^@
```

执行后，服务器可以向客户端广播交易确认消息和详细信息。

在 Stomp 规范中，目的地的含义是故意不透明的。它可以是任何字符串，完全由 Stomp 服务器来定义它们所支持的目标的语义和语法。然而，很常见的情况是，目标是类似路径的字符串，其中`/topic/..`表示发布-订阅（一对多），而`/queue/`表示点对点（一对一）消息交换。

Stomp 服务器可以使用`MESSAGE`命令向所有订阅者广播消息。下面的示例显示了一个服务器，该服务器将股票报价发送到一个已订阅的客户端：

```
MESSAGE
message-id:nxahklf6-1
subscription:sub-1
destination:/topic/price.stock.MMM

{"ticker":"MMM","price":129.45}^@
```

服务器不能发送未经请求的消息。来自服务器的所有消息必须响应特定的客户端订阅，并且服务器消息的`subscription-id`头必须与客户端订阅的`id`头匹配。

前面的概述旨在提供对 STOMP 协议的最基本的理解。我们建议对[规格](https://stomp.github.io/stomp-specification-1.2.html)协议进行全面审查。

#### 4.4.2.福利

与使用原始 WebSockets 相比，使用 STOMP 作为子协议使得 Spring 框架和 Spring 安全性提供了更丰富的编程模型。关于 HTTP 相对于原始 TCP 以及它如何让 Spring MVC 和其他 Web 框架提供丰富的功能，也可以提出同样的观点。以下是一系列好处：

* 无需发明定制的消息传递协议和消息格式。

* 在 Spring 框架中，包括[Java 客户端](#websocket-stomp-client)在内的 STOMP 客户机是可用的。

* 你可以（可选地）使用消息代理（例如 RabbitMQ、ActiveMQ 和其他代理）来管理订阅和广播消息。

* 应用程序逻辑可以在任意数量的`@Controller`实例中进行组织，并且可以基于 stomp 目标头将消息路由到它们，而不是针对给定连接使用单个`WebSocketHandler`处理原始消息。

* Spring 可以使用安全性来保护基于 STOMP 目的地和消息类型的消息。

#### 4.4.3.启用 Stomp

WebSocket 支持在`spring-messaging`和`spring-websocket`模块中可用。一旦有了这些依赖关系，就可以使用[Sockjs 后援](#websocket-fallback)在 WebSocket 上公开 Stomp 端点，如下例所示：

```
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio").withSockJS();  (1)
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.setApplicationDestinationPrefixes("/app"); (2)
        config.enableSimpleBroker("/topic", "/queue"); (3)
    }
}
```

|**1**|`/portfolio`是 WebSocket（或 Sockjs）<br/>客户端为 WebSocket 握手需要连接到的端点的 HTTP URL。|
|-----|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|**2**|目标头以`/app`开头的 stomp 消息被路由到`@MessageMapping`类中的`@Controller`方法。|
|**3**|使用内置的消息代理进行订阅和广播，并将目标头以`/topic `或`/queue`开头的消息路由到代理。|

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:message-broker application-destination-prefix="/app">
        <websocket:stomp-endpoint path="/portfolio">
            <websocket:sockjs/>
        </websocket:stomp-endpoint>
        <websocket:simple-broker prefix="/topic, /queue"/>
    </websocket:message-broker>

</beans>
```

|   |对于内置的简单代理，`/topic`和`/queue`前缀没有任何特殊的<br/>含义。它们仅仅是区分发布订阅和点对点<br/>消息传递（即多个订阅者和一个消费者）的一种约定。当你使用外部代理时，<br/>检查代理的 stomp 页面，以了解它支持什么样的 stomp 目的地和<br/>前缀。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

要从浏览器连接，对于 Sockjs，你可以使用[`sockjs-client`]（https://github.com/sockjs/sockjs-client）。对于 Stomp，许多应用程序使用[jmesnil/stomp-websocket](https://github.com/jmesnil/stomp-websocket)库（也称为 stomp.js），它是功能完备的，已经在生产中使用了多年，但不再维护。目前，[JSteunou/WebStomp-客户端](https://github.com/JSteunou/webstomp-client)是该库最活跃的维护和不断发展的后继库。下面的示例代码是基于它的：

```
var socket = new SockJS("/spring-websocket-portfolio/portfolio");
var stompClient = webstomp.over(socket);

stompClient.connect({}, function(frame) {
}
```

或者，如果你通过 WebSocket（不使用 Sockjs）进行连接，则可以使用以下代码：

```
var socket = new WebSocket("/spring-websocket-portfolio/portfolio");
var stompClient = Stomp.over(socket);

stompClient.connect({}, function(frame) {
}
```

注意，在前面的示例中`stompClient`不需要指定`login`和`passcode`头。即使这样做了，它们也会在服务器端被忽略（或者更确切地说，被覆盖）。有关身份验证的更多信息，请参见[连接到代理](#websocket-stomp-handle-broker-relay-configure)和[认证](#websocket-stomp-authentication)。

有关更多示例代码，请参见：

* [Using WebSocket to build an interactive web application](https://spring.io/guides/gs/messaging-stomp-websocket/)——入门指南。

* [股票投资组合](https://github.com/rstoyanchev/spring-websocket-portfolio)—一个示例应用程序。

#### 4.4.4. WebSocket 服务器

要配置底层 WebSocket 服务器，应用[服务器配置](#websocket-server-runtime-configuration)中的信息。然而，对于 Jetty，你需要通过`StompEndpointRegistry`设置`HandshakeHandler`和`WebSocketPolicy`:

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio").setHandshakeHandler(handshakeHandler());
    }

    @Bean
    public DefaultHandshakeHandler handshakeHandler() {

        WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
        policy.setInputBufferSize(8192);
        policy.setIdleTimeout(600000);

        return new DefaultHandshakeHandler(
                new JettyRequestUpgradeStrategy(new WebSocketServerFactory(policy)));
    }
}
```

#### 4.4.5.消息流

一旦公开了一个 STOMP 端点， Spring 应用程序就成为连接客户端的 STOMP 代理。本节描述服务器端的消息流。

`spring-messaging`模块包含对起源于[Spring Integration](https://spring.io/spring-integration)的消息传递应用程序的基本支持，该支持后来被提取并合并到 Spring 框架中，以便在许多[Spring projects](https://spring.io/projects)和应用程序场景中更广泛地使用。下面的列表简要描述了一些可用的消息传递抽象：

* [Message](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/messaging/Message.html):消息的简单表示，包括消息头和有效负载。

* [MessageHandler](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/messaging/MessageHandler.html):用于处理消息的契约。

* [MessageChannel](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/messaging/MessageChannel.html):用于发送消息的契约，该消息允许在生产者和消费者之间进行松散耦合。

* [下标 bablechannel](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/messaging/SubscribableChannel.html):`MessageChannel`与`MessageHandler`订阅者。

* [执行者下标 bablechannel](https://docs.spring.io/spring-framework/docs/5.3.16/javadoc-api/org/springframework/messaging/support/ExecutorSubscribableChannel.html):`SubscribableChannel`使用`Executor`传递消息。

Java 配置（即`@EnableWebSocketMessageBroker`）和 XML 名称空间配置（即`<websocket:message-broker>`）都使用前面的组件来组装消息工作流。下图显示了启用简单的内置消息代理时使用的组件：

![消息流简单代理](images/message-flow-simple-broker.png)

前面的图表显示了三个消息通道：

* `clientInboundChannel`:用于传递从 WebSocket 客户端接收的消息。

* `clientOutboundChannel`:用于向 WebSocket 客户端发送服务器消息。

* `brokerChannel`:用于从服务器端应用程序代码中向 Message Broker 发送消息。

下一个关系图显示了当外部代理（例如 RabbitMQ）被配置为管理订阅和广播消息时所使用的组件：

![消息流代理中继](images/message-flow-broker-relay.png)

前面两个图之间的主要区别是使用“代理中继”通过 TCP 将消息传递到外部的 Stomp 代理，并将消息从代理传递到订阅的客户机。

当接收到来自 WebSocket 连接的消息时，将它们解码为 Stomp 帧，转换为 Spring `Message`表示，并将其发送到`clientInboundChannel`以进行进一步的处理。例如，目标标头以`/app`开头的 stomp 消息可以路由到带注释的控制器中的`@MessageMapping`方法，而`/topic`和`/queue`消息可以直接路由到消息代理。

处理来自客户端的 stomp 消息的带注释的`@Controller`可以通过`brokerChannel`向消息代理发送消息，并且代理通过`clientOutboundChannel`将消息广播给匹配的订阅者。相同的控制器也可以对 HTTP 请求做出相同的响应，因此客户端可以执行 HTTP POST，然后使用`@PostMapping`方法向消息代理发送消息，以将消息广播到订阅的客户端。

我们可以通过一个简单的例子来追踪这个流程。考虑以下设置服务器的示例：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio");
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.setApplicationDestinationPrefixes("/app");
        registry.enableSimpleBroker("/topic");
    }
}

@Controller
public class GreetingController {

    @MessageMapping("/greeting")
    public String handle(String greeting) {
        return "[" + getTimestamp() + ": " + greeting;
    }
}
```

前面的示例支持以下流程：

1. 客户机连接到`[http://localhost:8080/portfolio](http://localhost:8080/portfolio)`，并且，一旦建立了 WebSocket 连接，Stomp 帧就开始在其上流动。

2. 客户机发送一个订阅帧，其目的标头为`/topic/greeting`。一旦接收并解码，消息将被发送到`clientInboundChannel`，然后路由到消息代理，该代理存储客户端订阅。

3. 客户端将发送帧发送到`/app/greeting`。`/app`前缀有助于将其路由到带注释的控制器。在去掉`/app`前缀之后，剩余的`/greeting`部分目标被映射到`@MessageMapping`中的`@MessageMapping`方法。

4. 从`GreetingController`返回的值被转换为 Spring `Message`，其有效负载基于返回值和默认的目的标头`/topic/greeting`（派生自输入目的标头，由`/app`替换为`/topic`）。生成的消息被发送到`brokerChannel`，并由消息代理处理。

5. 消息代理找到所有匹配的订阅者，并通过`clientOutboundChannel`向每个订阅者发送消息帧，从这里消息被编码为 Stomp 帧并在 WebSocket 连接上发送。

下一节将提供更多有关带注释方法的详细信息，包括所支持的参数和返回值的类型。

#### 4.4.6.带注释的控制器

应用程序可以使用带注释的`@Controller`类来处理来自客户端的消息。这样的类可以声明`@MessageMapping`、`@SubscribeMapping`和`@ExceptionHandler`方法，如以下主题中所述：

* [`@MessageMapping`]（# WebSocket-stomp-message-mapping）

* [`@SubscribeMapping`]（# WebSocket-stomp-subscribe-mapping）

* [`@MessageExceptionHandler`]（# WebSocket-stomp-exception-handler）

##### `@MessageMapping`

你可以使用`@MessageMapping`对基于目的地路由消息的方法进行注释。它在方法级和类型级都受到支持。在类型级别，`@MessageMapping`用于表示控制器中所有方法之间的共享映射。

默认情况下，映射值是 Ant 样式的路径模式（例如`/thing*`，`/thing/**`），包括对模板变量的支持（例如，`/thing/{id}`）。这些值可以通过`@DestinationVariable`方法参数进行引用。应用程序还可以切换到用于映射的以点分隔的目标约定，如[作为分隔器的点](#websocket-stomp-destination-separator)中所解释的那样。

###### 支持的方法参数

下表描述了方法参数：

|                                Method argument                                |说明|
|-------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|                                   `Message`                                   |以获取完整的消息。|
|                               `MessageHeaders`                                |用于访问`Message`中的标题。|
|`MessageHeaderAccessor`, `SimpMessageHeaderAccessor`, and `StompHeaderAccessor`|用于通过类型化访问器方法访问标头。|
|                                  `@Payload`                                   |为了访问消息的有效负载，通过配置的`MessageConverter`进行转换（例如，从 JSON），<br/><br/>不需要存在此注释，因为默认情况下是这样，假设没有<br/>其他参数匹配。<br/><br/>你可以用`@javax.validation.Valid`或 Spring 的`@Validated`、<br/>对有效负载参数进行注释，以使有效负载参数被自动验证。|
|                                   `@Header`                                   |用于访问特定的标头值——如果有必要，还可以使用`org.springframework.core.convert.converter.Converter`进行类型转换。|
|                                  `@Headers`                                   |用于访问消息中的所有头。此参数必须可分配给`java.util.Map`。|
|                            `@DestinationVariable`                             |用于访问从消息目标提取的模板变量。<br/>值根据需要转换为声明的方法参数类型。|
|                           `java.security.Principal`                           |反映在 WebSocket HTTP 握手时登录的用户。|

###### 返回值

默认情况下，来自`@MessageMapping`方法的返回值通过匹配的`MessageConverter`序列化到有效负载，并作为`Message`发送到`brokerChannel`，从那里向订阅者广播。出站消息的目的地与入站消息的目的地相同，但前缀为`/topic`。

你可以使用`@SendTo`和`@SendToUser`注释来定制输出消息的目标。`@SendTo`用于自定义目标目的地或指定多个目的地。`@SendToUser`用于将输出消息引导到仅与输入消息相关联的用户。见[用户目的地](#websocket-stomp-user-destination)。

你可以在同一个方法上同时使用`@SendTo`和`@SendToUser`，并且这两种方法在类级别上都是受支持的，在这种情况下，它们充当类中方法的默认值。但是，请记住，任何方法级别的`@SendTo`或`@SendToUser`注释都会覆盖类级别的任何此类注释。

消息可以异步处理，并且`@MessageMapping`方法可以返回`ListenableFuture`、`CompletableFuture`或`CompletionStage`。

请注意，`@SendTo`和`@SendToUser`仅仅是一种方便，相当于使用`SimpMessagingTemplate`来发送消息。如果有必要，对于更高级的场景，`@MessageMapping`方法可以直接使用`SimpMessagingTemplate`。可以这样做，而不是返回一个值，或者可能是另外返回一个值。见[发送消息](#websocket-stomp-handle-send)。

##### `@SubscribeMapping`

`@SubscribeMapping`类似于`@MessageMapping`，但仅将映射范围缩小到订阅消息。它支持与[方法参数](#websocket-stomp-message-mapping)相同的`@MessageMapping`。但是对于返回值，默认情况下，消息是直接发送到客户机的（通过`clientOutboundChannel`，响应订阅），而不是发送到代理的（通过`brokerChannel`，作为对匹配订阅的广播）。添加`@SendTo`或`@SendToUser`将重写此行为并将其发送给代理。

这个什么时候有用？假设代理被映射到`/topic`和`/queue`，而应用程序控制器被映射到`/app`。在此设置中，代理存储所有用于重复广播的`/topic`和`/queue`的订阅，并且不需要应用程序参与其中。客户机还可以订阅某些`/app`目标，并且控制器可以响应该订阅返回一个值，而不涉及代理，而无需存储或再次使用订阅（实际上是一次性的请求-回复交换）。这样做的一个用例是在启动时用初始数据填充 UI。

这什么时候没用？不要尝试将代理和控制器映射到相同的目标前缀，除非出于某种原因希望两者独立处理消息（包括订阅）。入站消息是并行处理的。不能保证代理或控制器是否首先处理给定的消息。如果目标是在订阅被存储并准备好广播时得到通知，那么如果服务器支持该订阅，客户端应该要求提供收据（Simple Broker 不支持）。例如，使用 Java[STOMP 客户端](#websocket-stomp-client)，你可以执行以下操作来添加收据：

```
@Autowired
private TaskScheduler messageBrokerTaskScheduler;

// During initialization..
stompClient.setTaskScheduler(this.messageBrokerTaskScheduler);

// When subscribing..
StompHeaders headers = new StompHeaders();
headers.setDestination("/topic/...");
headers.setReceipt("r1");
FrameHandler handler = ...;
stompSession.subscribe(headers, handler).addReceiptTask(() -> {
    // Subscription ready...
});
```

在`brokerChannel`上的服务器端选项是[要注册](#websocket-stomp-interceptors)和`ExecutorChannelInterceptor`，并实现`afterMessageHandled`方法，该方法在处理完消息（包括订阅）后调用。

##### `@MessageExceptionHandler`

应用程序可以使用`@MessageExceptionHandler`方法来处理来自`@MessageMapping`方法的异常。如果希望访问异常实例，可以在注释本身中声明异常，也可以通过方法参数声明异常。下面的示例通过方法参数声明异常：

```
@Controller
public class MyController {

    // ...

    @MessageExceptionHandler
    public ApplicationError handleException(MyException exception) {
        // ...
        return appError;
    }
}
```

`@MessageExceptionHandler`方法支持灵活的方法签名，并支持与[`@MessageMapping`]（# WebSocket-stomp-message-mapping）方法相同的方法参数类型和返回值。

通常，`@MessageExceptionHandler`方法应用于声明它们的`@Controller`类（或类层次结构）中。如果你希望这样的方法更多地全局应用（跨控制器），那么可以在标记为`@ControllerAdvice`的类中声明它们。这类似于 Spring MVC 中可用的[类似的支持](#mvc-ann-controller-advice)。

#### 4.4.7.发送消息

如果你想要从应用程序的任何部分向连接的客户端发送消息，该怎么办？任何应用程序组件都可以向`brokerChannel`发送消息。这样做的最简单的方法是注入`SimpMessagingTemplate`并使用它发送消息。通常，你将按类型注入它，如下例所示：

```
@Controller
public class GreetingController {

    private SimpMessagingTemplate template;

    @Autowired
    public GreetingController(SimpMessagingTemplate template) {
        this.template = template;
    }

    @RequestMapping(path="/greetings", method=POST)
    public void greet(String greeting) {
        String text = "[" + getTimestamp() + "]:" + greeting;
        this.template.convertAndSend("/topic/greetings", text);
    }

}
```

但是，如果存在另一个相同类型的 Bean，你也可以通过它的名称（`brokerMessagingTemplate`）来限定它。

#### 4.4.8.简单经纪人

内置的简单消息代理处理来自客户端的订阅请求，将它们存储在内存中，并将消息广播到具有匹配目标的连接客户端。代理支持类似路径的目标，包括对 Ant 风格的目标模式的订阅。

|   |应用程序也可以使用点分隔（而不是斜杠分隔）的目的地。<br/>参见[作为分隔器的点](#websocket-stomp-destination-separator)。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------|

如果配置了任务调度程序，那么简单代理支持[跺脚心跳](https://stomp.github.io/stomp-specification-1.2.html#Heart-beating)。要配置计划程序，你可以声明自己的`TaskScheduler` Bean，并通过`MessageBrokerRegistry`对其进行设置。或者，你可以使用在内置 WebSocket 配置中自动声明的配置，但是，你需要`@Lazy`来避免在内置 WebSocket 配置和`WebSocketMessageBrokerConfigurer`之间的循环。例如：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    private TaskScheduler messageBrokerTaskScheduler;

    @Autowired
    public void setMessageBrokerTaskScheduler(@Lazy TaskScheduler taskScheduler) {
        this.messageBrokerTaskScheduler = taskScheduler;
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/queue/", "/topic/")
                .setHeartbeatValue(new long[] {10000, 20000})
                .setTaskScheduler(this.messageBrokerTaskScheduler);

        // ...
    }
}
```

#### 4.4.9.外部经纪人

Simple Broker 非常适合入门，但只支持一组 STOMP 命令（它不支持 ACK、Receipts 和其他一些特性），依赖于一个简单的消息发送循环，并且不适合集群。作为替代方案，你可以升级应用程序以使用功能齐全的消息代理。

查看选择的消息代理的 STOMP 文档（例如[RabbitMQ](https://www.rabbitmq.com/stomp.html)，[ActiveMQ](https://activemq.apache.org/stomp.html)等），安装代理，并在启用了 STOMP 支持的情况下运行它。然后，你可以在 Spring 配置中启用 Stomp 代理中继（而不是简单的代理）。

下面的示例配置启用了功能齐全的代理：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/portfolio").withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableStompBrokerRelay("/topic", "/queue");
        registry.setApplicationDestinationPrefixes("/app");
    }

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:message-broker application-destination-prefix="/app">
        <websocket:stomp-endpoint path="/portfolio" />
            <websocket:sockjs/>
        </websocket:stomp-endpoint>
        <websocket:stomp-broker-relay prefix="/topic,/queue" />
    </websocket:message-broker>

</beans>
```

在前面的配置中，Stomp 代理中继是一个 Spring[`MessageHandler`]（https://DOCS. Spring.io/ Spring-Framework/DOCS/5.3.16/javadoc-api/org/springframework/messing/messagehandler.html），它通过将消息转发到外部消息代理来处理消息。为此，它建立到代理的 TCP 连接，将所有消息转发给它，然后将从代理收到的所有消息通过其 WebSocket 会话转发给客户机。从本质上讲，它充当了双向转发消息的“中继”。

|   |为 TCP 连接管理将`io.projectreactor.netty:reactor-netty`和`io.netty:netty-all`依赖项添加到项目中。|
|---|-------------------------------------------------------------------------------------------------------------------------------|

此外，应用程序组件（例如 HTTP 请求处理方法、业务服务和其他）也可以向代理中继发送消息，如[发送消息](#websocket-stomp-handle-send)中所述，以将消息广播到已订阅的客户端 WebSocket。

实际上，代理中继支持健壮和可伸缩的消息广播。

#### 4.4.10.连接到代理

Stomp 代理中继维护与代理的单个“系统”TCP 连接。此连接仅用于源自服务器端应用程序的消息，而不用于接收消息。可以为此连接配置 STOMP 凭据（即 STOMP 框架`login`和`passcode`标头）。这在 XML 名称空间和 Java 配置中都公开为`systemLogin`和`systemPasscode`属性，其默认值为`guest`和`guest`。

Stomp 代理中继还为每个连接的 WebSocket 客户端创建一个单独的 TCP 连接。你可以配置用于代表客户机创建的所有 TCP 连接的 STOMP 凭据。这在 XML 名称空间和 Java 配置中都公开为`clientLogin`和`clientPasscode`属性，其默认值为`guest`和`guest`。

|   |Stomp 代理中继总是在它代表客户转发给代理的每个`CONNECT`框架上设置`login`和`passcode`头。因此， WebSocket 客户机<br/>不需要设置那些头。他们被忽视了。正如[认证](#websocket-stomp-authentication)部分所解释的那样， WebSocket 客户端应该依赖 HTTP 身份验证来保护<br/> WebSocket 端点并建立客户端标识。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

Stomp 代理中继还通过“System”TCP 连接向消息代理发送和接收来自消息代理的心跳。你可以配置发送和接收心跳的间隔（默认情况下各为 10 秒）。如果失去了与代理的连接，代理中继将继续尝试每 5 秒重新连接一次，直到成功。

任何 Spring  Bean 都可以实现`ApplicationListener<BrokerAvailabilityEvent>`，以在与代理的“系统”连接丢失并重新建立时接收通知。例如，当没有活动的“系统”连接时，广播股票报价的股票报价服务可以停止尝试发送消息。

默认情况下，STOMP 代理中继总是连接到相同的主机和端口，如果连接丢失，则根据需要重新连接。如果你希望提供多个地址，那么在每次尝试连接时，你可以配置一个地址供应商，而不是一个固定的主机和端口。下面的示例展示了如何做到这一点：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {

    // ...

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableStompBrokerRelay("/queue/", "/topic/").setTcpClient(createTcpClient());
        registry.setApplicationDestinationPrefixes("/app");
    }

    private ReactorNettyTcpClient<byte[]> createTcpClient() {
        return new ReactorNettyTcpClient<>(
                client -> client.addressSupplier(() -> ... ),
                new StompReactorNettyCodec());
    }
}
```

你还可以使用`virtualHost`属性配置 Stomp 代理中继。此属性的值被设置为每个`CONNECT`帧的`host`头，并且可以是有用的（例如，在云环境中，其中建立 TCP 连接的实际主机与提供基于云的 Stomp 服务的主机不同）。

#### 4.4.11.作为分隔器的点

当消息路由到`@MessageMapping`方法时，它们将与`AntPathMatcher`进行匹配。默认情况下，模式应该使用斜杠（`/`）作为分隔符。这是 Web 应用程序中的一种很好的约定，类似于 HTTP URL。但是，如果你更习惯于消息传递约定，则可以切换到使用 dot（`.`）作为分隔符。

下面的示例展示了如何在 Java 配置中实现这一点：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    // ...

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.setPathMatcher(new AntPathMatcher("."));
        registry.enableStompBrokerRelay("/queue", "/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:websocket="http://www.springframework.org/schema/websocket"
        xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                https://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/websocket
                https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:message-broker application-destination-prefix="/app" path-matcher="pathMatcher">
        <websocket:stomp-endpoint path="/stomp"/>
        <websocket:stomp-broker-relay prefix="/topic,/queue" />
    </websocket:message-broker>

    <bean id="pathMatcher" class="org.springframework.util.AntPathMatcher">
        <constructor-arg index="0" value="."/>
    </bean>

</beans>
```

在此之后，控制器可以在`@MessageMapping`方法中使用一个点（`.`）作为分隔符，如下例所示：

```
@Controller
@MessageMapping("red")
public class RedController {

    @MessageMapping("blue.{green}")
    public void handleGreen(@DestinationVariable String green) {
        // ...
    }
}
```

客户机现在可以向`/app/red.blue.green123`发送消息。

在前面的示例中，我们没有更改“代理中继”的前缀，因为这些前缀完全依赖于外部消息代理。请参阅你使用的代理的 STOMP 文档页，以了解它对目标头支持哪些约定。

另一方面，“简单代理”确实依赖于配置的`PathMatcher`，因此，如果你切换分隔符，该更改也适用于代理以及代理从消息到订阅模式的目标匹配方式。

#### 4.4.12.认证

在 WebSocket 消息传递会话中的每一次重击都是从一个 HTTP 请求开始的。这可以是一个升级到 WebSockets 的请求（即 WebSocket 次握手），或者在 Sockjs 回退的情况下，是一系列 Sockjs HTTP 传输请求。

许多 Web 应用程序已经具有适当的身份验证和授权，以保护 HTTP 请求。通常，通过使用诸如登录页面、HTTP 基本身份验证或另一种方式的某种机制，通过 Spring 安全性对用户进行身份验证。经过身份验证的用户的安全上下文保存在 HTTP 会话中，并与同一基于 Cookie 的会话中的后续请求相关联。

因此，对于 WebSocket 握手或对于 Sockjs HTTP 传输请求，通常已经存在通过`HttpServletRequest#getUserPrincipal()`可访问的经过身份验证的用户。 Spring 自动地将该用户与为他们创建的 WebSocket 或 Sockjs 会话相关联，随后，与通过该会话通过用户头传输的所有 Stomp 消息相关联。

简而言之，一个典型的 Web 应用程序只需要做它在安全性方面已经做过的事情。通过基于 Cookie 的 HTTP 会话（该会话随后与为该用户创建的 WebSocket 或 Sockjs 会话相关联）维护安全上下文，在 HTTP 请求级别上对用户进行身份验证，并在流经该应用程序的每个`Message`上标记一个用户标头。

在`CONNECT`框架上，Stomp 协议确实有`login`和`passcode`头。它们最初是为 TCP 上的 Stomp 而设计的，现在也需要这样做。然而，对于 STOMP over WebSocket，默认情况下， Spring 忽略了 STOMP 协议级别上的身份验证头，并假定用户已经在 HTTP 传输级别上进行了身份验证。期望 WebSocket 或 Sockjs 会话包含经过身份验证的用户。

#### 4.4.13.令牌认证

[Spring Security OAuth](https://github.com/spring-projects/spring-security-oauth)提供了对基于令牌的安全性的支持，包括 JSON Web 令牌。你可以将其用作 Web 应用程序中的身份验证机制，包括对 WebSocket 交互的 stomp，如上一节所述（即，通过基于 cookie 的会话来维护身份）。

同时，基于 Cookie 的会话并不总是最合适的（例如，在不维护服务器端会话的应用程序中，或者在通常使用头进行身份验证的移动应用程序中）。

[WebSocket protocol, RFC 6455](https://tools.ietf.org/html/rfc6455#section-10.5)“并没有规定服务器可以在 WebSocket 握手过程中对客户端进行身份验证的任何特定方式。”然而，在实践中，浏览器客户机只能使用标准的身份验证头（即基本的 HTTP 身份验证）或 Cookie，并且不能（例如）提供自定义的头。同样，Sockjs JavaScript 客户机也不提供一种发送带有 Sockjs 传输请求的 HTTP 头的方法。见[Sockjs-客户端第 196 期](https://github.com/sockjs/sockjs-client/issues/196)。相反，它确实允许发送查询参数，你可以使用这些参数来发送令牌，但这有其自身的缺点（例如，令牌可能会无意中与服务器日志中的 URL 一起记录）。

|   |上述限制适用于基于浏览器的客户机，并且不适用于<br/> Spring 基于 Java 的 Stomp 客户机，该客户机确实支持发送带有<br/> WebSocket 和 Sockjs 请求的头。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

因此，希望避免使用 Cookie 的应用程序可能没有任何好的 HTTP 协议级别的身份验证替代方案。与其使用 Cookie，他们可能更喜欢在 Stomp 消息传递协议级别使用头进行身份验证。这样做需要两个简单的步骤：

1. 使用 STOMP 客户机在连接时传递身份验证头。

2. 用`ChannelInterceptor`处理身份验证头。

下一个示例使用服务器端配置来注册自定义身份验证拦截器。请注意，拦截器只需要验证和设置 Connect`Message`上的用户头。 Spring 记录并保存经过身份验证的用户，并将其与相同会话上的后续 Stomp 消息关联。下面的示例展示了如何注册自定义身份验证拦截器：

```
@Configuration
@EnableWebSocketMessageBroker
public class MyConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.interceptors(new ChannelInterceptor() {
            @Override
            public Message<?> preSend(Message<?> message, MessageChannel channel) {
                StompHeaderAccessor accessor =
                        MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
                if (StompCommand.CONNECT.equals(accessor.getCommand())) {
                    Authentication user = ... ; // access authentication header(s)
                    accessor.setUser(user);
                }
                return message;
            }
        });
    }
}
```

另外，请注意，当你对消息使用 Spring Security 的授权时，目前，你需要确保身份验证`ChannelInterceptor`配置是在 Spring Security 的授权之前进行的。最好的方法是在其自己的`WebSocketMessageBrokerConfigurer`实现中声明自定义拦截器，该实现被标记为`@Order(Ordered.HIGHEST_PRECEDENCE + 99)`。

#### 4.4.14.授权

Spring 安全性提供了[WebSocket sub-protocol authorization](https://docs.spring.io/spring-security/reference/servlet/integrations/websocket.html#websocket-authorization)，其使用`ChannelInterceptor`基于其中的用户头来授权消息。另外， Spring 会话提供了[WebSocket integration](https://docs.spring.io/spring-session/reference/web-socket.html)，以确保在 WebSocket 会话仍然处于活动状态时用户的 HTTP 会话不会过期。

#### 4.4.15.用户目的地

应用程序可以发送针对特定用户的消息， Spring 的 STOMP 支持为此目的识别带有`/user/`前缀的目的地。例如，客户端可能订阅`/user/queue/position-updates`目的地。`UserDestinationMessageHandler`处理此目的地并将其转换为用户会话所独有的目的地（例如`/queue/position-updates-user123`）。这提供了订阅一个通用命名的目的地的便利，同时，确保不与订阅相同目的地的其他用户发生冲突，以便每个用户都可以接收唯一的股票位置更新。

|   |在使用用户目标时，配置代理和<br/>应用程序目标前缀是很重要的，如[启用 Stomp](#websocket-stomp-enable)中所示，否则<br/>代理将处理“/user”前缀消息，这些消息只应由`UserDestinationMessageHandler`处理。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

在发送端，消息可以被发送到诸如`/user/{username}/queue/position-updates`的目的地，这反过来又通过`UserDestinationMessageHandler`被翻译成一个或多个目的地，一个针对每个会话与用户相关联。这使得应用程序中的任何组件都可以发送针对特定用户的消息，而不必知道他们的名字和通用目的地以外的任何信息。这也通过注释和消息传递模板得到了支持。

一种消息处理方法可以通过`@SendToUser`注释（也支持在类级上共享一个公共目的地）向与正在处理的消息相关联的用户发送消息，如下例所示：

```
@Controller
public class PortfolioController {

    @MessageMapping("/trade")
    @SendToUser("/queue/position-updates")
    public TradeResult executeTrade(Trade trade, Principal principal) {
        // ...
        return tradeResult;
    }
}
```

如果用户有一个以上的会话，默认情况下，目标用户是订阅给定目标的所有会话。然而，有时可能需要只针对发送要处理的消息的会话。可以通过将`broadcast`属性设置为 false 来实现此目的，如下例所示：

```
@Controller
public class MyController {

    @MessageMapping("/action")
    public void handleAction() throws Exception{
        // raise MyBusinessException here
    }

    @MessageExceptionHandler
    @SendToUser(destinations="/queue/errors", broadcast=false)
    public ApplicationError handleException(MyBusinessException exception) {
        // ...
        return appError;
    }
}
```

|   |虽然用户目的地通常意味着经过身份验证的用户，但并不是严格要求的。<br/>与经过身份验证的用户不关联的 WebSocket 会话<br/>可以订阅用户目的地。在这种情况下，`@SendToUser`注释<br/>的行为与`broadcast=false`完全相同（即仅针对发送正在处理的消息的<br/>会话）。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

你可以通过注入由 Java 配置或 XML 命名空间创建的`SimpMessagingTemplate`，从任何应用程序组件向用户目的地发送消息。（如果使用`@Qualifier`进行限定，则 Bean 名称为`brokerMessagingTemplate`。）下面的示例展示了如何这样做：

```
@Service
public class TradeServiceImpl implements TradeService {

    private final SimpMessagingTemplate messagingTemplate;

    @Autowired
    public TradeServiceImpl(SimpMessagingTemplate messagingTemplate) {
        this.messagingTemplate = messagingTemplate;
    }

    // ...

    public void afterTradeExecuted(Trade trade) {
        this.messagingTemplate.convertAndSendToUser(
                trade.getUserName(), "/queue/position-updates", trade.getResult());
    }
}
```

|   |当你使用带有外部消息代理的用户目的地时，你应该检查代理<br/>关于如何管理非活动队列的文档，这样，当用户会话<br/>结束时，所有唯一的用户队列都将被删除。例如，当你使用诸如`/exchange/amq.direct/position-updates`之类的目标时，RabbitMQ 会创建自动删除<br/>队列。<br/>因此，在这种情况下，客户端可以订阅`/user/exchange/amq.direct/position-updates`。<br/>类似地，ActiveMQ 也有[配置选项](https://activemq.apache.org/delete-inactive-destinations.html)用于清除不活动的目标。|
|---| |

在多应用服务器场景中，由于用户连接到不同的服务器，用户目的地可能仍未解决。在这种情况下，你可以配置一个目标来广播未解决的消息，以便其他服务器有机会尝试。这可以通过 Java 配置中`MessageBrokerRegistry`的`userDestinationBroadcast`属性和 XML 中`message-broker`元素的`user-destination-broadcast`属性来完成。

#### 4.4.16.消息顺序

来自代理的消息被发布到`clientOutboundChannel`，从那里它们被写到 WebSocket 会话。由于通道由`ThreadPoolExecutor`支持，消息在不同的线程中进行处理，客户端接收的结果序列可能与发布的确切顺序不匹配。

如果这是一个问题，请启用`setPreservePublishOrder`标志，如下例所示：

```
@Configuration
@EnableWebSocketMessageBroker
public class MyConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    protected void configureMessageBroker(MessageBrokerRegistry registry) {
        // ...
        registry.setPreservePublishOrder(true);
    }

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:message-broker preserve-publish-order="true">
        <!-- ... -->
    </websocket:message-broker>

</beans>
```

设置该标志后，同一客户机会话中的消息将一次发布到`clientOutboundChannel`，以保证发布的顺序。请注意，这会带来很小的性能开销，因此你应该仅在需要时才启用它。

#### 4.4.17.事件

发布了几个`ApplicationContext`事件，并且可以通过实现 Spring 的`ApplicationListener`接口来接收这些事件：

* `BrokerAvailabilityEvent`:表示代理何时变得可用或不可用。虽然“简单”代理在启动时立即可用，并且在应用程序运行时仍然可用，但 STOMP“代理中继”可能会失去与功能齐全的代理的连接（例如，如果代理被重新启动）。代理中继具有重新连接逻辑，并在代理恢复时重新建立与代理的“系统”连接。因此，每当状态从连接变为断开时，此事件就会发布，反之亦然。使用`SimpMessagingTemplate`的组件应该订阅此事件，并避免在代理不可用时发送消息。在任何情况下，他们都应该准备好在发送消息时处理`MessageDeliveryException`。

* `SessionConnectEvent`:当接收到新的 Stomp 连接时发布，以表示新客户端会话的开始。该事件包含表示连接的消息，包括会话 ID、用户信息（如果有的话）以及客户端发送的任何自定义标头。这对于跟踪客户端会话非常有用。订阅此事件的组件可以用`SimpMessageHeaderAccessor`或`StompMessageHeaderAccessor`包装所包含的消息。

* `SessionConnectedEvent`:在`SessionConnectEvent`之后不久发布，此时代理已经发送了一个 Stomp Connected 帧来响应该连接。在这一点上，Stomp 会话可以被认为是完全成立的。

* `SessionSubscribeEvent`:在接收到新的 Stomp 订阅时发布。

* `SessionUnsubscribeEvent`:当收到新的 stomp 退订时发布。

* `SessionDisconnectEvent`:在 stomp 会话结束时发布。断开连接可以是已经从客户端发送的，也可以是在 WebSocket 会话关闭时自动生成的。在某些情况下，此事件在每个会话中发布不止一次。对于多个断开事件，组件应该是幂等的。

|   |当你使用功能齐全的代理时，如果代理暂时不可用，则 STOMP“代理中继”会自动重新连接<br/>“系统”连接。但是，<br/>客户端连接不会自动重新连接。假设启用了心跳，客户机<br/>通常会注意到代理在 10 秒内没有响应。客户端需要<br/>实现自己的重新连接逻辑。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### 4.4.18.拦截

[Events](#websocket-stomp-appplication-context-events)为 stomp 连接的生命周期提供通知，但不是为每个客户机消息提供通知。应用程序还可以注册一个`ChannelInterceptor`来拦截任何消息和处理链的任何部分。下面的示例展示了如何截获来自客户端的入站消息：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.interceptors(new MyChannelInterceptor());
    }
}
```

自定义`ChannelInterceptor`可以使用`StompHeaderAccessor`或`SimpMessageHeaderAccessor`来访问有关消息的信息，如下例所示：

```
public class MyChannelInterceptor implements ChannelInterceptor {

    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
        StompCommand command = accessor.getStompCommand();
        // ...
        return message;
    }
}
```

应用程序还可以实现`ExecutorChannelInterceptor`，这是`ChannelInterceptor`的子接口，在处理消息的线程中具有回调。对于发送到通道的每条消息，都会调用一次`ChannelInterceptor`，而`ExecutorChannelInterceptor`在每个订阅了来自通道的消息的`MessageHandler`的线程中提供钩子。

注意，与前面描述的`SessionDisconnectEvent`一样，断开连接消息可以是来自客户端的，或者也可以是在 WebSocket 会话关闭时自动生成的。在某些情况下，拦截器可能会在每个会话中多次拦截此消息。对于多个断开事件，组件应该是幂等的。

#### 4.4.19.STOMP 客户端

Spring 提供了在 WebSocket 客户端上的 stomp 和在 TCP 客户端上的 stomp。

首先，你可以创建和配置`WebSocketStompClient`，如下例所示：

```
WebSocketClient webSocketClient = new StandardWebSocketClient();
WebSocketStompClient stompClient = new WebSocketStompClient(webSocketClient);
stompClient.setMessageConverter(new StringMessageConverter());
stompClient.setTaskScheduler(taskScheduler); // for heartbeats
```

在前面的示例中，你可以将`StandardWebSocketClient`替换为`SockJsClient`，因为这也是`WebSocketClient`的实现。`SockJsClient`可以使用 WebSocket 或基于 HTTP 的传输作为后备。有关更多详细信息，请参见[`SockJsClient`]（# WebSocket-fallback-sockjs-client）。

接下来，你可以建立一个连接，并为 STOMP 会话提供一个处理程序，如下例所示：

```
String url = "ws://127.0.0.1:8080/endpoint";
StompSessionHandler sessionHandler = new MyStompSessionHandler();
stompClient.connect(url, sessionHandler);
```

当会话准备好使用时，将通知处理程序，如下例所示：

```
public class MyStompSessionHandler extends StompSessionHandlerAdapter {

    @Override
    public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
        // ...
    }
}
```

一旦建立了会话，就可以发送任何有效负载，并使用配置的`MessageConverter`进行序列化，如下例所示：

```
session.send("/topic/something", "payload");
```

你也可以订阅目的地。`subscribe`方法需要一个订阅消息的处理程序，并返回一个`Subscription`句柄，你可以使用它来取消订阅。对于每个接收到的消息，处理程序可以指定目标`Object`类型，有效负载应该反序列化到该类型，如下例所示：

```
session.subscribe("/topic/something", new StompFrameHandler() {

    @Override
    public Type getPayloadType(StompHeaders headers) {
        return String.class;
    }

    @Override
    public void handleFrame(StompHeaders headers, Object payload) {
        // ...
    }

});
```

要启用 Stomp heartbeat，可以使用`WebSocketStompClient`配置`TaskScheduler`并可选地自定义心跳间隔（10 秒用于写不活动，导致发送心跳；10 秒用于读不活动，关闭连接）。

`WebSocketStompClient`仅在不活动的情况下发送心跳，即没有发送其他消息时。当使用外部代理时，这可能会带来挑战，因为具有非代理目的地的消息表示活动，但 AREN 并未实际转发给代理。在这种情况下，你可以在初始化`TaskScheduler`时配置`TaskScheduler`，从而确保仅在发送具有非代理目的地的消息时也将心跳转发到代理。

|   |当你使用`WebSocketStompClient`进行性能测试以模拟来自同一台机器的数千个<br/>客户端时，请考虑关闭心跳，因为每个<br/>连接都调度自己的心跳任务，而这并未针对<br/>在同一台机器上运行的大量客户端进行优化。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

STOMP 协议还支持 Receipts，其中客户端必须添加`receipt`头，服务器在处理发送或订阅后用接收帧对其进行响应。为了支持这一点，`StompSession`提供了`setAutoReceipt(boolean)`，这会导致在随后的每个发送或订阅事件上添加`receipt`头。或者，你也可以手动将收据标题添加到`StompHeaders`中。send 和 subscribe 都返回`Receiptable`的实例，你可以使用该实例来注册接收成功和失败的回调。对于此功能，你必须为客户机配置`TaskScheduler`和收据过期前的时间（默认情况下为 15 秒）。

请注意，`StompSessionHandler`本身是`StompFrameHandler`，这使得它除了用于处理消息异常的`handleException`回调和用于处理包括`ConnectionLostException`在内的传输级别错误的`handleTransportError`回调外，还可以处理错误帧。

#### 4.4.20. WebSocket 范围

WebSocket 每个会话都有一个属性映射。映射作为头附加到入站客户端消息，并且可以从控制器方法访问，如以下示例所示：

```
@Controller
public class MyController {

    @MessageMapping("/action")
    public void handle(SimpMessageHeaderAccessor headerAccessor) {
        Map<String, Object> attrs = headerAccessor.getSessionAttributes();
        // ...
    }
}
```

你可以在`websocket`范围中声明一个 Spring 管理的 Bean。你可以将 WebSocket 范围的 bean 注入控制器和在`clientInboundChannel`上注册的任何通道拦截器。这些通常是单例，并且比任何单独的会话活得更长 WebSocket。因此，你需要对 WebSocket 范围的 bean 使用范围代理模式，如下例所示：

```
@Component
@Scope(scopeName = "websocket", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MyBean {

    @PostConstruct
    public void init() {
        // Invoked after dependencies injected
    }

    // ...

    @PreDestroy
    public void destroy() {
        // Invoked when the WebSocket session ends
    }
}

@Controller
public class MyController {

    private final MyBean myBean;

    @Autowired
    public MyController(MyBean myBean) {
        this.myBean = myBean;
    }

    @MessageMapping("/action")
    public void handle() {
        // this.myBean from the current WebSocket session
    }
}
```

与任何自定义作用域一样， Spring 在第一次从控制器访问新的`MyBean`实例时初始化该实例，并将该实例存储在 WebSocket 会话属性中。随后将返回相同的实例，直到会话结束。 WebSocket-作用域 bean 具有调用的所有 Spring 生命周期方法，如前面的示例中所示。

#### 4.4.21.表现

谈到业绩，没有灵丹妙药。许多因素都会影响它，包括消息的大小和数量，应用程序方法是否执行需要阻塞的工作，以及外部因素（例如网络速度和其他问题）。本节的目标是提供可用配置选项的概述，以及关于如何推理缩放的一些想法。

在消息传递应用程序中，消息通过通道传递，以进行由线程池支持的异步执行。配置这样的应用程序需要对通道和消息流有很好的了解。因此，建议复习[消息流](#websocket-stomp-message-flow)。

显而易见的开始是配置线程池，这些线程池支持`clientInboundChannel`和`clientOutboundChannel`。默认情况下，这两个处理器的配置都是可用处理器数量的两倍。

如果在带注释的方法中处理消息主要是 CPU 绑定的，那么`clientInboundChannel`的线程数量应该与处理器数量保持接近。如果他们所做的工作更受 IO 约束，并且需要阻塞或等待数据库或其他外部系统，则线程池的大小可能需要增加。

|   |`ThreadPoolExecutor`有三个重要的属性：核心线程池大小，<br/>最大线程池大小，以及队列存储<br/>没有可用线程的任务的能力。<br/>一个常见的混淆之处是，配置核心池大小（例如，10）<br/>和最大线程池大小（例如，20）会导致线程池中包含 10 到 20 个线程，实际上，如果将容量保持在其默认值 integer.max\_value，<br/>，则线程池永远不会超过核心池大小而增加，由于<br/>所有额外的任务都是排队的。<br/><br/>参见`ThreadPoolExecutor`的 Javadoc 来了解这些属性是如何工作的，以及<br/>了解各种排队策略。|
|---| |

在`clientOutboundChannel`方面，这完全是关于向 WebSocket 客户端发送消息。如果客户机在快速网络上，线程的数量应该与可用处理器的数量保持接近。如果它们速度较慢或带宽较低，则会花费更长的时间来消耗消息，并给线程池带来负担。因此，增加线程池的大小是必要的。

虽然`clientInboundChannel`的工作负载是可以预测的——毕竟，它是基于应用程序所做的工作——但如何配置“ClientoutboundChannel”比较困难，因为它基于应用程序无法控制的因素。因此，还有两个属性与消息的发送有关：`sendTimeLimit`和`sendBufferSizeLimit`。你可以使用这些方法来配置允许发送多长时间，以及在向客户机发送消息时可以缓冲多少数据。

一般的想法是，在任何给定的时间，只能使用单个线程发送到客户端。同时，所有附加的消息都会得到缓冲，你可以使用这些属性来决定允许发送消息需要多长时间，以及在此期间可以缓冲多少数据。有关重要的附加详细信息，请参见 XMLSchema 的 Javadoc 和文档。

下面的示例展示了一种可能的配置：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
        registration.setSendTimeLimit(15 * 1000).setSendBufferSizeLimit(512 * 1024);
    }

    // ...

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:message-broker>
        <websocket:transport send-timeout="15000" send-buffer-size="524288" />
        <!-- ... -->
    </websocket:message-broker>

</beans>
```

还可以使用前面显示的 WebSocket 传输配置来配置传入的 STOMP 消息的最大允许大小。从理论上讲， WebSocket 条消息的大小几乎可以是无限的。在实践中， WebSocket 服务器施加了限制——例如，在 Tomcat 上施加 8K，在 Jetty 上施加 64K。出于这个原因，STOMP 客户机（例如 JavaScript[WebStomp-客户端](https://github.com/JSteunou/webstomp-client)和其他）在 16K 边界分割较大的 STOMP 消息，并将它们作为多个消息发送 WebSocket，这需要服务器进行缓冲和重新组装。

Spring 的 Stomp-over- WebSocket 支持做到了这一点，因此应用程序可以为 Stomp 消息配置最大大小，而与 WebSocket 服务器特定的消息大小无关。请记住， WebSocket 消息大小是自动调整的，如果需要的话，以确保它们能够至少携带 16k WebSocket 消息。

下面的示例展示了一种可能的配置：

```
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureWebSocketTransport(WebSocketTransportRegistration registration) {
        registration.setMessageSizeLimit(128 * 1024);
    }

    // ...

}
```

下面的示例展示了与前面示例类似的 XML 配置：

```
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        https://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:message-broker>
        <websocket:transport message-size="131072" />
        <!-- ... -->
    </websocket:message-broker>

</beans>
```

关于扩展的一个要点是使用多个应用程序实例。目前，你无法使用简单的代理来实现这一点。然而，当使用全功能代理（例如 RabbitMQ）时，每个应用程序实例都连接到代理，并且从一个应用程序实例广播的消息可以通过代理广播到通过任何其他应用程序实例连接的 WebSocket 客户端。

#### 4.4.22.监测

当使用`@EnableWebSocketMessageBroker`或`<websocket:message-broker>`时，关键基础设施组件会自动收集统计信息和计数器，它们为应用程序的内部状态提供了重要的见解。该配置还声明了类型`WebSocketMessageBrokerStats`的 Bean，该类型在一个位置收集所有可用的信息，并且默认情况下每 30 分钟将其记录在`INFO`级别。这个 Bean 可以通过 Spring 的`MBeanExporter`导出到 JMX，以便在运行时查看（例如，通过 JDK 的`jconsole`）。以下清单概述了可用的信息：

客户端 WebSocket 会话

当前

指示当前有多少个客户端会话，计数进一步细分为 WebSocket 与 HTTP 流和 Polling Sockjs 会话的比较。

合计

指示总共建立了多少个会话。

异常关闭

连接失败

建立了会话，但在 60 秒内没有收到任何消息后关闭。这通常表示代理或网络问题。

超过发送限制

会话在超过配置的发送超时或发送缓冲区限制后关闭，这可能发生在客户端速度较慢的情况下（请参见上一节）。

传输错误

会话在传输错误之后关闭，例如未能读或写到 WebSocket 连接或 HTTP 请求或响应。

Stomp 框架

处理的连接帧、连接帧和断开帧的总数，表示在 STOMP 级别上连接了多少个客户端。请注意，当会话异常关闭或当客户端关闭而不发送断开连接帧时，断开连接计数可能会更低。

Stomp 经纪商接力

TCP 连接

指示代表客户端 WebSocket 会话向代理建立了多少 TCP 连接。这应该等于客户端 WebSocket 会话的数量 + 用于从应用程序内发送消息的 1 个额外的共享“系统”连接。

Stomp 框架

代表客户端转发给代理或从代理接收的连接、已连接和断开连接帧的总数。请注意，无论客户端 WebSocket 会话是如何关闭的，断开连接帧都会被发送到代理。因此，较低的断开帧计数表示代理正在主动关闭连接（可能是由于心跳没有及时到达，输入帧无效或其他问题）。

客户端入站通道

来自线程池的统计数据支持`clientInboundChannel`，这些统计数据提供了对传入消息处理的健康状况的深入了解。在此排队的任务表明应用程序可能太慢而无法处理消息。如果存在 I/O 绑定任务（例如，缓慢的数据库查询、对第三方 REST API 的 HTTP 请求等），请考虑增加线程池大小。

客户端出站通道

来自线程池的统计数据支持`clientOutboundChannel`，该线程池提供了对向客户广播消息的健康状况的深入了解。在这里排队等待的任务表明客户端太慢，无法使用消息。解决这个问题的一种方法是增加线程池大小，以适应预期的并发慢客户端数量。另一种选择是减少发送超时和发送缓冲区大小限制（请参见上一节）。

Sockjs 任务调度程序

来自用于发送心跳的 SockJS 任务计划程序的线程池的统计信息。请注意，当心跳在 Stomp 级别协商时，Sockjs 心跳将被禁用。

#### 4.4.23.测试

在使用 Spring 的 Stomp-over- WebSocket 支持时，有两种主要的方法来测试应用程序。第一种方法是编写服务器端测试，以验证控制器的功能及其带注释的消息处理方法。第二种方法是编写完整的端到端测试，其中涉及运行客户机和服务器。

这两种方法并不相互排斥。相反，它们在总体测试策略中都有一席之地。服务器端测试更加集中，并且更容易编写和维护。另一方面，端到端集成测试更完整，测试更多，但它们也更多地参与编写和维护。

服务器端测试的最简单形式是编写控制器单元测试。然而，这是不够有用的，因为控制器所做的很大程度上取决于它的注释。纯粹的单元测试根本无法测试这一点。

理想情况下，被测控制器应该像在运行时那样被调用，这很像通过使用 Spring MVC 测试框架来测试处理 HTTP 请求的控制器的方法——也就是说，不运行 Servlet 容器，而是依赖 Spring 框架来调用带注释的控制器。与 Spring MVC 测试一样，这里有两种可能的选择，要么使用“基于上下文”的设置，要么使用“独立”的设置：

* 借助 Spring TestContext 框架加载实际的 Spring 配置，注入`clientInboundChannel`作为测试字段，并使用它发送要由控制器方法处理的消息。

* 手动设置调用控制器（即`SimpAnnotationMethodMessageHandler`）所需的最低 Spring 框架基础设施，并将控制器的消息直接传递给它。

这两种设置场景都在[股票投资组合的测试](https://github.com/rstoyanchev/spring-websocket-portfolio/tree/master/src/test/java/org/springframework/samples/portfolio/web)示例应用程序中进行了演示。

第二种方法是创建端到端集成测试。为此，你需要以嵌入式模式运行一个 WebSocket 服务器，并将其作为一个 WebSocket 客户端连接到它，该客户端发送 WebSocket 包含 Stomp 帧的消息。[股票投资组合的测试](https://github.com/rstoyanchev/spring-websocket-portfolio/tree/master/src/test/java/org/springframework/samples/portfolio/web)示例应用程序还通过使用 Tomcat 作为嵌入式 WebSocket 服务器和用于测试目的的简单的 Stomp 客户端来演示这种方法。

## 5. 其他 Web 框架

本章详细介绍了 Spring 与第三方 Web 框架的集成。

Spring 框架的核心价值主张之一是使 * 选择 * 成为可能。在一般意义上， Spring 并不强迫你使用或购买任何特定的架构、技术或方法（尽管它肯定会推荐一些而不是其他）。这种选择与开发人员及其开发团队最相关的架构、技术或方法的自由，可以说在 Web 领域最为明显， Spring 在该领域提供了自己的 Web 框架（[Spring MVC](#mvc)和[Spring WebFlux](webflux.html#webflux)），同时，支持与许多流行的第三方 Web 框架的集成。

### 5.1.公共配置

在深入了解每个受支持的 Web 框架的集成细节之前，让我们先来看看不特定于任何一个 Web 框架的常见配置 Spring。（本节同样适用于 Spring 自己的 Web 框架变体。）

Spring 的轻量级应用程序模型支持的概念之一（因为没有更好的词）是分层架构。请记住，在一个“经典”的分层架构中，Web 层只是许多层中的一个。它充当服务器端应用程序的入口点之一，并将其委托给在服务层中定义的服务对象（Facades），以满足特定于业务（和表示技术无关）的用例。在 Spring 中，这些服务对象、任何其他特定于业务的对象、数据访问对象和其他对象存在于不同的“业务上下文”中，其中不包含 Web 或表示层对象（表示对象，例如 Spring MVC 控制器，通常配置在不同的“表示上下文”中）。本节详细介绍了如何配置包含应用程序中所有“business bean”的 Spring 容器（a`WebApplicationContext`）。

接下来讨论细节，你所需要做的就是在标准的 Java EE Servlet `web.xml`文件中声明一个[`ContextLoaderListener`（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/context/contextloaderlistener.html），并添加一个`contextConfigLocation`节（在同一文件中），该节定义要加载的哪组 XML 配置文件 Spring。

考虑以下`<listener/>`配置：

```
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
```

进一步考虑以下`<context-param/>`配置：

```
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext*.xml</param-value>
</context-param>
```

如果没有指定`contextConfigLocation`上下文参数，则`ContextLoaderListener`查找要加载的名为`/WEB-INF/applicationContext.xml`的文件。一旦加载了上下文文件， Spring 将基于 Bean 定义创建一个[`WebApplicationContext`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/context/webapplicationcontext.html）对象，并将其存储在 Web 应用程序的`ServletContext`中。

所有 Java Web 框架都建立在 Servlet API 之上，因此你可以使用以下代码片段来访问由`ApplicationContext`创建的“业务上下文”`ContextLoaderListener`。

下面的示例展示了如何获得`WebApplicationContext`:

```
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);
```

[`WebApplicationContextUtils`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/context/support/webapplicationcontextutils.html）类是为了方便，所以你不需要记住`ServletContext`属性的名称。如果在`WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE`键下不存在对象，则其`getWebApplicationContext()`方法返回`null`。与其冒险在应用程序中获得`NullPointerExceptions`，不如使用`getRequiredWebApplicationContext()`方法。当`ApplicationContext`丢失时，此方法抛出一个异常。

一旦有了对`WebApplicationContext`的引用，就可以根据 bean 的名称或类型检索 bean。大多数开发人员按名称检索 bean，然后将它们强制转换到其实现的接口之一。

幸运的是，本节中的大多数框架都有更简单的查找 bean 的方法。它们不仅使从 Spring 容器获得 bean 变得容易，而且还允许你在它们的控制器上使用依赖注入。每个 Web Framework 部分都有关于其特定集成策略的更多详细信息。

### 5.2.JSF

JavaServer Faces 是 JCP 的标准的基于组件的、事件驱动的 Web 用户界面框架。它是 Java EE 保护伞的正式部分，但也可以单独使用，例如通过在 Tomcat 中嵌入 Mojarra 或 MyFaces。

请注意，最近的 JSF 版本与应用程序服务器中的 CDI 基础架构紧密相关，一些新的 JSF 功能仅在这样的环境中工作。 Spring 的 JSF 支持不再是积极发展的，主要是为了在更新基于 JSF 的旧应用程序时的迁移目的而存在。

Spring 的 JSF 集成中的关键元素是 JSF`ELResolver`机制。

#### 5.2.1. Spring  Bean 解析器

`SpringBeanFacesELResolver`是一个兼容 JSF 的`ELResolver`实现，与 JSF 和 JSP 使用的标准统一 EL 集成。它首先委托给 Spring 的“业务上下文”`WebApplicationContext`，然后委托给底层 JSF 实现的默认解析器。

在配置方面，你可以在 JSF`faces-context.xml`文件中定义`SpringBeanFacesELResolver`，如下例所示：

```
<faces-config>
    <application>
        <el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</el-resolver>
        ...
    </application>
</faces-config>
```

#### 5.2.2.使用`FacesContextUtils`

当将属性映射到`faces-config.xml`中的 bean 时，自定义`ELResolver`很好地工作，但是，有时你可能需要显式地获取 Bean。[`FacesContextUtils`]（https://DOCS. Spring.io/ Spring-framework/DOCS/5.3.16/javadoc-api/org/springframework/web/jsf/facescontextutils.html）类使这一点变得很简单。它类似于`WebApplicationContextUtils`，只是它需要一个`FacesContext`参数，而不是`ServletContext`参数。

下面的示例展示了如何使用`FacesContextUtils`:

```
ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());
```

### 5.3.Apache Struts2.x

由 Craig McClanahan 发明的[Struts](https://struts.apache.org)是一个由 Apache 软件基金会主持的开源项目。当时，它极大地简化了 JSP/ Servlet 编程范式，并赢得了许多使用专有框架的开发人员的支持。它简化了编程模型，它是开源的（因此像 Beer 一样是免费的），并且它拥有一个庞大的社区，这让该项目得以发展并在 Java Web 开发人员中流行起来。

作为原始 Struts1.x 的后续版本，请查看 Struts2.x 和 Struts-提供的[Spring Plugin](https://struts.apache.org/release/2.3.x/docs/spring-plugin.html)用于内置 Spring 集成。

### 5.4.Apache Tapestry5.x

[Tapestry](https://tapestry.apache.org/)是一个“面向组件的框架，用于在 Java 中创建动态的、健壮的、高度可扩展的 Web 应用程序。”

Spring 虽然具有自己的[强大的 Web 层](#mvc)，但是通过使用用于 Web 用户界面的 Tapestry 和用于较低层的 Spring 容器的组合来构建 Enterprise 的 Java 应用程序有许多独特的优点。

有关更多信息，请参见 Tapestry 的专用[integration module for Spring](https://tapestry.apache.org/integrating-with-spring-framework.html)。

### 5.5.更多资源

下面的链接指向关于本章中描述的各种 Web 框架的更多参考资料。

* [JSF](https://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html)主页

* [Struts](https://struts.apache.org/)主页

* [Tapestry](https://tapestry.apache.org/)主页

