Java、Spring 31°C 23-04-2025

^{最近更新于：2025-04-23 23:10:10}

Spring 框架是一个功能强大的 Java 开发框架，广泛用于企业级应用开发。其中的注解机制极大地简化了配置过程，提高了开发效率。

1. 组件管理注解

这些注解用于标记类为 Spring 组件，Spring 会自动扫描并将其注册为应用程序上下文中的 bean。

1.1 @Component

定义与作用：@Component 是一个通用注解，用于标记一个类为 Spring 管理的组件。被标记的类会被 Spring 的组件扫描机制（Component Scan）检测并注册为 bean，纳入 Spring 容器管理。
使用场景：适用于任何需要被 Spring 管理的类，例如工具类、辅助类或其他不属于特定层级的类。
示例代码：

// 引入 Spring 框架中用于标注组件的注解类
import org.springframework.stereotype.Component;

// 使用 @Component 注解将该类标记为一个 Spring Bean，使其能够被 Spring 容器管理
@Component
public class MyComponent {

    // 定义一个名为 doSomething 的方法，用于执行特定的操作
    public void doSomething() {
        // 输出一条消息到控制台，表示组件正在工作
        System.out.println("Component is working!");
    }
}

注意事项：
- 需要在配置类或 XML 中启用组件扫描（例如使用 @ComponentScan 或 <context:component-scan>）。
- @Component 是其他特定组件注解（如 @Service、@Repository）的父类，推荐根据类的职责选择更具体的注解以提高代码语义化。

1.2 @Service

定义与作用：@Service 用于标记服务层组件，是 @Component 的特化版本，表明该类负责业务逻辑处理。
使用场景：适用于服务层（Service Layer），通常包含业务逻辑的实现，例如用户管理、订单处理等。
示例代码：

// 导入 Spring 框架中的 Service 注解类
import org.springframework.stereotype.Service;

// 使用 @Service 注解将该类标识为一个服务层组件，使 Spring 容器能够识别并管理它
@Service
public class UserService {

    // 定义一个名为 getUserName 的方法，用于根据用户 ID 获取用户名
    public String getUserName(Long userId) {
        // 根据传入的 userId 参数生成用户名，格式为 "User-" 后跟 userId 的值
        // 这里只是一个简单的示例逻辑，实际应用中可能涉及复杂的业务逻辑或数据库查询
        return "User-" + userId;
    }
}

注意事项：
- 功能上与 @Component 相同，但使用 @Service 能更清晰地表达类的职责。
- 在大型项目中，语义明确的注解有助于团队协作和代码维护。

1.3 @Repository

定义与作用：@Repository 用于标记数据访问层组件，是 @Component 的特化版本。它不仅表示这是一个 bean，还提供了数据访问异常的自动转换功能（将底层异常如 SQLException 转换为 Spring 的 DataAccessException）。
使用场景：适用于数据访问对象（DAO），负责与数据库或其他存储系统交互。
示例代码：

// 导入 Spring 框架中的 Repository 注解类
import org.springframework.stereotype.Repository;

// 使用 @Repository 注解将该类标识为一个数据访问层（DAO）组件，使 Spring 容器能够识别并管理它
@Repository
public class UserRepository {

    // 定义一个名为 saveUser 的方法，用于将用户信息保存到数据库
    public void saveUser(String userName) {
        // 模拟将用户信息保存到数据库的操作
        // 在实际应用中，这里可能会包含与数据库交互的代码，例如使用 JDBC 或 ORM 框架（如 Hibernate）执行插入操作
        System.out.println("User " + userName + " saved!");
    }
}

注意事项：
- 需要配合 Spring 的数据访问框架（如 Spring JDBC 或 Spring Data JPA）使用，才能发挥异常转换功能。
- 如果不涉及数据访问异常转换，功能上与 @Component 无异。

1.4 @Controller

定义与作用：@Controller 用于标记控制层组件，负责处理 HTTP 请求并与视图层交互，是 Spring MVC 的核心注解。
使用场景：适用于 Web 应用的控制器类，用于接收用户请求并返回响应或视图。
示例代码：

