sets proc tco 資源 protected strac tac 依賴註入 wrap

一、創建BeanFactory流程

1、流程入口

創建BeanFactory的流程是從refresh方法的第二步開始的，通過調用obtainFreshBeanFactory方法完成流程。

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

2、流程分析

創建BeanFactory的流程是從第二步開始的，調用AbstractApplicationContext類中的obtainFreshBeanFactory方法：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		// 主要是通過該方法完成IoC容器的刷新
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
}
 

調用AbstractRefreshableApplicationContext中的refreshBeanFactory方法：

protected final void refreshBeanFactory() throws BeansException {
    // 如果之前有IoC容器，則銷毀
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        // 創建IoC容器，也就是DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        beanFactory.setSerializationId(getId());
        // 設置工廠的屬性：是否允許BeanDefinition覆蓋和是否允許循環依賴
        customizeBeanFactory(beanFactory);
        // 調用載入BeanDefinition的方法，在當前類中只定義了抽象的loadBeanDefinitions方法，具體的實現調用子類容器
        loadBeanDefinitions(beanFactory);
        synchronized (this.beanFactoryMonitor) {
            this.beanFactory = beanFactory;
        }
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}
 

其中調用createBeanFactory方法創建IoC容器。這裏創建的是DefaultListableBeanFactory，它是真正用於管理Bean實例及BeanDefeation的工廠。

二、加載BeanDefeation流程

1、流程入口

此流程是從AbstractRefreshableApplicationContext的refreshBeanFactory方法開始的，代碼如上所示，通過loadBeanDefinitions(beanFactory)進行BeanDefeation的加載。

 loadBeanDefinitions(beanFactory);

2、流程圖

這裏的調用較為復雜，可通過下面流程圖進行說明：

sequenceDiagram AbstractRefreshableApplicationContext->>AbstractXmlApplicationContext:loadBeanDefinitions(DefaultListableBeanFactory) AbstractXmlApplicationContext->>AbstractXmlApplicationContext:loadBeanDefinitions(XmlBeanDefinitionReader) AbstractXmlApplicationContext->>XmlBeanDefinitionReader:loadBeanDefinitions(Resource) XmlBeanDefinitionReader->>XmlBeanDefinitionReader:loadBeanDefinitions(EncodedResource) XmlBeanDefinitionReader->>XmlBeanDefinitionReader:doLoadBeanDefinitions() XmlBeanDefinitionReader->>XmlBeanDefinitionReader:registerBeanDefinitions()

3、流程分析

在創建完Ioc容器之後，調用AbstractXmlApplicationContext的loadBeanDefinitions進行beanDefeation的加載，其代碼如下：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // 創建一個BeanDefinition閱讀器，通過閱讀XML文件，真正完成BeanDefinition的加載和註冊
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

    initBeanDefinitionReader(beanDefinitionReader);
    // 委托給BeanDefinition閱讀器去加載BeanDefinition
    loadBeanDefinitions(beanDefinitionReader);
}

再調用其重載方法loadBeanDefinitions，代碼如下：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    // 獲取資源的定位
    // 這裏getConfigResources是一個空實現，真正實現是調用子類的獲取資源定位的方法
    // 比如：ClassPathXmlApplicationContext中進行了實現，而FileSystemXmlApplicationContext沒有使用該方法
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        // XML Bean讀取器調用其父類AbstractBeanDefinitionReader讀取定位的資源
        reader.loadBeanDefinitions(configResources);
    }
    // 如果子類中獲取的資源定位為空，則獲取FileSystemXmlApplicationContext構造方法中setConfigLocations方法設置的資源
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        // XML Bean讀取器調用其父類AbstractBeanDefinitionReader讀取定位的資源
        reader.loadBeanDefinitions(configLocations);
    }
}

