SpringIOC原理源碼理解(1)

1.Sprin的IOC過程

  1. 定位到外部配置的Bean的資源文件

  2. 解析外部配置的Bean的資源文件

  3. 初始化IOC容器

  4. 裝配Bean

  5. 通過高級IOC容器(上下文)getBean獲取程序需要的Bean

2.SpringIOC的體系結(jié)構(gòu)

圖片.png
  1. 其中BeanFactory作為最頂層的一個接口類,它定義了IOC容器的基本功能規(guī)范。

  2. BeanFactory只對IOC容器的基本行為做了定義,至于怎么加載bean它是不會關(guān)心的。

  3. BeanFactory默認(rèn)有三個子接口

  4. DefaultListableBeanFactory最終默認(rèn)實現(xiàn)了所有的接口

  5. 其中AutowireCapableBeanFactory接口定義了Bean的裝配規(guī)則

BeanFactory

 public interface BeanFactory {    
     
      //對FactoryBean的轉(zhuǎn)義定義圣贸,因為如果使用bean的名字檢索FactoryBean得到的對象是工廠生成的對象隔躲,    
      //如果需要得到工廠本身,需要轉(zhuǎn)義           
      String FACTORY_BEAN_PREFIX = "&"; 
       
      //根據(jù)bean的名字,獲取在IOC容器中得到bean實例    
      Object getBean(String name) throws BeansException;    
    
      //根據(jù)bean的名字和Class類型來得到bean實例卖漫,增加了類型安全驗證機(jī)制费尽。    
      Object getBean(String name, Class requiredType) throws BeansException;    
    
      //提供對bean的檢索,看看是否在IOC容器有這個名字的bean    
      boolean containsBean(String name);    
     
      //根據(jù)bean名字得到bean實例羊始,并同時判斷這個bean是不是單例    
      boolean isSingleton(String name) throws NoSuchBeanDefinitionException;    
     
      //得到bean實例的Class類型    
       Class getType(String name) throws NoSuchBeanDefinitionException;    
     
      //得到bean的別名旱幼,如果根據(jù)別名檢索,那么其原名也會被檢索出來    
       String[] getAliases(String name);    
     
    }

BeanDefinition(解析配置)

SpringIOC容器管理了我們定義的各種Bean對象及其相互的關(guān)系突委,Bean對象在Spring實現(xiàn)中是以BeanDefinition來描述的.Bean 的解析過程非常復(fù)雜柏卤,功能被分的很細(xì),因為這里需要被擴(kuò)展的地方很多匀油,必須保證有足夠的靈活性缘缚,以應(yīng)對可能的變化。Bean 的解析主要就是對 Spring 配置文件的解析敌蚜。這個解析過程主要通過下圖中的類完成桥滨。

圖片.png

XmlBeanFactory

XmlBeanFactory是DefaultListableBeanFactory的子類,可以說是最原始的IOC容器弛车,它只能解析XML資源文件齐媒,在現(xiàn)在版本他已經(jīng)不被推薦使用了,因為它無法在適用用當(dāng)前復(fù)雜的WEB環(huán)境纷跛。

高級的IOC容器(ApplicationContext)

隨著Spring的發(fā)展以及web環(huán)境的多變喻括,原始的XmlBeanFactory,IOC容器已經(jīng)不能滿足我們的需要,他只能讀取配置在Xml文件中bean的信息贫奠。經(jīng)過橫向的擴(kuò)展后Spring提供了高級的IOC容器ApplicationContext.ApplicationContext除了是一個高級的IOC容器還提供了很多的附加服務(wù)双妨。

  1. 支持信息源,可以實現(xiàn)國際化叮阅。(實現(xiàn)MessageSource接口)
  2. 訪問資源刁品。(實現(xiàn)ResourcePatternResolver接口)
  3. 支持應(yīng)用事件。(實現(xiàn)ApplicationEventPublisher接口)
圖片.png
  1. FileSystemXmlApplicationContext 加載指定盤符的資源文件
  2. ClassPathXmlApplicationContext 加載classpath下的資源文件
  3. xmlWebApplicationContext 加載URI資源文件

從FileSystemXmlApplicationContext 看IOC容器如何初始化

 偽代碼
new FileSystemXmlApplicationContext (path);
//使用了門面模式最終走到此處構(gòu)造方法
public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
            throws BeansException {
                 //委托到父類去設(shè)置資源加載器
                super(parent);
                //定位資源文件位置
                setConfigLocations(configLocations);
                if (refresh) {
                 refresh();
           }
    }
1.1到父類去設(shè)置資源加載器ResourceLoder
public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext, DisposableBean {
static {
        // Eagerly load the ContextClosedEvent class to avoid weird classloader issues
        // on application shutdown in WebLogic 8.1. (Reported by Dustin Woods.)
        ContextClosedEvent.class.getName();
    }

public AbstractApplicationContext() {
        this.resourcePatternResolver = getResourcePatternResolver();
    }

public AbstractApplicationContext(ApplicationContext parent) {
        this();
        setParent(parent);
    }
//設(shè)置一個資源加載器浩姥,繼承了DefaultResourceLoader所以類本身就是一個加載器
protected ResourcePatternResolver getResourcePatternResolver() {
        return new PathMatchingResourcePatternResolver(this);
    }
//設(shè)置上下文環(huán)境
@Override
    public void setParent(ApplicationContext parent) {
        this.parent = parent;
        if (parent != null) {
            Environment parentEnvironment = parent.getEnvironment();
            if (parentEnvironment instanceof ConfigurableEnvironment) {
                getEnvironment().merge((ConfigurableEnvironment) parentEnvironment);
            }
        }
    }
//設(shè)置Spring的資源加載器
public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) {
        Assert.notNull(resourceLoader, "ResourceLoader must not be null");
        this.resourceLoader = resourceLoader;
    }

