spring源码学习（2）

前面总算是找到了bean的加载与注册的入口了，下面就是应该是真正的操作了吧。

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标签：重点（1）
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
            //beans标签
			doRegisterBeanDefinitions(ele);
		}
}
//自然是从（1）开始入手了
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//里面的东西太多了，先遗留，以后再看，里面是对<bean>的各种解析
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    	//得到<bean>标签里面的内容，scope，class，name，lazy啊这些
        if (bdHolder != null) {
            //判断是否需要装饰：根据<bean>里面有没有自定义标签
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				//注册beanHolder:关键了，上面解析完，自然就是注册了。
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			//注册bean信息之后的监听器处理（spring4.3还没具体实现）
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
}

解析完xml，接下来就是注册了。

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

		//得到id
		String beanName = definitionHolder.getBeanName();
        //继续进入查看
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
        //通过别名注册
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
}
//方法有点长
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
		BeanDefinition oldBeanDefinition;
        //private final Map<String, BeanDefinition> beanDefinitionMap = new     ConcurrentHashMap<String, BeanDefinition>(256);
        //就不会存在并发安全的问题
		oldBeanDefinition = this.beanDefinitionMap.get(beanName);
        //老的beanDefinition是否存在
		if (oldBeanDefinition != null) {
            //如果不允许覆盖的话，那么就会抛错
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
						"': There is already [" + oldBeanDefinition + "] bound.");
			}
			else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (this.logger.isWarnEnabled()) {
					this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							oldBeanDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(oldBeanDefinition)) {
				if (this.logger.isInfoEnabled()) {
					this.logger.info("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (this.logger.isDebugEnabled()) {
					this.logger.debug("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
            //更新Map
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
            //bean的创建是否已经开始
			if (hasBeanCreationStarted()) {
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
			    //放入map
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
                //遗留
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}
        //遗留
		if (oldBeanDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}