正文
在上一篇我們已經完成了從xml配置檔案到BeanDefinition的轉換，轉換後的例項是GenericBeanDefinition的例項。本文主要來看看標籤解析剩餘部分及BeanDefinition的註冊。
預設標籤中的自定義標籤解析
在上篇博文中我們已經分析了對於預設標籤的解析，我們繼續看戲之前的程式碼，如下圖片中有一個方法：delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)
這個方法的作用是什麼呢？首先我們看下這種場景，如下配置檔案：
<bean id="demo" class="com.dabin.spring.MyTestBean">
<property name="beanName" value="bean demo1"/>
<meta key="demo" value="demo"/>
<mybean:username="mybean"/>
</bean>這個配置檔案中有個自定義的標籤，decorateBeanDefinitionIfRequired方法就是用來處理這種情況的，其中的null是用來傳遞父級BeanDefinition的，我們進入到其方法體：
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.
NamedNodeMap attributes = ele.getAttributes();
for (int i = 0; i < attributes.getLength(); i++) {
Node node = attributes.item(i);
finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
}
// Decorate based on custom nested elements.
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;
}我們看到上面的程式碼有兩個遍歷操作，一個是用於對所有的屬性進行遍歷處理，另一個是對所有的子節點進行處理，兩個遍歷操作都用到了decorateIfRequired(node, finalDefinition, containingBd);方法，我們繼續跟蹤程式碼，進入方法體：
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 {
if (logger.isDebugEnabled()) {
logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
}
}
}
return originalDef;
}
public String getNamespaceURI(Node node) {
return node.getNamespaceURI();
}
public boolean isDefaultNamespace(@Nullable String namespaceUri) {
//BEANS_NAMESPACE_URI = "http://www.springframework.org/schema/beans";
return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri));
}首先獲取自定義標籤的名稱空間，如果不是預設的名稱空間則根據該名稱空間獲取相應的處理器，最後呼叫處理器的 decorate() 進行裝飾處理。具體的裝飾過程這裡不進行講述，在後面分析自定義標籤時會做詳細說明。
註冊解析的BeanDefinition
對於配置檔案，解析和裝飾完成之後，對於得到的beanDefinition已經可以滿足後續的使用要求了，還剩下注冊，也就是processBeanDefinition函式中的BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,getReaderContext().getRegistry())程式碼的解析了。進入方法體：
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);
}
}
}從上面的程式碼我們看到是用了beanName作為唯一標示進行註冊的，然後註冊了所有的別名aliase。而beanDefinition最終都是註冊到BeanDefinitionRegistry中，接下來我們具體看下注冊流程。
透過beanName註冊BeanDefinition
在spring中除了使用beanName作為key將BeanDefinition放入Map中還做了其他一些事情，我們看下方法registerBeanDefinition程式碼，BeanDefinitionRegistry是一個介面，他有三個實現類，DefaultListableBeanFactory、SimpleBeanDefinitionRegistry、GenericApplicationContext，其中SimpleBeanDefinitionRegistry非常簡單，而GenericApplicationContext最終也是使用的DefaultListableBeanFactory中的實現方法，我們看下程式碼：
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
// 校驗 beanName 與 beanDefinition
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
// 校驗 BeanDefinition
// 這是註冊前的最後一次校驗了，主要是對屬性 methodOverrides 進行校驗
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition oldBeanDefinition;
// 從快取中獲取指定 beanName 的 BeanDefinition
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
/**
* 如果存在
*/
if (oldBeanDefinition != null) {
// 如果存在但是不允許覆蓋，丟擲異常
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
//
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
// 覆蓋 beanDefinition 與 被覆蓋的 beanDefinition 不是同類
else if (!beanDefinition.equals(oldBeanDefinition)) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
// 允許覆蓋，直接覆蓋原有的 BeanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
}
/**
* 不存在
*/
else {
// 檢測建立 Bean 階段是否已經開啟，如果開啟了則需要對 beanDefinitionMap 進行併發控制
if (hasBeanCreationStarted()) {
// beanDefinitionMap 為全域性變數，避免併發情況
synchronized (this.beanDefinitionMap) {
//
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// 不會存在併發情況，直接設定
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
// 重新設定 beanName 對應的快取
resetBeanDefinition(beanName);
}
}處理過程如下：
- 首先 BeanDefinition 進行校驗，該校驗也是註冊過程中的最後一次校驗了，主要是對 AbstractBeanDefinition 的 methodOverrides 屬性進行校驗
- 根據 beanName 從快取中獲取 BeanDefinition，如果快取中存在，則根據 allowBeanDefinitionOverriding 標誌來判斷是否允許覆蓋，如果允許則直接覆蓋，否則丟擲 BeanDefinitionStoreException 異常
- 若快取中沒有指定 beanName 的 BeanDefinition，則判斷當前階段是否已經開始了 Bean 的建立階段（），如果是，則需要對 beanDefinitionMap 進行加鎖控制併發問題，否則直接設定即可。對於
hasBeanCreationStarted()方法後續做詳細介紹，這裡不過多闡述。 - 若快取中存在該 beanName 或者 單利 bean 集合中存在該 beanName，則呼叫
resetBeanDefinition()重置 BeanDefinition 快取。
其實整段程式碼的核心就在於 this.beanDefinitionMap.put(beanName, beanDefinition); 。BeanDefinition 的快取也不是神奇的東西，就是定義 一個 ConcurrentHashMap，key 為 beanName，value 為 BeanDefinition。
透過別名註冊BeanDefinition
透過別名註冊BeanDefinition最終是在SimpleBeanDefinitionRegistry中實現的，我們看下程式碼：
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) {
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 + "'.");
}
}
//當A->B存在時，若再次出現A->C->B時候則會丟擲異常。
checkForAliasCircle(name, alias);
this.aliasMap.put(alias, name);
}
}
}上述程式碼的流程總結如下：
（1）alias與beanName相同情況處理，若alias與beanName併名稱相同則不需要處理並刪除原有的alias
（2）alias覆蓋處理。若aliasName已經使用並已經指向了另一beanName則需要使用者的設定進行處理
（3）alias迴圈檢查，當A->B存在時，若再次出現A->C->B時候則會丟擲異常。
alias標籤的解析
對應bean標籤的解析是最核心的功能，對於alias、import、beans標籤的解析都是基於bean標籤解析的，接下來我就分析下alias標籤的解析。我們回到 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法，繼續看下方法體，如下圖所示：
對bean進行定義時，除了用id來 指定名稱外，為了提供多個名稱，可以使用alias標籤來指定。而所有這些名稱都指向同一個bean。在XML配置檔案中，可用單獨的元素來完成bean別名的定義。我們可以直接使用bean標籤中的name屬性，如下：
<bean id="demo" class="com.dabin.spring.MyTestBean" name="demo1,demo2">
<property name="beanName" value="bean demo1"/>
</bean>在Spring還有另外一種宣告別名的方式：
<bean id="myTestBean" class="com.dabin.spring.MyTestBean"/>
<alias name="myTestBean" alias="testBean1,testBean2"/>我們具體看下alias標籤的解析過程，解析使用的方法processAliasRegistration(ele)，方法體如下：
protected void processAliasRegistration(Element ele) {
//獲取beanName
String name = ele.getAttribute(NAME_ATTRIBUTE);
//獲取alias
String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
boolean valid = true;
if (!StringUtils.hasText(name)) {
getReaderContext().error("Name must not be empty", ele);
valid = false;
}
if (!StringUtils.hasText(alias)) {
getReaderContext().error("Alias must not be empty", ele);
valid = false;
}
if (valid) {
try {
//註冊alias
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));
}
}透過程式碼可以發現解析流程與bean中的alias解析大同小異，都是講beanName與別名alias組成一對註冊到registry中。跟蹤程式碼最終使用了SimpleAliasRegistry中的registerAlias(String name, String alias)方法
import標籤的解析
對於Spring配置檔案的編寫，經歷過大型專案的人都知道，裡面有太多的配置檔案了。基本採用的方式都是分模組，分模組的方式很多，使用import就是其中一種，例如我們可以構造這樣的Spring配置檔案：
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="demo" class="com.dabin.spring.MyTestBean" name="demo1,demo2">
<property name="beanName" value="bean demo1"/>
</bean>
<import resource="lookup-method.xml"/>
<import resource="replaced-method.xml"/>
</beans>applicationContext.xml檔案中使用import方式匯入有模組配置檔案，以後若有新模組入加，那就可以簡單修改這個檔案了。這樣大大簡化了配置後期維護的複雜度，並使配置模組化，易於管理。我們來看看Spring是如何解析import配置檔案的呢。解析import標籤使用的是importBeanDefinitionResource(ele)，進入方法體：
protected void importBeanDefinitionResource(Element ele) {
// 獲取 resource 的屬性值
String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
// 為空，直接退出
if (!StringUtils.hasText(location)) {
getReaderContext().error("Resource location must not be empty", ele);
return;
}
// 解析系統屬性，格式如 ："${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*:"
}
// 絕對路徑
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 {
// 相對路徑則根據相應的地址計算出絕對路徑地址
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);
}
}
// 解析成功後，進行監聽器啟用處理
Resource[] actResArray = actualResources.toArray(new Resource[0]);
getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}解析 import 過程較為清晰，整個過程如下：
- 獲取 source 屬性的值，該值表示資源的路徑
- 解析路徑中的系統屬性，如”${user.dir}”
- 判斷資源路徑 location 是絕對路徑還是相對路徑
- 如果是絕對路徑，則調遞迴呼叫 Bean 的解析過程，進行另一次的解析
- 如果是相對路徑，則先計算出絕對路徑得到 Resource，然後進行解析
- 通知監聽器，完成解析
判斷路徑
方法透過以下方法來判斷 location 是為相對路徑還是絕對路徑：
absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();判斷絕對路徑的規則如下：
- 以 classpath*: 或者 classpath: 開頭為絕對路徑
- 能夠透過該 location 構建出
java.net.URL為絕對路徑 - 根據 location 構造
java.net.URI判斷呼叫isAbsolute()判斷是否為絕對路徑
如果 location 為絕對路徑則呼叫 loadBeanDefinitions()，該方法在 AbstractBeanDefinitionReader 中定義。
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
ResourceLoader resourceLoader = getResourceLoader();
if (resourceLoader == null) {
throw new BeanDefinitionStoreException(
"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
}
if (resourceLoader instanceof ResourcePatternResolver) {
// Resource pattern matching available.
try {
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
int loadCount = loadBeanDefinitions(resources);
if (actualResources != null) {
for (Resource resource : resources) {
actualResources.add(resource);
}
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
}
return loadCount;
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"Could not resolve bean definition resource pattern [" + location + "]", ex);
}
}
else {
// Can only load single resources by absolute URL.
Resource resource = resourceLoader.getResource(location);
int loadCount = loadBeanDefinitions(resource);
if (actualResources != null) {
actualResources.add(resource);
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
}
return loadCount;
}
}整個邏輯比較簡單，首先獲取 ResourceLoader，然後根據不同的 ResourceLoader 執行不同的邏輯，主要是可能存在多個 Resource，但是最終都會迴歸到 XmlBeanDefinitionReader.loadBeanDefinitions() ，所以這是一個遞迴的過程。
至此，import 標籤解析完畢，整個過程比較清晰明瞭：獲取 source 屬性值，得到正確的資源路徑，然後呼叫 loadBeanDefinitions() 方法進行遞迴的 BeanDefinition 載入。