前言

Spring已經(jīng)是我們Java Web開(kāi)發(fā)必不可少的一個(gè)框架，其大大簡(jiǎn)化了我們的開(kāi)發(fā)，提高了開(kāi)發(fā)者的效率。同時(shí)，其源碼對(duì)于開(kāi)發(fā)者來(lái)說(shuō)也是寶藏，從中我們可以學(xué)習(xí)到非常優(yōu)秀的設(shè)計(jì)思想以及優(yōu)雅的命名規(guī)范，但因其體系龐大、設(shè)計(jì)復(fù)雜對(duì)于剛開(kāi)始閱讀源碼的人來(lái)說(shuō)是非常困難的。所以在此之前首先你得下定決心，不管有多困難都得堅(jiān)持下去；其次，最好先把設(shè)計(jì)模式掌握熟練；然后在開(kāi)始閱讀源碼時(shí)一定要多畫(huà)UML類圖和時(shí)序圖，多問(wèn)自己為什么要這么設(shè)計(jì)？這樣設(shè)計(jì)的好處是什么？還有沒(méi)有更好的設(shè)計(jì)？當(dāng)然，暈車是難免的，但還是那句話，一定要持之以恒（PS：源碼版本5.1.3.RELEASE）。

正文

熟悉IOC體系結(jié)構(gòu)

要學(xué)習(xí)Spring源碼，我們首先得要找準(zhǔn)入口，那這個(gè)入口怎么找呢？我們不妨先思考一下，在Spring項(xiàng)目啟動(dòng)時(shí)，Spring做了哪些事情。這里我以最原始的xml配置方式來(lái)分析，那么在項(xiàng)目啟動(dòng)時(shí)，首先肯定要先定位——找到xml配置文件，定位之后肯定是加載——將我們的配置加載到內(nèi)存，最后才是根據(jù)我們的配置實(shí)例化（本篇文章只講前兩個(gè)過(guò)程）。那么Spring是如何定位和加載xml文件的呢？涉及到哪些類呢？我們先來(lái)看張類圖：

該圖是IOC的體系圖，整體上你需要有一個(gè)大概的印象，可以看到所有的IOC都是有繼承關(guān)系的，這樣設(shè)計(jì)的好處就是任何一個(gè)子類IOC可以直接使用父類IOC加載的Bean，有點(diǎn)像JVM類加載的雙親委派機(jī)制；而紅色方框圈起來(lái)的是本篇涉及到的重要類，需要著重記憶它們的關(guān)系。

圖中最重要的兩個(gè)類是BeanFactory和ApplicationContext，這是所有IOC的父接口。其中BeanFactory提供了最基本的對(duì)bean的操作：

而ApplicationContex繼承了BeanFactory，同時(shí)還繼承了MessageSource、ResourceLoader、ApplicationEventPublisher等接口以提供國(guó)際化、資源加載、事件發(fā)布等高級(jí)功能。我們應(yīng)該想到平時(shí)Spring加載xml文件應(yīng)該是ApplicationContext的子類，從圖中我們可以看到一個(gè)叫ClassPathXmlApplicationContext的類，聯(lián)想到我們平時(shí)都會(huì) 將xml放到classPath下，所以我們直接從這個(gè)類開(kāi)始就行，這就是優(yōu)秀命名的好處。

探究配置加載的過(guò)程

在ClassPathXmlApplicationContext中有很多構(gòu)造方法，其中有一個(gè)是傳入一個(gè)字符串的（即配置文件的相對(duì)路徑），但最終是調(diào)用的下面這個(gè)構(gòu)造：

