注解汇总：Spring 常用的注解
前言
本栏目的内容已经讲完了，本案例将把案例中所有讲到的注解都汇总起来，方便日后的学习需要用到的时候能够快速的找到相应的注解。本案例将结合小案例一起做汇总，也想丹玉是再复习一遍讲过用过的注解。
一、注解汇总
1、@Component @Repository @Service @Controller 注解
| 类型 | 位置（级别） | 作用 | 属性 |
|---|---|---|---|
| @Component | 任何位置(类级别) | 标识为Spring组件 | 无 |
| @Repository | 数据访问层(类级别) | 标识持久层组件，通常用于数据库访问 | 无 |
| @Service | 服务层(类级别) | 标识业务逻辑层组件，通常用于定义服务方法 | 无 |
| @Controller | 控制器层(类级别) | 标识控制器组件，用于处理Web请求 | 通常用于处理请求映射 |
好的，让我举一个简单的案例来说明这些注解的使用。
// 一个普通的组件类
@Component
public class MyComponent {
// 一些业务逻辑
}
// 一个数据访问组件类
@Repository
public class MyRepository {
// 数据访问方法
}
// 一个服务组件类
@Service
public class MyService {
// 一些服务方法
}
// 一个控制器类
@Controller
public class MyController {
// 请求映射和处理方法
}在这个案例中，我们使用了@Component、@Repository、@Service和@Controller注解来标识不同类型的组件类。这样做有以下作用：
MyComponent类被标识为一个Spring组件，它可以被自动扫描并纳入到Spring上下文中进行管理。
MyRepository类被标识为数据访问层的组件，通常用于数据库访问，并且可以受益于Spring提供的持久化支持。
MyService类被标识为服务层的组件，它通常包含业务逻辑和服务方法，可以被其他组件所依赖和调用。
MyController类被标识为控制器组件，用于处理Web请求，通常包含请求映射和处理方法，可以接收和响应来自客户端的HTTP请求。
通过使用这些注解，Spring框架能够更好地理解和管理各个组件类的作用和职责，并能够进行相应的依赖注入和协调工作。
2、@Autowired、@Qualifier 、@Primary
| 名称 | 类型 | 位置 | 作用 | 属性 |
|---|---|---|---|---|
| @Autowired | 类级别 | 字段、构造函数、方法 | 自动装配 Bean | 无 |
| @Qualifier | 方法级别 | 参数 | 指定要注入的 Bean | value: 指定要注入的 Bean 的名称 |
| @Primary | 类级别 | 类 | 指定首选 Bean | 无 |
以下是一个简单的示例，演示了如何在 Spring 中使用 @Autowired、@Qualifier 和 @Primary 注解进行依赖注入和自动装配：
// Service 接口
public interface Service {
void execute();
}
// 实现了 Service 接口的两个具体类
@Service
public class PrimaryService implements Service {
@Override
public void execute() {
System.out.println("Executing primary service");
}
}
@Service
public class SecondaryService implements Service {
@Override
public void execute() {
System.out.println("Executing secondary service");
}
}
// 用 @Autowired 和 @Qualifier 注解进行依赖注入
@Component
public class Client {
private Service service;
@Autowired
public void setService(@Qualifier("secondaryService") Service service) {
this.service = service;
}
public void performAction() {
service.execute();
}
}
// 使用 @Primary 注解指定首选的 Bean
@Configuration
public class AppConfig {
@Bean
@Primary
public Service primaryService() {
return new PrimaryService();
}
@Bean
public Service secondaryService() {
return new SecondaryService();
}
}在上面的示例中，我们定义了一个
Service接口，并实现了两个具体的服务类：PrimaryService和SecondaryService。然后我们创建了一个Client类，在这个类中使用了@Autowired和@Qualifier注解来注入Service，并且使用了@Primary注解来指定首选的Service。在
AppConfig中，我们使用@Bean注解注册了两个Service类型的 Bean，并且使用了@Primary注解指定了primaryService作为首选的 Bean。通过这个示例，我们展示了如何使用
@Autowired、@Qualifier和@Primary注解来实现依赖注入和选择首选的 Bean。
3、@Resource
| 名称 | 类型 | 位置 | 作用 | 属性 |
|---|---|---|---|---|
| @Resource | 类级别 | 字段、方法、构造函数 | 指定要注入的 Bean | name |
下面是一个简单的示例，演示了如何在 Spring 中使用 @Resource 注解进行依赖注入：
import javax.annotation.Resource;
public class CustomerService {
private CustomerDAO customerDAO;
@Resource
public void setCustomerDAO(CustomerDAO customerDAO) {
this.customerDAO = customerDAO;
}
public void saveCustomer(Customer customer) {
// 调用 customerDAO 对象的方法保存客户信息
customerDAO.save(customer);
}
}
public class CustomerDAO {
public void save(Customer customer) {
// 保存客户信息到数据库
}
}在上面的示例中，
CustomerService类有一个名为customerDAO的成员变量，并使用@Resource注解标记了setCustomerDAO方法。通过这个注解，Spring 将会自动注入一个符合类型的 Bean 到customerDAO中。在这个示例中，
CustomerDAO是一个简单的数据访问对象，被CustomerService使用来保存客户信息。通过使用@Resource注解，我们可以告诉 Spring 容器要注入哪个具体的CustomerDAO实例进入CustomerService中，从而实现依赖注入。
当使用 @Resource 注解时，可以通过指定 name 属性来指定要注入的 Bean 的名称。下面是一个示例：
import javax.annotation.Resource;
public class CustomerService {
@Resource(name = "myCustomerDAO")
private CustomerDAO customerDAO;
public void saveCustomer(Customer customer) {
// 调用 customerDAO 对象的方法保存客户信息
customerDAO.save(customer);
}
}
public class CustomerDAO {
public void save(Customer customer) {
// 保存客户信息到数据库
}
}在这个示例中，我们使用
@Resource(name = "myCustomerDAO")注解来标记customerDAO字段，并指定了name属性为"myCustomerDAO"。这样一来，Spring 容器会尝试找到一个名为"myCustomerDAO"的 Bean，并将其注入到customerDAO字段中。通过指定
name属性，我们可以精确地指定要注入的 Bean 的名称，从而实现更加灵活和精确的依赖注入行为。
4、 @inject、@Named 、@RequiredArgsConstructor
| 类型 | 位置（级别） | 作用 | 属性 |
|---|---|---|---|
| @Inject | 类成员、方法参数 | 标识依赖注入的目标点，用于注入依赖对象 | 无 |
| @Named | 类成员、方法参数 | 为依赖注入指定自定义的名称 | value属性，指定注入对象的名称 |
| @RequiredArgsConstructor | 类 | 生成包含所有参数的构造函数 | 无 |
以上是常见的Java依赖注入相关注解类型，它们在不同的位置（级别）和作用上有着不同的含义和用途。通过使用这些注解，我们可以实现更灵活和精确的依赖注入。
让我通过一个简单的案例来说明这些注解的使用。
import javax.inject.Inject;
import javax.inject.Named;
import lombok.RequiredArgsConstructor;
@Named("myBean")
public class MyBean {
private final MyDependency dependency;
@Inject
public MyBean(MyDependency dependency) {
this.dependency = dependency;
}
// 其他方法
}
@Named
public class MyDependency {
// 一些逻辑
}在这个案例中，我们使用了@Inject、@Named和@RequiredArgsConstructor注解来实现依赖注入和构造函数自动注入。
@Inject注解用于标识构造函数，告知容器在创建MyBean实例时需要注入MyDependency对象。@Named("myBean")注解用于给MyBean类指定一个特定的名称，以便在依赖注入时进行标识。@RequiredArgsConstructor注解在MyBean类上使用，它会生成一个包含所有参数的构造函数，这样就不需要手动编写构造函数。
通过这些注解的使用，我们可以实现依赖注入并且指定具体的依赖对象名称，同时也能简化构造函数的编写。
5、@Scope
| 注解 | 类型 | 使用位置 | 作用 | 属性 |
|---|---|---|---|---|
| @Scope | 单例/原型 | 类级别 | 指定Bean的作用域 | value, proxyMode等 |
@Scope注解用于指定Spring容器中托管的bean的作用域。它可以帮助开发人员控制bean实例的创建和销毁方式，从而影响bean在应用程序中的生命周期管理。
常用的作用域类型包括单例（Singleton）和原型（Prototype）。单例作用域表示在整个应用程序中只会创建一个该类型的bean实例，而原型作用域表示每次注入或获取bean时都会创建一个新的实例。
@Scope注解可以用在类级别，用来标识一个类是一个bean，并指定其作用域。以下是一个示例：
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
@Scope("prototype")
public class MyPrototypeBean {
// Bean的定义
}在这个示例中，@Scope注解被用来声明MyPrototypeBean的作用域为原型（Prototype），这意味着每次获取该bean时都会创建一个新的实例。
除了作用域值之外，@Scope注解还可以使用proxyMode属性来控制对Scoped Proxy的创建方式。这在解决作用域问题时可能会很有用，特别是对于一些复杂的AOP代理情形。
总的来说，@Scope注解提供了一种灵活的方式来管理Spring bean的作用域，使开发人员可以根据具体需求来控制bean的生命周期和实例化方式。
让我们来编写一个小案例来演示如何在Spring中使用@Scope注解的属性。假设我们有一个简单的服务类，我们将使用@Scope注解来指定其作用域为原型（Prototype），并通过属性proxyMode来控制代理模式。
import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.stereotype.Service;
@Service
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class MyPrototypeService {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}在上面的示例中，我们创建了一个名为MyPrototypeService的服务类，并使用@Scope注解来声明其作用域为原型（Prototype），同时通过属性proxyMode来指定代理模式为TARGET_CLASS。
6、@Configuration、@ComponentScan 、 @Bean
| 注解 | 位置（级别） | 作用 | 属性 |
|---|---|---|---|
| @Configuration | 类 | 标识类为配置类，用于定义应用程序上下文的配置信息 | 无或proxyBeanMethods |
| @ComponentScan | 类 | 启用组件扫描，自动发现并注册Spring组件 | value属性，指定扫描的包路径 |
| @Bean | 方法 | 声明一个由Spring容器管理的Bean，用于手动注册Bean | name属性，指定Bean的名称 |
让我通过一个简单的案例来说明@Configuration、@ComponentScan和@Bean注解的使用。
假设我们有一个简单的Spring应用，其中包含以下类：
public class MyService {
// 一些服务方法
}
@Configuration
@ComponentScan("com.example")
public class AppConfig {
@Bean
public MyService myService() {
return new MyService();
}
}在这个案例中，我们使用了
@Configuration注解来标识AppConfig类为配置类，用于定义应用程序上下文的配置信息。而@ComponentScan("com.example")注解用于启用组件扫描，自动发现并注册位于com.example包下的Spring组件。在
AppConfig类中，我们还使用了@Bean注解声明了一个名为myService的Bean，该Bean由Spring容器管理，并且是MyService类的实例化对象。通过这样的配置，Spring框架会在应用启动时自动扫描
com.example包下的组件，并将MyService类注册为一个Bean，同时AppConfig类中声明的myService方法也会被识别为Bean的配置方法。
@Configuration（无或proxyBeanMethods）：@Configuration 注解中的 proxyBeanMethods 属性是用来控制对 @Bean 方法的代理行为的。当设置为 true 时（默认值），Spring 会对 @Bean 方法进行代理以实现特定的行为，例如单例模式和依赖注入。而当设置为 false 时，将禁用方法代理，每次调用 @Bean 方法都会返回一个新的 bean 实例。
@Configuration(proxyBeanMethods = false)
public class AppConfig {
@Bean
public MyService myService() {
return new MyService();
}
}在这个示例中，我们显式地将
proxyBeanMethods设置为false，这意味着每次调用myService()方法都会返回一个新的MyService实例，而不再是单例模式。通常情况下，我们不需要显式地设置这个属性，因为默认值已经满足了大多数场景的需求。如果将
proxyBeanMethods属性设置为true（默认值），那么Spring会对@Bean方法进行代理以实现特定的行为，例如单例模式和依赖注入。如果将其设置为false，则禁用方法代理，每次调用@Bean方法都会返回一个新的 bean 实例。因此，实际上，
@Configuration注解的属性是指定当前配置类中@Bean方法的代理行为。这一点在实际开发中可能会对应用程序的性能和行为产生影响，开发人员需要根据具体情况来决定是否需要显式地设置这个属性值。
7、 @Import
| 注解 | 位置（级别） | 作用 | 属性 |
|---|---|---|---|
| @Import | 类 | 在配置类中引入其他配置类，实现配置类之间的组合和复用 | value属性，指定要导入的配置类 |
让我通过一个简单的案例来说明@Import注解的使用。
@Configuration
public class DatabaseConfig {
// 数据库相关配置
}
@Configuration
public class SecurityConfig {
// 安全相关配置
} 现在，我们想要创建一个新的配置类 AppConfig，并在其中引入 DatabaseConfig 和 SecurityConfig，可以使用 @Import 注解来实现：
@Configuration
@Import({DatabaseConfig.class, SecurityConfig.class})
public class AppConfig {
// 其他配置
}在这个案例中，
@Import注解被用于在AppConfig中引入了DatabaseConfig和SecurityConfig，从而将它们的配置内容组合到了AppConfig中，实现了配置类之间的组合和复用。通过这样的配置，
AppConfig将会包含DatabaseConfig和SecurityConfig中的所有配置内容，使得应用程序的各个配置信息能够集中在一个地方进行管理。
7、@PropertySource 和 @Value
| 注解 | 位置（级别） | 作用 | 属性 |
|---|---|---|---|
| @PropertySource | 类 | 用于指定属性文件的位置 | value属性，指定属性文件的位置 |
| @Value | 字段、方法、构造器 | 用于注入配置文件中的属性值到Java类中 | value属性，指定要注入的属性键 |
让我通过一个简单的案例来说明@PropertySource和@Value注解的使用。
app.name=MyApp
app.version=1.0 现在，我们希望在一个Spring组件中使用这些属性值。首先，我们需要在配置类中使用 @PropertySource 指定属性文件的位置，然后使用 @Value 注入属性值到对应的字段中。
@Configuration
@PropertySource("classpath:app.properties")
public class AppConfig {
@Value("${app.name}")
private String appName;
@Value("${app.version}")
private String appVersion;
// 其他配置
}在这个案例中，
@PropertySource注解用于指定属性文件app.properties的位置为 classpath 下，而@Value注解则被用于将配置文件中的属性值注入到对应的字段appName和appVersion中。通过这样的配置，Spring框架会在启动时加载
app.properties文件，并将其中定义的属性值注入到相应的字段中，使得我们可以在应用程序中直接使用这些属性值。
8、@Aspect、@EnableAspectJAutoProxy
| 注解名称 | 类型 | 位置 | 作用 | 属性 |
|---|---|---|---|---|
| @Aspect | 类级别 | 类 | 声明当前类为切面类 | 无 |
| @EnableAspectJAutoProxy | 类级别 | 配置类 | 启用 AspectJ 自动代理 | proxyTargetClass, exposeProxy, order |
让我给你一个简单的例子来演示如何使用 @Aspect 和 @EnableAspectJAutoProxy 注解。
@Aspect
@Component
public class LoggingAspect {
@Before("execution(* com.example.service.*.*(..))")
public void beforeAdvice() {
System.out.println("Before method execution: Logging the method");
}
}上面的代码定义了一个切面类 LoggingAspect，并在其中定义了一个前置通知（before advice），在目标方法执行前打印日志。
接下来，我们创建一个配置类，使用 @EnableAspectJAutoProxy 注解启用 AspectJ 自动代理：
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
// 这里可以定义其他的 bean 或者配置
} 在这个配置类中，我们使用了 @EnableAspectJAutoProxy 注解来启用对切面的支持。
1）@EnableAspectJAutoProxy的各个属性有什么用？
@EnableAspectJAutoProxy是Spring中用于启用基于AspectJ的自动代理功能的注解。它可以应用在@Configuration类上，用来开启对使用@Aspect注解定义的切面的自动代理支持。这样一来，Spring容器会自动为这些切面创建代理，并将其应用到相应的目标对象上。
@EnableAspectJAutoProxy注解有一些属性，主要用于配置自动代理的行为。以下是@EnableAspectJAutoProxy的各个属性及其作用：
proxyTargetClass
- 类型：boolean
- 默认值：false
- 作用：指定是否强制使用CGLIB代理，而不是默认的基于接口的JDK动态代理。当设为true时，将总是使用CGLIB代理，即使被代理的类实现了接口。
exposeProxy
- 类型：boolean
- 默认值：false
- 作用：指定是否暴露代理对象到AopContext中，允许在切面内部通过AopContext.currentProxy()方法访问当前代理对象。这在需要在切面内部调用其他切面方法时可能会有用。
proxyTargetClass
- 类型：boolean
- 默认值：false
- 作用：指定是否强制使用CGLIB代理，而不是默认的基于接口的JDK动态代理。当设为true时，将总是使用CGLIB代理，即使被代理的类实现了接口。
这些属性提供了对自动代理行为的细粒度控制，例如选择代理类型（CGLIB或JDK动态代理）以及是否暴露代理对象到AopContext中。通过合理地配置这些属性，开发人员可以根据具体需求来调整自动代理的行为，以满足不同的业务场景和性能要求。
8、@EventListener
| 注解名称 | 类型 | 位置 | 作用 | 属性 |
|---|---|---|---|---|
| @EventListener | 方法级别 | 方法 | 声明方法作为一个事件监听器 | condition, fallbackExecution |
案例：
/**
* @Date 2023-10-13
* @Author qiu
* 自定义事件监听器，用于监听用户发布的事件并进行处理，
* 监听器需要纳入容器管理
*/
@Slf4j
@Component
public class MyEventListener {
/**
* 自定义事件监听方法，容器会将用户发布的
* 事件对象传入这个方法中进行事件处理
*
* @EventListener 用于标识当前方法为监听方法
*
* @param event
*/
@EventListener
public void handlerEvent(MyEvent event) {
log.info("处理事件：" + event.getMessage());
}
}该类中定义了一个名为handlerEvent的方法，并使用了@EventListener注解。这个注解表示该方法是一个事件监听器，用来处理特定类型的事件。在示例中，它处理类型为MyEvent的事件。
当应用程序触发一个MyEvent事件时，Spring框架会自动调用handlerEvent方法，并将触发的事件作为参数传递给该方法。方法内部通过日志记录器打印了处理事件的消息。
通过使用Spring的事件机制，可以实现模块之间的松耦合，让不同部分的代码能够响应和处理特定类型的事件。在其他地方触发MyEvent事件时，MyEventListener中的handlerEvent方法会被自动调用，从而实现事件的处理逻辑。
1）@EventListener的各个属性有什么用
@EventListener注解用于将一个方法标记为事件监听器，以便在应用程序中接收并响应特定类型的事件。@EventListener注解有一些属性可以用来配置事件监听器的行为。让我来解释一下这些属性及其用途：
condition
- 类型：String
- 默认值：""
- 作用：允许指定一个SpEL表达式作为条件，只有当条件表达式为true时，才会触发该事件监听器。这样可以根据具体的条件来决定是否执行监听方法。
fallbackExecution
- 类型：boolean
- 默认值：false
- 作用：指定当处理事件时是否应该捕获并记录任何异常，而不是让它们传播回调用者。当设置为true时，如果事件监听器方法抛出异常，Spring会捕获并记录异常，而不会向上传播。
async
- 类型：boolean
- 默认值：false
- 作用：指示是否异步地执行事件处理方法。当设置为true时，事件处理方法将在单独的线程中异步执行，而不会阻塞事件发布的线程。
通过合理地配置这些属性，开发人员可以根据具体的需求来控制事件监听器的行为。例如，可以使用condition属性来根据特定条件选择性地触发事件监听器，使用async属性来异步处理事件，以提高系统的响应性能。同时，fallbackExecution属性也提供了一种方式来处理事件监听器方法可能抛出的异常。
9、@EnableScheduling、@Scheduled
| 注解名称 | 类型 | 位置 | 作用 | 属性 |
|---|---|---|---|---|
| @EnableScheduling | 类级别 | 配置类 | 启用计划任务调度 | 无 |
| @Scheduled | 方法级别 | 方法 | 声明方法作为定时任务 | cron, zone, fixedDelay, fixedRate, initialDelay, etc. |
让我给你一个简单的例子来演示如何使用 @EnableScheduling 和 @Scheduled 注解。
首先，我们创建一个配置类 SchedulingConfig，并在其中使用 @EnableScheduling 注解启用计划任务调度：
@Configuration
@EnableScheduling
public class SchedulingConfig {
// 这里可以定义其他的 bean 或者配置
} 接下来，创建一个服务类 MyScheduledService，并在其中定义一个定时任务方法，使用 @Scheduled 注解标识：
@Service
public class MyScheduledService {
@Scheduled(fixedRate = 2000) // 每隔2秒执行一次
public void performTask() {
System.out.println("Task performed at " + new Date());
}
}在上面的代码中，performTask 方法被标注为定时任务，使用 fixedRate 属性指定了每隔2秒执行一次。
在 @Scheduled 注解中，有几个常用的属性可以用来指定定时任务的执行规则：
cron：使用 cron 表达式来指定定时任务的执行时间。例如：@Scheduled(cron = "0 * * * * ?")表示每分钟执行一次。zone：指定时区，用于计算 cron 表达式中的时间。默认为服务器的时区。fixedDelay：表示在上一次任务执行结束后多长时间再次执行，单位为毫秒。例如：@Scheduled(fixedDelay = 5000)表示上一次任务执行结束后5秒再次执行。fixedRate：表示从上一次任务开始执行时算起，经过固定的时间间隔执行下一次任务，单位为毫秒。例如：@Scheduled(fixedRate = 5000)表示每隔5秒执行一次任务。initialDelay：表示首次任务执行延迟的时间，单位为毫秒。例如：@Scheduled(initialDelay = 10000, fixedRate = 5000)表示首次任务执行延迟10秒，然后每隔5秒执行一次任务。
这些属性可以根据实际需求灵活地组合和调整，以满足不同的定时任务执行需求。
来讲一下 Cron 表达式：
Cron 表达式是一种用于指定时间的字符串表达式，通常用来表示定时任务的执行时间。Cron 表达式由 6 或 7 个字段组成，每个字段之间用空格分隔，其格式如下：
<秒> <分> <时> <日> <月> <周> [年]
其中，秒、分、时、日、月 和 周 是必需的字段，它们分别表示秒、分、小时、日期、月份和星期。每个字段可以是一个具体值、一个范围、一个列表或者一个通配符。
以下是一些常用的 Cron 表达式示例：
- "0 * * * * ?" 表示每个整分钟触发一次。
- "0/5 * * * * ?" 表示每隔 5 秒钟触发一次。
- "0 0/15 8-20 * * ?" 表示每天上午 8 点到晚上 8 点之间，每隔 15 分钟触发一次。
- "0 0 12 ? * WED" 表示每个星期三的中午 12 点触发一次。
- "0 0 10,14,16 * * ?" 表示每天上午 10 点、下午 2 点和下午 4 点各触发一次。
- "0 0/30 9-17 * * MON-FRI" 表示每个工作日上午 9 点到下午 5 点之间，每隔 30 分钟触发一次。
还有一些特殊符号也可以用来表示 Cron 表达式：
- * 表示所有可能的值。
- - 表示一个范围。
- , 表示多个值，用逗号隔开。
- / 表示增量，如 0/5 表示从 0 开始，每隔 5 秒一次。
- ? 表示未指定的值，用于日和星期字段。如果日和星期都未指定，则表示每天都触发一次。
- # 表示某个月份的第几个星期几，如 2#1 表示每个月的第一个周一。
Cron 表达式非常灵活，可以根据不同的场景自由组合。但是需要注意的是，应该避免使用过于复杂的表达式，以免造成混淆和误解。
二、总结
这就是本栏目所讲的所有的注解，我把他们重新整理起来，方便日后的查找和使用，把之前讲过的重点又重新的复习了一遍。