Spring IOC初始化3--注册BeanDefinition

Spring IOC 源码分析有三篇
Spring IOC 初始化1–定位
Spring IOC 初始化2–加载BeanDefinition
Spring IOC 初始化3–注册BeanDefinition

基于 Spring 5.2.6.RELEASE
注册Beandefinition

//org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	// BeanDefinitionHolder是对BeanDefinition的封装	下一篇展开
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			//向Spring IOC容器注册Beandefinition
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		//发送一个完成注册的事件
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

注册Beandefinition

//org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition
public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {

	//获取bean的名称
	String beanName = definitionHolder.getBeanName();
	//向IOC容器注册BeanDefinition
	//AbstractBeanDefinitionReader#registry
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

	//注册别名
	//this.aliasMap.put(alias, name);别名，beanName
	//private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}

//ioc容器，beanName，BeanDefinition
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
//DefaultListableBeanFactory#registerBeanDefinition
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");

	//校验BeanDefiniton
	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 existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
		//BeanDefinition不允许重写
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
					"': There is already [" + existingDefinition + "] bound.");
		}
		//旧BeanDefinition的role小于新BeanDefinition的role
		//ROLE_APPLICATION = 0
		//ROLE_SUPPORT = 1
		//ROLE_INFRASTRUCTURE = 2
		else if (existingDefinition.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 [" +
						existingDefinition + "] with [" + beanDefinition + "]");
			}
		}
		//新旧BeanDefinition不相同
		else if (!beanDefinition.equals(existingDefinition)) {
			if (this.logger.isInfoEnabled()) {
				this.logger.info("Overriding bean definition for bean '" + beanName +
						"' with a different definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		else {
			if (this.logger.isDebugEnabled()) {
				this.logger.debug("Overriding bean definition for bean '" + beanName +
						"' with an equivalent definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		//替换BeanDefinition
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	else {//容器中不存在要注册的BeanDefinition
		//如果bean已经创建完成了
		//保存被创建过的beanName
		if (hasBeanCreationStarted()) {
			//加锁	主要是下面的不安全的集合
			synchronized (this.beanDefinitionMap) {
				this.beanDefinitionMap.put(beanName, beanDefinition);
				//向beanDefinitionNames 中添加新注册的beanName
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				removeManualSingletonName(beanName);
			}
		}
		else {
			// bean正在创建
			this.beanDefinitionMap.put(beanName, beanDefinition);
			this.beanDefinitionNames.add(beanName);
			removeManualSingletonName(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

	//检查是否有同名的BeanDefinition已经在IOC容器中注册
	//DefaultSingletonBeanRegistry#singletonObjects	单例bean容器
	if (existingDefinition != null || containsSingleton(beanName)) {
		//重置所有已经注册过的BeanDefinition的缓存
		resetBeanDefinition(beanName);
	}else if (isConfigurationFrozen()) {
        clearByTypeCache();
    }
}

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) {
            if (condition.test(this.manualSingletonNames)) {
                Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                action.accept(updatedSingletons);
                this.manualSingletonNames = updatedSingletons;
            }
        }
    }
    else {
        // Still in startup registration phase
        if (condition.test(this.manualSingletonNames)) {
            action.accept(this.manualSingletonNames);
        }
    }
}

private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);
//org.springframework.beans.factory.support.DefaultListableBeanFactory#resetBeanDefinition
protected void resetBeanDefinition(String beanName) {
	//AbstractBeanFactory#mergedBeanDefinitions
	//移除
	clearMergedBeanDefinition(beanName);

	destroySingleton(beanName);
    
    // Notify all post-processors that the specified bean definition has been reset.
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        if (processor instanceof MergedBeanDefinitionPostProcessor) {
            ((MergedBeanDefinitionPostProcessor) processor).resetBeanDefinition(beanName);
        }
    }

	for (String bdName : this.beanDefinitionNames) {
		if (!beanName.equals(bdName)) {
			BeanDefinition bd = this.beanDefinitionMap.get(bdName);
			if (beanName.equals(bd.getParentName())) {
				resetBeanDefinition(bdName);
			}
		}
	}
}

//org.springframework.beans.factory.support.DefaultListableBeanFactory#destroySingleton
public void destroySingleton(String beanName) {
	super.destroySingleton(beanName);
	this.manualSingletonNames.remove(beanName);
	clearByTypeCache();
}

//DefaultSingletonBeanRegistry#destroySingleton
public void destroySingleton(String beanName) {
	// Remove a registered singleton of the given name, if any.
	removeSingleton(beanName);

	// private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
	// DefaultSingletonBeanRegistry#disposableBeans
	DisposableBean disposableBean;
	synchronized (this.disposableBeans) {
		disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
	}
	destroyBean(beanName, disposableBean);
}

//org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#destroySingleton
protected void removeSingleton(String beanName) {
	synchronized (this.singletonObjects) {
		this.singletonObjects.remove(beanName);
		this.singletonFactories.remove(beanName);
		this.earlySingletonObjects.remove(beanName);
		this.registeredSingletons.remove(beanName);
	}
}

//org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#destroyBean
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
	// Trigger destruction of dependent beans first...
	Set<String> dependencies = this.dependentBeanMap.remove(beanName);
	if (dependencies != null) {
		if (logger.isDebugEnabled()) {
			logger.debug("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
		}
		for (String dependentBeanName : dependencies) {
			destroySingleton(dependentBeanName);
		}
	}

	// Actually destroy the bean now...
	if (bean != null) {
		try {
			bean.destroy();
		}
		catch (Throwable ex) {
			logger.error("Destroy method on bean with name '" + beanName + "' threw an exception", ex);
		}
	}

	// Trigger destruction of contained beans...
	Set<String> containedBeans = this.containedBeanMap.remove(beanName);
	if (containedBeans != null) {
		for (String containedBeanName : containedBeans) {
			destroySingleton(containedBeanName);
		}
	}

	// Remove destroyed bean from other beans' dependencies.
	synchronized (this.dependentBeanMap) {
		for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
			Map.Entry<String, Set<String>> entry = it.next();
			Set<String> dependenciesToClean = entry.getValue();
			dependenciesToClean.remove(beanName);
			if (dependenciesToClean.isEmpty()) {
				it.remove();
			}
		}
	}

	// Remove destroyed bean's prepared dependency information.
	this.dependenciesForBeanMap.remove(beanName);
}

​

private void clearByTypeCache() {
	this.allBeanNamesByType.clear();
	this.singletonBeanNamesByType.clear();
}