Spring-源码深入分析(二)

Beandefinition对象已经获取到，我们还需要获取它的依赖属性

1、bean定义的属性都存储在spring-beans.xsd文件里面

然后在自己的xml文件中，引入进来：

1. http://www.springframework.org/schema/beans/spring-beans.xsd
   

2、Beandefinition对象在一个场合可能是结果，在另外的场合可能就变成原因了，由于过程没有完成，所以它是原因。

3、下面的方式是对beanName的生成，如果在bean标签里面不配置id和name的话，依然可以使用属性，因为我们在写注解的时候，很少配置id和name。最后转BeanDefinitionHolder对象，来对BeanDefinition对象的注册的工作的。bean名称，bean定义，bean别名注册。

1.   if (beanDefinition != null) {
   
2.            if (!StringUtils.hasText(beanName)) {
   
3.                try {
   
4.                    if (containingBean != null) {
   
5.                        beanName = BeanDefinitionReaderUtils.generateBeanName(
   
6.                                beanDefinition, this.readerContext.getRegistry(), true);
   
7.                    }
   
8.                    else {
   
9.                        beanName = this.readerContext.generateBeanName(beanDefinition);
   
10.                        // Register an alias for the plain bean class name, if still possible,
    
11.                        // if the generator returned the class name plus a suffix.
    
12.                        // This is expected for Spring 1.2/2.0 backwards compatibility.
    
13.                        String beanClassName = beanDefinition.getBeanClassName();
    
14.                        if (beanClassName != null &&
    
15.                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
    
16.                                !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
    
17.                            aliases.add(beanClassName);
    
18.                        }
    
19.                    }
    
20.                    if (logger.isTraceEnabled()) {
    
21.                        logger.trace("Neither XML 'id' nor 'name' specified - " +
    
22.                                "using generated bean name [" + beanName + "]");
    
23.                    }
    
24.                }
    
25.                catch (Exception ex) {
    
26.                    error(ex.getMessage(), ele);
    
27.                    return null;
    
28.                }
    
29.            }
    
30.            String[] aliasesArray = StringUtils.toStringArray(aliases);
    
31.            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    
32.        }
    

然后是否装饰bean定义：

1.  bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
   

我们看下装饰器如何去装饰的？

1.       public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
   
2.            Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) {
   
3. 
   
4.        BeanDefinitionHolder finalDefinition = definitionHolder;
   
5. 
   
6.        // Decorate based on custom attributes first.
   
7.        NamedNodeMap attributes = ele.getAttributes();
   
8.        for (int i = 0; i < attributes.getLength(); i++) {
   
9.            Node node = attributes.item(i);
   
10.            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
    
11.        }
    
12. 
    
13.        // Decorate based on custom nested elements.
    
14.        NodeList children = ele.getChildNodes();
    
15.        for (int i = 0; i < children.getLength(); i++) {
    
16.            Node node = children.item(i);
    
17.            if (node.getNodeType() == Node.ELEMENT_NODE) {
    
18.                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
    
19.            }
    
20.        }
    
21.        return finalDefinition;
    
22.    }
    
23.      public BeanDefinitionHolder decorateIfRequired(
    
24.            Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
    
25. 
    
26.        String namespaceUri = getNamespaceURI(node);
    
27.        if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
    
28.            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    
29.            if (handler != null) {
    
30.                BeanDefinitionHolder decorated =
    
31.                        handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
    
32.                if (decorated != null) {
    
33.                    return decorated;
    
34.                }
    
35.            }
    
36.            else if (namespaceUri.startsWith("http://www.springframework.org/")) {
    
37.                error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
    
38.            }
    
39.            else {
    
40.                // A custom namespace, not to be handled by Spring - maybe "xml:...".
    
41.                if (logger.isDebugEnabled()) {
    
42.                    logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
    
43.                }
    
44.            }
    
45.        }
    
46.        return originalDef;
    
47.    }
    

上面的方法是找到自定义标签，是一种扩展接口，现在我有这个装饰，没有定义命名空间的话就是刚才默认值，如果要扩展的话，就有一个装饰的接口，就是通过namespaceHandler，通过自定义的标签来装饰BeanDefinitionHolder对象的实现的，就是说可以修改BeanDefinitionHolder它而已。

