Spring & Spring Boot 常用注解整理

現(xiàn)代的 Spring 與 Spring Boot 應(yīng)用大量使用注解來簡化配置、管理組件和實現(xiàn)各種框架功能。本文系統(tǒng)整理了常用的 Spring/Spring Boot 注解，按照功能分類進行介紹。每個注解都會涵蓋其含義、提供來源、應(yīng)用場景以及代碼示例，幫助開發(fā)者深入理解和快速檢索。

一、Spring Boot 核心注解

@SpringBootApplication

簡介： @SpringBootApplication 是 Spring Boot 應(yīng)用的主入口注解。它標(biāo)注在啟動類上，表示這是一個 Spring Boot 應(yīng)用。該注解由 Spring Boot 提供（位于 org.springframework.boot.autoconfigure 包），本質(zhì)上是一個組合注解，包含了 Spring Framework 和 Spring Boot 的關(guān)鍵配置注解。

作用與場景： 使用 @SpringBootApplication 標(biāo)記主類后，Spring Boot 會自動進行以下配置：

• 配置類聲明： 包含了 @SpringBootConfiguration（其本身是 @Configuration 的特化），因此該類被視為配置類，可定義 Bean。
• 組件掃描： 內(nèi)含 @ComponentScan，會自動掃描該類所在包及其子包下的組件（被諸如 @Component、@Service、@Controller 等注解標(biāo)記的類），將它們注冊為 Spring 容器中的 Bean。
• 自動配置： 內(nèi)含 @EnableAutoConfiguration，根據(jù)類路徑下依賴自動配置 Spring Boot 應(yīng)用。例如，若 classpath 中存在 HSQLDB 數(shù)據(jù)庫依賴，則會自動配置內(nèi)存數(shù)據(jù)庫等。開發(fā)者無需手動編寫大量配置即可啟動應(yīng)用。

使用示例： 創(chuàng)建一個 Spring Boot 主啟動類，在類上添加 @SpringBootApplication 注解，并編寫 main 方法啟動應(yīng)用：

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

上述代碼中，MyApplication 類由 @SpringBootApplication 注解標(biāo)記為應(yīng)用入口。運行 SpringApplication.run 后，Spring Boot 將引導(dǎo)啟動內(nèi)嵌服務(wù)器、初始化 Spring 容器，自動掃描組件并完成配置。

注： @SpringBootApplication 提供了屬性用于定制，如 exclude 可排除特定的自動配置類。如果需要禁用某些自動配置，可以使用例如 @SpringBootApplication(exclude = DataSourceAutoConfiguration.class) 來排除。

二、Spring 容器與組件注冊注解

這一類注解用于將類注冊為 Spring 容器管理的組件或定義配置，以取代傳統(tǒng)的 XML 配置文件，實現(xiàn)注解驅(qū)動的裝配。

@Component

簡介： @Component 是一個通用的組件注解，由 Spring Framework 提供（org.springframework.stereotype.Component）。它用于將一個普通的 Java 類標(biāo)識為 Spring 容器中的 Bean。被標(biāo)注的類在組件掃描時會被發(fā)現(xiàn)并實例化，由容器統(tǒng)一管理生命周期。

作用與場景： 當(dāng)某個類不好歸類到特定層時，可以使用 @Component 進行標(biāo)注。典型場景如工具類、通用邏輯處理類等。使用 @Component 后，無需在 XML 中聲明 bean，Spring 會根據(jù)配置的掃描路徑自動將其注冊。提供模塊： Spring Context 模塊提供對組件掃描和 @Component 注解的支持。

使用示例： 定義一個組件類并演示注入：

@Component
public class MessageUtil {
    public String getWelcomeMessage() {
        return "Welcome to Spring!";
    }
}
// 使用組件
@Service
public class GreetingService {
    @Autowired
    private MessageUtil messageUtil;
    public void greet() {
        System.out.println(messageUtil.getWelcomeMessage());
    }
}

上例中，MessageUtil 類通過 @Component 標(biāo)記成為容器 Bean，GreetingService 中使用 @Autowired（詳見后文）將其注入，最后調(diào)用其方法。

@Service

簡介： @Service 是 @Component 的一種特化，用于標(biāo)注業(yè)務(wù)邏輯層的組件（Service層）。它位于 Spring 框架的 org.springframework.stereotype 包。

作用與場景： 在分層架構(gòu)中，服務(wù)層類使用 @Service 注解，使代碼含義更語義化。盡管行為上和 @Component 相同（被掃描注冊為 Bean），@Service 強調(diào)該類承擔(dān)業(yè)務(wù)服務(wù)職責(zé)。提供模塊： Spring Context，同屬于組件模型的一部分。

使用示例：

@Service
public class OrderService {
    public void createOrder(Order order) {
        // 業(yè)務(wù)邏輯：創(chuàng)建訂單
    }
}

通過 @Service，OrderService 會被自動掃描注冊。在需要使用它的地方，例如控制層或其他服務(wù)層，可以通過依賴注入獲取該 Bean 實例。

@Repository

簡介： @Repository 是 @Component 的特化注解之一，用于標(biāo)注數(shù)據(jù)訪問層組件（DAO層，或倉庫類）。定義在 Spring Framework 的 org.springframework.stereotype.Repository 包中。

作用與場景： DAO 類（例如訪問數(shù)據(jù)庫的類）使用 @Repository 注解不僅可以被掃描為容器 Bean，還能啟用異常轉(zhuǎn)換功能。Spring DAO 層會捕獲底層數(shù)據(jù)訪問異常（如 JDBC 的 SQLException 或 JPA 的異常），將其翻譯為 Spring 統(tǒng)一的DataAccessException體系，從而簡化異常處理。換句話說，如果一個類標(biāo)注為 @Repository，Spring 在為其創(chuàng)建代理時會自動處理持久化異常，將原始異常轉(zhuǎn)為 Spring 的非檢查型數(shù)據(jù)訪問異常，以提高健壯性。另外，標(biāo)注了 @Repository 的類可以被 @Autowired 等注解自動裝配到其他地方。

使用示例：

@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public User findById(Long id) {
        try {
            return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id=?", 
                                               new BeanPropertyRowMapper<>(User.class), id);
        } catch (DataAccessException e) {
            // Spring 已將底層SQLException翻譯為DataAccessException
            throw e;
        }
    }
}

上例中，UserDao 使用 @Repository 注解，使其成為容器管理的DAO組件。Spring 自動為其提供異常轉(zhuǎn)換功能：如果 JDBC 操作拋出 SQLException，會被翻譯為 DataAccessException（RuntimeException），調(diào)用處可以統(tǒng)一處理。標(biāo)注后也允許通過 @Autowired 注入到服務(wù)層使用。

@Controller

簡介： @Controller 是 Spring MVC 的控制層組件注解，同樣派生自 @Component。由 Spring Web MVC 模塊提供（org.springframework.stereotype.Controller），用于標(biāo)識一個類是Web MVC 控制器，負(fù)責(zé)處理 HTTP 請求并返回視圖或響應(yīng)。

作用與場景： 在 Web 應(yīng)用程序中，@Controller 注解的類會被 DispatcherServlet 識別為控制器，用于映射請求URL、封裝模型數(shù)據(jù)并返回視圖名。通常配合視圖模板（如 Thymeleaf、JSP）返回頁面。如果需要直接返回 JSON 數(shù)據(jù)，可以配合 @ResponseBody 或直接使用 @RestController（后者見下文）。

使用示例：

@Controller
public class HomeController {
    @RequestMapping("/home")
    public String homePage(Model model) {
        model.addAttribute("msg", "Hello Spring MVC");
        return "home"; // 返回視圖名，由視圖解析器解析為頁面
    }
}

上述 HomeController 使用 @Controller 標(biāo)記，提供一個映射 “/home” 請求的處理方法。返回值 "home" 代表視圖邏輯名，框架會根據(jù)配置解析到具體的頁面（如 home.html）。如果我們在類上使用了 @Controller，框架在啟動時會自動注冊相應(yīng)的映射。

@RestController

簡介： @RestController 是 Spring 提供的組合注解，等價于同時在類上使用 @Controller 和 @ResponseBody。它主要由 Spring Web 模塊提供，用于RESTful Web服務(wù)的控制器。

作用與場景： 標(biāo)注 @RestController 的類會被識別為控制器，并且其每個處理方法的返回值會直接作為 HTTP 響應(yīng)體輸出，而不是作為視圖名稱解析。適用于需要返回 JSON、XML 等數(shù)據(jù)的場景，比如 Web API 接口。模塊提供： Spring Web（Spring MVC）。

使用示例：

@RestController
@RequestMapping("/api")
public class UserApiController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, RESTful";
    }
    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        // 直接接收J(rèn)SON反序列化為User對象，處理后返回
        return userService.save(user);
    }
}

UserApiController 使用 @RestController 注解，其方法返回字符串和對象將直接通過消息轉(zhuǎn)換器寫入響應(yīng)（例如字符串作為純文本，User 對象會序列化為 JSON）。不需要再在每個方法上加 @ResponseBody，使代碼更加簡潔。通常在開發(fā) REST API 時，都使用 @RestController 來定義控制器。

@Configuration

簡介： @Configuration 用于聲明一個配置類，由 Spring Framework 提供（org.springframework.context.annotation.Configuration）。配置類可以包含若干個帶有 @Bean 注解的方法，以定義 Bean 并交由 Spring 容器管理。@Configuration 本身也是 @Component，因此配置類也會被組件掃描注冊。

作用與場景： 在 Java Config 風(fēng)格的應(yīng)用中，@Configuration 相當(dāng)于傳統(tǒng) XML 配置文件。用于定義 Beans、設(shè)置依賴注入規(guī)則等。Spring Boot 應(yīng)用的某些自動配置也是以配置類形式存在。提供模塊： Spring Context。

