《spring源码深度解析》spring BeanDefinition解析（XmlBeanDefinitionReader）

———— 5.1.3.RELEASE
words: 7.7k    views:    time: 40min
spring源码深度解析
IOC

spring从xml中解析及注册BeanDefinition的过程主要由XmlBeanDefinitionReader主导，其相当于一个组织者的角色，将解析的工作委托给BeanDefinitionDocumentReader，注册工作则分配给BeanDefinitionRegistry。

在真正开始BeanDefinition解析前，它将自己以及Resource，ReaderEventListener等接口打包成XmlReaderContext，然后交给BeanDefinitionDocumentReader，以便在解析过程中可以回调ReaderEventListener中的事件接口。

在完成BeanDefinition解析时，会调用BeanDefinitionRegistry进行注册，实际上当所有BeanDefinition注册完成时，它的使命也就结束了，剩下事情的就交给BeanFactory了。

根据上面的理解，我们大概可以画出它们之间的UML关系：


示例

:pom.xml
1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>
:bean.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?xml version="1.0" encoding="UTF-8"?>
<!-- xmlns 声明xml文件默认的命名空间，表示未使用其他命名空间的所有标签的默认命名空间 -->
<!-- xmlns:xsi 声明XML Schema实例，声明后就可以使用schemaLocation属性 -->
<!-- xsi:schemaLocation 指定xsd文件位置，有两个值：分别表示使用的命名空间；和命名空间使用的xsd位置。 -->
<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="testField" class="test.test.TestField">
        <constructor-arg name="id" value="test-id" />
        <meta key="meta2" value="testMeta2" />
    </bean>

    <bean id="testBean" class="test.test.TestBean">
        <property name="field" ref="testField" />
        <meta key="meta1" value="testMeta1" />
        <replaced-method name="show" replacer="replacedMethodTest"/> 
    </bean>

    <bean id="lookupTest" class="test.test.LookupTest">
        <lookup-method name="getBean" bean="testBean" />
    </bean>
	
    <bean id="replacedMethodTest" class="test.test.ReplacedMethodTest" />
</beans>
:TestBean.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class TestBean {

    private TestField field;

    public TestField getField() {
        return field;
    }

    public void setField(TestField field) {
        this.field = field;
    }
	
    public String show(){
        return field.getId();
    }
}
:TestField.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class TestField {
	
    private String id;
	
    public TestField(String id){
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}
:LookupTest.java
1
2
3
4
5
6
7
8
public abstract class LookupTest {

    public abstract TestBean getBean();
	
    public TestField getField(){
        return getBean().getField();
    }
}
:ReplacedMethodTest.java
1
2
3
4
5
6
7
public class ReplacedMethodTest implements MethodReplacer {

    @Override
    public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
        return "replaced-id";
    }
}
:APP.java mark:38
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public static void main( String[] args ){
    //BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("bean.xml")); @Deprecated 
		
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
	
    // ReaderEventListener跟随解析上下文ReaderContext一直伴随着解析过程，
    // 以便在解析过程中可以在一些步骤节点回调ReaderEventListener的接口并，传入必要的信息
    reader.setEventListener(new ReaderEventListener() {
        @Override
        public void defaultsRegistered(DefaultsDefinition defaultsDefinition) {
            // BeanDefinitionParserDelegate.initDefaults 
        }
			
        @Override
        public void importProcessed(ImportDefinition importDefinition) {
            // DefaultBeanDefinitionDocumentReader.importBeanDefinitionResource
        }
			
        @Override
        public void componentRegistered(ComponentDefinition componentDefinition) { 
            // DefaultBeanDefinitionDocumentReader.processBeanDefinition
            // BeanDefinition注册完成时，可以拿到BeanDefinition做一些处理，这里获取了下meta
            BeanDefinition[] bdArray = componentDefinition.getBeanDefinitions();
            for(BeanDefinition bd : bdArray){
                String[] metaArray = bd.attributeNames();
                for(String meta : metaArray){
                    LOG.info("acquire meta：[" + meta + " = " + bd.getAttribute(meta) + "]");
                }
            }
        }
			
        @Override
        public void aliasRegistered(AliasDefinition aliasDefinition) {
            // DefaultBeanDefinitionDocumentReader.processAliasRegistration
        }
    });
    reader.loadBeanDefinitions(new ClassPathResource("bean.xml"));
		
    TestBean testBean = (TestBean)beanFactory.getBean("testBean");
    LOG.info("测试属性注入：" + testBean.getField().getId());
		
    LOG.info("测试replaced-method：" + testBean.show());
		
    LookupTest lookupTest = (LookupTest)beanFactory.getBean("lookupTest");
    LOG.info("测试lookup-method：" + lookupTest.getField().getId());
}

