学习目标

• 了解Spring MVC核心类的作用
• 掌握@Controller注解的使用
• 掌握@RequestMapping注解的使用
• 掌握请求的映射方式

自JDK5推出以来，注解已成为Java知识体系不可缺少的一部分。Spring MVC在Spring 2.5之后也新增了基于注解的Controller形式。基于注解的Controller简化了XML文件配置，极大地提高了开发效率。

11.1 DispatcherServlet

DispatcherServlet是Spring MVC的核心类，其全限定名是org.springframework.web.servlet.DispatcherServlet。

DispatcherServlet是Spring MVC的流程控制中心，也称为Spring MVC的前端控制器，它可以拦截客户端的请求。拦截客户端请求之后，DispatcherServlet会根据具体规则将请求交给其他组件处理。所有请求都要经过DispatcherServlet进行转发处理，这样就降低了Spring MVC组件之间的耦合性。

DispatcherServlet本质上是一个Servlet，可以在web.xml文件中完成DispatcherServlet的配置和映射。下面新建一个项目，在项目的web.xml文件中演示DispatcherServlet的配置和映射。

参考第10章Spring MVC入门程序，在IDEA中创建一个名称为ch11的Maven Web项目。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>heima_ssm_book</artifactId>
        <groupId>io.weew12.github</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ch11</artifactId>
    <packaging>war</packaging>

    <name>ch11</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>5.3.31</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.opoo.maven</groupId>
                <artifactId>tomcat9-maven-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <port>8080</port>
                    <path>/ch11</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

maven 项目 tomcat 插件配置：

项目创建完成之后，在项目web.xml文件中配置DispatcherServlet：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!-- 配置 Spring MVC 的前端控制器 -->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置初始化参数，用于读取 Spring MVC 的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <!-- 应用加载时创建 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

在文件中，<init-param>元素用于指定DispatcherServlet初始化参数，参数名为contextConfigLocation，参数值为指定路径下的文件spring-mvc.xml。DispatcherServlet初始化时会读取spring-mvc.xml文件中的配置信息完成初始化。

如果web.xml没有通过<init-param>元素指定DispatcherServlet初始化时要加载的文件，则应用程序会去WEB-INF文件夹下寻找并加载默认配置文件。默认配置文件的名称规则如下：

[servlet-name]-servlet.xml

在上述名称规则中，[servlet-name]是指web.xml文件中<servlet-name>元素的值；servlet.xml是配置文件名的固定后缀。因此，如果文件中没有指定要加载的配置文件，应用程序会在WEB-INF文件夹下寻找并加载名称为DispatcherServlet-servlet.xml的配置文件。

在文件中，<load-on-startup>元素用于指定DispatcherServlet是否在启动时加载。

如果<load-on-startup>元素的值为正整数或者0，表示在项目启动时就加载并初始化这个Servlet，值越小，Servlet的优先级越高，就越先被加载；如果<load-on-startup>元素的值为负数或者没有设置，则Servlet会在被请求时加载并初始化。

11.2 @Controller注解

在Spring MVC的执行流程中，DispatcherServlet把用户请求转发给处理器类中的Handler（处理器），Handler对用户的请求进行处理。在Spring MVC框架中，传统的处理器类需要直接或间接地实现Controller接口，这种方式需要在Spring MVC配置文件中定义请求和Controller的映射关系。当后台需要处理的请求较多时，使用传统的处理器类会比较繁琐且灵活性低。为此，Spring MVC框架提供了@Controller注解。使用@Controller注解时，只需要将@Controller注解标注在普通Java类上，然后通过Spring的扫描机制找到标注了该注解的Java类，该Java类就成为了Spring MVC的处理器类。

基于@Controller注解的处理器类示例代码如下：

import org.springframework.stereotype.Controller;

@Controller
public class FirstController {
    // 标注@Controller注解
}

为了保证Spring MVC能够找到处理器类，需要在Spring MVC的配置文件中添加相应的扫描配置信息。

首先在配置文件的声明中引入spring-context声明，用于支持配置文件中所使用的<context:component-scan>元素；然后使用<context:component-scan>元素指定被Spring扫描的类包。Spring MVC配置文件的类包扫描配置信息如文件所示：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置 Spring MVC 要扫描的包 -->
    <context:component-scan base-package="io.weew12.github.controller"/>
</beans>

<context:component-scan>元素的base-package属性指定了需要扫描的类包为io.weew12.github.controller。文件被加载时，Spring会自动扫描io.weew12.github.controller类包及其子包下的Java类。如果被扫描的Java类中带有@Controller、@Service等注解，则把这些类注册为Bean并存放在Spring中。