使用示例：

@Configuration
public class AppConfig {
    @Bean
    public DataSource dataSource() {
        // 配置數(shù)據(jù)源 Bean，例如使用 HikariCP 數(shù)據(jù)源
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        ds.setUsername("root");
        ds.setPassword("123456");
        return ds;
    }
    @Bean
    public UserService userService() {
        // 將 UserService 注冊為 Bean，并注入依賴的數(shù)據(jù)源
        return new UserService(dataSource());
    }
}

上述 AppConfig 被 @Configuration 注解標(biāo)識為配置類。方法 dataSource() 和 userService() 上的 @Bean 注解會使 Spring 將其返回值注冊為容器中的 Bean。其中 userService() 方法調(diào)用了 dataSource()，Spring 會攔截并確保返回的是容器中單例的 DataSource Bean，而非每次調(diào)用重新實例化（即 CGLIB 增強 @Configuration 類確保 Bean 單例行為）。

@Bean

簡介： @Bean 注解用于定義一個 Bean。它標(biāo)注在方法上，表示該方法返回的對象會注冊到 Spring 容器中。@Bean 通常配合 @Configuration 使用，由 Spring Context 模塊提供。

作用與場景： 當(dāng)通過 JavaConfig 定義 Bean 時，用 @Bean 替代傳統(tǒng) XML <bean> 聲明。例如整合第三方庫的 Bean、或需要在創(chuàng)建 Bean 時執(zhí)行一些自定義邏輯等場景。@Bean 方法可以指定名稱（默認(rèn)是方法名），還支持設(shè)置 initMethod（初始化時回調(diào)方法）和 destroyMethod（銷毀時回調(diào)方法）。

使用示例：

@Configuration
public class MyConfig {
    @Bean(name = "customBean", initMethod = "init", destroyMethod = "cleanup")
    public MyComponent customBean() {
        return new MyComponent();
    }
}

在上例中，@Bean 注解聲明了 customBean 這個 Bean。容器啟動時調(diào)用 customBean() 方法創(chuàng)建 MyComponent 實例，并以 "customBean" 名稱注冊。initMethod="init" 表示在 Bean 創(chuàng)建后自動調(diào)用其 init() 方法進行初始化；destroyMethod="cleanup" 表示容器銷毀該 Bean 時調(diào)用其 cleanup() 方法。通過這種方式可以管理 Bean 的生命周期方法（類似于 InitializingBean 和 DisposableBean 接口或 @PostConstruct/@PreDestroy，見后文）。

@ComponentScan

簡介： @ComponentScan 用于配置組件掃描路徑的注解。由 Spring Context 提供，通常與 @Configuration 一起使用。它的作用是指示 Spring 在指定的包路徑下搜索帶有組件注解的類，并注冊為 Bean。

作用與場景： 默認(rèn)情況下，Spring Boot 的 @SpringBootApplication 已經(jīng)隱含指定掃描其所在包及子包。如果需要自定義掃描范圍（例如掃描其他包的組件），可以使用 @ComponentScan 注解并提供 basePackages 等屬性。普通 Spring 應(yīng)用（非 Boot）則經(jīng)常需要在主配置類上顯式使用 @ComponentScan 指定根包。提供模塊： Spring Context。

使用示例：

@Configuration
@ComponentScan(basePackages = {"com.example.service", "com.example.dao"})
public class AppConfig {
    // ... Bean definitions
}

上述配置類通過 @ComponentScan 指定 Spring 將掃描 com.example.service 和 com.example.dao 這兩個包及其子包，搜索所有標(biāo)注了 @Component/@Service/@Controller 等的類并注冊。這樣可以將應(yīng)用的組件按照包組織，而由配置集中管理掃描范圍。

@Import

簡介： @Import 注解用于導(dǎo)入額外的配置類或組件到 Spring 容器。它由 Spring Context 提供，可用在 @Configuration 類上，將一個或多個配置類合并進來。也可以用于引入第三方配置。

作用與場景： 當(dāng)項目拆分成多個配置類時，可以通過 @Import 將它們組合。例如，將公共配置獨立出來，再在主配置中引入。Spring Boot 自動配置內(nèi)部也大量使用了 @Import 來按條件加載配置類。提供模塊： Spring Context。

使用示例：

@Configuration
@Import({SecurityConfig.class, DataConfig.class})
public class MainConfig {
    // 主配置，導(dǎo)入了安全配置和數(shù)據(jù)配置
}

如上，MainConfig 通過 @Import 導(dǎo)入了 SecurityConfig 和 DataConfig 兩個配置類。這樣這兩個配置類中定義的 Bean 同樣會加載到容器中，相當(dāng)于把多個配置模塊拼裝在一起。相比在 XML 里用 <import>，注解方式更加直觀。

注： Spring Boot 提供的許多 @Enable... 注解（例如后文的 @EnableScheduling 等）內(nèi)部也是通過 @Import 導(dǎo)入相應(yīng)的配置實現(xiàn)啟用功能的。

三、依賴注入注解

依賴注入（DI）是 Spring 核心機制之一。以下注解用于在容器中進行 Bean 注入和裝配，解決 Bean 間的依賴關(guān)系。

@Autowired

簡介： @Autowired 是 Spring 提供的自動裝配注解（org.springframework.beans.factory.annotation.Autowired），用于按類型自動注入依賴對象。它可作用于字段、setter方法或者構(gòu)造函數(shù)上。由 Spring Context 模塊支持。

作用與場景： 標(biāo)注了 @Autowired 的屬性或方法，Spring 會在容器啟動時自動尋找匹配的 Bean 注入。其中按類型匹配是默認(rèn)行為。如果匹配到多個同類型 Bean，則需要結(jié)合 @Qualifier 或 @Primary 來消除歧義（見下文）。如果沒有找到匹配 Bean，默認(rèn)會拋出異常?？赏ㄟ^設(shè)置 @Autowired(required=false) 來表示找不到 Bean 時跳過注入而不報錯。

使用示例：

@Component
public class UserService {
    @Autowired  // 按類型自動裝配
    private UserRepository userRepository;
    // 或者構(gòu)造函數(shù)注入
    // @Autowired 
    // public UserService(UserRepository userRepository) { ... }
    public User findUser(Long id) {
        return userRepository.findById(id);
    }
}

上例中，UserService 有一個成員 userRepository，使用 @Autowired 標(biāo)注。容器會自動將類型為 UserRepository 的 Bean 注入進來（假設(shè)已有 @Repository 或 @Component 標(biāo)記的 UserRepository 實現(xiàn)）。開發(fā)者可以通過構(gòu)造器、setter 或字段注入的方式使用 @Autowired。注意： Spring 4.3+ 如果類中只有一個構(gòu)造器，且需要注入?yún)?shù)，可省略構(gòu)造函數(shù)上的 @Autowired，仍會自動注入。

@Qualifier

簡介： @Qualifier 注解與 @Autowired 配合使用，用于按照名稱或限定符進行依賴注入匹配。它由 Spring 提供（org.springframework.beans.factory.annotation.Qualifier），可以解決當(dāng)容器中存在多個同類型 Bean 時的沖突。

作用與場景： 默認(rèn)按類型注入在有多于一個候選 Bean 時會無法確定注入哪個。例如有兩個實現(xiàn)類實現(xiàn)了同一接口，都被注冊為 Bean。這種情況下，可以在注入點使用 @Qualifier("beanName") 指定注入哪一個 Bean，或在 Bean 定義處使用 @Component("name") 為 Bean 命名，然后在注入處引用同名限定符。提供模塊： Spring Context/Beans。

使用示例：

@Component("mysqlRepo")
public class MySqlUserRepository implements UserRepository { ... }
@Component("oracleRepo")
public class OracleUserRepository implements UserRepository { ... }
@Service
public class UserService {
    @Autowired
    @Qualifier("mysqlRepo")  // 指定注入名稱為 mysqlRepo 的實現(xiàn)
    private UserRepository userRepository;
    // ...
}

如上，有兩個 UserRepository 實現(xiàn) Bean，分別命名為 “mysqlRepo” 和 “oracleRepo”。在 UserService 中，通過 @Qualifier("mysqlRepo") 指定注入名為 mysqlRepo 的 Bean。這樣即使存在多個同類型 Bean，Spring 也能準(zhǔn)確地注入所需的依賴。

@Primary

簡介： @Primary 注解用于標(biāo)記一個 Bean 為主要候選者。當(dāng)按類型注入出現(xiàn)多個 Bean 可選時，標(biāo)有 @Primary 的 Bean 將優(yōu)先被注入。它由 Spring 提供（org.springframework.context.annotation.Primary），可作用于類或方法（例如 @Bean 方法）上。

作用與場景： 如果不方便在每個注入點都使用 @Qualifier 指定 Bean，另一種方式是在 Bean 定義處用 @Primary 聲明一個首選 Bean。當(dāng)存在歧義時，容器會選擇標(biāo)記了 @Primary 的 Bean 注入。注意，@Primary 只能有一個，否則仍然無法明確選擇。提供模塊： Spring Context。

使用示例：

@Configuration
public class RepoConfig {
    @Bean
    @Primary  // 將這個Bean標(biāo)記為首選
    public UserRepository mysqlUserRepository() {
        return new MySqlUserRepository();
    }
    @Bean
    public UserRepository oracleUserRepository() {
        return new OracleUserRepository();
    }
}
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    // 將自動注入 mysqlUserRepository，因為它被標(biāo)記為 @Primary
}

