IoC容器深度解析

深入分析Spring IoC容器的工作原理，理解BeanFactory和ApplicationContext的实现机制，掌握BeanDefinition的结构和解析、Bean的创建流程、依赖注入等核心原理。

📋 IoC容器概览

IoC（Inversion of Control，控制反转）是Spring框架的核心，通过IoC容器管理Bean的生命周期和依赖关系。

🎯 一、BeanFactory体系

1.1 BeanFactory接口

BeanFactory是IoC容器的基础接口，定义了获取Bean的基本方法：

java

public interface BeanFactory {
    
    // 获取Bean（根据名称）
    Object getBean(String name) throws BeansException;
    
    // 获取Bean（根据类型）
    <T> T getBean(Class<T> requiredType) throws BeansException;
    
    // 获取Bean（根据名称和类型）
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    
    // 判断Bean是否存在
    boolean containsBean(String name);
    
    // 判断Bean是否为单例
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    
    // 判断Bean是否为原型
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    
    // 获取Bean的类型
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    
    // 获取Bean的别名
    String[] getAliases(String name);
}

核心方法：

getBean：获取Bean实例（支持按名称、类型、名称+类型获取）
containsBean：判断容器中是否存在指定Bean
isSingleton/isPrototype：判断Bean的作用域
getType：获取Bean的类型

1.2 ListableBeanFactory接口

ListableBeanFactory扩展了BeanFactory，提供了批量获取Bean的能力：

java

public interface ListableBeanFactory extends BeanFactory {
    
    // 获取指定类型的所有Bean名称
    String[] getBeanNamesForType(Class<?> type);
    
    // 获取指定类型的所有Bean名称（包括父容器）
    String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, 
            boolean allowEagerInit);
    
    // 获取指定类型的所有Bean
    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
    
    // 获取所有Bean定义名称
    String[] getBeanDefinitionNames();
    
    // 获取Bean定义数量
    int getBeanDefinitionCount();
    
    // 判断是否有指定类型的Bean
    boolean containsBeanDefinition(String beanName);
}

特点：

支持批量操作
支持类型匹配
支持父容器查找

1.3 HierarchicalBeanFactory接口

HierarchicalBeanFactory提供了父子容器的支持：

java

public interface HierarchicalBeanFactory extends BeanFactory {
    
    // 获取父BeanFactory
    BeanFactory getParentBeanFactory();
    
    // 判断本地容器是否包含指定Bean（不包括父容器）
    boolean containsLocalBean(String name);
}

应用场景：

Spring MVC中，DispatcherServlet创建的容器作为子容器
父容器负责业务Bean，子容器负责Web相关Bean

1.4 DefaultListableBeanFactory

DefaultListableBeanFactory是BeanFactory的核心实现类：

java

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, 
        Serializable {
    
    // Bean定义注册表（名称 -> BeanDefinition）
    private final Map<String, BeanDefinition> beanDefinitionMap = 
            new ConcurrentHashMap<>(256);
    
    // Bean定义名称列表（按注册顺序）
    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
    
    // 单例Bean缓存（一级缓存）
    private final Map<String, Object> singletonObjects = 
            new ConcurrentHashMap<>(256);
    
    // 早期单例Bean缓存（二级缓存）
    private final Map<String, Object> earlySingletonObjects = 
            new ConcurrentHashMap<>(16);
    
    // 单例Bean工厂缓存（三级缓存）
    private final Map<String, ObjectFactory<?>> singletonFactories = 
            new HashMap<>(16);
}

核心属性：

beanDefinitionMap：存储所有Bean定义
singletonObjects：存储单例Bean实例（一级缓存）
earlySingletonObjects：存储早期单例Bean（二级缓存）
singletonFactories：存储单例Bean工厂（三级缓存，用于解决循环依赖）

🎯 二、ApplicationContext体系

2.1 ApplicationContext接口

ApplicationContext是Spring的高级IoC容器接口，继承了BeanFactory并扩展了很多功能：

java

public interface ApplicationContext extends EnvironmentCapable, 
        ListableBeanFactory, HierarchicalBeanFactory,
        MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    
    // 获取容器ID
    String getId();
    
    // 获取应用名称
    String getApplicationName();
    
    // 获取显示名称
    String getDisplayName();
    
    // 获取启动时间
    long getStartupDate();
    
    // 获取父上下文
    ApplicationContext getParent();
    
    // 获取AutowireCapableBeanFactory
    AutowireCapableBeanFactory getAutowireCapableBeanFactory() 
            throws IllegalStateException;
}

