默認標籤的解析是在DefaultBeanDefinitionDocumentReader.parseDefaultElement(Element, BeanDefinitionParserDelegate)方法中處理的。
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
可以看出,此方法可以解析import,alias,bean,beans這四種標籤。
import標籤的解析
Spring可以通過import標籤對多個Spring配置文件進行整合,以此實現配置文件的模塊化。
<beans>
<import resource="transaction.xml"/>
<import resource="dubbo.xml"/>
</beans>
下面看看Spring是如何解析import標籤的。
/**
* 解析import標籤,加載bean到beanFactory中
*/
protected void importBeanDefinitionResource(Element ele) {
//獲取import標籤的resource屬性
String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
//如果resource屬性爲空,則不做任何處理
if (!StringUtils.hasText(location)) {
getReaderContext().error("Resource location must not be empty", ele);
return;
}
// 解析resource屬性,如 "${user.dir}"
location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);
Set<Resource> actualResources = new LinkedHashSet<>(4);
// 判斷location是絕對還是相對路徑
boolean absoluteLocation = false;
try {
absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
}
catch (URISyntaxException ex) {
// cannot convert to an URI, considering the location relative
// unless it is the well-known Spring prefix "classpath*:"
}
// 如果是絕對路徑,根據絕對路徑加載resource屬性對應的配置文件
if (absoluteLocation) {
try {
int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
if (logger.isDebugEnabled()) {
logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
}
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error(
"Failed to import bean definitions from URL location [" + location + "]", ele, ex);
}
}
else {//如果是相對路徑,先嚐試根據相對路徑獲取資源。如果獲取失敗,則計算出絕度路徑,獲取資源
// No URL -> considering resource location as relative to the current file.
try {
int importCount;
//先嚐試根據相對路徑獲取資源
Resource relativeResource = getReaderContext().getResource().createRelative(location);
if (relativeResource.exists()) {
importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
actualResources.add(relativeResource);
}
else {//如果獲取失敗,則計算出絕度路徑,獲取資源
String baseLocation = getReaderContext().getResource().getURL().toString();
importCount = getReaderContext().getReader().loadBeanDefinitions(
StringUtils.applyRelativePath(baseLocation, location), actualResources);
}
if (logger.isDebugEnabled()) {
logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
}
}
catch (IOException ex) {
getReaderContext().error("Failed to resolve current resource location", ele, ex);
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
ele, ex);
}
}
//將LinkedHashSet形式的資源轉化爲數組形式
Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
//通知監聽器,解析完成。
getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}
將步驟總結如下
- 獲取import標籤的resource屬性
- 如果resource屬性爲空,則不做任何處理
- 解析resource屬性成location,如 “${user.dir}”
- 判斷location是絕對還是相對路徑
- 如果是絕對路徑,根據絕對路徑加載resource屬性對應的配置文件
- 如果是相對路徑,先嚐試根據相對路徑獲取資源。如果獲取失敗,則計算出絕度路徑,根據絕對路徑加載配置文件
- 通知監聽器,解析完成
alias標籤的解析
Spirng可以使用alias標籤來完成bean別名的定義。如<bean id="testBean" class="com.test"/>
,要給這個bean起別名,可以直接使用bean標籤中的那麼屬性:<bean id="testBean" name="testBean,testBean2" class="com.test"/>
Spring還提供了另外一種聲明別名的方式:
<bean id="testBean" class="com.test"/>
<alias name="testBean" alias="testBean,testBean2"/>
下面看看Spring是如何解析alias標籤的。
protected void processAliasRegistration(Element ele) {
//獲取alias標籤的name和alias屬性
String name = ele.getAttribute(NAME_ATTRIBUTE);
String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
boolean valid = true;
//如果name屬性爲空
if (!StringUtils.hasText(name)) {
getReaderContext().error("Name must not be empty", ele);
valid = false;
}
//如果alias屬性爲空
if (!StringUtils.hasText(alias)) {
getReaderContext().error("Alias must not be empty", ele);
valid = false;
}
//如果name和alias屬性都不爲空
if (valid) {
try {
//註冊別名
getReaderContext().getRegistry().registerAlias(name, alias);
}
catch (Exception ex) {
getReaderContext().error("Failed to register alias '" + alias +
"' for bean with name '" + name + "'", ele, ex);
}
//註冊別名成功後通知監聽器做相應處理
getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
}
}
將步驟總結如下
- 獲取alias標籤的name和alias屬性
- 如果name或alias屬性爲空,則不做任何處理
- 註冊別名
- 註冊別名成功後通知監聽器做相應處理
下面看看org.springframework.core.SimpleAliasRegistry.registerAlias(String, String)是如何爲bean註冊別名的。
@Override
public void registerAlias(String name, String alias) {
Assert.hasText(name, "'name' must not be empty");
Assert.hasText(alias, "'alias' must not be empty");
if (alias.equals(name)) {
this.aliasMap.remove(alias);
}
else {
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("Cannot register alias '" + alias + "' for name '" +
name + "': It is already registered for name '" + registeredName + "'.");
}
}
checkForAliasCircle(name, alias);
//以上都是在做檢查
//註冊別名,即將別名alias作爲key,name作爲value放入map中
this.aliasMap.put(alias, name);
}
}
bean標籤的解析
在這四種標籤中,bean標籤的解析是最重要也是最複雜的。下面看看DefaultBeanDefinitionDocumentReader.processBeanDefinition(Element, BeanDefinitionParserDelegate)是如何解析bean標籤的。
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
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));
}
}
將步驟總結如下:
- 解析bean標籤。委託BeanDefinitionDelegate類的parseBeanDefinitionElement方法去解析bean標籤,返回一個BeanDefinitionHolder類型的bdHolder。bdHolder此時已經包含bean標籤的各種屬性了。
- 解析默認標籤中的自定義標籤。當返回的bdHolder不爲空的情況下,若存在默認標籤的子節點下再有自定義屬性,還需要再次對自定義標籤進行解析
- 註冊。解析完成後,委託BeanDefinitionReaderUtils的registerBeanDefinition方法對bdHolder進行註冊
- 通知監聽器bean已經註冊完成
解析bean標籤
進入BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element)方法
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
//獲取bean的id屬性
String id = ele.getAttribute(ID_ATTRIBUTE);
//獲取bean的name屬性
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<>();
//如果bean的name屬性不爲空,根據分隔符分割name屬性
//public static final String MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; ";
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
//如果bean的id屬性爲空且name屬性不爲空
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
//將name屬性分割後的第一個值作爲id,並在日誌中打印出來
beanName = aliases.remove(0);
if (logger.isDebugEnabled()) {
logger.debug("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
//檢查id和name在當前beans中有沒有重複
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
//解析其他屬性,封裝成AbstractBeanDefinition
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
//如果beanName依然爲空,使用默認的方式生成唯一的beanName
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
// Register an alias for the plain bean class name, if still possible,
// if the generator returned the class name plus a suffix.
// This is expected for Spring 1.2/2.0 backwards compatibility.
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
if (logger.isDebugEnabled()) {
logger.debug("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;
}
將步驟總結如下:
- 獲取id和name屬性
- 默認id屬性爲beanName,如果id屬性值爲空,則取name屬性的第一個名稱;
- 判斷beanName的唯一性;
- 解析其他屬性,封裝成AbstractBeanDefinition
- 如果beanName依然爲空,使用默認的方式生成唯一的beanName;
- 將獲取到的信息封裝成BeanDefinitionHolder並返回
第四步需要特別關注
/**
* 解析bean標籤的其他屬性
*/
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
//獲取bean標籤class屬性
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
//獲取bean標籤parent屬性
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
//創建GenericBeanDefinition,記錄className,和parent
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//將bean的其他屬性值都記錄到bd中
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
//解析子元素description
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//解析子元素meta
parseMetaElements(ele, bd);
//解析子元素loopup-method
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//解析子元素replaced-method
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//解析子元素constructor-arg
parseConstructorArgElements(ele, bd);
//解析子元素property
parsePropertyElements(ele, bd);
//解析子元素qualifier
parseQualifierElements(ele, bd);
//記錄Resource
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;
}
這裏只是對此方法做簡單介紹。至此,我們已經完成了從bean標籤到GenericBeanDefinition的轉換,bean標籤中的屬性都可以在GenericBeanDefinition實例中找到。
解析默認標籤中的自定義標籤
上面用了大量的篇幅介紹BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
,下面將介紹bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
。
當Spring中的bean使用的是默認標籤的配置,但其中的子元素使用的確實自定義標籤的配置,這個方法就會執行。
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
}
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) {
BeanDefinitionHolder finalDefinition = definitionHolder;
// Decorate based on custom attributes first.
//獲取bean標籤的所有屬性
NamedNodeMap attributes = ele.getAttributes();
//遍歷所有的屬性,如果有自定義屬性,則對BeanDefinitionHolder進行裝飾
for (int i = 0; i < attributes.getLength(); i++) {
Node node = attributes.item(i);
finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
}
// Decorate based on custom nested elements.
//遍歷所有的子節點,如果有自定義節點,則對BeanDefinitionHolder進行裝飾
NodeList children = ele.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node node = children.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
}
}
return finalDefinition;
}
註冊
在上面已經對BeanDefinitionHolder實例進行了初始化和裝飾,接下來就可以註冊了。
/**
* 將給定的BeanDefinitionHolder註冊到BeanDefinitionHolder中。
*/
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// 使用beanName 作爲註冊時的唯一標識
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 註冊別名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
通知監聽器
在註冊完成後,如果需要對註冊事件進行監聽,可以通過註冊監聽器的方式將處理邏輯寫入監聽器中。
beans標籤的解析
/**
* 遞歸調用beans的解析方法
*/
protected void doRegisterBeanDefinitions(Element root) {
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) {
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isInfoEnabled()) {
logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
postProcessXml(root);
this.delegate = parent;
}
沒什麼好講的,非常類似於import標籤提供的功能。
本文已收錄於Spring源碼札記專欄。