在上例的配置中，我們定義了兩個 UserRepository Bean，其中 MySQL 實現(xiàn)被標(biāo)記為 @Primary。因此在 UserService 中按類型注入 UserRepository 時，Spring 會注入標(biāo)記了 @Primary 的 MySQL 實現(xiàn)。@Primary 提供了一個全局默認(rèn)方案，簡化了注入點的選擇。

@Resource

簡介： @Resource 是來自 JSR-250 規(guī)范的注解（Javax/Jakarta Annotation），Spring 對其提供了支持，用于按名稱或按類型注入依賴。它通常位于 jakarta.annotation.Resource（Java EE/Jakarta EE）包下。注意： 盡管不在 Spring 包中，Spring 容器能識別并處理它。

作用與場景： @Resource 可以看作功能類似于 @Autowired + @Qualifier 的組合。默認(rèn)情況下按名稱注入：它首先按照屬性名或指定的名稱在容器中查找 Bean，找不到再按類型匹配。這在某些情況下很有用，例如需要與傳統(tǒng) Java EE 代碼兼容時。在 Spring 應(yīng)用中，也有開發(fā)者偏好使用 @Resource 進行依賴注入。提供模塊： 需要引入相應(yīng)的 Jakarta Annotation API，但 Spring Framework 自身支持處理。

使用示例：

@Component("userRepo")
public class UserRepositoryImpl implements UserRepository { ... }
@Service
public class UserService {
    @Resource(name = "userRepo")  // 按名稱注入名為"userRepo"的Bean
    private UserRepository userRepo;
    // ...
}

這里，UserRepositoryImpl 組件被命名為 "userRepo"。在 UserService 中，通過 @Resource(name = "userRepo") 來注入。如果省略 name 屬性，@Resource 默認(rèn)以屬性名 userRepo 作為 Bean 名稱查找。與 @Autowired 不同，@Resource 不支持 required=false 屬性，但其異常信息可能更直觀（若找不到 Bean 則拋出 NoSuchBeanDefinitionException）。值得一提的是，Spring 也支持 JSR-330 的 @Inject（javax.inject.Inject）注解，其語義與 @Autowired 相同，也可用于構(gòu)造函數(shù)注入等。在實際開發(fā)中，可根據(jù)團隊規(guī)范選擇使用 Spring 原生的 @Autowired 還是標(biāo)準(zhǔn)的 @Resource/@Inject。

@Value

簡介： @Value 注解用于將外部化配置中的屬性值注入到 Bean 的字段或參數(shù)中。它由 Spring 提供（org.springframework.beans.factory.annotation.Value），常用于讀取 application.properties/yaml 配置文件或系統(tǒng)環(huán)境變量、JNDI等屬性。

作用與場景： 當(dāng)需要在 Bean 中使用配置文件里的值時，可以使用 @Value("${property.name}") 注入。例如數(shù)據(jù)庫連接參數(shù)、服務(wù)端口號等。還支持設(shè)置默認(rèn)值和 SpEL 表達式。提供模塊： Spring Context 環(huán)境抽象。

使用示例：
假設(shè) application.properties 有如下內(nèi)容：

app.name=MySpringApp
app.version=1.0.0

Java 類使用 @Value 注入：

@Component
public class AppInfo {
    @Value("${app.name}")
    private String appName;
    @Value("${app.version:0.0.1}")  // 帶默認(rèn)值，若配置缺失則使用0.0.1
    private String appVersion;
    // ...
}

上述 AppInfo 類中，@Value("${app.name}") 將把配置中的 app.name 值注入到 appName 字段。如果對應(yīng)屬性不存在，會啟動失敗。而 appVersion 字段提供了默認(rèn)值 0.0.1，當(dāng)配置文件未設(shè)置 app.version 時就會使用默認(rèn)值。這樣，可以靈活地將外部配置與代碼解耦，使應(yīng)用更易于調(diào)整參數(shù)而無需改動源碼。

@Scope

簡介： @Scope 注解用于指定 Bean 的作用域，由 Spring 提供（org.springframework.context.annotation.Scope）。默認(rèn)情況下，Spring 容器中的 Bean 都是單例（singleton）作用域。通過 @Scope 可以定義其他作用域，例如 prototype、request、session 等。

作用與場景： 常見的作用域：

• singleton（默認(rèn)）：容器中僅保持一個實例。
• prototype：每次請求 Bean 時都會創(chuàng)建新實例。
• Web相關(guān)的作用域（需要在 Web 容器環(huán)境下使用）：如 request（每個HTTP請求創(chuàng)建）、session（每個會話創(chuàng)建）等。

在需要每次使用新對象的場景（如有狀態(tài) Bean），可將 Bean 定義成 prototype；在 Web 應(yīng)用中某些 Bean 希望隨請求或會話存續(xù)，可用相應(yīng)作用域。提供模塊： Spring Context。

使用示例：

@Component
@Scope("prototype")
public class Connection {
    public Connection() {
        System.out.println("New Connection created.");
    }
}

將 Connection Bean 聲明為 prototype，每次獲取都會創(chuàng)建新的實例：

@Autowired
private Connection conn1;
@Autowired
private Connection conn2;

上面 conn1 和 conn2 將是不同的實例，因為 Connection 定義為 prototype。日志會打印兩次 “New Connection created.”。若作用域是 singleton，則只創(chuàng)建一次實例并復(fù)用。需要注意，prototype Bean 的生命周期由使用方管理，Spring 只負(fù)責(zé)創(chuàng)建，不會自動調(diào)用其銷毀方法。

@Lazy

簡介： @Lazy 注解用于將 Bean 的初始化延遲到首次使用時（懶加載）。由 Spring 提供（org.springframework.context.annotation.Lazy），可用于類級別或 @Bean 方法上。

作用與場景： 默認(rèn)情況下，單例 Bean 在容器啟動時就會初始化。如果某些 Bean 的創(chuàng)建比較耗時或在應(yīng)用運行期間可能不會被用到，可以標(biāo)記為 @Lazy，這樣只有在真正需要時才實例化，減少啟動時間和資源消耗。懶加載常用于：例如調(diào)試或在單元測試中減少不必要 Bean 創(chuàng)建，或避免循環(huán)依賴時暫緩 Bean 的注入初始化。對于 prototype Bean，Spring 始終延遲創(chuàng)建（因為本身就按需創(chuàng)建），@Lazy主要針對單例 Bean。提供模塊： Spring Context。

使用示例：

@Service
@Lazy
public class HeavyService {
    public HeavyService() {
        // 構(gòu)造函數(shù)可能進行大量初始化
        System.out.println("HeavyService initialized");
    }
    // ...
}
@Controller
public class DemoController {
    @Autowired
    private HeavyService heavyService; // 被@Lazy標(biāo)記，不會在容器啟動時實例化
    // ...
}

如上，HeavyService 使用 @Lazy 注解標(biāo)記為懶加載單例。啟動時不會打印 “HeavyService initialized”。當(dāng) DemoController 第一次實際調(diào)用 heavyService 的方法或訪問它時，Spring 才會創(chuàng)建 HeavyService 實例并注入。這對于優(yōu)化啟動性能和按需加載組件很有幫助。但應(yīng)謹(jǐn)慎使用懶加載，如果Bean在啟動后馬上就會用到，則不應(yīng)延遲初始化，以免首次調(diào)用時產(chǎn)生延遲。

四、配置屬性注解

Spring 提供了將配置文件內(nèi)容綁定到對象的機制，這類注解幫助管理應(yīng)用的外部化配置和環(huán)境區(qū)分。

@ConfigurationProperties

簡介： @ConfigurationProperties 用于將一組配置屬性映射到一個 Java 類上。由 Spring Boot 提供（org.springframework.boot.context.properties.ConfigurationProperties），通常配合 Bean 使用。通過前綴（prefix）來批量注入配置項到類的屬性中。

作用與場景： 當(dāng)有多項相關(guān)配置需要使用時，比起逐個使用 @Value，可以定義一個配置屬性類。例如應(yīng)用配置、數(shù)據(jù)源配置等。在類上標(biāo)注 @ConfigurationProperties(prefix="xxx") 后，該類的各屬性會根據(jù)前綴讀取配置文件中的對應(yīng)項賦值。需要將該類注冊為 Bean（可以通過在類上加 @Component 或在配置類中用 @Bean 創(chuàng)建），Spring Boot 會自動將配置綁定到 Bean 實例上。

使用示例：
application.yml:

app:
  name: MyApp
  apiUrl: https://api.example.com
  pool:
    size: 20
    enableLog: true

定義屬性綁定類：

@Component  // 確保被掃描注冊為Bean
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private String apiUrl;
    private Pool pool;
    // 內(nèi)部靜態(tài)類或普通類用于嵌套屬性
    public static class Pool {
        private int size;
        private boolean enableLog;
        // getters/setters ...
    }
    // getters/setters ...
}

將 AppProperties 注入使用：

@RestController
public class AppInfoController {
    @Autowired
    private AppProperties appProperties;
    @GetMapping("/appInfo")
    public AppProperties getAppInfo() {
        // 返回整個配置對象，框架會序列化為JSON
        return appProperties;
    }
}

在這個例子中，@ConfigurationProperties(prefix="app") 使得 YAML 中 app 下的配置自動綁定到 AppProperties Bean。name、apiUrl 會對應(yīng)賦值，嵌套的 pool.size 和 pool.enableLog 也會注入到 Pool 類中。這樣可以方便地管理和校驗成組的配置屬性。需要注意，綁定類必須有無參構(gòu)造器，提供標(biāo)準(zhǔn)的 getter/setter。Spring Boot 還支持JSR-303校驗注解（如 @Validated）配合 @ConfigurationProperties 對配置進行格式校驗。

@EnableConfigurationProperties

