// 核心數(shù)據(jù)結(jié)構(gòu)示意
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory 
    implements ConfigurableListableBeanFactory, BeanDefinitionRegistry {
    // Bean定義注冊(cè)表：存儲(chǔ)所有BeanDefinition
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
    // 單例Bean緩存：一級(jí)緩存singletonObjects
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    // 三級(jí)緩存結(jié)構(gòu)（解決循環(huán)依賴）
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();
    private final Map<String, Object> earlySingletonObjects = new HashMap<>();
}

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 1. 解析Bean類型
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    // 2. 準(zhǔn)備方法覆蓋（處理@Lookup等）
    mbd.prepareMethodOverrides();
    // 3. 實(shí)例化前的BeanPostProcessor處理
    Object bean = resolveBeforeInstantiation(beanName, mbd);
    if (bean != null) return bean;
    // 4. 執(zhí)行實(shí)際創(chuàng)建
    Object beanInstance = doCreateBean(beanName, mbd, args);
    return beanInstance;
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    // 一級(jí)緩存查詢
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null) {
        // 二級(jí)緩存查詢
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null) {
            // 三級(jí)緩存獲取工廠并創(chuàng)建
            ObjectFactory<?> factory = this.singletonFactories.get(beanName);
            if (factory != null) {
                singletonObject = factory.getObject();
                this.earlySingletonObjects.put(beanName, singletonObject);
                this.singletonFactories.remove(beanName);
            }
        }
    }
    return singletonObject;
}

private final Map<Class<?>, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>();
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
    metadata.checkConfigMembers(beanDefinition);
}
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
    // 從緩存獲取
    InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
    // 檢查是否需要刷新
    if (InjectionMetadata.needsRefresh(metadata, clazz)) {
        synchronized (this.injectionMetadataCache) {
            metadata = buildAutowiringMetadata(clazz); // 反射解析
            this.injectionMetadataCache.put(cacheKey, metadata);
        }
    }
    return metadata;
}

// DefaultSingletonBeanRegistry中的三級(jí)緩存
public class DefaultSingletonBeanRegistry {
    // 一級(jí)緩存：完全初始化完成的單例Bean
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    // 二級(jí)緩存：早期曝光的單例Bean（已實(shí)例化但尚未初始化）
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
    // 三級(jí)緩存：?jiǎn)卫鼴ean工廠，用于生成早期Bean引用
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
}

@ConditionalOnClass      // 類路徑存在指定類
@ConditionalOnMissingBean // 容器中不存在指定Bean
@ConditionalOnProperty   // 配置屬性滿足條件
@ConditionalOnWebApplication // 當(dāng)前是Web應(yīng)用

// AutoConfigurationImportSelector核心邏輯
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
        getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    return configurations;
}
private List<String> filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) {
    // 遍歷每個(gè)配置類
    for (String configuration : configurations) {
        // 獲取其上的@Conditional注解
        // 調(diào)用ConditionEvaluator評(píng)估
        if (conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
            continue; // 不滿足條件則跳過(guò)
        }
        result.add(configuration);
    }
    return result;
}

@Configuration
public class MyAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean(MyService.class)
    public MyService defaultMyService() {
        return new DefaultMyServiceImpl();
    }
}
// 用戶自定義Bean將覆蓋默認(rèn)實(shí)現(xiàn)
@Component
public class CustomMyService implements MyService {
    // 自定義實(shí)現(xiàn)
}

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;
public class ThreadLocalScope implements Scope {
    private final ThreadLocal<Map<String, Object>> threadLocal = 
        ThreadLocal.withInitial(HashMap::new);
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = threadLocal.get();
        return scope.computeIfAbsent(name, k -> objectFactory.getObject());
    }
    @Override
    public Object remove(String name) {
        return threadLocal.get().remove(name);
    }
    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        // 線程銷毀時(shí)清理
    }
    @Override
    public String getConversationId() {
        return Thread.currentThread().getName();
    }
}

@Configuration
public class ScopeConfig {
    @Bean
    public static BeanFactoryPostProcessor beanFactoryPostProcessor() {
        return beanFactory -> beanFactory.registerScope("threadLocal", new ThreadLocalScope());
    }
}

@Component
@Scope("threadLocal")
public class RequestContext {
    private String traceId;
    // getter/setter
}
// 或通過(guò)@Scope的proxyMode創(chuàng)建代理
@Component
@Scope(value = "threadLocal", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class TenantDataSource {
    // 多租戶數(shù)據(jù)源實(shí)現(xiàn)
}

@ConfigurationProperties(prefix = "app.datasource")
@ConstructorBinding // Spring Boot 2.2+支持
public class DataSourceProperties {
    private final String url;
    private final String username;
    private final int poolSize;
    // 單構(gòu)造器可省略@ConstructorBinding
    public DataSourceProperties(String url, String username, int poolSize) {
        this.url = url;
        this.username = username;
        this.poolSize = poolSize;
    }
    // 僅提供getter，無(wú)setter實(shí)現(xiàn)不可變
    public String getUrl() { return url; }
}
// 啟用配置類
@Configuration
@EnableConfigurationProperties(DataSourceProperties.class)
public class AppConfig {
}

<bean id="abstractDataSource" abstract="true" 
      class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
</bean>
<bean id="masterDataSource" parent="abstractDataSource">
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

// 掃描入口
public int scan(String... basePackages) {
    int beanCount = 0;
    for (String basePackage : basePackages) {
        // 查找候選組件
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
        for (BeanDefinition candidate : candidates) {
            // 解析作用域、代理模式等
            ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(candidate);
            candidate.setScope(scopeMetadata.getScopeName());
            // 生成Bean名稱
            String beanName = beanNameGenerator.generateBeanName(candidate, registry);
            // 注冊(cè)到容器
            registry.registerBeanDefinition(beanName, candidate);
            beanCount++;
        }
    }
    return beanCount;
}

// AbstractAutowireCapableBeanFactory中的實(shí)例化
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 1. 使用工廠方法實(shí)例化
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }
    // 2. 構(gòu)造器自動(dòng)裝配
    Constructor<?>[] constructors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (constructors != null) {
        return autowireConstructor(beanName, mbd, constructors, args);
    }
    // 3. 默認(rèn)無(wú)參構(gòu)造器
    return instantiateBean(beanName, mbd);
}

private void invokeAwareMethods(String beanName, Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(this);
        }
        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
        }
    }
}

// 初始化前回調(diào)
Object postProcessBeforeInitialization(Object bean, String beanName)
// 初始化后回調(diào)
Object postProcessAfterInitialization(Object bean, String beanName)