上面演示了spring最基本的用法，也是其最核心的功能，把spring当成bean的工厂以及容器，将bean的创建、装配以及管理工作都通过配置委托给spring。此外，示例中演示了<meta>、<lookup-method>、以及<replaced-method>的用法，是为了方便体现下面代码中的实现。

这里涉及的几个核心接口有：BeanFactory、BeanDefinitionReader、BeanDefinitionRegistry

  • BeanFactory负责管理BeanDefinition，想当于的容器，以便后面进行bean的创建；
  • BeanDefinitionReader负责从资源文件中解析和创建BeanDefinition，相当于解析器；
  • BeanDefinitionRegistry负责将BeanDefinitionReader解析出来的BeanDefinition注册到BeanFactory中，想当于注册器，充当一个中间人的角色，将两边联系在一起。

其中XmlBeanDefinitionReader和DefaultListableBeanFactory为两个最主要的实现，根据具体实现可以画出对应的UML：

UML中的XmlBeanFactory为使用者提供了一站式服务，它将自己声明为BeanFactory，并在自己的构造器中初始化一个默认的XmlBeanDefinitionReader，这样使用者不需要关心解析或注册是谁负责的，只需把资源文件交给工厂，然后就可以直接获取bean。

这样的好处是更加方便了，但代价是失去了一些自定义的能力，因为XmlBeanDefinitionReader的构造被隐藏了。所以设计者将XmlBeanFactory标记成@Deprecated，并解释如下

For advanced needs, consider using a {@link DefaultListableBeanFactory} with an {@link XmlBeanDefinitionReader}. The latter allows
for reading from multiple XML resources and is highly configurable in its actual XML parsing behavior.

下面以示例中的reader.loadBeanDefinitions(new ClassPathResource("bean.xml"))作为入口对解析过程做一些梳理，如果忽略掉一些细节处理，其解析流程可以大体描述如下：

XmlBeanDefinitionReader

对照上面的流程，下面从XmlBeanDefinitionReader开始梳理一遍源码：

1. EncodedResource

XmlBeanDefinitionReader首先将ClassPathResource装饰成EncodedResource，在原来的基础上增加了自定义编码的能力

:org.springframework.beans.factory.xml.XmlBeanDefinitionReader
1
2
3
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    return loadBeanDefinitions(new EncodedResource(resource));
}

spring对其内部使用的资源统一抽象成了Resource，下图列举了一些在spring-core和spring-beans中的实现类：

对于来自File、Classpath或者ByteArray等不同的资源，其都提供了对应的接口将其适配成Resource。比如ClassPathResource，实际上它就是负责将ClassLoader适配成了Resource

:org.springframework.core.io.ClassPathResource
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class ClassPathResource extends AbstractFileResolvingResource {

    private final String path;

    private ClassLoader classLoader;

    private Class<?> clazz;
	
    // ... ...
	
    public InputStream getInputStream() throws IOException {
        InputStream is;
        if (this.clazz != null) {
            is = this.clazz.getResourceAsStream(this.path);
        }else if (this.classLoader != null) {
            is = this.classLoader.getResourceAsStream(this.path);
        }else {
            is = ClassLoader.getSystemResourceAsStream(this.path);
        }if (is == null) {
            throw new FileNotFoundException(getDescription() + " cannot be opened because it does not exist");
        }
        return is;
    }
}

至于EncodedResource，则是一个典型的装饰器，在Resource的基础上添加了自定义编码读取的能力

:org.springframework.core.io.support.EncodedResource
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class EncodedResource implements InputStreamSource {

    private final Resource resource;

    private final String encoding;

    private final Charset charset;
	
    // ... ...
	
    public Reader getReader() throws IOException {
        if (this.charset != null) {
            return new InputStreamReader(this.resource.getInputStream(), this.charset);
        }else if (this.encoding != null) {
            return new InputStreamReader(this.resource.getInputStream(), this.encoding);
        }else {
            return new InputStreamReader(this.resource.getInputStream());
        }
    }
}