2、生成BeanDefinitionHolder对象之后，然后进行对BeanDefinitionHolder对象进行注册

1. BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
   

看下如何去注册的？

1.    public static void registerBeanDefinition(
   
2.            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
   
3.            throws BeanDefinitionStoreException {
   
4. 
   
5.        // Register bean definition under primary name.
   
6.        String beanName = definitionHolder.getBeanName();
   
7.        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
   
8. 
   
9.        // Register aliases for bean name, if any.
   
10.        String[] aliases = definitionHolder.getAliases();
    
11.        if (aliases != null) {
    
12.            for (String alias : aliases) {
    
13.                registry.registerAlias(beanName, alias);
    
14.            }
    
15.        }
    
16.    }
    

看下DefaultListableBeanFactory：开始注册bean定义

1.   @Override
   
2.    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
   
3.            throws BeanDefinitionStoreException {
   
4. 
   
5.        Assert.hasText(beanName, "Bean name must not be empty");
   
6.        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
   
7. 
   
8.        if (beanDefinition instanceof AbstractBeanDefinition) {
   
9.            try {
   
10.                ((AbstractBeanDefinition) beanDefinition).validate();
    
11.            }
    
12.            catch (BeanDefinitionValidationException ex) {
    
13.                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    
14.                        "Validation of bean definition failed", ex);
    
15.            }
    
16.        }
    
17. 
    
18.        BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    
19.        if (existingDefinition != null) {
    
20.            if (!isAllowBeanDefinitionOverriding()) {
    
21.                throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
    
22.            }
    
23.            else if (existingDefinition.getRole() < beanDefinition.getRole()) {
    
24.                // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
    
25.                if (logger.isInfoEnabled()) {
    
26.                    logger.info("Overriding user-defined bean definition for bean '" + beanName +
    
27.                            "' with a framework-generated bean definition: replacing [" +
    
28.                            existingDefinition + "] with [" + beanDefinition + "]");
    
29.                }
    
30.            }
    
31.            else if (!beanDefinition.equals(existingDefinition)) {
    
32.                if (logger.isDebugEnabled()) {
    
33.                    logger.debug("Overriding bean definition for bean '" + beanName +
    
34.                            "' with a different definition: replacing [" + existingDefinition +
    
35.                            "] with [" + beanDefinition + "]");
    
36.                }
    
37.            }
    
38.            else {
    
39.                if (logger.isTraceEnabled()) {
    
40.                    logger.trace("Overriding bean definition for bean '" + beanName +
    
41.                            "' with an equivalent definition: replacing [" + existingDefinition +
    
42.                            "] with [" + beanDefinition + "]");
    
43.                }
    
44.            }
    
45.            this.beanDefinitionMap.put(beanName, beanDefinition);
    
46.        }
    
47.        else {
    
48.            if (hasBeanCreationStarted()) {
    
49.                // Cannot modify startup-time collection elements anymore (for stable iteration)
    
50.                synchronized (this.beanDefinitionMap) {
    
51.                    this.beanDefinitionMap.put(beanName, beanDefinition);
    
52.                    List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
    
53.                    updatedDefinitions.addAll(this.beanDefinitionNames);
    
54.                    updatedDefinitions.add(beanName);
    
55.                    this.beanDefinitionNames = updatedDefinitions;
    
56.                    if (this.manualSingletonNames.contains(beanName)) {
    
57.                        Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
    
58.                        updatedSingletons.remove(beanName);
    
59.                        this.manualSingletonNames = updatedSingletons;
    
60.                    }
    
61.                }
    
62.            }
    
63.            else {
    
64.                // Still in startup registration phase
    
65.                this.beanDefinitionMap.put(beanName, beanDefinition);
    
66.                this.beanDefinitionNames.add(beanName);
    
67.                this.manualSingletonNames.remove(beanName);
    
68.            }
    
69.            this.frozenBeanDefinitionNames = null;
    
70.        }
    
71. 
    
72.        if (existingDefinition != null || containsSingleton(beanName)) {
    
73.            resetBeanDefinition(beanName);
    
74.        }
    
75.    }
    
76. BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    
77. private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
    

在上面beanDefinitionMap是一个map，默认的值是256，可以存储256个对象，那么如何去注册的呢？

