SpringMVC学习之 @RequestMapping

原创

miaowYHu 2024-08-11 22:54:51 博主文章分类：Spring ©著作权

文章标签 学习 windows python 请求头正则表达式 文章分类 Html/CSS 前端开发

©著作权归作者所有：来自51CTO博客作者miaowYHu的原创作品，请联系作者获取转载授权，否则将追究法律责任

关于@RequestMapping注解的相关知识，我们这将围绕@RequestMapping的功能，位置，method属性以及Params属性、headers属性。

@RequestMapping注解的位置

@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。

@RequestMapping标识一个类：设置映射请求的请求路径的初始信息
@RequestMapping标识一个方法：设置映射请求请求路径的具体信息

例如：

@Controller
@RequestMapping("/test")
public class RequestMappingController {
    //此时请求映射所映射的请求的请求路径为：/test/testRequestMapping
    @RequestMapping("/testRequestMapping")
    public String testRequestMapping(){
        return "success";
    }
}

@RequestMapping注解的value属性

@RequestMapping 注解的 value 属性用于指定请求的 URL 路径。它可以是一个字符串或字符串数组，表示该方法或类所处理的请求路径。以下是对 value 属性的详细介绍：

1. 基本用法

value 属性可以直接指定一个 URL 路径。例如：

@RequestMapping(value = "/users")
    public String getUsers() {
        // 处理 /users 请求
        return "userList";
    }

在这个例子中，当客户端发送请求到 /users 时，getUsers 方法将被调用。

2. 多个路径

value 属性可以接受一个字符串数组，这样可以将多个路径映射到同一个处理方法。例如：

@RequestMapping(value = {"/users", "/members"})
    public String getUsers() {
        // 处理 /users 和 /members 请求
        return "userList";
    }

在这个例子中，getUsers 方法将处理对 /users 和 /members 的请求。

3. 路径变量

可以在 value 属性中使用路径变量，使用 {} 来定义变量。例如：

@RequestMapping(value = "/users/{id}")
    public String getUser(@PathVariable("id") String userId) {
        // 根据 userId 获取用户信息
        return "userInfo";
    }

在这个例子中，{id} 是一个路径变量，表示用户的 ID。客户端请求 /users/123 时，userId 将被赋值为 123。

4. 组合路径

可以在 value 属性中组合多个路径。例如：

@RequestMapping(value = "/api/users")
    public class UserController {
    
        @RequestMapping(value = "/list")
        public String listUsers() {
            // 处理 /api/users/list 请求
            return "userList";
        }
    
        @RequestMapping(value = "/{id}")
        public String getUser(@PathVariable("id") String userId) {
            // 处理 /api/users/{id} 请求
            return "userInfo";
        }
    }

在这个例子中，listUsers 方法处理 /api/users/list 请求，而 getUser 方法处理 /api/users/{id} 请求。

5. 使用正则表达式

在 Spring 4.3 及以上版本中，可以使用正则表达式来匹配路径。例如：

@RequestMapping(value = "/users/{id:[0-9]+}")
    public String getUser(@PathVariable("id") String userId) {
        // 处理用户 ID 为数字的请求
        return "userInfo";
    }

在这个例子中，只有当 id 是数字时，getUser 方法才会被调用。

6. 结合其他属性

value 属性可以与其他属性（如 method、params、headers 等）结合使用，以进一步限制请求的匹配。例如：

@RequestMapping(value = "/users", method = RequestMethod.GET, params = "active=true")
    public String getActiveUsers() {
        // 处理 /users 请求，且请求参数 active=true
        return "activeUserList";
    }

@RequestMapping 注解的 value 属性是定义请求路径的核心部分。通过合理使用该属性，可以实现灵活的 URL 路径映射，支持路径变量、多个路径、正则表达式等功能，从而构建出清晰且易于维护的 RESTful API。

@RequestMapping注解的method属性

@RequestMapping 注解的 method 属性用于指定该请求处理方法支持的 HTTP 方法类型。通过设置 method 属性，可以限制哪些类型的 HTTP 请求会被映射到该方法上。常见的 HTTP 方法包括 GET、POST、PUT、DELETE 等。

