（Spring源码分析）默认标签的解析

秒速五厘米 2024-04-18 21:18 82阅读 0赞

在上一节[XmlBeanFactory容器分析][XmlBeanFactory]中，在`parseDefaultElement`方法中是对默认的标签进行解析的

*  ### 默认的标签解析是在`parseDefaultElement`方法进行的 ###

/** * 对四种不同的标签进行处理 * * @param ele * @param delegate */
    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);
        }
    }

**在parseDefaultElement对四种不同的标签进行处理**

*  ### 对bean标签的解析 ###

对bean标签的解析最为复杂也最为重要，理解了bean标签的解析，其他标签解析就很轻松了

/** * 调用decorateBeanDefinitionIfRequired方法解析bean标签并调用registerBeanDefinition方法注册bean */
    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { 
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); // 对Element对象进行解析，返回BeanDefinitionHolder对象，BeanDefinitionHolder对象中已经包含了class、name、id、alias之类的属性
        if (bdHolder != null) { 
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); // 当存在默认标签的子节点下还有自定义属性时，再对其进行解析
            try { 
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); // 将解析后的bdHolder进行注册
            }
            catch (BeanDefinitionStoreException ex) { 
                getReaderContext().error("Failed to register bean definition with name '" +
                                         bdHolder.getBeanName() + "'", ele, ex);
            }
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); // 发出响应事件，通知相关的监听器，这个bean已经加载完成了
        }
    }

**下面主要看一下`parseBeanDefinitionElement()`方法和`registerBeanDefinition()`方法的源码**

*  ### 先来看一下parseBeanDefinitionElement()方法的源码 ###