再調用的方法，代碼如下：

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    // 將讀入的XML資源進行特殊編碼處理
    return loadBeanDefinitions(new EncodedResource(resource));
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    Assert.notNull(encodedResource, "EncodedResource must not be null");
    if (logger.isInfoEnabled()) {
        logger.info("Loading XML bean definitions from " + encodedResource.getResource());
    }

    Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
    if (currentResources == null) {
        currentResources = new HashSet<>(4);
        this.resourcesCurrentlyBeingLoaded.set(currentResources);
    }
    if (!currentResources.add(encodedResource)) {
        throw new BeanDefinitionStoreException(
            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
    }
    try {
        // 將資源文件轉為InputStream的IO流
        InputStream inputStream = encodedResource.getResource().getInputStream();
        try {
            // 從InputStream中得到XML的解析源
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            // 這裏是具體的讀取過程
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
        finally {
            inputStream.close();
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException(
            "IOException parsing XML document from " + encodedResource.getResource(), ex);
    }
    finally {
        currentResources.remove(encodedResource);
        if (currentResources.isEmpty()) {
            this.resourcesCurrentlyBeingLoaded.remove();
        }
    }
}

具體的讀取過程在doLoadBeanDefinitions方法中進行，將讀取的beanDefinition信息進行註冊：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    throws BeanDefinitionStoreException {
    try {
        // 通過DOM4J加載解析XML文件，最終形成Document對象
        Document doc = doLoadDocument(inputSource, resource);
        // 通過對Document對象的操作，完成BeanDefinition的加載和註冊工作
        return registerBeanDefinitions(doc, resource);
    }
    //拋出異常。。。
}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    // 創建BeanDefinitionDocumentReader來解析Document對象，完成BeanDefinition解析
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    // 獲得容器中已經註冊的BeanDefinition數量
    int countBefore = getRegistry().getBeanDefinitionCount();
    //解析過程入口，BeanDefinitionDocumentReader只是個接口，具體的實現過程在DefaultBeanDefinitionDocumentReader完成
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    // 統計新的的BeanDefinition數量
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

在上面的registerBeanDefinitions方法中，關註兩個方法：

• createReaderContext()，主要用於獲取NameSpaceResolver

• registerBeanDefinitions()，通過獲取的獲取NameSpaceResolver查找對應的NameSpaceHandler，解析文檔，得到BeanDefinition，並進行註冊。

  註：這裏是通過/src/main/resources/META-INF/spring.handlers文件進行匹配的

首先查看createReaderContext方法：

public XmlReaderContext createReaderContext(Resource resource) {
    return new XmlReaderContext(resource, this.problemReporter, this.eventListener, this.sourceExtractor, this, getNamespaceHandlerResolver());
}

public NamespaceHandlerResolver getNamespaceHandlerResolver() {
    if (this.namespaceHandlerResolver == null) {
        this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
    }
    return this.namespaceHandlerResolver;
}

protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
    ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
    return new DefaultNamespaceHandlerResolver(cl);
}

通過這三個方法，將NamespaceHandlerResolver初始化成功。

再查看DefaultBeanDefinitionDocumentReader的registerBeanDefinitions方法，代碼如下：

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    this.readerContext = readerContext;
    logger.debug("Loading bean definitions");
    // 獲得Document的根元素<beans>標簽
    Element root = doc.getDocumentElement();
    // 真正實現BeanDefinition解析和註冊工作
    doRegisterBeanDefinitions(root);
}

這裏的doRegisterBeanDefinitions是真正進行BeanDefinition解析和註冊工作的。

protected void doRegisterBeanDefinitions(Element root) {
    // 這裏使用了委托模式，將具體的BeanDefinition解析工作交給了BeanDefinitionParserDelegate去完成
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);

    // 判斷該根標簽是否包含http://www.springframework.org/schema/beans默認命名空間
    if (this.delegate.isDefaultNamespace(root)) {
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
        if (StringUtils.hasText(profileSpec)) {
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                if (logger.isInfoEnabled()) {
                    logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                "] not matching: " + getReaderContext().getResource());
                }
                return;
            }
        }
    }
    // 在解析Bean定義之前，進行自定義的解析，增強解析過程的可擴展性
    preProcessXml(root);
    // 委托給BeanDefinitionParserDelegate,從Document的根元素開始進行BeanDefinition的解析
    parseBeanDefinitions(root, this.delegate);
    // 在解析Bean定義之後，進行自定義的解析，增加解析過程的可擴展性
    postProcessXml(root);

    this.delegate = parent;
}

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // 加載的Document對象是否使用了Spring默認的XML命名空間（beans命名空間）
    if (delegate.isDefaultNamespace(root)) {
        // 獲取Document對象根元素的所有子節點（bean標簽、import標簽、alias標簽和其他自定義標簽context、aop等）
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                // bean標簽、import標簽、alias標簽，則使用默認解析規則
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                }
                else {//像context標簽、aop標簽、tx標簽，則使用用戶自定義的解析規則解析元素節點
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        // 如果不是默認的命名空間，則使用用戶自定義的解析規則解析元素節點
        delegate.parseCustomElement(root);
    }
}