使用方法

method 属性可以接受一个或多个 RequestMethod 枚举值。以下是一些常见的用法示例：

1. 处理 GET 请求

如果你希望某个方法只处理 GET 请求，可以这样定义：

@RequestMapping(value = "/users", method = RequestMethod.GET)
    public String getUsers() {
        // 处理 GET 请求，返回用户列表
        return "userList";
    }

2. 处理 POST 请求

如果你希望某个方法只处理 POST 请求，可以这样定义：

@RequestMapping(value = "/users", method = RequestMethod.POST)
    public String createUser() {
        // 处理 POST 请求，创建新用户
        return "userCreated";
    }

3. 处理 PUT 请求

PUT 请求通常用于更新资源，可以这样定义：

@RequestMapping(value = "/users/{id}", method = RequestMethod.PUT)
    public String updateUser(@PathVariable("id") String userId) {
        // 处理 PUT 请求，更新用户信息
        return "userUpdated";
    }

4. 处理 DELETE 请求

DELETE 请求用于删除资源，可以这样定义：

@RequestMapping(value = "/users/{id}", method = RequestMethod.DELETE)
    public String deleteUser(@PathVariable("id") String userId) {
        // 处理 DELETE 请求，删除用户
        return "userDeleted";
    }

5. 处理多个 HTTP 方法

如果你希望一个方法能够处理多种 HTTP 方法，可以将 method 属性设置为一个数组。例如，处理 GET 和 POST 请求：

@RequestMapping(value = "/users", method = {RequestMethod.GET, RequestMethod.POST})
    public String handleUsers() {
        // 处理 GET 或 POST 请求
        return "handleUsers";
    }

@RequestMapping 注解的 method 属性提供了灵活性，使得开发者可以根据不同的 HTTP 方法来定义不同的处理逻辑。这种方式有助于构建 RESTful 风格的 API，使得接口更加清晰和易于维护。通过合理使用 method 属性，可以确保请求被正确地路由到相应的处理方法。

@RequestMapping注解的params属性

@RequestMapping 注解的 params 属性用于指定请求中必须包含的参数。通过使用 params 属性，可以限制只有在请求中包含特定参数时，才会调用对应的处理方法。这对于实现条件请求处理非常有用。

1. 基本用法

params 属性可以是一个字符串，表示请求中必须包含的参数。例如：

@RequestMapping(value = "/users", params = "active=true")
    public String getActiveUsers() {
        // 处理请求中包含 active=true 的 /users 请求
        return "activeUserList";
    }

在这个例子中，只有当请求的 URL 为 /users?active=true 时，getActiveUsers 方法才会被调用。

2. 多个参数

可以使用逗号分隔多个参数，表示请求中必须同时包含这些参数。例如：

@RequestMapping(value = "/users", params = {"role=admin", "status=active"})
    public String getAdminActiveUsers() {
        // 处理请求中同时包含 role=admin 和 status=active 的 /users 请求
        return "adminActiveUserList";
    }

在这个例子中，只有当请求的 URL 为 /users?role=admin&status=active 时，getAdminActiveUsers 方法才会被调用。

3. 使用逻辑运算符

可以使用 ! 来表示参数不应该存在。例如：

@RequestMapping(value = "/users", params = "!active")
    public String getInactiveUsers() {
        // 处理请求中不包含 active 参数的 /users 请求
        return "inactiveUserList";
    }

在这个例子中，只有当请求的 URL 为 /users 且不包含 active 参数时，getInactiveUsers 方法才会被调用。

4. 组合使用

可以将 params 属性与其他属性（如 method、value 等）结合使用，以进一步限制请求的匹配。例如：

@RequestMapping(value = "/users", method = RequestMethod.GET, params = "sort=desc")
    public String getSortedUsers() {
        // 处理 GET 请求且请求参数 sort=desc 的 /users 请求
        return "sortedUserList";
    }

在这个例子中，只有当请求的 URL 为 /users?sort=desc 且使用 GET 方法时，getSortedUsers 方法才会被调用。

5. 使用正则表达式