簡介： @EnableConfigurationProperties 是 Spring Boot 用于啟用 @ConfigurationProperties 支持的注解。它通常加在主應(yīng)用類或配置類上，用來將帶有 @ConfigurationProperties 注解的配置POJO注入到容器中。

作用與場景： 在 Spring Boot 2.x 以后，如果配置屬性類已經(jīng)被聲明為 Bean（例如加了 @Component），則無需顯式使用這個注解。@EnableConfigurationProperties 常用在需要將未被組件掃描的配置屬性類納入 Spring 管理時。例如定義了一個純 POJO 沒有用@Component，則可以在主類上通過此注解指定要啟用綁定的配置類列表。提供模塊： Spring Boot AutoConfigure。

使用示例：

@SpringBootApplication
@EnableConfigurationProperties(AppProperties.class)
public class MyApplication {
    // ...
}

上述在主啟動類上添加了 @EnableConfigurationProperties(AppProperties.class)，顯式指定將 AppProperties 這個被 @ConfigurationProperties 注解的類納入配置屬性綁定并注冊為 Bean。這樣即使未加 @Component，仍可使用 @Autowired 注入 AppProperties 實例。Spring Boot 自動配置模塊會掃描此注解并完成相應(yīng)的綁定工作。

@Profile

簡介： @Profile 注解用于根據(jù)**環(huán)境（Profile）**加載 Bean。由 Spring 提供（org.springframework.context.annotation.Profile）?？梢詷?biāo)注在類或方法（Bean 方法）上，只有在激活的環(huán)境與指定 Profile 匹配時，該 Bean 才會注冊到容器。

作用與場景： 常用于區(qū)別開發(fā)、測試、生產(chǎn)環(huán)境的配置。例如開發(fā)環(huán)境使用嵌入式數(shù)據(jù)庫，而生產(chǎn)環(huán)境使用正式數(shù)據(jù)庫連接，就可以用 @Profile("dev") 和 @Profile("prod") 注解分別標(biāo)注不同的配置類或 Bean。在運行應(yīng)用時通過配置 spring.profiles.active 激活某個 Profile，則對應(yīng)的 Bean 生效。提供模塊： Spring Context 環(huán)境管理。

使用示例：

@Configuration
public class DataSourceConfig {
    @Bean
    @Profile("dev")
    public DataSource memoryDataSource() {
        // 開發(fā)環(huán)境使用內(nèi)存數(shù)據(jù)庫
        return new H2DataSource(...);
    }
    @Bean
    @Profile("prod")
    public DataSource mysqlDataSource() {
        // 生產(chǎn)環(huán)境使用MySQL數(shù)據(jù)源
        return new MySQLDataSource(...);
    }
}

當(dāng)設(shè)置 spring.profiles.active=dev 時，應(yīng)用啟動只會創(chuàng)建 memoryDataSource Bean；設(shè)置為 prod 時只創(chuàng)建 mysqlDataSource Bean。如果不激活任何 Profile，上述兩個 Bean 都不會加載（也可以用 @Profile("default") 指定默認(rèn)配置）。使用 @Profile 實現(xiàn)了根據(jù)環(huán)境有條件地注冊 Bean，方便一套代碼多環(huán)境運行。

五、Bean 生命周期與作用域注解

Spring 管理的 Bean 具有完整的生命周期，包括初始化和銷毀過程。以下注解用于在生命周期特定階段執(zhí)行方法，以及控制 Bean 的作用域與加載時機。

@PostConstruct

簡介： @PostConstruct 是一個來自 Java 標(biāo)準(zhǔn)（JSR-250）的注解（位于 jakarta.annotation.PostConstruct）。Spring 容器在Bean初始化完依賴注入后，會調(diào)用被該注解標(biāo)記的方法。常用于初始化邏輯。需要注意在 Spring Boot 3+ 中，@PostConstruct 等由 Jakarta 引入，需要相應(yīng)依賴。

作用與場景： 當(dāng)我們希望在 Bean 完成依賴注入后自動執(zhí)行一些初始化代碼，可以在 Bean 的方法上加 @PostConstruct。例如設(shè)置默認(rèn)值、開啟定時器、檢查配置完整性等。在傳統(tǒng) Spring 中，這相當(dāng)于 <bean init-method="..."> 或?qū)崿F(xiàn) InitializingBean 接口的 afterPropertiesSet。提供模塊： JSR-250（Javax/Jakarta Annotation），由 Spring 容器支持調(diào)用。

使用示例：

@Component
public class CacheManager {
    private Map<String, Object> cache;
    @PostConstruct
    public void init() {
        // 初始化緩存
        cache = new ConcurrentHashMap<>();
        System.out.println("CacheManager initialized");
    }
}

當(dāng) Spring 創(chuàng)建了 CacheManager Bean 并注入完依賴后，會自動調(diào)用其 init() 方法，輸出 “CacheManager initialized” 并完成緩存容器初始化。這樣開發(fā)者無需手動調(diào)用初始化邏輯，容器托管完成。這對于單例Bean非常方便。

@PreDestroy

簡介： @PreDestroy 同樣來自 JSR-250 標(biāo)準(zhǔn)（jakarta.annotation.PreDestroy），Spring 在 Bean 銷毀前（容器關(guān)閉或 Bean 移除前）調(diào)用標(biāo)注該注解的方法。常用于資源釋放、保存狀態(tài)等操作。

作用與場景： 當(dāng)應(yīng)用結(jié)束或容器要銷毀 Bean 時，希望執(zhí)行一些清理工作，例如關(guān)閉文件流、線程池、數(shù)據(jù)庫連接等，可以在方法上加 @PreDestroy 注解。相當(dāng)于 XML 配置中的 <bean destroy-method="..."> 或?qū)崿F(xiàn) DisposableBean 接口的 destroy 方法。提供模塊： JSR-250，由 Spring 容器負(fù)責(zé)調(diào)用。

使用示例：

@Component
public class ConnectionManager {
    private Connection connection;
    @PostConstruct
    public void connect() {
        // 建立數(shù)據(jù)庫連接
        connection = DriverManager.getConnection(...);
    }
    @PreDestroy
    public void disconnect() throws SQLException {
        // 關(guān)閉數(shù)據(jù)庫連接
        if(connection != null && !connection.isClosed()) {
            connection.close();
            System.out.println("Connection closed.");
        }
    }
}

在上例中，ConnectionManager Bean 在初始化時建立數(shù)據(jù)庫連接，在容器銷毀時通過 @PreDestroy 標(biāo)記的 disconnect() 方法關(guān)閉連接。Spring 在應(yīng)用關(guān)閉時會調(diào)用該方法，確保資源釋放。這使得資源管理更加可靠，避免連接泄漏等問題。

@Scope (作用域) – 見上文第三部分

(此處簡要說明：) 使用 @Scope 注解可以改變 Bean 的作用域，比如 "singleton"、"prototype" 等。已在依賴注入部分詳細介紹其使用。

@Lazy (懶加載) – 見上文第三部分

(此處簡要說明：) 使用 @Lazy 可以延遲 Bean 的初始化直至第一次使用。在某些場景下提高啟動性能或解決循環(huán)依賴。前文已介紹其概念和示例。

六、Web 開發(fā)注解

Spring MVC 框架提供了大量注解來簡化 Web 開發(fā)，包括請求映射、參數(shù)綁定、響應(yīng)處理等。這些注解大多位于 org.springframework.web.bind.annotation 包中。

@RequestMapping

簡介： @RequestMapping 是最基本的請求映射注解，用于將 HTTP 請求URL路徑映射到對應(yīng)的控制器類或處理方法上。由 Spring Web MVC 提供?？捎糜陬惡头椒墑e。

作用與場景： 在類上標(biāo)注 @RequestMapping("basePath") 可以為該控制器指定一個基礎(chǔ)路徑，方法上的 @RequestMapping("subPath") 則在類路徑基礎(chǔ)上進一步細分。它支持設(shè)置請求方法（GET、POST等）、請求參數(shù)和請求頭等屬性，用于更精確地映射請求。例如只處理 GET 請求，或某個請求參數(shù)存在時才匹配。Spring MVC 啟動時會根據(jù)這些注解建立 URL 到方法的映射關(guān)系。

使用示例：

@Controller
@RequestMapping("/users")
public class UserController {
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public String getUserProfile(@PathVariable Long id, Model model) {
        // 根據(jù)id查詢用戶...
        model.addAttribute("user", userService.findById(id));
        return "profile";
    }
    @RequestMapping(value = "", method = RequestMethod.POST, params = "action=register")
    public String registerUser(UserForm form) {
        // 處理用戶注冊
        userService.register(form);
        return "redirect:/users";
    }
}

UserController 類上的 @RequestMapping("/users") 指定了基礎(chǔ)路徑“/users”。方法級注解：

• getUserProfile: 映射 GET 請求到 “/users/{id}”。使用 method = RequestMethod.GET 限定請求方法為 GET，@PathVariable 獲取 URL 中的 {id} 部分。返回視圖名 “profile” 供顯示用戶信息。
• registerUser: 映射 POST 請求到 “/users”，并使用 params="action=register" 進一步限定只有請求參數(shù)包含 action=register 時才調(diào)用此方法。這是區(qū)分同一路徑不同操作的方式。處理完后重定向到用戶列表。

@RequestMapping 非常靈活，其常用屬性：