2. DocumentLoader

封装成EncodedResource之后，XmlBeanDefinitionReader将其交给DocumentLoader，并委托它解析出一个Document，至于DocumentLoader中的解析则是依赖的标准的javax.xml.parser，这里不再展开

:org.springframework.beans.factory.xml.XmlBeanDefinitionReader mark:26,43,44
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    Assert.notNull(encodedResource, "EncodedResource must not be null");
    if (logger.isTraceEnabled()) {
        logger.trace("Loading XML bean definitions from " + encodedResource);
    }

    // 检测循环import
    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());
            }
            // 根据EncodedResource中的InputStream以及编码，创建InputSource，后续进行xml解析
            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();
        }
    }
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
    try {
        Document doc = doLoadDocument(inputSource, resource); // 解析Document
        int count = registerBeanDefinitions(doc, resource);   // 根据Document解析和注册BeanDefinition
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + count + " bean definitions from " + resource);
        }
        return count;
    }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);
    }
}

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
    return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
            getValidationModeForResource(resource), isNamespaceAware());
}

3. BeanDefinitionDocumentReader

3.1. XmlReaderContext

解析出Document之后，XmlBeanDefinitionReader会创建一个BeanDefinitionDocumentReader实例，用来解析BeanDefinition

:org.springframework.beans.factory.xml.XmlBeanDefinitionReader mark:4
1
2
3
4
5
6
7
8
9
10
11
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;
}

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

并在解析之前，将自己包装成一个XmlReaderContext作为解析过程的上下文参数传给BeanDefinitionDocumentReader，其中包含了一些组件如下：

parseBeanDefinitions

BeanDefinitionDocumentReader也没有自己解析Document，而是又委托给BeanDefinitionParserDelegate，并且将XmlReaderContext交给它，但是解析过程由自己负责调度，并且在解析结束之后由自己调用BeanDefinitionRegistry进行注册，以及回调ReaderEventListener

在拿到Document之后，即遍历其Element，然后根据节点类型解析处理，这里根据NameSpace区分了下标签是默认还是自定义的

:org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader mark:21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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.isDebugEnabled()) {
                        logger.debug("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;
}

// 区分NameSpace进行处理
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);
    }
}
parseDefaultElement

本文先梳理下默认标签的解析，对于自定义标签后面单独再进行说明，至于默认标签的类型则有四种：import、alias、bean、beans

:org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader mark:6,7
1
2
3
4
5
6
7
8
9
10
11
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { // import
        importBeanDefinitionResource(ele);
    }else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { // alias
        processAliasRegistration(ele);
    }else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { // bean
        processBeanDefinition(ele, delegate);
    }else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { //beans
        doRegisterBeanDefinitions(ele);
    }
}
processBeanDefinition

这里先梳理下bean标签的解析过程，至于其它三个标签也都是围绕bean进行的。对于解析的逻辑也比较清晰，首先解析出BeanDefinition，然后进行装饰（就是检查bean中有没有自定义的属性或者子节点需要解析），最后进行注册以及事件回调

:org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
1
2
3
4
5
6
7
8
9
10
11
12
13
14
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  // 1.解析BeanDefinition
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); // 2.对BeanDefinition进行装饰
        try {
            // 3.注册装饰后的BeanDefinition
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex);
        }
        // 4.回调事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

3.2. BeanDefinitionParserDelegate

BeanDefinitionParserDelegate的初始化由DefaultBeanDefinitionDocumentReader负责

:org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
1
2
3
4
5
6
protected BeanDefinitionParserDelegate createDelegate(
            XmlReaderContext readerContext, Element root, @Nullable BeanDefinitionParserDelegate parentDelegate) {
    BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
    delegate.initDefaults(root, parentDelegate);
    return delegate;
}

这里在初始化中有一个事件回调，对应示例中的defaultsRegistered，即在解析开始之前会初始化一些默认配置，如果想进行一些自定义修改，可以在这里进行

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate mark:3
1
2
3
4
public void initDefaults(Element root, @Nullable BeanDefinitionParserDelegate parent) {
    populateDefaults(this.defaults, (parent != null ? parent.defaults : null), root);
    this.readerContext.fireDefaultsRegistered(this.defaults);
}