這裏根據是否默認的命名空間和標簽進行不同的處理，我們先關註默認的處理。

如下，在parseDefaultElement中進行默認標簽的解析：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    // 解析<import>標簽
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    // 解析<alias>標簽
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    // 解析<bean>標簽
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
    // 解析內置<bean>標簽
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // 遞歸調用
        doRegisterBeanDefinitions(ele);
    }
}

這裏重點關註一下bean標簽的解析，如上，調用processBeanDefinition方法。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // 解析<bean>標簽，獲取BeanDefinition
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        // 如果需要，則裝飾BeanDefinition對象
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // Register the final decorated instance.
            // 註冊最終的BeanDefinition到BeanDefinitionRegistry（DefaultListableBeanFactory）
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name ‘" +
                                     bdHolder.getBeanName() + "‘", ele, ex);
        }
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

這裏通過對bean的解析獲取BeanDefinition對象，並對其進行裝飾，最終將BeanDefinition註冊到DefaultListableBeanFactory中，通過Map集合的方式進行存儲。

這裏調用BeanDefinitionParserDelegate中的三個重載方法parseBeanDefinitionElement方法進行bean標簽的解析，代碼如下：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    // 解析<bean>標簽，獲取BeanDefinition對象
    return parseBeanDefinitionElement(ele, null);
}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    // 獲取bean的id
    String id = ele.getAttribute(ID_ATTRIBUTE);
    // 獲取bean的name
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    List<String> aliases = new ArrayList<>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = aliases.remove(0);
        if (logger.isDebugEnabled()) {
            logger.debug("No XML ‘id‘ specified - using ‘" + beanName +
                         "‘ as bean name and " + aliases + " as aliases");
        }
    }

    if (containingBean == null) {
        // 檢查bean的id或者name是否唯一
        checkNameUniqueness(beanName, aliases, ele);
    }
    // 解析<bean>標簽，獲取BeanDefinition對象
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                        beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    String beanClassName = beanDefinition.getBeanClassName();
                    if (beanClassName != null &&
                        beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                        !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                        aliases.add(beanClassName);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Neither XML ‘id‘ nor ‘name‘ specified - " +
                                 "using generated bean name [" + beanName + "]");
                }
            }
            catch (Exception ex) {
                error(ex.getMessage(), ele);
                return null;
            }
        }
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        // 將BeanDefinition對象和BeanName封裝到BeanDefinitionHolder對象中
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}

public AbstractBeanDefinition parseBeanDefinitionElement(
    Element ele, String beanName, @Nullable BeanDefinition containingBean) {

    this.parseState.push(new BeanEntry(beanName));

    String className = null;
    // 獲取bean標簽的class屬性
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }
    String parent = null;
    // 獲取bean標簽的parent屬性
    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        parent = ele.getAttribute(PARENT_ATTRIBUTE);
    }

    try {
        // 創建BeanDefinition對象GenericBeanDefinition
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);
        // 解析<bean>標簽的屬性
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        /** 解析<bean>標簽的子標簽  --- begin**/
        // 解析<description>標簽
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
        // 解析<meta>標簽
        parseMetaElements(ele, bd);
        // 解析<lookup-method>標簽
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        // 解析<replaced-method>標簽
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        // 解析<constructor-arg>標簽
        parseConstructorArgElements(ele, bd);
        // 解析<property>標簽
        parsePropertyElements(ele, bd);
        // 解析<qualifier>標簽
        parseQualifierElements(ele, bd);
        /** 解析<bean>標簽的子標簽  --- end**/
        bd.setResource(this.readerContext.getResource());
        bd.setSource(extractSource(ele));
        return bd;
    }
   //拋出異常。。。
    return null;
}

三、創建Bean流程

1、流程入口

創建Bean的流程是refresh方法中的第11步：

// 實例化剩余的單例bean（非懶加載方式）
// 註意事項：Bean的IoC、DI和AOP都是發生在此步驟
finishBeanFactoryInitialization(beanFactory);