value 或 path：映射的 URL 路徑，可以是 Ant 風(fēng)格模式（如 /users/*）。method：限定 HTTP 方法，如 RequestMethod.GET 等。params：指定必須存在的參數(shù)或參數(shù)值，如 "action=register" 或 "!admin"（必須不包含admin參數(shù)）。headers：指定必須的請求頭，如 "Content-Type=application/json"。 @GetMapping / @PostMapping 等

簡介： @GetMapping 和 @PostMapping 是 @RequestMapping 的派生注解，專門用于簡化映射 GET 和 POST 請求。類似的還有 @PutMapping、@DeleteMapping、@PatchMapping，分別對應(yīng) HTTP PUT/DELETE/PATCH 方法。它們由 Spring MVC 提供，從 Spring 4.3 開始引入。

作用與場景： 這些注解相當(dāng)于 @RequestMapping(method = RequestMethod.X) 的快捷方式，使代碼更簡潔。尤其在定義 RESTful API 時，常用不同 HTTP 方法表示不同操作，用這些注解能直觀體現(xiàn)方法用途。例如 @GetMapping 表示獲取資源，@PostMapping 表示創(chuàng)建資源等。

使用示例：

@RestController
@RequestMapping("/items")
public class ItemController {
    @GetMapping("/{id}")
    public Item getItem(@PathVariable Long id) {
        return itemService.findById(id);
    }
    @PostMapping("")
    public Item createItem(@RequestBody Item item) {
        return itemService.save(item);
    }
    @DeleteMapping("/{id}")
    public void deleteItem(@PathVariable Long id) {
        itemService.delete(id);
    }
}

上例中：

• @GetMapping("/{id}) 等價于 @RequestMapping(value="/{id}", method = RequestMethod.GET)，用于獲取指定ID的 Item。
• @PostMapping("") 等價于類路徑/items下的 POST 請求（創(chuàng)建新的 Item），請求體通過 @RequestBody 解析為 Item 對象。
• @DeleteMapping("/{id}") 處理刪除操作。

這些組合注解讓控制器方法定義更直觀，更符合 RESTful 風(fēng)格?？梢愿鶕?jù)需要使用對應(yīng)的 HTTP方法注解。未提供參數(shù)時，@GetMapping 等注解的路徑可以直接寫在注解括號內(nèi)（如上 @PostMapping("") 指當(dāng)前路徑）。

@PathVariable

簡介： @PathVariable 用于將 URL 路徑中的動態(tài)部分綁定到方法參數(shù)上。由 Spring MVC 提供。常與 @RequestMapping 或 @GetMapping 等一起使用，用于處理RESTful風(fēng)格的URL。

作用與場景： 當(dāng)URL中含有變量占位符（如 /users/{id}）時，可通過在方法參數(shù)上加 @PathVariable 來獲取該占位符的值。可以指定名稱匹配占位符，或者不指定名稱則根據(jù)參數(shù)名自動推斷。適用于從路徑獲取資源標(biāo)識（ID、name等）的場景。

使用示例：

@GetMapping("/orders/{orderId}/items/{itemId}")
public OrderItem getOrderItem(
        @PathVariable("orderId") Long orderId, 
        @PathVariable("itemId") Long itemId) {
    return orderService.findItem(orderId, itemId);
}

當(dāng)收到請求 /orders/123/items/456 時：

• orderId 參數(shù)會被賦值為 123（Long 類型轉(zhuǎn)換），
• itemId 參數(shù)賦值為 456。

@PathVariable("orderId") 中指定名稱，與 {orderId} 占位符對應(yīng)。如果方法參數(shù)名與占位符名稱相同，可以簡寫為 @PathVariable Long orderId。

通過 @PathVariable，我們無需從 HttpServletRequest 手動解析路徑，Spring MVC 自動完成轉(zhuǎn)換和注入，簡化了代碼。

@RequestParam

簡介： @RequestParam 用于綁定 HTTP 請求的查詢參數(shù)或表單數(shù)據(jù)到方法參數(shù)上。由 Spring MVC 提供。支持為參數(shù)設(shè)置默認(rèn)值、是否必需等屬性。

作用與場景： 處理 GET 請求的查詢字符串參數(shù)（URL ? 后的參數(shù)）或 POST 表單提交的字段時，可以使用 @RequestParam 獲取。例如搜索接口的關(guān)鍵詞，分頁的頁碼和大小等。它可以將 String 類型的請求參數(shù)轉(zhuǎn)換為所需的目標(biāo)類型（如 int、boolean），自動完成類型轉(zhuǎn)換和必要的校驗。

使用示例：

@GetMapping("/search")
public List<Product> searchProducts(
        @RequestParam(name="keyword", required=false, defaultValue="") String keyword,
        @RequestParam(defaultValue="0") int pageIndex,
        @RequestParam(defaultValue="10") int pageSize) {
    return productService.search(keyword, pageIndex, pageSize);
}

當(dāng)請求 /search?keyword=phone&pageIndex=1 到達時：

• keyword 參數(shù)綁定到方法的 keyword 參數(shù)。如果未提供則使用默認(rèn)值空字符串。
• pageIndex 綁定到整型參數(shù)，未提供則為默認(rèn)0。
• pageSize 在此請求未提供，因此取默認(rèn)值10。

@RequestParam 常用屬性：

• value 或 name：參數(shù)名，對應(yīng)URL中的參數(shù)名。
• required：是否必須提供，默認(rèn) true（不提供會報錯）。上例中我們將 keyword 標(biāo)記為 false 可選。
• defaultValue：如果請求未包含該參數(shù)則使用默認(rèn)值（注意即使標(biāo)記 required=true，有 defaultValue 也不會報錯）。

通過 @RequestParam，方法可以直接獲得解析后的參數(shù)值，無需自己從 request 獲取和轉(zhuǎn)換，大大簡化控制器代碼。

@RequestBody

簡介： @RequestBody 用于將 HTTP 請求報文體中的內(nèi)容轉(zhuǎn)換為 Java 對象并綁定到方法參數(shù)上。常用于處理 JSON 或 XML 等請求體。由 Spring MVC 提供。

作用與場景： 在 RESTful API 中，POST/PUT 等請求通常會攜帶 JSON 格式的數(shù)據(jù)作為請求體。使用 @RequestBody 注解在方法參數(shù)（通常是自定義的 DTO 類）上，Spring MVC 會利用 HttpMessageConverter 將 JSON/XML 等按需轉(zhuǎn)換為對應(yīng)的對象實例。適用于需要從請求正文獲取復(fù)雜對象的場景。與之對應(yīng)，返回值或方法上使用 @ResponseBody（或 @RestController）可將對象序列化為響應(yīng)。

使用示例：

@PostMapping("/users")
public ResponseEntity<String> addUser(@RequestBody UserDTO userDto) {
    // userDto 已自動綁定了請求JSON的數(shù)據(jù)
    userService.save(userDto);
    return ResponseEntity.ok("User added successfully");
}

假設(shè)客戶端發(fā)送 POST 請求至 /users，請求體為：

{ "name": "Tom", "email": "tom@example.com" }

Spring MVC 會根據(jù) @RequestBody UserDTO userDto：

• 讀取請求體 JSON，
• 將其轉(zhuǎn)換為 UserDTO 對象（要求有適當(dāng)?shù)膶傩院蛃etter）。
• 然后傳遞給控制器方法使用。

方法處理后返回成功響應(yīng)。使用 @RequestBody，開發(fā)者無需手動解析 JSON，提高了開發(fā)效率并減少出錯。

注意： @RequestBody 默認(rèn)要求請求體存在，否則報錯。如果希望在請求體為空時處理為 null，可以設(shè)置 required=false。對于 GET 請求一般不使用 @RequestBody（GET沒有主體或主體被忽略）。

@ResponseBody

簡介： @ResponseBody 注解用于將控制器方法的返回值直接作為 HTTP 響應(yīng)內(nèi)容輸出，而不是解析為視圖名稱。由 Spring MVC 提供?？梢詷?biāo)注在方法上或（較少見）標(biāo)注在類上（類上標(biāo)注相當(dāng)于對該類所有方法應(yīng)用此行為）。

作用與場景： @ResponseBody 常用于 AJAX 接口或 RESTful 方法，需要返回 JSON、XML或純文本等給客戶端，而非頁面。當(dāng)方法標(biāo)注該注解后，Spring 會將返回對象通過合適的 HttpMessageConverter 轉(zhuǎn)換為 JSON/XML 或其他格式寫入響應(yīng)流。例如返回一個對象會自動序列化為 JSON 字符串。@RestController 注解實際上已經(jīng)包含了 @ResponseBody 效果，所以在使用 @RestController 時無需再標(biāo)注此注解在每個方法上。

使用示例：

@Controller
public class StatusController {
    @GetMapping("/ping")
    @ResponseBody
    public String ping() {
        return "OK";
    }
    @GetMapping("/status")
    @ResponseBody
    public Map<String, Object> status() {
        Map<String, Object> info = new HashMap<>();
        info.put("status", "UP");
        info.put("timestamp", System.currentTimeMillis());
        return info;
    }
}

對于上例：

• /ping 請求返回純文本 “OK” 給客戶端。
• /status 請求返回一個 Map，Spring 會將其轉(zhuǎn)換為 JSON，如：{"status":"UP","timestamp":1638346953000}。

因為使用的是普通的 @Controller 類，所以需要在每個方法上添加 @ResponseBody 來指示直接返回內(nèi)容。如果改用 @RestController 則可以省略這些注解。@ResponseBody 常用于快速測試接口或者在需要精確控制輸出內(nèi)容時使用。

@CrossOrigin

簡介： @CrossOrigin 注解用于配置跨域資源共享 (CORS)。由 Spring Web 提供，可標(biāo)注在類或方法上。它允許來自不同域名的客戶端訪問被標(biāo)注的資源。

作用與場景： 當(dāng)前端和后端分屬不同域（例如前端React開發(fā)服務(wù)器 http://localhost:3000，后端 http://localhost:8080）時，瀏覽器會攔截跨域請求。使用 @CrossOrigin 可以在服務(wù)端指定允許跨域的來源、方法、頭信息等，從而使瀏覽器允許調(diào)用。可以針對整個控制器類統(tǒng)一配置（類上標(biāo)注）或針對特定方法（方法上標(biāo)注）配置不同跨域策略。

使用示例：

@RestController
@RequestMapping("/api")
@CrossOrigin(origins = "http://localhost:3000")
public class ApiController {
    @GetMapping("/data")
    public Data getData() { ... }
    @PostMapping("/submit")
    @CrossOrigin(origins = "http://example.com", methods = RequestMethod.POST)
    public void submitData(@RequestBody Data data) { ... }
}

類上標(biāo)注的 @CrossOrigin(origins = "http://localhost:3000") 表示允許來自 http://localhost:3000 的跨域請求訪問該控制器的所有接口。submitData 方法上單獨標(biāo)注了一個不同的 @CrossOrigin，表示對于 /api/submit 接口，允許來自 http://example.com 的 POST 請求跨域訪問（不受類上通用配置限制）。@CrossOrigin 還可設(shè)置允許的請求頭、是否發(fā)送憑證等，通過參數(shù)如 allowedHeaders, allowCredentials 等配置。使用這個注解，開發(fā)者不必在全局Web配置中配置 CorsRegistry，可以就近管理跨域策略。

@ExceptionHandler

簡介： @ExceptionHandler 用于在控制器中定義異常處理方法的注解。由 Spring MVC 提供。通過指定要處理的異常類型，當(dāng)控制器方法拋出該異常時，轉(zhuǎn)而由標(biāo)注了 @ExceptionHandler 的方法來處理。

作用與場景： 為了避免將異常堆棧暴露給客戶端或者在每個控制器方法中編寫重復(fù)的 try-catch，可以使用 @ExceptionHandler集中處理。例如處理表單校驗異常返回友好錯誤信息、處理全局異常返回統(tǒng)一格式響應(yīng)等。@ExceptionHandler 通常與 @ControllerAdvice（后述）配合，用于全局異常處理；也可以直接在本控制器內(nèi)部定義專門的異常處理方法。

使用示例：

@Controller
@RequestMapping("/orders")
public class OrderController {
    @GetMapping("/{id}")
    public String getOrder(@PathVariable Long id, Model model) {
        Order order = orderService.findById(id);
        if(order == null) {
            throw new OrderNotFoundException(id);
        }
        model.addAttribute("order", order);
        return "orderDetail";
    }
    // 本控制器專門處理 OrderNotFoundException
    @ExceptionHandler(OrderNotFoundException.class)
    public String handleNotFound(OrderNotFoundException ex, Model model) {
        model.addAttribute("error", "訂單不存在，ID=" + ex.getOrderId());
        return "orderError";
    }
}

在 OrderController 中，getOrder 方法如果找不到訂單，會拋出自定義的 OrderNotFoundException。下方用 @ExceptionHandler(OrderNotFoundException.class) 標(biāo)注了 handleNotFound 方法來處理這種異常：當(dāng)異常拋出后，控制器不會繼續(xù)執(zhí)行原流程，而是進入該方法。方法可以接收異常對象，以及 Model 等參數(shù)，處理后返回一個視圖名 "orderError" 顯示錯誤信息。

通過 @ExceptionHandler，控制器內(nèi)部的異常處理邏輯與正常業(yè)務(wù)邏輯解耦，代碼清晰且易于維護。

@ControllerAdvice

簡介： @ControllerAdvice 是全局控制器增強注解。由 Spring MVC 提供，用于定義一個全局異常處理或全局?jǐn)?shù)據(jù)綁定的切面類。標(biāo)注該注解的類可以包含多個 @ExceptionHandler 方法，用于處理應(yīng)用所有控制器拋出的異常；也可以包含 @ModelAttribute 或 @InitBinder 方法對所有控制器生效。

作用與場景： 當(dāng)需要對所有控制器統(tǒng)一處理某些邏輯時，使用 @ControllerAdvice 非常方便。典型用法是結(jié)合 @ExceptionHandler 作為全局異常處理器，比如攔截所有 Exception 返回通用錯誤響應(yīng)，或分類處理不同異常類型返回不同狀態(tài)碼。提供模塊： Spring MVC。

使用示例：

@ControllerAdvice
public class GlobalExceptionHandler {
    // 處理所有異常的fallback
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ResponseEntity<String> handleException(Exception ex) {
        // 記錄日志
        ex.printStackTrace();
        // 返回通用錯誤響應(yīng)
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body("Internal Server Error: " + ex.getMessage());
    }
    // 處理特定異常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public ResponseEntity<List<String>> handleValidationException(MethodArgumentNotValidException ex) {
        List<String> errors = ex.getBindingResult().getAllErrors()
                                .stream()
                                .map(ObjectError::getDefaultMessage)
                                .collect(Collectors.toList());
        return ResponseEntity.badRequest().body(errors);
    }
}

GlobalExceptionHandler 類使用 @ControllerAdvice 聲明后，Spring 會將其中標(biāo)注了 @ExceptionHandler 的方法應(yīng)用到整個應(yīng)用的控制器：

• 第一個方法捕獲所有未被其它更專門處理的異常，打印棧Trace并返回500錯誤提示。
• 第二個方法專門處理參數(shù)校驗失敗異常，提取錯誤信息列表并返回400狀態(tài)和錯誤列表。

此外，可以在 @ControllerAdvice 類中定義 @ModelAttribute 方法，為所有控制器請求添加模型數(shù)據(jù)（如公共下拉選項），或定義 @InitBinder 方法，注冊全局屬性編輯器等。@ControllerAdvice 可以通過屬性限制只應(yīng)用于某些包或注解的控制器，但全局異常處理通常都是應(yīng)用全局的。

通過 @ControllerAdvice，我們實現(xiàn)了 AOP 式的全局控制器邏輯抽取，使各控制器關(guān)注自身業(yè)務(wù)，將通用邏輯集中處理，保持代碼整潔。

七、數(shù)據(jù)訪問與事務(wù)注解

在使用 Spring 管理數(shù)據(jù)持久化層時，會涉及到 JPA/Hibernate 等注解定義實體，以及 Spring 提供的事務(wù)管理注解等。

@Entity

簡介： @Entity 是 Java Persistence API (JPA) 的注解（jakarta.persistence.Entity），用于將一個類聲明為 JPA 實體。Spring Boot 通常通過 JPA/Hibernate 來操作數(shù)據(jù)庫，因此定義模型時會用到它。@Entity 注解的類對應(yīng)數(shù)據(jù)庫中的一張表。

作用與場景： 標(biāo)記為 @Entity 的類將由 JPA 實現(xiàn)（例如 Hibernate）管理，其實例可映射到數(shù)據(jù)庫記錄。必須提供主鍵（用 @Id 標(biāo)注），可選地用 @Table 指定表名，不指定則默認(rèn)表名為類名。提供模塊： JPA 規(guī)范，由 Hibernate 等實現(xiàn)。在 Spring Boot 中，引入 spring-boot-starter-data-jpa 會自動掃描 @Entity 類并創(chuàng)建表結(jié)構(gòu)（結(jié)合DDL生成策略）。

使用示例：

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;              // 主鍵
    @Column(name = "username", length = 50, nullable = false, unique = true)
    private String username;      // 用戶名列
    @Column(nullable = false)
    private String password;      // 密碼列
    // getters & setters ...
}

User 類被 @Entity 注解標(biāo)記為持久化實體，對應(yīng)數(shù)據(jù)庫表users（由@Table指定，若不指定默認(rèn)表名User）。字段上：

• id 用 @Id 標(biāo)識為主鍵，@GeneratedValue 指定主鍵生成策略（自增）。
• username 用 @Column 細化映射：列名指定為username，長度50，非空且唯一。
• password 僅用了 @Column(nullable=false)，列名默認(rèn)為屬性名。

定義好實體后，可以使用 Spring Data JPA 的倉庫接口來自動生成常用查詢（見下文 @Repository 和 @Query）。Spring Boot 啟動時若開啟DDL-auto，會根據(jù)實體定義自動在數(shù)據(jù)庫創(chuàng)建或更新表結(jié)構(gòu)。

@Table

簡介： @Table 是 JPA 注解（jakarta.persistence.Table），配合 @Entity 使用，用于指定實體映射的數(shù)據(jù)庫表信息，如表名、schema、catalog等。

作用與場景： 默認(rèn)情況下，實體類名即表名。若數(shù)據(jù)庫表名與類名不同，或者需要定義 schema，使用 @Table 注解非常必要。也能定義唯一約束等。提供模塊： JPA。

使用示例：

@Entity
@Table(name = "T_USER", schema = "public", uniqueConstraints = {
    @UniqueConstraint(columnNames = "email")
})
public class User {
    // ...
}

該實體指定映射到 public 模式下的 T_USER 表，并聲明 email 列上有唯一約束。@Table 的屬性：

• name：表名。
• schema/catalog：所屬 schema 或 catalog 名稱。
• uniqueConstraints：唯一約束定義。

@Id

簡介： @Id 是 JPA 注解（jakarta.persistence.Id），指定實體類的主鍵字段。每個 @Entity 必須有且只有一個屬性使用 @Id 注解?？膳浜?@GeneratedValue 一起使用定義主鍵生成策略。

作用與場景： 標(biāo)記主鍵后，JPA 會將該字段作為數(shù)據(jù)庫表的主鍵列。支持基本類型或包裝類型，或 java.util.UUID 等。提供模塊： JPA。

使用示例：

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    // ... 其他字段
}

如上，id 字段為主鍵，使用自動生成策略。常見的 GenerationType：

• IDENTITY：數(shù)據(jù)庫自增字段（MySQL的AUTO_INCREMENT等）。
• SEQUENCE：使用數(shù)據(jù)庫序列（需要定義序列，Oracle等DB適用）。
• AUTO：讓 JPA 自動選擇合適策略。
• TABLE：使用一個數(shù)據(jù)庫表模擬序列。

@GeneratedValue

簡介： @GeneratedValue 是 JPA 注解（jakarta.persistence.GeneratedValue），與 @Id 聯(lián)用，表示主鍵的生成方式?？芍付ú呗?strategy 和生成器 generator。

作用與場景： 根據(jù)數(shù)據(jù)庫和需求選擇主鍵生成策略。比如 MySQL 用 IDENTITY 讓數(shù)據(jù)庫自增，Oracle 用 SEQUENCE 指定序列名稱等。提供模塊： JPA。

使用示例：

@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq")
@SequenceGenerator(name = "user_seq", sequenceName = "user_sequence", allocationSize = 1)
private Long id;

上例中，使用序列生成器：

• @SequenceGenerator 定義名為 “user_seq” 的序列生成器，映射數(shù)據(jù)庫序列 “user_sequence”。
• @GeneratedValue 引用該生成器并使用 SEQUENCE 策略。每次插入User時會從序列獲取下一個值作為ID。

對于常用的 AUTO 或 IDENTITY 策略，在大多數(shù)情況下只需簡單標(biāo)注 @GeneratedValue(strategy = GenerationType.IDENTITY) 等，無需額外生成器配置。

@Column

簡介： @Column 是 JPA 注解（jakarta.persistence.Column），用于定義實體字段與數(shù)據(jù)庫表列的映射細節(jié)?？梢圆皇褂茫绻粯?biāo)注，JPA 默認(rèn)按屬性名映射列名（可能做小寫下劃線轉(zhuǎn)換，視實現(xiàn)而定）。

作用與場景： @Column 可指定列名、數(shù)據(jù)類型長度、是否允許NULL、是否唯一等約束。對于日期時間類型，還可指定 columnDefinition 或 Temporal 等，控制SQL類型。提供模塊： JPA。

使用示例：

@Column(name = "email", length = 100, nullable = false, unique = true)
private String email;

如上，將字段 email 映射為名為 email 的列（其實和默認(rèn)同名，但明確指出），長度100，非空且唯一。使用 @Column 可以清晰地將實體和數(shù)據(jù)庫字段對應(yīng)起來。

@Repository – 見上文第二部分

(此處補充：) 在數(shù)據(jù)訪問層，@Repository 標(biāo)注的接口或類通常與 Spring Data JPA 搭配使用。如一個接口 UserRepository extends JpaRepository<User, Long> 上加 @Repository（實際上 Spring Data JPA 的接口已經(jīng)隱式有這個語義），Spring 會為其生成實現(xiàn)并交由容器管理。@Repository 除了提供組件掃描和異常轉(zhuǎn)換外，本身沒有其他方法屬性。

@Transactional

簡介： @Transactional 是 Spring 提供的聲明式事務(wù)管理注解（org.springframework.transaction.annotation.Transactional）?？蓸?biāo)注在類或方法上，表示其中的數(shù)據(jù)庫操作應(yīng)當(dāng)在一個事務(wù)中執(zhí)行。Spring 將在運行時提供事務(wù)支持，如開始、提交或回滾事務(wù)。

作用與場景： 數(shù)據(jù)庫操作需要事務(wù)保障數(shù)據(jù)一致性，例如同時更新多張表，要么全部成功要么全部失敗。使用 @Transactional 可以在不手動編程式管理事務(wù)的情況下，由框架自動處理。典型應(yīng)用：

• Service 層的方法需要原子性，則加上 @Transactional，Spring會在進入方法時開啟事務(wù)，方法成功返回則提交，如有異常則回滾。
• 也可加在類上，表示類中所有公有方法都事務(wù)管理。

提供模塊： Spring ORM/Transaction 模塊，需要相應(yīng)的事務(wù)管理器（DataSourceTransactionManager 或 JpaTransactionManager 等）配置。Spring Boot 自動根據(jù)數(shù)據(jù)源配置合適的事務(wù)管理器。

使用示例：

@Service
public class AccountService {
    @Autowired
    private AccountRepository accountRepo;
    @Autowired
    private AuditService auditService;
    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        // 扣減轉(zhuǎn)出賬戶余額
        accountRepo.decreaseBalance(fromId, amount);
        // 增加轉(zhuǎn)入賬戶余額
        accountRepo.increaseBalance(toId, amount);
        // 記錄轉(zhuǎn)賬流水
        auditService.logTransfer(fromId, toId, amount);
        // 方法結(jié)束時，Spring自動提交事務(wù)。如發(fā)生運行時異常則自動回滾。
    }
}

transfer 方法標(biāo)注了 @Transactional，因此上述三個數(shù)據(jù)庫操作將處于同一個事務(wù)中：如果任何一步拋出未經(jīng)捕獲的異常（默認(rèn)僅RuntimeException和Error會導(dǎo)致回滾，可通過 rollbackFor 屬性更改回滾規(guī)則），所有已執(zhí)行的數(shù)據(jù)庫更新都會回滾，保持?jǐn)?shù)據(jù)一致性。如果全部成功，則提交事務(wù)，將更新真正持久化。事務(wù)傳播行為和隔離級別等也可以通過注解屬性配置，例如 @Transactional(propagation=Propagation.REQUIRES_NEW) 開啟新事務(wù)，@Transactional(isolation=Isolation.SERIALIZABLE) 設(shè)置高隔離級別等，視業(yè)務(wù)需求而定。

注意： 使用 @Transactional 時，需要確保啟用了 Spring 的事務(wù)支持（見下文 @EnableTransactionManagement），Spring Boot 會自動在有數(shù)據(jù)源時啟用事務(wù)管理。所以在 Boot 場景下通常不需要額外配置即可使用。

@JsonFormat

簡介： @JsonFormat 是 Jackson 提供的序列化/反序列化格式化注解（com.fasterxml.jackson.annotation.JsonFormat）。可作用在字段、方法（getter / setter）或類型上，用于自定義日期-時間、數(shù)字、布爾等屬性在 JSON ←→ Java 轉(zhuǎn)換時的形態(tài)、時區(qū)與本地化設(shè)置。

作用與場景：

• 日期時間格式化：將 Date / LocalDateTime 等類型格式化為固定字符串（例如 yyyy-MM-dd HH:mm:ss）并指定時區(qū)，避免前后端默認(rèn)時區(qū)不一致導(dǎo)致時間偏移。
• 數(shù)字 / 布爾形態(tài)控制：可把布爾值序列化成 0/1，或把 Instant、LocalDateTime 轉(zhuǎn)成數(shù)值時間戳（shape = NUMBER）等。
• 與 Bean Validation 協(xié)同：在 DTO 中同時配合 @DateTimeFormat / 校驗注解，可保持前后端格式完全一致。
• 優(yōu)先級：字段級 @JsonFormat 會覆蓋 ObjectMapper 的全局日期格式配置，適用于單獨字段需要特殊格式的場景。

使用示例：

@Data
public class OrderDTO {
    private Long id;
    // 1. 指定日期-時間格式 + 時區(qū)
    @JsonFormat(shape = JsonFormat.Shape.STRING,
                pattern = "yyyy-MM-dd HH:mm:ss",
                timezone = "GMT+8")
    private LocalDateTime createdAt;
    // 2. 以秒級時間戳輸出
    @JsonFormat(shape = JsonFormat.Shape.NUMBER)
    private Instant eventTime;
    // 3. 布爾值改為 0 / 1
    @JsonFormat(shape = JsonFormat.Shape.NUMBER)
    private Boolean paid;
}

@Getter

簡介： @Getter 是 Lombok 提供的生成器注解（lombok.Getter）。編譯期自動為被注解的類或字段生成 public getter 方法，省去手寫樣板代碼。

作用與場景：

• 簡化 POJO / DTO 編寫：一個注解即可為所有字段（或單獨字段）生成讀取方法，保持類體簡潔。
• 與框架集成：Spring / Jackson / Hibernate 等框架依賴 getter 讀取屬性時可直接使用 Lombok 生成的方法。

使用示例：

@Getter          // 為所有字段生成 getter
public class UserVO {
    private Long id;
    @Getter(AccessLevel.NONE) // 不生成該字段的 getter
    private String password;
    // 也可在字段級別加 @Getter 僅生成單個方法
}

依賴：開發(fā)環(huán)境需引入 lombok 依賴，并在 IDE 中安裝 Lombok 插件或開啟 Annotation Processing。

@Setter

簡介： @Setter 同樣由 Lombok 提供（lombok.Setter），自動為類或字段生成 public setter 方法。

作用與場景：

• 可變對象賦值：在需要修改字段值、或框架反射注入時使用。
• 粒度控制：可通過 AccessLevel 設(shè)置方法可見性（如 @Setter(AccessLevel.PROTECTED)），或僅在特定字段上使用，避免暴露全部可寫接口。

使用示例：

@Getter
@Setter               // 為所有字段生成 setter
public class ProductVO {
    private Long id;
    @Setter(AccessLevel.PRIVATE) // 僅類內(nèi)部可修改
    private BigDecimal price;
    // price 的 setter 為 private，其余字段的 setter 為 public
}

@ToString

簡介： @ToString 亦由 Lombok 提供（lombok.ToString）。在編譯期生成 toString() 方法，自動拼接字段名和值，支持包含/排除特定字段、隱藏敏感信息等。

作用與場景：

• 調(diào)試與日志：快速輸出對象內(nèi)容而不必手寫 toString()。
• 避免敏感字段泄漏：可用 @ToString.Exclude 排除字段，或在注解上設(shè)置 callSuper = true 包含父類字段。
• 鏈?zhǔn)阶⒔?/strong>：常與 @Getter/@Setter/@EqualsAndHashCode 等一起使用，快速生成完整數(shù)據(jù)類。

@Getter
@Setter
@ToString(exclude = "password")          // 排除 password
public class AccountVO {
    private String username;
    @ToString.Exclude
    private String password;             // 或者字段級排除
    private LocalDateTime lastLogin;
}
/*
輸出示例：
AccountVO(username=admin, lastLogin=2025-05-10T20:30:00)
*/

