Spring IoC 容器与 Bean 生命周期：从源码到生产实践

// AbstractBeanFactory.java（简化）
protected <T> T doGetBean(...) {
    String beanName = transformedBeanName(name);
    Object sharedInstance = getSingleton(beanName);          // ② 三级缓存
    if (sharedInstance != null && args == null) {
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        // 父容器 / 合并定义 / dependsOn / 作用域创建...
        if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, () -> {
                return createBean(beanName, mbd, args);      // ⑥ 核心创建
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
    }
    return adaptBeanInstance(name, bean, requiredType);      // ⑦ 类型适配
}

// BeanDefinition 关键属性
class GenericBeanDefinition {
    String scope = "singleton";        // 作用域
    boolean lazyInit;                  // 是否懒加载
    String factoryBeanName;            // factory-bean（实例工厂）
    String factoryMethodName;          // factory-method
    boolean primary;                   // @Primary 优先注入
    String initMethodName;             // init-method
    String destroyMethodName;          // destroy-method
    String[] dependsOn;                // 显式依赖
    boolean autowireCandidate;         // 是否参与自动装配
    ResolvableType resolvableType;     // 泛型类型
    boolean synthetic;                 // 框架内部生成（AOP、事件监听器）
}

// 入口一：@Component 扫描 → 解析候选组件生成 ScannedGenericBeanDefinition
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry);
scanner.scan("com.example.service");

// 入口二：@Bean 方法 → ConfigurationClassPostProcessor 在刷新早期解析，
// 生成 BeanDefinition，factoryMethodName 指向配置类方法

// AbstractAutowireCapableBeanFactory.createBean（简化）
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    Object bean = resolveBeforeInstantiation(beanName, mbd); // ① 短路机会
    if (bean != null) {
        return bean;   // 直接返回代理或替换 Bean，跳过后续
    }
    return doCreateBean(beanName, mbd, args);                // ② 正式创建
}

// ConstructorResolver 依次尝试：
// ① autowireConstructor（@Autowired 构造器）→ ② 主构造器（Spring 4.3+）→ ③ 默认无参构造
Constructor<?> ctor = resolveAutowiredCandidate(...);

// doCreateBean 关键片段（简化）
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);  // ① 实例化
    Object bean = instanceWrapper.getWrappedInstance();
    if (mbd.isSingleton()) {
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); // ② 三级缓存入口
    }
    populateBean(beanName, mbd, instanceWrapper);   // ③ 属性填充（依赖注入发生地）
    Object exposedObject = initializeBean(beanName, bean, mbd);  // ④ 初始化回调
    return exposedObject;
}

protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
    invokeAwareMethods(beanName, bean);            // ① Aware（BeanName/ClassLoader/BeanFactory）
    Object wrapped = applyBeanPostProcessorsBeforeInitialization(bean, beanName);  // ② BeforeInit
    invokeInitMethods(beanName, wrapped, mbd);     // ③ InitializingBean + init-method
    return applyBeanPostProcessorsAfterInitialization(wrapped, beanName);          // ④ AfterInit（AOP）
}

@Configuration
public class OrderedProcessors {
    @Bean
    public static BeanPostProcessor firstProcessor() {
        return new MyProcessor();     // 实现 Ordered.getOrder() 返回 0
    }
    @Bean
    public static BeanPostProcessor secondProcessor() {
        return new MyProcessor2();    // getOrder() 返回 10
    }
}
// 执行顺序：order 小的 before 先执行，after 反向：小 order 的 after 后执行

@Component
public class CacheWarmer implements SmartInitializingSingleton {
    @Override
    public void afterSingletonsInstantiated() {
        productService.preloadHotProducts();   // 此时可安全依赖任意 Bean
    }
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);   // 一级：完整 Bean
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        singletonObject = this.earlySingletonObjects.get(beanName); // 二级：早期引用
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            singletonObject = singletonFactory.getObject();  // ③ 调工厂产出
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);        // 晋升：三级 → 二级
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

// doCreateBean 实例化后立即调用 addSingletonFactory 放入三级
this.singletonFactories.put(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

// 工厂的核心：getEarlyBeanReference
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            // SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference
            exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);   // 生成提前代理
        }
    }
    return exposedObject;
}

// Spring Boot 2.6+ 默认禁止循环依赖：启动即报错
// spring.main.allow-circular-references=true 可放开（不推荐，只是给存量系统兜底）

@Component
public class MyRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // 阶段一：注册新 BeanDefinition（此时尚无 Bean 被实例化）
        AbstractBeanDefinition bd = BeanDefinitionBuilder
            .genericBeanDefinition(MyService.class).setInitMethodName("init").getBeanDefinition();
        registry.registerBeanDefinition("myService", bd);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 阶段二：修改既有 BeanDefinition 属性
        beanFactory.getBeanDefinition("myService").getPropertyValues().add("timeout", 3000);
    }
}

public class CustomInstantiationAwareBPP implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        if (beanName.equals("specialBean")) {
            return new SpecialBeanProxy();   // 直接替换，跳过后续流程
        }
        return null;                          // null → 走正常流程
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return !beanName.equals("noAutowired");  // false → 跳过属性填充
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        return pvs;   // 属性填充前自定义处理
    }
}

@Component
public class ComplexClientFactoryBean implements FactoryBean<ComplexClient> {
    @Override
    public ComplexClient getObject() {
        // 复杂构建逻辑：连接池、重试、超时、校验
        return ComplexClient.builder().connectionTimeout(5000).poolSize(32).build();
    }
    @Override
    public Class<?> getObjectType() { return ComplexClient.class; }
    @Override
    public boolean isSingleton() { return true; }
}
// 注入 ComplexClient 即可，容器自动调用 getObject()
// 获取 FactoryBean 本身：getBean("&complexClientFactoryBean")

@Component
public class MessageConsumer implements SmartLifecycle {
    private volatile boolean running = false;

    @Override
    public void start() { running = true; }      // 容器启动阶段：启动 MQ 消费者
    @Override
    public void stop() { running = false; }      // 容器关闭阶段：优雅下线
    @Override
    public boolean isRunning() { return running; }
    @Override
    public int getPhase() { return Integer.MAX_VALUE; }
    // phase 越大越晚启动、越早停止：依赖方用小 phase，被依赖方用大 phase
}

public class MyRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                        BeanDefinitionRegistry registry) {
        GenericBeanDefinition bd = new GenericBeanDefinition();
        bd.setBeanClass(Router.class);
        bd.getPropertyValues().add("routes", discoverRoutes(importingClassMetadata));
        registry.registerBeanDefinition("router", bd);   // 编程式注册
    }
}

@Configuration
@Import(MyRegistrar.class)     // 组合注解 @EnableXxx 的惯用实现方式
public class AppConfig {}

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestContextHolder { ... }

@Service
public class OrderFacade {
    private final RequestContextHolder ctx;   // 注入的是代理
    // 每次调用 ctx 的方法，代理解析当前 HTTP 请求对应的真实实例
}

@Service
public class UserService {
    @Autowired
    private UserService self;                     // 自注入：让方法经过代理

    @Transactional
    public void createUser(User u) { ... }

    public void createUserBatch(List<User> users) {
        users.forEach(u -> self.createUser(u));   // 通过 self 调用才能触发事务代理
    }
}