SpringFrameworkPart6-Spring Framework常用注解

Spring框架核心注解

Spring的一个核心功能是IOC，就是将Bean初始化加载到容器中，Bean是如何加载到容器的，可以使用Spring注解方式或者Spring XML配置方式。

Spring注解方式减少了配置文件内容，更加便于管理，并且使用注解可以大大提高了开发效率！

注解本身是没有功能的，和xml一样，注解和xml都是一种元数据，元数据即解释数据的数据，也就是所谓的配置。

我们可以通过 org.springframework.beans.factory.annotation 和 org.springframework.context.annotation 包中的注解来使用 Spring DI 引擎的功能。

xml用来管理bean；
注解只负责完成属性的注入；

使用注解需要开启对注解的支持

1 2	<context:component-scan base-package="com.guo"></context:component-scan> <context:annotation-config/>

常用注解

给容器中注入组件

包扫描+组件标注注解

@Component：表示一个带注释的类是一个“组件”，成为Spring管理的Bean
- 作用：是一个泛化的组件注解，用于标记一个类作为 Spring 容器中的一个组件，让 Spring 能够自动扫描并将其纳入容器管理。
- 使用：当一个类不属于特定的层（如控制层、业务层、数据访问层），但又需要被 Spring 容器管理时，就可以使用@Component注解。例如，一些工具类、配置类等可以使用该注解。
- @Controller、@Service、@Repository都可以称为@Component。@Controller、@Service、@Reponsitory都组合了 @Component注解。为了区分三层不同的作用，因此分别为三层起了不同的名字。
@Controller：应用在控制层
- 作用：用于标记控制层的组件，主要处理用户的请求和视图的展示。它负责接收客户端的请求，调用相应的业务逻辑方法，并将结果返回给客户端。
- 使用场景：在 Web 应用中，通常用于处理 HTTP 请求的控制器类上。比如，处理用户登录、注册请求，或者根据用户的操作返回相应页面的控制器。
@Service：应用在service层（业务逻辑层）
- 作用：用于标记业务层的组件，主要包含应用的业务逻辑。它通常会调用数据访问层的方法来完成数据库操作，并对数据进行处理和业务规则的应用。
- 使用场景：在处理复杂业务逻辑的服务类上使用，如用户服务、订单服务等。例如，在电商应用中，计算订单总价、处理库存更新等业务逻辑就可以放在@Service注解标记的类中。
@Repository：应用在dao层（实现类）（数据访问层）
- 作用：用于标记数据访问层的组件，主要负责与数据库进行交互，执行数据库的增删改查操作。它提供了一种将数据访问逻辑封装起来的方式，使得业务层可以方便地调用数据访问方法。
- 使用场景：在与数据库交互的 DAO（Data Access Object）类上使用。比如，在用户管理系统中，实现用户数据的存储、查询、更新和删除操作的类就可以使用@Repository注解。

配置相关注解

配置管理

@Configuration
- 作用：标记类为配置类，替代XML配置文件。配置类中可以声明@Bean方法，Spring容器会将其作为Bean定义的来源。
- 使用：
  1
  2
  3
  4
  5
  6
  7
  @Configuration
  public class AppConfig {
  @Bean
  public DataSource dataSource() {
  return new HikariDataSource();
  }
  }

@ComponentScan

作用：自动扫描指定包路径下的组件（如@Component, @Service, @Repository等），并将其注册为Spring Bean。
属性：
- basePackages：指定扫描的包路径（支持多个）
- excludeFilters：排除不需要扫描的组件

使用

@Configuration
@ComponentScan(basePackages = "com.example.service",
               excludeFilters = @ComponentScan.Filter(type=FilterType.ANNOTATION, classes=Controller.class))
public class AppConfig {}

@AliasFor
- 作用：为注解属性声明别名（用于元注解组合）主要用于元注解组合时实现属性覆盖

@PropertySource

作用：加载外部属性文件到Spring Environment
特性：
- 支持classpath:、file:等前缀
- 支持多个文件（Spring 4+使用@PropertySources）

使用：