// 导入 Spring 框架中的 Controller 注解类
import org.springframework.stereotype.Controller;
// 导入 Spring 框架中的 RequestMapping 注解类，用于处理 HTTP 请求
import org.springframework.web.bind.annotation.RequestMapping;

// 使用 @Controller 注解将该类标识为一个控制器组件，使 Spring 容器能够识别并管理它
@Controller
public class UserController {

    // 使用 @RequestMapping 注解将 "/hello" URL 映射到 sayHello 方法，当客户端访问该 URL 时，将调用该方法处理请求
    @RequestMapping("/hello")
    public String sayHello() {
        // 返回视图名称 "hello"，指示 Spring 将请求转发到名称为 "hello" 的视图页面
        return "hello";
    }
}

注意事项：
- 通常与 @RequestMapping 等注解配合使用。
- 如果需要返回 JSON 数据而不是视图，可以使用 @ResponseBody 或直接使用 @RestController。

2. 依赖注入注解

这些注解用于自动装配 bean 和注入配置值，简化依赖管理。

2.1 @Autowired

定义与作用：@Autowired 实现 bean 的自动注入，Spring 会根据类型（byType）查找并注入匹配的 bean。它可以作用于字段、构造器或 setter 方法。
使用场景：需要将一个 bean 注入到另一个 bean 中，例如将服务层注入到控制器中。
示例代码：

// 导入 Spring 框架中的 Autowired 注解类，用于自动装配依赖的 Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 框架中的 Component 注解类，用于将类标识为 Spring Bean
import org.springframework.stereotype.Component;

// 使用 @Component 注解将该类标记为一个 Spring Bean，使其能够被 Spring 容器管理
@Component
public class UserController {

    // 使用 @Autowired 注解自动装配 UserService Bean，Spring 容器会自动将 UserService 的实例注入到该字段中
    @Autowired
    private UserService userService;

    // 定义一个名为 printUser 的方法，用于根据用户 ID 打印用户名
    public void printUser(Long userId) {
        // 调用 userService 的 getUserName 方法获取用户名，并将其输出到控制台
        System.out.println(userService.getUserName(userId));
    }
}

注意事项：
- 默认情况下，依赖的 bean 必须存在，否则抛出 NoSuchBeanDefinitionException。可以通过 @Autowired(required = false) 设置为可选。
- 如果容器中有多个同类型 bean，会导致注入失败，需配合 @Qualifier 解决。

2.2 @Qualifier

定义与作用：@Qualifier 与 @Autowired 配合使用，通过指定 bean 的名称（byName）解决类型注入时的歧义。
使用场景：当容器中存在多个相同类型的 bean 时，明确指定注入哪一个。
示例代码：

// 导入 Spring 框架中的 Autowired 注解类，用于自动装配依赖的 Bean
import org.springframework.beans.factory.annotation.Autowired;
// 导入 Spring 框架中的 Qualifier 注解类，用于指定注入的具体 Bean 名称
import org.springframework.beans.factory.annotation.Qualifier;
// 导入 Spring 框架中的 Component 注解类，用于将类标识为 Spring Bean
import org.springframework.stereotype.Component;

// 使用 @Component 注解将该类标记为一个 Spring Bean，使其能够被 Spring 容器管理
@Component
public class UserController {

    // 使用 @Autowired 注解自动装配 UserService Bean，并结合 @Qualifier 注解指定要注入的 Bean 的名称为 "specificUserService"
    @Autowired
    @Qualifier("specificUserService")
    private UserService userService;
}

注意事项：
- @Qualifier 的值必须与目标 bean 的名称（默认是类名首字母小写，或通过 @Component("name") 指定）匹配。
- 只在有多个候选 bean 时使用，否则可以省略。

2.3 @Value

定义与作用：@Value 用于从配置文件（如 application.properties 或 application.yml）中注入属性值，支持 SpEL（Spring Expression Language）表达式。
使用场景：注入外部配置值，例如数据库 URL、API 密钥等。
示例代码：