@Configuration
@EnableTransactionManagement
public class TxConfig {
    @Bean
    public PlatformTransactionManager txManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource); // 配置事務(wù)管理器
    }
}

public interface UserRepository extends JpaRepository<User, Long> {
    // 使用JPQL查詢
    @Query("SELECT u FROM User u WHERE u.email = ?1")
    User findByEmail(String email);
    // 使用原生SQL查詢
    @Query(value = "SELECT * FROM users u WHERE u.status = :status LIMIT :limit", nativeQuery = true)
    List<User> findTopByStatus(@Param("status") int status, @Param("limit") int limit);
}

@Aspect
@Component  // 切面本身也需注冊為Bean
public class LoggingAspect {
    // 切點定義：匹配 service 包下所有類的公共方法
    @Pointcut("execution(public * com.example.service..*(..))")
    public void serviceMethods() {}
    // 前置通知：在滿足切點的方法執(zhí)行之前執(zhí)行
    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Entering: " + joinPoint.getSignature());
    }
    // 后置通知：無論方法正?；虍惓＝Y(jié)束都會執(zhí)行
    @After("serviceMethods()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("Exiting: " + joinPoint.getSignature());
    }
}

@Aspect
@Component
public class SecurityAspect {
    // 切點：controller 包下的所有含 @GetMapping 注解的方法
    @Pointcut("within(@org.springframework.web.bind.annotation.RestController *) && @annotation(org.springframework.web.bind.annotation.GetMapping)")
    public void allGetEndpoints() {}
    @Before("allGetEndpoints()")
    public void checkAuthentication() {
        // 執(zhí)行權(quán)限驗證邏輯
        if (!SecurityContext.isAuthenticated()) {
            throw new SecurityException("User not authenticated");
        }
    }
}