扩展功能：

EnvironmentCapable：环境配置支持
MessageSource：国际化消息支持
ApplicationEventPublisher：事件发布支持
ResourcePatternResolver：资源解析支持

2.2 ConfigurableApplicationContext接口

ConfigurableApplicationContext提供了配置和管理容器的能力：

java

public interface ConfigurableApplicationContext extends ApplicationContext, 
        Lifecycle, Closeable {
    
    // 设置容器ID
    void setId(String id);
    
    // 设置父容器
    void setParent(ApplicationContext parent);
    
    // 设置环境
    void setEnvironment(ConfigurableEnvironment environment);
    
    // 添加BeanFactoryPostProcessor
    void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor);
    
    // 添加ApplicationListener
    void addApplicationListener(ApplicationListener<?> listener);
    
    // 刷新容器（核心方法）
    void refresh() throws BeansException, IllegalStateException;
    
    // 注册关闭钩子
    void registerShutdownHook();
    
    // 关闭容器
    @Override
    void close();
}

核心方法：

refresh()：刷新容器，加载和初始化所有Bean
registerShutdownHook()：注册JVM关闭钩子，确保容器优雅关闭

2.3 AbstractApplicationContext

AbstractApplicationContext是ApplicationContext的抽象实现类，实现了refresh()方法：

java

public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    
    // 刷新容器（核心方法）
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 1. 准备刷新
            prepareRefresh();
            
            // 2. 获取BeanFactory
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            
            // 3. 准备BeanFactory
            prepareBeanFactory(beanFactory);
            
            try {
                // 4. 后处理BeanFactory
                postProcessBeanFactory(beanFactory);
                
                // 5. 调用BeanFactoryPostProcessor
                invokeBeanFactoryPostProcessors(beanFactory);
                
                // 6. 注册BeanPostProcessor
                registerBeanPostProcessors(beanFactory);
                
                // 7. 初始化MessageSource
                initMessageSource();
                
                // 8. 初始化ApplicationEventMulticaster
                initApplicationEventMulticaster();
                
                // 9. 初始化其他特殊Bean（由子类实现）
                onRefresh();
                
                // 10. 注册监听器
                registerListeners();
                
                // 11. 完成BeanFactory初始化，实例化所有单例Bean
                finishBeanFactoryInitialization(beanFactory);
                
                // 12. 完成刷新
                finishRefresh();
            }
            catch (BeansException ex) {
                // ...
                destroyBeans();
                cancelRefresh(ex);
                throw ex;
            }
            finally {
                // 清除缓存
                resetCommonCaches();
            }
        }
    }
}

refresh方法流程图：

🎯 三、BeanDefinition体系

3.1 BeanDefinition接口

BeanDefinition是Bean定义的核心接口，描述了Bean的元数据信息：

java

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    
    // Bean的类名
    void setBeanClassName(String beanClassName);
    String getBeanClassName();
    
    // Bean的作用域（singleton/prototype）
    void setScope(String scope);
    String getScope();
    
    // 是否懒加载
    void setLazyInit(boolean lazyInit);
    boolean isLazyInit();
    
    // 依赖的Bean名称
    void setDependsOn(String... dependsOn);
    String[] getDependsOn();
    
    // 是否作为自动注入的候选者
    void setAutowireCandidate(boolean autowireCandidate);
    boolean isAutowireCandidate();
    
    // 是否为主Bean（存在多个同类型Bean时）
    void setPrimary(boolean primary);
    boolean isPrimary();
    
    // 工厂Bean名称
    void setFactoryBeanName(String factoryBeanName);
    String getFactoryBeanName();
    
    // 工厂方法名称
    void setFactoryMethodName(String factoryMethodName);
    String getFactoryMethodName();
    
    // 构造器参数值
    ConstructorArgumentValues getConstructorArgumentValues();
    
    // 属性值（PropertyValue）
    MutablePropertyValues getPropertyValues();
    
    // 初始化方法名称
    void setInitMethodName(String initMethodName);
    String getInitMethodName();
    
    // 销毁方法名称
    void setDestroyMethodName(String destroyMethodName);
    String getDestroyMethodName();
    
    // Bean的角色（ROLE_APPLICATION/ROLE_SUPPORT/ROLE_INFRASTRUCTURE）
    void setRole(int role);
    int getRole();
    
    // Bean的描述
    void setDescription(String description);
    String getDescription();
    
    // 是否单例
    boolean isSingleton();
    
    // 是否原型
    boolean isPrototype();
    
    // 是否抽象
    boolean isAbstract();
}

