Bean生命周期（详细，按源码步骤一步步分析）

淩亂°似流年 2024-04-07 14:28 24阅读 0赞

> [Java知识点总结：想看的可以从这里进入][Java]

#### 目录 ####

*   *  7、Bean的生命周期
     *   *  7.1、生命周期流程
         *  7.2、源码分析
         *   *  7.2.1、doGetBean
             *  7.2.2、Bean信息注册
             *  7.2.3、获取注册信息
             *  7.2.4、检查依赖关系
             *  7.2.5、判断Scope
             *   *  1、缓存中获取
                 *  2、创建单例Bean
                 *  3、创建原型Bean
                 *  4、其他
             *  7.2.6、实例化前准备
             *   *  1、引用问题
                 *  2、方法覆盖
                 *  3、前置处理
             *  7.2.7、实例化初始化
             *   *  1、BeanWrapper
                 *  2、实例化Bean
                 *  3、处理循环依赖
                 *  4、属性注入
                 *  5、调用初始化方法
                 *   *  检查Aware接口
                     *  初始化前置方法
                     *  开始初始化
                     *  初始化后置方法
                 *  6、注册销毁方法
             *  7.2.8、实例化完成
             *  7.2.9、销毁

### 7、Bean的生命周期 ###

--------------------

#### 7.1、生命周期流程 ####

![bean的声明周期][bean]

1.  Spring容器启动后，获取配置文件，注册配置的 Bean

*  资源定位：通过ResourceLoader进行资源定位，可以通过class的全限定名确定Bean的位置
 *  元信息解析：BeanDefinitionReader读取定位到所有Bean，将每一个Bean都解析成一个`BeanDefinition对象(包含Bean的各种信息：class名、作用域、懒加载、FactoryBean、构造函数、属性值、描述以及bean的来源等)`，并加载到内存中。（XmlBeanDefinationReader读取XML配置信息、PropertiesBeanDefinitionReader读取properties配置文件、AnnotatedBeanDefinitionReader读取注解配置元信息）
 *  元信息注册：Spring将这些BeanDefinition对象都保存到 BeanDefinitionRegistry(Bean定义注册表)的ConcurrentHashMap集合中。
 *  BeanDefinition合并：Spring通过BeanFactoryPostProcessor将这些BeanDefinition对象进行整理合并（子类覆盖父类属性，占位符替换成真实数据等等），然后生成一个RootBeanDefinition对象（继承了AbstractBeanDefinition，而AbstractBeanDefinition实现了BeanDefinition）。
    
    RootBeanDefinition 本质上是 Spring BeanFactory 运行时统一的 BeanDefinition 视图，Spring在获取Bean是就是获取这个对象，通过次对象获取相应的Bean

1.  通过 getMergedLocalBeanDefinition(beanName) 获取注册信息，并检查bean之间的依赖关系，确保bean初始化前，它所依赖的其他bean已经被初始化
2.  准备实例化

*  获取 scope属性的值，根据不同的值，选择不同的创建方式。（缓存中、单例、原型、其他）
 *  在实例化前进行一些必要的处理
    
     *  间接引用替换成直接引用
     *  查是否存在覆盖方法
     *  执行前置处理器，做进一步的检查

1.  开始 实例化、初始化Bean对象

*  实例化Bean对象，并创建一个BeanWrapper对象，将Bean对象注入
 *  处理循环依赖问题
 *  开始属性注入
 *  调用初始化方法
    
     *  查看是否实现了Aware相关的接口
     *  初始化前置处理方法
     *  初始化方法
     *  初始化后置处理方法

1.  初始化完成，Bean对象创建成功
2.  根据不同的bean在不同的时机销毁bean对象

#### 7.2、源码分析 ####

##### 7.2.1、doGetBean #####

在 ApplicationContext 类型容器的内部持有一个BeanFactory类型的容器，所有的bean实际是存放在这个内置容器中的。ApplicationContext类型的容器在启动的过程中会自动创建所有单例类型的bean，实际是调用了`getBean(beanName)`这个方法，此方法就是调用的 doGetBean 方法。

所以说研究Bean的生命周期，离不开doGetBean方法。

//ApplicationContext下的getBean
    Object getBean(String name) throws BeansException;

//AbstractBeanFactory实现的getBean方法
    @Override
    public Object getBean(String name) throws BeansException {
        
        //调用doGetBean
        return doGetBean(name, null, null, false);
    }