与传统的处理器类实现方式相比，使用@Controller注解的方式更加简单灵活。因此，在实际开发中通常使用@Controller注解来定义处理器类。

11.3 @RequestMapping注解

使用@Controller注解可以将普通的类声明成Spring MVC的处理器类，但是只使用@Controller注解的话，Spring MVC框架并不能确定当前Web请求由哪个Handler进行处理。为此，Spring MVC框架还提供了@RequestMapping注解。@RequestMapping注解可以为Handler提供必要的映射信息，将请求的URL映射到具体的处理方法。

11.3.1 @RequestMapping注解的使用

@RequestMapping注解用于建立请求URL和Handler之间的映射关系，该注解可以标注在方法上和类上。

标注在方法上

当@RequestMapping注解标注在方法上时，该方法就成了一个可以处理客户端请求的Handler（处理器），它会在Spring MVC接收到对应的URL请求时被执行。Handler在浏览器中对应的访问地址由：项目访问路径+处理方法的映射路径共同组成。

下面通过一个案例演示@RequestMapping注解标注在方法上的使用。

在ch11项目的src/main/java目录下创建类包controller，并在类包下创建FirstController类。FirstController类中创建sayHello()方法，用于处理客户端请求：

package io.weew12.github.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class FirstController {
    /**
     * 注解加载方法上
     */
    @RequestMapping(value = "/firstController")
    public void sayHello() {
        System.out.println("hello Spring MVC");
    }
}

spring-mvc.xml 配置：

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:mvc="http://www.springframework.org/schema/mvc"
  xsi:schemaLocation="
  http://www.springframework.org/schema/beans     
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context 
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/mvc
  http://www.springframework.org/schema/mvc/spring-mvc.xsd">
  <context:component-scan base-package="io.weew12.github.controller"/>
  <mvc:annotation-driven/>
</beans>

@RequestMapping注解的value属性指定了sayHello()方法的映射路径为/firstController。项目ch11启动后，在浏览器中访问地址http://localhost:8080/ch11/firstController时，会执行文件中的sayHello()方法。启动项目，在浏览器中访问http://localhost:8080/ch11/firstController，控制台输出信息如图所示。

从图所示的控制台输出信息可以看出，sayHello()方法被成功执行，说明@RequestMapping注解标注在方法上时，成功建立了请求URL和处理请求方法之间的关系。

标注在类上

当@RequestMapping注解标注在类上时，@RequestMapping的value属性值相当于本处理器类的命名空间，即访问该处理器类下的任意处理器都需要带上这个命名空间。当@RequestMapping标注在类上时，其value属性值作为请求URL的第一级访问目录。当处理器类和处理器都使用@RequestMapping注解指定了对应的映射路径时，处理器在浏览器中的访问地址由项目访问路径+处理器类的映射路径+处理器的映射路径共同组成。

下面通过一个案例演示@RequestMapping注解标注在类上的使用。修改文件，在FirstController类上标注@RequestMapping注解：

package io.weew12.github.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping(value = "/springMVC")
public class FirstController {
    /**
     * 注解加载方法上
     */
    @RequestMapping(value = "/firstController")
    public void sayHello() {
        System.out.println("hello Spring MVC");
    }
}

在文件中，@RequestMapping注解指定了FirstController类的映射路径"/springMVC"；@RequestMapping注解指定了sayHello()方法的映射路径为"/firstController"。项目ch11启动后，在浏览器中访问地址http://localhost:8080/ch11/springMVC/firstController时，sayHello()方法会被执行。启动项目，在浏览器中访问http://localhost:8080/ch11/springMVC/firstController，控制台输出信息如图所示。

从图所示的控制台输出信息可以看出，sayHello()方法被成功执行，说明@RequestMapping注解标注在类上时，成功建立了请求URL和处理请求类之间的关系。

11.3.2 @RequestMapping注解的属性

在11.3.1节中，使用@RequestMapping注解的value属性映射请求的URL访问路径。除了value属性外，@RequestMapping注解还有其他6个属性。@RequestMapping注解的属性如表11-1所示。

表11-1**@RequestMapping**注解的属性