@Configuration
@PropertySource("classpath:app.properties")
@PropertySource(value = "file:/etc/config/override.properties", ignoreResourceNotFound = true)
public class AppConfig { ... }

扩展：@PropertySources

可以使用此注解指定多个 @PropertySource 配置：

@Configuration
@PropertySources({ 
    @PropertySource("classpath:/annotations.properties"),
    @PropertySource("classpath:/vehicle-factory.properties")
})
class VehicleFactoryConfig {}

注意，自 Java 8 以来，可以通过上述重复注解的特性来实现同样的功能。

Bean管理

@Bean：导入第三方包里面的注解
- 作用：@Bean注解通常用于在 Java 配置类中定义 Bean。当你需要将第三方库中的类或者你自己编写的但不适合用组件扫描注解标注的类纳入 Spring 容器管理时，就可以使用@Bean注解。它允许你以编程的方式创建和配置 Bean。
- 特性：
  - 方法名默认作为Bean名称
  - 支持initMethod/destroyMethod配置生命周期方法
- 使用
  1
  2
  3
  4
  5
  6
  7
  @Configuration
  public class DataSourceConfig {
  @Bean(name = "primaryDataSource", initMethod = "init")
  public DataSource dataSource() {
  return new HikariDataSource();
  }
  }
@Conditional：
- 作用：这是一个元注解，用于自定义条件化创建 Bean。可以根据指定的条件决定是否创建某个 Bean。基于条件决定是否注册 Bean（自定义条件逻辑）。它需要配合一个条件类（Condition Class）使用，条件类通过实现Condition接口，定义了Bean加载的条件逻辑。
- 使用：
  1
  2
  3
  4
  5
  6
  7
  @Component
  @Conditional(MyCondition.class)
  public class MyConditionalComponent {
  public void doSomething() {
  System.out.println("Conditional component...");
  }
  }
  在上述代码中，MyConditionalComponent类仅在MyCondition条件满足时才会被加载。这种方式使得开发者可以根据运行时环境或配置动态决定Bean的加载，增强了应用的灵活性。通过这种方式，开发者可以实现按需加载Bean，从而优化应用的性能和资源利用率。

@ConditionalOnProperty（Spring Boot特有）

作用：根据配置文件中的属性值来决定是否创建 Bean。

```java import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;

@Configuration public class PropertyConfig { @Bean @ConditionalOnProperty(name = “myapp.feature.enabled”, havingValue = “true”) public MyFeature myFeature() { return new MyFeature(); } }


    在这个例子中，只有当配置文件（如`application.properties`）中`myapp.feature.enabled`属性的值为`true`时，`myFeature` Bean 才会被创建。
  
- @Order

  - 作用：定义Bean的加载/执行顺序（数值越小优先级越高）

  - **应用场景**：

    - 多个Bean实现同一接口时指定注入顺序
    - AOP切面的执行顺序

  - 使用：

    ```java
    @Component
    @Order(1)
    public class ValidationFilter implements Filter { ... }

@ApplicationScope
- 作用：定义 Bean 的作用域为 ServletContext 级别
@Scope：Bean作用域注解
- 作用：@Scope注解用于定义Bean的作用域。它支持以下几种作用域：
- 取值
  - Singleton：单例作用域，Spring容器中只有一个实例（默认值）。
  - Prototype：原型作用域，每次请求都会创建一个新的实例。
  - Session：会话作用域，每个用户会话对应一个实例。
  - Request：请求作用域，每个HTTP请求对应一个实例。
- 使用：
  1
  2
  3
  4
  5
  6
  7
  @Component
  @Scope("prototype")
  public class MyComponent {
  public void doSomething() {
  System.out.println("Doing something...");
  }
  }
  在上述代码中，MyComponent类被标记为原型作用域。这意味着每次请求该Bean时，Spring都会创建一个新的实例。这种方式适用于需要独立实例的场景，例如工具类或状态管理类。通过@Scope注解，开发者可以灵活地控制Bean的生命周期，从而更好地满足应用的需求。
