昨天 18:13 The University of Queensland Java 发布于广东

关注

Spring IoC 注解

Spring IoC 提供了丰富的注解，可简化 Bean 的定义、依赖注入等操作。以下为你详细介绍一些常用注解及其使用方法：

1. 用于定义 Bean 的注解

@Component
- 功能：这是一个通用注解，用于将类标记为 Spring 管理的 Bean 。它可以用在任何类上，Spring 会自动扫描带有该注解的类并将其注册到 IoC 容器中。
- 示例：

import org.springframework.stereotype.Component;

@Component
public class UserService {
    public void doSomething() {
        System.out.println("UserService is doing something.");
    }
}

@Service
- 功能：通常用于标记业务逻辑层的类，它是 @Component 的一个特化注解，本质上和 @Component 功能相同，但使用 @Service 能让代码更具可读性，明确表示该类是服务层组件。
- 示例：

import org.springframework.stereotype.Service;

@Service
public class OrderService {
    public void processOrder() {
        System.out.println("Processing order...");
    }
}

@Repository
- 功能：主要用于标记数据访问层（DAO）的类，同样是 @Component 的特化注解，它还能将 DAO 层抛出的异常转换为 Spring 的数据访问异常体系。
- 示例：

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    public void saveUser() {
        System.out.println("Saving user...");
    }
}

@Controller
- 功能：用于标记控制器层的类，是 @Component 的特化注解，主要用于 Spring MVC 框架中处理 HTTP 请求。
- 示例：

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserController {
    @GetMapping("/users")
    public String getUsers() {
        return "users";
    }
}

@Configuration
- 功能：用于标记配置类，该类中可以包含多个 @Bean 注解的方法，用于定义和注册 Bean 。
- 示例：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

2. 用于依赖注入的注解

@Autowired
- 功能：可以用在构造函数、Setter 方法、字段上，用于自动注入依赖的 Bean 。默认按类型进行注入，如果存在多个相同类型的 Bean ，可以结合 @Qualifier 注解使用。
- 示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserManager {
    private UserService userService;

    @Autowired
    public UserManager(UserService userService) {
        this.userService = userService;
    }

    public void manageUser() {
        userService.doSomething();
    }
}

@Qualifier
- 功能：当存在多个相同类型的 Bean 时，使用 @Qualifier 注解指定要注入的 Bean 的名称。
- 示例：

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

@Component
public class PaymentProcessor {
    private PaymentService paymentService;

    @Autowired
    public PaymentProcessor(@Qualifier("creditCardPaymentService") PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

@Resource
- 功能：这是 JSR - 250 标准的注解，默认按名称进行注入，如果没有指定名称，则按类型进行注入。
- 示例：

import javax.annotation.Resource;
import org.springframework.stereotype.Component;

@Component
public class ProductService {
    @Resource
    private ProductRepository productRepository;

    public void addProduct() {
        productRepository.saveProduct();
    }
}

3. 其他注解

@Scope
- 功能：用于指定 Bean 的作用域，常见的作用域有 singleton（单例）、prototype（原型）等。
- 示例：

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class CartService {
    // 该 Bean 每次获取时都会创建一个新的实例
}

@Lazy
- 功能：用于延迟加载 Bean ，当 Bean 被标记为 @Lazy 时，它不会在容器启动时立即创建，而是在第一次被使用时才创建。
- 示例：

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
@Lazy
public class ExpensiveService {
    public ExpensiveService() {
        System.out.println("ExpensiveService is created.");
    }
}

4. 条件注解

@Conditional
- 功能：根据自定义的条件来决定是否创建某个 Bean 。需要实现 Condition 接口来定义条件。
- 示例：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ConditionalConfig {
    @Bean
    @Conditional(MyCondition.class)
    public MyBean myBean() {
        return new MyBean();
    }
}

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class MyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 自定义条件判断逻辑
        return true; 
    }
}

除了之前提到的 Spring IoC 注解，下面为你详细介绍更多相关注解及其用途：

1. 定义 Bean 相关注解

@Named
- 功能：这是 JSR - 330 标准中的注解，和 @Component 类似，可将类标记为 Spring 管理的 Bean。在使用 JSR - 330 标准的依赖注入时较为常用。
- 示例：

import javax.inject.Named;