這里使用了大量的Super(),委派到父類AbstractApplicationContext去加載資源加載器挑随,保證資源加載器的一致性。

1.2資源的定位
//處理資源路徑為一個字符串的情況勒叠,解析為數(shù)組的形式
public void setConfigLocation(String location) {
    //String CONFIG_LOCATION_DELIMITERS = ",; \t\n";
    setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS));
    }
//解析Bean定義資源文件的路徑兜挨,處理多個資源文件字符串?dāng)?shù)組  
public void setConfigLocations(String... locations) {
        if (locations != null) {
            Assert.noNullElements(locations, "Config locations must not be null");
            this.configLocations = new String[locations.length];
            for (int i = 0; i < locations.length; i++) {
         //將字符串解析為資源路徑
                this.configLocations[i] = resolvePath(locations[i]).trim();
            }
        }
        else {
            this.configLocations = null;
        }
    }

可以看出AbstractRefreshableConfigApplicationContext主要的作用就是資源定位。
我們既可以使用一個字符串來配置多個Spring Bean定義資源文件眯分,也可以使用字符串?dāng)?shù)組拌汇。使用一個字符串的時候要使用“,; \t\n”分隔。

至此弊决,Spring IoC容器在初始化時將配置的Bean定義資源文件定位為Spring封裝的Resource噪舀。

1.3裝載Bean
@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            //調(diào)用容器準(zhǔn)備刷新的方法魁淳,獲取容器的當(dāng)時時間,同時給容器設(shè)置同步標(biāo)識  
            prepareRefresh();
            // 告訴子類刷新內(nèi)部bean工廠与倡。
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            //為BeanFactory配置容器特性界逛,例如類加載器、事件處理器等 
            prepareBeanFactory(beanFactory);

            try {
                //為容器的某些子類指定特殊的BeanPost事件處理器  
                postProcessBeanFactory(beanFactory);
                 //調(diào)用所有注冊的BeanFactoryPostProcessor的Bean 
                invokeBeanFactoryPostProcessors(beanFactory);
                //為BeanFactory注冊BeanPost事件處理器.  
                //BeanPostProcessor是Bean后置處理器纺座,用于監(jiān)聽容器觸發(fā)的事件
                registerBeanPostProcessors(beanFactory);
                //初始化信息源息拜,和國際化相關(guān).
                initMessageSource();
                // 初始化容器事件傳播器.  
                initApplicationEventMulticaster();
                //調(diào)用子類的某些特殊Bean初始化方法 
                onRefresh();
                ///為事件傳播器注冊事件監(jiān)聽器.
                registerListeners();
                //初始化所有剩余的單態(tài)Bean. 
                finishBeanFactoryInitialization(beanFactory);
                //初始化容器的生命周期事件處理器,并發(fā)布容器的生命周期事件 
                finishRefresh();
            }

            catch (BeansException ex) {
                logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);

                //銷毀以創(chuàng)建的單態(tài)Bean  
                destroyBeans();
                //取消refresh操作净响,重置容器的同步標(biāo)識.
                cancelRefresh(ex);
                throw ex;
            }
        }
    }
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//委派到子類去調(diào)用載入定義Bean的資源文件的工廠
        refreshBeanFactory();
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

refresh()方法主要為IoC容器Bean的生命周期管理提供條件少欺,Spring IoC容器載入Bean定義資源文件從其子類容器的refreshBeanFactory()方法啟動,所以整個refresh()中“ConfigurableListableBeanFactory beanFactory =obtainFreshBeanFactory();”這句以后代碼的都是注冊容器的信息源和生命周期事件馋贤,真正的載入過程就是這句代碼赞别。

AbstractApplicationContext的子類AbstractRefreshableApplicationContext的refreshBeanFactory()方法:

@Override
    protected final void refreshBeanFactory() throws BeansException {
        //如果容器存在銷毀并關(guān)閉它
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            //創(chuàng)建IOC容器
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            // 設(shè)置容器的唯一標(biāo)識
            beanFactory.setSerializationId(getId());
            //對IoC容器進(jìn)行定制化,如設(shè)置啟動參數(shù)掸掸,開啟注解的自動裝配等 
            customizeBeanFactory(beanFactory);
           //調(diào)用加載bean的方法演训,并委派到子類實現(xiàn)
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

在創(chuàng)建IoC容器前欺税,如果已經(jīng)有容器存在,則需要把已有的容器銷毀和關(guān)閉纯续,以保證在refresh之后使用的是新建立起來的IoC容器仁讨。refresh的作用類似于對IoC容器的重啟羽莺,在新建立好的容器中對容器進(jìn)行初始化,對Bean定義資源進(jìn)行載入洞豁。IOC容器是單例的盐固。

在AbstractXmlApplicationContext中實現(xiàn)bean的加載:

@Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // 創(chuàng)建XmlBeanDefinitionReader,即創(chuàng)建Bean讀取器丈挟,并通過回調(diào)設(shè)置到容器中去刁卜,容  器使用該讀取器讀取Bean定義資源
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's
        // resource loading environment.
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        //設(shè)置資源加載器,因為父類實現(xiàn)了DefaultResourceLoader曙咽,所以本身就是個資源加載器
        beanDefinitionReader.setResourceLoader(this);
        //為Bean讀取器設(shè)置SAX xml解析器
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        //當(dāng)Bean讀取器讀取Bean定義的Xml資源文件時蛔趴,啟用Xml的校驗機(jī)制  
        initBeanDefinitionReader(beanDefinitionReader);
        //Bean讀取器真正實現(xiàn)加載的方法 
        loadBeanDefinitions(beanDefinitionReader);
    }

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        //從本類獲取Bean定義資源的定位  
        Resource[] configResources = getConfigResources();
        if (configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }
        //如果本類中獲取的Bean定義資源定位為空,則獲取FileSystemXmlApplicationContext構(gòu)造方法中setConfigLocations方法設(shè)置的資源
        String[] configLocations = getConfigLocations();
        if (configLocations != null) {
        //讀取器讀取
            reader.loadBeanDefinitions(configLocations);
        }
    }