- 扩展：
  
  @RequestScope / @SessionScope / @ApplicationScope
  - 作用：Web作用域的快捷注解（Spring 4+）
  - 等价于：@Scope("request"), @Scope("session"), @Scope("application")
@PostConstruct
- 作用：@PostConstruct注解用于定义Bean初始化后的方法。被标记的方法会在Bean实例化并注入依赖后自动执行，通常用于执行初始化逻辑。
- 使用：
  1
  2
  3
  4
  5
  6
  7
  @Component
  public class MyComponent {
  @PostConstruct
  public void init() {
  System.out.println("Bean initialized...");
  }
  }
  MyComponent类的init()方法被标记为初始化后执行。这意味着在Bean实例化并注入依赖后，Spring会自动调用该方法。这种方式使得开发者可以在Bean初始化阶段执行必要的逻辑，例如资源分配或状态初始化。通过这种方式，开发者可以确保Bean在使用前处于正确的状态。
@PreDestroy
- 作用：@PreDestroy注解用于定义Bean销毁前的方法。被标记的方法会在Bean销毁前自动执行，通常用于执行清理逻辑。
- 使用和@PostConstruct类似
@DependsOn：依赖关系管理
- 作用：强制指定当前Bean的依赖项，确保依赖项先初始化
- 使用
  1
  2
  3
  @Bean
  @DependsOn("databaseInitializer")
  public DataSource dataSource() { ... }
@Description
- 作用：为Bean添加描述信息（通常用于JMX等管理场景）
@Value
- 作用：在Spring应用中，配置文件（如application.properties）通常用于存储应用的配置信息。通过@Value注解，开发者可以将配置文件中的属性值注入到Bean中。
  - ${}：从Environment中取值
  - #{}：SpEL表达式
- 使用：
  1
  2
  3
  4
  5
  @Component
  public class MyComponent {
  @Value("${my.property}")
  private String property;
  }
  在上述代码中，@Value注解将配置文件中的my.property属性值注入到property字段中。这种方式使得开发者可以灵活地从配置文件中读取配置信息，而无需手动解析配置文件。通过这种方式，开发者可以实现配置的动态化管理，从而增强应用的灵活性。
@Profile
- 作用：在多环境开发中，某些Bean可能仅在特定环境下需要被加载。通过@Profile注解，开发者可以定义Bean所属的环境，例如开发环境（dev）、测试环境（test）或生产环境（prod）。

Import组件导入

@Import：导入其他配置类或组件（如@Configuration类）

作用：将配置类、普通类或其他组件导入到当前 Spring 容器中，支持导入 @Configuration 类、ImportSelector 实现类和 ImportBeanDefinitionRegistrar 实现类

使用：

@Import(SomeService.class)
@Configuration
public class AppConfig {
    // ...
}

这样，SomeService 类就会被注册为 Spring 容器中的一个 bean。

使用ImportSelector动态导入

ImportSelector 是一个接口，可以实现动态选择要导入的类：

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 根据条件动态返回要导入的类
        return new String[] {
            "com.example.ServiceA",
            "com.example.ServiceB"
        };
    }
}

@Import(MyImportSelector.class)
@Configuration
public class AppConfig {
    // ...
}

@ImportResource

作用：导入 XML 配置文件

使用：

1
2
3

@Configuration
@ImportResource("classpath:legacy-config.xml")
public class HybridConfig { ... }

依赖注入注解

@Autowired
- 作用：自动注入依赖（默认按类型匹配），@Autowired 是 Spring 中最常用的依赖注入注解，其主要功能是自动装配 Bean。它可以作用于构造函数、字段、方法之上。默认情况下，它会依据类型进行自动装配，如果存在多个相同类型的 Bean，就会抛出异常。

@Qualifier

作用：当存在多个相同类型的 Bean 时，@Autowired 仅依据类型注入会产生歧义，此时就需要使用 @Qualifier 注解来指定要注入的 Bean 的名称，以此解决歧义问题。

使用场景：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

interface MyComponent {}

class MyComponentImpl1 implements MyComponent {}

class MyComponentImpl2 implements MyComponent {}

@Service
public class MyService {
    private MyComponent myComponent;

