关键词：Spring 源码, ApplicationContext, BeanFactory, BeanDefinition, 注解配置, XML 配置, 源码分析

写在前面

在前面手写 Spring 框架的系列文章中，我们已经从零实现了 IoC、DI、AOP 和 Bean 配置化功能。通过手写实践，我们对 Spring 的核心概念有了深入的理解。

本文将带大家进入 Spring 源码的世界，深入分析 ApplicationContext 的体系结构、BeanFactory 的实现机制，以及 BeanDefinition 的加载过程和继承体系。通过阅读本文，你将能够：

  • ✅ 理解 ApplicationContext 的完整继承体系
  • ✅ 掌握 BeanFactory 在 Spring 中的实现方式
  • ✅ 深入理解 BeanDefinition 的加载过程（XML + 注解）
  • ✅ 熟悉 BeanDefinition 的继承体系和各种实现类
  • ✅ 理解 Spring 中元数据和属性访问的设计

目录

一、ApplicationContext 体系结构

1.1 ApplicationContext 是什么

ApplicationContext 字面意思是"应用上下文"，它是 Spring 框架中最核心的接口之一。

ApplicationContext = BeanFactory + 高级功能

功能 说明
BeanFactory IoC 容器的基础功能，Bean 的创建和管理
应用事件发布 ApplicationEventPublisher，支持事件机制
资源加载 ResourceLoader，加载配置文件等资源
环境参数 EnvironmentCapable，获取系统环境变量
国际化 MessageSource，支持多语言国际化

1.2 核心接口分析

ApplicationContext 继承结构：

ApplicationContext
    │
    ├── ListableBeanFactory（可列表的 BeanFactory）
    │
    ├── HierarchicalBeanFactory（分层的 BeanFactory）
    │
    ├── MessageSource（国际化）
    │
    ├── ApplicationEventPublisher（事件发布）
    │
    └── ResourcePatternResolver（资源加载）

接口职责说明：

接口 功能 核心方法
BeanFactory Bean 创建和管理 getBean(), containsBean()
ListableBeanFactory 批量获取 Bean getBeanDefinitionNames(), getBeansOfType()
HierarchicalBeanFactory 父子容器 getParentBeanFactory()
MessageSource 国际化 getMessage()
ApplicationEventPublisher 事件发布 publishEvent()
ResourcePatternResolver 资源加载 getResources()

1.3 实现类分支

ApplicationContext 的实现类有两个重要分支：

ApplicationContext
    │
    ├── ConfigurableApplicationContext
    │       │
    │       ├── AbstractApplicationContext
    │       │       │
    │       │       ├── AbstractRefreshableApplicationContext ← 可刷新的上下文
    │       │       │       │
    │       │       │       ├── ClassPathXmlApplicationContext
    │       │       │       └── FileSystemXmlApplicationContext
    │       │       │
    │       │       └── GenericApplicationContext ← 通用上下文
    │       │               │
    │       │               ├── AnnotationConfigApplicationContext
    │       │               └── GenericXmlApplicationContext
    │       │
    │       └── WebApplicationContext（Web 应用专用）
    │
    └── ...

两大分支对比：

分支 特点 代表实现
AbstractRefreshableApplicationContext 每次刷新都会重建 BeanFactory ClassPathXmlApplicationContext
GenericApplicationContext 可以在运行时动态注册 Bean 定义 AnnotationConfigApplicationContext

二、BeanFactory 实现

2.1 BeanFactory 继承体系

BeanFactory 是 Spring IoC 容器的核心，ApplicationContext 内部也是通过 BeanFactory 来管理 Bean。

BeanFactory
    │
    ├── HierarchicalBeanFactory（支持父子容器）
    │       │
    │       └── ConfigurableBeanFactory（可配置）
    │               │
    │               ├── AutowireCapableBeanFactory（支持自动装配）
    │               │       │
    │               │       └── AbstractAutowireCapableBeanFactory
    │               │               │
    │               │               └── DefaultListableBeanFactory ← 最终实现
    │               │
    │               └── ConfigurableListableBeanFactory
    │
    └── ListableBeanFactory（可枚举）
            │
            └── ConfigurableListableBeanFactory
                    │
                    └── DefaultListableBeanFactory ← 最终实现

完整继承体系：

