学习Spring源码（四）Spring Bean注册解析

心已赠人 2022-03-19 06:18 371阅读 0赞

Spring是通过IoC容器对Bean进行管理的，而Bean的初始化主要分为两个过程：Bean的注册和Bean实例化。Bean的注册主要是指Spring通过读取配置文件获取各个bean的声明信息，并且对这些信息进行注册的过程。Bean的实例化则指的是Spring通过Bean的注册信息对各个Bean进行实例化的过程。本文主要讲解Spring是如何注册Bean，并且为后续的Bean实例化做准备的。

Spring提供了BeanFactory对Bean进行获取，但Bean的注册和管理并不是在BeanFactory中进行的，而是在BeanDefinitionRegistry中进行的，这里BeanFactory只是提供了一个查阅的功能。如果把整个IoC容器比作一个图书馆的话，BeanFactory只是提供给学生查阅书籍的管理员，而BeanDefinitionRegistry则是注册所有图书信息的图书管理软件。Spring的Bean信息是注册在一个个BeanDefinitioin中的，其就相当于一本本的图书，在图书管理软件中是注册备案了的。如下是IoC容器对Bean注册进行管理的类结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70][]  
1. bean声明示例

首先我们看下如下利用配置文件声明一个Bean，并且通过ClassPathXmlApplicationContext读取该Bean的过程：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        
        <bean id="mockBO" class="MockBusinessObject"/>
    </beans>

通过上述方式，我们就创建了一个MockBusinessObject的实例，通过如下代码我们即可获取该实例，并且使用该实例完成我们所需要的工作：

public class TestBeanApp {
      public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        MockBusinessObject business = context.getBean(MockBusinessObject.class);
        System.out.println(business);
      }
    }

这里我们选用的IoC容器是ClassPathXmlApplicationContext

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 1][]

ClassPathXmlApplicationContext加载时序图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 2][]

Spring有两种类型的Bean工厂：ApplicationContext和BeanFactory。这里ApplicationContext是继承自BeanFactory的，因而其具有BeanFactory的全部功能。ApplicationContext和BeanFactory的主要区别有两点：

1.  ApplicationContext在注册Bean之后还会立即初始化各个Bean的实例，BeanFactory只有在调用getBean()方法时才会开始实例化各个Bean；
2.  ApplicationContext会自动检测配置文件中声明的BeanFactoryPostProcessor和BeanPostProcessor等实例，并且在实例化各个Bean的时候会自动调用这些配置文件中声明的辅助bean实例，而BeanFactory必须手动调用其相应的方法才能将声明的辅助Bean添加到IoC容器中。

2. 源码解析

2.1 初始化BeanFactory信息  
       我们这里以ClassPathXmlApplicationContext为例，首先查看在构造该实例时Spring所做的工作：

public ClassPathXmlApplicationContext(
        String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
        throws BeansException {
    
        super(parent);
        setConfigLocations(configLocations); // 设置属性文件路径等
        if (refresh) {
            refresh(); // bean的注册和初始化
        }
    }

通过跟踪其源码，我们最终看到上述代码，setConfigLocations()方法主要是对设置配置文件的路径，并且会对配置文件路径中的占位符使用属性文件中相关的属性进行替换。这里的refresh()方法则主要是进行bean的注册和初始化的，跟踪其代码如下：

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 准备Bean初始化相关的环境信息，其内部提供了一个空实现的initPropertySources()方法用于提供给用户一个更改相关环境信息的机会
            prepareRefresh();
    
            // 创建BeanFactory实例，并且注册xml文件中相关的bean信息
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
            // 注册Aware和Processor实例，并且注册了后续处理请求所需的一些Editor信息
            prepareBeanFactory(beanFactory);
    
            try {
                // 提供的一个空方法，用于供给子类对已经生成的BeanFactory的一些信息进行定制
                postProcessBeanFactory(beanFactory);
    
                // 调用BeanFactoryPostProcessor及其子接口的相关方法，这些接口提供了一个入口，提供给了调用方一个修改已经生成的BeanDefinition的入口
                invokeBeanFactoryPostProcessors(beanFactory);
    
                // 对BeanPostProcessor进行注册
                registerBeanPostProcessors(beanFactory);
    
                // 初始化国际化所需的bean信息
                initMessageSource();
    
                // 初始化事件广播器的bean信息
                initApplicationEventMulticaster();
    
                // 提供的一个空方法，供给子类用于提供自定义的bean信息，或者修改已有的bean信息
                onRefresh();
    
                // 注册事件监听器
                registerListeners();
    
                // 对已经注册的非延迟（配置文件指定）bean的实例化
                finishBeanFactoryInitialization(beanFactory);
    
                // 清除缓存的资源信息，初始化一些声明周期相关的bean，并且发布Context已被初始化的事件
                finishRefresh();
            }
    
            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                                "cancelling refresh attempt: " + ex);
                }
    
                // 发生异常则销毁已经生成的bean
                destroyBeans();
    
                // 重置refresh字段信息
                cancelRefresh(ex);
    
                throw ex;
            }
    
            finally {
                // 初始化一些缓存信息
                resetCommonCaches();
            }
        }
    }

