解析 Bean 标签的基本步骤
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// step 1
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// step 2
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// step 3
// 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);
}
// step 4
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
Bean 标签的解析可以分为上面函数中的四步。
BeanDefinitionParserDelegate类进行元素解析，返回BeanDefinitionHolder类，该类中已经包含了配置文件中配置的各种属性，如 class、name、id、alias 等。- 若标签存在自定义属性，还需要再次对自定义属性进行解析。
BeanDefinitionReaderUtils.registerBeanDefinition()完成了对 bdHolder 的注册。- 发出响应事件，通知相关监听器，当前 bean 已经加载完成。
解析 BeanDefinition
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
parseMetaElements(ele, bd);
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
parseConstructorArgElements(ele, bd);
parsePropertyElements(ele, bd);
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
...
}
上述解析工作主要包括：
- 提取元素中的 id 和 name 属性；
- 解析其他所有属性并封装到 GenericBeanefinition 类型实例中；
- 如果检测到 bean 没有指定 beanName，按默认规则生成 beanName；
- 将获取到的信息封装到 BeanDefinitionHolder 中
属性解析的具体过程
1、创建用于属性承载的 Beanefinition
Spring 通过 Beanefinition 将配置文件中的 bean 标签信息转换为容器的内部展示，并将 Beanefinition 注册到 BeanefinitionRegistry 中。在 Spring 中存在三种 Beanefinition : RootBeanefinition、ChildBeanefinition 以及 GenericBeanefinition，均继承自 AbstractBeanefinition。GenericBeanefinition 是 2.5 版本之后的属性定义类。BeanDefinitionReaderUtils.createBeanDefinition() 完成创建工作。
public static AbstractBeanDefinition createBeanDefinition(
@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setParentName(parentName);
if (className != null) {
// 如果有 classLoader，那么就传入 class 对象
if (classLoader != null) {
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}
2、解析各类属性
parseBeanDefinitionAttributes() 完成了属性的解析工作，被解析的属性主要包括：scope 属性、abstract 属性、lazy_init 属性、autowire 属性、depends-on 属性、autowire-candidate 属性、primary 属性、init-method 属性、destroy-method 属性、factory-method 属性、factory-bean 属性。
解析子元素 meta
public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
// 获取当前节点子元素
NodeList nl = ele.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
// 判断是否是 bean 元素下的 meta 元素
if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
Element metaElement = (Element) node;
String key = metaElement.getAttribute(KEY_ATTRIBUTE);
String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
// 使用 key、value 构建 BeanMetadataAttribute
BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
attribute.setSource(extractSource(metaElement));
// 记录数据
attributeAccessor.addMetadataAttribute(attribute);
}
}
}
解析子元素 lookup-method
获取器注入：它是把一个方法声明为返回某种类型的 bean，但实际要返回的 bean 是在配置文件里面配置的，此方法可用在可插拔的功能的设计，解除程序依赖。解析过程和 meta 基本一致。
解析子元素 replaced-method
方法替换：可以在运行时用新的方法替换现有的方法
解析子元素 constructor-arg
针对构造函数的参数进行配置
解析子元素 property
针对类中的变量进行配置
解析 qualifier
配置注入 Bean 的名称
3、解析自定义标签元素
在解析完 Bean 标签默认的元素之后，就需要解析自定义的一些标签属性。 decorateBeanDefinitionIfRequired 函数完成了上述功能。
public BeanDefinitionHolder decorateIfRequired(
Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
// 获取自定义标签的命名空间
String namespaceUri = getNamespaceURI(node);
// 对非默认的标签进行处理
if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
// 找到命名空间对应的处理器
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler != null) {
// 进行修饰
BeanDefinitionHolder decorated =
handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
if (decorated != null) {
return decorated;
}
}
else if (namespaceUri.startsWith("http://www.springframework.org/")) {
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
}
else {
// A custom namespace, not to be handled by Spring - maybe "xml:...".
if (logger.isDebugEnabled()) {
logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
}
}
}
return originalDef;
}
对 bean 标签下所有的元素和子节点调用上述函数进行解析，获取最终的解析结果。
4、注册解析的 BeanDefinition
通过 beanName 注册 BeanDefinition
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
...
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
// 对 AbstractBeanDefinition 的校验，针对 AbstractBeanDefinition 的 methodOverrides 属性
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
// 若 beanName 已经被注册，如果不允许覆盖，则抛出异常；否则直接覆盖
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
...
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
// 加入 map 缓存
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
removeManualSingletonName(beanName);
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
// 清除之前的缓存
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
else if (isConfigurationFrozen()) {
clearByTypeCache();
}
}
总结一下，大致过程可以分为 4 步：
- 校验 methodOverrides 属性；
- 对 beanName 已经注册的情况处理；
- 加入 map 缓存；
- 清除解析之前留下的对应 beanName 的缓存
通过 alias 注册 BeanDefinition
public void registerAlias(String name, String alias) {
...
synchronized (this.aliasMap) {
// 避免和 name 相同的 alias
if (alias.equals(name)) {
this.aliasMap.remove(alias);
...
}
else {
// alias 覆盖处理，若已经有了且对应 name 则不处理，若对应了其他 name 则判断是否可以覆盖
String registeredName = this.aliasMap.get(alias);
if (registeredName != null) {
if (registeredName.equals(name)) {
// An existing alias - no need to re-register
return;
}
if (!allowAliasOverriding()) {
throw new IllegalStateException(...);
}
...
}
// 检查循环，防止发生 name 和 alias 互相设置为别名的情况
checkForAliasCircle(name, alias);
// 注册 alias
this.aliasMap.put(alias, name);
...
}
}
}
总结一下，注册 alias 大致分为 4 步：
- alias 与 beanName 相同时的处理；
- alias 覆盖处理；
- alias 循环检查；
- 注册 alias。
5、通知监视器解析及注册完成
为了程序的扩展需要，当开发人员需要对注册 BeanDefinition 事件进行监听时可以通过注册监听器的方式将处理逻辑写入监听器中。
359
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