到AbstractBeanDefinitionReader完成加載
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
        //獲取初始化IOC容器時的資源加載器
        ResourceLoader resourceLoader = getResourceLoader();
        if (resourceLoader == null) {
            throw new BeanDefinitionStoreException(
                    "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
        }

        if (resourceLoader instanceof ResourcePatternResolver) {
            try {
                //將指定位置的Bean定義資源文件解析為Spring IoC容器封裝的資源  
                //加載多個指定位置的Bean定義資源文件
                Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
                //委派子類完成加載
                int loadCount = loadBeanDefinitions(resources);
                if (actualResources != null) {
                    for (Resource resource : resources) {
                        actualResources.add(resource);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
                }
                return loadCount;
            }
            catch (IOException ex) {
                throw new BeanDefinitionStoreException(
                        "Could not resolve bean definition resource pattern [" + location + "]", ex);
            }
        }
        else {
            // Can only load single resources by absolute URL.
            //將指定位置的Bean定義資源文件解析為Spring IoC容器封裝的資源 
            //加載單個指定位置的Bean定義資源文件
            Resource resource = resourceLoader.getResource(location);
            int loadCount = loadBeanDefinitions(resource);
            if (actualResources != null) {
                actualResources.add(resource);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
            }
            return loadCount;
        }
    }
@Override
    public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
        Assert.notNull(locations, "Location array must not be null");
        int counter = 0;
        for (String location : locations) {
            counter += loadBeanDefinitions(location);
        }
        return counter;
    }

獲取資源的方法

IOC容器初始化時例朱,在初始化時默認(rèn)的資源加載是DefaultResourceLoader孝情,調(diào)用getResource方法獲取要加載的資源。

@Override
    public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");
         //如果是指定盤符下的路徑  
        if (location.startsWith("/")) {
            return getResourceByPath(location);
        }
           //如果是類路徑的方式洒嗤,那需要使用ClassPathResource 來得到bean 文件的資源對象  
        else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
            return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
        }
        else {
            try {
     // 如果是URL 方式箫荡,使用UrlResource 作為bean 文件的資源對象..
                URL url = new URL(location);
                return new UrlResource(url);
            }
            catch (MalformedURLException ex) {
                // No URL -> resolve as resource path.
                return getResourceByPath(location);
            }
        }
    }

FileSystemXmlApplicationContext容器提供了getResourceByPath方法的實現(xiàn),就是為了處理既不是classpath標(biāo)識渔隶,又不是URL標(biāo)識的Resource定位這種情況羔挡。

@Override
    protected Resource getResourceByPath(String path) {
        if (path != null && path.startsWith("/")) {
            path = path.substring(1);
        }
        return new FileSystemResource(path);
    }

得到了所需要的資源之后,調(diào)用XmlBeanDefinitionReader的loadBeanDefinitions(Resource resource)方法加載bean

//編碼處理
@Override
    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
        return loadBeanDefinitions(new EncodedResource(resource));
    }
    //這里是載入XML形式Bean定義資源文件方法
    public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        Assert.notNull(encodedResource, "EncodedResource must not be null");
        ......
        try {
              //將資源轉(zhuǎn)換為流
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
               //從InputStream中得到XML的解析源 
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {
                    inputSource.setEncoding(encodedResource.getEncoding());
                }
                   //具體的解析xml過程
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }
            finally {
                inputStream.close();
            }
        }
        .........
     //XML文件轉(zhuǎn)化為DOM對象的過程
     protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {
               //將XML文件轉(zhuǎn)換為DOM對象,解析過程由documentLoader實現(xiàn)
            Document doc = doLoadDocument(inputSource, resource);
              //這里是啟動對Bean定義解析的詳細(xì)過程婉弹,該解析過程會用到Spring的Bean配置規(guī)則
            return registerBeanDefinitions(doc, resource);
            .......
        }
    }

具體解析過程不分析了
接下來是最重要的一步分析Spring IoC容器將載入的Bean定義資源文件轉(zhuǎn)換為Document對象之后睬魂,是如何將其解析為Spring IoC管理的Bean對象并將其注冊到容器中的

注冊bean對象到IOC容器

//將Bean的資源轉(zhuǎn)換為Spring IOC容器的內(nèi)部數(shù)據(jù)格式
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        //創(chuàng)建BeanDefinitionDocumentReader對DOM對象進(jìn)行讀取
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        documentReader.setEnvironment(getEnvironment());
        //獲得容器中注冊的Bean數(shù)量  
        int countBefore = getRegistry().getBeanDefinitionCount();
        //解析過程入口,這里使用了委派模式
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        //統(tǒng)計解析的Bean數(shù)量  
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }

到DefaultBeanDefinitionDocumentReader解析DOM文檔

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        //獲得根元素
        Element root = doc.getDocumentElement();
        //進(jìn)行解析
        doRegisterBeanDefinitions(root);
    }
