Spring IoC 容器原理：BeanFactory 与 ApplicationContext

// ① 构造器注入（推荐：不可变、可测试、保证非空）
public class OrderService {
    private final UserRepository userRepo;
    public OrderService(UserRepository userRepo) {
        this.userRepo = userRepo;
    }
}

// ② Setter 注入（可选依赖、运行时可变）
public class OrderService {
    private UserRepository userRepo;
    @Autowired
    public void setUserRepo(UserRepository userRepo) {
        this.userRepo = userRepo;
    }
}

// ③ 字段注入（最方便，但不推荐：不可变差、难测试）
public class OrderService {
    @Autowired
    private UserRepository userRepo;
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {

        // ① 准备刷新：校验必要属性、初始化 PropertySources
        prepareRefresh();

        // ② 获取 BeanFactory：解析 XML/注解，注册 BeanDefinition
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // ③ 准备 BeanFactory：设置类加载器、注册标准 Bean
        prepareBeanFactory(beanFactory);

        try {
            // ④ 子类扩展点：注册容器级后处理器
            postProcessBeanFactory(beanFactory);

            // ⑤ 执行 BeanFactoryPostProcessor（如 PropertyPlaceholder）
            invokeBeanFactoryPostProcessors(beanFactory);

            // ⑥ 注册 BeanPostProcessor（如 AutowiredAnnotationBPP）
            registerBeanPostProcessors(beanFactory);

            // ⑦ 初始化国际化 MessageSource
            initMessageSource();

            // ⑧ 初始化事件广播器
            initApplicationEventMulticaster();

            // ⑨ 子类扩展点（如 SpringBoot 在此启动内嵌 Tomcat）
            onRefresh();

            // ⑩ 注册事件监听器
            registerListeners();

            // ⑪ 实例化所有非懒加载的单例 Bean ★最重的一步
            finishBeanFactoryInitialization(beanFactory);

            // ⑫ 发布 ContextRefreshedEvent、注册 JMX 等收尾
            finishRefresh();
        } catch (BeansException ex) {
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
    }
}

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    // Bean 的全限定类名
    String getBeanClassName();

    // 作用域：singleton / prototype / request / session
    String getScope();

    // 是否懒加载
    boolean isLazyInit();

    // 依赖的其他 Bean（保证创建顺序）
    String[] getDependsOn();

    // 构造器参数
    ConstructorArgumentValues getConstructorArgumentValues();

    // 属性值（setter 注入）
    MutablePropertyValues getPropertyValues();

    // 初始化 / 销毁方法
    String getInitMethodName();
    String getDestroyMethodName();
}

public class DefaultListableBeanFactory
        extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry {

    // ★ BeanDefinition 的最终存储地
    private final Map<String, BeanDefinition> beanDefinitionMap
            = new ConcurrentHashMap<>(256);

    // 保持注册顺序的 Bean 名称列表
    private volatile List<String> beanDefinitionNames
            = new ArrayList<>(256);
}

// 入口：外部调用或容器内部触发
public Object getBean(String name) {
    return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(String name, ...) {
    // ① 先查三级缓存（处理循环依赖）
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null) return (T) sharedInstance;

    // ② 检查并创建依赖的 Bean（depends-on）
    String[] dependsOn = mbd.getDependsOn();
    for (String dep : dependsOn) getBean(dep);

    // ③ 根据 scope 创建 Bean
    if (mbd.isSingleton()) {
        sharedInstance = getSingleton(beanName, () -> {
            return createBean(beanName, mbd, args);
        });
    }
    return (T) sharedInstance;
}

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 解析 Bean 的 Class（处理 FactoryBean 等情况）
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

    return doCreateBean(beanName, mbd, args);
}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // ──── 阶段 1：实例化 ────
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
    Object bean = instanceWrapper.getWrappedInstance();

    // ★ 提前暴露到三级缓存（解决循环依赖的关键）
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

    // ──── 阶段 2：属性填充 ────
    populateBean(beanName, mbd, instanceWrapper);

    // ──── 阶段 3：初始化 ────
    Object exposedBean = initializeBean(beanName, bean, mbd);
    //   ├─ invokeAwareMethods()      → BeanNameAware, BeanFactoryAware
    //   ├─ applyBeanPostProcessorsBeforeInitialization()  → @PostConstruct
    //   ├─ invokeInitMethods()       → InitializingBean.afterPropertiesSet(), init-method
    //   └─ applyBeanPostProcessorsAfterInitialization()   → AOP 代理在此生成

    return exposedBean;
}

// 一级缓存：完整的 Bean 实例（已初始化完毕）
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 二级缓存：早期 Bean 实例（已实例化，未填充属性）
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

// 三级缓存：Bean 工厂（ObjectFactory，用于生成早期引用）
private final Map<String, ObjectFactory<?>> singletonFactories
        = new HashMap<>(16);