属性名	类型	描述
name	String	可选属性，用于为映射地址指定别名
value	String[]	可选属性，同时也是默认属性，用于指定请求的URL
method	RequestMethod[]	可选属性，用于指定该方法可以处理哪种类型的请求方式，其请求方式包括GET、POST、HEAD、OPTIONS、PUT、PATCH、DELETE和TRACE
params	String[]	可选属性，用于指定客户端请求中参数的值必须包含哪些参数的值时，才可以通过其标注的方法处理
headers	String[]	可选属性，用于指定客户端请求中必须包含哪些header的值时，才可以通过其标注的方法处理
consumes	String[]	可选属性，用于指定处理请求的提交内容类型（Content-type），如application/json、text/html等
produces	String[]	可选属性，用于指定返回的内容类型，仅当request请求头中的（Accept）类型中包含该指定类型时才返回

表11-1列举了@RequestMapping注解的属性，所有属性都是可选属性。除name属性外，其他属性都可以同时指定多个参数。下面结合示例学习@RequestMapping注解的常用属性。

value属性

value属性是@RequestMapping注解的默认属性。当value属性是@RequestMapping注解显式使用的唯一属性时，可以省略value的属性名。例如，下面两种映射路径标注的含义相同：

@RequestMapping(value="/firstController")
@RequestMapping("/firstController")

使用value属性时，可以指定映射单个的请求URL，也可以将多个请求映射到一个方法上。在value属性中添加一个带有请求路径的列表，就可以将这个请求列表中的路径都映射到对应的方法上：

文件11-5 AuthController.java

package io.weew12.github.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class AuthController {
    /**
     * 设定当前方法的访问映射地址列表
     */
    @RequestMapping(value = {"/addUser", "/deleteUser"})
    public void checkAuth() {
        System.out.println("增删操作校验");
    }
}

在文件中，将两个请求路径存放在英文大括号内，路径之间使用英文逗号进行分隔。此时，checkAuth()方法会处理映射请求路径"/addUser"和"/deleteUser"。

启动项目，在浏览器中访问地址http://localhost:8080/ch11/addUser，控制台输出信息如图所示。

在浏览器中访问地址http://localhost:8080/chapter11/deleteUser，控制台输出信息如图所示。

从图输出的内容分析可知，访问不同的两个路径，但都成功执行了checkAuth()方法，由此说明实现了多个请求映射到一个方法上。

method属性

method属性可以对处理器映射的URL请求方式进行限定。当请求的URL和处理器映射成功，但请求方式和method属性指定的属性值不匹配时，处理器并不能正常处理请求。下面通过一个案例演示method属性限定HTTP请求的方式：

文件11-6 MethodController.java

package io.weew12.github.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/method")
public class MethodController {
    /**
     * 处理请求方式为GET的请求
     */
    @RequestMapping(method = RequestMethod.GET)
    public void get() {
        System.out.println("RequestMethod.GET");
    }

    /**
     * 处理请求方式为DELETE的请求
     */
    @RequestMapping(method = RequestMethod.DELETE)
    public void delete() {
        System.out.println("RequestMethod.DELETE");
    }

    /**
     * 处理请求方式为POST的请求
     */
    @RequestMapping(method = RequestMethod.POST)
    public void post() {
        System.out.println("RequestMethod.POST");
    }

    /**
     * 处理请求方式为PUT的请求
     */
    @RequestMapping(method = RequestMethod.PUT)
    public void put() {
        System.out.println("RequestMethod.PUT");
    }
}

启动项目后，在客户端依次以GET方式、DELETE方式、POST方式和PUT方式请求访问http://localhost:8080/chapter11/method时，程序会分别执行文件11-6中的get()方法、delete()方法、post()方法和put()方法。控制台输出信息如图11-5所示。

如果需要同时支持多个请求方式，则需要将请求方式列表存放在英文大括号中，以数组的形式给method属性赋值，并且多个请求方式之间用英文逗号分隔：

@RequestMapping(
    value = "/test",
    method = {RequestMethod.GET, RequestMethod.POST}
)
public void getAndPost() {
    System.out.println("RequestMethod.GET + RequestMethod.POST");
}

如果没有指定method属性的值，@RequestMapping注解会根据客户端的请求方式自动适应。

params属性

params属性中定义的值可以将请求映射的定位范围缩小。当客户端进行请求时，如果请求参数的值等于params属性定义的值，则可以正常执行所映射到的方法，否则映射到的方法不执行。params属性值的定义方式：

package io.weew12.github.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ParamsController {

    @RequestMapping(value = "/params", params = "id=1")
    public void findById(String id) {
        System.out.println("id=" + id);
    }
}

在文件中，@RequestMapping注解的params属性指定了findById()方法参数id的值为1。项目启动后，在浏览器中输入http://localhost:8080/ch11/params?id=1，控制台输出信息如图所示。