//進(jìn)行解析的方法
protected void doRegisterBeanDefinitions(Element root) {
        actually necessitating one.
        //去創(chuàng)建BeanDefinitionParserDelegate 對象
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent);
        //Bean定義的Document對象使用了Spring默認(rèn)的XML命名空間
        if (this.delegate.isDefaultNamespace(root)) {
        //首先檢查是否含有profile標(biāo)簽
            String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
            if (StringUtils.hasText(profileSpec)) {
        //解析 profile 標(biāo)簽  
                String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                        profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                    return;
                }
            }
        }
        //在解析Bean定義之前镀赌,進(jìn)行自定義的解析氯哮,增強解析過程的可擴(kuò)展性
        preProcessXml(root);
        //從根元素開始完成解析
        parseBeanDefinitions(root, this.delegate);
        //在解析Bean定義之后,進(jìn)行自定義的解析商佛,增加解析過程的可擴(kuò)展性
        postProcessXml(root);

        this.delegate = parent;
    }


protected BeanDefinitionParserDelegate createDelegate(
            XmlReaderContext readerContext, Element root, BeanDefinitionParserDelegate parentDelegate) {
        //創(chuàng)建BeanDefinitionParserDelegate對象
        BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
        //BeanDefinitionParserDelegate初始化Document根元素
        delegate.initDefaults(root, parentDelegate);
        return delegate;
    }

<profile>在Spring3開始提供喉钢,配合Maven完成多個配置環(huán)境的切換

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
         //Bean定義的Document對象使用了Spring默認(rèn)的XML命名空間 
        if (delegate.isDefaultNamespace(root)) {
         //獲取Bean定義的Document對象根元素的所有子節(jié)點
            NodeList nl = root.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                //獲得Document節(jié)點是XML元素節(jié)點
                if (node instanceof Element) {
                    Element ele = (Element) node;
                    if (delegate.isDefaultNamespace(ele)) {
                      //使用Spring默認(rèn)的Bean規(guī)則解析
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                       //使用自定義的的Bean規(guī)則解析
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
      //Document的根節(jié)點沒有使用Spring默認(rèn)的命名空間,則使用用戶自定義的
            delegate.parseCustomElement(root);
        }
    }

看Spring默認(rèn)解析Bean的方式

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        //如果元素節(jié)點是<Import>導(dǎo)入元素良姆,進(jìn)行導(dǎo)入解析
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            importBeanDefinitionResource(ele);
        }
       //如果元素節(jié)點是<Alias>別名元素肠虽,進(jìn)行別名解析
        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        }
       //元素節(jié)點既不是導(dǎo)入元素,也不是別名元素玛追,即普通的<Bean>元素
       //按照Spring的Bean規(guī)則解析元素
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        }
     //含有<beans> 標(biāo)簽再去解析
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
            // recurse
            doRegisterBeanDefinitions(ele);
        }
    }

    //解析import標(biāo)簽
    protected void importBeanDefinitionResource(Element ele) {
        //獲取<import>標(biāo)簽中resource屬性的內(nèi)容location
        String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
        //屬性值為空税课,返回
        if (!StringUtils.hasText(location)) {
            getReaderContext().error("Resource location must not be empty", ele);
            return;
        }

        //使用系統(tǒng)變量值解析location屬性值
        location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

        Set<Resource> actualResources = new LinkedHashSet<Resource>(4);

        //標(biāo)識給定的導(dǎo)入元素的location是否是絕對路徑
        boolean absoluteLocation = false;
        try {
            absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
        }
        catch (URISyntaxException ex) {
            //給定的導(dǎo)入元素的location不是絕對路徑  
        }

        //給定的導(dǎo)入元素的location是絕對路徑  
        if (absoluteLocation) {
            try {
                //使用資源讀入器加載給定路徑的Bean定義資源
                int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
                if (logger.isDebugEnabled()) {
                    logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
                }
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error(
                        "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
            }
        }
        else {
            //給定的導(dǎo)入元素的location是相對路徑
            try {
                int importCount;
                //將給定導(dǎo)入元素的location封裝為相對路徑資源
                Resource relativeResource = getReaderContext().getResource().createRelative(location);
                //如果資源存在
                if (relativeResource.exists()) {
                    //使用資源讀入器加載Bean定義資源
                    importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
                    actualResources.add(relativeResource);
                }
                else {
                    //封裝的相對路徑資源不存在
                    //獲取Spring IoC容器資源讀入器的基本路徑
                    String baseLocation = getReaderContext().getResource().getURL().toString();
                    //封裝資源
                    importCount = getReaderContext().getReader().loadBeanDefinitions(
                            StringUtils.applyRelativePath(baseLocation, location), actualResources);
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
                }
            }
            catch (IOException ex) {
                getReaderContext().error("Failed to resolve current resource location", ele, ex);
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
                        ele, ex);
            }
        }
        //最后將資源封裝好
        Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
        //在解析完<Import>元素之后,發(fā)送容器導(dǎo)入其他資源處理完成事件  
        getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
    }


 //解析alias標(biāo)簽
   protected void processAliasRegistration(Element ele) {
        //獲取name屬性值
        String name = ele.getAttribute(NAME_ATTRIBUTE);
        //獲取alias屬性值
        String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
        boolean valid = true;
        if (!StringUtils.hasText(name)) {
            getReaderContext().error("Name must not be empty", ele);
            valid = false;
        }
        if (!StringUtils.hasText(alias)) {
            getReaderContext().error("Alias must not be empty", ele);
            valid = false;
        }
        //兩個屬性值不能為null
        if (valid) {
            try {
                //向IOC容器注冊別名
                getReaderContext().getRegistry().registerAlias(name, alias);
            }
            catch (Exception ex) {
                getReaderContext().error("Failed to register alias '" + alias +
                        "' for bean with name '" + name + "'", ele, ex);
            }
            //在解析完<Alias>元素之后痊剖,發(fā)送容器別名處理完成事件
            getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
        }
    }