DefaultListableBeanFactory
    └── AbstractAutowireCapableBeanFactory
            └── AbstractBeanFactory
                    ├── FactoryBeanRegistrySupport
                    └── ConfigurableBeanFactory
                            └── HierarchicalBeanFactory
                                    └── BeanFactory

2.2 DefaultListableBeanFactory

DefaultListableBeanFactory 是 Spring 中最核心的 BeanFactory 实现，它集成了所有功能：

public class DefaultListableBeanFactory 
    extends AbstractAutowireCapableBeanFactory
    implements ConfigurableListableBeanFactory, 
               BeanDefinitionRegistry, 
               Serializable {
    
    /** BeanDefinition 存储容器 */
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
    
    /** Bean 名称列表 */
    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
    
    // ... 实现各种 BeanFactory 和 BeanDefinitionRegistry 接口的方法
}

核心功能：

功能 说明
BeanDefinition 注册 实现 BeanDefinitionRegistry 接口，管理 Bean 定义
Bean 创建 继承 AbstractAutowireCapableBeanFactory，创建 Bean 实例
依赖注入 支持构造器注入、属性注入
自动装配 支持 @Autowired 自动装配
单例管理 管理单例 Bean 的生命周期

三、BeanDefinition 加载

3.1 XML 配置方式

XML 配置文件示例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 普通 Bean 定义 -->
    <bean id="beanE" class="com.study.spring.sample.config.BeanE" />
    <bean id="beanF" class="com.study.spring.sample.config.BeanF" />

    <!-- 开启注解支持 -->
    <context:annotation-config/>
    
    <!-- 组件扫描 -->
    <context:component-scan base-package="com.study.spring.sample.config" />
</beans>

加载流程：

public class XMLConfigMain {
    public static void main(String[] args) {
        // 创建 ApplicationContext
        ApplicationContext context = new GenericXmlApplicationContext(
            "classpath:com/study/spring/sample/config/application.xml"
        );
        
        // 获取 Bean
        BeanF bf = context.getBean(BeanF.class);
        bf.do1();
    }
}

处理流程：

解析 XML 文件
    │
    ▼
解析 <bean> 元素
    │
    ▼
创建 BeanDefinition 对象
    │
    ▼
注册到 BeanDefinitionRegistry
    │
    ▼
通过 BeanFactory 创建 Bean

核心类：XmlBeanDefinitionReader

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
    
    /**
     * 从 XML 文件加载 Bean 定义
     */
    public int loadBeanDefinitions(String location) {
        // 1. 加载 XML 资源
        Resource resource = resourceLoader.getResource(location);
        
        // 2. 解析 XML
        Document document = doLoadDocument(resource);
        
        // 3. 解析 <bean> 元素
        return registerBeanDefinitions(document, resource);
    }
    
    /**
     * 解析并注册 BeanDefinition
     */
    public int registerBeanDefinitions(Document doc, Resource resource) {
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        int countBefore = getRegistry().getBeanDefinitionCount();
        
        // 解析 Document
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }
}

3.2 注解配置方式

配置类方式：

@Configuration
@ComponentScan("com.study.spring.sample.config")
public class JavaBasedMain {
    
    @Bean
    public BeanH getBeanH() {
        return new BeanH();
    }

    public static void main(String[] args) {
        ApplicationContext context = 
            new AnnotationConfigApplicationContext(JavaBasedMain.class);
        
        BeanH bh = context.getBean(BeanH.class);
        bh.doH();
    }
}

扫描包方式：

public class AnnotationMain {
    public static void main(String[] args) {
        ApplicationContext context = 
            new AnnotationConfigApplicationContext("com.study.spring.sample.config");
        
        BeanG bg = context.getBean(BeanG.class);
        bg.dog();
    }
}

注解配置两种方式：

  1. 配置类方式：传入 @Configuration 注解的类
  2. 扫描路径方式：指定要扫描的包路径

3.3 扫描实现原理

AnnotationConfigApplicationContext 构造方法：

public class AnnotationConfigApplicationContext extends GenericApplicationContext {
    
    private final AnnotatedBeanDefinitionReader reader;
    private final ClassPathBeanDefinitionScanner scanner;
    
    public AnnotationConfigApplicationContext() {
        // 1. 创建注解 Bean 定义读取器
        this.reader = new AnnotatedBeanDefinitionReader(this);
        
        // 2. 创建类路径 Bean 定义扫描器
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
    
    public AnnotationConfigApplicationContext(String... basePackages) {
        this();
        // 扫描指定包
        scan(basePackages);
        refresh();
    }
    
    public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        this();
        // 注册配置类
        register(componentClasses);
        refresh();
    }
}