从图所示的控制台输出信息可以看出，findById()方法正常执行了，说明浏览器客户端请求参数中携带的名称为id且值为1的参数，符合@RequestMapping注解params属性的设定。如客户端请求访问findById()方法未携带名称为id的参数，或所携带参数id的值不等于1，则findById()方法将不执行。

11.3.3 请求映射方式

基于注解风格的Spring MVC通过@RequestMapping注解指定请求映射的URL路径。URL路径映射常用的方式有基于请求方式的URL路径映射、基于Ant风格的URL路径映射和基于REST风格的URL路径映射3种。

基于请求方式的URL路径映射

11.3.2节中已经学习了可以使用@RequestMapping注解的method属性来限定当前方法匹配哪种类型的请求方式。除了可以使用@RequestMapping注解来限定客户端的请求方式外，从Spring 4.3版本开始，还可以使用组合注解完成客户端请求方式的限定。组合注解简化了常用的HTTP请求方式的映射，并且更好地表达了被注解方法的语义。Spring MVC组合注解如下所示：

• @GetMapping：匹配GET方式的请求。
• @PostMapping：匹配POST方式的请求。
• @PutMapping：匹配PUT方式的请求。
• @DeleteMapping：匹配DELETE方式的请求。
• @PatchMapping：匹配PATCH方式的请求。

下面以@GetMapping为例讲解组合注解的用法，@GetMapping是@RequestMapping(method = RequestMethod.GET)的缩写，使用组合注解替代@RequestMapping注解可以省略method属性，从而简化代码：

@GetMapping(value="/firstController")
public void sayHello() {
    // 方法体
}

在上述示例代码中，使用了@GetMapping注解处理GET请求，效果与使用@RequestMapping的method属性处理GET请求方式相同。

基于Ant风格的URL路径映射

Spring MVC支持Ant风格的URL路径映射，所谓Ant风格其实就是一种通配符风格，可以在处理器映射路径中使用通配符对访问的URL路径进行关联。Ant风格的通配符有以下3种：

• ?：匹配任何单字符。
• *：匹配0或者任意数量的字符。
• **：匹配0或者多级目录。

基于Ant风格的URL路径映射中，Ant风格通配符的路径匹配如表11-2所示。

表11-2 Ant风格通配符的路径匹配

通配符	URL路径示例	匹配说明
?	/ant1?	匹配项目根路径下/ant1[anyone]路径，其中[anyone]可以是任意单字符，即/ant1后有且只有1个字符，例如：/ant12、/ant1a可以被/ant1?匹配
*	/ant2/*.do	匹配项目根路径下/ant2/[any].do路径，其中[any]可以是任意数量的字符，例如：/ant2/findAll.do、/ant2/.do可以被/ant2/*.do匹配
*	/*/ant3	匹配项目根路径下/[onemore]/ant3路径，其中[onemore]可以是数量多于0个的任意字符，例如：/a/ant3、/findAl/ant3可以被/*/ant3匹配，但是字符数量不能为0，并且目录层数必须一致，例如：//ant3、/findAl/a/ant3不能被/*/ant3匹配
**	/**/ant4	匹配项目根路径下/[anypath]/ant4路径，其中[anypath]可以是0或者多层的目录，例如：/ant4、/a/ant4、/a/b/ant4可以被/**/ant4匹配
**	/ant5/**	匹配项目根路径下/ant5/[anypath]路径，其中[anypath]可以是0或者多层的目录，例如：/ant5、/ant5/a、/ant5/a/b可以被/ant5/**匹配

当映射路径中同时使用多个通配符时，可能会发生通配符冲突的情况。当多个通配符冲突时，路径会遵守最长匹配原则（has more characters）去匹配通配符，如果一个请求路径同时满足两个或多个Ant风格的映射路径匹配规则，那么请求路径最终会匹配满足规则字符最多的路径。例如，/ant/a/path同时满足/**/path和/ant/*/path匹配规则，但/ant/a/path最终会匹配/ant/*/path路径。

基于RESTful风格的URL路径映射

除了支持Ant风格的URL路径映射外，Spring MVC还支持RESTful风格的URL路径映射。

REST（Representational State Transfer）是一种网络资源的访问风格，规范了网络资源的访问方式。REST所访问的网络资源可以是一段文本、一张图片、一首歌曲、一种服务，总之是一个具体的存在。每个网络资源都有一个URI（Uniform Resource Identifier，统一资源标识符）指向它，要获取这个资源，访问它的URI就可以，因此URI即为每一个资源的独一无二的标识符。

