Spring 源码深度解析：ApplicationContext 体系结构与 BeanDefinition 加载原理

最新推荐文章于 2026-06-14 23:58:53 发布
原创 最新推荐文章于 2026-06-14 23:58:53 发布 · 465 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #后端 #开源 #架构

关键词：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 + 高级功能

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

1.2 核心接口分析

ApplicationContext 继承结构：

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

接口职责说明：

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

1.3 实现类分支

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

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

两大分支对比：

分支特点代表实现
AbstractRefreshableApplicationContext每次刷新都会重建 BeanFactoryClassPathXmlApplicationContext
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 源码
BeanDefinitionGenericBeanDefinitionGenericBeanDefinition、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 源码：从BeanDefinition源码探索Bean的本质
忆~遂愿的博客
04-30 5057
本文深入解析Spring框架的核心组件之一，即BeanDefinition，探索Bean的本质。首先介绍了BeanDefinition的概念和作用，它是Spring中管理Bean配置元数据的接口，定义了Bean的各种属性和行为。接着，分析了BeanDefinition的实现类以及其重要属性，如Bean的类名、作用域、构造函数、依赖关系等。通过深入研究BeanDefinition的源码，揭示了Spring是如何管理和创建Bean实例的过程。
《Spring源码深度解析》
热门推荐
ByteX的博客
07-07 4万+
Spring整体架构和环境搭建 Spring整体架构 Spring Core：框架的最基础部分，提供 IoC 容器，对 bean 进行管理。 Spring Context：继承BeanFactory，提供上下文信息，扩展出JNDI、EJB、电子邮件、国际化等功能。 Spring DAO：提供了JDBC的抽象层，还提供了声明性事务管理方法。 Spring ORM：提供了JPA、JDO、Hibernate、MyBatis 等ORM映射层. Spring AOP：集成了所有AOP功能 Spring Web：提供
Spring源码——容器扩展ApplicationContext
等一杯咖啡的博客
10-06 4891
Spring源码——容器扩展ApplicationContext 前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第六章的部分，依照书中内容以及个人理解对Spring进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framewor...
Spring IOC容器加载流程原理源码深度剖析
Zhuxiaoyu_91的博客
01-13 902
Spring IOC容器加载流程原理源码深度剖析
【infra之路】02_RadixAttention与KV_Cache管理
sweet_ran的博客
06-09 352
LLM 推理过程中，KV Cache 的管理效率直接决定吞吐量。vLLM 的 PagedAttention 用固定大小的 block 解决了显存碎片问题，但留下了一个遗憾：前缀缓存必须按 block 边界对齐，语义上完整的前缀被 block 尺寸强行截断。SGLang 的 RadixAttention 用一棵变长的基数树绕开了这个限制，把缓存匹配精度从 block 级提升到 token 级。
Spring AI Alibaba 1.x 系列【73】两步 RAG
记录知识、锤炼自我
06-10 194
检索增强生成（Retrieval-Augmented Generation，RAG） 通过在查询时获取相关的外部知识来解决这些问题：使用特定上下文信息来增强 LLM 的回答。
Spring AI Alibaba 1.x 系列【74】Agentic RAG 与混合 RAG
记录知识、锤炼自我
06-10 242
Agentic RAG 将检索增强生成与基于 Agent 的推理相结合。Agent 不是在生成之前固定检索文档，而是逐步推理并自主决定在交互过程中何时以及如何检索信息。
ai-agent框架spring ai/alibaba 原理源码分析(五) graph I 状态图
leehom的博客
06-12 224
本文深入剖析Spring AI Alibaba（SAA）框架1.1.2.2版本的图结构设计与实现。SAA通过StateGraph构建复杂AI应用流程，核心包含节点（基础节点/子图节点）、边（条件路由/并行路由）和状态管理三大要素。文章重点分析了四大推理框架在图结构中的映射实现：Reflection的自我优化循环、ReAct的"思考-行动"闭环、CoT的推理链以及Plan-and-Execute的规划执行分离架构
SpringMVC 入门到实战 DispatcherServlet 源码解读 92-95
道友
06-13 334
SpringMVC 入门到实战 DispatcherServlet 源码解读 92-95
ACE-6.3 Issuing snoop transactions（发出监听事务）
最新发布
weixin_44700185的博客
06-14 29
主题集成动作串行 snoop互连可配置为串行发送 snoop，以降低峰值带宽。收到PassDirty后的优化一旦某个 master 返回脏数据，剩余 master 只需使用失效即可，无需再要求写回。适用事务ReadUnique可从该优化中受益。互连实现需要维护状态：是否已收到PassDirty，并动态调整后续 snoop 类型。在实际多核多簇 SoC 中，这种优化可以减少不必要的写回操作，降低功耗和 snoop 延迟。
SpringMVC 入门到实战 SpringMVC 的执行流程 96
道友
06-13 174
SpringMVC 入门到实战 SpringMVC 的执行流程 96
Spring AI 结构化输出 + 大模型参数全解（含千问调优）
qq_69304031的博客
06-12 438
结构化输出（Structured Output）：让大模型不返回自由文本，而是严格按指定格式（如 JSON）输出，程序可直接解析成对象，免手动字符串处理、免正则、免 JSON.parse 异常Spring。结构化输出：大模型返回 JSON，Spring AI 一键转 Java Bean，类型安全、稳定高效Spring。两种写法.entity()简洁、灵活。三大参数temperature 控创意、top_k 控数量、top_p 控概率，场景化设置即可。千问调优。
spring3.5的本质改变
weixin_46228563的博客
06-11 294
Spring Boot 3.5 在项目里「常用且本质」的变化，可以分成两类：必须改的底座，和日常开发会真正用到的能力。
Spring 零基础入门到进阶 基于注解管理 Bean 38-43
道友
06-09 226
Spring 零基础入门到进阶 基于注解管理 Bean 38-43
SpringMVC 入门到实战 文件上传 75-77
道友
06-12 273
SpringMVC 入门到实战 文件上传 75-77
SpringBoot 动态国际化
qq_30118563的博客
06-10 202
Data// 国际化key// 语言// 翻译值@Mapper// 查询所有国际化数据这是实现热更新的关键/*** 动态国际化：DB存储 + 热更新*/// 本地缓存：key = code + "_" + lang，value = 翻译内容@Resource/*** 加载DB数据到缓存*//*** 拼接缓存key：code + 语言*//*** 重写核心方法：从缓存读取翻译*/@Override。
从硬编码到“规则即配置”！SpringBoot 整合 Drools 8 实现电商促销规则动态编排
1加1等于的博客
06-10 620
摘要 本文介绍了如何使用Drools 8规则引擎解决电商促销场景中的动态规则管理问题。传统硬编码方式存在频繁发版、代码臃肿等缺点，而Drools可将促销逻辑从业务代码中剥离，实现规则动态配置和实时生效。 主要内容包括： Drools核心概念：Fact（业务数据对象）、DRL规则文件（when-then语法）和Kie容器 SpringBoot集成Drools 8的实战步骤：引入依赖、创建Fact实体类、编写DRL规则文件 电商促销规则实现示例：包含基础满减、VIP折扣和新用户优惠的叠加规则 通过salienc
Spring Security 配置类（SecurityConfig）
2503_93626619的博客
06-10 228
java运行@Autowired// 分页查询权限列表// 新增权限// 更新权限// 删除权限。
springboot我们项目中的常见注解
weixin_46228563的博客
06-11 186
├── repository/ @Repository 或 JpaRepository 接口。Spring Boot 3.x 里这些是。@Autowired / 构造器注入。
【Spring AI + Google ADK 】流式输出时 outputKey 状态缓存失败的问题
Candy___i的博客
06-12 333
Google ADK Java 中的 LlmAgent.outputKey 机制在多 Agent 工作流中存在流式输出问题。当切换到 Spring AI 流式模式时，中间 token 可能被错误标记为最终响应（partial=false），导致 outputKey 提前写入残缺片段。问题的核心在于 Spring AI 到 ADK 的适配层破坏了 Event.partial 的语义，正确的实现应确保只有最终 chunk 标记为 partial=false。ADK 通过 event.finalResponse(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

加倍巴巴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值