可以看到，refresh()方法主要做了如下几个工作：

*  BeanFactory的初始化，并且加载配置文件中相关bean的信息；
 *  BeanFactoryPostProcessor和BeanPostProcessor和调用；
 *  初始化国际化信息；
 *  注册和调用相关的监听器；
 *  实例化注册的Bean信息；

对于bean所需实例化信息的注册，我们主要关注obtainFreshBeanFactory()方法，逐步跟踪其代码如下：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        refreshBeanFactory(); // 初始化BeanFactory并加载xml文件信息
        // 获取已生成的BeanFactory
        ConfigurableListableBeanFactory beanFactory = getBeanFactory(); 
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

这里我们跟踪refreshBeanFactory()方法如下：

@Override
    protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) { // 如果BeanFactory已经创建则对其进行销毁
            destroyBeans();
            closeBeanFactory();
        }
        try {
            // 创建BeanFactory实例
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId()); // 为当前BeanFactory设置一个标识id
            customizeBeanFactory(beanFactory); // 设置BeanFacotry的定制化属性信息
            loadBeanDefinitions(beanFactory); // 加载xml文件信息
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

可以看到，这里的xml加载主要是在loadBeanDefinitions()方法中，跟踪该方法如下：

@Override
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // 创建一个XmlBeanDefinitionReader用于读取xml文件中的属性
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
        // 设置一些环境变量相关的信息
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
        // 提供的一个可供子类继承的方法，用于定制XmlBeanDefinitionReader相关的信息
        initBeanDefinitionReader(beanDefinitionReader);
        // 加载xml文件中的信息
        loadBeanDefinitions(beanDefinitionReader);
    }

可以看到，这里xml文件中的bean信息，Spring主要是委托给了XmlBeanDefinitionReader来进行。如下是继续跟踪loadBeanDefinitions()方法的代码：

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

@Override
    public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
        Assert.notNull(resources, "Resource array must not be null");
        int counter = 0;
        for (Resource resource : resources) {
            counter += loadBeanDefinitions(resource);
        }
        return counter;
    }

这里XmlBeanDefinitionReader会依次读取所指定的每个配置文件的bean信息，继续跟踪loadBeanDefinitions()如下：

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 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();
            }
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                "IOException parsing XML document from " + encodedResource.getResource(), ex);
        }
        finally {
            currentResources.remove(encodedResource);
            if (currentResources.isEmpty()) {
                this.resourcesCurrentlyBeingLoaded.remove();
            }
        }
    }

上述代码中，主要是将xml文件转换为了一个InputStream，最终通过调用doLoadBeanDefinitions()方法进行bean信息的注册。如下是doLoadBeanDefinitions()方法的实现：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
        throws BeanDefinitionStoreException {
        try {
            Document doc = doLoadDocument(inputSource, resource);
            return registerBeanDefinitions(doc, resource);
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (SAXParseException ex) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(), "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
        }
        catch (SAXException ex) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(), "XML document from " + resource + " is invalid", ex);
        }
        catch (ParserConfigurationException ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "Parser configuration exception parsing XML from " + resource, ex);
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "IOException parsing XML document from " + resource, ex);
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, ex);
        }
    }

上述代码中，首先将资源文件转换为一个Document对象，该对象中保存有各个xml文件中各个节点和子节点的相关信息。通过转换得到的Document对象，通过registerBeanDefinitions()方法完成Bean的注册，如下是registerBeanDefinitions()方法的代码：

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        int countBefore = getRegistry().getBeanDefinitionCount();
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }

如下是BeanDefinitionDocumentReader.registerBeanDefinitions()方法的实现：

@Override
    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();
        doRegisterBeanDefinitions(root);
    }

2.2 解析xml文件  
       这里首先通过Document对象获取到xml文件的根节点信息，然后通过doRegisterBeanDefinitions()方法转换节点的bean信息：

protected void doRegisterBeanDefinitions(Element root) {
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent);
    
        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;
                }
            }
        }
    
        preProcessXml(root);
        parseBeanDefinitions(root, this.delegate);
        postProcessXml(root);
    
        this.delegate = parent;
    }

在doRegisterBeanDefinitions()方法中，其首先获取当前xml文件是否为默认的命名空间，也即是否使用的是Spring的xsd文件声明的bean，如果是的，则获取当前是否有指定profile相关的信息，并且在环境变量中获取当前是哪种profile，与命名空间中指定的profile进行比较，如果profile不匹配，则过滤掉当前的xml文件。  
        下面的preProcessorXml()和postProcessorXml()方法是两个空方法，用于供给子类实现从而对获取到的Document对象进行定制。真正的bean节点的读取在parseBeanDefinitions()方法中：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        if (delegate.isDefaultNamespace(root)) {
            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;
                    if (delegate.isDefaultNamespace(ele)) {
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);
        }
    }