核心组件：

组件 作用
AnnotatedBeanDefinitionReader 读取注解类，解析 @Bean 方法
ClassPathBeanDefinitionScanner 扫描包路径，查找 @Component 类

AnnotatedBeanDefinitionReader 初始化：

public class AnnotatedBeanDefinitionReader {
    
    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        this.registry = registry;
        
        // 注册核心的 ConfigurationClassPostProcessor
        // 用于解析 @Configuration 类
        AnnotationConfigUtils.registerAnnotationConfigProcessors(registry);
    }
    
    /**
     * 注册配置类
     */
    public void register(Class<?>... componentClasses) {
        for (Class<?> componentClass : componentClasses) {
            registerBean(componentClass);
        }
    }
}

扫描流程：

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
    
    /**
     * 扫描指定包
     */
    public int scan(String... basePackages) {
        // 1. 清空之前的 Bean 定义（如果需要）
        
        // 2. 扫描每个包
        for (String basePackage : basePackages) {
            // 2.1 查找候选组件
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            
            // 2.2 解析并注册
            for (BeanDefinition candidate : candidates) {
                // 解析 Scope
                ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                
                // 生成 Bean 名称
                String beanName = beanNameGenerator.generateBeanName(candidate, registry);
                
                // 处理通用注解（@Lazy、@Primary 等）
                if (candidate instanceof AbstractBeanDefinition) {
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                
                // 注册 Bean 定义
                registry.registerBeanDefinition(beanName, candidate);
            }
        }
        
        return registry.getBeanDefinitionCount();
    }
    
    /**
     * 查找候选组件
     */
    public Set<BeanDefinition> findCandidateComponents(String basePackage) {
        Set<BeanDefinition> candidates = new LinkedHashSet<>();
        
        // 1. 组装扫描路径
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            resolveBasePackage(basePackage) + '/' + resourcePattern;
        
        // 2. 获取所有资源
        Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
        
        for (Resource resource : resources) {
            if (resource.isReadable()) {
                // 3. 读取元数据
                MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
                
                // 4. 检查是否匹配过滤器（@Component 注解）
                if (isCandidateComponent(metadataReader)) {
                    // 5. 创建 ScannedGenericBeanDefinition
                    ScannedGenericBeanDefinition sbd = 
                        new ScannedGenericBeanDefinition(metadataReader);
                    sbd.setSource(resource);
                    
                    if (isCandidateComponent(sbd)) {
                        candidates.add(sbd);
                    }
                }
            }
        }
        
        return candidates;
    }
}

扫描过滤器配置：

protected void registerDefaultFilters() {
    // 默认包含 @Component 注解的类
    addIncludeFilter(new AnnotationTypeFilter(Component.class));
    
    // 也包含 @Service、@Repository、@Controller
    // 因为它们都标注了 @Component 元注解
}

3.4 @Configuration 解析

@Configuration 解析发生在 refresh() 方法中：

public void refresh() {
    // 1. 准备刷新
    prepareRefresh();
    
    // 2. 获取 BeanFactory
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    // 3. 准备 BeanFactory
    prepareBeanFactory(beanFactory);
    
    try {
        // 4. 后置处理 BeanFactory
        postProcessBeanFactory(beanFactory);
        
        // 5. 【关键】调用 BeanFactoryPostProcessors
        // 这里会调用 ConfigurationClassPostProcessor 解析 @Configuration
        invokeBeanFactoryPostProcessors(beanFactory);
        
        // 6. 注册 BeanPostProcessors
        registerBeanPostProcessors(beanFactory);
        
        // 7. 初始化 MessageSource
        initMessageSource();
        
        // 8. 初始化事件发布器
        initApplicationEventMulticaster();
        
        // 9. 初始化其他特殊 Bean
        onRefresh();
        
        // 10. 注册监听器
        registerListeners();
        
        // 11. 实例化所有非延迟单例 Bean
        finishBeanFactoryInitialization(beanFactory);
        
        // 12. 完成刷新
        finishRefresh();
    }
    // ...
}