在 Spring 4.3 及以上版本中，params 属性也支持使用正则表达式。例如：

@RequestMapping(value = "/users", params = "id=[0-9]+")
    public String getUserById(@RequestParam("id") String id) {
        // 处理请求中 id 参数为数字的 /users 请求
        return "userInfo";
    }

@RequestMapping注解的headers属性

@RequestMapping 注解的 headers 属性用于指定请求中必须包含的 HTTP 请求头。通过使用 headers 属性，可以限制只有在请求中包含特定请求头时，才会调用对应的处理方法。这对于实现条件请求处理非常有用，尤其是在需要根据请求头的不同来执行不同逻辑的场景中。
1. 基本用法

headers 属性可以是一个字符串，表示请求中必须包含的请求头。例如：

@RequestMapping(value = "/users", headers = "X-Requested-With=XMLHttpRequest")
    public String getAjaxUsers() {
        // 处理 AJAX 请求的 /users 请求
        return "ajaxUserList";
    }

在这个例子中，只有当请求的头部包含 X-Requested-With: XMLHttpRequest 时，getAjaxUsers 方法才会被调用。

2. 多个请求头

可以使用逗号分隔多个请求头，表示请求中必须同时包含这些请求头。例如：

@RequestMapping(value = "/users", headers = {"Accept=application/json", "User-Agent=Mozilla"})
    public String getJsonUsers() {
        // 处理请求中同时包含 Accept 为 application/json 和 User-Agent 为 Mozilla 的 /users 请求
        return "jsonUserList";
    }

在这个例子中，只有当请求的头部同时包含 Accept: application/json 和 User-Agent: Mozilla 时，getJsonUsers 方法才会被调用。

3. 使用逻辑运算符

可以使用 ! 来表示请求头不应该存在。例如：

@RequestMapping(value = "/users", headers = "!X-Requested-With")
    public String getNonAjaxUsers() {
        // 处理请求中不包含 X-Requested-With 请求头的 /users 请求
        return "nonAjaxUserList";
    }

在这个例子中，只有当请求的头部不包含 X-Requested-With 时，getNonAjaxUsers 方法才会被调用。

4. 组合使用

可以将 headers 属性与其他属性（如 method、value 等）结合使用，以进一步限制请求的匹配。例如：

@RequestMapping(value = "/users", method = RequestMethod.GET, headers = "X-API-Version=1.0")
    public String getVersion1Users() {
        // 处理 GET 请求且请求头中包含 X-API-Version: 1.0 的 /users 请求
        return "version1UserList";
    }

在这个例子中，只有当请求的 URL 为 /users 且使用 GET 方法，并且请求头中包含 X-API-Version: 1.0 时，getVersion1Users 方法才会被调用。

5. 使用正则表达式

在 Spring 4.3 及以上版本中，headers 属性也支持使用正则表达式。例如：

@RequestMapping(value = "/users", headers = "User-Agent=.*Chrome.*")
    public String getChromeUsers() {
        // 处理请求中 User-Agent 包含 Chrome 的 /users 请求
        return "chromeUserList";
    }

在这个例子中，只有当请求的头部中 User-Agent 包含 Chrome 时，getChromeUsers 方法才会被调用。

SpringMVC支持ant风格的路径

Spring MVC 支持使用 Ant 风格的路径模式来匹配请求 URL。这种路径匹配方式非常灵活，允许使用通配符来定义 URL 模式，从而简化请求映射的配置。以下是 Ant 风格路径的基本介绍和使用示例。

Ant 风格的路径模式

*（星号）：

