Spring源码(二-1)-XML文件的读取-bean标签

• IDEA编译Spring源码
• Spring源码(一)-Bean的定义-BeanDefinition
• Spring源码(二)-XML文件的读取-BeanDefinitionReader

bean标签的解析及注册

上篇博文看到的四个标签中， bean 的解析最为复杂和重要。进入DefaultBeanDefinitionDocumentReader类processBeanDefinition(ele, delegate)函数

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//委托 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement方法进行元素解析，
		//返回 BeanDefinitionHolder对象，这个对象就会包含
		//BeanDefinition,beanName以及aliases
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); >1
		if (bdHolder != null) {
			//当返回的 bdHolder 不为空的情况下，如果存在默认标签的子节点下再有自定义标签，
			// 需要再次对自定义标签进行解析
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				//注册解析得到的BeanDefinition
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); >2
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			//通知相关的监昕器，这个 bean 加载完成了
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}
复制代码

解析 BeanDefinition

首先进入delegate.parseBeanDefinitionElement(ele);函数

@Nullable
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		//解析id属性
		String id = ele.getAttribute(ID_ATTRIBUTE);
		//解析name属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<>();
		// 将bean元素的name放入别名数组中,spring支持两种方式定义别名，
		// 一种是通过<alias>,另一种是<bean name=""/>
		if (StringUtils.hasLength(nameAttr)) {
			//分割nameAttr
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		String beanName = id;
        // 如果beanName为空 并且别名集合不为空，将第一个别名作为beanName
		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");
			}
		}
         // 内部Bean为空时
		// 什么情况下不为空呢？也就是有内部类时
		/**
		 * <bean  class="com.gongj.bean.User" name="user2,use" id="user">
		 * 		<property name="vip">
		 * 			<bean id="inner" class="com.gongj.bean.User$Vip">
		 * 				<constructor-arg ref="user"/>
		 * 				<property name="vipLevel" value="9"/>
		 * 			</bean>
		 * 		</property>
		 * 	</bean>
		 *
		 */
		if (containingBean == null) {
			//验证指定的bean名称(也就是id属性)和别名是否已经存在
			checkNameUniqueness(beanName, aliases, ele);
		}
		// 对bean标签的其他属性进行解析，并封装在 GenericBeanDefinition 类型的实例中 
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); >1
		if (beanDefinition != null) {
          //如果不存在 beanName
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						//那么根据 BeanDefinitionReaderUtils 提供的命名规则为当前 bean 生成对应的beanName
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
                // 根据 XmlReaderContext 生成对应的beanName
                        //类似于 com.gongj.bean.User#0
						beanName = this.readerContext.generateBeanName(beanDefinition);	
                      // 类似于：com.gongj.bean.User
						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);
			//将获取到的信息封装到 BeanDefinitionHolder 实例中
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}
复制代码

进入标记点 >1，parseBeanDefinitionElement(ele, beanName, containingBean)函数，对标签其他属性的解析过程。

@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 {
			//将class与parentName作为参数，创建一个 GenericBeanDefinition 实例
			AbstractBeanDefinition bd = createBeanDefinition(className, parent); >1
			//解析默认 bean 标签的各种属性,通过set方法进行属性赋值
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); >2
			//提取description
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

			// 解析meta元数据
			parseMetaElements(ele, bd);
			//解析lookup-method属性
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			//解析replaced-method属性
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			//解析构造函数参数
			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;
	}
复制代码

进入createBeanDefinition(className, parent)函数

	protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
			throws ClassNotFoundException {

		return BeanDefinitionReaderUtils.createBeanDefinition(
				parentName, className, this.readerContext.getBeanClassLoader());
	}
复制代码

然后再调试进入createBeanDefinition( parentName, className, this.readerContext.getBeanClassLoader())函数

	public static AbstractBeanDefinition createBeanDefinition(
			@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();
		//parentName可能为空
		bd.setParentName(parentName);
		if (className != null) {
			if (classLoader != null) {
				//如果 classLoader 不为空， 则使用传入的 classLoader 加载类对象，否则只是
				//记录className
				bd.setBeanClass(ClassUtils.forName(className, classLoader));
			}
			else {
				bd.setBeanClassName(className);
			}
		}
		return bd;
	}
复制代码

联系之前博文：Spring源码(一)-Bean的定义-BeanDefinition，可以进行考证，如果是 xml 配置，会解析所有属性并统一封装至 GenericBeanDefinition 类型的实例中，之后再逐渐解析。

然后再看一下 标记点 2 那个函数 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); 解析默认 bean 标签的各种属性。

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {

		//解析 singleton 属性
		if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
			//'singleton'属性升级到'scope'声明
			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));
		}
		//当当前Bean没有明确使用 scope 属性时,且当前Bean被解析为是内部bean的话，
		//则默认使用外部Bean的作用域作为当前bean的作用域
		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 (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		// 若没有设置或设置为其他字符都会被设置为false
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		//解析 autowire 属性
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));
		//解析 depends-on 属性
		if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
			String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
			bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
		}
		//解析 autowire-candidate 属性
		String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
		if (isDefaultValue(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;
	}
复制代码

每个属性的作用可以看笔者的之前源码：Spring源码(一)-Bean的定义-BeanDefinition

注册BeanDefinition

到这里Spring已经将 xml 中的配置信息封装至BeanDefinitionHolder对象，接下来就可以执行对 BeanDefinition 的注册了，一起继续向下吧。调试进入 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())函数

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		// 注册bean定义
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); >1

		// Register aliases for bean name, if any.
		// 注册bean名称的别名(如果有的话)
		String[] aliases = definitionHolder.getAliases(); 
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias); >2
			}
		}
	}