ConfigurationClassPostProcessor 解析：

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor {
    
    /**
     * 处理 @Configuration 类
     */
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // 1. 获取所有候选配置类
        String[] candidateNames = registry.getBeanDefinitionNames();
        
        for (String beanName : candidateNames) {
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            
            // 检查是否是配置类
            if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, metadataReaderFactory)) {
                // 解析配置类
                processConfigBeanDefinitions(registry);
            }
        }
    }
    
    /**
     * 解析配置类
     */
    public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        // 1. 创建配置类解析器
        ConfigurationClassParser parser = new ConfigurationClassParser(...);
        
        // 2. 解析每个配置类
        for (String configName : candidateNames) {
            parser.parse(registry.getBeanDefinition(configName));
        }
        
        // 3. 获取解析结果
        Set<ConfigurationClass> configClasses = parser.getConfigurationClasses();
        
        // 4. 加载 Bean 定义
        this.reader.loadBeanDefinitions(configClasses);
    }
}

BeanDefinition 加载小结：

方式 核心类 功能
XML 配置 XmlBeanDefinitionReader 解析 XML，注册 <bean> 定义的 Bean
组件扫描 ClassPathBeanDefinitionScanner 扫描 @Component 注解的类
配置类解析 ConfigurationClassPostProcessor 解析 @Configuration 类和 @Bean 方法

四、BeanDefinition 继承体系

4.1 元数据与属性访问

BeanDefinition 继承结构：

BeanDefinition
    │
    ├── BeanMetadataElement（元数据元素）
    │       └── getSource()：获取数据源
    │
    └── AttributeAccessor（属性访问器）
            ├── setAttribute(String, Object)
            ├── getAttribute(String)
            └── removeAttribute(String)

核心接口说明：

BeanMetadataElement - 元数据元素
public interface BeanMetadataElement {
    /**
     * 获取配置源
     * @return 元数据对象（可能为 null）
     */
    @Nullable
    default Object getSource() {
        return null;
    }
}

作用：标识 Bean 的来源（哪个类、哪个配置文件等）

BeanMetadataAttribute - 元数据属性
public class BeanMetadataAttribute implements BeanMetadataElement {
    private final String name;   // 属性名
    @Nullable
    private final Object value;  // 属性值
    @Nullable
    private Object source;       // 数据源
}
AttributeAccessor - 属性访问器
public interface AttributeAccessor {
    /**
     * 设置属性
     */
    void setAttribute(String name, @Nullable Object value);
    
    /**
     * 获取属性
     */
    @Nullable
    Object getAttribute(String name);
    
    /**
     * 移除属性
     */
    @Nullable
    Object removeAttribute(String name);
    
    /**
     * 判断是否包含属性
     */
    boolean hasAttribute(String name);
    
    /**
     * 获取所有属性名
     */
    String[] attributeNames();
}

作用：给 Bean 定义附加额外属性（扩展性设计）

AttributeAccessorSupport - 属性访问抽象实现
public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {
    /** 属性存储容器 */
    private final Map<String, Object> attributes = new LinkedHashMap<>();
    
    @Override
    public void setAttribute(String name, @Nullable Object value) {
        Assert.notNull(name, "Name must not be null");
        if (value != null) {
            this.attributes.put(name, value);
        } else {
            removeAttribute(name);
        }
    }
    
    @Override
    @Nullable
    public Object getAttribute(String name) {
        Assert.notNull(name, "Name must not be null");
        return this.attributes.get(name);
    }
    
    // ... 其他实现
}
BeanMetadataAttributeAccessor - 元数据属性访问器
public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport 
    implements BeanMetadataElement {
    
    @Nullable
    private Object source;
    
    public void setSource(@Nullable Object source) {
        this.source = source;
    }
    
    @Override
    @Nullable
    public Object getSource() {
        return this.source;
    }
}

AbstractBeanDefinition 继承于它，使得同时具有属性访问和元数据访问功能。

继承关系图：

BeanMetadataAttributeAccessor
    │
    ├── AttributeAccessorSupport（属性访问）
    │       └── Map<String, Object> attributes
    │
    └── BeanMetadataElement（元数据）
            └── Object source
                    │
                    ▼
            AbstractBeanDefinition
                    │
                    ├── GenericBeanDefinition
                    ├── RootBeanDefinition
                    ├── ScannedGenericBeanDefinition
                    ├── AnnotatedGenericBeanDefinition
                    └── ConfigurationClassBeanDefinition