// 导入 Spring 框架中的 Value 注解类，用于注入配置文件中的属性值
import org.springframework.beans.factory.annotation.Value;
// 导入 Spring 框架中的 Component 注解类，用于将类标识为 Spring Bean
import org.springframework.stereotype.Component;

// 使用 @Component 注解将该类标记为一个 Spring Bean，使其能够被 Spring 容器管理
@Component
public class AppConfig {

    // 使用 @Value 注解从配置文件中读取 "app.name" 属性的值，并将其赋值给 appName 字段
    // 如果 "app.name" 属性不存在，则使用默认值 "DefaultApp"
    @Value("${app.name:DefaultApp}")
    private String appName;

    // 提供一个公共方法 getAppName，用于获取 appName 字段的值
    public String getAppName() {
        return appName;
    }
}

配置文件（application.properties）：

  app.name=MyApp

注意事项：
- 如果配置文件中未定义属性，会注入 null，除非指定默认值（如 ${key:default}）。
- 支持复杂的 SpEL 表达式，例如 @Value("#{'${app.name}'.toUpperCase()}")。

3. 配置类注解

这些注解用于定义配置类和手动创建 bean，替代传统的 XML 配置。

3.1 @Configuration

定义与作用：@Configuration 标记一个类为配置类，Spring 会从中读取 bean 定义。它本身是一个 @Component，因此也会被扫描。
使用场景：使用 Java 代码代替 XML 配置，定义 bean 和其他配置。
示例代码：

// 导入 Spring 框架中的 Configuration 注解类，用于定义配置类
import org.springframework.context.annotation.Configuration;

// 使用 @Configuration 注解将该类标记为一个配置类，告诉 Spring 容器这是一个用于定义 Bean 的 Java 配置类
@Configuration
public class AppConfig {
    // 在这里可以使用 @Bean 注解定义各种 Bean，类似于在 XML 配置文件中定义 <bean> 元素
    // 例如：
    /*
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
    */
}

注意事项：
- 通常与 @Bean 一起使用。
- 配置类中的 @Bean 方法会被 Spring 代理，确保 bean 的单例性（除非指定其他作用域）。

3.2 @Bean

定义与作用：@Bean 在 @Configuration 类中定义一个 bean，方法返回值即为 bean 实例，由 Spring 容器管理。
使用场景：手动创建 bean，例如集成第三方库的实例。
示例代码：

// 导入 Spring 框架中的 Bean 注解类，用于定义 Bean
import org.springframework.context.annotation.Bean;
// 导入 Spring 框架中的 Configuration 注解类，用于定义配置类
import org.springframework.context.annotation.Configuration;

// 使用 @Configuration 注解将该类标记为一个配置类，表示该类主要用于定义 Spring 容器中的 Bean
@Configuration
public class AppConfig {
    // 使用 @Bean 注解定义一个 Bean，告诉 Spring 容器如何创建和配置 UserService Bean
    @Bean
    public UserService userService() {
        // 返回 UserService Bean 的实例，Spring 容器会自动将该实例注册为一个 Bean，供其他组件使用
        return new UserService();
    }
}

注意事项：
- 方法名默认作为 bean 的名称，可通过 @Bean(name = "customName") 指定。
- 如果不使用 @Configuration，直接在普通类中使用 @Bean，不会启用 Spring 的代理机制，可能导致意外行为。

4. 作用域和生命周期注解

这些注解控制 bean 的作用域和生命周期。

4.1 @Scope

定义与作用：@Scope 指定 bean 的作用域，默认是 singleton，可选值包括 prototype、request、session 等。
使用场景：需要控制 bean 是否为单例或每次请求创建新实例。
示例代码：

// 导入 Spring 框架中的 Bean 注解类，用于定义 Bean
import org.springframework.context.annotation.Bean;
// 导入 Spring 框架中的 Configuration 注解类，用于定义配置类
import org.springframework.context.annotation.Configuration;
// 导入 Spring 框架中的 Scope 注解类，用于指定 Bean 的作用域
import org.springframework.context.annotation.Scope;