public ClassPathXmlApplicationContext( String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException { super(parent); //創(chuàng)建解析器，解析configLocations setConfigLocations(configLocations); if (refresh) { refresh(); } }

首先調(diào)用父類構(gòu)造器設(shè)置環(huán)境：

public AbstractApplicationContext(@Nullable ApplicationContext parent) { this(); setParent(parent); } public void setParent(@Nullable ApplicationContext parent) { this.parent = parent; if (parent != null) { Environment parentEnvironment = parent.getEnvironment(); if (parentEnvironment instanceof ConfigurableEnvironment) { getEnvironment().merge((ConfigurableEnvironment) parentEnvironment); } } }

然后解析傳入的相對(duì)路徑保存到configLocations變量中，最后再調(diào)用父類AbstractApplicationContext的refresh方法刷新容器（啟動(dòng)容器都會(huì)調(diào)用該方法），我們著重來(lái)看這個(gè)方法：

public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { //為容器初始化做準(zhǔn)備 prepareRefresh(); // 解析xml ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. registerBeanPostProcessors(beanFactory); // Initialize message source for this context. initMessageSource(); // Initialize event multicaster for this context. initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. onRefresh(); // Check for listener beans and register them. registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn('Exception encountered during context initialization - ' + 'cancelling refresh attempt: ' + ex); } // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset ’active’ flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { // Reset common introspection caches in Spring’s core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); } } }

這個(gè)方法是一個(gè)典型的模板方法模式的實(shí)現(xiàn)，第一步是準(zhǔn)備初始化容器環(huán)境，這一步不重要，重點(diǎn)是第二步，創(chuàng)建BeanFactory對(duì)象、加載解析xml并封裝成BeanDefinition對(duì)象都是在這一步完成的。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { refreshBeanFactory(); return getBeanFactory(); }

點(diǎn)進(jìn)去看是調(diào)用了refreshBeanFactory方法，但這里有兩個(gè)實(shí)現(xiàn)，應(yīng)該進(jìn)哪一個(gè)類里面呢？

如果你還記得前面的繼承體系，那你就會(huì)毫不猶豫的進(jìn)入AbstractRefreshableApplicationContext類中，所以在閱讀源碼的過(guò)程中一定要記住類的繼承體系。

protected final void refreshBeanFactory() throws BeansException { //如果BeanFactory不為空，則清除BeanFactory和里面的實(shí)例 if (hasBeanFactory()) { destroyBeans(); closeBeanFactory(); } try { //創(chuàng)建DefaultListableBeanFactory DefaultListableBeanFactory beanFactory = createBeanFactory(); beanFactory.setSerializationId(getId()); //設(shè)置是否可以循環(huán)依賴 allowCircularReferences //是否允許使用相同名稱重新注冊(cè)不同的bean實(shí)現(xiàn). customizeBeanFactory(beanFactory); //解析xml，并把xml中的標(biāo)簽封裝成BeanDefinition對(duì)象 loadBeanDefinitions(beanFactory); synchronized (this.beanFactoryMonitor) { this.beanFactory = beanFactory; } } catch (IOException ex) { throw new ApplicationContextException('I/O error parsing bean definition source for ' + getDisplayName(), ex); } }

在這個(gè)方法中首先會(huì)清除掉上一次創(chuàng)建的BeanFactory和對(duì)象實(shí)例，然后創(chuàng)建了一個(gè)DefaultListableBeanFactory對(duì)象并傳入到了loadBeanDefinitions方法中，這也是一個(gè)模板方法，因?yàn)槲覀兊呐渲貌恢褂衳ml，還有注解等，所以這里我們應(yīng)該進(jìn)入AbstractXmlApplicationContext類中：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { //創(chuàng)建xml的解析器，這里是一個(gè)委托模式 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); // Configure the bean definition reader with this context’s // resource loading environment. beanDefinitionReader.setEnvironment(this.getEnvironment()); //這里傳一個(gè)this進(jìn)去，因?yàn)锳pplicationContext是實(shí)現(xiàn)了ResourceLoader接口的 beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // Allow a subclass to provide custom initialization of the reader, // then proceed with actually loading the bean definitions. initBeanDefinitionReader(beanDefinitionReader); //主要看這個(gè)方法 loadBeanDefinitions(beanDefinitionReader); }

首先創(chuàng)建了一個(gè)XmlBeanDefinitionReader對(duì)象，見(jiàn)名知意，這個(gè)就是解析xml的類，需要注意的是該類的構(gòu)造方法接收的是BeanDefinitionRegistry對(duì)象，而這里將DefaultListableBeanFactory對(duì)象傳入了進(jìn)去（別忘記了這個(gè)對(duì)象是實(shí)現(xiàn)了BeanDefinitionRegistry類的），如果你足夠敏感，應(yīng)該可以想到后面會(huì)委托給該類去注冊(cè)。注冊(cè)什么呢？自然是注冊(cè)BeanDefintion。記住這個(gè)猜想，我們稍后來(lái)驗(yàn)證是不是這么回事。

接著進(jìn)入loadBeanDefinitions方法獲取之前保存的xml配置文件路徑，并委托給XmlBeanDefinitionReader對(duì)象解析加載：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException { Resource[] configResources = getConfigResources(); if (configResources != null) { reader.loadBeanDefinitions(configResources); } //獲取需要加載的xml配置文件 String[] configLocations = getConfigLocations(); if (configLocations != null) { reader.loadBeanDefinitions(configLocations); } }

最后會(huì)進(jìn)入到抽象父類AbstractBeanDefinitionReader中：

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException { // 這里獲取到的依然是DefaultListableBeanFactory對(duì)象 ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader == null) { throw new BeanDefinitionStoreException( 'Cannot load bean definitions from location [' + location + ']: no ResourceLoader available'); } if (resourceLoader instanceof ResourcePatternResolver) { // Resource pattern matching available. try { //把字符串類型的xml文件路徑，形如：classpath*:user/**/*-context.xml,轉(zhuǎn)換成Resource對(duì)象類型，其實(shí)就是用流 //的方式加載配置文件，然后封裝成Resource對(duì)象 Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); //主要看這個(gè)方法 int count = loadBeanDefinitions(resources); if (actualResources != null) { Collections.addAll(actualResources, resources); } if (logger.isTraceEnabled()) { logger.trace('Loaded ' + count + ' bean definitions from location pattern [' + location + ']'); } return count; } 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 count = loadBeanDefinitions(resource); if (actualResources != null) { actualResources.add(resource); } if (logger.isTraceEnabled()) { logger.trace('Loaded ' + count + ' bean definitions from location [' + location + ']'); } return count; } }

這個(gè)方法中主要將xml配置加載到存中并封裝成為Resource對(duì)象，這一步不重要，可以略過(guò)，主要的還是loadBeanDefinitions方法，最終還是調(diào)用到子類XmlBeanDefinitionReader的方法：

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { try { //獲取Resource對(duì)象中的xml文件流對(duì)象 InputStream inputStream = encodedResource.getResource().getInputStream(); try { //InputSource是jdk中的sax xml文件解析對(duì)象 InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } //主要看這個(gè)方法 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } finally { inputStream.close(); } } } protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { //把inputSource 封裝成Document文件對(duì)象，這是jdk的API Document doc = doLoadDocument(inputSource, resource); //主要看這個(gè)方法，根據(jù)解析出來(lái)的document對(duì)象，拿到里面的標(biāo)簽元素封裝成BeanDefinition int count = registerBeanDefinitions(doc, resource); if (logger.isDebugEnabled()) { logger.debug('Loaded ' + count + ' bean definitions from ' + resource); } return count; } } public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { // 創(chuàng)建DefaultBeanDefinitionDocumentReader對(duì)象，并委托其做解析注冊(cè)工作 BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); int countBefore = getRegistry().getBeanDefinitionCount(); //主要看這個(gè)方法，需要注意createReaderContext方法中創(chuàng)建的幾個(gè)對(duì)象 documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); return getRegistry().getBeanDefinitionCount() - countBefore; } public XmlReaderContext createReaderContext(Resource resource) { // XmlReaderContext對(duì)象中保存了XmlBeanDefinitionReader對(duì)象和DefaultNamespaceHandlerResolver對(duì)象的引用，在后面會(huì)用到 return new XmlReaderContext(resource, this.problemReporter, this.eventListener, this.sourceExtractor, this, getNamespaceHandlerResolver()); }

接著看看DefaultBeanDefinitionDocumentReader中是如何解析的：

protected void doRegisterBeanDefinitions(Element root) { // 創(chuàng)建了BeanDefinitionParserDelegate對(duì)象 BeanDefinitionParserDelegate parent = this.delegate; this.delegate = createDelegate(getReaderContext(), root, parent); // 如果是Spring原生命名空間，首先解析 profile標(biāo)簽，這里不重要 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); // We cannot use Profiles.of(...) since profile expressions are not supported // in XML config. See SPR-12458 for details. if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) { if (logger.isDebugEnabled()) { logger.debug('Skipped XML bean definition file due to specified profiles [' + profileSpec + '] not matching: ' + getReaderContext().getResource()); } return; } } } preProcessXml(root); //主要看這個(gè)方法，標(biāo)簽具體解析過(guò)程 parseBeanDefinitions(root, this.delegate); postProcessXml(root); this.delegate = parent; }

在這個(gè)方法中重點(diǎn)關(guān)注preProcessXml、parseBeanDefinitions、postProcessXml三個(gè)方法，其中preProcessXml和postProcessXml都是空方法，意思是在解析標(biāo)簽前后我們自己可以擴(kuò)展需要執(zhí)行的操作，也是一個(gè)模板方法模式，體現(xiàn)了Spring的高擴(kuò)展性。然后進(jìn)入parseBeanDefinitions方法看具體是怎么解析標(biāo)簽的：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { if (delegate.isDefaultNamespace(root)) { NodeList nl = root.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element) { Element ele = (Element) node; if (delegate.isDefaultNamespace(ele)) { //默認(rèn)標(biāo)簽解析 parseDefaultElement(ele, delegate); } else { //自定義標(biāo)簽解析 delegate.parseCustomElement(ele); } } } } else { delegate.parseCustomElement(root); } }

這里有兩種標(biāo)簽的解析：Spring原生標(biāo)簽和自定義標(biāo)簽。怎么區(qū)分這兩種標(biāo)簽?zāi)兀?/p>

// 自定義標(biāo)簽<context:component-scan/>// 默認(rèn)標(biāo)簽<bean:/>

如上，帶前綴的就是自定義標(biāo)簽，否則就是Spring默認(rèn)標(biāo)簽，無(wú)論哪種標(biāo)簽在使用前都需要在Spring的xml配置文件里聲明Namespace URI，這樣在解析標(biāo)簽時(shí)才能通過(guò)Namespace URI找到對(duì)應(yīng)的NamespaceHandler。

xmlns:context='http://www.springframework.org/schema/context'

http://www.springframework.org/schema/beans

isDefaultNamespace判斷是不是默認(rèn)標(biāo)簽，點(diǎn)進(jìn)去看看是不是跟我上面說(shuō)的一致：

public boolean isDefaultNamespace(Node node) { return isDefaultNamespace(getNamespaceURI(node)); } public static final String BEANS_NAMESPACE_URI = 'http://www.springframework.org/schema/beans'; public boolean isDefaultNamespace(@Nullable String namespaceUri) { return (!StringUtils.hasLength(namespaceUri) || BEANS_NAMESPACE_URI.equals(namespaceUri)); }

可以看到http://www.springframework.org/schema/beans所對(duì)應(yīng)的就是默認(rèn)標(biāo)簽。接著，我們進(jìn)入parseDefaultElement方法：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { //import標(biāo)簽解析 if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } //alias標(biāo)簽解析 else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { processAliasRegistration(ele); } //bean標(biāo)簽 else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse doRegisterBeanDefinitions(ele); } }

這里面主要是對(duì)import、alias、bean標(biāo)簽的解析以及beans的字標(biāo)簽的遞歸解析，主要看看bean標(biāo)簽的解析：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { // 解析elment封裝為BeanDefinitionHolder對(duì)象 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { // 該方法功能不重要，主要理解設(shè)計(jì)思想：裝飾者設(shè)計(jì)模式以及SPI設(shè)計(jì)思想 bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { // 完成document到BeanDefinition對(duì)象轉(zhuǎn)換后，對(duì)BeanDefinition對(duì)象進(jìn)行緩存注冊(cè) BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); } // Send registration event. getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } } public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { // 獲取id和name屬性 String id = ele.getAttribute(ID_ATTRIBUTE); String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); // 獲取別名屬性，多個(gè)別名可用,;隔開(kāi) List<String> aliases = new ArrayList<>(); if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); } String beanName = id; 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'); } } //檢查beanName是否重復(fù) if (containingBean == null) { checkNameUniqueness(beanName, aliases, ele); } // 具體的解析封裝過(guò)程還在這個(gè)方法里 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { 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.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); return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray); } return null; } // bean的解析 public AbstractBeanDefinition parseBeanDefinitionElement( Element ele, String beanName, @Nullable BeanDefinition containingBean) { this.parseState.push(new BeanEntry(beanName)); // 獲取class名稱和父類名稱 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 { // 創(chuàng)建GenericBeanDefinition對(duì)象 AbstractBeanDefinition bd = createBeanDefinition(className, parent); // 解析bean標(biāo)簽的屬性，并把解析出來(lái)的屬性設(shè)置到BeanDefinition對(duì)象中 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); //解析bean中的meta標(biāo)簽 parseMetaElements(ele, bd); //解析bean中的lookup-method標(biāo)簽 parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); //解析bean中的replaced-method標(biāo)簽 parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); //解析bean中的constructor-arg標(biāo)簽 parseConstructorArgElements(ele, bd); //解析bean中的property標(biāo)簽 parsePropertyElements(ele, bd); parseQualifierElements(ele, bd); bd.setResource(this.readerContext.getResource()); bd.setSource(extractSource(ele)); return bd; } return null; }

bean標(biāo)簽的解析步驟仔細(xì)理解并不復(fù)雜，就是將一個(gè)個(gè)標(biāo)簽屬性的值裝入到了BeanDefinition對(duì)象中，這里需要注意parseConstructorArgElements和parsePropertyElements方法，分別是對(duì)constructor-arg和property標(biāo)簽的解析，解析完成后分別裝入了BeanDefinition對(duì)象的constructorArgumentValues和propertyValues中，而這兩個(gè)屬性在接下來(lái)c和p標(biāo)簽的解析中還會(huì)用到，而且還涉及一個(gè)很重要的設(shè)計(jì)思想——裝飾器模式。

Bean標(biāo)簽解析完成后將生成的BeanDefinition對(duì)象、bean的名稱以及別名一起封裝到了BeanDefinitionHolder對(duì)象并返回，然后調(diào)用了decorateBeanDefinitionIfRequired進(jìn)行裝飾：

public BeanDefinitionHolder decorateBeanDefinitionIfRequired( Element ele, BeanDefinitionHolder definitionHolder, @Nullable BeanDefinition containingBd) { BeanDefinitionHolder finalDefinition = definitionHolder; //根據(jù)bean標(biāo)簽屬性裝飾BeanDefinitionHolder，比如<bean p:username='dark'/> NamedNodeMap attributes = ele.getAttributes(); for (int i = 0; i < attributes.getLength(); i++) { Node node = attributes.item(i); finalDefinition = decorateIfRequired(node, finalDefinition, containingBd); } //根據(jù)bean標(biāo)簽子元素裝飾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; }

在這個(gè)方法中分別對(duì)Bean標(biāo)簽的屬性和子標(biāo)簽迭代，獲取其中的自定義標(biāo)簽進(jìn)行解析，并裝飾之前創(chuàng)建的BeanDefinition對(duì)象，如同下面的c和p：

// c:和p:表示通過(guò)構(gòu)造器和屬性的setter方法給屬性賦值，是constructor-arg和property的簡(jiǎn)化寫(xiě)法

<bean p:username='Dark' p:password='111' c:age='12' c:sex='1'/>

兩個(gè)步驟是一樣的，我們點(diǎn)進(jìn)decorateIfRequired方法中：

public BeanDefinitionHolder decorateIfRequired( Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) { //根據(jù)node獲取到node的命名空間，形如：http://www.springframework.org/schema/p String namespaceUri = getNamespaceURI(node); if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) { // 根據(jù)配置文件獲取namespaceUri對(duì)應(yīng)的處理類，SPI思想 NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); if (handler != null) { //調(diào)用NamespaceHandler處理類的decorate方法，開(kāi)始具體裝飾過(guò)程，并返回裝飾完的對(duì)象 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; }

這里也和我們之前說(shuō)的一樣，首先獲取到標(biāo)簽對(duì)應(yīng)的namespaceUri，然后通過(guò)這個(gè)Uri去獲取到對(duì)應(yīng)的NamespceHandler，最后再調(diào)用NamespceHandler的decorate方法進(jìn)行裝飾。我們先來(lái)看看獲取NamespceHandler的過(guò)程，這涉及到一個(gè)非常重要的高擴(kuò)展性的思想——SPI（有關(guān)SPI，在我之前的文章Dubbo——SPI及自適應(yīng)擴(kuò)展原理中已經(jīng)詳細(xì)講解過(guò)，這里不再贅述）：

public NamespaceHandler resolve(String namespaceUri) { // 獲取spring中所有jar包里面的 'META-INF/spring.handlers'文件，并且建立映射關(guān)系 Map<String, Object> handlerMappings = getHandlerMappings(); //根據(jù)namespaceUri：http://www.springframework.org/schema/p，獲取到這個(gè)命名空間的處理類 Object handlerOrClassName = handlerMappings.get(namespaceUri); if (handlerOrClassName == null) { return null; } else if (handlerOrClassName instanceof NamespaceHandler) { return (NamespaceHandler) handlerOrClassName; } else { String className = (String) handlerOrClassName; try { Class<?> handlerClass = ClassUtils.forName(className, this.classLoader); if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) { throw new FatalBeanException('Class [' + className + '] for namespace [' + namespaceUri + '] does not implement the [' + NamespaceHandler.class.getName() + '] interface'); } NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass); //調(diào)用處理類的init方法，在init方法中完成標(biāo)簽元素解析類的注冊(cè) namespaceHandler.init(); handlerMappings.put(namespaceUri, namespaceHandler); return namespaceHandler; } } } // AOP標(biāo)簽對(duì)應(yīng)的NamespaceHandler，可以發(fā)現(xiàn)NamespaceHandler的作用就是管理和注冊(cè)與自己相關(guān)的標(biāo)簽解析器 public void init() { // In 2.0 XSD as well as in 2.1 XSD. registerBeanDefinitionParser('config', new ConfigBeanDefinitionParser()); registerBeanDefinitionParser('aspectj-autoproxy', new AspectJAutoProxyBeanDefinitionParser()); registerBeanDefinitionDecorator('scoped-proxy', new ScopedProxyBeanDefinitionDecorator()); // Only in 2.0 XSD: moved to context namespace as of 2.1 registerBeanDefinitionParser('spring-configured', new SpringConfiguredBeanDefinitionParser()); }

看到這里我們應(yīng)該就清楚了Spring是如何解析xml里的標(biāo)簽了以及我們?nèi)绻獢U(kuò)展自己的標(biāo)簽該怎么做。只需要?jiǎng)?chuàng)建一個(gè)我們的自定義標(biāo)簽和解析類，并指定它的命名空間以及NamespaceHandler，最后在META-INF/spring.handlers文件中指定命名空間和NamespaceHandler的映射關(guān)系即可，就像Spring的c和p標(biāo)簽一樣：

http://www.springframework.org/schema/c=org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler

http://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler

像這樣使用SPI的思想設(shè)計(jì)我們的項(xiàng)目的話，當(dāng)需要擴(kuò)展時(shí)，不需要改動(dòng)任何的代碼，非常的方便優(yōu)雅。

接著，我們回到handler的decorate方法，這里有三個(gè)默認(rèn)的實(shí)現(xiàn)類：NamespaceHandlerSupport、SimpleConstructorNamespaceHandler、SimplePropertyNamespaceHandler。第一個(gè)是一個(gè)抽象類，與我們這里的流程無(wú)關(guān)，感興趣的可自行了解，第二個(gè)和第三個(gè)則分別是c和p標(biāo)簽對(duì)應(yīng)的NamespaceHandler，兩個(gè)裝飾的處理邏輯基本上是一樣的，我這里進(jìn)入的是SimpleConstructorNamespaceHandler類：

public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) { if (node instanceof Attr) { Attr attr = (Attr) node; String argName = StringUtils.trimWhitespace(parserContext.getDelegate().getLocalName(attr)); String argValue = StringUtils.trimWhitespace(attr.getValue()); ConstructorArgumentValues cvs = definition.getBeanDefinition().getConstructorArgumentValues(); boolean ref = false; // handle -ref arguments if (argName.endsWith(REF_SUFFIX)) { ref = true; argName = argName.substring(0, argName.length() - REF_SUFFIX.length()); } ValueHolder valueHolder = new ValueHolder(ref ? new RuntimeBeanReference(argValue) : argValue); valueHolder.setSource(parserContext.getReaderContext().extractSource(attr)); // handle 'escaped'/'_' arguments if (argName.startsWith(DELIMITER_PREFIX)) { String arg = argName.substring(1).trim(); // fast default check if (!StringUtils.hasText(arg)) { cvs.addGenericArgumentValue(valueHolder); } // assume an index otherwise else { int index = -1; try { index = Integer.parseInt(arg); } catch (NumberFormatException ex) { parserContext.getReaderContext().error( 'Constructor argument ’' + argName + '’ specifies an invalid integer', attr); } if (index < 0) { parserContext.getReaderContext().error( 'Constructor argument ’' + argName + '’ specifies a negative index', attr); } if (cvs.hasIndexedArgumentValue(index)) { parserContext.getReaderContext().error( 'Constructor argument ’' + argName + '’ with index '+ index+' already defined using <constructor-arg>.' + ' Only one approach may be used per argument.', attr); } cvs.addIndexedArgumentValue(index, valueHolder); } } // no escaping -> ctr name else { String name = Conventions.attributeNameToPropertyName(argName); if (containsArgWithName(name, cvs)) { parserContext.getReaderContext().error( 'Constructor argument ’' + argName + '’ already defined using <constructor-arg>.' + ' Only one approach may be used per argument.', attr); } valueHolder.setName(Conventions.attributeNameToPropertyName(argName)); cvs.addGenericArgumentValue(valueHolder); } } return definition; }

很簡(jiǎn)單，拿到c標(biāo)簽對(duì)應(yīng)的值，封裝成ValueHolder，再添加到BeanDefinition的ConstructorArgumentValues屬性中去，這樣就裝飾完成了。

講到這里你可能會(huì)覺(jué)得，這和平時(shí)看到裝飾器模式不太一樣。其實(shí)，設(shè)計(jì)模式真正想要表達(dá)的是各種模式所代表的思想，而不是死搬硬套的實(shí)現(xiàn)，只有靈活的運(yùn)用其思想才算是真正的掌握了設(shè)計(jì)模式，而裝飾器模式的精髓就是動(dòng)態(tài)的將屬性、功能、責(zé)任附加到對(duì)象上，這樣你再看這里是否是運(yùn)用了裝飾器的思想呢？

裝飾完成后返回BeanDefinitionHolder對(duì)象并調(diào)用BeanDefinitionReaderUtils.registerBeanDefinition方法將該對(duì)象緩存起來(lái)，等待容器去實(shí)例化。這里就是將其緩存到DefaultListableBeanFactory的beanDefinitionMap屬性中，自己看看代碼也就明白了，我就不貼代碼了。至此，Spring的XML解析原理分析完畢，下面是我畫(huà)的時(shí)序圖，可以對(duì)照看看：

總結(jié)

本篇是Spring源碼分析的第一篇，只是分析了refresh中的obtainFreshBeanFactory方法，我們可以看到僅僅是對(duì)XML的解析和bean定義的注冊(cè)緩存，Spring就做了這么多事，并考慮到了各個(gè)可能會(huì)擴(kuò)展的地方，那我們平時(shí)做的項(xiàng)目呢？看似簡(jiǎn)單的背后是否有深入思考過(guò)呢？

以上這篇這一次搞懂Spring的XML解析原理說(shuō)明就是小編分享給大家的全部?jī)?nèi)容了，希望能給大家一個(gè)參考，也希望大家多多支持好吧啦網(wǎng)。