1、先判断bean定义对象是否允许覆盖，如果允许两个bean定义对象的名称不相同的话，你定义相同的话，就会抛出异常，默认是允许覆盖的，没有相同的话就进行简单的put操作。

然后把beanName也放入到一个集合中manualSingletonNames 单例的

1. else {
   
2.            if (hasBeanCreationStarted()) {
   
3.                // Cannot modify startup-time collection elements anymore (for stable iteration)
   
4.                synchronized (this.beanDefinitionMap) {
   
5.                    this.beanDefinitionMap.put(beanName, beanDefinition);
   
6.                    List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
   
7.                    updatedDefinitions.addAll(this.beanDefinitionNames);
   
8.                    updatedDefinitions.add(beanName);
   
9.                    this.beanDefinitionNames = updatedDefinitions;
   
10.                    if (this.manualSingletonNames.contains(beanName)) {
    
11.                        Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
    
12.                        updatedSingletons.remove(beanName);
    
13.                        this.manualSingletonNames = updatedSingletons;
    
14.                    }
    
15.                }
    
16.            }
    
17. /** List of names of manually registered singletons, in registration order. */
    
18.    private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);
    

进行bean名称的注册，bean定义的注册，然后把之前的beanNname移除掉

1.  this.beanDefinitionMap.put(beanName, beanDefinition);
   
2. this.beanDefinitionNames.add(beanName);
   
3.  this.manualSingletonNames.remove(beanName);(16);
   

这个代表冻结beanName

1. this.frozenBeanDefinitionNames = null;
   

这个代表重置bean定义对象

1. resetBeanDefinition(beanName);
   

BeanDefinition的获取，注册已经完成

然后开始注册别名：循环遍历注册，看下注册在哪里？也是简单的放到aliasMap里面

1. // Register aliases for bean name, if any.
   
2.        String[] aliases = definitionHolder.getAliases();
   
3.        if (aliases != null) {
   
4.            for (String alias : aliases) {
   
5.                registry.registerAlias(beanName, alias);
   
6.            }
   
7.        }
   
8.     @Override
   
9.    //这个方法主要做简单的校验
   
10.    public void registerAlias(String name, String alias) {
    
11.        Assert.hasText(name, "'name' must not be empty");
    
12.        Assert.hasText(alias, "'alias' must not be empty");
    
13.        synchronized (this.aliasMap) {
    
14.            if (alias.equals(name)) {
    
15.                this.aliasMap.remove(alias);
    
16.                if (logger.isDebugEnabled()) {
    
17.                    logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
    
18.                }
    
19.            }
    
20.            else {
    
21.                String registeredName = this.aliasMap.get(alias);
    
22.                if (registeredName != null) {
    
23.                    if (registeredName.equals(name)) {
    
24.                        // An existing alias - no need to re-register
    
25.                        return;
    
26.                    }
    
27.                    if (!allowAliasOverriding()) {
    
28.                        throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
    
29.                                name + "': It is already registered for name '" + registeredName + "'.");
    
30.                    }
    
31.                    if (logger.isDebugEnabled()) {
    
32.                        logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
    
33.                                registeredName + "' with new target name '" + name + "'");
    
34.                    }
    
35.                }
    
36.                checkForAliasCircle(name, alias);
    
37.                this.aliasMap.put(alias, name);
    
38.                if (logger.isTraceEnabled()) {
    
39.                    logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
    
40.                }
    
41.            }
    
42.        }
    
43.    }
    
44.    /** Map from alias to canonical name. */
    
45.    private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
    

为什么分开两个类进行注册呢？肯定是继承了这个功能，这时的BeanDefinition对象已经创建成功，放到了map缓存当中，beanDefinition的阅读，解析，注册

总结：如何从xml文件获取到beandefinition对象

1、beanDefiniitonReader对象读取xml文件，获取document对象

2、从document通过beanDefiniitonPaserDeletar委托解析器解析默认标签和自定义标签成BeanDefinitionHolder(封装beanDefinition,beanName,aliseNames)对象

3、根据beanDefinitionHolder对象通过beanDefinitionRegister接口进行beanDefinition注册到Map集合同时注册别名到Map集合中。