// 使用 @Configuration 注解将该类标记为一个配置类，表示该类主要用于定义 Spring 容器中的 Bean
@Configuration
public class AppConfig {
    // 使用 @Bean 注解定义一个 Bean，并使用 @Scope 注解指定该 Bean 的作用域为 "prototype"（原型作用域）
    @Bean
    @Scope("prototype")
    public UserService userService() {
        // 返回 UserService Bean 的实例，Spring 容器会根据指定的作用域管理该 Bean 的生命周期
        return new UserService();
    }
}

注意事项：
- singleton：容器中只有一个实例（默认）。
- prototype：每次请求创建新实例。
- Web 作用域（如 request、session）需在 Web 环境下使用。

5. 事务管理注解

这些注解用于声明事务管理，确保方法在事务环境中执行。

5.1 @Transactional

定义与作用：@Transactional 声明方法或类需要事务支持，Spring 会确保方法在事务中执行，失败时回滚。
使用场景：数据库操作需要原子性，例如保存用户和更新余额的组合操作。
示例代码：

// 导入 Spring 框架中的 Service 注解类，用于标识业务逻辑层组件
import org.springframework.stereotype.Service;
// 导入 Spring 框架中的 Transactional 注解类，用于管理事务
import org.springframework.transaction.annotation.Transactional;

// 使用 @Service 注解将该类标识为一个业务逻辑层组件，使 Spring 容器能够识别并管理它
@Service
public class UserService {
    // 使用 @Transactional 注解声明该方法需要事务管理，确保数据库操作在事务范围内执行
    @Transactional
    public void saveUser(String userName) {
        // 这里是模拟的数据库保存操作，在实际应用中会执行数据库插入语句
        // 输出保存用户信息的提示消息
        System.out.println("User saved: " + userName);
    }
}

注意事项：
- 需要配置事务管理器（如 @EnableTransactionManagement 和 PlatformTransactionManager）。
- 可设置属性，如 @Transactional(rollbackOn = Exception.class) 指定回滚条件。

6. Web 开发注解

这些注解用于处理 HTTP 请求和响应，构建 Web 应用。

6.1 @RequestMapping

定义与作用：@RequestMapping 映射 HTTP 请求到控制器方法，支持多种 HTTP 方法（GET、POST 等）。
使用场景：定义 Web 请求的处理路径。
示例代码：

// 导入 Spring 框架中的 Controller 注解类，用于标识该类为控制器组件
import org.springframework.stereotype.Controller;
// 导入 Spring 框架中的 RequestMapping 注解类，用于映射 HTTP 请求到处理方法
import org.springframework.web.bind.annotation.RequestMapping;
// 导入 HTTP 请求方法枚举，用于指定请求类型（如 GET、POST 等）
import org.springframework.web.bind.annotation.RequestMethod;

// 使用 @Controller 注解将该类标记为一个控制器组件，处理 HTTP 请求
@Controller
public class UserController {
    // 使用 @RequestMapping 注解将 "/users" URL 路径（仅支持 GET 请求）映射到 getUsers 方法
    @RequestMapping(value = "/users", method = RequestMethod.GET)
    public String getUsers() {
        // 返回视图名称 "userList"，Spring 会根据视图解析器配置将请求转发到对应的视图页面（如 userList.jsp）
        return "userList";
    }
}

注意事项：
- 支持特定方法注解（如 @GetMapping、@PostMapping）简化代码。
- 可作用于类级别，定义公共路径前缀。

6.2 @PathVariable

定义与作用：@PathVariable 从 URL 路径中提取参数值。
使用场景：RESTful 风格请求，如 /users/{id}。
示例代码：