processBeanDefinition

parseBeanDefinitionElement

初始化之后便进行真正的解析，首先解析出id和name，然后再依次解析各种标签

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate mark:2,3,24,54,72-83
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    String id = ele.getAttribute(ID_ATTRIBUTE); // id
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); // name

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

    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = aliases.remove(0);
        if (logger.isTraceEnabled()) {
            logger.trace("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.isTraceEnabled()) {
                    logger.trace("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;
}

public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {
    this.parseState.push(new BeanEntry(beanName));

    String className = null;
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }
    String parent = null;
    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        parent = ele.getAttribute(PARENT_ATTRIBUTE);
    }

    try {
        AbstractBeanDefinition bd = createBeanDefinition(className, parent); // 创建GenericBeanDefinition
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); // 硬编码解析默认bean的各种属性
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); // 提取description
        parseMetaElements(ele, bd); // 解析元数据
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); // 解析lookup-method属性
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); // 解析replaced-method属性
        parseConstructorArgElements(ele, bd); // 解析构造函数参数
        parsePropertyElements(ele, bd); // 解析property子元素
        parseQualifierElements(ele, bd); // 解析qualifier子元素
        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;
}
createBeanDefinition

在解析各种标签之前首先要创建一个BeanDefinition来承载各种解析的属性，BeanDefinition是一个接口，其主要实现类如下：

通常解析的时候都先使用GenericBeanDefinition作为默认实现

In general, use this {@code GenericBeanDefinition} class for the purpose of registering user-visible bean definitions (which a
post-processor might operate on, potentially even reconfiguring the parent name). Use {@code RootBeanDefinition} / {@code
ChildBeanDefinition} where parent/child relationships happen to be pre-determined.

对于大部分的属性，基本都定义在AbstractBeanDefinition中

:org.springframework.beans.factory.support.AbstractBeanDefinition
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable {
    
    // bean的作用范围
    private String scope = SCOPE_DEFAULT;

    // 是否抽象，对应属性abstract
    private boolean abstractFlag = false;

    // 是否延迟加载，对应属性lazy-init
    private boolean lazyInit = false;

    // 自动注入模式，对于属性autowire
    private int autowireMode = AUTOWIRE_NO;

    // 依赖检查，spring 3.0之后弃用
    private int dependencyCheck = DEPENDENCY_CHECK_NONE;

    // 表示一个bean的实例化依赖另一个bean（先后关系），对应属性depend-on
    private String[] dependsOn;

    // false表示容器在查找自动装配对象时，将忽略该bean
    // 即该bean不会作为候选者装配到其它的bean中，不过自身还是可以装配其它bean的
    private boolean autowireCandidate = true;

    // true表示当自动装配出现多个候选者时，该bean将作为首选者，对应属性primary
    private boolean primary = false;

    // 用于记录Qualifier，对应子元素qualifier
    private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>();

    // 回调方法，替代反射创建实例
    private Supplier<?> instanceSupplier;

    // 默认允许访问非公开的构造器和方法，程序设置
    private boolean nonPublicAccessAllowed = true;

    // 默认以一种宽松的模式解析构造函数（当发生方法重载，并且参数具有父子关系，将难以定位使用哪个方法）
    private boolean lenientConstructorResolution = true;

    // 对应属性：factory-bean
    // <bean id ="instanceFactoryBean" class="test.InstanceFactoryBean"/>
    // <bean id="testBean" factory-bean="instanceFactoryBean" factory-method="creat"/>
    private String factoryBeanName;

    // 对应factory-method
    private String factoryMethodName;

    // 构造器属性注入，对应constructor-arg
    private ConstructorArgumentValues constructorArgumentValues;

    // 普通属性集合
    private MutablePropertyValues propertyValues;

    // 方法重写持有者，记录lookup-method、replaced-method
    private MethodOverrides methodOverrides;

    // 初始化方法，对应init-method
    private String initMethodName;

    // 销毁方法，对应destroy-method
    private String destroyMethodName;

    // 是否执行init-method，程序设置
    private boolean enforceInitMethod = true;

    // 是否执行destroy-method，程序设置
    private boolean enforceDestroyMethod = true;

    //是否用户自定义的而不是程序本身定义的，创建AOP时为true，程序设置
    private boolean synthetic = false;

    // 定义这个bean的应用
    // ROLE_APPLICATION：用户
    // ROLE_INFRASTRUCTURE：完全内部使用，与用户无关
    // ROLE_SUPPORT：默写复杂配置的一部分
    private int role = BeanDefinition.ROLE_APPLICATION;

    // 描述信息
    private String description;

    // 定义这个bean的资源
    private Resource resource;
	
    // ... ...
}
parseBeanDefinitionAttributes