这里在读取bean节点的时候分为了两种情形进行读取：①默认的命名空间，也即Spring所提供的xsd命名空间的bean读取；②自定义的命名空间定义的bean读取。关于自定义命名空间bean的读取我们在后续文章中会进行讲解，本文主要讲解使用Spring默认命名空间所定义的bean的读取。如下是parseDefaultElement()方法的实现：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            importBeanDefinitionResource(ele);
        } else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        } else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
            doRegisterBeanDefinitions(ele);
        }
    }

可以看到，在对xml节点的读取的时候，其分为了四种情形：①读取import节点所指定的xml文件信息；②读取alias节点的信息；③读取bean节点指定的信息；④读取嵌套bean的信息。由于这里对bean节点的解析是较为复杂，并且最为重要的，本文主要对其余三种节点的解析进行讲解，对bean节点的解析将放入下一篇文章进行讲解。  
2.2.1 读取import节点指定的bean信息

protected void importBeanDefinitionResource(Element ele) {
        String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
        if (!StringUtils.hasText(location)) {
            getReaderContext().error("Resource location must not be empty", ele);
            return;
        }
    
        // 处理import节点指定的路径中的属性占位符，将其替换为属性文件中指定属性值
        location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);
    
        Set<Resource> actualResources = new LinkedHashSet<>(4);
    
        // 处理路径信息，判断其为相对路径还是绝对路径
        boolean absoluteLocation = false;
        try {
            absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
        } catch (URISyntaxException ex) {}
    
        if (absoluteLocation) { // 如果是绝对路径，则直接读取该文件
            try {
                // 递归调用loadBeanDefinitions()方法加载import所指定的文件中的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 {
            try {
                int importCount;
                Resource relativeResource = getReaderContext().getResource()
                    .createRelative(location); // 判断是否为相对路径
                // 如果是相对路径，则调用loadBeanDefinitions()方法加载该文件中的bean信息
                if (relativeResource.exists()) {
                    importCount = getReaderContext().getReader()
                        .loadBeanDefinitions(relativeResource);
                    actualResources.add(relativeResource);
                }
                else {
                    // 如果相对路径，也不是绝对路径，则将该路径当做一个外部url进行请求读取
                    String baseLocation = getReaderContext().getResource()
                        .getURL().toString();
                    // 继续调用loadBeanDefinitions()方法读取下载得到的xml文件信息
                    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文件读取完成事件的监听器
        getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
    }

可以看到，对import节点的解析，主要思路还是判断import节点中指定的路径是相对路径还是绝对路径，如果都不是，则将其作为一个外部URL进行读取，最终将读取得到的文件还是使用loadBeanDefinitions()进行递归调用读取该文件中的bean信息。  
2.2.2 读取alias节点指定的信息

protected void processAliasRegistration(Element ele) {
        String name = ele.getAttribute(NAME_ATTRIBUTE); // 获取name属性的值
        String alias = ele.getAttribute(ALIAS_ATTRIBUTE); // 获取alias属性的值
        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;
        }
        if (valid) {
            try {
                // 注册别名信息
                getReaderContext().getRegistry().registerAlias(name, alias);
            }
            catch (Exception ex) {
                getReaderContext().error("Failed to register alias '" + alias +
                                         "' for bean with name '" + name + "'", ele, ex);
            }
            // 激活对alias注册完成进行监听的监听器
            getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
        }
    }

如下是registerAlias()方法的最终实现：

@Override
    public void registerAlias(String name, String alias) {
        Assert.hasText(name, "'name' must not be empty");
        Assert.hasText(alias, "'alias' must not be empty");
        if (alias.equals(name)) {
            this.aliasMap.remove(alias);
        }
        else {
            String registeredName = this.aliasMap.get(alias);
            if (registeredName != null) {
                if (registeredName.equals(name)) {
                    // 如果已注册，则直接返回
                    return;
                }
                if (!allowAliasOverriding()) {
                    throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" + name + "': It is already registered for name '" + registeredName + "'.");
                }
            }
            // 检查是否有循环别名注册
            checkForAliasCircle(name, alias);
            // 将别名作为key，目标bean名称作为值注册到存储别名的Map中
            this.aliasMap.put(alias, name);
        }
    }

可以看到，别名的注册，其实就是将别名作为一个key，将目标bean的名称作为值，存储到一个Map中。这里需要注意的是，目标bean的名称也可能是一个别名。  
2.2.3 读取嵌套beans信息  
       对于嵌套beans的解析，可以看到，其调用的是doRegisterBeanDefinitions()方法，该方法正是前面我们讲解的开始对bean解析的方法，因而这里其实是使用递归对嵌套bean进行解析的。这里需要说明的是，一个xml文件，其根节点其实就是一个beans节点，而嵌套beans节点的节点名也是beans，因而嵌套beans其实也可以理解为一份单独引入的xml文件，因而可以使用递归的方式对其进行读取。

Spring解析四种基本标签的入口，及DefaultBeanDefinitionDocumentReader.parseDefaultElement方法：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            importBeanDefinitionResource(ele);
        }
        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        }
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        }
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
            // recurse
            doRegisterBeanDefinitions(ele);
        }
    }