2、流程圖

sequenceDiagram AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons DefaultListableBeanFactory->>AbstractBeanFactory:getBean AbstractBeanFactory->>AbstractBeanFactory:doGetBean AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean

3、流程分析

首先通過finishBeanFactoryInitialization方法，進入DefaultListableBeanFactory的preInstantiateSingletons方法中，代碼如下：

public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Pre-instantiating singletons in " + this);
    }

    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 觸發所有非懶加載方式的單例bean的創建
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 如果bean不是抽象的，而且是單例的，同時還不是懶加載的，則進行下面的操作
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 如果bean是一個工廠bean，則走下面的方法
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                                                    ((SmartFactoryBean<?>) factory)::isEagerInit,
                                                                    getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                       ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            else { // 普通bean走下面的方法
                getBean(beanName);
            }
        }
    }

這裏主要關註普通bean的創建，進入AbstractBeanFactory中的getBean方法：

public Object getBean(String name) throws BeansException {
    // 獲取Bean的實例
    return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

    // 獲取bean名稱
    final String beanName = transformedBeanName(name);
    Object bean;

    // 從緩存中獲取單例bean
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) { //如果獲取到單例bean，則走下面代碼
        if (logger.isDebugEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.debug("Returning eagerly cached instance of singleton bean ‘" + beanName +
                             "‘ that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.debug("Returning cached instance of singleton bean ‘" + beanName + "‘");
            }
        }
        // 如果取出來的Bean實例是FactoryBean的Bean實例，則需要從FactoryBean實例中產生一個對象實例。
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {//如果沒有獲取到單例bean，則走下面代碼

        // 如果原型模式的Bean發生循環引用，則直接不處理，拋出異常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // Check if bean definition exists in this factory.
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                    nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            // 獲取要實例化的bean的BeanDefinition對象
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 檢查該BeanDefinition對象對應的Bean是否是抽象的
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            String[] dependsOn = mbd.getDependsOn();
            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 + "‘");
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                        "‘" + beanName + "‘ depends on missing bean ‘" + dep + "‘", ex);
                    }
                }
            }

            // 如果是單例的Bean，請下面的代碼
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 創建單例Bean的主要方法
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            else if (mbd.isPrototype()) {
                // It‘s a prototype -> create a new instance.
                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();
                final 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);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                                                    "Scope ‘" + scopeName + "‘ is not active for the current thread; consider " +
                                                    "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                                                    ex);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

這裏主要關註單例Bean的的創建，進入AbstractAutowireCapableBeanFactory中的createBean方法，跳轉到doCreateBean方法中，這裏是進行bean創建的核心代碼：

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {

    if (logger.isDebugEnabled()) {
        logger.debug("Creating instance of bean ‘" + beanName + "‘");
    }
    RootBeanDefinition mbdToUse = mbd;

    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // Prepare method overrides.
    // 處理方法覆蓋
    try {
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                                               beanName, "Validation of method overrides failed", ex);
    }

    try {
        // 獲取BeanPostProcessor代理對象
        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 {
        // 完成Bean實例的創建（實例化、填充屬性、初始化）
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean ‘" + beanName + "‘");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    throws BeanCreationException {

    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    // bean初始化第一步：默認調用無參構造實例化Bean
    // 構造參數依賴註入，就是發生在這一步
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // 實例化後的Bean對象
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    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;
        }
    }

    // 解決循環依賴的關鍵步驟
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
    // 如果需要提前暴露單例Bean，則將該Bean放入三級緩存中
    if (earlySingletonExposure) {
        if (logger.isDebugEnabled()) {
            logger.debug("Eagerly caching bean ‘" + beanName + "‘ to allow for resolving potential circular references");
        }
        // 將剛創建的bean放入三級緩存中singleFactories(key是beanName，value是FactoryBean)
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // bean初始化第二步：填充屬性（DI依賴註入發生在此步驟）
        populateBean(beanName, mbd, instanceWrapper);
        // bean初始化第三步：調用初始化方法，完成bean的初始化操作（AOP發生在此步驟）
        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);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName, "...");
                }
            }
        }
    }

    // Register bean as disposable.
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

這裏通過三步實現Bean的創建，具體的實現會再後面文章進行說明。

Spring容器的初始化流程