复制代码

从上面的代码可以看出 ，解析的 BeanDefinition 都会被注册到 BeanDefinitionRegistry 类型的实例中， 对于 BeanDefinition 的注册分成了两部分：通过 beanName 的注册以及通过别名的注册。

通过beanName注册

首先进入registry.registerBeanDefinition(beanName,definitionHolder.getBeanDefinition())函数，进入该函数会进入到 BeanDefinitionRegistry接口，该接口下有三个子类，我们选择进入默认使用的DefaultListableBeanFactory子类

@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 中的 methodOverrides 属性校验，
				* 校验 methodOverrides 是否与工厂方法并存或者 methodOverrides 对应的方法根本不存在
				*/
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}
		// beanDefinitionMap: bean定义对象的映射 key为beanName
		// 根据beanName获取BeanDefinition
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		//处理已经注册的 Bean 情况
		if (existingDefinition != null) {
			//如果对应的 Bean 已经注册且在配置中配置了 bean 不允许被覆盖，
			//则抛出异常,默认是 true，也就是允许覆盖
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			// getRole方法可以去看上篇 BeanDefinition
        // 使用新的BeanDefinition覆盖已经加载的BeanDefinition
			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 + "]");
				}
			}
			//注册 BeanDefinition,加入 beanDefinitionMap 缓存。
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		//处理未注册的情况
		else {
			// 如果beanDefinition已经被标记为创建(为了解决单例bean的循环依赖问题)
			if (hasBeanCreationStarted()) { 
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					//注册 BeanDefinition
					this.beanDefinitionMap.put(beanName, beanDefinition);
					// 创建List<String>并将缓存的beanDefinitionNames和新的beanName加入集合
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName); >1
				}
			}
			else {
				// Still in startup registration phase
				// 仍处于启动注册阶段
				this.beanDefinitionMap.put(beanName, beanDefinition);
				//维护了beanName集合
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName); >1
			}
			this.frozenBeanDefinitionNames = null;
		}
		// 当前注册的bean的定义已经在beanDefinitionMap缓存中存在，
		// 或者其实例已经存在于单例bean的缓存中(singletonObjects)，就进行重置当前Bean的BeanDefinition
		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}

    protected boolean hasBeanCreationStarted() {
		return !this.alreadyCreated.isEmpty();
	}
复制代码

我们看一下removeManualSingletonName(beanName)这个函数，这个函数使用了 java8 的函数式接口。

private void removeManualSingletonName(String beanName) {
		updateManualSingletonNames(set -> set.remove(beanName), set -> set.contains(beanName));
	}

	private void updateManualSingletonNames(Consumer<Set<String>> action, Predicate<Set<String>> condition) {
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			synchronized (this.beanDefinitionMap) {
				//如果manualSingletonNames中包含新注册的beanName
              //对应 set -> set.contains(beanName)
				if (condition.test(this.manualSingletonNames)) {
					// 创建set集合并将manualSingletonNames加入到新创建的set集合
					Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
					//然后移除新注册的beanName
                  //对应set.remove(beanName)
					action.accept(updatedSingletons);
					this.manualSingletonNames = updatedSingletons;
				}
			}
		}
		else {
			// Still in startup registration phase
			if (condition.test(this.manualSingletonNames)) {
				action.accept(this.manualSingletonNames);
			}
		}
	}
复制代码

第一个函数表达式入参为一个 Consumer 消费型接口，代表接受一个输入参数并且无返回的操作
第二个函数表达式入参为一个 Predicate 断言形接口，接受一个输入参数，返回一个布尔值结果。

接下来就看看上面代码所用的数据存储容器：

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

复制代码

• beanDefinitionMap：bean定义对象的映射，key为beanName，value为BeanDefinition
• beanDefinitionNames ：beanName列表
• alreadyCreated ：存储至少创建了一次的bean的名称
• manualSingletonNames：这个Set集合的作用还不是太清楚。源码注释翻译出来：手动注册的单例的名字列表

通过别名注册

进入registry.registerAlias(beanName, alias)函数，会跳转到 AliasRegistry接口，该接口下有两个实现类 GenericApplicationContext和SimpleAliasRegistry，我们选择SimpleAliasRegistry

@Override
	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) {
			//别名与beanName相同
			if (alias.equals(name)) {
				//将该别名从Map中移除
				this.aliasMap.remove(alias);
				if (logger.isDebugEnabled()) {
					logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
				}
			}
			//别名与beanName不相同
			else {
				// 根据传入的别名获取beanName
				String registeredName = this.aliasMap.get(alias);
				if (registeredName != null) {
					//已经注册的名称与当前需要注册的beanName相等
					/*
					<alias name="user" alias="user2"></alias>
					<alias name="user" alias="user2"></alias>
					 */
					if (registeredName.equals(name)) {
						// An existing alias - no need to re-register
						//已存在的别名-不需要重新注册
						return;
					}
					//如果 alias 不允许被覆盖则抛出异常，默认是true，允许被覆盖
					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 + "'");
					}
				}
				// 检查给定的名称（user2）是否指向给定的别名（user）作为别名（user2）
				/*
				2、<alias name="user" alias="user2"></alias>
				1、<alias name="user2" alias="user"></alias>
				 */
				checkForAliasCircle(name, alias);
				//缓存别名
				this.aliasMap.put(alias, name);
				if (logger.isTraceEnabled()) {
					logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
				}
			}
		}
	}
复制代码