其余三种标签的解析过程上文已经进行了讲解，这里不再赘述，我们直接进入processBeanDefinition()方法：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        // 对基本的bean标签属性进行解析
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            // 对自定义的属性或者自定义的子节点进行解析，以丰富当前的BeanDefinition
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // 将当前bean注册到BeanDefinitionRegistry中
                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));
        }
    }

在processBeanDefinition()方法中，其主要分为三步：

*  对基本的bean标签属性及子节点进行解析；
 *  将解析得到的BeanDefinitionHolder对象进行修饰，其主要是根据自定义的属性和子标签来进一步丰富当前BeanDefinition的属性；
 *  将BeanDefinition注册到BeanDefinitionRegistry中。       这里需要注意的是BeanDefinitionHolder只是BeanDefinition的一个容器，在BeanDefinitionRegistry中注册的其实是BeanDefinition。

这里我们主要看解析bean基本属性的BeanDefinitionParserDelegate.parseBeanDefinitionElement()方法，关于对BeanDefinition进行修饰的BeanDefinitionParserDelegate.decorateBeanDefinitionIfRequired()，其主要涉及到了自定义标签的使用和解析，这与上文中所讲的自定义标签的解析是一致的，我们将在下一篇文章中进行讲解。如下是parseBeanDefinitionElement()的实现：

@Nullable
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
        // 获取bean标签的id属性值
        String id = ele.getAttribute(ID_ATTRIBUTE);
        // 获取bean标签的name属性值
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    
        // 对name属性值按照逗号和分号进行分割，将分割后的所有name属性值作为当前bean的别名
        List<String> aliases = new ArrayList<>();
        if (StringUtils.hasLength(nameAttr)) {
            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            aliases.addAll(Arrays.asList(nameArr));
        }
    
        // 以id属性的值作为当前bean的默认名称，如果没有id属性，那么将name属性的第一个值作为当前bean的名称
        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");
            }
        }
        // 检查当前bean的名称与已经解析的bean名称是否有相同的，如果有相同的则抛出异常，保证所有不同bean的名称和别名相互之间不相同
    if (containingBean == null) {
            checkNameUniqueness(beanName, aliases, ele);
        }
    
        // 对bean标签中的各个属性以及子标签进行解析
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            // 如果没有指定id或name属性，则为当前bean自动生成名称
            if (!StringUtils.hasText(beanName)) {
                try {
                    // 如果父bean为空，那么按照默认方式生成bean名称
                    if (containingBean != null) {
                        beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                    } else {
                        // 如果父bean不为空，则生成名称时按照一定规则将父bean加入生成的bean名称中
                        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;
                }
            }
            // 将生成的BeanDefinition，beanName和alias封装到BeanDefinitionHolder中
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }
    
        return null;
    }

可以看到parseBeanDefinitionElement()方法首先会获取当前bean的id和name属性值，默认以id属性作为bean的名称，如果没有则将name属性值按照逗号或分号分割，并分割后的第一个值作为bean的名称，其余的值作为别名，如果id和name属性都存在，那么将name属性分割后的所有值都作为别名。这里在处理完id和name属性后，会对生成的bean名称和别名进行检查，以保证所有bean的名称和别名相互之间不能重复。接着通过parseBeanDefinitionElement()方法对bean的其他属性进行解析，从而生成一个BeanDefinition对象。解析完之后会检查如果当前bean还是没有名称，则按照上述的规则为bean生成一个默认名称。我们这里主要看parseBeanDefinitionElement()方法，如下是该方法的源码：

@Nullable
    public AbstractBeanDefinition parseBeanDefinitionElement(
        Element ele, String beanName, @Nullable BeanDefinition containingBean) {
    
        // 将当前bean的名称push到parseState属性中，以标识当前beanName的bean正在被解析
        this.parseState.push(new BeanEntry(beanName));
    
        // 获取class属性的值
        String className = null;
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
        }
        
        // 获取parent属性的值
        String parent = null;
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }
    
        try {
            // 创建一个BeanDefinition的对象
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
    
            // 转换基本的bean属性的值
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
    
            // 转换并封装元节点标签
            parseMetaElements(ele, bd);
            
            // 转换lookup-method子标签，将其封装到MethodOverrides对象中
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            // 转换replaced-method子标签，也将其封装到MethodOverrides对象中
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    
            // 解析并且封装constructor-arg子标签到BeanDefinition中
            parseConstructorArgElements(ele, bd);
            // 解析并且封装property子标签到BeanDefinition中
            parsePropertyElements(ele, bd);
            // 解析并且封装qualifier子标签到BeanDefinition中
            parseQualifierElements(ele, bd);
    
            // 封装一些资源属性
            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;
    }

