Spring Bean 作用域、生命周期与自动装配深度解析

注入行为差异

直接通过 context.getBean() 获取 Bean 时，对于 Prototype 作用域会触发新实例创建。但在使用 @Autowired 或 @Resource 注入时，情况有所不同：

• Prototype 作用域：注入操作仅在容器初始化阶段执行一次。后续通过字段引用访问的是最初注入的实例，不会因后续请求自动重新注入新实例。
• Request/Session 作用域：Spring 实际上注入的是一个代理对象而非真实实例。代理对象在应用启动时就被注入到依赖它的单例 Bean 中，但真实实例的创建被延迟到 HTTP 请求发生时。代理对象内部持有对当前 HTTP 请求上下文的引用，当调用方法时，会从上下文查找或创建新的真实实例。这种机制确保每个请求线程都能获得独立的实例。

各作用域说明

• Singleton（单例）：默认作用域，每个 Spring 容器中仅存在一个 Bean 实例。
• Prototype（原型）：每次请求 Bean 时都会创建一个新的实例。
• Request（请求）：每个 HTTP 请求创建一个新的 Bean 实例。
• Session（会话）：每个用户会话创建一个 Bean 实例。
• Application（应用）：整个 Web 应用共享一个 Bean 实例。

Bean 的生命周期

Bean 的生命周期指的是从创建到销毁的整个过程，主要分为五个阶段：

1. 实例化：容器通过反射调用构造器创建对象实例。
2. 属性赋值：容器注入依赖的属性值（如 @Autowired）。
3. 初始化：
   • 通知方法调用：通过特定接口（如 BeanNameAware）注入框架相关依赖。
   • 前置处理：进行准备工作，如参数校验。
   • 初始化回调：触发自定义逻辑（如 InitializingBean.afterPropertiesSet）。
   • 后置处理：流程结束后执行清理或结果处理（如 AOP 通知）。
4. 使用 Bean：进入就绪状态，可被应用程序调用。
5. 销毁 Bean：容器关闭时触发。

示例代码

/**
 * 实现类
 */
@Component
@Slf4j
public class BeanLifeComponent implements BeanNameAware, BeanPostProcessor, InitializingBean {
    private Cat cat;

    // 1. 实例化
    public BeanLifeComponent() {
        log.info("1.实例化：执行构造方法");
    }

    // 2. 属性赋值
    @Autowired
    public void setCat(Cat cat) {
        log.info("2.属性赋值：执行 setter 方法");
        this.cat = cat;
    }

    // 3.1 通知方法调用
    @Override
    public void setBeanName(String name) {
        log.info("3.1 通知方法调用，bean name is {}", name);
    }

    // 3.2 前置处理
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        log.info("3.3 前置处理，bean:{},beanName:{}", bean, beanName);
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    // 3.3 初始化回调
    @Override
    public void afterPropertiesSet() {
        log.info("3.2 初始化回调");
    }

    // 3.4 后置处理
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        log.info("3.4 后置处理，bean:{},beanName:{}", bean, beanName);
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }

    // 4. 使用 Bean
    public void use() {
        log.info("4.使用 Bean");
    }

    // 5. 销毁 Bean
    @PreDestroy
    public void preDestroy() {
        log.info("5.销毁 Bean");
    }
}

日志顺序与源码解析

运行测试后，日志显示的顺序往往是：invokeInitMethods（初始化回调）→ applyBeanPostProcessorsBeforeInitialization（前置处理）→ applyBeanPostProcessorsAfterInitialization（后置处理）。这看起来与理论流程矛盾，原因在于 BeanPostProcessor 本身也是 Bean。

当 Spring 初始化一个 BeanPostProcessor 实现类时，这个过程是递归的：

1. 创建非 BeanPostProcessor Bean 时，按正常顺序执行：Before → Init → After。
2. 创建 BeanPostProcessor Bean 时，Spring 需要先让它完成初始化（调用 invokeInitMethods），然后才能将其加入列表供其他 Bean 使用。
3. 但对于这个 BeanPostProcessor 自己来说，它自己的 afterPropertiesSet 会在 invokeInitMethods 中执行，而它自己的 postProcessBeforeInitialization 和 postProcessAfterInitialization 方法不会在它自己的创建过程中被调用。

因此，日志中看到的顺序实际上是 BeanPostProcessor 自身初始化过程中的特殊表现，而非普通 Bean 的处理顺序。正确的通用流程依然是：前置处理 → 初始化回调 → 后置处理。

核心源码位于 AbstractAutowireCapableBeanFactory 的 createBean 方法中，依次调用了 doCreateBean、populateBean 和 initializeBean。在 initializeBean 中，依次调用了 invokeAwareMethods、applyBeanPostProcessorsBeforeInitialization、invokeInitMethods 和 applyBeanPostProcessorsAfterInitialization。

SpringBoot 自动装配

自动装配的作用是注册 Bean 到 Spring 容器，无需手动配置。其本质是将依赖 Jar 包中的配置类及 Bean 加载到 IoC 容器的过程，遵循'约定大于配置'的理念。

加载 Bean 的方式

1. @ComponentScan

告诉 Spring 容器去哪里扫描被 @Component、@Service 等注解标记的类。如果未指定路径，默认扫描启动类所在目录及其子目录。

@SpringBootApplication
@ComponentScan("com.example.springprincicle.component")
public class SpringPrincipleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringPrincipleApplication.class, args);
    }
}

2. @Import

用于将配置类或其他类导入到当前上下文。

用法一：导入单个类

@SpringBootApplication
@Import(TestConfig.class)
public class SpringPrincipleApplication { ... }

用法二：ImportSelector 接口实现类

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.example.springprincicle.component.TestConfig"};
    }
}

3. 自定义注解

为了降低耦合，通常由依赖开发者提供一个封装了 @Import 的自定义注解。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportSelector.class)
public @interface EnableTestConfig {}

@SpringBootApplication 源码解析

这是一个组合注解，包含三个核心部分：

1. @ComponentScan：默认扫描启动类路径。排除不需要扫描的配置类，防止重复注册。
2. @SpringBootConfiguration：标记为配置类，并支持索引加速启动。
3. @EnableAutoConfiguration：核心入口。

@EnableAutoConfiguration 内部通过 AutoConfigurationImportSelector 动态加载自动配置类。该类实现了 DeferredImportSelector 接口，负责在启动时读取 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件（Spring Boot 3.x 推荐方式）或 spring.factories（兼容旧版）。

在 getCandidateConfigurations 方法中，系统会扫描类路径下的配置文件，加载所有候选自动配置类名，并进行去重和过滤。这一机制确保了第三方库能自动适配 Spring Boot 环境，极大减少了手动配置的成本。