Spring boot 中的IOC容器对Bean的管理

news2025/4/25 10:47:33

Spring Boot 中 IOC 容器对 Bean 的管理，涵盖从容器启动到 Bean 的生命周期管理的全流程。

步骤 1：理解 Spring Boot 的容器启动

Spring Boot 的 IOC 容器基于 ApplicationContext，在应用启动时自动初始化。

入口类：通过 @SpringBootApplication 注解标记主类，启动容器。
```
@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args); // 启动容器
    }
}
```
- @SpringBootApplication 组合了三个核心注解：
  - @Configuration：标记为配置类。
  - @ComponentScan：自动扫描当前包及子包的组件（@Component, @Service 等）。
  - @EnableAutoConfiguration：启用 Spring Boot 的自动配置机制。
容器初始化：
- Spring Boot 启动时，创建 ApplicationContext（默认实现为 AnnotationConfigApplicationContext）。
- 自动加载所有符合条件的 Bean（通过组件扫描和自动配置）。

步骤 2：注册 Bean 到容器

Bean 的注册主要有三种方式：

方式 1：组件扫描（自动注册）

使用 @Component 及其派生注解标记类，容器自动扫描并注册为 Bean。
```
@Service // 等价于 @Component，语义化标记为服务层
public class UserService {
    // ...
}
```
- 其他派生注解：@Repository（DAO 层）、@Controller（Web 层）、@RestController。

方式 2：Java 配置类（显式注册）

定义 @Configuration 类，通过 @Bean 方法显式注册 Bean。

@Configuration
public class AppConfig {
    @Bean // 方法返回的对象会被注册为 Bean
    public DataSource dataSource() {
        return new HikariDataSource(); // 例如配置数据源
    }
}

方式 3：自动配置（Spring Boot 特有）

Spring Boot 根据类路径依赖自动注册 Bean（如引入 spring-boot-starter-web 会自动配置 Tomcat、Spring MVC 相关 Bean）。
原理：通过 META-INF/spring.factories 文件定义自动配置类，结合条件注解（如 @ConditionalOnClass）判断是否生效。

步骤 3：依赖注入（DI）

容器负责将依赖的 Bean 注入到需要它们的对象中。

注入方式

构造器注入（推荐）：

@Service
public class OrderService {
    private final UserService userService;
    
    @Autowired // Spring 4.3+ 后，如果只有一个构造器，可省略 @Autowired
    public OrderService(UserService userService) {
        this.userService = userService;
    }
}

Setter 注入：

public class MyService {
    private MyRepository repository;
    
    @Autowired
    public void setRepository(MyRepository repository) {
        this.repository = repository;
    }
}

字段注入（不推荐，仅用于简单场景）：

@Service
public class MyService {
    @Autowired
    private MyRepository repository;
}

步骤 4：Bean 的作用域管理

通过 @Scope 注解指定 Bean 的作用域。

常用作用域：
- Singleton（默认）：整个容器中只有一个实例(从始至终只有这一个)。
```
@Bean
@Scope("singleton")
public MyBean myBean() { return new MyBean(); }
```
- Prototype：每次请求创建新实例(每次使用的时候都需要重新创建这个bean)。
```
@Bean
@Scope("prototype")
public MyBean myBean() { return new MyBean(); }
```
- Request（Web 环境）：每个 HTTP 请求一个实例。
- Session（Web 环境）：每个用户会话一个实例。

步骤 5：Bean 的生命周期管理

通过注解或接口控制 Bean 的初始化和销毁逻辑。

初始化方法：

@Component
public class MyBean {
    @PostConstruct // 初始化完成后执行
    public void init() {
        System.out.println("Bean 初始化完成！");
    }
}

销毁方法：

@Component
public class MyBean {
    @PreDestroy // 容器关闭前执行
    public void cleanup() {
        System.out.println("Bean 即将销毁！");
    }
}

步骤 6：高级配置与条件化 Bean

通过条件注解控制 Bean 的注册。

条件注解示例：

@Configuration
public class MyConfig {
    @Bean
    @ConditionalOnClass(name = "com.example.ExternalLibrary") // 当类路径存在该类时注册
    public MyBean myBean() {
        return new MyBean();
    }
    
    @Bean
    @ConditionalOnMissingBean // 当容器中没有该类型 Bean 时注册
    public BackupBean backupBean() {
        return new BackupBean();
    }
}

Profile 环境隔离：

@Bean
@Profile("dev") // 仅在 dev 环境下激活
public DataSource devDataSource() {
    return new EmbeddedDatabaseBuilder().build();
}

步骤 7：解决常见问题

循环依赖：
- 避免构造器注入循环，改用 Setter 或字段注入。
- 重构代码，提取公共逻辑到第三方 Bean。

Bean 冲突：

使用 @Primary 标记首选 Bean：

@Bean
@Primary
public MyService primaryService() {
    return new PrimaryService();
}

使用 @Qualifier 指定具体 Bean：

@Autowired
@Qualifier("secondaryService")
private MyService myService;

步骤 8：测试与验证

集成测试：

@SpringBootTest
class UserServiceTest {
    @Autowired
    private UserService userService; // 注入真实 Bean
}

单元测试（Mock 依赖）：

@SpringBootTest
class OrderServiceTest {
    @MockBean
    private UserService userService; // 模拟 UserService
    
    @Autowired
    private OrderService orderService;
}