    @Autowired
    @Qualifier("myComponentImpl1")
    public MyService(MyComponent myComponent) {
        this.myComponent = myComponent;
    }
    // 其他方法
}

@Resource
- 作用：它默认按照名称进行注入，如果找不到匹配的名称，就会按照类型进行注入。是Java标准注解，用于按名称注入依赖关系。与@Autowired类似，@Resource也可以用于字段、构造函数或方法。不同之处在于，@Resource支持通过name属性指定注入的Bean名称，这在存在多个同类型Bean时非常有用。
@Inject
- 作用：@Inject是Java标准注解，用于声明依赖注入。它与@Autowired功能类似都是依据类型进行注入，但遵循Java标准规范。不过，@Inject 没有 required 属性，即默认情况下注入的 Bean 必须存在。在Spring环境中，@Inject和@Autowired可以互换使用，但在某些情况下（例如与Java EE集成时），@Inject可能是更好的选择。
@Value
- 作用：@Value 注解主要用于将外部配置的值注入到 Bean 的字段中，这些外部配置可以来自属性文件、环境变量等。（如@Value("${key}")或 SpEL 表达式）
@Primary
- 作用：当容器中存在多个相同类型的 Bean 时，使用 @Autowired 进行依赖注入会产生歧义。@Primary 注解的作用就是指定在这种情况下优先注入被该注解标记的 Bean。

@Required

作用：@Required 注解用于标记 Bean 的属性为必需的，即要求在配置 Bean 时必须为该属性注入值。不过，从 Spring 5.1 开始，该注解已被标记为过时，推荐使用构造器注入来确保依赖的必需性。

使用：构造器注入能在对象创建时就确保依赖的注入，避免了在运行时出现依赖未注入的问题，提高了代码的健壮性。

import org.springframework.stereotype.Component;

@Component
class MyBean {
    private final String requiredProperty;

    public MyBean(String requiredProperty) {
        this.requiredProperty = requiredProperty;
    }
}

@Lookup
- 作用：@Lookup 注解用于声明查找方法，主要用于获取原型作用域的 Bean。在 Spring 中，单例 Bean 默认会在容器启动时创建，并且在整个应用生命周期中只有一个实例。而原型作用域的 Bean 每次被请求时都会创建一个新的实例。当单例 Bean 需要使用原型作用域的 Bean 时，使用 @Lookup 注解可以确保每次获取到的都是新的原型 Bean 实例。

AOP与切面编程

@Aspect
- 作用：该注解用于把一个类标记为切面类。切面类里包含了切入点和通知，这些可以对特定的方法进行增强。
@Pointcut
- 作用：@Pointcut 注解用于定义切点表达式，以此指定切入点。切入点明确了在哪些方法执行时会触发通知。
@Before
- 作用：@Before 注解定义的是前置通知，它会在目标方法执行之前执行。
@After
- 作用：@After 注解定义的是后置通知，无论目标方法是否抛出异常，它都会在目标方法执行之后执行。
@AfterReturning
- 作用：@AfterReturning 注解定义的是返回通知，它会在目标方法成功返回后执行。
@AfterThrowing
- 作用：@AfterThrowing 注解定义的是异常通知，它会在目标方法抛出异常后执行
@Around
- 作用：@Around 注解定义的是环绕通知，它能够完全控制目标方法的执行，既可以在目标方法执行前后添加额外的逻辑，还能决定是否执行目标方法。
@EnableAspectJAutoProxy
- 作用：@EnableAspectJAutoProxy 注解用于启用 AspectJ 自动代理功能，它需要和 @Configuration 注解一起使用，这样 Spring 就能自动识别并应用切面类。

@DeclareParents

作用：@DeclareParents 注解用于引入其他接口到目标类，从而实现接口增强。通过这个注解，目标类可以在不修改原有代码的情况下拥有新的接口和实现。

使用：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
import org.springframework.stereotype.Component;

interface NewFeature {
    void performNewFeature();
}

class NewFeatureImpl implements NewFeature {
    @Override
    public void performNewFeature() {
        System.out.println("Performing new feature");
    }
}