// 导入 Spring 框架中的 GetMapping 注解类，用于映射 HTTP GET 请求到具体的方法
import org.springframework.web.bind.annotation.GetMapping;
// 导入 Spring 框架中的 PathVariable 注解类，用于将 URL 中的占位符参数绑定到方法参数
import org.springframework.web.bind.annotation.PathVariable;
// 导入 Spring 框架中的 RestController 注解类，用于定义 RESTful 风格的控制器
import org.springframework.web.bind.annotation.RestController;

// 使用 @RestController 注解将该类标记为一个 RESTful 风格的控制器，它不仅是一个控制器，还会将方法返回值直接写入 HTTP 响应体
@RestController
public class UserController {
    // 使用 @GetMapping 注解将 HTTP GET 请求映射到 "/users/{id}" 路径，并将其映射到 getUser 方法
    // 其中 {id} 是一个路径变量，用于从 URL 中提取参数
    @GetMapping("/users/{id}")
    public String getUser(@PathVariable Long id) {
        // 返回一个包含用户 ID 的字符串，作为 HTTP 响应体返回给客户端
        return "User ID: " + id;
    }
}

注意事项：
- 参数名默认与 URL 模板一致，可通过 @PathVariable("id") 显式指定。
- 支持多个路径变量。

6.3 @RequestParam

定义与作用：@RequestParam 从请求参数（查询字符串或表单数据）中提取值。
使用场景：处理查询参数，如 /search?name=John。
示例代码：

// 导入 Spring 框架中的 GetMapping 注解类，用于映射 HTTP GET 请求到具体的方法
import org.springframework.web.bind.annotation.GetMapping;
// 导入 Spring 框架中的 RequestParam 注解类，用于将请求参数绑定到方法参数
import org.springframework.web.bind.annotation.RequestParam;
// 导入 Spring 框架中的 RestController 注解类，用于定义 RESTful 风格的控制器
import org.springframework.web.bind.annotation.RestController;

// 使用 @RestController 注解将该类标记为一个 RESTful 风格的控制器，它不仅是一个控制器，还会将方法返回值直接写入 HTTP 响应体
@RestController
public class UserController {
    // 使用 @GetMapping 注解将 HTTP GET 请求映射到 "/search" 路径，并将其映射到 search 方法
    @GetMapping("/search")
    public String search(@RequestParam String name) {
        // 返回一个包含搜索关键词的字符串，作为 HTTP 响应体返回给客户端
        return "Searching for: " + name;
    }
}

注意事项：
- 默认参数为必填，可通过 @RequestParam(required = false) 设置为可选。
- 可指定默认值，如 @RequestParam(defaultValue = "guest")。

6.4 @ResponseBody

定义与作用：@ResponseBody 指示方法返回值直接作为 HTTP 响应体返回，通常为 JSON 或 XML。
使用场景：构建 RESTful 接口，返回数据而非视图。
示例代码：

// 导入 Spring 框架中的 GetMapping 注解类，用于映射 HTTP GET 请求到具体的方法
import org.springframework.web.bind.annotation.GetMapping;
// 导入 Spring 框架中的 ResponseBody 注解类，用于将方法返回值直接写入 HTTP 响应体
import org.springframework.web.bind.annotation.ResponseBody;
// 导入 Spring 框架中的 Controller 注解类，用于将类标识为控制器组件
import org.springframework.stereotype.Controller;

// 使用 @Controller 注解将该类标记为一个控制器组件，用于处理 HTTP 请求
@Controller
public class UserController {
    // 使用 @GetMapping 注解将 HTTP GET 请求映射到 "/users" 路径
    @GetMapping("/users")
    // 使用 @ResponseBody 注解表示该方法的返回值应直接作为 HTTP 响应体返回
    public @ResponseBody String getUsers() {
        // 返回一个 JSON 格式的字符串，包含用户列表信息
        return "{\"users\": [\"John\", \"Jane\"]}";
    }
}

注意事项：
- 需要配置消息转换器（如 Jackson）以支持对象到 JSON 的自动转换。
- 与 @Controller 配合使用，若所有方法都返回响应体，可用 @RestController。

6.5 @RestController