//解析普通bean
    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        //使用BeanDefinitionHolder對普通bean進(jìn)行封裝
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            //對封裝好的普通Bean對象進(jìn)行解析
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                //向Spring IoC容器注冊解析得到的Bean定義韩玩,這是Bean定義向IoC容器注冊的入口 
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error("Failed to register bean definition with name '" +
                        bdHolder.getBeanName() + "'", ele, ex);
            }
            //在完成向Spring IoC容器注冊解析得到的Bean定義之后,發(fā)送注冊事件
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

到BeanDefinitionParserDelegate封裝普通的Bean對象


//解析普通的Bean標(biāo)簽
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        //獲取的ID name的屬性值
        String id = ele.getAttribute(ID_ATTRIBUTE);
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
        //創(chuàng)建一個別名的集合
        List<String> aliases = new ArrayList<String>();
        //將name屬性值存放到別名的集合
        if (StringUtils.hasLength(nameAttr)) {
            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            aliases.addAll(Arrays.asList(nameArr));
        }
        //id
        String beanName = id;
        //如果<Bean>元素中沒有配置id屬性時陆馁,將別名中的第一個值賦值給beanName
        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");
            }
        }
        //元素中是否包含子<Bean>元素
        if (containingBean == null) {
            //檢查<Bean>元素所配置的id或者name的唯一性
            checkNameUniqueness(beanName, aliases, ele);
        }
        //詳細(xì)對<Bean>元素中配置的Bean定義進(jìn)行解析的地方 
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            //如果id為null
            if (!StringUtils.hasText(beanName)) {
                try {
                    //如果id為null,且包含子<bean>標(biāo)簽找颓,生成一個id
                    if (containingBean != null) {
                        beanName = BeanDefinitionReaderUtils.generateBeanName(
                                beanDefinition, this.readerContext.getRegistry(), true);
                    }
                    else {
                        //如果id為null,且不包含子<bean>標(biāo)簽,生成一個id
                        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);
            //返回封裝好的Bean
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }

        return null;
    }
    
//具體解析過程
    public AbstractBeanDefinition parseBeanDefinitionElement(
            Element ele, String beanName, BeanDefinition containingBean) {
        //記錄解析的<Bean>击狮,這是一個棧  
        this.parseState.push(new BeanEntry(beanName));
        //獲得全限定類名,但是不做實例化處理益老,交給AbstractBeanDefinition彪蓬,記錄
        String className = null;
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
        }
        
        try {
            String parent = null;
            //如果<Bean>元素中配置了parent屬性,則獲取parent屬性的值
            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
                parent = ele.getAttribute(PARENT_ATTRIBUTE);
            }
             //根據(jù)<Bean>元素配置的class名稱和parent屬性值創(chuàng)建BeanDefinition  
             //為載入Bean定義信息做準(zhǔn)備
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
            //對當(dāng)前的<Bean>元素中配置的一些屬性進(jìn)行解析和設(shè)置捺萌,如配置的單態(tài)(singleton)屬性等  
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            //為<Bean>元素解析的Bean設(shè)置description信息
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            //對<Bean>元素的meta(元信息)屬性解析
            parseMetaElements(ele, bd);
            //對<Bean>元素的lookup-method屬性解析
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            //對<Bean>元素的replaced-method屬性解析  
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
             //解析<Bean>元素的構(gòu)造方法設(shè)置
            parseConstructorArgElements(ele, bd);
            //解析<Bean>元素的<property>設(shè)置
            parsePropertyElements(ele, bd);
            //解析<Bean>元素的qualifier屬性
            parseQualifierElements(ele, bd);
            //為當(dāng)前解析的Bean設(shè)置所需的資源和依賴對象
            bd.setResource(this.readerContext.getResource());
            bd.setSource(extractSource(ele));

            return bd;
        }
        catch (ClassNotFoundException ex) {
            error("Bean class [" + className + "] not found", ele, ex);
        }
        catch (NoClassDefFoundError err) {
            error("Class that bean class [" + className + "] depends on not found", ele, err);
        }
        catch (Throwable ex) {
            error("Unexpected failure during bean definition parsing", ele, ex);
        }
        finally {
            this.parseState.pop();
        }

        return null;
    }

在解析<Bean>元素過程中沒有創(chuàng)建和實例化Bean對象档冬,只是創(chuàng)建了Bean對象的定義類BeanDefinition,將<Bean>元素中的配置信息設(shè)置到BeanDefinition中作為記錄互婿,當(dāng)依賴注入時才使用這些記錄信息創(chuàng)建和實例化具體的Bean對象捣郊。