可以看到，parseBeanDefinitionElement()首先是获取class和parent属性值，并将其封装到BeanDefinition中，然后是解析bean标签的基本属性值，接着是解析bean标签的子标签，如元节点、lookup-method、replaced-method、constructor-arg等。我们首先看parseBeanDefinitionAttributes()方法：

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
            @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
        // 检查当前bean是否有singleton属性，有则提示应该使用scope属性，并抛出异常
        if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
            error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration",
                  ele);
        }
        else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
            // 获取并设置scope属性值
            bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
        }
        else if (containingBean != null) {
            // 没有scope属性值，则将父bean的scope属性设置给当前bean
            bd.setScope(containingBean.getScope());
        }
    
        // 获取并设置abstract属性值
        if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
            bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
        }
    
        // 获取并设置lazy-init属性值，如果当前bean的lazy-init是默认值，
        // 则将beans标签中设置的lazy-init属性值设置给当前bean
        String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
        if (DEFAULT_VALUE.equals(lazyInit)) {
            lazyInit = this.defaults.getLazyInit();
        }
        bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
    
        // 获取并设置autowire属性值
        String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
        bd.setAutowireMode(getAutowireMode(autowire));
    
        // 获取depends-on属性值，并且按照逗号或分号进行分割，然后设置depends-on属性值
        if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
            String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
            bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn,
              MULTI_VALUE_ATTRIBUTE_DELIMITERS));
        }
    
        // 获取并设置autowire-candicate属性值，如果其为空，那么获取当前xml
        // 最外层beans标签设置的autowire-candicate属性值，并将其设置给当前bean
        String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
        if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
            String candidatePattern = this.defaults.getAutowireCandidates();
            if (candidatePattern != null) {
                String[] patterns =
                    StringUtils.commaDelimitedListToStringArray(candidatePattern);
                bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
            }
        }
        else {
            bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
        }
    
        // 获取并设置primary属性值
        if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
            bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
        }
    
        // 获取并设置init-method属性值，如果该属性为空，
        // 则获取当前xml最外层beans标签设置的init-method属性值，并且设置给当前bean
        if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
            String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
            bd.setInitMethodName(initMethodName);
        }
        else if (this.defaults.getInitMethod() != null) {
            bd.setInitMethodName(this.defaults.getInitMethod());
            bd.setEnforceInitMethod(false);
        }
    
        // 获取并设置destroy-method属性的值，如果该属性值为空，
        // 则获取当前xml最外层beans标签设置的destroy-method属性值，并设置给当前bean
        if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
            String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
            bd.setDestroyMethodName(destroyMethodName);
        }
        else if (this.defaults.getDestroyMethod() != null) {
            bd.setDestroyMethodName(this.defaults.getDestroyMethod());
            bd.setEnforceDestroyMethod(false);
        }
    
        // 获取并设置fatory-method属性的值
        if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
            bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
        }
        
        // 获取并设置factory-bean属性的值
        if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
            bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
        }
    
        return bd;
    }

可以看到，parseBeanDefinitionAttributes()方法主要是获取当前bean标签的各个节点的属性值，并且将其设置给当前的BeanDefinition。对于部分属性，如：init-method、autowire等，如果其值为空，则会获取当前xml最外层beans标签对应的属性值，并将其设置给当前bean。接下来我们看parseMetaElements()方法：

public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor
    attributeAccessor) {
        NodeList nl = ele.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
                Element metaElement = (Element) node;
                String key = metaElement.getAttribute(KEY_ATTRIBUTE);
                String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
                BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
                attribute.setSource(extractSource(metaElement));
                attributeAccessor.addMetadataAttribute(attribute);
            }
        }
    }

关于meta子标签，其主要有key和value两个属性值，用于保存一些元数据，以供给后续自定义Spring功能或者在相关的请求中获取使用。这里可以看到，对meta标签的解析也只是将其属性值获取到之后封装到BeanMetadataAttribute对象中，并且添加到BeanMetadataAttributeAccessor中。接着我们看看parseLookupOverrideSubElements()方法：

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
        NodeList nl = beanEle.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
                Element ele = (Element) node;
                String methodName = ele.getAttribute(NAME_ATTRIBUTE);
                String beanRef = ele.getAttribute(BEAN_ELEMENT);
                LookupOverride override = new LookupOverride(methodName, beanRef);
                override.setSource(extractSource(ele));
                overrides.addOverride(override);
            }
        }
    }

