Spring源码解析二：Spring IOC容器的初始化

谁践踏了优雅 2023-07-25 14:05 19阅读 0赞

### IOC容器的初始化分为三个步骤 ###

1.  Resource定位，即BeanDefinition的资源定位。
2.  BeanDefinition的载入
3.  向IOC容器注册BeanDefinition

### 1，Resource定位 ###

以ApplicationContext的具体实现FileSystemXmlApplicationContext来介绍Resource定位的过程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70]  
IOC容器初始化类比为用木桶来装水，Resource的定位过程就是寻找水的过程。

它是由ResourceLoader通过统一的Resource接口来完成的，Resource对各种形式的BeanDefinition的使用都提供了统一的接口  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70 1]  
Resource接口有许多实现类，针对不同的BeanDefinition，如：

在文件系统中的Bean定义信息可以使用FileSystemResource来进行抽象。

在类路径中的Bean定义信息可以使用ClassPathResource来进行抽象。

我们来看下FileSystemXmlApplicationContext其中的一个构造函数：

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
                throws BeansException {
        
    
            super(parent);
            setConfigLocations(configLocations);
            if (refresh) {
        
                refresh();
            }
        }

这里有个\*\*refresh()\*\*方法，这个方法非常重要，可以说是IOC容器启动的入口，该方法的实现在AbstractApplicationContext中。

在AbstractApplicationContext的refresh方法中，最终对调用到AbstractRefreshableApplicationContext的refreshBeanFactory，在这里会创建一个基础的IOC容器供ApplicationContext使用，这个基础的BeanFactory就是DefaultListableBeanFactory。

protected final void refreshBeanFactory() throws BeansException {
        
            if (hasBeanFactory()) {
        
                destroyBeans();
                closeBeanFactory();
            }
            try {
        
                DefaultListableBeanFactory beanFactory = createBeanFactory();
                beanFactory.setSerializationId(getId());
                customizeBeanFactory(beanFactory);
                loadBeanDefinitions(beanFactory);
                synchronized (this.beanFactoryMonitor) {
        
                    this.beanFactory = beanFactory;
                }
            }
            catch (IOException ex) {
        
                throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
            }
        }

再根据loadBeanDefinitions方法一直往下查找，最终会找到DefaultResourceLoader类的getResource方法：

public Resource getResource(String location) {
        
            Assert.notNull(location, "Location must not be null");
            if (location.startsWith(CLASSPATH_URL_PREFIX)) {
        
                return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
            }
            else {
        
                try {
        
                    // Try to parse the location as a URL...
                    URL url = new URL(location);
                    return new UrlResource(url);
                }
                catch (MalformedURLException ex) {
        
                    // No URL -> resolve as resource path.
                    return getResourceByPath(location);
                }
            }
        }

这里的getResourceByPath方法最终被子类重写，该场景下重写该方法的类就是FileSystemXmlApplicationContext

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

这样我们从FileSystemXmlApplicationContext的构造函数中的refresh方法开始，最终到getResourceByPath结束，完成了资源定位的解析。但是这个只是容器启动中的一部分，还有载入和解析也是糅合在一起的，只是为了思路清晰，故意对这些地方视而不见。

### 2，BeanDefinition的载入和解析 ###

在第一部分资源的定位中，我们是以getResourceByPath()结束的，接下来我们要通过该方法返回的Resource对象来进行BeanDefinition的载入了。现在我们已经知道水在哪里了，就可以现在打水和装水之旅了。

这个过程就是将定义的BeanDefinition在IOC容器中转化成一个Spring内部表示的数据结构的过程。我们紧接着前面的源码往下梳理：

AbstractRefreshableApplicationContext的方法refreshBeanFactory中调用loadBeanDefinitions(),往下梳理找到类AbstractXmlApplicationContext，源码片段如下：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        
            // Create a new XmlBeanDefinitionReader for the given BeanFactory.
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
            // Configure the bean definition reader with this context's
            // resource loading environment.
            beanDefinitionReader.setResourceLoader(this);
            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
            // Allow a subclass to provide custom initialization of the reader,
            // then proceed with actually loading the bean definitions.
            initBeanDefinitionReader(beanDefinitionReader);
            loadBeanDefinitions(beanDefinitionReader);
        }

其中第7行是为读取器设置ResourceLoader，为后面的资源读取做准备；第13行就是启动Bean定义信息载入的开始。

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        
            Resource[] configResources = getConfigResources();
            if (configResources != null) {
        
                reader.loadBeanDefinitions(configResources);
            }
            String[] configLocations = getConfigLocations();
            if (configLocations != null) {
        
                reader.loadBeanDefinitions(configLocations);
            }
        }

第2行是以Resource的方式获取配置文件的资源位置，而第6行是以String的形式获取配置文件的位置。

reader.loadBeanDefinitions()的实现见XmlBeanDefinitionReader的父类AbstractBeanDefinitionReader

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;
        }

这里如果Resource为空，则停止BeanDefinition的载入。在启动BeanDefinition的过程中，会遍历整个Resource集合所包含的BeanDefinition的信息。