定义与作用：@RestController 结合 @Controller 和 @ResponseBody，专为 RESTful 服务设计，所有方法默认返回响应体。
使用场景：开发 REST API。
示例代码：

// 导入 Spring 框架中的 GetMapping 注解类，用于映射 HTTP GET 请求到具体的方法
import org.springframework.web.bind.annotation.GetMapping;
// 导入 Spring 框架中的 RestController 注解类，用于定义 RESTful 风格的控制器
import org.springframework.web.bind.annotation.RestController;

// 使用 @RestController 注解将该类标记为一个 RESTful 风格的控制器，它不仅是一个控制器，还会将方法返回值直接写入 HTTP 响应体
@RestController
public class UserRestController {
    // 使用 @GetMapping 注解将 HTTP GET 请求映射到 "/users" 路径，并将其映射到 getUsers 方法
    @GetMapping("/users")
    public String getUsers() {
        // 返回一个 JSON 格式的字符串，表示用户列表信息
        // 该字符串将直接作为 HTTP 响应体返回给客户端
        return "{\"users\": [\"John\", \"Jane\"]}";
    }
}

注意事项：
- 不适用于返回视图的场景。
- 简化了 RESTful 开发，避免重复添加 @ResponseBody。

7. 异常处理注解

这些注解用于处理控制器中的异常，提供统一的异常处理逻辑。

7.1 @ExceptionHandler

定义与作用：@ExceptionHandler 定义控制器内的异常处理方法，捕获并处理特定类型的异常。
使用场景：自定义异常响应，例如返回错误页面或 JSON 错误信息。
示例代码：

// 导入 Spring 框架中的 ExceptionHandler 注解类，用于定义异常处理方法
import org.springframework.web.bind.annotation.ExceptionHandler;
// 导入 Spring 框架中的 RestController 注解类，用于定义 RESTful 风格的控制器
import org.springframework.web.bind.annotation.RestController;
// 导入 Spring 框架中的 GetMapping 注解类，用于映射 HTTP GET 请求到具体的方法
import org.springframework.web.bind.annotation.GetMapping;

// 使用 @RestController 注解将该类标记为一个 RESTful 风格的控制器，它不仅是一个控制器，还会将方法返回值直接写入 HTTP 响应体
@RestController
public class UserController {
    // 使用 @GetMapping 注解将 HTTP GET 请求映射到 "/test" 路径，并将其映射到 test 方法
    @GetMapping("/test")
    public String test() {
        // 故意抛出一个 RuntimeException 异常，用于演示异常处理机制
        throw new RuntimeException("Error occurred!");
    }

    // 使用 @ExceptionHandler 注解定义一个异常处理方法，专门处理 RuntimeException 类型的异常
    @ExceptionHandler(RuntimeException.class)
    public String handleException(RuntimeException e) {
        // 返回一个包含错误信息的字符串，作为 HTTP 响应体返回给客户端
        return "Error: " + e.getMessage();
    }
}

注意事项：
- 只处理当前控制器抛出的异常，若需全局处理，使用 @ControllerAdvice。
- 可指定多个异常类型，如 @ExceptionHandler({Exception1.class, Exception2.class})。

8. 参数绑定和模型属性注解

这些注解用于自定义参数绑定和模型属性管理。

8.1 @InitBinder

定义与作用：@InitBinder 初始化 WebDataBinder，用于自定义请求参数的转换和验证。
使用场景：处理特殊格式的参数，例如日期字符串到 Date 对象的转换。
示例代码：

// 导入 Spring 框架中的 WebDataBinder 类，用于数据绑定操作
import org.springframework.web.bind.WebDataBinder;
// 导入 Spring 框架中的 InitBinder 注解类，用于定义数据绑定初始化方法
import org.springframework.web.bind.annotation.InitBinder;
// 导入 Spring 框架中的 RestController 注解类，用于定义 RESTful 风格的控制器
import org.springframework.web.bind.annotation.RestController;