可以看到，parseLookupOverrideSubElements()方法首先会获取当前bean标签的所有子标签，然后遍历判断是否有定义lookup-method子标签，如果有定义，则获取其name属性和bean属性的值，并且封装到LookupOverride对象中。这里需要说明下lookup-method方法的作用：如果一个bean A依赖了另一个bean B，但是B并不是单例的，比如是prototype类型的，那么每次获取B的时候都需要在A中通过ApplicationContext获取，这就使得A依赖了本不属于自己的属性ApplicationContext，这里我们可以使用lookup-method标签处理这个问题，该标签name属性指定了获取指定bean的方法名，而bean标签则指定了目标bean的名称，使用方式如下：

这里getB方法是在类A中定义的一个抽象。接下来我们看看parseReplacedMethodSubElements()方法：

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
        NodeList nl = beanEle.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            // 查找replaced-method子标签
            if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
                Element replacedMethodEle = (Element) node;
                // 获取name属性和replacer属性的值
                String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
                String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
                // 将name属性和replacer属性的值封装到ReplaceOverride对象中
                ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
                // 获取并且封装arg-type子标签的属性
                List<Element> argTypeEles =
                    DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);
                for (Element argTypeEle : argTypeEles) {
                    String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);
                    match = (StringUtils.hasText(match) ? match :
                             DomUtils.getTextValue(argTypeEle));
                    if (StringUtils.hasText(match)) {
                        replaceOverride.addTypeIdentifier(match);
                    }
                }
                replaceOverride.setSource(extractSource(replacedMethodEle));
                overrides.addOverride(replaceOverride);
            }
        }
    }

在parseReplacedMethodSubElements()方法中，其首先会遍历bean标签的所有子标签，判断其是否为replaced-method子标签，然后获取该标签的name和replacer属性的值，并且封装到ReplaceOverride对象中，接着解析当前replaced-method标签是否有arg-type子标签，该子标签用于标识当前replaced-method的参数类型，如果有则将其设置到ReplaceOverride中。  
       这里需要说明的是，replaced-method方法主要用于在运行时动态地替换目标方法的。比如类A有一个方法methodA()，但其实现的功能并不能满足要求，那么我们可以声明一个实现了MethodReplacer接口的bean B，并使用replaced-method标签替换bean A的methodA()的执行。replaced-method的具体用法如下：

这里B是一个实现了MethodReplacer接口的类，如：

public class B implements MethodReplacer {
        @Override
        public Object reimplement(Object obj, Method method, Object[] args)  throws Throwable{
            System.out.println("this is method in B.");
        }
    }

这样在调用bean A的methodA时，其实际会被替换为调用B的reimplement()方法。接下来我们看看parseConstructorArgElements()方法：

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
        NodeList nl = beanEle.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
                parseConstructorArgElement((Element) node, bd);
            }
        }
    }

在parseConstructorArgElements()方法中，其只会解析第一个遇到的constructor-arg子标签，具体的解析过程在parseConstructorArgElement()方法，如下是该方法的实现：

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
        // 获取index，type和name属性值
        String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
        String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
        
        // 当有index属性值时的处理方式
        if (StringUtils.hasLength(indexAttr)) {
            try {
                int index = Integer.parseInt(indexAttr);
                if (index < 0) {
                    error("'index' cannot be lower than 0", ele);
                }
                else {
                    try {
                        this.parseState.push(new ConstructorArgumentEntry(index));
                        // 对属性值进行解析
                        Object value = parsePropertyValue(ele, bd, null);
                        ConstructorArgumentValues.ValueHolder valueHolder = new
                            ConstructorArgumentValues.ValueHolder(value);
                        // 封装type属性值
                        if (StringUtils.hasLength(typeAttr)) {
                            valueHolder.setType(typeAttr);
                        }
                        
                        // 封装name属性值
                        if (StringUtils.hasLength(nameAttr)) {
                            valueHolder.setName(nameAttr);
                        }
                        valueHolder.setSource(extractSource(ele));
                        if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)){
                            error("Ambiguous constructor-arg entries for index " + index,ele);
                        }
                        else {
                            bd.getConstructorArgumentValues().addIndexedArgumentValue(index,
                               valueHolder);
                        }
                    }
                    finally {
                        this.parseState.pop();
                    }
                }
            } catch (NumberFormatException ex) {
                error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
            }
        }
        else {  // 当没有index属性值时的处理方式
            try {
                this.parseState.push(new ConstructorArgumentEntry());
                // 对属性值进行解析
                Object value = parsePropertyValue(ele, bd, null);
                // 对解析的属性值进行封装
                ConstructorArgumentValues.ValueHolder valueHolder = new
                    ConstructorArgumentValues.ValueHolder(value);
                // 设置type属性值
                if (StringUtils.hasLength(typeAttr)) {
                    valueHolder.setType(typeAttr);
                }
                
                // 设置name属性值
                if (StringUtils.hasLength(nameAttr)) {
                    valueHolder.setName(nameAttr);
                }
                valueHolder.setSource(extractSource(ele));
                bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
            }
            finally {
                this.parseState.pop();
            }
        }
    }