核心属性：

beanClassName：Bean的类名
scope：Bean的作用域
propertyValues：属性值（用于属性注入）
constructorArgumentValues：构造器参数值
factoryMethodName：工厂方法名称

3.2 BeanDefinition的实现类

AbstractBeanDefinition：BeanDefinition的抽象实现：

java

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
        implements BeanDefinition, Cloneable {
    
    private volatile Object beanClass;
    
    private String scope = SCOPE_DEFAULT;
    
    private boolean abstractFlag = false;
    
    private boolean lazyInit = false;
    
    private int autowireMode = AUTOWIRE_NO;
    
    private int dependencyCheck = DEPENDENCY_CHECK_NONE;
    
    private String[] dependsOn;
    
    private boolean autowireCandidate = true;
    
    private boolean primary = false;
    
    private final MutablePropertyValues propertyValues;
    
    private MethodOverrides methodOverrides = new MethodOverrides();
    
    private String factoryBeanName;
    
    private String factoryMethodName;
    
    private String initMethodName;
    
    private String destroyMethodName;
    
    private int role = BeanDefinition.ROLE_APPLICATION;
    
    private String description;
    
    private Resource resource;
}

RootBeanDefinition：根Bean定义（用于常规Bean）：

java

public class RootBeanDefinition extends AbstractBeanDefinition {
    // 存储Bean的完整类型信息
    private volatile Class<?> beanClass;
    
    // 存储工厂方法
    private Method factoryMethod;
    
    // 存储构造器
    private Constructor<?> resolvedConstructorOrFactoryMethod;
}

GenericBeanDefinition：通用Bean定义（用于配置类）：

java

public class GenericBeanDefinition extends AbstractBeanDefinition {
    // 父Bean定义名称
    private String parentName;
}

AnnotatedGenericBeanDefinition：注解通用Bean定义（用于注解配置）：

java

public class AnnotatedGenericBeanDefinition extends GenericBeanDefinition 
        implements AnnotatedBeanDefinition {
    private final AnnotationMetadata metadata;
}

🎯 四、Bean的创建流程

4.1 Bean创建流程概览

Bean的创建是一个复杂的过程，涉及多个步骤：

4.2 getBean方法

AbstractBeanFactory.getBean：

java

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType,
        @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    
    String beanName = transformedBeanName(name);
    Object bean;
    
    // 1. 先尝试从单例缓存中获取
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    else {
        // 2. 如果缓存中没有，检查是否正在创建
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        
        // 3. 检查父容器
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory)
                        .doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }
        
        try {
            // 4. 获取BeanDefinition
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);
            
            // 5. 处理依赖的Bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(...);
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(...);
                    }
                }
            }
            
            // 6. 创建Bean实例
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            else if (mbd.isPrototype()) {
                // 原型Bean每次都创建新实例
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            else {
                // 其他作用域
                String scopeName = mbd.getScope();
                Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException(...);
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new BeanCreationException(...);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }
    
    // 7. 类型检查
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, 
                        bean.getClass());
            }
            return convertedBean;
        }
        catch (TypeMismatchException ex) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

4.3 createBean方法

AbstractAutowireCapableBeanFactory.createBean：

java

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, 
        @Nullable Object[] args) throws BeanCreationException {
    
    RootBeanDefinition mbdToUse = mbd;
    
    // 1. 解析Bean的Class
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    
    // 2. 处理lookup-method和replace-method
    try {
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(...);
    }
    
    try {
        // 3. 给BeanPostProcessor一个机会返回代理对象
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(...);
    }
    
    try {
        // 4. 实际创建Bean
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(...);
    }
}

4.4 doCreateBean方法

AbstractAutowireCapableBeanFactory.doCreateBean：

java

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, 
        @Nullable Object[] args) throws BeanCreationException {
    
    // 1. 实例化Bean
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }
    
    // 2. 允许MergedBeanDefinitionPostProcessor后处理
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(...);
            }
            mbd.postProcessed = true;
        }
    }
    
    // 3. 提前暴露引用（解决循环依赖）
    boolean earlySingletonExposure = (mbd.isSingleton() && 
            this.allowCircularReferences && 
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    
    // 4. 初始化Bean实例
    Object exposedObject = bean;
    try {
        populateBean(beanName, mbd, instanceWrapper);
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(
                ((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(...);
        }
    }
    
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }
            else if (!this.allowCircularReferences || 
                    this.singletonsCurrentlyInCreation.contains(beanName)) {
                // ...
            }
        }
    }
    
    // 5. 注册Bean的销毁方法
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(...);
    }
    
    return exposedObject;
}

