spring内幕(五)容器的初始化过程之BeanDefinition的注册
前面找到resource ,然后又解析到BeanDefinition之后，接下来要将BeanDefinition注册到容器中。
注册就比较简单了，其触发地点在DefaultBeanDefinitionDocumentReader的processBeanDefinition中
该方法就是 delegate.parseBeanDefinitionElement(ele)解析元素，
然后BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())注册
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//todo 核心方法parseBeanDefinitionElement delegate的该方法就是解析xml的元素为beanDefinition
//BeanDefinitionHolder是BeanDefinition对象的封装类，封装了BeanDefinition Bean的名字和别名 ，用它完成向IOC容器的注册
//todo 解析xml元素的地方
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
//todo 这里是向IOC容器注册解析得到BeanDefinition的地方
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
//在beanDefinition向IOC容器注册完以后，发送消息
// Send registration event.
//
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
将BeanDefinition注册到容器的过程 是借助BeanDefinitionRegistry来完成的
先从definitionHolder里面取出名字
从definitionHolder里面取出来BeanDefinition
调用registerBeanDefinition方法注册
registry.registerBeanDefinition(beanName,definitionHolder.getBeanDefinition());
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
//先从definitionHolder里面取出名字
String beanName = definitionHolder.getBeanName();
//从definitionHolder里面取出来BeanDefinition
//调用registerBeanDefinition方法注册
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//取出别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
//注册别名
registry.registerAlias(beanName, alias);
}
}
}
注册beanDefinition
这里需要注意的是 BeanDefinitionRegistry接口的实现类
就是DefaultListableBeanFactory 也就是当初创建的Ioc容器本身，该容器实现了BeanDefinitionRegistry的接口，提供了注册的方法registerBeanDefinition。
1.先校验
验证不能将静态工厂方法与方法重写相结合(静态工厂方法必须创建实例)
-
优先尝试从beanDefinitionMap中加载BeanDefinition
检查是否有相同名字的bean存在了，如果有，但是容器设置了不许覆盖，就会抛异常
如果允许 则覆盖掉
//存储到beanDefinitionMap中去 ，key为beanName value为beanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition); -
如果之前没有相同的BeanDefinition存在
判断是否bean已经在创建中
bean已经在创建中(如果bean实例化过一次 就会被记录在alreadyCreated列表中 )
bean如果都在创建过程中了，就需要加锁进行注册，且不能直接去修改启动期间的 beanDefinitionMap 和beanDefinitionNames 以及manualSingletonNames 对象，而是通过整个替换的形式，直接创建新的 然后修改引用。
具体过程如下
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 existingDefinition = this.beanDefinitionMap.get(beanName);
//检查是否有相同名字的bean存在了，如果有，但是容器设置了不许覆盖，就会抛异常
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 + "]");
}
}
//存储到beanDefinitionMap中去 ，key为beanName value为beanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
//如果之前没有相同的BeanDefinition存在
//bean已经在创建中(如果bean实例化过一次 就会被记录在alreadyCreated列表中 )
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
//bean如果都在创建过程中了，就需要加锁进行注册
synchronized (this.beanDefinitionMap) {
//存储到beanDefinitionMap中去 ，key为beanName value为beanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
//刷新beanDefinitionNames
//创建新数组 长度比之前+1
List updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
//合并以前的beanDefinitionNames的内容
updatedDefinitions.addAll(this.beanDefinitionNames);
//新增新的names
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
//如果手动的单例列表里面包含了该beanName(手动单例列表，是维护了一份 直接通过代码set进去的单例对象，比如说 xmlBeanFactory.registerSingleton("demo", new Demo());)
//如果之前已经手动设置过了单例，现在框架又来实例化一次，就会破坏掉单例的性质，因此需要检查
//如果包含 那么就将其从手动单例列表中移除，说明其已经不是手动单例的状态了
if (this.manualSingletonNames.contains(beanName)) {
Set updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
//存储到beanDefinitionMap中去 ，key为beanName value为beanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
//记录所有的BeanName
this.beanDefinitionNames.add(beanName);
//从手动单例列表中移除， 如果该列表中有这个beanName的话，说明其已经不是手动单例的状态了
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
//如果已经存在了一个Definition，那么就将这个以前的bean相关的信息都重置掉 然后销毁这个bean
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
注册别名
如果beanName与别名相同 移除别名
如果不同， 那么尝试从aliasMap缓存中获取别名 ，如果别名已经在缓存中存在，缓存中的beaName和传入的beanName相同，说明明已经注册过了,不做任何操作,不需要再次注册。
否则，如果不同 即同一个别名指向了多个beanName，又不允许覆盖的话， 就抛异常。
最后判断别名是否循环 比如说 别名A是BeanName的别名， BeanName 又是别名A的别名
内部的检查逻辑是检查 给定的名称是否注册了给定的别名
设置别名 key为别名 name是beanName
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)) {
//移除别名
this.aliasMap.remove(alias);
if (logger.isDebugEnabled()) {
logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
}
}
else {
//尝试从aliasMap缓存中获取别名
String registeredName = this.aliasMap.get(alias);
//如果别名已经在缓存中存在
if (registeredName != null) {
//缓存中的beaName和传入的beanName相同,不做任何操作,不需要再次注册
//说明已经注册过了
if (registeredName.equals(name)) {
// An existing alias - no need to re-register
return;
}
//如果不同 即同一个别名指向了多个beanName
//又不允许覆盖的话， 就抛异常
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 + "'");
}
}
//判断别名是否循环 比如说 别名A是BeanName的别名， BeanName 又是别名A的别名
//内部的检查逻辑是检查 给定的名称是否注册了给定的别名
checkForAliasCircle(name, alias);
//设置别名 key为别名 name是beanName
this.aliasMap.put(alias, name);
if (logger.isTraceEnabled()) {
logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
}
}
}
}