4.2 核心实现类

BeanDefinition 继承体系：

BeanDefinition
    │
    ├── AnnotatedBeanDefinition（带注解的 BeanDefinition）
    │       │
    │       ├── ScannedGenericBeanDefinition ← 扫描的 Bean
    │       ├── AnnotatedGenericBeanDefinition ← 注解注册的 Bean
    │       └── ConfigurationClassBeanDefinition ← @Configuration 的 Bean
    │
    └── AbstractBeanDefinition（抽象模板）
            │
            ├── GenericBeanDefinition（通用 BeanDefinition）
            ├── RootBeanDefinition（根 BeanDefinition，合并后的最终形态）
            └── ChildBeanDefinition（子 BeanDefinition，支持父子关系）

各实现类说明：

实现类 用途 特点
GenericBeanDefinition 通用 Bean 定义 最常用的实现，支持设置父 Bean
RootBeanDefinition 根 Bean 定义 合并后的最终形态，内部使用
ScannedGenericBeanDefinition 扫描的 Bean 用于 @ComponentScan 扫描的类
AnnotatedGenericBeanDefinition 注解注册的 Bean 用于 register() 注册的类
ConfigurationClassBeanDefinition 配置类 Bean 用于 @Configuration 和 @Bean
ChildBeanDefinition 子 Bean 定义 继承父 Bean 定义（已废弃）
AnnotatedBeanDefinition 接口
public interface AnnotatedBeanDefinition extends BeanDefinition {
    /**
     * 获取注解元数据
     */
    AnnotationMetadata getMetadata();
    
    /**
     * 获取工厂方法元数据（@Bean 方法）
     */
    @Nullable
    MethodMetadata getFactoryMethodMetadata();
}

作用：用于获取 Bean 所在类的注解信息，在解析处理时需要用到。

AbstractBeanDefinition 模板类

核心属性：

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
    implements BeanDefinition, Cloneable {
    
    // 作用域
    @Nullable
    private String scope = SCOPE_DEFAULT;
    
    // 是否为抽象
    private boolean abstractFlag = false;
    
    // 是否懒加载
    @Nullable
    private Boolean lazyInit;
    
    // 自动装配模式
    private int autowireMode = AUTOWIRE_NO;
    
    // 依赖检查
    private int dependencyCheck = DEPENDENCY_CHECK_NONE;
    
    // 依赖的 Bean
    @Nullable
    private String[] dependsOn;
    
    // 是否为主要候选者
    private boolean primary = false;
    
    // 构造参数
    @Nullable
    private ConstructorArgumentValues constructorArgumentValues;
    
    // 属性值
    @Nullable
    private MutablePropertyValues propertyValues;
    
    // 初始化方法
    @Nullable
    private String initMethodName;
    
    // 销毁方法
    @Nullable
    private String destroyMethodName;
    
    // 工厂 Bean 名称
    @Nullable
    private String factoryBeanName;
    
    // 工厂方法名称
    @Nullable
    private String factoryMethodName;
    
    // Bean 类
    @Nullable
    private volatile Object beanClass;
}

完整类图：

┌─────────────────────────────────────────────────────────────────────┐
│                         BeanDefinition                               │
│  - getBeanClassName(): String                                       │
│  - getScope(): String                                               │
│  - isLazyInit(): boolean                                            │
│  - getConstructorArgumentValues(): ConstructorArgumentValues        │
│  - getPropertyValues(): MutablePropertyValues                       │
└─────────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    AbstractBeanDefinition                            │
│  - scope: String                                                    │
│  - lazyInit: Boolean                                                │
│  - primary: boolean                                                 │
│  - constructorArgumentValues: ConstructorArgumentValues             │
│  - propertyValues: MutablePropertyValues                            │
│  - initMethodName: String                                           │
│  - destroyMethodName: String                                        │
│  - factoryBeanName: String                                          │
│  - factoryMethodName: String                                        │
└──────┬──────────────────────────────────────────────────────────────┘
       │
       ├── GenericBeanDefinition
       │      - parentName: String
       │
       ├── RootBeanDefinition
       │      - 用于合并后的最终 Bean 定义
       │      - 不支持设置父 Bean
       │
       ├── ScannedGenericBeanDefinition
       │      - metadata: AnnotationMetadata
       │      - 用于组件扫描
       │
       ├── AnnotatedGenericBeanDefinition
       │      - metadata: AnnotationMetadata
       │      - 用于注解注册
       │
       └── ConfigurationClassBeanDefinition
              - 用于 @Configuration 类
              - 用于 @Bean 方法