@Aspect
@Component
public class IntroductionAspect {
    @DeclareParents(value = "com.example.service.*+", defaultImpl = NewFeatureImpl.class)
    public static NewFeature newFeature;
}

在这个例子中，IntroductionAspect 切面类使用 @DeclareParents 注解将 NewFeature 接口引入到 com.example.service 包下的所有类中，默认实现为 NewFeatureImpl 类。

JSON常用注解

@JsonIgnoreProperties

作用：此注解是类注解，作用是json序列化时将java bean中的一些属性忽略掉，序列化和反序列化都受影响。

使用：

//生成json时将name和age属性过滤
@JsonIgnoreProperties({"name"},{"age"})
public class  user {
 
    private  String name;
    private int age;
}

@JsonIgnore
- 作用：此注解用于属性或者方法上（最好是属性上），作用和上面的@JsonIgnoreProperties一样。
@JsonFormat
- 作用：此注解用于属性或者方法上（最好是属性上），格式化日期/时间类型字段
- 参数：
  - shape：数据类型（如Shape.STRING）
  - pattern：自定义格式（如"yyyy-MM-dd HH:mm"）
- 使用：
  1
  2
  3
  4
  public class Event {
  @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy/MM/dd")
  private LocalDate eventDate;
  }
@JsonInclude
- 作用：控制序列化时包含属性的规则
- 取值：
  - Include.NON_NULL：排除null值
  - Include.NON_EMPTY：排除空值/空集合
@JsonSerialize
- 作用：@JsonSerialize 注解通常用在属性或者 getter 方法上，其主要作用是在对象序列化为 JSON 格式时，嵌入自定义的序列化逻辑。在处理一些特殊类型的数据或者需要对数据进行特定格式转换时，这个注解就非常有用
@JsonDeserialize
- 作用：@JsonDeserialize 注解用于属性或者 setter 方法上，它的作用是在将 JSON 数据反序列化为 Java 对象时，嵌入自定义的反序列化逻辑。当 JSON 数据的格式和 Java 对象的属性类型不完全匹配，或者需要对数据进行一些预处理时，就可以使用这个注解。
@Transient
- 作用：在使用对象关系映射（ORM）框架（如 Hibernate）时，如果一个 Java 类的属性并非对应数据库表中的字段，就需要使用 @Transient 注解来标记这个属性。如果不标记，ORM 框架默认会将其视为数据库表字段，可能会导致错误。
@JsonIgnoreType
- 作用：@JsonIgnoreType 注解标注在类上，当其他类将该类作为属性时，这个属性在序列化过程中会被忽略，不会出现在生成的 JSON 数据中

事件，异步与定时任务

@EnableAsync
- 作用：配置类中通过此注解开启对异步任务的支持；当你在配置类上添加了这个注解后，Spring 会自动扫描带有 @Async 注解的方法，并将这些方法的执行交给线程池来处理，从而实现异步执行。

@Async：

作用：@Async 注解用于标记一个方法为异步方法。当调用这个方法时，Spring 会将该方法的执行从当前线程中分离出来，放到线程池中异步执行，调用者线程不会被阻塞，可以继续执行后续的代码。