@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) { ... }

@After("serviceMethods()")
public void logAfter(JoinPoint joinPoint) { ... }

@AfterReturning(pointcut = "execution(* com.example.service.OrderService.placeOrder(..))", returning = "result")
public void logOrderResult(Object result) {
    System.out.println("Order placed result: " + result);
}

@AfterThrowing(pointcut = "execution(* com.example..*.*(..))", throwing = "ex")
public void logException(Exception ex) {
    System.err.println("Exception in method: " + ex.getMessage());
}

@Around("execution(* com.example.service.*.*(..))")
public Object measureExecutionTime(ProceedingJoinPoint pjp) throws Throwable {
    long start = System.currentTimeMillis();
    Object result;
    try {
        result = pjp.proceed(); // 執(zhí)行目標(biāo)方法
    } finally {
        long end = System.currentTimeMillis();
        System.out.println(pjp.getSignature() + " executed in " + (end - start) + "ms");
    }
    return result;
}

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AopConfig {
    // 切面類Bean或通過@Component掃描切面類
}

@Service
public class NotificationService {
    @Async
    public void sendEmail(String to, String content) {
        // 模擬發(fā)送郵件的耗時操作
        try {
            Thread.sleep(5000);
            System.out.println("Email sent to " + to);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

@SpringBootApplication
@EnableAsync  // 開啟異步支持
public class MyApp { ... }

@RestController
public class OrderController {
    @Autowired
    private NotificationService notificationService;
    @PostMapping("/order")
    public ResponseEntity<String> placeOrder(@RequestBody Order order) {
        orderService.process(order);
        // 異步發(fā)送通知
        notificationService.sendEmail(order.getEmail(), "Your order is placed.");
        return ResponseEntity.ok("Order received");
    }
}

@Bean(name = "taskExecutor")
public Executor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(10);
    executor.initialize();
    return executor;
}

@Component
public class ReportTask {
    @Scheduled(cron = "0 0 2 * * ?")
    public void generateDailyReport() {
        // 每天凌晨2點生成報告
        System.out.println("Generating daily report at " + LocalDate.now());
        // ... 報表生成邏輯
    }
    @Scheduled(fixedRate = 60000)
    public void checkSystemHealth() {
        // 每隔60秒檢查系統(tǒng)健康
        System.out.println("Health check at " + Instant.now());
        // ... 健康檢查邏輯
    }
}

@SpringBootApplication
@EnableScheduling
public class Application { ... }

@SpringBootApplication
@EnableCaching
public class Application { ... }

@Service
public class ProductService {
    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // 假設(shè)這里有復(fù)雜計算或慢速數(shù)據(jù)庫查詢
        System.out.println("Loading product " + id + " from DB...");
        return productRepository.findById(id).orElse(null);
    }
}

@CachePut(value = "products", key = "#product.id")
public Product updateProduct(Product product) {
    System.out.println("Updating product " + product.getId());
    return productRepository.save(product);
}

@CacheEvict(value = "products", key = "#id")
public void deleteProduct(Long id) {
    System.out.println("Deleting product " + id);
    productRepository.deleteById(id);
}

@CacheEvict(value = "products", allEntries = true)
public void refreshAllProducts() { ... }

// 定義事件類（可以繼承 ApplicationEvent 也可以是普通類）
public class UserRegisteredEvent /* extends ApplicationEvent */ {
    private final User user;
    public UserRegisteredEvent(User user) { this.user = user; }
    public User getUser() { return user; }
}
// 發(fā)布事件的組件
@Service
public class UserService {
    @Autowired 
    private ApplicationEventPublisher eventPublisher;
    public void register(User user) {
        // ... 保存用戶邏輯
        // 發(fā)布事件
        eventPublisher.publishEvent(new UserRegisteredEvent(user));
    }
}
// 監(jiān)聽事件的組件
@Component
public class WelcomeEmailListener {
    @EventListener
    public void handleUserRegistered(UserRegisteredEvent event) {
        User newUser = event.getUser();
        // 發(fā)送歡迎郵件
        System.out.println("Sending welcome email to " + newUser.getEmail());
        // ... 實際發(fā)送郵件邏輯
    }
}

@EventListener(condition = "#event.user.vip")
public void handleVipUserRegistered(UserRegisteredEvent event) { ... }

@Component
public class StatsListener implements ApplicationListener<UserRegisteredEvent> {
    @Override
    public void onApplicationEvent(UserRegisteredEvent event) {
        // 統(tǒng)計用戶注冊
        metrics.increment("user.register.count");
    }
}

@SpringBootTest
class ApplicationTests {
    @Autowired
    private UserService userService;
    @Test
    void testUserRegistration() {
        User user = new User("alice");
        userService.register(user);
        // 驗證注冊結(jié)果，比如檢查數(shù)據(jù)庫或事件發(fā)布效果
        assertNotNull(user.getId());
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)

@WebMvcTest(controllers = UserController.class)
class UserControllerTests {
    @Autowired
    private MockMvc mockMvc;
    @MockBean
    private UserService userService;  // 將UserService模擬
    @Test
    void testGetUser() throws Exception {
        User user = new User(1L, "Bob");
        // 定義當(dāng)userService.findById(1)被調(diào)用時返回user對象
        given(userService.findById(1L)).willReturn(user);
        mockMvc.perform(get("/users/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.name").value("Bob"));
    }
}

@DataJpaTest
class UserRepositoryTests {
    @Autowired
    private UserRepository userRepository;
    @Test
    void testFindByEmail() {
        // 準(zhǔn)備測試數(shù)據(jù)
        User user = new User();
        user.setEmail("test@example.com");
        user.setName("Test");
        userRepository.save(user);
        // 執(zhí)行查詢方法
        User found = userRepository.findByEmail("test@example.com");
        assertEquals("Test", found.getName());
    }
}

@MockBean
private WeatherService weatherService;

@SpringBootTest
class OrderServiceTests {
    @Autowired
    private OrderService orderService;
    @MockBean
    private PaymentClient paymentClient;  // 模擬外部支付服務(wù)客戶端
    @Test
    void testOrderPayment() {
        Order order = new Order(...);
        // 假定調(diào)用外部支付返回成功結(jié)果
        given(paymentClient.pay(order)).willReturn(new PaymentResult(true));
        boolean result = orderService.processPayment(order);
        assertTrue(result);
        // 驗證內(nèi)部行為，如訂單狀態(tài)更新
        // ...
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
            .and().formLogin();
    }
}

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    // ...
}

@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true, securedEnabled = true, jsr250Enabled = true)
public class SecurityConfig { ... }

@Service
public class AccountService {
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteAccount(Long accountId) {
        // 只有ADMIN角色用戶才能執(zhí)行
        accountRepository.deleteById(accountId);
    }
    @PreAuthorize("#user.name == authentication.name or hasAuthority('SCOPE_profile')")
    public Profile getUserProfile(User user) {
        // 用戶本人或具有profile權(quán)限的可以查看
        return profileRepository.findByUser(user);
    }
}

@Secured("ROLE_ADMIN")
public void createUser(User user) { ... }
@Secured({"ROLE_USER", "ROLE_ADMIN"})
public Data getData() { ... }

@RolesAllowed("ADMIN")
public void updateSettings(Settings settings) { ... }