上一节分析了Spring解析xml默认命名空间并将解析到的数据封住至BeanDefinitionHolder对象中。接下来就可以执行BeanDefinition的注册了。该过程分为两个部分，注册BeanDefinition和注册aliases（别名）。
1. 引
上一节分析到了processBeanDefinition方法中的第一步，接着往下执行就应该是装饰BeanDefinition对象和执行BeanDefinition注册。
/**
* 解析bean标签将其转换为definition并注册到BeanDefinitionRegistry
* Process the given bean element, parsing the bean definition and registering it with the registry.
*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 1、将解析的节点信息封装至BeanDefinitionHolder对象
// BeanDefinitionHolder-->封装了BeanDefinition,beanName以及aliases
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 2、装饰BeanDefinition
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
// 3、执行注册
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
// 4、发送注册事件
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
1. 注册BeanDefinition步骤简析
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
// Register bean definition under primary name.
// 1、注册BeanDefinition
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
// 2、注册aliases（别名）
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
从代码中可以了解到，该过程一共分为了两个部分
- 1、注册BeanDefinition
- 2、注册aliases（别名）
下面对这两个过程逐一进行分析。
3.注册注册BeanDefinition
注册注册BeanDefinition的工作交给了BeanDefinitionRegistry接口的默认实现DefaultListableBeanFactory。该过程还是比较复杂的。来看代码。。。
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
// 1、如果beanDefinition是AbstractBeanDefinition实例,则验证
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
//验证不能将静态工厂方法与方法重写相结合(静态工厂方法必须创建实例)
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex);
}
}
// 2、优先尝试从缓存中加载BeanDefinition
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
// beanName已经存在且不允许被覆盖，抛出异常
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
// 使用新的BeanDefinition覆盖已经加载的BeanDefinition，if else中只有日志打印，无实质代码，删除为了阅读方便
else if (existingDefinition.getRole() < beanDefinition.getRole()) {}
else if (!beanDefinition.equals(existingDefinition)) {}
else {}
this.beanDefinitionMap.put(beanName, beanDefinition);
}
// 3、缓存中无对应的BeanDefinition，则直接注册
else {
// 如果beanDefinition已经被标记为创建(为了解决单例bean的循环依赖问题)
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
// 加入beanDefinitionMap
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);
// 将updatedDefinitions赋值给beanDefinitionNames
this.beanDefinitionNames = updatedDefinitions;
// 如果manualSingletonNames中包含新注册的beanName
if (this.manualSingletonNames.contains(beanName)) {
// 创建set集合并将manualSingletonNames加入到新创建的set集合
Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
// 移除新注册的beanName
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
//以上操作就是重新创建beanDefinitionNames和manualSingletonNames集合,这段代码我也不是很理解...
}
else {
// 将beanDefinition信息维护至缓存
// beanDefinitionMap-->(key->beanName,value->beanDefinition)
this.beanDefinitionMap.put(beanName, beanDefinition);
// beanDefinitionNames-->维护了beanName集合
this.beanDefinitionNames.add(beanName);
// manualSingletonNames缓存了手动注册的单例bean，所以需要调用一下remove方法，防止beanName重复
// 例如：xmlBeanFactory.registerSingleton("myDog", new Dog());
// 就可以向manualSingletonNames中注册单例bean
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
// 4、重置BeanDefinition，
// 当前注册的bean的定义已经在beanDefinitionMap缓存中存在，
// 或者其实例已经存在于单例bean的缓存中
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
注册流程在代码里已经标注的很清楚了，其中synchronized方法中的代码，分析不是很明确，希望了解的同学可以留言指正。
4.注册别名
// 注册别名
@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)) {
//移除别名
this.aliasMap.remove(alias);
if (logger.isDebugEnabled()) {
logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
}
}
else {
//尝试从缓存中获取别名
String registeredName = this.aliasMap.get(alias);
//如果别名已经在缓存中存在
if (registeredName != null) {
//缓存中的别名和beanName(注意:不是别名)相同,不做任何操作,不需要再次注册
if (registeredName.equals(name)) {
// An existing alias - no need to re-register
return;
}
//缓存中存在别名,且不允许覆盖,抛出异常
if (!allowAliasOverriding()) {
throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
name + "': It is already registered for name '" + registeredName + "'.");
}
}
//检查给定名称是否已指向另一个方向的别名作为别名,预先捕获循环引用并抛出相应的IllegalStateException
checkForAliasCircle(name, alias);
//缓存别名
this.aliasMap.put(alias, name);
}
}
}
5.分析
以上操作已经完成了整个BeanDefinition和别名的注册，加上以前分析的代码我们可以发现一些Spring源码中的书写技巧。
- 方法职责单一，Spring中很少有一个长而复杂的方法，也很少在一个方法里处理多个逻辑，即便有也是将具体的逻辑分支细化，在主方法里调用。
- 处理流程明确简析，Spring中很多方法，例如我们今天分析的BeanDefinition注册，以及接下来要分析的获取bean的过程等，都是先进行合法验证、尝试从缓存中获取、如未能从缓存中获取到才去真正创建对象实例、将新创建的实例加入缓存等等。
以上只是两个小例子，多读代码，多跟踪调试，才是阅读开源代码的途径，随着阅读次数的增加，相信大家会原来越加深对框架的理解，当我们真正能读懂Spring的源码之后，相信大家在看其他的源码，也能触类旁通，成为阅读开源代码的高手。
