注解汇总：Spring 常用的注解

前言

本栏目的内容已经讲完了，本案例将把案例中所有讲到的注解都汇总起来，方便日后的学习需要用到的时候能够快速的找到相应的注解。本案例将结合小案例一起做汇总，也想丹玉是再复习一遍讲过用过的注解。

一、注解汇总

1、@Component @Repository @Service @Controller 注解

 好的，让我举一个简单的案例来说明这些注解的使用。

// 一个普通的组件类
@Component
public class MyComponent {
    // 一些业务逻辑
}
 
// 一个数据访问组件类
@Repository
public class MyRepository {
    // 数据访问方法
}
 
// 一个服务组件类
@Service
public class MyService {
    // 一些服务方法
}
 
// 一个控制器类
@Controller
public class MyController {
    // 请求映射和处理方法
}

在这个案例中，我们使用了@Component、@Repository、@Service和@Controller注解来标识不同类型的组件类。这样做有以下作用：

1. MyComponent类被标识为一个Spring组件，它可以被自动扫描并纳入到Spring上下文中进行管理。

2. MyRepository类被标识为数据访问层的组件，通常用于数据库访问，并且可以受益于Spring提供的持久化支持。

3. MyService类被标识为服务层的组件，它通常包含业务逻辑和服务方法，可以被其他组件所依赖和调用。

4. MyController类被标识为控制器组件，用于处理Web请求，通常包含请求映射和处理方法，可以接收和响应来自客户端的HTTP请求。

通过使用这些注解，Spring框架能够更好地理解和管理各个组件类的作用和职责，并能够进行相应的依赖注入和协调工作。

2、@Autowired、@Qualifier 、@Primary

以下是一个简单的示例，演示了如何在 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

 下面是一个简单的示例，演示了如何在 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 

以上是常见的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注解用于指定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、@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注解的使用。

@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注解的使用。

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 注解。

@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的各个属性及其作用：

1. proxyTargetClass

   • 类型：boolean
   • 默认值：false
   • 作用：指定是否强制使用CGLIB代理，而不是默认的基于接口的JDK动态代理。当设为true时，将总是使用CGLIB代理，即使被代理的类实现了接口。

2. exposeProxy

   • 类型：boolean
   • 默认值：false
   • 作用：指定是否暴露代理对象到AopContext中，允许在切面内部通过AopContext.currentProxy()方法访问当前代理对象。这在需要在切面内部调用其他切面方法时可能会有用。

3. proxyTargetClass

   • 类型：boolean
   • 默认值：false
   • 作用：指定是否强制使用CGLIB代理，而不是默认的基于接口的JDK动态代理。当设为true时，将总是使用CGLIB代理，即使被代理的类实现了接口。

这些属性提供了对自动代理行为的细粒度控制，例如选择代理类型（CGLIB或JDK动态代理）以及是否暴露代理对象到AopContext中。通过合理地配置这些属性，开发人员可以根据具体需求来调整自动代理的行为，以满足不同的业务场景和性能要求。

8、@EventListener

案例：

/**
 * @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注解有一些属性可以用来配置事件监听器的行为。让我来解释一下这些属性及其用途：

1. condition

   • 类型：String
   • 默认值：""
   • 作用：允许指定一个SpEL表达式作为条件，只有当条件表达式为true时，才会触发该事件监听器。这样可以根据具体的条件来决定是否执行监听方法。

2. fallbackExecution

   • 类型：boolean
   • 默认值：false
   • 作用：指定当处理事件时是否应该捕获并记录任何异常，而不是让它们传播回调用者。当设置为true时，如果事件监听器方法抛出异常，Spring会捕获并记录异常，而不会向上传播。

3. async

   • 类型：boolean
   • 默认值：false
   • 作用：指示是否异步地执行事件处理方法。当设置为true时，事件处理方法将在单独的线程中异步执行，而不会阻塞事件发布的线程。

通过合理地配置这些属性，开发人员可以根据具体的需求来控制事件监听器的行为。例如，可以使用condition属性来根据特定条件选择性地触发事件监听器，使用async属性来异步处理事件，以提高系统的响应性能。同时，fallbackExecution属性也提供了一种方式来处理事件监听器方法可能抛出的异常。

9、@EnableScheduling、@Scheduled

让我给你一个简单的例子来演示如何使用 @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 注解中，有几个常用的属性可以用来指定定时任务的执行规则：

1. cron：使用 cron 表达式来指定定时任务的执行时间。例如：@Scheduled(cron = "0 * * * * ?") 表示每分钟执行一次。
2. zone：指定时区，用于计算 cron 表达式中的时间。默认为服务器的时区。
3. fixedDelay：表示在上一次任务执行结束后多长时间再次执行，单位为毫秒。例如：@Scheduled(fixedDelay = 5000) 表示上一次任务执行结束后5秒再次执行。
4. fixedRate：表示从上一次任务开始执行时算起，经过固定的时间间隔执行下一次任务，单位为毫秒。例如：@Scheduled(fixedRate = 5000) 表示每隔5秒执行一次任务。
5. initialDelay：表示首次任务执行延迟的时间，单位为毫秒。例如：@Scheduled(initialDelay = 10000, fixedRate = 5000) 表示首次任务执行延迟10秒，然后每隔5秒执行一次任务。

这些属性可以根据实际需求灵活地组合和调整，以满足不同的定时任务执行需求。

 来讲一下 Cron 表达式：
Cron 表达式是一种用于指定时间的字符串表达式，通常用来表示定时任务的执行时间。Cron 表达式由 6 或 7 个字段组成，每个字段之间用空格分隔，其格式如下：

<秒> <分> <时> <日> <月> <周> [年]

其中，秒、分、时、日、月 和 周 是必需的字段，它们分别表示秒、分、小时、日期、月份和星期。每个字段可以是一个具体值、一个范围、一个列表或者一个通配符。

以下是一些常用的 Cron 表达式示例：

1. "0 * * * * ?" 表示每个整分钟触发一次。
2. "0/5 * * * * ?" 表示每隔 5 秒钟触发一次。
3. "0 0/15 8-20 * * ?" 表示每天上午 8 点到晚上 8 点之间，每隔 15 分钟触发一次。
4. "0 0 12 ? * WED" 表示每个星期三的中午 12 点触发一次。
5. "0 0 10,14,16 * * ?" 表示每天上午 10 点、下午 2 点和下午 4 点各触发一次。
6. "0 0/30 9-17 * * MON-FRI" 表示每个工作日上午 9 点到下午 5 点之间，每隔 30 分钟触发一次。

还有一些特殊符号也可以用来表示 Cron 表达式：

1. * 表示所有可能的值。
2. - 表示一个范围。
3. , 表示多个值，用逗号隔开。
4. / 表示增量，如 0/5 表示从 0 开始，每隔 5 秒一次。
5. ? 表示未指定的值，用于日和星期字段。如果日和星期都未指定，则表示每天都触发一次。
6. # 表示某个月份的第几个星期几，如 2#1 表示每个月的第一个周一。

Cron 表达式非常灵活，可以根据不同的场景自由组合。但是需要注意的是，应该避免使用过于复杂的表达式，以免造成混淆和误解。
 

二、总结

这就是本栏目所讲的所有的注解，我把他们重新整理起来，方便日后的查找和使用，把之前讲过的重点又重新的复习了一遍。