Spring容器对默认标签的解析

ゝ一纸荒年。 2023-05-21 10:29 100阅读 0赞

本文主要研究Spring对xml配置文件中标签的解析，源码版本：5.2.2.RELEASE。Spring配置文件中的标签中有默认标签和自定义标签两种，标签的解析是在DefaultBeanDefinitionDocumentReader.parseBeanDefinitions函数中进行的，可以看到默认标签与自定义标签有解析是不同的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70]

## 容器对默认标签的解析 ##

说说对默认标签的解析过程。默认标签的解析是在DefaultBeanDefinitionDocumentReader.parseDefaultElement函数中进行的，分别对4种不同的标签（import,alias,bean和beans）做了不同处理。我们先看下此函数的源码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 1]

### Bean标签的解析及注册 ###

在4中标签中对bean标签的解析最为复杂也最为重要，因为这个标签用得太多了，对beans标签的解析可以看做是循环调用bean标签解析的过程。所以从bean标签开始深入分析，如果能理解bean标签的解析过程，其他默认标签的解析就迎刃而解了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 2]

对于bean标签的解析用的是processBeanDefinition函数，首先看看函数processBeanDefinition(ele,delegate)，其代码如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 3]  
首先BeanDefinitionDelegate这个委托类的parseBeanDefinitionElement方法进行元素的解析，返回BeanDefinitionHolder类型的实例bdHolder，经过这个方法后bdHolder实例已经包含了我们配置文件中的各种属性了，例如class、name、id、alias等。当解析完成后，需要对解析后的bdHolder进行注册，注册过程委托给了BeanDefinitionReaderUtils的registerBeanDefinition方法。最后发出响应事件，通知相关的监听器已经加载完这个Bean了。

查看BeanDefinitionDelegate类的parseBeanDefinitionElement方法源码：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { 
        // 解析 ID 属性
        String id = ele.getAttribute(ID_ATTRIBUTE);
        // 解析 name 属性
        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.isDebugEnabled()) { 
                logger.debug("No XML 'id' specified - using '" + beanName +
                        "' as bean name and " + aliases + " as aliases");
            }
        }
    
        // 检查 name 的唯一性
        if (containingBean == null) { 
            checkNameUniqueness(beanName, aliases, ele);
        }
    
        // 解析其他属性，最终构造的是GenericBeanDefinition类型的实例
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) { 
            // 如果 beanName 不存在，则根据条件构造一个 beanName
            if (!StringUtils.hasText(beanName)) { 
                try { 
                    if (containingBean != null) { 
                        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);
    
            // 封装 BeanDefinitionHolder
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }
    
        return null;
    }

对默认标签解析的全过程了，我们分析下当前层完成的工作：

*  提取元素中的id和name属性
 *  进一步解析其他所有属性并统一封装到GenericBeanDefinition类型的实例中
 *  如果检测到bean没有指定名称，那么为此bean生成beanName
 *  将获取到的信息封装到BeanDefinitionHolder的实例中。

parseBeanDefinitionElement(ele, beanName, containingBean);这个方法会分析bean标签的除id与name外的其他属性，最终生成一个GenericBeanDefinition类型的实例。查看源码：

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 { 
            //创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition实例
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
            //硬编码解析BeanDefinition的各种属性
    		//比如：singleton、scope、abstract、lazy-init、autowire等
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            //设置description属性
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            //解析meta元素
            parseMetaElements(ele, bd);
            //解析lookup-method属性
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            //解析replace-method属性
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
            //解析constructor-arg构造函数属性参数
            parseConstructorArgElements(ele, bd);
            //解析property子元素
            parsePropertyElements(ele, bd);
            //解析qualifier子元素
            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;
    }

这个函数的核心就是创建了一个用于承载属性的AbstractBeanDefinition类型的对象。

### 什么是BeanDefinition ###

在Java中，一切皆对象，对象是类的实体。在JDK中使用java.lang.Class来描述类。在Spring中，存在bean这样一个概念，而Spring使用BeanDefinition来描述bean。BeanDefinition实例的意义与JDK中的Class类实例的意义相近。Bean对象的创建与依赖注入都是依照BeanDefinition来进行初始化、注入等，就好比Bean创建的配方。

BeanDefinition接口是Spring对bean的抽象。BeanDefinitionBuilder是Builder模式的应用。通过这个类我们可以方便的构建BeanDefinition的实例对象。BeanDefinition是配置文件元素标签在容器中的内部表示形式。一个bean标签会拥有class、scope、lazy-init等属性，BeanDefinition则提供了相应的setBeanClassName()、setScope()、setLazyInit()等方法，BeanDefinition接口提供的方法和bean标签中的属性一一对应。其中GenericBeanDefinition类是自2.5版本以后新加入的bean文件配置属性定义类，是一站式服务的。

在配置文件中可以定义父和子，父用RootBeanDefinition表示，而子用ChildBeanDefinition表示，而没有父的就使用RootBeanDefinition表示。AbstractBeanDefinition对两者共同的类信息进行抽象。

Spring通过BeanDefinition将配置文件中的配置信息转换为容器的内部表示，并将这些BeanDefinition注册到BeanDefinitionRegistry中。Spring容器的BeanDefinitionRegistry就像是Spring配置信息的内存数据库，主要是以map的形式保存，后续操作直接从BeanDefinitionResistry中读取配置信息。

因此，要解析属性首先要创建用于承载属性的实例，也就是创建GenericBeanDefinition类型的实例。而代码createBeanDefinition(className,parent)的作用就是实现此功能。  
当创建好了承载bean信息的BeanDefinition实例后，接下来就是解析各种属性了，首先我们看下BeanDefinitionParserDelegate.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd)方法，源码如下：

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
            @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) { 
        //解析singleton属性
        if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) { 
            error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
        }
        //解析scope属性
        else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) { 
            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());
        }
        //解析abstract属性
        if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) { 
    bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
        }
        //解析lazy_init属性
        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));
        //解析dependsOn属性
        if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) { 
            String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
            bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
        }
        //解析autowireCandidate属性
        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属性
        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属性
        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);
        }
        //解析factory_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;
    }