🎯 五、依赖注入

5.1 依赖注入方式

Spring支持三种依赖注入方式：

构造器注入：通过构造器参数注入依赖
Setter注入：通过Setter方法注入依赖
字段注入：通过@Autowired注解直接注入字段

5.2 自动装配模式

Spring支持多种自动装配模式：

AUTOWIRE_NO：不自动装配（默认）
AUTOWIRE_BY_NAME：按名称自动装配
AUTOWIRE_BY_TYPE：按类型自动装配
AUTOWIRE_CONSTRUCTOR：按构造器自动装配

5.3 populateBean方法

AbstractAutowireCapableBeanFactory.populateBean：

java

protected void populateBean(String beanName, RootBeanDefinition mbd, 
        @Nullable BeanWrapper bw) {
    
    if (bw == null) {
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(...);
        }
        else {
            return;
        }
    }
    
    // 给InstantiationAwareBeanPostProcessor一个机会修改属性值
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = 
                        (InstantiationAwareBeanPostProcessor) bp;
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), 
                        beanName);
                if (pvsToUse == null) {
                    if (filteredPds == null) {
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, 
                                mbd.allowCaching);
                    }
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, 
                            bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }
                }
                pvs = pvsToUse;
            }
        }
    }
    
    // 应用属性值
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }
    
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

📖 学习资源

视频教程

书籍推荐

《Spring源码深度解析》 - 郝佳
《Spring技术内幕》 - 计文柯
《深入理解Spring框架》 - 张卫滨

网站资源

✅ 学习检查清单

[ ] 已理解BeanFactory接口体系
[ ] 已理解ApplicationContext接口体系
[ ] 已理解BeanDefinition的结构和作用
[ ] 已理解Bean的创建流程
[ ] 已理解依赖注入机制
[ ] 已理解单例Bean的缓存机制
[ ] 已理解BeanFactoryPostProcessor的作用
[ ] 已理解BeanPostProcessor的作用
[ ] 已绘制IoC容器架构图
[ ] 已总结核心知识点

上一章节：Spring源码深度解析概览
下一章节：AOP实现原理
返回目录：源码阅读

开发与调试

测试能力

运维与监控

NoSQL

中间件

存储

接入层

操作系统

框架

硬件知识

缓存

品质

经验底蕴

能力

任务拆分

文档能力

协议设计

基本理论

接入层架构

数据层架构

通讯机制

逻辑层架构

IoC容器深度解析 ​

📋 IoC容器概览 ​

🎯 一、BeanFactory体系 ​

1.1 BeanFactory接口 ​

1.2 ListableBeanFactory接口 ​

1.3 HierarchicalBeanFactory接口 ​

1.4 DefaultListableBeanFactory ​

🎯 二、ApplicationContext体系 ​

2.1 ApplicationContext接口 ​

2.2 ConfigurableApplicationContext接口 ​

2.3 AbstractApplicationContext ​

🎯 三、BeanDefinition体系 ​

3.1 BeanDefinition接口 ​

3.2 BeanDefinition的实现类 ​

🎯 四、Bean的创建流程 ​

4.1 Bean创建流程概览 ​

4.2 getBean方法 ​

4.3 createBean方法 ​

4.4 doCreateBean方法 ​

🎯 五、依赖注入 ​

5.1 依赖注入方式 ​

5.2 自动装配模式 ​

5.3 populateBean方法 ​

📖 学习资源 ​

视频教程 ​

书籍推荐 ​

网站资源 ​

✅ 学习检查清单 ​

IoC容器深度解析

📋 IoC容器概览

🎯 一、BeanFactory体系

1.1 BeanFactory接口

1.2 ListableBeanFactory接口

1.3 HierarchicalBeanFactory接口

1.4 DefaultListableBeanFactory

🎯 二、ApplicationContext体系

2.1 ApplicationContext接口

2.2 ConfigurableApplicationContext接口

2.3 AbstractApplicationContext

🎯 三、BeanDefinition体系

3.1 BeanDefinition接口

3.2 BeanDefinition的实现类

🎯 四、Bean的创建流程

4.1 Bean创建流程概览

4.2 getBean方法

4.3 createBean方法

4.4 doCreateBean方法

🎯 五、依赖注入

5.1 依赖注入方式

5.2 自动装配模式

5.3 populateBean方法

📖 学习资源

视频教程

书籍推荐

网站资源

✅ 学习检查清单