使用：

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    @Async
    public void asyncMethod() {
        try {
            // 模拟耗时操作
            Thread.sleep(3000);
            System.out.println("异步方法执行完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在调用 asyncMethod 时，调用者线程不会等待该方法执行完毕，而是会继续执行后续代码。

@EnableScheduling
- 作用：此注解同样用在配置类上，用于开启 Spring 的定时任务调度功能。添加该注解后，Spring 会自动扫描带有 @Scheduled 注解的方法，并按照指定的时间规则定时执行这些方法。
@Scheduled：
- 作用：@Scheduled 注解用于标记一个方法为定时任务方法，它可以指定方法的执行时间规则。该注解支持多种时间表达式，常见的有 fixedRate、fixedDelay 和 cron 等。
- 属性：
  - fixedRate：指定方法执行的时间间隔，单位为毫秒。无论方法执行时间长短，下一次执行都会在上一次开始后的指定时间间隔后启动。
  - fixedDelay：指定方法执行完成后，下一次执行的延迟时间，单位为毫秒。即上一次方法执行完毕后，等待指定的时间再执行下一次。
  - cron：使用 Cron 表达式来指定方法的执行时间，Cron 表达式可以更灵活地定义执行时间规则。

Enable***注解

这些注解主要是用来开启对xxx的支持：

@EnableAspectAutoProxy：开启对AspectJ自动代理的支持；
@EnableAsync：开启异步方法的支持；
@EnableScheduling：开启计划任务的支持；
@EnableWebMvc：开启web MVC的配置支持；
@EnableConfigurationProperties：开启对@ConfigurationProperties注解配置Bean的支持；
@EnableJpaRepositories：开启对SpringData JPA Repository的支持；
@EnableTransactionManagement：开启注解式事务的支持；
@EnableCaching：开启注解式的缓存支持；

测试相关

@RunWith
- 作用：运行器，Spring中通常用于对JUnit的支持
@ContextConfiguration
- 作用：用来加载配置配置文件，其中classes属性用来加载配置类。
- 使用
  1
  2
  3
  4
  @RunWith(SpringJUnit4ClassRunner.class)
  @ContextConfiguration(locations = {"classpath*:/*.xml"})
  public class CDPlayerTest {
  }
  @ContextConfiguration这个注解通常与@RunWith(SpringJUnit4ClassRunner.class)联合使用用来测试。
  
  @ContextConfiguration括号里的locations = {“classpath:/.xml”}就表示将classpath路径里所有的xml文件都包括进来，自动扫描的bean就可以拿到，此时就可以在测试类中使用@Autowired注解来获取之前自动扫描包下的所有bean。
@SpringBootTest
- 作用：启动完整Spring应用上下文
- 参数：
  - webEnvironment：定义Web环境模式
  - classes：显式指定配置类
- 示例：
  1
  2
  @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
  class ApplicationIntegrationTests { ... }

@MockBean

作用：向应用上下文注入Mock对象（替换现有Bean）
示例：

@SpringBootTest
class UserServiceTest {
    @MockBean
    private UserRepository userRepository;
    
    @Autowired
    private UserService userService;
}

@SpyBean
- 作用：对现有Bean进行部分Mock（保留原始实现）
- 示例：
1
2
@SpyBean
private EmailService emailService;

@TestConfiguration

作用：定义测试专用的配置类

示例

@TestConfiguration
static class TestConfig {
    @Bean
    public Clock testClock() {
        return Clock.fixed(Instant.now(), ZoneId.systemDefault());
    }
}

其他注解

@EqualsAndHashCode（Lombok）
- 作用：自动生成 equals() 和 hashCode() 方法，避免手动编写冗余代码。
- 参数：
  - callSuper：是否包含父类的字段（默认false）。若为true，生成的方法会调用super.equals()。
  - exclude/of：排除或指定参与计算的字段。
- 注意：需添加 Lombok 依赖
- 使用
  1
  2
  3
  4
  5
  @EqualsAndHashCode(callSuper = true, exclude = "age")
  public class Person extends Human {
  private String name;
  private int age;
  }
@XmlAccessorType (JAXB)
- 作用：控制 JAXB 如何将 Java 对象与 XML 互相转换，指定字段/属性的访问方式。类级别的注解，定义这个类中何种类型需要映射到XML。
- 属性：
  - XmlAccessType.FIELD：映射这个类中的所有字段到XML
  - XmlAccessType.PROPERTY：映射这个类中的属性（get/set方法）到XML
  - XmlAccessType.PUBLIC_MEMBER：将这个类中的所有public的field或property同时映射到XML（默认）
  - XmlAccessType.NONE：不映射

引用自Spring Framework 的详细注解大全的注解表格

核心容器与配置

注解	说明
`@Configuration`	标记类为配置类，替代 XML 配置
`@Bean`	在配置类中声明一个 Bean，由 Spring 容器管理
`@Component`	通用组件注解，标记类为 Spring 管理的 Bean
`@ComponentScan`	自动扫描并注册指定包下的组件（如`@Component`、`@Service`等）
`@Import`	导入其他配置类或组件（如`@Configuration`类）
`@PropertySource`	加载外部属性文件（如`.properties`或`.yml`）
`@Lazy`	延迟初始化 Bean
`@Scope`	定义 Bean 的作用域（如`singleton` 、`prototype` 、`request`等）
`@DependsOn`	指定当前 Bean 依赖的其他 Bean，确保初始化顺序
`@Profile`	指定 Bean 或配置仅在特定环境下生效（如`dev`、`prod`）
`@Conditional`	基于条件决定是否注册 Bean（自定义条件逻辑）
`@Service`	标记服务层组件（`@Component`的特化）
`@Repository`	标记数据访问层组件（`@Component`的特化），支持异常转换
`@Controller`	标记 MVC 控制器组件（`@Component`的特化）
`@Role`	定义 Bean 的角色（如`ROLE_APPLICATION` 、`ROLE_INFRASTRUCTURE`）
`@Description`	为 Bean 添加描述信息（通常用于监控或文档）
`@PropertySources`	组合多个`@PropertySource`
`@ImportResource`	导入 XML 配置文件
`@Order`	定义 Bean 的加载顺序（值越小优先级越高）
`@AliasFor`	为注解属性声明别名（用于元注解组合）
`@RequestScope`	定义 Bean 的作用域为 HTTP 请求级别
`@SessionScope`	定义 Bean 的作用域为 HTTP 会话级别
`@ApplicationScope`	定义 Bean 的作用域为 ServletContext 级别

依赖注入（DI）

注解	说明
`@Autowired`	自动注入依赖（默认按类型匹配）
`@Qualifier`	按名称指定注入的 Bean，配合`@Autowired`使用
`@Primary`	当存在多个同类型 Bean 时，优先注入被标记的 Bean
`@Value`	注入属性值（如`@Value("${key}")`或 SpEL 表达式）
`@Required`	标记 Bean 属性为必需（已过时，推荐使用构造器注入）
`@Lookup`	声明查找方法，用于获取原型作用域的 Bean
`@Resource`	JSR-250 注解，按名称注入依赖（类似`@Autowired` + `@Qualifier`）
`@Inject`	JSR-330 注解（需引入`javax.inject`），功能类似`@Autowired`

AOP 与切面编程

注解	说明
`@Aspect`	标记类为切面类
`@Pointcut`	定义切点表达式，指定切入点
`@Before`	在目标方法执行前执行
`@After`	在目标方法执行后执行（无论是否抛出异常）
`@AfterReturning`	在目标方法成功返回后执行
`@AfterThrowing`	在目标方法抛出异常后执行
`@Around`	环绕通知，可完全控制目标方法执行
`@EnableAspectJAutoProxy`	启用 AspectJ 自动代理（需配合`@Configuration`）
`@DeclareParents`	引入其他接口到目标类（实现接口增强）

数据访问与事务

注解	说明
`@Transactional`	声明事务管理（类或方法级别），可配置隔离级别、传播行为等
`@Repository`	标记数据访问层（DAO）组件，支持异常转换（如将 SQL 异常转换为 Spring 异常）
`@PersistenceContext`	注入 JPA 的`EntityManager`
`@PersistenceUnit`	注入 JPA 的`EntityManagerFactory`
`@Sql`	在测试方法执行前 / 后运行 SQL 脚本
`@SqlMergeMode`	控制测试类与方法的`@Sql`注解合并方式

Web/MVC 相关

注解	说明
`@Controller`	标记类为 MVC 控制器
`@RequestMapping`	映射 HTTP 请求路径（支持`method` 、`produces`等属性）
`@RequestParam`	绑定请求参数到方法参数
`@PathVariable`	绑定 URL 路径变量到方法参数
`@RequestBody`	将请求体反序列化为对象（如 JSON/XML）
`@ResponseBody`	将方法返回值序列化为响应体（如 JSON）
`@ModelAttribute`	绑定请求参数到模型对象，或添加模型数据
`@SessionAttributes`	将模型属性存储到 HTTP Session 中
`@CookieValue`	绑定 Cookie 值到方法参数
`@RequestHeader`	绑定请求头到方法参数
`@ExceptionHandler`	处理控制器内的异常
`@ControllerAdvice`	全局异常处理类，可结合`@ExceptionHandler`
`@InitBinder`	自定义请求参数绑定逻辑
`@CrossOrigin`	允许跨域请求（Spring 4.2 + 支持）
`@RestController`	组合`@Controller`和`@ResponseBody`（Spring 4.0+）
`@GetMapping`/`@PostMapping`	`@RequestMapping`的快捷方式（如`@GetMapping("/path")`）
`@PutMapping`	`@RequestMapping(method = PUT)`的快捷方式
`@DeleteMapping`	`@RequestMapping(method = DELETE)`的快捷方式
`@PatchMapping`	`@RequestMapping(method = PATCH)`的快捷方式
`@MatrixVariable`	绑定 URL 矩阵变量（如`/users;id=1`）
`@RestControllerAdvice`	组合`@ControllerAdvice`和`@ResponseBody`
`@ResponseStatus`	定义 HTTP 响应状态码（如`@ResponseStatus(HttpStatus.NOT_FOUND)`）

测试相关

注解	说明
`@ContextConfiguration`	指定测试类的 Spring 配置（如 XML 或配置类）
`@WebAppConfiguration`	标记测试类需要加载 Web 应用上下文
`@DirtiesContext`	标记测试后需要重置 Spring 上下文
`@TestExecutionListeners`	自定义测试执行监听器
`@TestPropertySource`	为测试类指定属性文件或键值对
`@DynamicPropertySource`	动态注册测试属性（如集成测试中的数据库端口）
`@Sql`	在测试方法执行前 / 后运行 SQL 脚本

事件与异步

注解	说明
`@EventListener`	标记方法为事件监听器（监听 Spring 事件）
`@Async`	标记方法为异步执行（需启用`@EnableAsync`）
`@EnableAsync`	启用异步方法执行支持
`@Scheduled`	定义定时任务（需启用`@EnableScheduling`）
`@EnableScheduling`	启用定时任务支持

消息与 WebSocket

注解	说明
`@MessageMapping`	映射消息到处理方法（如 WebSocket 消息）
`@SubscribeMapping`	处理订阅请求（如 STOMP 协议）
`@SendTo`	指定方法返回值的发送目标（如广播消息）
`@DestinationVariable`	绑定消息目标路径中的变量
`@MessageExceptionHandler`	处理消息处理过程中的异常

缓存相关

注解	说明
`@Cacheable`	缓存方法结果（需启用`@EnableCaching`）
`@CachePut`	更新缓存
`@CacheEvict`	清除缓存
`@Caching`	组合多个缓存操作
`@CacheConfig`	在类级别统一配置缓存属性
`@EnableCaching`	启用缓存支持

校验与格式化

注解	说明
`@Valid`	触发 Bean 验证（JSR-303/JSR-349 规范，需引入 Hibernate Validator）
`@Validated`	Spring 的校验注解，支持分组校验
`@DateTimeFormat`	格式化日期时间字段（如`@DateTimeFormat(pattern = "yyyy-MM-dd")`）
`@NumberFormat`	格式化数字字段

JSR 标准注解支持

注解	说明
`@PostConstruct`	JSR-250 注解，标记 Bean 初始化后执行的方法
`@PreDestroy`	JSR-250 注解，标记 Bean 销毁前执行的方法
`@Resource`	JSR-250 注解，按名称注入依赖（类似`@Autowired` + `@Qualifier`）
`@Inject`	JSR-330 注解（需引入`javax.inject`），功能类似`@Autowired`
`@Named`	JSR-330 注解，功能类似`@Component`或`@Qualifier`

空安全注解

注解	说明
`@NonNull`	标记字段、参数或返回值不可为`null`（编译时检查）
`@Nullable`	标记字段、参数或返回值可为`null`
`@NonNullApi`	包级别注解，默认所有参数和返回值不可为`null`
`@NonNullFields`	包级别注解，默认所有字段不可为`null`