/*参数：
    	name要获取的bean名
    	requiredType要获取的bean的类型
    	args使用显式参数创建 bean 实例时使用的参数（仅在创建新实例而不是检索现有实例时应用）
    	typeCheckOnly是否获取实例进行类型检查，而不是实际使用
    */
    protected <T> T doGetBean(
        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {
        
        //返回 bean 名称，必要时去除工厂取消引用前缀，并将别名解析为规范名称
        String beanName = transformedBeanName(name);
        //bean实例
        Object beanInstance;
        
        //1、检查缓存中是否有手动注册的单例，如果缓存中有，则直接从缓存中加载
        Object sharedInstance = getSingleton(beanName);
        //从缓存中获取到了
        if (sharedInstance != null && args == null) {
        
            //跟踪启用
            if (logger.isTraceEnabled()) {
        
                //此 bean 当前是否正在创建中
                if (isSingletonCurrentlyInCreation(beanName)) {
        
                    logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
        
                    logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            //获取创建好的Bean实例
            beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        
        //2、如果缓存中没有对应bean，需要通过父类工厂加载Bean的一些配置信息
        else {
        
            //如果是目前正在创建的原型，则出错。
            if (isPrototypeCurrentlyInCreation(beanName)) {
        
                throw new BeanCurrentlyInCreationException(beanName);
            }
            // 获取父工厂
            BeanFactory parentBeanFactory = getParentBeanFactory();
            //获取到了父工厂，且自身工厂内不存在该bean（双亲委派机制）
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
        
                //获取原始 bean 名称，将本地定义的别名解析为规范名称。
                String nameToLookup = originalBeanName(name);
                 //根据doGetBean的四个参数进行判断
                //父工厂是AbstractBeanFactory的实例，调用父工厂的doGetBean
                if (parentBeanFactory instanceof AbstractBeanFactory) {
        
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
        
                    //用显式参数委托给父对象。.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) {
        
                    // 没有参数 -> 委托给标准的getBean方法。
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
        
                    return (T) parentBeanFactory.getBean(nameToLookup);
                }
            }
            //是否获取实例进行类型检查，将指定的 bean 标记为已创建（或即将创建）。
            if (!typeCheckOnly) {
        
                markBeanAsCreated(beanName);
            }
            //应用程序启动指标，创建一个新步骤并标记它的开始。
            StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
                .tag("beanName", name);
            try {
        
                //bean的类型不为空
                if (requiredType != null) {
        
                    beanCreation.tag("beanType", requiredType::toString);
                }
                // 从bean 名称映射中返回一个合并的 RootBeanDefinition，存放的整合的Bean信息
                RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                //检查给定的合并 bean 定义，可能会引发验证异常
                checkMergedBeanDefinition(mbd, beanName, args);
                
                //初始化依赖的bean。返回此 bean 所依赖的 bean 名称。
                String[] dependsOn = mbd.getDependsOn();
                //不为null。表示Bean中依赖了其他的Bean
                if (dependsOn != null) {
        
                    for (String dep : dependsOn) {
        
                         //如果此依赖已注册为依赖项
                        if (isDependent(beanName, dep)) {
        
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        //为bean注册依赖
                        registerDependentBean(dep, beanName);
                        try {
        .
                            //递归（注册的bean可能还依赖了其他bean，需要递归）
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
        
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }
    			
                //3、到了此处开始创建bean，如果是单列的
                if (mbd.isSingleton()) {
        
                    // 第二个参数的回调接口，接口是接口实现的方法是 createBean(beanName, mbd, args)
                    sharedInstance = getSingleton(beanName, () -> {
        
                        try {
        
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
        
                            // 显式地从单例缓存中删除实例:它可能已经放在那里了
                            // 由创建过程触发，以允许循环引用解析
                            // 删除接收到该bean临时引用的所有bean。
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName,mbd);
                }
                //4、如果非单例
                else if (mbd.isPrototype()) {
        
                    // 这是一个原型 -> 创建一个新实例
                    Object prototypeInstance = null;
                    try {
        
                        //建原型之前的回调。默认实现将原型注册为当前正在创建中
                        beforePrototypeCreation(beanName);
                        //开始创建原型模式
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
        
                        //创建原型后的回调。默认实现将原型标记为不再处于创建状态
                        afterPrototypeCreation(beanName);
                    }
                    beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }
    			//5、不是单例，又不是原型
                else {
        
                    String scopeName = mbd.getScope();
                    if (!StringUtils.hasLength(scopeName)) {
        
                        throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
                    }
                    Scope scope = this.scopes.get(scopeName);
                    if (scope == null) {
        
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
                    try {
        
                        Object scopedInstance = scope.get(beanName, () -> {
        
                            beforePrototypeCreation(beanName);
                            try {
        
                                return createBean(beanName, mbd, args);
                            }
                            finally {
        
                                afterPrototypeCreation(beanName);
                            }
                        });
                        beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) {
        
                        throw new ScopeNotActiveException(beanName, scopeName, ex);
                    }
                }
            }
            catch (BeansException ex) {
        
                beanCreation.tag("exception", ex.getClass().toString());
                beanCreation.tag("message", String.valueOf(ex.getMessage()));
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
            finally {
        
                beanCreation.end();
            }
        }
        return adaptBeanInstance(name, beanInstance, requiredType);
    }

方法内包含了获取Bean信息，到获取Bean对象等一系列步骤：

先检查缓存，缓存中存在单例的Bean则从缓存中实例化

如果缓存中不存在，需要通过父类工厂加载Bean的一些配置信息

加载完成后开始创建，先判断是否为单例，是创建单例Bean，再判断是否为原型，是就创建原型的Bean如果两者都不是则获取Scope属性。

最后再获取Bean的实例对象（贯穿始终的，每次加载创建的Bean都需要获取）

##### 7.2.2、Bean信息注册 #####

在Spring启动后，框架首先开始对配置的Bean进行资源整合。SpringIOC容器会为我们管理所需的一些Bean，而Spring需要获取到这些Bean的全部信息，才能在容器中生成并进行管理。这一步主要是通过XML文件、注解等获取我们已经配置的Bean的一些信息。

*  资源定位：通过ResourceLoader进行资源定位，可以通过class的全限定名确定Bean的位置
 *  元信息解析：BeanDefinitionReader读取定位到所有Bean，将每一个Bean都解析成一个\`BeanDefinition对象，并加载到内存中。
 *  元信息注册：Spring将这些BeanDefinition对象都保存到 BeanDefinitionRegistry(Bean定义注册表)的ConcurrentHashMap集合中。
 *  BeanDefinition合并：Spring通过BeanFactoryPostProcessor将这些BeanDefinition对象进行整理合并（子类覆盖父类属性，占位符替换成真实数据等等），然后生成一个RootBeanDefinition对象

//信息注册，并返回注册的信息
    protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) throws BeanDefinitionStoreException {
        
        return getMergedBeanDefinition(beanName, bd, null);
    }
    /*
    	beanName – bean 定义的名称
    	bd – 原始 bean 定义
    	containsBd – 如果是顶级 bean， 则为null
    */
    protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)throws BeanDefinitionStoreException {
        
        synchronized (this.mergedBeanDefinitions) {
        	
            RootBeanDefinition mbd = null;
            RootBeanDefinition previous = null;
    
            // 说明是顶级bean，直接获取 RootBeanDefinitio
            if (containingBd == null) {
        
                mbd = this.mergedBeanDefinitions.get(beanName);
            }
    
            //不是顶级bean，RootBeanDefinition为null，会进行创建
            if (mbd == null || mbd.stale) {
        
                previous = mbd;
                //如果此BeanDefinition对象没有父bean
                if (bd.getParentName() == null) {
        
                    // bd是RootBeanDefinition类型的则进行复制，如果不是则进行创建
                    if (bd instanceof RootBeanDefinition) {
        
                        mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                    }
                    else {
        
                        mbd = new RootBeanDefinition(bd);
                    }
                }
                //有父bean，会进行子类覆盖的合并，然后生成一个RootBeanDefinition对象
                else {
        
                    // 子bean定义：需要与父合并。
                    BeanDefinition pbd;
                    try {
        
                        //获取父 bean，必要时去除工厂取消引用前缀，并将别名解析为规范名称
                        String parentBeanName = transformedBeanName(bd.getParentName());
                        //bean的名字和父bean的名字不相同
                        if (!beanName.equals(parentBeanName)) {
        
                            //返回给定 bean 名称的“合并”BeanDefinition，如有必要，将子 bean 定义与其父 bean 合并。
                            pbd = getMergedBeanDefinition(parentBeanName);
                        }
                        ///bean的名字和父bean的名字相同
                        else {
        
                            //获取父工厂
                            BeanFactory parent = getParentBeanFactory();
                            if (parent instanceof ConfigurableBeanFactory) {
        
                                pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                            }
                            else {
        
                                throw new NoSuchBeanDefinitionException(parentBeanName,"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +"': cannot be resolved without a ConfigurableBeanFactory parent");
                            }
                        }
                    }
                    catch (NoSuchBeanDefinitionException ex) {
        
                        throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                    }
                    // 具有覆盖值的深拷贝。
                    mbd = new RootBeanDefinition(pbd);
                    //从给定的 bean 定义覆盖此 bean 定义中的设置（可能是从父子继承关系复制的父节点）。
                    mbd.overrideFrom(bd);
                }
    
                // 未配置scope属性，则默认为单例。
                if (!StringUtils.hasLength(mbd.getScope())) {
        
                    mbd.setScope(SCOPE_SINGLETON);
                }
    
                //设置了scope属性，则获取值
                if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
        
                    mbd.setScope(containingBd.getScope());
                }
    
                //将BeanDefinition信息注册到 RootBeanDefinition
                if (containingBd == null && isCacheBeanMetadata()) {
        
                    this.mergedBeanDefinitions.put(beanName, mbd);
                }
            }
            if (previous != null) {
        
                copyRelevantMergedBeanDefinitionCaches(previous, mbd);
            }
            return mbd;
        }
    }

//返回给定 bean 名称的“合并”BeanDefinition，如有必要，将子 bean 定义与其父 bean 合并。
    public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
        
        String beanName = transformedBeanName(name);
        //检查该工厂中是否存在bean定义
        if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
        
            return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
        }
        // 在本地解析合并的 bean 定义。
        return getMergedLocalBeanDefinition(beanName);
    }

//BeanDefinition合并，进行覆盖
    public void overrideFrom(BeanDefinition other) {
        
        if (StringUtils.hasLength(other.getBeanClassName())) {
        
            setBeanClassName(other.getBeanClassName());
        }
        if (StringUtils.hasLength(other.getScope())) {
        
            setScope(other.getScope());
        }
        setAbstract(other.isAbstract());
        if (StringUtils.hasLength(other.getFactoryBeanName())) {
        
            setFactoryBeanName(other.getFactoryBeanName());
        }
        if (StringUtils.hasLength(other.getFactoryMethodName())) {
        
            setFactoryMethodName(other.getFactoryMethodName());
        }
        setRole(other.getRole());
        setSource(other.getSource());
        copyAttributesFrom(other);
    
        if (other instanceof AbstractBeanDefinition) {
        
            AbstractBeanDefinition otherAbd = (AbstractBeanDefinition) other;
            if (otherAbd.hasBeanClass()) {
        
                setBeanClass(otherAbd.getBeanClass());
            }
            if (otherAbd.hasConstructorArgumentValues()) {
        
                getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
            }
            if (otherAbd.hasPropertyValues()) {
        
                getPropertyValues().addPropertyValues(other.getPropertyValues());
            }
            if (otherAbd.hasMethodOverrides()) {
        
                getMethodOverrides().addOverrides(otherAbd.getMethodOverrides());
            }
            Boolean lazyInit = otherAbd.getLazyInit();
            if (lazyInit != null) {
        
                setLazyInit(lazyInit);
            }
            setAutowireMode(otherAbd.getAutowireMode());
            setDependencyCheck(otherAbd.getDependencyCheck());
            setDependsOn(otherAbd.getDependsOn());
            setAutowireCandidate(otherAbd.isAutowireCandidate());
            setPrimary(otherAbd.isPrimary());
            copyQualifiersFrom(otherAbd);
            setInstanceSupplier(otherAbd.getInstanceSupplier());
            setNonPublicAccessAllowed(otherAbd.isNonPublicAccessAllowed());
            setLenientConstructorResolution(otherAbd.isLenientConstructorResolution());
            if (otherAbd.getInitMethodName() != null) {
        
                setInitMethodName(otherAbd.getInitMethodName());
                setEnforceInitMethod(otherAbd.isEnforceInitMethod());
            }
            if (otherAbd.getDestroyMethodName() != null) {
        
                setDestroyMethodName(otherAbd.getDestroyMethodName());
                setEnforceDestroyMethod(otherAbd.isEnforceDestroyMethod());
            }
            setSynthetic(otherAbd.isSynthetic());
            setResource(otherAbd.getResource());
        }
        else {
        
            getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
            getPropertyValues().addPropertyValues(other.getPropertyValues());
            setLazyInit(other.isLazyInit());
            setResourceDescription(other.getResourceDescription());
        }
    }

##### 7.2.3、获取注册信息 #####

在Spring将Bean的信息注册成一个个的BeanDefinition对象后，IOC容器需要去获取这些注册的信息。

*  如果该对象配置成懒加载，那么直到我们向Spring要依赖对象实例之前，都是以一个个的BeanDefination的形式存在。
 *  如果不是选择懒加载的方式，容器启动阶段完成之后，其中有一个步骤 finishBeanFactoryInitialization()，在这一步将立即启动Bean实例化阶段，通过隐式的调用所有依赖对象的getBean方法来实例化所有配置的Bean，完成类的加载。

在doGet方法中，检测了缓存中不存在单例bean后，就会创建父工厂，获取bena的一些信息

// 获取父工厂
    BeanFactory parentBeanFactory = getParentBeanFactory();
    ...........
    try {
        
        .........
        // 返回一个合并的 RootBeanDefinition，存放的整合的Bean信息
        RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        //检查给定的合并 bean 定义，可能会引发验证异常
        checkMergedBeanDefinition(mbd, beanName, args);
        }

获取RootBeanDefinition中的注册信息

//bean 名称映射
    private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);
    
    //返回一个合并的 RootBeanDefinition
    protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        
        //从map集合中根据beanName获取RootBeanDefinition（缓存中）
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
        //获取到后直接返回
        if (mbd != null && !mbd.stale) {
        
            return mbd;
        }
        //未获取到，则此事还没有RootBeanDefinition，进行信息注册（getBeanDefinition(beanName)
        return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    }
    
    protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
        throws BeanDefinitionStoreException {
        
        return getMergedBeanDefinition(beanName, bd, null);
    }
    
    protected RootBeanDefinition getMergedBeanDefinition( String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {
        
        //mergedBeanDefinitions缓存上锁，避免出现并发问题
        synchronized (this.mergedBeanDefinitions) {
        
            RootBeanDefinition mbd = null;
            RootBeanDefinition previous = null;
    
            //重复获取BeanDefinition信息，并发情况考虑
            if (containingBd == null) {
        
                mbd = this.mergedBeanDefinitions.get(beanName);
            }
    
            if (mbd == null || mbd.stale) {
        
                previous = mbd;
                //当前bean不存在继承情况的处理，
                if (bd.getParentName() == null) {
        
                    // 是RootBeanDefinition类型的，就使用给定根 bean 定义的副本，否则新创建
                    if (bd instanceof RootBeanDefinition) {
        
                        mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                    }
                    else {
        
                        mbd = new RootBeanDefinition(bd);
                    }
                }
                //当前bean存在继承情况的处理，
                else {
        
                    //子bean定义：需要与父合并
                    BeanDefinition pbd;
                    try {
        
                        String parentBeanName = transformedBeanName(bd.getParentName());
                        if (!beanName.equals(parentBeanName)) {
        
                            //获取当前BeanDefinition中parentName对应的父BeanDefinition信息
                            pbd = getMergedBeanDefinition(parentBeanName);
                        }
                        else {
        
                            BeanFactory parent = getParentBeanFactory();
                            if (parent instanceof ConfigurableBeanFactory) {
        
                                //parentName和当前beanName相同时，在父工厂中获取父类BeanDefinition对象
                                pbd = ((ConfigurableBeanFactory)parent).getMergedBeanDefinition(parentBeanName);
                            }
                            else {
        
                                throw new NoSuchBeanDefinitionException(parentBeanName,
                                    "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
                                     "': cannot be resolved without a ConfigurableBeanFactory parent");
                            }
                        }
                    }
                    catch (NoSuchBeanDefinitionException ex) {
        
                        throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                                "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                    }
                    // 根据父类BeanDefinition信息创建新对象。
                    mbd = new RootBeanDefinition(pbd);
                    //父类对象继承当前BeanDefinition核心属性
                    mbd.overrideFrom(bd);
                }
    
                // 如果之前未配置，则设置默认单例范围。
                if (!StringUtils.hasLength(mbd.getScope())) {
        
                    mbd.setScope(SCOPE_SINGLETON);
                }
    
                // 非单例
                if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
        
                    mbd.setScope(containingBd.getScope());
                }
    
                // 选择性将新建的mergedBeanDefinition信息添加到 mergedBeanDefinitions缓存中
                if (containingBd == null && isCacheBeanMetadata()) {
        
                    this.mergedBeanDefinitions.put(beanName, mbd);
                }
            }
            //将缓存的BeanDefinition部分信息复制到新创建的BeanDefinition信息中
            if (previous != null) {
        
                copyRelevantMergedBeanDefinitionCaches(previous, mbd);
            }
            return mbd;
        }
    }

##### 7.2.4、检查依赖关系 #####

Spring在获取了注册的信息后，会检查获取Bean之间的依赖关系。

doGetBean中的这段代码就是初始化依赖的bean。返回此 bean 所依赖的 bean 名称。

//初始化依赖的bean。返回此 bean 所依赖的 bean 名称。
    String[] dependsOn = mbd.getDependsOn();
    //不为null。表示Bean中依赖了其他的Bean
    if (dependsOn != null) {
        
        for (String dep : dependsOn) {
        
            //如果此依赖已注册为依赖项
            if (isDependent(beanName, dep)) {
        
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
            }
            //为bean注册依赖
            registerDependentBean(dep, beanName);
            try {
        .
                //递归（注册的bean可能还依赖了其他bean，需要递归）
                getBean(dep);
                }
            catch (NoSuchBeanDefinitionException ex) {
        
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
            }
        }
    }

*  判断该bean是否已经注入过了
    
        //beanName – 要检查的 bean 的名称     dependentBeanName – 依赖 bean 的名称
        protected boolean isDependent(String beanName, String dependentBeanName) {
              
            synchronized (this.dependentBeanMap) {
              
                return isDependent(beanName, dependentBeanName, null);
            }
        }
        
        //依赖 bean 名称之间的映射：bean 名称到依赖 bean 名称集
        private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
        
        private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
              
            //如果alreadySeen不为空，且内含有beanName
            if (alreadySeen != null && alreadySeen.contains(beanName)) {
              
                return false;
            }
            //确定原始名称，将别名解析为规范名称
            String canonicalName = canonicalName(beanName);
            //从依赖 bean 名称之间的映射集中获取依赖的Bean
            Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
            //没有获取到，返回false
            if (dependentBeans == null) {
              
                return false;
            }
            //包含依赖 bean 的名称，已经注册过了返回true
            if (dependentBeans.contains(dependentBeanName)) {
              
                return true;
            }
            //遍历获取到的结果集
            for (String transitiveDependency : dependentBeans) {
              
                //创建alreadySeen，将bean 的名称添加进去
                if (alreadySeen == null) {
              
                    alreadySeen = new HashSet<>();
                }
                //递归检查依赖
                alreadySeen.add(beanName);
                if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
              
                    return true;
                }
            }
            return false;
        }
 *  注入Bean
    
        //依赖 bean 名称之间的映射：bean 名称到 bean 依赖项的 bean 名称集
        private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
        //依赖 bean 名称之间的映射：bean 名称到依赖 bean 名称集
        private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
        
        public void registerDependentBean(String beanName, String dependentBeanName) {
              
            //确定原始名称，将别名解析为规范名称
            String canonicalName = canonicalName(beanName);
        	//
            synchronized (this.dependentBeanMap) {
              
                Set<String> dependentBeans =
                    this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
                if (!dependentBeans.add(dependentBeanName)) {
              
                    return;
                }
            }
            synchronized (this.dependenciesForBeanMap) {
              
                Set<String> dependenciesForBean =
                    this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
                dependenciesForBean.add(canonicalName);
            }
        }

##### 7.2.5、判断Scope #####

Spring会判断Scope属性，然后根据其属性决定怎么实例化Bean（从缓存中获取、创建单例、创建原型、其他）

###### 1、缓存中获取 ######

如果缓存中有，从缓存中获取单例 bean，通过方法：getSingleton(String beanName, boolean allowEarlyReference)

//1、检查缓存中是否有手动注册的单例，如果缓存中有，则直接从缓存中加载
    Object sharedInstance = getSingleton(beanName);
    //从缓存中获取到了
    if (sharedInstance != null && args == null) {
        
        //跟踪启用
        if (logger.isTraceEnabled()) {
        
            //此 bean 当前是否正在创建中
            if (isSingletonCurrentlyInCreation(beanName)) {
        
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
        
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        //获取创建好的Bean实例
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

返回在给定名称下注册的单例对象。

public Object getSingleton(String beanName) {
        
        return getSingleton(beanName, true);
    }
    //单例对象的缓存
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    //早期单例对象的缓存
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    // 单例工厂的缓存
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    
    //返回在给定名称下注册的（原始）单例对象。beanName – 要查找的 bean 的名称 allowEarlyReference – 是否应该创建早期引用
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        
        // 从单例对象的缓存中检查是否存在该实例
        Object singletonObject = this.singletonObjects.get(beanName);
        // 如果缓存中没有，再判断是否正在创建
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        
            //从早期单例对象的缓存中检查是否存在该实例
            singletonObject = this.earlySingletonObjects.get(beanName);
            //如果早期单例对象中没有，且可以创建
            if (singletonObject == null && allowEarlyReference) {
        
                synchronized (this.singletonObjects) {
        
                    // 在完整的单例锁中一致地创建早期引用(继续从缓存中判断)
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
        
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
        
                            //从单例工厂的缓存获取
                            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                            //获取成功
                            if (singletonFactory != null) {
        
                                singletonObject = singletonFactory.getObject();
                                //将其添加到单例对象缓存和早期单例对象缓存中
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }

###### 2、创建单例Bean ######

如果缓存中没有则判断为单例，创建单例的 BeangetSingleton(String beanName, ObjectFactory<?> singletonFactory)

if (mbd.isSingleton()) {
        
        // 返回以给定名称注册的（原始）单例对象，如果尚未注册，则创建并注册一个新对象
        sharedInstance = getSingleton(beanName, () -> {
        
            try {
        
                return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
        
                // 显式地从单例缓存中删除实例:它可能已经放在那里了
                // 由创建过程触发，以允许循环引用解析
                // 删除接收到该bean临时引用的所有bean。
                destroySingleton(beanName);
                throw ex;
            }
        });
        //获取给定 bean 实例的对象，bean 实例本身或其创建的对象（如果是 FactoryBean）。
        
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName,mbd);
    }

//指示对象当前是否在销毁中的标志。
    private boolean singletonsCurrentlyInDestruction = false;
    
    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        
        //beanName不能为空
        Assert.notNull(beanName, "Bean name must not be null");
        synchronized (this.singletonObjects) {
        
            //再次检查是否已经被加载了,如果加载了直接复用
            Object singletonObject = this.singletonObjects.get(beanName);
            //为空则表示之前没有被加载过
            if (singletonObject == null) {
        
                //对象在销毁状态，则不能创建
                if (this.singletonsCurrentlyInDestruction) {
        
                    throw new BeanCreationNotAllowedException(beanName,
                       "Singleton bean creation not allowed while singletons of this factory are 					in destruction " +"(Do not request a bean from a BeanFactory in a destroy method                  			  implementation!)");
                }
                //调试
                if (logger.isDebugEnabled()) {
        
                    logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
                //初始化前操作，校验是否 beanName 是否有别的线程在初始化，并记录beanName的初始化状态
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
        
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                try {
        
                    //调用createBean方法实例化bean
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
        
                    //单例对象是否在此期间隐式出现？如果是，继续执行，因为异常表示该状态。
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
        
                        throw ex;
                    }
                }
                catch (BeanCreationException ex) {
        
                    if (recordSuppressedExceptions) {
        
                        for (Exception suppressedException : this.suppressedExceptions) {
        
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
        
                    if (recordSuppressedExceptions) {
        
                        this.suppressedExceptions = null;
                    }
                    //创建后，移除初始化状态
                    afterSingletonCreation(beanName);
                }
                //创建完了，将其加入到缓存中
                if (newSingleton) {
        
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }

###### 3、创建原型Bean ######

如果缓存中没有，且判断为原型，创建原型的Bean

else if (mbd.isPrototype()) {
        
        //原型实例
        Object prototypeInstance = null;
        try {
        
            //在原型创建之前的回调，默认实现将原型注册为当前正在创建中
            beforePrototypeCreation(beanName);
            prototypeInstance = createBean(beanName, mbd, args);
        }
        finally {
        
            afterPrototypeCreation(beanName);
        }
        beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    }
    protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException;

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
        
        if (logger.isTraceEnabled()) {
        
            logger.trace("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;
    
        // 确保此时实际解析了 bean 类，并克隆 bean 定义，以防动态解析的 Class 无法存储在共享的合并 bean 定义中。
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }
    
        // 准备方法覆盖。
        try {
        
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
        
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),beanName, 
                                                   "Validation of method overrides failed", ex);
        }
        try {
        
            // 让 BeanPostProcessors 有机会返回一个代理而不是目标 bean 实例
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
        
                return bean;
            }
        }
        catch (Throwable ex) {
        
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                                            "BeanPostProcessor before instantiation of bean failed", ex);
        }
    
        try {
        
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
        
                logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }
        catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        
            //检测到的异常已经具有正确的 bean 创建上下文，或者要与 DefaultSingletonBeanRegistry 通信的非法单例状态。
            throw ex;
        }
        catch (Throwable ex) {
        
            throw new BeanCreationException(
                mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
        }
    }

###### 4、其他 ######

既不是单例，也不是原型，则获取Scope

else {
        
        //获取 Scope 的取值
        String scopeName = mbd.getScope();
        //没有为 bean 定义范围名称
        if (!StringUtils.hasLength(scopeName)) {
        
            throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
        }
        Scope scope = this.scopes.get(scopeName);
        //没有为作用域名称注册作用域
        if (scope == null) {
        
            throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
        }
        try {
        
            //从底层范围返回具有给定名称的对象，如果在底层存储机制中找不到，则creating it
            Object scopedInstance = scope.get(beanName, () -> {
        
                beforePrototypeCreation(beanName);
                try {
        
                    return createBean(beanName, mbd, args);
                }
                finally {
        
                    afterPrototypeCreation(beanName);
                }
            });
            beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
        }
        catch (IllegalStateException ex) {
        
            throw new ScopeNotActiveException(beanName, scopeName, ex);
        }
    }

##### 7.2.6、实例化前准备 #####

在判断完Scope属性后，就会针对不同的模式创建不同的Bean对象，创建对象使用了createBean这个方法，这个方法就是进行Bean的实例化，其中在实例化开始前会有一些准备工作（解析引用，检查方法的覆盖，前置处理方法）

//AbstractAutowireCapableBeanFactory类
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {
        
        if (logger.isTraceEnabled()) {
        
            logger.trace("Creating instance of bean '" + beanName + "'");
        }
        // 保存了Bean的元信息
        RootBeanDefinition mbdToUse = mbd;
        //确保此时实际解析了 bean 类，并克隆 bean 定义，以防动态解析的 Class 无法存储在共享的合并 bean 定义中。
        //将 bean 类名称解析为 Class 引用，并将解析的 Class 存储在 bean 定义中以供进一步使用。
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }
        //准备方法重写
        try {
        
            //验证并准备为此 bean 定义的方法覆盖。检查具有指定名称的方法是否存在
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
        
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                   beanName, "Validation of method overrides failed", ex);
        }
    
        try {
        
            //前置方法处理：解析指定bean，给BeanPostProcessors一个机会返回一个代理而不是目标bean实例。
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
        
                //如果代理成功创建 bean 后，直接返回
                return bean;
            }
        }
        catch (Throwable ex) {
        
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                        "BeanPostProcessor before instantiation of bean failed", ex);
        }
    
        try {
        
            //开始创建Bean
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
        
                logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }
        catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        
            //先前检测到的异常已经具有正确的 bean 创建上下文，或者要与 DefaultSingletonBeanRegistry 通信的非法单例状态。
            throw ex;
        }
        catch (Throwable ex) {
        
            throw new BeanCreationException(
                mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
        }
    }

###### 1、引用问题 ######

间接引用替换成直接引用

protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)throws CannotLoadBeanClassException {
        
        try {
        
            //返回此定义是否指定了一个 bean 类,指定了直接返回
            if (mbd.hasBeanClass()) {
        
                return mbd.getBeanClass();
            }
            //获取系统范围的安全管理器
            if (System.getSecurityManager() != null) {
        
                return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
                     () -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
            }
            else {
        
                return doResolveBeanClass(mbd, typesToMatch);
            }
        }
        catch (PrivilegedActionException pae) {
        
            ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
            throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
        }
        catch (ClassNotFoundException ex) {
        
            throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
        }
        catch (LinkageError err) {
        
            throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
        }
    }

###### 2、方法覆盖 ######

检查是否存在覆盖方法：获取类的重载方法列表，然后遍历，一个一个进行处理

//验证并准备为此 bean 定义的方法覆盖。检查具有指定名称的方法是否存在
    mbdToUse.prepareMethodOverrides();

public void prepareMethodOverrides() throws BeanDefinitionValidationException {
        
        // 检查查找的方法是否存在，并确定它们的重载状态。
        if (hasMethodOverrides()) {
        
            getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
        }
    }

###### 3、前置处理 ######

前置处理：执行了两个关键方法，前置拦截器和后置拦截器。

//前置方法处理：解析指定bean，给BeanPostProcessors一个机会返回一个代理而不是目标bean实例。
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
        
        //如果代理成功创建 bean 后，直接返回
        return bean;
    }

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        
            // 确保此时实际解析了 bean 类
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
        
                    // 执行前置拦截器的操作
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
        
                        // 执行后置拦截器的操作
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }
    
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        
            Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
        
                return result;
            }
        }
        return null;
    }
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)throws BeansException {
        
        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
        
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
        
                return result;
            }
            result = current;
        }
        return result;
    }

##### 7.2.7、实例化初始化 #####

准备完成后，就开始创建对象了，在createBean方法中，完成了前面的准备工作后，调用doCreateBean(beanName, mbdToUse, args)创建实例：

try {
        
        //开始创建Bean
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
        
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }

到了这一步，就开始真正创建bean对象了：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {
        
        // 实例化 bean,返回BeanWrapper。
        BeanWrapper instanceWrapper = null;
        //如果bean是单例，就先清除缓存中的bean信息
        if (mbd.isSingleton()) {
        
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        //根据指定bean使用对应的策略实例化bean
        if (instanceWrapper == null) {
        
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        //获取包装实例
        Object bean = instanceWrapper.getWrappedInstance();
        //返回包装的 bean 实例的类型。
        Class<?> beanType = instanceWrapper.getWrappedClass();
        //如果类型不为空，RootBeanDefinition的类型就是此类型
        if (beanType != NullBean.class) {
        
            mbd.resolvedTargetType = beanType;
        }
        
        // 后置处理器修改合并后的 bean 定义：Autowired 注解正式通过此方法实现诸如类型的预解析
        synchronized (mbd.postProcessingLock) {
        
            if (!mbd.postProcessed) {
        
                try {
        
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
        
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                       		"Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }
    
        //依赖处理，提前暴露bean的引用，提前解决循环依赖的问题
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                          isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
        
            if (logger.isTraceEnabled()) {
        
                logger.trace("Eagerly caching bean '" + beanName +
                             "' to allow for resolving potential circular references");
            }
            //第二个参数是回调接口，实现的功能是将切面动态织入 bean
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
    
        // 初始化 bean 实例
        Object exposedObject = bean;
        //将各个属性值注入，如果存在对其它 bean 的依赖，将会递归初始化依赖的 bean
        try {
        
            //属性注入
            populateBean(beanName, mbd, instanceWrapper);
            //调用初始化方法，例如 init-method
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
        
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
        
                throw (BeanCreationException) ex;
            }
            else {
        
                throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }
    	//循环依赖的检查
        if (earlySingletonExposure) {
        
            Object earlySingletonReference = getSingleton(beanName, false);
            // 只有在检测到有循环依赖的情况下才不为空
            if (earlySingletonReference != null) {
        
                if (exposedObject == bean) {
        
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
        
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
        
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
        
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    // bean 创建后，它所依赖的 bean 一定也已经创建了，此时actualDependentBeans也就位空了，但如果 actualDependentBeans 不为空，表示还有依赖的 bean 没有初始化完成，也就是存在循环依赖
                    if (!actualDependentBeans.isEmpty()) {
        
                        throw new BeanCurrentlyInCreationException(beanName,
                            "Bean with name '" + beanName + "' has been injected into other 	beans [" +StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +"] in its raw version as part of a circular reference, but has eventually been " +"wrapped. This means that said other beans do not use the final version of the " +"bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }
    
        // 注册 DisposableBean, destroy-method 属性,以便在销毁对象时调用。
        try {
        
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
        
            throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }
        return exposedObject;
    }

###### 1、BeanWrapper ######

创建BeanWrapper对象，将新创建的Bean对象注入：BeanWrapper是Spring封装的一个对象，通过BeanFactory等隐式调用，是对反射相关API的简单封装，它和bean的关系，就像是父类和子类一样，如果要调用某个bean的方法，可以用BeanWrapper直接代替Bean来调用其方法。

（BeanWrapper使Srping不必关心Bean的类型，只需要使用BeanWrapper，就能分析和操作标准 JavaBean ，获取和设置属性值（单独或批量）、获取属性描述符以及查询属性的可读性/可写性的能力。）

//createBeanInstance():一种是工厂方法，另一种就是构造函数（如果存在工厂方法则使用工厂方法进行初始化，不存在工厂则使用有参构造，都不存在则使用默认的构造）
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        
        // 确保此时实际解析了 bean 类
        Class<?> beanClass = resolveBeanClass(mbd, beanName);
        if(beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) &&!mbd.isNonPublicAccessAllowed()){
        
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        //如果实例供应商存在，此功能供应商获取
        if (instanceSupplier != null) {
        
            return obtainFromSupplier(instanceSupplier, beanName);
        }
        //获取工厂方法名称不为空,使用工厂方法实例化
        if (mbd.getFactoryMethodName() != null) {
        
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
    
        //重新创建同一个bean时的快捷方式...
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
        
            synchronized (mbd.constructorArgumentLock) {
        
                // 如果一个类有多个构造函数，每个构造函数都有不同的参数，调用前需要进行判断对应的构造函数或者工厂方法
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
        
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        // 如果已经解析过，不需要再次解析
        if (resolved) {
        
            if (autowireNecessary) {
        
                // 构造函数自动注入
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
        
                // 使用默认的构造函数
                return instantiateBean(beanName, mbd);
            }
        }
    
        // 自动装配的候选构造函数？
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        
            return autowireConstructor(beanName, mbd, ctors, args);
        }
    
        //默认构造的首选构造函数？
        ctors = mbd.getPreferredConstructors();
        if (ctors != null) {
        
            return autowireConstructor(beanName, mbd, ctors, null);
        }
    
        // 没有特殊处理：只需使用无参数构造函数
        return instantiateBean(beanName, mbd);
    }

//使用其默认构造函数实例化给定的 bean
    protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
        
        try {
        
            Object beanInstance;
            if (System.getSecurityManager() != null) {
        
                beanInstance = AccessController.doPrivileged(
                    (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
                    getAccessControlContext());
            }
            else {
        
                beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
            }
            //创建BeanWrapper对象，将实例化的Bean注入其中
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            initBeanWrapper(bw);
            return bw;
        }
        catch (Throwable ex) {
        
            throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
        }
    }

###### 2、实例化Bean ######

若想获取BeanWrapper 这个对象，需要通过反射机制调用bean的构造函数进行创建bean对象，然后将bean对象传递给 BeanWrapper 。

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        
        // 如果没有覆盖，请不要使用 CGLIB 覆盖该类
        if (!bd.hasMethodOverrides()) {
        
            Constructor<?> constructorToUse;
            synchronized (bd.constructorArgumentLock) {
        
                //获取构造函数
                constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
        
                    //反射
                    final Class<?> clazz = bd.getBeanClass();
                    //指定的类是一个接口，出现异常
                    if (clazz.isInterface()) {
        
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }
                    try {
        
                        if (System.getSecurityManager() != null) {
        
                            constructorToUse = AccessController.doPrivileged(
                                (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
                        }
                        else {
        
                            //通过反射获取构造函数
                            constructorToUse = clazz.getDeclaredConstructor();
                        }
                        bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                    }
                    catch (Throwable ex) {
        
                        throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                    }
                }
            }
            return BeanUtils.instantiateClass(constructorToUse);
        }

获取到了构造函数，使用给定构造函数实例化类

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
        
        //构造函数不能为空
        Assert.notNull(ctor, "Constructor must not be null");
        try {
        
            //反射工具，获取访问的权限
            ReflectionUtils.makeAccessible(ctor);
            //存在定是否存在 Kotlin 反射，且给定的Class是 Kotlin 类型（默认构造）
            if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
        
                return KotlinDelegate.instantiateClass(ctor, args);
            }
            //自定义的构造
            else {
        
                //获取参数的类型
                Class<?>[] parameterTypes = ctor.getParameterTypes();
                //不能指定比构造函数参数更多的参数
                Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
                //具有默认值的 args
                Object[] argsWithDefaultValues = new Object[args.length];
                for (int i = 0 ; i < args.length; i++) {
        
                    if (args[i] == null) {
        
                        Class<?> parameterType = parameterTypes[i];
                        argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
                    }
                    else {
        
                        argsWithDefaultValues[i] = args[i];
                    }
                }
                //返回新的实例
                return ctor.newInstance(argsWithDefaultValues);
            }
        }
        catch (InstantiationException ex) {
        
            throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
        }
        catch (IllegalAccessException ex) {
        
            throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
        }
        catch (IllegalArgumentException ex) {
        
            throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
        }
        catch (InvocationTargetException ex) {
        
            throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
        }
    }

###### 3、处理循环依赖 ######

某些对象可能会出现循环依赖的情况，所以需要进行处理

//依赖处理，提前暴露bean的引用,即使被 BeanFactoryAware 等生命周期接口触发，也急切地缓存单例以解决循环引用。
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        
        if (logger.isTraceEnabled()) {
        
            logger.trace("Eagerly caching bean '" + beanName +
                         "' to allow for resolving potential circular references");
        }
        //第二个参数是回调接口，实现的功能是将切面动态织入 bean
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

###### 4、属性注入 ######

属性注入，获取Bean中各个属性的值，开始对值进行注入

//将各个属性值注入，如果存在对其它 bean 的依赖，将会递归初始化依赖的 bean
    try {
        
        populateBean(beanName, mbd, instanceWrapper);
    }

//用 bean 定义中的属性值填充给定 BeanWrapper 中的 bean 实例。
    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        
        //实例为空
        if (bw == null) {
        
            //具有属性值，抛出异常。没有属性值直接跳过
            if (mbd.hasPropertyValues()) {
        
                throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
            else {
        
                // 跳过空实例的属性填充阶段
                return;
            }
        }
        //RootBeanDefinition不是合成的。且具有实例化感知 Bean 后处理器，则获取实例化后的后处理
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        
            for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        
                if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
        
                    return;
                }
            }
        }
        //获取属性值
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
        
        //获取自动装配的方式
        int resolvedAutowireMode = mbd.getResolvedAutowireMode();
        // 根据名称或者根据类型自动装配
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        
            //可变属性值
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // 根据名称自动装配属性值(byName)
            if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
        
                autowireByName(beanName, mbd, bw, newPvs);
            }
            // 根据类型添加基于自动装配的属性值。(byType)
            if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }
    
        //是否具有实例化感知 Bean 后处理器
        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        //是否需要深度检查（深度的依赖）
        boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
    
        //属性描述符
        PropertyDescriptor[] filteredPds = null;
        //如果有后置处理器，进行后置的处理
        if (hasInstAwareBpps) {
        
            if (pvs == null) {
        
                pvs = mbd.getPropertyValues();
            }
            for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        
               //属性值
                PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
        
                    if (filteredPds == null) {
        
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }
                    pvsToUse = bp.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);
        }
    }

*  byName
    
        protected void autowireByName(
            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
              
        	//属性名
            String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
            //遍历属性
            for (String propertyName : propertyNames) {
              
                //如果有这个属性
                if (containsBean(propertyName)) {
              
                    Object bean = getBean(propertyName);
                    pvs.add(propertyName, bean);
                    //注册依赖 Bean
                    registerDependentBean(propertyName, beanName);
                    if (logger.isTraceEnabled()) {
              
                        logger.trace("Added autowiring by name from bean name '" + beanName +
                             "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
                    }
                }
                else {
              
                    if (logger.isTraceEnabled()) {
              
                        logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                                     "' by name: no matching bean found");
                    }
                }
            }
        }
 *  byType
    
        protected void autowireByType(
            String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
              
        	//获取自定义类型转换器
            TypeConverter converter = getCustomTypeConverter();
            if (converter == null) {
              
                converter = bw;
            }
        	//自动装配的 Bean 名称
            Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
            //属性名称
            String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
            for (String propertyName : propertyNames) {
              
                try {
              
                    //获取属性描述符
                    PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
                    // 不要尝试为 Object 类型按类型自动装配：
                    if (Object.class != pd.getPropertyType()) {
              
                        //获取写入方法参数
                        MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                        // 在优先后处理器的情况下，不允许使用 Eager init 进行类型匹配
                        boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
                        //按类型依赖描述符自动装配
                        DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                        //解决依赖,自动装配参数
                        Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                        //不为null，直接添加
                        if (autowiredArgument != null) {
              
                            pvs.add(propertyName, autowiredArgument);
                        }
                        for (String autowiredBeanName : autowiredBeanNames) {
              
                            //注册依赖的bean
                            registerDependentBean(autowiredBeanName, beanName);
                            if (logger.isTraceEnabled()) {
              
                                logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
                                             propertyName + "' to bean named '" + autowiredBeanName + "'");
                            }
                        }
                        autowiredBeanNames.clear();
                    }
                }
                catch (BeansException ex) {
              
                    throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
                }
            }
        }

###### 5、调用初始化方法 ######

此时开始调用Bean的初始化方法，进行初始化

//调用初始化方法，例如 init-method
    exposedObject = initializeBean(beanName, exposedObject, mbd);

//初始化给定的 bean 实例，应用工厂回调以及 init 方法和 bean 后处理器。
    //从createBean调用传统定义的 bean，从initializeBean调用现有 bean 实例
    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        
        //1、处理Aware接口
        if (System.getSecurityManager() != null) {
        
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
        
    		// 对特殊的 bean 处理：Aware/ BeanClassLoader / BeanFactoryAware
            invokeAwareMethods(beanName, bean);
        }
    	//2、执行BeanPostProcessor前置处理：
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
        
            //在初始化之前应用 Bean 后处理器
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
    
        //3、开始初始化
        try {
        
            //调用初始化方法
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
        
            throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
        }
        //4、执行BeanPostProcessor后置处理
        if (mbd == null || !mbd.isSynthetic()) {
        
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
    
        return wrappedBean;
    }

###### 检查Aware接口 ######

查看是否实现了Aware相关的接口，通过这些接口可以获取Spring相关资源。比如：

*  获取Bean的名称：如果Bean实现了BeanNameAware接口，就会调用实现方法setBeanName(String)，传递的为Bean的ID值
 *  资源路径：BeanClassLoaderAware 的setBeanClassLoader
 *  获取BeanFactory：如果Bean实现了BeanFactoryAware接口，就会调用实现方法setBeanFactory(BeanFactory)，传递的是Spring工厂自身

private void invokeAwareMethods(String beanName, Object bean) {
        
        //看是否属于Aware
        if (bean instanceof Aware) {
        
            //实现了BeanNameAware
            if (bean instanceof BeanNameAware) {
        
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            //实现了BeanClassLoaderAware
            if (bean instanceof BeanClassLoaderAware) {
        
                ClassLoader bcl = getBeanClassLoader();
                if (bcl != null) {
        
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                }
            }
            //实现了BeanFactoryAware
            if (bean instanceof BeanFactoryAware) {
        
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

###### 初始化前置方法 ######

预初始化(初始化前的前置处理)：如果Bean实现了BeanPostProcessor接口，spring将调用他们的postProcessBeforeInitialization(Object bean, String beeanName)方法。

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
    throws BeansException {
        
        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
        
            //调用postProcessBeforeInitialization(Object bean, String beeanName)方法
            Object current = processor.postProcessBeforeInitialization(result, beanName);
            if (current == null) {
        
                return result;
            }
            result = current;
        }
        return result;
    }

###### 开始初始化 ######

进行初始化（BeanFactory管理的Bean是在使用到Bean的时候才会实例化Bean，ApplicantContext管理的Bean在容器初始化的时候就会完成Bean实例化）

如果实现了 InitializingBean 接口，则执行 afterPropertiesSet 方法。

如果配置了 init-method 还会在afterPropertiesSet之后在执行 init-method。

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
    throws Throwable {
        
    	//是否实现InitializingBean接口
        boolean isInitializingBean = (bean instanceof InitializingBean);
        //实现了InitializingBean，且 mbd不为null或不为外部管理的初始化方法
        if (isInitializingBean&&(mbd==null||!mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        
            if (logger.isTraceEnabled()) {
        
                logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            //执行afterPropertiesSet方法
            if (System.getSecurityManager() != null) {
        
                try {
        
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
        
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
        
                    throw pae.getException();
                }
            }
            else {
        
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }
    
        if (mbd != null && bean.getClass() != NullBean.class) {
        
            //获取初始化方法名称
            String initMethodName = mbd.getInitMethodName();
            //如果存在自定义的初始化方法则执行自定义的初始化方法
            if (StringUtils.hasLength(initMethodName) &&
                !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
        
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

###### 初始化后置方法 ######

调用BeanPostProcessor的初始化后的方法(初始化后的后置处理)：如果Bean实现了BeanPostProcessor接口，spring就将调用他们的postprocessAfterInitialization(Object bean, String beanName)方法

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {
        
        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
        
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
        
                return result;
            }
            result = current;
        }
        return result;
    }

###### 6、注册销毁方法 ######

根据不同的 scope 进行 disposableBean 的注册，同时也会注册用户自定义的销毁逻辑：（1）DisposableBean接口的destory()；（2）destory-method参数配置的方法。

// 注册 DisposableBean, destroy-method 属性,以便在销毁对象时调用。
    try {
        
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

//将给定的 bean 注册其 DisposableBean 接口和/或在工厂关闭时调用的给定销毁方法（如果适用）。仅适用于单例。
    protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        
        AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
        if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
        
            //是单例
            if (mbd.isSingleton()) {
        
                // 注册一个为给定 bean 执行所有销毁工作的 DisposableBean 实现：DestructionAwareBeanPostProcessors、DisposableBean 接口、自定义销毁方法。
                registerDisposableBean(beanName, new DisposableBeanAdapter(
                    bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
            }
            //不是单例
            else {
        
                // 具有自定义范围的 bean...
                Scope scope = this.scopes.get(mbd.getScope());
                if (scope == null) {
        
                    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
                }
                scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(
                    bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
            }
        }
    }

##### 7.2.8、实例化完成 #####

Bean实例化完成，可以使用，在销毁前一直驻留在上下文应用中，最后获取Bean的实例对象：getObjectForBeanInstance，此方法贯穿doGetBean，用于获取Bean对象。

protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
        
        //验证 bean 类型：判断是否是工厂bean
        if (BeanFactoryUtils.isFactoryDereference(name)) {
        
            if (beanInstance instanceof NullBean) {
        
                return beanInstance;
            }
            if (!(beanInstance instanceof FactoryBean)) {
        
                throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
            }
            if (mbd != null) {
        
                mbd.isFactoryBean = true;
            }
            return beanInstance;
        }
    
        //现在我们有了bean实例，它可能是一个普通bean或一个FactoryBean。如果它是一个FactoryBean，我们使用它来创建一个bean实例,对非 FactoryBean 不做处理。
        if (!(beanInstance instanceof FactoryBean)) {
        
            return beanInstance;
        }
    
        Object object = null;
        if (mbd != null) {
        
            mbd.isFactoryBean = true;
        }
        else {
        
            object = getCachedObjectForFactoryBean(beanName);
        }
        if (object == null) {
        
            //从工厂返回bean实例
            FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
            //缓存从FactoryBean获取的对象，如果它是单例。
            if (mbd == null && containsBeanDefinition(beanName)) {
        
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    }

##### 7.2.9、销毁 #####

在bean创建完成后，就会对这个bean注册一个销毁的Adapter对象。DisposableBeanAdapter对象（实现了DisposableBean）调用destory()方法销毁Bean（此对象收集 bean是否实现了 DisposableBean 接口，是否配置 destroy-method 属性，过滤了 DestructionAwareBeanPostProcessor 类型的接口）销毁bean的顺序是如下：

*  添加了@PreDestroy注解的bean，通过beanpostProcessor实现类 InitDestroyAnnotationBeanPostProcessor处理；
 *  实现了DisposableBean接口的bean，调用那个其实现的destroy()方法
 *  bean配置了destroy-method，调用destroy-method

Bean会根据其scope属性去销毁

[Java]: https://blog.csdn.net/yuandfeng/article/details/114333525
[bean]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/12132d7008b24638bdd5280c671cdfa3.png