@Named
public class LogService {
    public void logMessage(String message) {
        System.out.println("Logging: " + message);
    }
}

2. 依赖注入相关注解

@Inject
- 功能：同样是 JSR - 330 标准的注解，用于执行依赖注入，和 @Autowired 功能类似，默认按类型注入。
- 示例：

import javax.inject.Inject;
import org.springframework.stereotype.Component;

@Component
public class ReportService {
    private LogService logService;

    @Inject
    public ReportService(LogService logService) {
        this.logService = logService;
    }
}

@Value
- 功能：用于将属性值注入到 Bean 的字段、方法参数或者构造函数参数中。可以注入普通字符串、配置文件中的属性值等。
- 示例：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class AppConfigProperties {
    @Value("${app.name}")
    private String appName;

    public String getAppName() {
        return appName;
    }
}

3. Bean 生命周期相关注解

@PostConstruct
- 功能：该注解用于标记一个方法，此方法会在 Bean 实例化之后、依赖注入完成之后立即执行，常用于进行一些初始化操作。
- 示例：

import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;

@Component
public class DatabaseInitializer {
    @PostConstruct
    public void init() {
        System.out.println("Initializing database...");
    }
}

@PreDestroy
- 功能：用于标记一个方法，该方法会在 Bean 被销毁之前执行，常用于释放资源等操作。
- 示例：

import javax.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class ConnectionManager {
    @PreDestroy
    public void closeConnections() {
        System.out.println("Closing database connections...");
    }
}

4. 配置类相关注解

@Import
- 功能：在配置类中使用，用于导入其他配置类，将其他配置类中的 Bean 定义合并到当前配置类中。
- 示例：

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import({AppConfig.class, DatabaseConfig.class})
public class RootConfig {
    // 合并 AppConfig 和 DatabaseConfig 中的 Bean 定义
}

@ImportResource
- 功能：用于在 Java 配置类中引入 XML 配置文件，将 XML 配置文件中的 Bean 定义引入到 Spring 容器中。
- 示例：

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

@Configuration
@ImportResource("classpath:applicationContext.xml")
public class MixedConfig {
    // 引入 XML 配置文件中的 Bean 定义
}

5. 条件注解

@ConditionalOnClass
- 功能：只有当指定的类存在于类路径中时，才会创建对应的 Bean。
- 示例：

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {
    @Bean
    @ConditionalOnClass(name = "com.example.SomeClass")
    public MyBean myBean() {
        return new MyBean();
    }
}

@ConditionalOnMissingClass
- 功能：当指定的类不存在于类路径中时，才会创建对应的 Bean。
- 示例：

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AnotherConfig {
    @Bean
    @ConditionalOnMissingClass("com.example.OtherClass")
    public AnotherBean anotherBean() {
        return new AnotherBean();
    }
}

@ConditionalOnProperty
- 功能：根据配置文件中的属性值来决定是否创建 Bean。可以指定属性名、属性值等条件。
- 示例：

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

@Configuration
public class FeatureConfig {
    @Bean
    @ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
    public FeatureService featureService() {
        return new FeatureService();
    }
}

@ConditionalOnMissingBean
- 功能：当容器中不存在指定类型的 Bean 时，才会创建对应的 Bean。
- 示例：

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DefaultConfig {
    @Bean
    @ConditionalOnMissingBean(MyService.class)
    public MyService defaultMyService() {
        return new DefaultMyService();
    }
}

6. 自动配置相关注解

@EnableAutoConfiguration
- 功能：启用 Spring Boot 的自动配置功能，Spring Boot 会根据类路径中的依赖和配置文件自动配置 Spring 应用。
- 示例：

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAutoConfiguration
public class Application {
    public static void main(String[] args) {
        // 启动 Spring Boot 应用
    }
}

@AutoConfigureBefore 和 @AutoConfigureAfter
- 功能：用于指定自动配置类的加载顺序，@AutoConfigureBefore 表示当前自动配置类在指定的自动配置类之前加载，@AutoConfigureAfter 则相反。
- 示例：

import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;

@Configuration
@AutoConfigureAfter(DatabaseAutoConfiguration.class)
@ConditionalOnClass(SomeClass.class)
public class MyAutoConfiguration {
    // 配置逻辑
}

这些注解丰富了 Spring IoC 的功能，能帮助开发者更灵活、高效地构建和管理 Spring 应用。