这里面调用的loadBeanDefinitions()方法具体实现并不在AbstractBeanDefinitionReader，而是在子类里：

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<EncodedResource>(4);
                this.resourcesCurrentlyBeingLoaded.set(currentResources);
            }
            if (!currentResources.add(encodedResource)) {
        
                throw new BeanDefinitionStoreException(
                        "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
            }
            try {
        
                InputStream inputStream = encodedResource.getResource().getInputStream();
                try {
        
                    InputSource inputSource = new InputSource(inputStream);
                    if (encodedResource.getEncoding() != null) {
        
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
                    return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                }
                finally {
        
                    inputStream.close();
                }
            }

在这里可以拿到代表XML文件的Resource，读取器在打开I/O流后就可以得到XML的文件对象，接下来的事情就是按照Spring的Bean定义规则对这个XML文件做解析并封装了。而这个解析的过程是在类BeanDefinitionParserDelegate

在调用doLoadBeanDefinitions过程中，代码会走到类XmlBeanDefinitionReader中的doLoadBeanDefinitions的方法

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
                throws BeanDefinitionStoreException {
        
            try {
        
                int validationMode = getValidationModeForResource(resource);
                Document doc = this.documentLoader.loadDocument(
                        inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
                return registerBeanDefinitions(doc, resource);
            }

这里第5行就是Document对象生成的入口，具体实现在DefaultDocumentLoader中。

第7行就是BeanDefinition解析的入口，我们接着往下走，最终的解析过程在类BeanDefinitionParserDelegate中,源码如下:

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        
            String id = ele.getAttribute(ID_ATTRIBUTE);
            String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    
            List<String> aliases = new ArrayList<String>();
            if (StringUtils.hasLength(nameAttr)) {
        
                String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_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) {
        
                checkNameUniqueness(beanName, aliases, ele);
            }
    
            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);
                            // Register an alias for the plain bean class name, if still possible,
                            // if the generator returned the class name plus a suffix.
                            // This is expected for Spring 1.2/2.0 backwards compatibility.
                            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);
                return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
            }
    
            return null;
        }

其中 第24行会触发对Bean元素的详细解析，解析完成后会返回一个AbstractBeanDefinition对象，可以看下这个对象的属性，基本上都是Spring配置文件中的常用属性  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70 2]  
解析方法的具体内容如下：

public AbstractBeanDefinition parseBeanDefinitionElement(
                Element ele, String beanName, BeanDefinition containingBean) {
        
    
            this.parseState.push(new BeanEntry(beanName));
    
            String className = null;
            if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        
                className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
            }
    
            try {
        
                String parent = null;
                if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        
                    parent = ele.getAttribute(PARENT_ATTRIBUTE);
                }
                AbstractBeanDefinition bd = createBeanDefinition(className, parent);
    
                parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
                bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
    
                parseMetaElements(ele, bd);
                parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
                parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    
                parseConstructorArgElements(ele, bd);
                parsePropertyElements(ele, bd);
                parseQualifierElements(ele, bd);
    
                bd.setResource(this.readerContext.getResource());
                bd.setSource(extractSource(ele));
    
                return bd;
            }

其中第18行-27行，都是对Spring配置文件中不同节点的解析，可以每个都深入去研究下。最终返回一个AbstractBeanDefinition对象。

到这里，XML文件中定义的BeanDefinition就被整个载入到IOC容器中，建立了对应的数据结构，可以看成是POJO在容器中的抽象。但是这个时候容器中还只是有一些静态的配置信息，完成了管理Bean对象的数据准备工作，但是容器还没有完全发挥作用。

### 3，BeanDefinition注册过程 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70 3]  
这个源码中方法调用过程比较简单，我们直接来看注册的核心代码：

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);
                }
            }
    
            synchronized (this.beanDefinitionMap) {
        
                Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
                if (oldBeanDefinition != null) {
        
                    if (!this.allowBeanDefinitionOverriding) {
        
                        throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                                "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                                "': There is already [" + oldBeanDefinition + "] bound.");
                    }
                    else {
        
                        if (this.logger.isInfoEnabled()) {
        
                            this.logger.info("Overriding bean definition for bean '" + beanName +
                                    "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
                        }
                    }
                }
                else {
        
                    this.beanDefinitionNames.add(beanName);
                    this.frozenBeanDefinitionNames = null;
                }
                this.beanDefinitionMap.put(beanName, beanDefinition);
    
                resetBeanDefinition(beanName);
            }
        }

最关键的一步就是第36行，**所谓的注册就是将解析得到的BeanDefinition设置到hashMap中去**。至此就完成了整个IOC容器初始化的工作，这样一来就可以在beanDefinition里检索和使用已经配置好的Bean了。ICO容器的作用就是维护和处理里面的Bean。

最后，我们来回答下这个问题，spring 容器中bean是什么时候被初始化的？

通过前面的分析，我们知道bean的实例化是伴随着容器的初始化而同时进行的（但是也有特例），并且默认情况下是单例的

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70]: /images/20230528/33704c4faaa34a698b3545e0fc7a3b8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70 1]: /images/20230528/6c072a282080418ca96e93c9e3537f16.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70 2]: /images/20230528/10c0d121f84540d7b6d9ae5312362e53.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NTEzNDMw_size_16_color_FFFFFF_t_70 3]: /images/20230528/a2eba689d8cc4b65a2e5a0f66c5f4b48.png