我们这里主要看下parsePropertyValue()方法的实现：

@Nullable
    public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
        String elementName = (propertyName != null) ?
            "<property> element for property '" + propertyName + "'" :
        "<constructor-arg> element";
    
        // 判断当前标签是否至少有一个非description和meta的子标签，没有则抛出异常
        NodeList nl = ele.getChildNodes();
        Element subElement = null;
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            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;
                }
            }
        }
    
        // 获取ref和value属性的值
        boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
        boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
        // 判断当前标签不能同时设置ref和value属性的值，同时设置了则报错
        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属性值，则对ref属性值进行解析
        if (hasRefAttribute) {
            String refName = ele.getAttribute(REF_ATTRIBUTE);
            if (!StringUtils.hasText(refName)) {
                error(elementName + " contains empty 'ref' attribute", ele);
            }
            // 如果是ref属性值，则将其值封装为RuntimeBeanReference类型的对象
            RuntimeBeanReference ref = new RuntimeBeanReference(refName);
            ref.setSource(extractSource(ele));
            return ref;
        // 如果有value属性值，则对value属性值进行处理
        } else if (hasValueAttribute) {
            // 将value属性值封装到TypedStringValue对象中
            TypedStringValue valueHolder = new
                TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
            valueHolder.setSource(extractSource(ele));
            return valueHolder;
        } else if (subElement != null) {
            // 如果当前标签还有子标签，那么对该子标签进行解析
            return parsePropertySubElement(subElement, bd);
        }
        else {
            // 如果不满足前面任何一个条件，则抛出异常
            error(elementName + " must specify a ref or value", ele);
            return null;
        }
    }

可以看到parsePropertyValue()方法只是对当前标签中存在的属性进行解析，如果该标签还有子标签，则托付给parsePropertySubElement()方法进行解析，如下是该方法的源码：

@Nullable
    public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
        // 如果该子标签使用的自定义的标签名，则使用自定义子标签进行解析
        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;
        }
        else if (nodeNameEquals(ele, REF_ELEMENT)) {
            // 如果当前子标签是ref子标签，则获取其bean属性的值，并且将其封装到RuntimeBeanReference对象中
            String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
            boolean toParent = false;
            if (!StringUtils.hasLength(refName)) {
                refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
                toParent = true;
                if (!StringUtils.hasLength(refName)) {
                    error("'bean' or 'parent' is required for <ref> element", ele);
                    return null;
                }
            }
            if (!StringUtils.hasText(refName)) {
                error("<ref> element contains empty target attribute", ele);
                return null;
            }
            RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
            ref.setSource(extractSource(ele));
            return ref;
        }
        else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
            // 如果当前子标签是idref子标签，则还是将其封装到一个RuntimeBeanReference对象中
            return parseIdRefElement(ele);
        }
        else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
            // 如果当前子标签是value子标签，则将其封装到一个TypedStringValue对象中，
            // 并且会检查其type属性指定的class是否存在
            return parseValueElement(ele, defaultValueType);
        }
        else if (nodeNameEquals(ele, NULL_ELEMENT)) {
            // 如果子标签是一个null子标签，则封装一个包含空属性的TypedStringValue对象
            TypedStringValue nullHolder = new TypedStringValue(null);
            nullHolder.setSource(extractSource(ele));
            return nullHolder;
        }
        else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
            // 如果是array子标签，则对array子标签进行解析
            return parseArrayElement(ele, bd);
        }
        else if (nodeNameEquals(ele, LIST_ELEMENT)) {
            // 如果是list子标签，则对list子标签进行解析
            return parseListElement(ele, bd);
        }
        else if (nodeNameEquals(ele, SET_ELEMENT)) {
            // 如果是set子标签，则对set子标签进行解析
            return parseSetElement(ele, bd);
        }
        else if (nodeNameEquals(ele, MAP_ELEMENT)) {
            // 如果是map子标签，则对map子标签进行解析
            return parseMapElement(ele, bd);
        }
        else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
            // 如果是props子标签，则对props子标签进行解析
            return parsePropsElement(ele);
        }
        else {
            error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
            return null;
        }
    }

如此我们就讲解完了对constructor-arg标签的解析过程。总的来说，constructor-arg标签的解析首先会解析当前标签属性的值，比如index、ref和value等，然后会解析其子标签的值，子标签可能为bean，ref，idref以及一些集合类型的属性，解析完成之后将得到的结果返回。  
       对于parsePropertyElements()方法，其主要是解析property子标签的，property子标签的解析与constructor-arg标签的解析过程非常类似，如果是parsePropertyElements()方法的源码：