五、总结

核心知识点回顾

1. ApplicationContext 体系

  • 继承 BeanFactory，提供 IoC 容器基础功能
  • 扩展事件发布、资源加载、国际化等高级功能
  • 主要分支：可刷新的 AbstractRefreshableApplicationContext 和通用的 GenericApplicationContext

2. BeanFactory 实现

  • DefaultListableBeanFactory 是核心实现
  • 实现 BeanDefinitionRegistry 接口，管理 Bean 定义
  • 继承 AbstractAutowireCapableBeanFactory，支持自动装配

3. BeanDefinition 加载

  • XML 方式：XmlBeanDefinitionReader 解析 XML 文件
  • 扫描方式：ClassPathBeanDefinitionScanner 扫描 @Component 类
  • 配置类方式：ConfigurationClassPostProcessor 解析 @Configuration 和 @Bean

4. BeanDefinition 继承体系

  • AbstractBeanDefinition：模板类，提供通用属性
  • GenericBeanDefinition：通用实现，支持父子关系
  • RootBeanDefinition：合并后的最终形态
  • ScannedGenericBeanDefinition：扫描生成的 Bean 定义
  • AnnotatedBeanDefinition：接口，提供注解元数据访问

5. 设计亮点

  • 元数据与属性分离：BeanMetadataElement + AttributeAccessor
  • 模板方法模式：AbstractBeanDefinition 提供通用实现
  • 策略模式：不同类型的 BeanDefinition 应对不同场景

与手写框架的对比

功能 手写框架 Spring 源码
BeanDefinition GenericBeanDefinition GenericBeanDefinition、ScannedGenericBeanDefinition 等多种实现
元数据 简单实现 BeanMetadataElement、AnnotationMetadata 完整接口
属性访问 无 AttributeAccessor 接口
XML 解析 简单 DOM 解析 XmlBeanDefinitionReader + BeanDefinitionDocumentReader
注解扫描 简单扫描 ClassPathBeanDefinitionScanner + ASM 元数据读取
配置类解析 简单处理 ConfigurationClassPostProcessor 完整解析流程

学习建议

  1. 阅读源码：重点阅读 DefaultListableBeanFactory、AbstractApplicationContext、ConfigurationClassPostProcessor
  2. 调试跟踪：通过断点调试 Bean 的加载过程
  3. 思考问题：
    • 为什么需要多种 BeanDefinition 实现？
    • RootBeanDefinition 和 GenericBeanDefinition 的区别是什么？
    • Spring 是如何处理循环依赖的 Bean 定义注册的？
  4. 扩展练习：
    • 实现自己的 BeanDefinition 扩展
    • 实现自定义的配置解析器

相关资源

  • Spring Core 文档：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html
  • Spring 源码：https://github.com/spring-projects/spring-framework
  • Spring 中文文档：https://github.com/DocsHome/spring-docs

如果本文对你有帮助，欢迎点赞、收藏、关注！如有疑问，欢迎在评论区留言讨论。

关键词：Spring 源码, ApplicationContext, BeanFactory, BeanDefinition, 注解配置, XML 配置, 组件扫描, 元数据, 属性访问

本文是 Spring 源码分析系列第一篇，深入分析了 ApplicationContext 体系结构和 BeanDefinition 加载原理。敬请期待后续文章…

# spring # java # 后端 # 开源 # 架构
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

19 AI 时代的程序员核心竞争力——什么技能不会被替代？

avatar AI编程社区
cover

【Codex】掌握 Codex 渐进加载 Skills，高效拓展自动化工作流

avatar AI编程社区

企业采购AI订阅的发票与合规路径分析

企业采购 ChatGPT、Claude、Gemini 这类 AI 订阅，财务侧的硬约束通常有两条：费用列支需要合规发票，付款方式最好走对公。而海外 AI 平台恰好两条都给不了——境外主体开不出国内税务体系的发票，也不接对公人民币转账。这个缺口决定了企业采购的实际路径：通过具备国内经营主体、能开增值税发票的正规充值服务完成采购。本文从财务合规视角拆解这条路径：发票为什么是筛选服务方的第一标准、普票专

avatar AI编程社区