对照上面的属性，依次尝试解析

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

    if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) { // 不再兼容singleton，提示改用scope
        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) { 
        // Take default from containing bean in case of an inner bean definition.
        bd.setScope(containingBean.getScope());
    }

    if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) { // 解析abstract属性
        bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
    }

    String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
    if (DEFAULT_VALUE.equals(lazyInit)) { // 解析lazy-init属性，默认false
        lazyInit = this.defaults.getLazyInit();
    }
    bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

    String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE); //解析autowire属性
    bd.setAutowireMode(getAutowireMode(autowire));

    if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) { // 解析depends-on属性
    String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
        bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
    }

    String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE); // 解析autowire-candidate属性
    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));
    }

    if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) { // 解析primary属性
        bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
    }

    if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) { // 解析init-method属性
        String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
        bd.setInitMethodName(initMethodName);
    }else if (this.defaults.getInitMethod() != null) {
        bd.setInitMethodName(this.defaults.getInitMethod());
        bd.setEnforceInitMethod(false);
    }

    if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) { // 解析destroy-method属性
        String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
        bd.setDestroyMethodName(destroyMethodName);
    }else if (this.defaults.getDestroyMethod() != null) {
        bd.setDestroyMethodName(this.defaults.getDestroyMethod());
        bd.setEnforceDestroyMethod(false);
    }

    if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) { // 解析factory-method属性
        bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
    }
    if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) { //解析factory-bean属性
        bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
    }
    return bd;
}
parseMetaElements

如上面的示例，spring允许配置bean的时候以key-value的形式添加一些自定义属性，并可以自行从BeanDefinition中获取使用

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)) { // 获取当前节点下的所有meta
            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到BeanDefinition中
        }
    }
}
parseLookupOverrideSubElements

某些时候，可能出现应用中实现逻辑不再符合需求的情况，比如示例中的LookupTest.getBean()，这时便需要动态替换

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)) { // lookup-method
            Element ele = (Element) node;
            String methodName = ele.getAttribute(NAME_ATTRIBUTE);
            String beanRef = ele.getAttribute(BEAN_ELEMENT);
            LookupOverride override = new LookupOverride(methodName, beanRef); // 封装成LookupOverride
            override.setSource(extractSource(ele));
            overrides.addOverride(override);
        }
    }
}
parseReplacedMethodSubElement

如上面示例所示，replaced-method不仅可以动态的替换返回实体bean，还可以动态的改变原方法的逻辑，不过他们都是解析成MethodOverride保存到了AbstractBeanDefinition的methodOverrides中

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public void parseReplacedMethodSubElements(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, REPLACED_METHOD_ELEMENT)) { // replaced-method
            Element replacedMethodEle = (Element) node;
            String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE); // 要替换的旧方法
            String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE); // 用来替换的方法
            ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
            // Look for arg-type match elements.
            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);
        }
    }
}
parseConstructorArgElements

其解析步骤也比较清晰，即逐个解析constructor-arg标签，并使用ConstructorArgumentValues.ValueHolder来封装，只是对于是否指定了index属性进行了下区分，如果指定了就保存到indexedArgumentValue中，否则保存到genericArgumentValue中

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate mark:23,35,47,56
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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)) { // constructor-arg
            parseConstructorArgElement((Element) node, bd);
        }
    }
}

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
    String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
    String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    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);
                    if (StringUtils.hasLength(typeAttr)) {
                        valueHolder.setType(typeAttr);
                    }
                    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 {
        try {
            this.parseState.push(new ConstructorArgumentEntry());
            Object value = parsePropertyValue(ele, bd, null);
            ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
            if (StringUtils.hasLength(typeAttr)) {
                valueHolder.setType(typeAttr);
            }
            if (StringUtils.hasLength(nameAttr)) {
                valueHolder.setName(nameAttr);
            }
            valueHolder.setSource(extractSource(ele));
            bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
        }finally {
            this.parseState.pop();
        }
    }
}

