本文共 6244 字，大约阅读时间需要 20 分钟。

• 实例化 Instantiation
• 属性赋值 Populate
• 初始化 Initialization
• 销毁 Destruction

package org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
           BeanWrapper instanceWrapper = null;        if (mbd.isSingleton()) {
               instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);        }        if (instanceWrapper == null) {
   //实例化            instanceWrapper = this.createBeanInstance(beanName, mbd, args);        }        Object bean = instanceWrapper.getWrappedInstance();        Class
    beanType = instanceWrapper.getWrappedClass();        if (beanType != NullBean.class) {
               mbd.resolvedTargetType = beanType;        }        synchronized(mbd.postProcessingLock) {
               if (!mbd.postProcessed) {
                   try {
                       this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);                } catch (Throwable var17) {
                       throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);                }                mbd.postProcessed = true;            }        }        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);        if (earlySingletonExposure) {
               if (this.logger.isTraceEnabled()) {
                   this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");            }// 添加单例实例 解决循环依赖            this.addSingletonFactory(beanName, () -> {
                   return this.getEarlyBeanReference(beanName, mbd, bean);            });        }        Object exposedObject = bean;        try {
   //属性赋值            this.populateBean(beanName, mbd, instanceWrapper);          //初始化实例            exposedObject = this.initializeBean(beanName, exposedObject, mbd);        } catch (Throwable var18) {
               if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                   throw (BeanCreationException)var18;            }            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);        }        if (earlySingletonExposure) {
   //从三级缓存中获取单例bean             Object earlySingletonReference = this.getSingleton(beanName, false);            if (earlySingletonReference != null) {
                   if (exposedObject == bean) {
                       exposedObject = earlySingletonReference;                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                       String[] dependentBeans = this.getDependentBeans(beanName);                    Set
   
     actualDependentBeans = new LinkedHashSet(dependentBeans.length);                    String[] var12 = dependentBeans;                    int var13 = dependentBeans.length;                    for(int var14 = 0; var14 < var13; ++var14) {
                           String dependentBean = var12[var14];                        if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                               actualDependentBeans.add(dependentBean);                        }                    }                    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 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");                    }                }            }        }        try {
   //销毁            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);            return exposedObject;        } catch (BeanDefinitionValidationException var16) {
               throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);        }    }
   

package org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.java

//如果一级缓存不包含beanName则添加入三级缓存然后删除二级缓存 protected void addSingletonFactory(String beanName, ObjectFactory
    singletonFactory) {
           Assert.notNull(singletonFactory, "Singleton factory must not be null");        synchronized(this.singletonObjects) {
               if (!this.singletonObjects.containsKey(beanName)) {
                   this.singletonFactories.put(beanName, singletonFactory);                this.earlySingletonObjects.remove(beanName);                this.registeredSingletons.add(beanName);            }        }    }//Spring首先从一级缓存singletonObjects中获取。如果获取不到，并且对象正在创建中，就再从二级缓存earlySingletonObjects中获取。如果还是获取不到且允许singletonFactories通过getObject()获取，就从三级缓存singletonFactory.getObject()(三级缓存)获取，如果获取到了则：从singletonFactories中移除，并放入earlySingletonObjects中。其实也就是从三级缓存移动到了二级缓存。@Nullable    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
           Object singletonObject = this.singletonObjects.get(beanName);        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
               synchronized(this.singletonObjects) {
                   singletonObject = this.earlySingletonObjects.get(beanName);                if (singletonObject == null && allowEarlyReference) {
                       ObjectFactory
    singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);                    if (singletonFactory != null) {
                           singletonObject = singletonFactory.getObject();                        this.earlySingletonObjects.put(beanName, singletonObject);                        this.singletonFactories.remove(beanName);                    }                }            }        }        return singletonObject;    }

参考:

转载地址：http://jkgai.baihongyu.com/