匹配零个或多个字符（不包括斜杠 /）。
例如，/users/* 可以匹配 /users/1、/users/abc，但不能匹配 /users/1/details。

**（双星号）：

匹配零个或多个路径（包括斜杠 /）。
例如，/users/** 可以匹配 /users、/users/1、/users/1/details、/users/abc/xyz 等。

?（问号）：

匹配单个字符。
例如，/users/? 可以匹配 /users/1、/users/a，但不能匹配 /users/abc。

使用示例

以下是一些使用 Ant 风格路径的示例：

1. 使用 * 匹配单层路径

@Controller
    @RequestMapping("/users/*")
    public class UserController {
    
        @RequestMapping
        public String handleUser() {
            // 处理 /users/{username} 的请求
            return "userProfile";
        }
    }

在这个例子中，handleUser 方法将处理所有 /users/{username} 的请求。

2. 使用** 匹配多层路径

@Controller
    @RequestMapping("/users/**")
    public class UserController {
    
        @RequestMapping
        public String handleAllUserRequests() {
            // 处理所有以 /users 开头的请求
            return "allUserRequests";
        }
    }

在这个例子中，handleAllUserRequests 方法将处理所有以 /users 开头的请求，包括 /users、/users/1、/users/1/details 等。

3. 使用 ? 匹配单个字符

@Controller
    @RequestMapping("/users/?")
    public class UserController {
    
        @RequestMapping
        public String handleSingleCharacterUser() {
            // 处理 /users/a 或 /users/1 的请求
            return "singleCharacterUser";
        }
    }

在这个例子中，handleSingleCharacterUser 方法将处理 /users/a 和 /users/1 的请求。

组合使用

可以将 Ant 风格的路径与其他属性（如 method、params 等）结合使用，以实现更复杂的请求映射。例如：

@RequestMapping(value = "/users/**", method = RequestMethod.GET)
    public String getAllUsers() {
        // 处理所有 GET 请求的 /users 开头的请求
        return "getAllUsers";
    }

SpringMVC支持路径中的占位符

在 Spring MVC 中，支持在请求路径中使用占位符（也称为路径变量），这使得开发者能够动态地提取 URL 中的部分内容并将其传递给处理方法。占位符通常使用 {} 来定义，允许在 URL 中匹配特定的变量。

1. 基本用法

使用占位符的基本语法如下：

@RequestMapping("/users/{id}")
    public String getUser(@PathVariable("id") String userId) {
        // 处理 /users/{id} 的请求
        // userId 将被赋值为 URL 中的 id 部分
        return "userProfile";
    }

在这个例子中，当请求的 URL 为 /users/123 时，userId 将被赋值为 123。

2. 多个占位符

可以在同一个路径中使用多个占位符：

@RequestMapping("/users/{userId}/posts/{postId}")
    public String getUserPost(@PathVariable("userId") String userId, 
                               @PathVariable("postId") String postId) {
        // 处理 /users/{userId}/posts/{postId} 的请求
        return "userPost";
    }

在这个例子中，当请求的 URL 为 /users/123/posts/456 时，userId 将被赋值为 123，postId 将被赋值为 456。

3. 可选路径变量

在 Spring 4.3 及以上版本中，可以使用 @RequestMapping 的 value 属性结合 ? 来实现可选路径变量。例如：

@RequestMapping("/users/{id}/details/{detailId:[0-9]*}")
    public String getUserDetails(@PathVariable("id") String userId, 
                                  @PathVariable(value = "detailId", required = false) String detailId) {
        // 处理 /users/{id}/details 或 /users/{id}/details/{detailId} 的请求
        return "userDetails";
    }

在这个例子中，detailId 是可选的，如果请求的 URL 为 /users/123/details，则 detailId 将为 null。

4. 使用正则表达式

可以在路径变量中使用正则表达式来限制匹配的格式。例如：

@RequestMapping("/users/{id:[0-9]+}")
    public String getUserById(@PathVariable("id") String userId) {
        // 处理 /users/{id} 的请求，其中 id 必须是数字
        return "userProfile";
    }

在这个例子中，只有当 id 是数字时，getUserById 方法才会被调用。

5. 结合其他请求参数

可以将路径变量与其他请求参数结合使用：

@RequestMapping("/users/{id}")
    public String getUser(@PathVariable("id") String userId, 
                          @RequestParam(value = "active", required = false) Boolean active) {
        // 处理 /users/{id} 的请求，同时可以获取 active 请求参数
        return "userProfile";
    }

在这个例子中，active 是一个可选的请求参数，可以通过 URL 查询字符串传递。

上一篇：Spring系统学习-基于XML的声明式事务

下一篇：什么是SpringMVC?

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