对于构造参数的值配置做了如下约束，只能是ref、value、子节点其中的一种情况，如果是ref则使用RuntimeBeanReference封装，如果是value则使用TypedStringValue封装

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate mark:38,39,42,43,46
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
    String elementName = (propertyName != null ?
                            "<property> element for property '" + propertyName + "'" :
                            "<constructor-arg> element");

    // 除了meta和description之外，只允许有一个直属子节点						
    // 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);
        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);
    if ((hasRefAttribute && hasValueAttribute) 
        || ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
            error(elementName +
                    " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
    }

    if (hasRefAttribute) { // ref
        String refName = ele.getAttribute(REF_ATTRIBUTE);
        if (!StringUtils.hasText(refName)) {
            error(elementName + " contains empty 'ref' attribute", ele);
        }
        RuntimeBeanReference ref = new RuntimeBeanReference(refName);
        ref.setSource(extractSource(ele));
        return ref;
    }else if (hasValueAttribute) { // value
        TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
        valueHolder.setSource(extractSource(ele));
        return valueHolder;
    }else if (subElement != null) { // 子节点
        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;
    }
}

如果是子节点的话，则分情况进行讨论

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
    if (!isDefaultNamespace(ele)) {
        return parseNestedCustomElement(ele, bd);
    }else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
        BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
        if (nestedBd != null) {
            nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
        }
        return nestedBd;
    }else if (nodeNameEquals(ele, REF_ELEMENT)) {
        // A generic reference to any name of any bean.
        String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
        boolean toParent = false;
        if (!StringUtils.hasLength(refName)) {
            // A reference to the id of another bean in a parent context.
            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解析
        return parseIdRefElement(ele);
    }else if (nodeNameEquals(ele, VALUE_ELEMENT)) { // value值
        return parseValueElement(ele, defaultValueType);
    }else if (nodeNameEquals(ele, NULL_ELEMENT)) { // null
        // It's a distinguished null value. Let's wrap it in a TypedStringValue
        // object in order to preserve the source location.
        TypedStringValue nullHolder = new TypedStringValue(null);
        nullHolder.setSource(extractSource(ele));
        return nullHolder;
    }else if (nodeNameEquals(ele, ARRAY_ELEMENT)) { // Array
        return parseArrayElement(ele, bd);
    }else if (nodeNameEquals(ele, LIST_ELEMENT)) { // list
        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;
    }
}
parsePropertyElements

对于property属性的解析其实复用了上面的parsePropertyElement，只是解析的结果使用PropertyValue封装，然后记录到了BeanDefinition的propertyValues中

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate mark:23,24,27
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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);
        }
    }
}
	
public void parsePropertyElement(Element ele, BeanDefinition bd) {
    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;
        }
        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();
    }
}
parseQualifierElements

Qualifier用来指定注入Bean的名称，一般在注解中结合Autowire用的比较多，其解析过程也与上面类似，不再赘述

decorateBeanDefinitionIfRequired

接着对前面解析出的BeanDefinition进行装饰，其实就是检查下Bean下面有没有自定义的属性或者子节点，如果有则获取对应的NamespaceHandler做进一步解析

:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate mark:14,22,32
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
    return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
}

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
            Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) {

    BeanDefinitionHolder finalDefinition = definitionHolder;

    // Decorate based on custom attributes first.
    NamedNodeMap attributes = ele.getAttributes();
    for (int i = 0; i < attributes.getLength(); i++) {
        Node node = attributes.item(i);
        finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); // 遍历检查属性
    }

    // Decorate based on custom nested elements.
    NodeList children = ele.getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        Node node = children.item(i);
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); // 遍历检查子节点
        }
    }
    return finalDefinition;
}

public BeanDefinitionHolder decorateIfRequired(
            Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
    String namespaceUri = getNamespaceURI(node);
    if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler != null) {
            BeanDefinitionHolder decorated =
                    handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
            if (decorated != null) {
                return decorated;
            }
        }else if (namespaceUri.startsWith("http://www.springframework.org/")) {
            error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
        }else {
            // A custom namespace, not to be handled by Spring - maybe "xml:...".
            if (logger.isDebugEnabled()) {
                logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
            }
        }
    }
    return originalDef;
}
registerBeanDefinition

