bean标签的解析及注册
上篇博文看到的四个标签中， bean 的解析最为复杂和重要。进入DefaultBeanDefinitionDocumentReader类processBeanDefinition(ele, delegate)函数。
protected void processBeanDefinition(Element ele,
BeanDefinitionParserDelegate delegate) {
//委托 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement
//方法进行元素解析，
//返回 BeanDefinitionHolder对象，这个对象就会包含
//BeanDefinition,beanName以及aliases
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(
ele); > 1
if(bdHolder != null) {
//当返回的 bdHolder 不为空的情况下，如果存在默认标签的子节点下
//再有自定义标签， 需要再次对自定义标签进行解析
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele,
bdHolder);
try {
// Register the final decorated instance.
//注册解析得到的BeanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
getReaderContext().getRegistry()); > 2
}
catch(BeanDefinitionStoreException ex) {
getReaderContext().error(
"Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
//通知相关的监昕器，这个 bean 加载完成了
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(
bdHolder));
}
}解析 BeanDefinition
首先进入delegate.parseBeanDefinitionElement(ele);函数
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @
Nullable BeanDefinition containingBean) {
//解析id属性
String id = ele.getAttribute(ID_ATTRIBUTE);
//解析name属性
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List < String > aliases = new ArrayList < > ();
// 将bean元素的name放入别名数组中,spring支持两种方式定义别名，
// 一种是通过<alias>,另一种是<bean name=""/>
if(StringUtils.hasLength(nameAttr)) {
//分割nameAttr
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr,
MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
// 如果beanName为空 并且别名集合不为空，将第一个别名作为beanName
if(!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
beanName = aliases.remove(0);
if(logger.isTraceEnabled()) {
logger.trace("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
// 内部Bean为空时
// 什么情况下不为空呢？也就是有内部类时
/**
* <bean class="com.gongj.bean.User" name="user2,use" id="user">
* <property name="vip">
* <bean id="inner" class="com.gongj.bean.User$Vip">
* <constructor-arg ref="user"/>
* <property name="vipLevel" value="9"/>
* </bean>
* </property>
* </bean>
*
*/
if(containingBean == null) {
//验证指定的bean名称(也就是id属性)和别名是否已经存在
checkNameUniqueness(beanName, aliases, ele);
}
// 对bean标签的其他属性进行解析，并封装在 GenericBeanDefinition 类型的实例中
AbstractBeanDefinition beanDefinition =
parseBeanDefinitionElement(ele, beanName, containingBean); > 1
if(beanDefinition != null) {
//如果不存在 beanName
if(!StringUtils.hasText(beanName)) {
try {
if(containingBean != null) {
//那么根据 BeanDefinitionReaderUtils 提供的命名规则为当前
//bean 生成对应的beanName
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(),
true);
}
else {
// 根据 XmlReaderContext 生成对应的beanName
//类似于 com.gongj.bean.User#0
beanName = this.readerContext.generateBeanName(
beanDefinition);
// 类似于：com.gongj.bean.User
String beanClassName = beanDefinition.getBeanClassName();
if(beanClassName != null && beanName.startsWith(
beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(
beanClassName)) {
//放入别名集合中
aliases.add(beanClassName);
}
}
if(logger.isTraceEnabled()) {
logger.trace("Neither XML 'id' nor 'name' specified - " +
"using generated bean name [" + beanName + "]");
}
}
catch(Exception ex) {
error(ex.getMessage(), ele);
return null;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
//将获取到的信息封装到 BeanDefinitionHolder 实例中
return new BeanDefinitionHolder(beanDefinition, beanName,
aliasesArray);
}
return null;
}进入标记点 >1，parseBeanDefinitionElement(ele, beanName, containingBean)函数，对标签其他属性的解析过程。
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele,
String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
//class
if(ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
//parent
if(ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
//将class与parentName作为参数，创建一个 GenericBeanDefinition 实例
AbstractBeanDefinition bd = createBeanDefinition(className,
parent); > 1
//解析默认 bean 标签的各种属性,通过set方法进行属性赋值
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); >2
//提取description
bd.setDescription(DomUtils.getChildElementValueByTagName(ele,
DESCRIPTION_ELEMENT));
// 解析meta元数据
parseMetaElements(ele, bd);
//解析lookup-method属性
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//解析replaced-method属性
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//解析构造函数参数
parseConstructorArgElements(ele, bd);
//解析property子元素
parsePropertyElements(ele, bd);
// 解析qualifier子元素
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
catch(ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch(NoClassDefFoundError err) {
error("Class that bean class [" + className +
"] depends on not found", ele, err);
}
catch(Throwable ex) {
error("Unexpected failure during bean definition parsing", ele,
ex);
}
finally {
this.parseState.pop();
}
return null;
}进入createBeanDefinition(className, parent)函数
protected AbstractBeanDefinition createBeanDefinition(@Nullable
String className, @Nullable String parentName)
throws ClassNotFoundException {
return BeanDefinitionReaderUtils.createBeanDefinition(parentName,
className, this.readerContext.getBeanClassLoader());
}然后再调试进入`createBeanDefinition(
parentName, className, this.readerContext.getBeanClassLoader())`函数public static AbstractBeanDefinition createBeanDefinition(@Nullable String parentName,
@Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
GenericBeanDefinition bd = new GenericBeanDefinition();
//parentName可能为空
bd.setParentName(parentName);
if(className != null) {
if(classLoader != null) {
//如果 classLoader 不为空， 则使用传入的 classLoader 加载类对象，否则只是
//记录className
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}联系之前博文：Spring源码(一)-Bean的定义-BeanDefinition，可以进行考证，如果是 xml 配置，会解析所有属性并统一封装至 GenericBeanDefinition 类型的实例中，之后再逐渐解析。
然后再看一下 标记点 2 那个函数 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); 解析默认 bean 标签的各种属性。
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele,
String beanName, @Nullable BeanDefinition containingBean,
AbstractBeanDefinition bd) {
//解析 singleton 属性
if(ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
//'singleton'属性升级到'scope'声明
error(
"Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration",
ele);
}
//解析 scope 属性
else if(ele.hasAttribute(SCOPE_ATTRIBUTE)) {
bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
}
//当当前Bean没有明确使用 scope 属性时,且当前Bean被解析为是内部bean的话，
//则默认使用外部Bean的作用域作为当前bean的作用域
else if(containingBean != null) {
// Take default from containing bean in case of an inner bean definition.
bd.setScope(containingBean.getScope());
}
//解析 abstract 属性
if(ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(
ABSTRACT_ATTRIBUTE)));
}
//解析 lazy-init 属性
String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
if(isDefaultValue(lazyInit)) {
lazyInit = this.defaults.getLazyInit();
}
// 若没有设置或设置为其他字符都会被设置为false
bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
//解析 autowire 属性
String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
bd.setAutowireMode(getAutowireMode(autowire));
//解析 depends-on 属性
if(ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn,
MULTI_VALUE_ATTRIBUTE_DELIMITERS));
}
//解析 autowire-candidate 属性
String autowireCandidate = ele.getAttribute(
AUTOWIRE_CANDIDATE_ATTRIBUTE);
if(isDefaultValue(autowireCandidate)) {
String candidatePattern = this.defaults.getAutowireCandidates();
if(candidatePattern != null) {
String[] patterns = StringUtils.commaDelimitedListToStringArray(
candidatePattern);
bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(
patterns, beanName));
}
}
else {
bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
}
//解析 primary 属性
if(ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(
PRIMARY_ATTRIBUTE)));
}
//解析 init-method 属性
if(ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
bd.setInitMethodName(initMethodName);
}
else if(this.defaults.getInitMethod() != null) {
bd.setInitMethodName(this.defaults.getInitMethod());
bd.setEnforceInitMethod(false);
}
//解析 destroy-method 属性
if(ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
String destroyMethodName = ele.getAttribute(
DESTROY_METHOD_ATTRIBUTE);
bd.setDestroyMethodName(destroyMethodName);
}
else if(this.defaults.getDestroyMethod() != null) {
bd.setDestroyMethodName(this.defaults.getDestroyMethod());
bd.setEnforceDestroyMethod(false);
}
//解析 factory-method 属性
if(ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
bd.setFactoryMethodName(ele.getAttribute(
FACTORY_METHOD_ATTRIBUTE));
}
//解析 factory-bean 属性
if(ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
}
return bd;
}每个属性的作用可以看笔者的之前源码：Spring源码(一)-Bean的定义-BeanDefinition
注册BeanDefinition
到这里Spring已经将 xml 中的配置信息封装至BeanDefinitionHolder对象，接下来就可以执行对 BeanDefinition 的注册了，一起继续向下吧。调试进入 `BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
getReaderContext().getRegistry())`函数
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder,
BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
// 注册bean定义
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); >
1
// Register aliases for bean name, if any.
// 注册bean名称的别名(如果有的话)
String[] aliases = definitionHolder.getAliases();
if(aliases != null) {
for(String alias: aliases) {
registry.registerAlias(beanName, alias); > 2
}
}
}从上面的代码可以看出 ，解析的 BeanDefinition 都会被注册到 BeanDefinitionRegistry 类型的实例中， 对于 BeanDefinition 的注册分成了两部分：通过 beanName 的注册以及通过别名的注册。
通过beanName注册
首先进入registry.registerBeanDefinition(beanName,definitionHolder.getBeanDefinition())函数，进入该函数会进入到 BeanDefinitionRegistry接口，该接口下有三个子类，我们选择进入默认使用的DefaultListableBeanFactory子类
@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");
if(beanDefinition instanceof AbstractBeanDefinition) {
try {
/*
＊注册前的最后一次校验
主要是对于 AbstractBeanDefinition 中的 methodOverrides 属性校验，
* 校验 methodOverrides 是否与工厂方法并存或者 methodOverrides
对应的方法根本不存在
*/
((AbstractBeanDefinition) beanDefinition).validate();
}
catch(BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(),
beanName, "Validation of bean definition failed", ex);
}
}
// beanDefinitionMap: bean定义对象的映射 key为beanName
// 根据beanName获取BeanDefinition
BeanDefinition existingDefinition = this.beanDefinitionMap.get(
beanName);
//处理已经注册的 Bean 情况
if(existingDefinition != null) {
//如果对应的 Bean 已经注册且在配置中配置了 bean 不允许被覆盖，
//则抛出异常,默认是 true，也就是允许覆盖
if(!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName,
beanDefinition, existingDefinition);
}
// getRole方法可以去看上篇 BeanDefinition
// 使用新的BeanDefinition覆盖已经加载的BeanDefinition
else if(existingDefinition.getRole() < beanDefinition.getRole()) {
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 + "]");
}
}
//注册 BeanDefinition,加入 beanDefinitionMap 缓存。
this.beanDefinitionMap.put(beanName, beanDefinition);
}
//处理未注册的情况
else {
// 如果beanDefinition已经被标记为创建(为了解决单例bean的循环依赖问题)
if(hasBeanCreationStarted()) {
synchronized(this.beanDefinitionMap) {
//注册 BeanDefinition
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);
this.beanDefinitionNames = updatedDefinitions;
removeManualSingletonName(beanName); > 1
}
}
else {
// Still in startup registration phase
// 仍处于启动注册阶段
this.beanDefinitionMap.put(beanName, beanDefinition);
//维护了beanName集合
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName); > 1
}
this.frozenBeanDefinitionNames = null;
}
// 当前注册的bean的定义已经在beanDefinitionMap缓存中存在，
// 或者其实例已经存在于单例bean的缓存中(singletonObjects)，
//就进行重置当前Bean的BeanDefinition
if(existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
protected boolean hasBeanCreationStarted() {
return !this.alreadyCreated.isEmpty();
}我们看一下removeManualSingletonName(beanName)这个函数，这个函数使用了 java8 的函数式接口。
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()) {
synchronized(this.beanDefinitionMap) {
//如果manualSingletonNames中包含新注册的beanName
//对应 set -> set.contains(beanName)
if(condition.test(this.manualSingletonNames)) {
// 创建set集合并将manualSingletonNames加入到新创建的set集合
Set < String > updatedSingletons = new LinkedHashSet < >
(this.manualSingletonNames);
//然后移除新注册的beanName
//对应set.remove(beanName)
action.accept(updatedSingletons);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
if(condition.test(this.manualSingletonNames)) {
action.accept(this.manualSingletonNames);
}
}
}第一个函数表达式入参为一个 Consumer 消费型接口，代表接受一个输入参数并且无返回的操作
第二个函数表达式入参为一个 Predicate 断言形接口，接受一个输入参数，返回一个布尔值结果。
接下来就看看上面代码所用的数据存储容器：
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);
- beanDefinitionMap：bean定义对象的映射，key为beanName，value为BeanDefinition
- beanDefinitionNames ：beanName列表
- alreadyCreated ：存储至少创建了一次的bean的名称
- manualSingletonNames：手动注册的单例的名称列表
通过别名注册
进入registry.registerAlias(beanName, alias)函数，会跳转到 AliasRegistry接口，该接口下有两个实现类 GenericApplicationContext和SimpleAliasRegistry，我们选择SimpleAliasRegistry。
@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)) {
//将该别名从Map中移除
this.aliasMap.remove(alias);
if(logger.isDebugEnabled()) {
logger.debug("Alias definition '" + alias +
"' ignored since it points to same name");
}
}
//别名与beanName不相同
else {
// 根据传入的别名获取beanName
String registeredName = this.aliasMap.get(alias);
if(registeredName != null) {
//已经注册的名称与当前需要注册的beanName相等
/*
<alias name="user" alias="user2"></alias>
<alias name="user" alias="user2"></alias>
*/
if(registeredName.equals(name)) {
// An existing alias - no need to re-register
//已存在的别名-不需要重新注册
return;
}
//如果 alias 不允许被覆盖则抛出异常，默认是true，允许被覆盖
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 +
"'");
}
}
// 检查给定的名称（user2）是否指向给定的别名（user）作为别名（user2）
/*
2、<alias name="user" alias="user2"></alias>
1、<alias name="user2" alias="user"></alias>
*/
checkForAliasCircle(name, alias);
//缓存别名
this.aliasMap.put(alias, name);
if(logger.isTraceEnabled()) {
logger.trace("Alias definition '" + alias +
"' registered for name '" + name + "'");
}
}
}
}bean 标签的解析及注册解析完成啦！