public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
        NodeList nl = beanEle.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
                parsePropertyElement((Element) node, bd);
            }
        }
    }

可以看到，parsePropertyElements()方法首先会找到标签名为property的子标签，然后对其进行解析，解析的方法parsePropertyElement()如下：

public void parsePropertyElement(Element ele, BeanDefinition bd) {
        // 获取name属性的值
        String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
        if (!StringUtils.hasLength(propertyName)) {
            error("Tag 'property' must have a 'name' attribute", ele);
            return;
        }
        this.parseState.push(new PropertyEntry(propertyName));
        try {
            if (bd.getPropertyValues().contains(propertyName)) {
                error("Multiple 'property' definitions for property '" + propertyName + "'",
                      ele);
                return;
            }
            // 解析property标签及其子标签的值
            Object val = parsePropertyValue(ele, bd, propertyName);
            PropertyValue pv = new PropertyValue(propertyName, val);
            parseMetaElements(ele, pv);
            pv.setSource(extractSource(ele));
            bd.getPropertyValues().addPropertyValue(pv);
        } finally {
            this.parseState.pop();
        }
    }

有了前面对constructor-arg的解析过程，这里property的解析就比较简单了。parsePropertyElement()方法首先获取name属性的值，然后调用前面讲的parsePropertyValue()方法对property标签的其他属性以及子标签进行解析，最后将解析结果封装到PropertyValue对象中。  
       对于qualifier的解析，如下是parseQualifierElements()方法的源码：

public void parseQualifierElements(Element beanEle, AbstractBeanDefinition bd) {
        NodeList nl = beanEle.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (isCandidateElement(node) && nodeNameEquals(node, QUALIFIER_ELEMENT)) {
                parseQualifierElement((Element) node, bd);
            }
        }
    }

可以看到，该方法主要是获取子标签名为qualifier的标签，具体的解析过程在parseQualifierElement()方法中，如下是该方法的源码：

public void parseQualifierElement(Element ele, AbstractBeanDefinition bd) {
        String typeName = ele.getAttribute(TYPE_ATTRIBUTE);
        if (!StringUtils.hasLength(typeName)) {
            error("Tag 'qualifier' must have a 'type' attribute", ele);
            return;
        }
        this.parseState.push(new QualifierEntry(typeName));
        try {
            AutowireCandidateQualifier qualifier = new AutowireCandidateQualifier(typeName);
            qualifier.setSource(extractSource(ele));
            String value = ele.getAttribute(VALUE_ATTRIBUTE);
            if (StringUtils.hasLength(value)) {
                qualifier.setAttribute(AutowireCandidateQualifier.VALUE_KEY, value);
            }
            NodeList nl = ele.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                if (isCandidateElement(node) && nodeNameEquals(node,
                       QUALIFIER_ATTRIBUTE_ELEMENT)) {
                    Element attributeEle = (Element) node;
                    String attributeName = attributeEle.getAttribute(KEY_ATTRIBUTE);
                    String attributeValue = attributeEle.getAttribute(VALUE_ATTRIBUTE);
                    if (StringUtils.hasLength(attributeName) &&
                        StringUtils.hasLength(attributeValue)) {
                        BeanMetadataAttribute attribute = new
                            BeanMetadataAttribute(attributeName, attributeValue);
                        attribute.setSource(extractSource(attributeEle));
                        qualifier.addMetadataAttribute(attribute);
                    }
                    else {
                        error("Qualifier 'attribute' tag must have a 'name' and 'value'",
                              attributeEle);
                        return;
                    }
                }
            }
            bd.addQualifier(qualifier);
        }
        finally {
            this.parseState.pop();
        }
    }

这里对qualifier标签的解析，首先会获取其type属性的值，然后会获取value属性的值，并且检查当前qualifier标签是否有子标签，如果有子标签，则会解析各个子标签的key和value属性的值，并且将解析的最终结果封装到一个AutowireCandidateQualifier对象中。这里需要说明的是，qualifier标签用于指定当前bean的限定标识符，即另外的bean如果依赖了当前的bean，则可以使用@Qualifier("currentBeanName")来直接引用当前的bean。

如此对bean标签的解析我们就全部讲完了，可以看到，Spring对bean的解析主要是将其封装到BeanDefinition对象中，而bean的实例化则是在后续进行的，BeanDefinition中只是保存了实例化当前bean所需要的必要信息。Spring的这种设计模式也提供给了我们一种定制BeanDefinition的方式。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70]: /images/20220319/913e75cf7adf40ada6c93888d82d8301.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 1]: /images/20220319/008d81c425914d7688b9fe97e6b337cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 2]: /images/20220319/90a7721b77884ca1a66a280f1af6ad8e.png