<property>標(biāo)簽解析過程

  //獲取Property標(biāo)簽
  public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
        //獲取<bean>標(biāo)簽的所有子標(biāo)簽
        NodeList nl = beanEle.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            //如果是property標(biāo)簽
            if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
                //解析
                parsePropertyElement((Element) node, bd);
            }
        }
    }


   public void parsePropertyElement(Element ele, BeanDefinition bd) {
        //獲取name屬性值
        String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
        //name屬性值為空 返回
        if (!StringUtils.hasLength(propertyName)) {
            error("Tag 'property' must have a 'name' attribute", ele);
            return;
        }
        this.parseState.push(new PropertyEntry(propertyName));
        try {
            //如果一個Bean中已經(jīng)有同名的property存在,則不進(jìn)行解析慈参,直接返回
             //即如果在同一個Bean中配置同名的property呛牲,則只有第一個起作用  
            if (bd.getPropertyValues().contains(propertyName)) {
                error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
                return;
            }
            //解析value值
            Object val = parsePropertyValue(ele, bd, propertyName);
            //創(chuàng)建Property實例
            PropertyValue pv = new PropertyValue(propertyName, val);
            //解析<property>元素中的屬性
            parseMetaElements(ele, pv);
            pv.setSource(extractSource(ele));
            //將property實例設(shè)置給BeanDefinition
            bd.getPropertyValues().addPropertyValue(pv);
        }
        finally {
            
            this.parseState.pop();
        }
    }


  public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
        String elementName = (propertyName != null) ?
                        "<property> element for property '" + propertyName + "'" :
                        "<constructor-arg> element";
        //子元素類型
        // Should only have one child element: ref, value, list, etc.
        NodeList nl = ele.getChildNodes();
        Element subElement = null;
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            //子元素不是description和meta屬性  
            if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
                    !nodeNameEquals(node, META_ELEMENT)) {
                // Child element is what we're looking for.
                if (subElement != null) {
                    error(elementName + " must not contain more than one sub-element", ele);
                }
                else {
                    subElement = (Element) node;
                }
            }
        }
        //判斷property的屬性值是ref還是value,不允許既是ref又是value
        boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
        boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
        if ((hasRefAttribute && hasValueAttribute) ||
                ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
            error(elementName +
                    " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
        }
        //如果是ref屬性
        if (hasRefAttribute) {
            String refName = ele.getAttribute(REF_ATTRIBUTE);
            if (!StringUtils.hasText(refName)) {
                error(elementName + " contains empty 'ref' attribute", ele);
            }
            //如果屬性是ref驮配,創(chuàng)建一個ref的數(shù)據(jù)對象RuntimeBeanReference娘扩,這個對象封裝ref資源
            RuntimeBeanReference ref = new RuntimeBeanReference(refName);
            //設(shè)置這個ref的數(shù)據(jù)對象是被當(dāng)前的property對象所引用
            ref.setSource(extractSource(ele));
            return ref;
        }
        //如果屬性是value着茸,創(chuàng)建一個value的數(shù)據(jù)對象TypedStringValue,這個對象  封裝value資源
        else if (hasValueAttribute) {
            TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
            //設(shè)置這個value數(shù)據(jù)對象是被當(dāng)前的property對象所引用
            valueHolder.setSource(extractSource(ele));
            return valueHolder;
        }
         //如果當(dāng)前<property>元素還有子元素
        else if (subElement != null) {
            //解析<property>的子元素  
            return parsePropertySubElement(subElement, bd);
        }
        else {
            // Neither child element nor "ref" or "value" attribute found.
            error(elementName + " must specify a ref or value", ele);
            return null;
        }
    }

a. ref被封裝為指向依賴對象一個引用琐旁。

b.value配置都會封裝成一個字符串類型的對象涮阔。

c.ref和value都通過“解析的數(shù)據(jù)類型屬性值.setSource(extractSource(ele));”方法將屬性值/引用與所引用的屬性關(guān)聯(lián)起來

//解析<property>元素中ref,value或者集合等子元素
public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {
        //如果<property>沒有使用Spring默認(rèn)的命名空間,則使用用戶自定義的規(guī)則解析
        if (!isDefaultNamespace(ele)) {
            return parseNestedCustomElement(ele, bd);
        }
        else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
            //如果子元素是bean灰殴,則使用解析<Bean>元素的方法解析
            BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
            if (nestedBd != null) {
                nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
            }
            return nestedBd;
        }
        //如果包含ref屬性
        else if (nodeNameEquals(ele, REF_ELEMENT)) {
            //獲取<property>元素中的bean屬性值敬特,引用其他解析的Bean的名稱 
            //可以不再同一個Spring配置文件中,具體請參考Spring對ref的配置規(guī)則  
            String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
            boolean toParent = false;
            if (!StringUtils.hasLength(refName)) {
                //獲取<property>元素中的local屬性值牺陶,引用同一個Xml文件中配置  
               //的Bean的id伟阔,local和ref不同,local只能引用同一個配置文件中的Bean  
                refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);
                if (!StringUtils.hasLength(refName)) {
                    //獲取<property>元素中parent屬性值掰伸,引用父級容器中的Bean
                    refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
                    toParent = true;
                    if (!StringUtils.hasLength(refName)) {
                        error("'bean', 'local' or 'parent' is required for <ref> element", ele);
                        return null;
                    }
                }
            }
             //沒有配置ref的目標(biāo)屬性值  
            if (!StringUtils.hasText(refName)) {
                error("<ref> element contains empty target attribute", ele);
                return null;
            }
            //創(chuàng)建ref類型數(shù)據(jù)皱炉,指向被引用的對象
            RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
             //設(shè)置引用類型值是被當(dāng)前子元素所引用  
            ref.setSource(extractSource(ele));
            return ref;
        }
        else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
            return parseIdRefElement(ele);
        }
        else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
            return parseValueElement(ele, defaultValueType);
        }
         //如果子元素是null,為<property>設(shè)置一個封裝null值的字符串?dāng)?shù)據(jù)
        else if (nodeNameEquals(ele, NULL_ELEMENT)) {
            
            TypedStringValue nullHolder = new TypedStringValue(null);
            nullHolder.setSource(extractSource(ele));
            return nullHolder;
        }
        else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
            return parseArrayElement(ele, bd);
        }
        else if (nodeNameEquals(ele, LIST_ELEMENT)) {
            return parseListElement(ele, bd);
        }
        else if (nodeNameEquals(ele, SET_ELEMENT)) {
            return parseSetElement(ele, bd);
        }
        else if (nodeNameEquals(ele, MAP_ELEMENT)) {
            return parseMapElement(ele, bd);
        }
        else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
            return parsePropsElement(ele);
        }
        else {
            error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
            return null;
        }
    }
