上篇已经讲到将资源文件里的标签解析为BeanDefinition对象并封装至BeanDefinitionHolder对象,接下来就是对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) {
//解析Element节点,并将转换信息封装到BeanDefinitionHolder
//BeanDefinitionHolder封装了definition,beanName,以及aliases信息
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
// 执行注册
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
// 发送注册事件
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
通过上面代码可以看到, 通过BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
进行注册,跟踪源码
/**
* 将解析到的bean注册到beanFactory
* @param definitionHolder 封装了definition,beanName,以及aliases信息
* @param registry BeanDefinitionRegistry可以理解为spring内置数据库,通过hashMap维护bean注册信息
* @throws BeanDefinitionStoreException if registration failed
*/
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws
BeanDefinitionStoreException {
// Register bean definition under primary name.
// 获取beanName
String beanName = definitionHolder.getBeanName();
// 执行注册
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
// 注册别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
beanDefinition分为了两个部分, beanName注册和aliases注册
1. beanName注册
@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");
//如果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);
}
}
//尝试从缓存中获取beanDefinition
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
//如果beanDefinition在缓存中已经存在
if (existingDefinition != null) {
// beanDefinition在缓存中已经存在,且不允许被覆盖,
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
//缓存中existingDefinition角色索引值小于beanDefinition角色索引值,则用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 + "]");
}
}
//缓存中的existingDefinition不等于beanDefinition,则用beanDefinition覆盖缓存中的existingDefinition
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
//直接用beanDefinition覆盖缓存中的existingDefinition
else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
//覆盖,这里我们也可以看到spring内部通过Map<String, BeanDefinition>来维护注册的beanDefinition信息
this.beanDefinitionMap.put(beanName, beanDefinition);
}
//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信息维护到缓存中
// Still in startup registration phase
//beanDefinitionMap-->(key->beanName,value->beanDefinition)
this.beanDefinitionMap.put(beanName, beanDefinition);
//beanDefinitionNames-->维护了beanName集合
this.beanDefinitionNames.add(beanName);
//manualSingletonNames维护的是手动注册的bean,所以如果manualSingletonNames缓存已经存在beanName,要将其移除
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
2. aliases别名注册
//获取bean的别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
//循环并注册别名
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
修改xml配置文件,增加别名
<bean id="foo" class="org.springframework.tests.sample.beans.TestBean" p:name="Baz" name="foo,myFoo"/>
再来看别名的注册过程
// 注册别名
@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 + "'.");
}
if (logger.isDebugEnabled()) {
logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
registeredName + "' with new target name '" + name + "'");
}
}
//检查给定名称是否已指向另一个方向的别名作为别名,预先捕获循环引用并抛出相应的IllegalStateException
checkForAliasCircle(name, alias);
//缓存别名
this.aliasMap.put(alias, name);
if (logger.isTraceEnabled()) {
logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
}
}
}
}
分析到这里已经完成了资源文件定位,资源文件解析,注册BeanDefinition,SpringIoC容器的启动工作也就到此结束了,到这里大家可以发现,SpringIoC容器初始化的过程中,并没有发现我们最想看的依赖注入部分,这个操作发生在什么时候呢,就是在我们第一次像IoC容器索取bean的时候,即下面这句代码ITestBean foo = (ITestBean) beanFactory.getBean("foo");
,虽然代码只有一行,但是其复杂度远远超出我们想象,再接下来几篇代码中,我们就会分析IoC容器的依赖注入~