RESTful按照REST风格访问网络资源，简单来说，RESTful就是把请求参数变成请求路径的一种风格。

例如，传统风格访问的URL格式如下：

http://.../findUserById?id=1

而采用RESTful风格后，其访问的URL格式如下：

http://.../user/id/1

从上述两个请求中可以看出，RESTful风格中的URL将请求参数id=1变成了请求路径的一部分，并且将传统风格URL中的findUserById变成了user。需要注意的是，RESTful风格中的URL不使用动词形式的路径，例如，findUserById表示查询用户，是一个动词，而user表示用户，为名词。

RESTful风格在HTTP请求中通过GET、POST、PUT和DELETE这4个动词对应4种基本请求操作，具体如下所示：

• GET：用于获取资源。
• POST：用于新建资源。
• PUT：用于更新资源。
• DELETE：用于删除资源。

RESTful风格4种请求的约定方式如表11-3所示。

表11-3 RESTful风格4种请求的约定方式

URL路径	请求方式	说明
http://localhost:8080/ch11/user/1	HTTP GET	获得参数1进行查询user操作
http://localhost:8080/ch11/user/1	HTTP DELETE	获得参数1进行删除user操作
http://localhost:8080/ch11/user/1	HTTP PUT	获得参数1进行更新user操作
http://localhost:8080/ch11/user	HTTP POST	新增user操作

表11-3列出RESTful风格4种请求的约定方式，约定不是规范，约定是可以打破的，所以称为RESTful风格，而不是RESTful规范。使用RESTful风格的优势在于路径的书写比较简便，并且通过地址无法得知做的是何种操作，可以隐藏资源的访问行为。如何获取表11-3中URL路径的参数，将会在第12章进行详细讲解，本章只对映射方式进行讲解。

11.4 本章小结

本章主要对Spring MVC的核心类及相关注解的使用进行了讲解。首先介绍了DispatcherServlet核心类的作用和配置；然后介绍了@Controller注解的使用；最后讲解了@RequestMapping注解的相关知识，包括其属性和请求映射方式。通过学习本章的内容，能够了解Spring MVC核心类DispatcherServlet的作用，并掌握@Controller注解和@RequestMapping注解的使用。

【思考题】

1. 请简述@Controller注解的使用步骤。

引入依赖：首先，确保你的项目中已经包含了Spring框架的相关依赖。对于Maven项目来说，这通常意味着在pom.xml文件中添加了spring-webmvc或相关模块的依赖。

创建控制器类：接下来，在你的Java源代码中创建一个新的类。这个类将作为处理HTTP请求的控制器。例如，你可以命名为MyController。

添加@Controller注解：在新创建的控制器类上方添加@Controller注解。这样就告诉Spring这是一个控制器类，其方法可以用来处理Web请求。

@Controller
public class MyController {
    // 控制器的方法定义
}

定义处理器方法：在控制器类内定义具体的方法来处理特定类型的请求（如GET、POST等）。这些方法需要被映射到具体的URL路径上，通常通过使用@RequestMapping或其他更具体的注解（如@GetMapping, @PostMapping）来实现。

@Controller
public class MyController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

配置视图解析器（可选）：如果你的应用程序需要返回视图而非简单的文本响应，则可能还需要配置一个视图解析器，比如Thymeleaf或者JSP。这样，当控制器方法返回字符串时，该字符串会被解析为对应的视图名。

2. 请列举@RequestMapping注解的属性（至少3个）。

value 或 path：指定请求映射到的URL模式。这是最常用的属性之一，用于确定哪个URL应该由带有此注解的方法来处理。

@RequestMapping(value = "/users", method = RequestMethod.GET)
public List<User> getUsers() { ... }

method：限制匹配的HTTP请求类型。例如，你可以指定只允许GET请求访问某个方法。

@RequestMapping(value = "/saveUser", method = RequestMethod.POST)
public void saveUser(@RequestBody User user) { ... }

params：根据请求参数的存在与否来决定是否匹配。如果指定了参数列表，则只有当请求中包含所有列出的参数时才会调用该方法。

@RequestMapping(value = "/search", params = {"q"})
public String search(@RequestParam("q") String query) { ... }

headers：类似于params属性，但基于HTTP头信息进行过滤。可用于根据请求头的内容来决定路由。

@RequestMapping(value = "/info", headers = "Accept=application/json")
public ResponseEntity<String> info() { ... }