/** * 在BeanDefinitionParserDelegate类中 */
    @Nullable
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) { 
        return parseBeanDefinitionElement(ele, null);
    }
    
    /** * 解析bean元素标签中各种属性 */
    @Nullable
    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { 
        String id = ele.getAttribute(ID_ATTRIBUTE); // 解析id属性
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); // 解析name属性
    
        // 分割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); // bean的名称默认是为<bean>标签的id，如果alias存在的话就是alias
            if (logger.isDebugEnabled()) { 
                logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases");
            }
        }
    
        if (containingBean == null) { 
            checkNameUniqueness(beanName, aliases, ele);
        }
    
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); // 解析BeanDefinition元素
        if (beanDefinition != null) { 
            if (!StringUtils.hasText(beanName)) { 
                try { 
                    if (containingBean != null) {  // 如果beanName不存在，那么按照Spring提供的命名规则为当前bean生成对应的beanName
                        beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                    }
                    else { 
                        beanName = this.readerContext.generateBeanName(beanDefinition);
                        String beanClassName = beanDefinition.getBeanClassName();
                        if (beanClassName != null &&
                            beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                            !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) { 
                            aliases.add(beanClassName);
                        }
                    }
                    if (logger.isDebugEnabled()) { 
                        logger.debug("Neither XML 'id' nor 'name' specified - " + "using generated bean name [" + beanName + "]");
                    }
                }
                catch (Exception ex) { 
                    error(ex.getMessage(), ele);
                    return null;
                }
            }
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }
        return null;
    }
    
    /** * 解析BeanDefinition元素 */
    @Nullable
    public AbstractBeanDefinition parseBeanDefinitionElement(
        Element ele, String beanName, @Nullable BeanDefinition containingBean) { 
    
        this.parseState.push(new BeanEntry(beanName));
    
        String className = null;
        // 解析class属性
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) { 
            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
        }
        String parent = null;
        // 解析parent属性
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) { 
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }
    
        try { 
            // 创建用于保存bean属性的AbstractBeanDefinition子类GenericBeanDefinition对象
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
    
            // 硬编码解析默认bean的各种属性
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            // 提取description
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            // 解析元数据
            parseMetaElements(ele, bd);
            // 解析lookup-method属性
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            // 解析replaced-method属性
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    
            parseConstructorArgElements(ele, bd);
            parsePropertyElements(ele, bd);
            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()`方法主要是解析Bean标签的属性，然后封装到BeanDefinition类中**

*  ### 再来看一下registerBeanDefinition()方法的源码 ###

/** * 在BeanDefinitionReaderUtils类中 * 将bean的信息和bean的别名注册到BeanDefinitionRegistry中 */
    public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException { 
    
        String beanName = definitionHolder.getBeanName();
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); // 将bean的信息注册到BeanDefinitionRegistry中
    
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) { 
            for (String alias : aliases) { 
                registry.registerAlias(beanName, alias); // 将bean的别名注册到BeanDefinitionRegistry中
            }
        }
    }

**`registerBeanDefinition`主要是将封装好的BeanDefinition对象进行注册**

*  ### 再来看一下registerBeanDefinition()方法的源码 ###

/** * 在DefaultListableBeanFactory类中 * 注册bean到beanDefinitionMap中，beanDefinitionMap是Spring容器实际存储bean的map集合 */
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException { 
    
        Assert.hasText(beanName, "Bean name must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    
        if (beanDefinition instanceof AbstractBeanDefinition) { 
            try { 
                ((AbstractBeanDefinition) beanDefinition).validate();
            }
            catch (BeanDefinitionValidationException ex) { 
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex);
            }
        }
    
        BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName); // 先从beanDefinitionMap中根据beanName获取value值
        if (existingDefinition != null) {  // 当beanDefinitionMap中已经存在该bean
            if (!isAllowBeanDefinitionOverriding()) {  // 不允许覆盖bean时
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + existingDefinition + "] bound.");
            }
            else if (existingDefinition.getRole() < beanDefinition.getRole()) { 
                if (logger.isWarnEnabled()) { 
                    logger.warn("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.isInfoEnabled()) { 
                    logger.info("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
                }
            }
            else { 
                if (logger.isDebugEnabled()) { 
                    logger.debug("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
                }
            }
            this.beanDefinitionMap.put(beanName, beanDefinition); // 当允许覆盖bean时覆盖该bean
        }
        else {  // 当beanDefinitionMap中已经不存在该bean
            if (hasBeanCreationStarted()) { 
                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;
                    if (this.manualSingletonNames.contains(beanName)) { 
                        Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                        updatedSingletons.remove(beanName);
                        this.manualSingletonNames = updatedSingletons;
                    }
                }
            }
            else { 
                this.beanDefinitionMap.put(beanName, beanDefinition);
                this.beanDefinitionNames.add(beanName);
                this.manualSingletonNames.remove(beanName);
            }
            this.frozenBeanDefinitionNames = null;
        }
    
        if (existingDefinition != null || containsSingleton(beanName)) { 
            resetBeanDefinition(beanName);
        }
    }

`registerBeanDefinition`方法主要是具体实现将BeanDefinition注册到beanDefinitionMap，beanDefinitionMap是BeanDefinitionRegistry中的属性，beanDefinitionMap实现是一个ConcurrentHashMap，key为beanName，value为BeanDefinition对象，在Spring容器中，bean属性都储存在beanDefinitionMap中

### 总结 ###

**在默认标签的解析过程中，有三个类或者变量很重要**

*  BeanDefinition

BeanDefinition是一个接口，是元素标签在Spring容器的内部表现形式。在Spring中存在三种实现RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition，均继承了AbstractBeanDefinition抽象类，在元素标签中的class、scope、lazy-init等配置属性，在BeanDefinition提供了相应了beanClass、scope、lazyInit属性。BeanDefinition中的属性是通过集成父类AbstractBeanDefinition中的和配置属性保持一一对应。

private volatile Object beanClass; // 对应class属性
    
    private String scope = SCOPE_DEFAULT; // 对应scope属性
    
    private boolean lazyInit = false; // 对lazy-init属性
    ......

*  BeanDefinitionRegistry

Spring通过BeanDefinition将配置文件中的配置信息转换为容器的内部表示，并将这些BeanDefinition注册到BeanDefinitionRegistry中，Spring容器的BeanDefinitionRegistry就像是Spring配置信息的内存数据库，主要以map的形式保存，从Spring容器中获取bean也是从BeanDefinitionRegistry中获取bean的信息的，对外提供对BeanDefinition的增删改查操作

XmlBeanFactory继承了实现了BeanDefinitionRegistry接口的父类DefaultListableBeanFactory，在接口中定义了对BeanDefinition的增删改查操作

void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException; // 注册BeanDefinition
    
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; // 移除BeanDefinition
    
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; // 获取BeanDefinition
    
    boolean containsBeanDefinition(String beanName); // 判断是否包含BeanDefinition
    
    String[] getBeanDefinitionNames(); // 获取beanName
    
    int getBeanDefinitionCount(); // 获取BeanDefinition总数

*  beanDefinitionMap

beanDefinitionMap是BeanDefinitionRegistry中的属性，beanDefinitionMap实现是一个ConcurrentHashMap，key为beanName，value为BeanDefinition对象，bean属性都储存在beanDefinitionMap中

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

[XmlBeanFactory]: https://blog.csdn.net/qq_35620501/article/details/100747260