从上面代码我们可以清晰地看到对Bean标签各个属性的解析，这些属性我们在工作中都或多或少用到过。 完成Bean标签基本属性解析后，会依次调用parseMetaElements()、parseLookupOverrideSubElements()、parseReplacedMethodSubElements() 、parseConstructorArgElements()等函数对子元素meta、lookup-method、replace-method、constructor-arg完成解析。各种属性解析的具体代码不再赘述。

### BeanDefinition注册到容器 ###

DefaultBeanDefinitionDocumentReader.parseBeanDefinitions()方法在完成对bean标签的解析，生成BeanDefinitionHolder实例后，下一步就是把bdHolder持有的BeanDefinition对象注册到容器中。

注册执行的具体动作  
BeanDefinitionReaderUtils.registerBeanDefinition -----> DefaultListableBeanFactory.registerBeanDefinition

@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);
    	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 + "]");
    			}
    		}
    		//以beanName为key，注册到beanDefinitionMap中
    		this.beanDefinitionMap.put(beanName, beanDefinition);
    	}
    	else { 
    		//该bean还没注册，检查工厂的bean创建工作是否已经开始
    		if (hasBeanCreationStarted()) { 
    			// this.beanDefinitionNames是一个普通的ArrayList，为了保证beanDefinitionMap与beanDefinitionNames的一致性，加锁
    			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;
    				removeManualSingletonName(beanName);
    			}
    		}
    		else { 
    			// 如果仍然在启动注册阶段，则直接注册
    			// Still in startup registration phase
    			this.beanDefinitionMap.put(beanName, beanDefinition);
    			this.beanDefinitionNames.add(beanName);
    			removeManualSingletonName(beanName);
    		}
    		this.frozenBeanDefinitionNames = null;
    	}
    
    	if (existingDefinition != null || containsSingleton(beanName)) { 
    		resetBeanDefinition(beanName);
    	}
    }

整个过程，所谓的容器注册，就是以 beanName为key， BeanDefinition为value，存放到beanDefinitionMap中，该map的类型是ConcurrentHashMap，已经是线程安全了为什么还加synchronized呢？这是因为beanDefinitionNames是一个普通的ArrayList类型线性表，加锁是要保证对beanDefinitionNames的操作以及对beanDefinitionMap操作的数据一致性。

/** 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);

至此，beanDefinition信息已经注册到Spring容器中（bean定义注册表），接下来就可以被容器使用，都在beanDefinitionMap进行检索，这些信息是容器建立依赖反转的基础。bean定义注册表是Spring容器高层的重要组成部分。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70]: /images/20230521/5a8a4627911740c5822ce2e929155085.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 1]: /images/20230521/d9ebcda7293b4c7d889b315baa39d87c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 2]: /images/20230521/5ae81b74a992414ba901001c8bc153dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 3]: /images/20230521/0734286846684864879ed9b132be168a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 4]: /images/20230521/3f50476447ea4a21b296afcc1358114d.png