// 使用 @RestController 注解将该类标记为一个 RESTful 风格的控制器
@RestController
public class UserController {
    // 使用 @InitBinder 注解定义数据绑定初始化方法，用于配置 WebDataBinder 的行为
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        // 注册一个自定义的日期编辑器，将字符串格式的日期转换为 Date 对象
        // 使用 SimpleDateFormat 指定日期格式为 "yyyy-MM-dd"
        // 参数 true 表示允许空值
        binder.registerCustomEditor(Date.class, new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));
    }
}

注意事项：
- 方法在每次请求前调用，适用于控制器级别的绑定定制。
- 可与 @ControllerAdvice 结合实现全局绑定。

8.2 @ModelAttribute

定义与作用：@ModelAttribute 将请求参数绑定到模型对象，或将方法返回值添加到模型中。
使用场景：表单提交时自动填充对象，或预加载模型数据。
示例代码：

// 导入 Spring 框架中的 ModelAttribute 注解类，用于绑定请求参数到模型对象
import org.springframework.web.bind.annotation.ModelAttribute;
// 导入 Spring 框架中的 PostMapping 注解类，用于映射 HTTP POST 请求到具体的方法
import org.springframework.web.bind.annotation.PostMapping;
// 导入 Spring 框架中的 RestController 注解类，用于定义 RESTful 风格的控制器
import org.springframework.web.bind.annotation.RestController;

// 使用 @RestController 注解将该类标记为一个 RESTful 风格的控制器，它不仅是一个控制器，还会将方法返回值直接写入 HTTP 响应体
@RestController
public class UserController {
    // 使用 @PostMapping 注解将 HTTP POST 请求映射到 "/users" 路径，并将其映射到 addUser 方法
    @PostMapping("/users")
    public String addUser(@ModelAttribute User user) {
        // 返回一个包含用户名称的字符串，作为 HTTP 响应体返回给客户端
        // 这里假设 User 类有一个 getName() 方法用于获取用户名称
        return "Added user: " + user.getName();
    }
}

User 类：

  public class User {
      private String name;
      // getter 和 setter
  }

注意事项：
- 方法级别的 @ModelAttribute 可用于在请求前准备数据。
- 参数级别的 @ModelAttribute 自动绑定请求参数。

8.3 @SessionAttributes

定义与作用：@SessionAttributes 将模型属性存储在会话（Session）中，跨请求共享。
使用场景：需要在多个请求间共享数据，例如向导式表单。
示例代码：

// 导入 Spring 框架中的 ModelAttribute 注解类，用于将请求参数绑定到模型对象
import org.springframework.web.bind.annotation.ModelAttribute;
// 导入 Spring 框架中的 SessionAttributes 注解类，用于指定哪些模型属性应存储在 HTTP 会话中
import org.springframework.web.bind.annotation.SessionAttributes;
// 导入 Spring 框架中的 GetMapping 注解类，用于映射 HTTP GET 请求到具体的方法
import org.springframework.web.bind.annotation.GetMapping;
// 导入 Spring 框架中的 RestController 注解类，用于定义 RESTful 风格的控制器
import org.springframework.web.bind.annotation.RestController;

// 使用 @RestController 注解将该类标记为一个 RESTful 风格的控制器
// 使用 @SessionAttributes 注解指定将名称为 "user" 的模型属性存储在 HTTP 会话中
@RestController
@SessionAttributes("user")
public class UserController {
    // 使用 @GetMapping 注解将 HTTP GET 请求映射到 "/set-user" 路径，并将其映射到 setUser 方法
    @GetMapping("/set-user")
    public String setUser(@ModelAttribute("user") User user) {
        // 设置用户名称为 "John"
        user.setName("John");
        // 返回一个字符串，表示用户已设置到会话中
        return "User set in session";
    }
}

注意事项：
- 需要手动清理会话属性（如通过 SessionStatus），否则会一直保留。
- 只适用于 @Controller，不适用于 @RestController。

评论留言

欢迎您，！您可以在这里畅言您的的观点与见解！

0 条评论

Spring 框架中的常见注解