//解析<list>集合子元素 
public List<Object> parseListElement(Element collectionEle, BeanDefinition bd) {
        //獲取<list>元素中的value-type屬性狮鸭,即獲取集合元素的數(shù)據(jù)類型  
        String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);
         //獲取<list>集合元素中的所有子節(jié)點 
        NodeList nl = collectionEle.getChildNodes();
        //Spring中將List封裝為ManagedList
        ManagedList<Object> target = new ManagedList<Object>(nl.getLength());
        //設(shè)置引用資源
        target.setSource(extractSource(collectionEle));
        //設(shè)置集合目標(biāo)數(shù)據(jù)類型  
        target.setElementTypeName(defaultElementType);
        target.setMergeEnabled(parseMergeAttribute(collectionEle));
        //解析
        parseCollectionElements(nl, target, bd, defaultElementType);
        return target;
    }

protected void parseCollectionElements(
            NodeList elementNodes, Collection<Object> target, BeanDefinition bd, String defaultElementType) {
         //遍歷集合所有節(jié)點  
        for (int i = 0; i < elementNodes.getLength(); i++) {
            Node node = elementNodes.item(i);
            if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) {
                //將解析的元素加入集合中合搅,遞歸調(diào)用下一個子元素 
                target.add(parsePropertySubElement((Element) node, bd, defaultElementType));
            }
        }
    }

經(jīng)過對Spring Bean定義資源文件轉(zhuǎn)換的Document對象中的元素層層解析,Spring IoC現(xiàn)在已經(jīng)將XML形式定義的Bean定義資源文件轉(zhuǎn)換為Spring IoC所識別的數(shù)據(jù)結(jié)構(gòu)——BeanDefinition歧蕉,它是Bean定義資源文件中配置的POJO對象在Spring IoC容器中的映射灾部,我們可以通過AbstractBeanDefinition為入口,榮IoC容器進(jìn)行索引廊谓、查詢和操作梳猪。
通過Spring IoC容器對Bean定義資源的解析后麻削,IoC容器大致完成了管理Bean對象的準(zhǔn)備工作蒸痹,即初始化過程,但是最為重要的依賴注入還沒有發(fā)生呛哟,現(xiàn)在在IoC容器中BeanDefinition存儲的只是一些靜態(tài)信息叠荠,接下來需要向容器注冊Bean定義信息才能全部完成IoC容器的初始化過程.

解析完成后,將BeanDefinition注冊到IOC容器

    public static void registerBeanDefinition(
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
            throws BeanDefinitionStoreException {

        // Register bean definition under primary name.
        String beanName = definitionHolder.getBeanName();
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

        // Register aliases for bean name, if any.
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String alias : aliases) {
                registry.registerAlias(beanName, alias);
            }
        }
    }

DefaultListableBeanFactory中完成注冊

    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);
    
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {

        Assert.hasText(beanName, "Bean name must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");

        if (beanDefinition instanceof AbstractBeanDefinition) {
            try {
                ((AbstractBeanDefinition) beanDefinition).validate();
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                        "Validation of bean definition failed", ex);
            }
        }

        BeanDefinition oldBeanDefinition;

        oldBeanDefinition = this.beanDefinitionMap.get(beanName);
        //檢查是否有同名的BeanDefinition已經(jīng)在IoC容器中注冊扫责,如果已經(jīng)注冊榛鼎,  
        //并且不允許覆蓋已注冊的Bean,則拋出注冊失敗異常
        if (oldBeanDefinition != null) {
            if (!isAllowBeanDefinitionOverriding()) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                        "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                        "': There is already [" + oldBeanDefinition + "] bound.");
            }
            //如果允許覆蓋鳖孤,則同名的Bean者娱,后注冊的覆蓋先注冊的
            else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
                // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                            "' with a framework-generated bean definition: replacing [" +
                            oldBeanDefinition + "] with [" + beanDefinition + "]");
                }
            }
            else {
                if (this.logger.isInfoEnabled()) {
                    this.logger.info("Overriding bean definition for bean '" + beanName +
                            "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
                }
            }
        }
        else {
             //IoC容器中沒有已經(jīng)注冊同名的Bean,按正常注冊流程注冊
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
            this.frozenBeanDefinitionNames = null;
        }
        //存儲注冊的BeanDefinition
        this.beanDefinitionMap.put(beanName, beanDefinition);
        //重置所有已經(jīng)注冊過的BeanDefinition的緩存 
        if (oldBeanDefinition != null || containsSingleton(beanName)) {
            resetBeanDefinition(beanName);
        }
    }

至此苏揣,Bean定義資源文件中配置的Bean被解析過后黄鳍,已經(jīng)注冊到IoC容器中,被容器管理起來平匈,真正完成了IoC容器初始化所做的全部工作】蚬担現(xiàn) 在IoC容器中已經(jīng)建立了整個Bean的配置信息藏古,這些BeanDefinition信息已經(jīng)可以使用,并且可以被檢索忍燥,IoC容器的作用就是對這些注冊的Bean定義信息進(jìn)行處理和維護(hù)拧晕。這些的注冊的Bean定義信息是IoC容器控制反轉(zhuǎn)的基礎(chǔ),正是有了這些注冊的數(shù)據(jù)梅垄,容器才可以進(jìn)行依賴注入厂捞。

ioc.jpg