在解析结束之后便是进行注册，对于注册则分为两部分

:org.springframework.beans.factory.support.BeanDefinitionReaderUtils mark:5,11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
        }
    }
}
  • 通过beanName注册
:org.springframework.beans.factory.support.DefaultListableBeanFactory mark:2,43
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
// Map of bean definition objects, keyed by bean name
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

// List of bean definition names, in registration order
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

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(); // 主要校验methodOverrides属性
        }catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex);
        }
    }

    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) { // 如果已经注册过且不允许覆盖，则异常
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }else if (existingDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (logger.isInfoEnabled()) {
                logger.info("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        existingDefinition + "] with [" + beanDefinition + "]");
            }
        }else if (!beanDefinition.equals(existingDefinition)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }else {
            if (logger.isTraceEnabled()) {
                logger.trace("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }else {
        if (hasBeanCreationStarted()) { // 工厂是否已经开始创建bean
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) { // 如果是则认为是来自于手动注册，而手动注册行为无法保证，所以需要同步
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions; // 加入beanDefinitionNames，并且用volatile修饰，直接整个替换
                if (this.manualSingletonNames.contains(beanName)) {
                    Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons; // 从manualSingletonNames移除，也是整个替换
                }
            }
        }else { 
            // Still in startup registration phase 否则就还在启动阶段
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName); // 重置beanName对应的缓存
    }
}
  • 通过别名注册
:org.springframework.core.SimpleAliasRegistry mark:2,30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// Map from alias to canonical name
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
	
public void registerAlias(String name, String alias) {
    Assert.hasText(name, "'name' must not be empty");
    Assert.hasText(alias, "'alias' must not be empty");
    synchronized (this.aliasMap) {
        if (alias.equals(name)) {
            this.aliasMap.remove(alias);
            if (logger.isDebugEnabled()) {
                logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
            }
        }else {
            String registeredName = this.aliasMap.get(alias);
            if (registeredName != null) {
                if (registeredName.equals(name)) {
                    // An existing alias - no need to re-register
                    return;
                }
                if (!allowAliasOverriding()) {
                    throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
                                name + "': It is already registered for name '" + registeredName + "'.");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
                                registeredName + "' with new target name '" + name + "'");
                }
            }
            checkForAliasCircle(name, alias); // 当存在A->B时，若再存在A->C->B则抛出异常
            this.aliasMap.put(alias, name);
            if (logger.isTraceEnabled()) {
                logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
            }
        }
    }
}

一般在定义bean的时候其实就可以指定多个name，比如

1
<bean id="testBean1,testBean2" class="test.test.TestBean">

当然也可以使用独立的声明方式

1
<alias name="testBean" alias="testBean1,testBean2"/>

至于其解析也是类似的，就是将别名与beanName组成一对注册到registry中，不再赘述

importBeanDefinitionResource

<import resource=""/>标签是很常用的，其很好的简化了对配置文件的维护，这里简单看一下解析过程

:org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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;
    }

    // Resolve system properties: e.g. "${user.dir}" // 替换环境变量
    location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

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

    // Discover whether the location is an absolute or relative URI
    boolean absoluteLocation = false; // 先尝试绝对路径获取，如果不行再按相对当前文件的地址获取
    try {
        absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
    }catch (URISyntaxException ex) {
        // cannot convert to an URI, considering the location relative
        // unless it is the well-known Spring prefix "classpath*:"
    }

    // Absolute or relative?
    if (absoluteLocation) {
        try {
            int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
            if (logger.isTraceEnabled()) {
                logger.trace("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 {
        // No URL -> considering resource location as relative to the current file.
        try {
            int importCount;
            Resource relativeResource = getReaderContext().getResource().createRelative(location);
            if (relativeResource.exists()) {
                importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
                actualResources.add(relativeResource);
            }else {
                String baseLocation = getReaderContext().getResource().getURL().toString();
                importCount = getReaderContext().getReader().loadBeanDefinitions(
                        StringUtils.applyRelativePath(baseLocation, location), actualResources);
            }
            if (logger.isTraceEnabled()) {
                logger.trace("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[0]);
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

doRegisterBeanDefinitions

嵌套beans标签与单独的配置文件并没有区别，无非是递归调用beans的解析过程，这里不再赘述


参考：

  1. 《spring源码深度解析》 郝佳