總結(jié)一下IOC容器初始化的基本步驟:
首先IOC容器,需要設(shè)置資加載器和定位資源队丝,為了保證資源加載器的一致性會在祖先類AbstructApplicationContext中設(shè)置一個默認(rèn)的
DefaultResourceLoader.而資源的定位是在AbstructRefreshableConfigApplicationContext中定位的蔫敲。
通過refresh()方法,在AbstructRefreshableApplicationContext中創(chuàng)建唯一的IOC容器炭玫,并通過loadBeanDefinitions(beanFactory)開啟資源加載的過程奈嘿。
然后會在XmlWebApplicationContext中設(shè)置資源讀取器,并委托到AbstractBeanDefinitionReader去吞加,在AbstractBeanDefinitionReader會獲取到IOC容器的資源加載器
通過getResoureces()方法將資源(xml文件)封裝為IOC容器的資源裙犹。然后通過子類XmlBeanDefinitionReader經(jīng)過編碼處理,使用標(biāo)準(zhǔn)的JAXP解析資源為DOM對象衔憨。
再通過XmlBeanDefinitionReader的子類DefaultBeanDefinitionDocumentReader去解析DOM對象叶圃,同時解析profile,import,alias標(biāo)簽践图。
而普通的Bean會由BeanDefinitionParserDelegate類完成解析掺冠,封裝為一個beanDefinition對象(并沒有實例化),然后將結(jié)果返回到DefaultBeanDefinitionDocumentReade封裝成
BeanDefinitionHolder码党,最終交給DefaultListableBeanFactory注冊到IOC容器德崭。
注冊過程就是在 IOC 容器內(nèi)部維護(hù)的一個ConcurrentHashMap來保存得到的BeanDefinition的過程。這個Map是IoC容器持有bean信息的場所以后對bean的操作都是圍繞這個HashMap來實現(xiàn)的.
然后我們就可以通過BeanFactory和ApplicationContext來享受到Spring IOC的服務(wù)了.

最后編輯于
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 序言:七十年代末揖盘,一起剝皮案震驚了整個濱河市眉厨,隨后出現(xiàn)的幾起案子,更是在濱河造成了極大的恐慌兽狭,老刑警劉巖憾股,帶你破解...
    沈念sama閱讀 211,194評論 6 490
  • 序言:濱河連續(xù)發(fā)生了三起死亡事件,死亡現(xiàn)場離奇詭異箕慧,居然都是意外死亡服球,警方通過查閱死者的電腦和手機(jī),發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 90,058評論 2 385
  • 文/潘曉璐 我一進(jìn)店門颠焦,熙熙樓的掌柜王于貴愁眉苦臉地迎上來斩熊,“玉大人,你說我怎么就攤上這事蒸健∽恚” “怎么了婉商?”我有些...
    開封第一講書人閱讀 156,780評論 0 346
  • 文/不壞的土叔 我叫張陵,是天一觀的道長渣叛。 經(jīng)常有香客問我丈秩,道長,這世上最難降的妖魔是什么淳衙? 我笑而不...
    開封第一講書人閱讀 56,388評論 1 283
  • 正文 為了忘掉前任蘑秽,我火速辦了婚禮,結(jié)果婚禮上箫攀,老公的妹妹穿的比我還像新娘肠牲。我一直安慰自己,他們只是感情好靴跛,可當(dāng)我...
    茶點故事閱讀 65,430評論 5 384
  • 文/花漫 我一把揭開白布缀雳。 她就那樣靜靜地躺著,像睡著了一般梢睛。 火紅的嫁衣襯著肌膚如雪肥印。 梳的紋絲不亂的頭發(fā)上,一...
    開封第一講書人閱讀 49,764評論 1 290
  • 那天绝葡,我揣著相機(jī)與錄音深碱,去河邊找鬼。 笑死藏畅,一個胖子當(dāng)著我的面吹牛敷硅,可吹牛的內(nèi)容都是我干的。 我是一名探鬼主播愉阎,決...
    沈念sama閱讀 38,907評論 3 406
  • 文/蒼蘭香墨 我猛地睜開眼绞蹦,長吁一口氣:“原來是場噩夢啊……” “哼!你這毒婦竟也來了诫硕?” 一聲冷哼從身側(cè)響起坦辟,我...
    開封第一講書人閱讀 37,679評論 0 266
  • 序言:老撾萬榮一對情侶失蹤刊侯,失蹤者是張志新(化名)和其女友劉穎章办,沒想到半個月后,有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體滨彻,經(jīng)...
    沈念sama閱讀 44,122評論 1 303
  • 正文 獨居荒郊野嶺守林人離奇死亡藕届,尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點故事閱讀 36,459評論 2 325
  • 正文 我和宋清朗相戀三年,在試婚紗的時候發(fā)現(xiàn)自己被綠了亭饵。 大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片休偶。...
    茶點故事閱讀 38,605評論 1 340
  • 序言:一個原本活蹦亂跳的男人離奇死亡,死狀恐怖辜羊,靈堂內(nèi)的尸體忽然破棺而出踏兜,到底是詐尸還是另有隱情词顾,我是刑警寧澤,帶...
    沈念sama閱讀 34,270評論 4 329
  • 正文 年R本政府宣布碱妆,位于F島的核電站肉盹,受9級特大地震影響,放射性物質(zhì)發(fā)生泄漏疹尾。R本人自食惡果不足惜上忍,卻給世界環(huán)境...
    茶點故事閱讀 39,867評論 3 312
  • 文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望纳本。 院中可真熱鬧窍蓝,春花似錦、人聲如沸繁成。這莊子的主人今日做“春日...
    開封第一講書人閱讀 30,734評論 0 21
  • 文/蒼蘭香墨 我抬頭看了看天上的太陽巾腕。三九已至观蓄,卻和暖如春,著一層夾襖步出監(jiān)牢的瞬間祠墅,已是汗流浹背侮穿。 一陣腳步聲響...
    開封第一講書人閱讀 31,961評論 1 265
  • 我被黑心中介騙來泰國打工, 沒想到剛下飛機(jī)就差點兒被人妖公主榨干…… 1. 我叫王不留毁嗦,地道東北人亲茅。 一個月前我還...
    沈念sama閱讀 46,297評論 2 360
  • 正文 我出身青樓,卻偏偏與公主長得像狗准,于是被迫代替她去往敵國和親克锣。 傳聞我的和親對象是個殘疾皇子,可洞房花燭夜當(dāng)晚...
    茶點故事閱讀 43,472評論 2 348

推薦閱讀更多精彩內(nèi)容