程序博客网 > js实现tab切换

Spring默认标签解析及注册实现

来源：互联网 发布：js实现tab切换 编辑：程序博客网 时间：2024/06/08 04:53


转载 http://blog.csdn.net/fighterandknight/article/details/51235842


在使用spring的时候，我也经常会使用到bean标签，beans标签，import标签，aop标签等。

下面主要为读者介绍spring的默认的自带标签的解析流程。


验证模式（DTD&XSD）

dtd基本已被淘汰，现在spring的验证模式基本都是采用xsd文件作为xml文档的验证模式，通过xsd文件可以检查该xml是否符合规范，是否有效。在使用xsd文件对xml文档进行校验的时候，除了要名称空间外（xmlns="http://www.springframework.org/schema/beans"）还必须指定该名称空间所对应的xsd文档的存贮位置，通过schemaLocation属性来指定名称空间所对应的xsd文档的存储位置，它包含两部分，一部分是名称空间的URI，另一部分是该名称空间所标识的xsd文件位置或URL地址（xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd“）。

名称空间URI

当我们使用spring标签的时候，例如使用aop标签的时候，这个aop标签是在哪里解析的呢，例如看下面的例子：
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop"    
  5.     xsi:schemaLocation="  
  6.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
  7.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd  ">  
  8.           
  9.     <aop:aspectj-autoproxy/>    
  10.     <bean name="purchaseService"   class="net.itaem.aop.PurchaseService" />  
  11.     <bean name="purchaseService2"   class="net.itaem.aop.fPurchaseService2" />  
  12.     <bean class="net.itaem.aop.LogAspect"/>      
  13. </beans>  
其中schemaLocation有包含http://www.springframework.org/schema/aop这个地址，我们可以在这里找到
我们可以看到，它对应着一个类的路径，是AopNamespaceHandler，着代表着aop的实现是经过这个处理器实现的。

XSD文件位置

我们可以看到在xsi:schemaLocation里面http://www.springframework.org/schema/aop 后面还跟着http://www.springframework.org/schema/aop/spring-aop-3.2.xsd，这个xsd文件代表着aop标签的定义以及解析校验规范都是在这里定义的。那么是不是要去这个网址http://www.springframework.org/schema/aop/spring-aop-3.2.xsd下载呢，让我们先看看下面这个截图：



从中可以看到http://www.springframework.org/schema/aop/spring-aop-3.2.xsd对应着一个路径，在这个路径我们可以找到对应的xsd文件，所以，在解析该标签的时候spring会更具schemas文件下面对应的路径去找这个校验文件，如果实在是没有找到的话它才回去网上下载然后再执行校验。


确定XML的解析模式


spring的配置文件已经写好了，spring启动的时候，它究竟是如何确定spring使用的是哪种xml验证模式呢，是DTD还是XSD，下面我们先通过时序图看看spring在判断验证模式的实现


图1

绕了那么多个方法，我们终于看到获取xml验证模式的获取了，是不是觉得很蛋疼，说实话，要不是画了时序图我也不知道这绕了那么远。好了，让我们先看看它的核心实现代码吧
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1.     protected int getValidationModeForResource(Resource resource) {  
  2.         int validationModeToUse = getValidationMode();  
  3. //如果是手动指定了验证模式，那么就使用手动指定的验证模式  
  4.         if (validationModeToUse != VALIDATION_AUTO) {  
  5.             return validationModeToUse;  
  6.         }  
  7. //如果未指定，那么就自动检测验证模式  
  8.         int detectedMode = detectValidationMode(resource);  
  9.         if (detectedMode != VALIDATION_AUTO) {  
  10.             return detectedMode;  
  11.         }  
  12.         // Hmm, we didn't get a clear indication... Let's assume XSD,  
  13.         // since apparently no DTD declaration has been found up until  
  14.         // detection stopped (before finding the document's root tag).  
  15.         return VALIDATION_XSD;  
  16.     }  
一般的话，我们是不会手动去指定spring的验证模式的，所以的话通常是spring自动检测xml的验证模式，那么通过什么检测，怎么实现呢，detectValidationMode方法是怎么判断的呢，其实判断很简单，就是判断xml文件开始时候的定义是否包含文档类型定义（doctype），如果包含，那么就是dtd的文档验证模式，如果不包含，那么就是xsd的验证模式。


加载xml文档

确定好，文档的解析模式后，下面的话便调用loadDocument方法对xml文档进行加载。对于xml文档的加载spring采用的还是javax.xml.parsers.DocumentBuilderFactory下面的DocumentBuilder去解析inputsource，返回document对象。
那么解析的时候是怎么获取验证文件的呢。在文章的前面有说过如果本地有验证文件那么就从本地获取验证文件，如果本地没有验证文件才去网上下载验证文件，那么这是怎么实现的呢？
其实这关键就在于EntityResolver这个类。何为EntityResolver，官方是这样解释的：如果SAX应用程序需要实现自定义处理外部尸体，则必须实现此接口并使用setEntityResolver方法向SAX驱动器注册一个实例，也就是说对于解析一个xmlSAX首先读取该XML文档的声明，根据声明去找相应的DTD或者XSD定义，然后根据DTD或者XSD对文档进行一个验证。
在spring里面用DelegatingEntityResolver实现了EntityResolver类，并在解析的时候会根据要获取的解析文件URL先去本地找对应的验证文件，DTD文件是在当前路径下去找，XSD文件统一是从META-INF/Spring.schemas文件中去找对应的本都验证文件。


解析并注册BeanDefinitions

让我们继续doLoadBeanDefinitions方法的执行，先看看解析注册beandefinitions的时序图

图2

1）spring有4种不同的默认标签，分别是import，alias，bean，beans，这四种标签的解析统一是由parseDefaultElement方法完成。
2）自定义的标签，像aop标签，是由parseCustomElement方法完成的。


默认标签解析

让我们来先看看spring是如何解析默认的标签的，先看parseDefaultElement方法的内容：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {  
  2.         //对import标签的解析  
  3.         if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {  
  4.             importBeanDefinitionResource(ele);  
  5.         }  
  6.         //对alias标签的解析  
  7.         else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {  
  8.             processAliasRegistration(ele);  
  9.         }  
  10.         //对bean标签的解析  
  11.         else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {  
  12.             processBeanDefinition(ele, delegate);  
  13.         }  
  14.         //对beans标签的解析  
  15.         else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {  
  16.             // recurse  
  17.             doRegisterBeanDefinitions(ele);  
  18.         }  
  19.     }  

从上面可以看大parseDefaultElement方法包含了spring 4中不同的默认标签的解析入口，针对这4种标签的解析大同小异，但是其中最复杂的应该属bean标签，因为他的属性最多，所逻辑也就比较复杂一点，下面我们通过bean标签的解析流程来看看spring是如何解析默认标签的。
先上DefaultBeanDefinitionDocumentReader类的processBeanDefinition方法：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * Process the given bean element, parsing the bean definition 
  3.      * and registering it with the registry. 
  4.      */  
  5.     protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {  
  6.         BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  
  7.         if (bdHolder != null) {  
  8.             bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);  
  9.             try {  
  10.                 // Register the final decorated instance.  
  11.                 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());  
  12.             }  
  13.             catch (BeanDefinitionStoreException ex) {  
  14.                 getReaderContext().error("Failed to register bean definition with name '" +  
  15.                         bdHolder.getBeanName() + "'", ele, ex);  
  16.             }  
  17.             // Send registration event.  
  18.             getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));  
  19.         }  
  20.     }  
1）首先委托BeanDefinitionParserDelegate类的parseBeanDefinitionElement方法进行元素解析，返回BeanDefinitionHolder类型的示例bdHolder，经过这个方法后，bdHolder示例已经包含我们配置文件中配置的各个属性了，如class、name、id、alias之类的属性。
2）当返回的bdHolder不为空的情况下，若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析，也就是调用decorateBeanDefinitionIfRequired方法
3）解析完成后，需要对解析之后的bdHolder进行注册，同样，注册操作委托给了BeanDefinitionReaderUtils的registerBeanDefinition方法。
4）最后发出响应事件，通知相关的监听器，这个bean已经加载完成了。


下面让我看看parseBeanDefinitionElement方法的实现：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Parses the supplied {@code <bean>} element. May return {@code null} 
  3.  * if there were errors during parse. Errors are reported to the 
  4.  * {@link org.springframework.beans.factory.parsing.ProblemReporter}. 
  5.  */  
  6. public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {  
  7.     //获取id属性  
  8.     id = ele.getAttribute(ID_ATTRIBUTE);  
  9.     //获取name属性  
  10.     String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  
  11.     //分割name属性  
  12.     List<String> aliases = new ArrayList<String>();  
  13.     if (StringUtils.hasLength(nameAttr)) {  
  14.         String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);  
  15.         aliases.addAll(Arrays.asList(nameArr));  
  16.     }  
  17.   
  18.     String beanName = id;  
  19.     if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {  
  20.         beanName = aliases.remove(0);  
  21.         if (logger.isDebugEnabled()) {  
  22.             logger.debug("No XML 'id' specified - using '" + beanName +  
  23.                     "' as bean name and " + aliases + " as aliases");  
  24.         }  
  25.     }  
  26.   
  27.     if (containingBean == null) {  
  28.         checkNameUniqueness(beanName, aliases, ele);  
  29.     }  
  30.     //解析bean的属性和元素，并分装成GeneicBeanDefinition中(GeneicBeanDefinition是AbstractBeanDefinition实现类)  
  31.     AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);  
  32.     if (beanDefinition != null) {  
  33.         if (!StringUtils.hasText(beanName)) {  
  34.         //如果不存在beanName，则使用默认的规则创建beanName  
  35.             try {  
  36.                 if (containingBean != null) {  
  37.                     beanName = BeanDefinitionReaderUtils.generateBeanName(  
  38.                             beanDefinition, this.readerContext.getRegistry(), true);  
  39.                 }  
  40.                 else {  
  41.                     beanName = this.readerContext.generateBeanName(beanDefinition);  
  42.                     // Register an alias for the plain bean class name, if still possible,  
  43.                     // if the generator returned the class name plus a suffix.  
  44.                     // This is expected for Spring 1.2/2.0 backwards compatibility.  
  45.                     String beanClassName = beanDefinition.getBeanClassName();  
  46.                     if (beanClassName != null &&  
  47.                             beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&  
  48.                             !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {  
  49.                         aliases.add(beanClassName);  
  50.                     }  
  51.                 }  
  52.                 if (logger.isDebugEnabled()) {  
  53.                     logger.debug("Neither XML 'id' nor 'name' specified - " +  
  54.                             "using generated bean name [" + beanName + "]");  
  55.                 }  
  56.             }  
  57.             catch (Exception ex) {  
  58.                 error(ex.getMessage(), ele);  
  59.                 return null;  
  60.             }  
  61.         }  
  62.         String[] aliasesArray = StringUtils.toStringArray(aliases);  
  63.         return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);  
  64.     }  
  65.   
  66.     return null;  
  67. }  

解析的核心逻辑由parseBeanDefinitionElement方法实现，让我们看看parseBeanDefinitionElement方法到底为我们做了哪些操作。
1）提取元素中的id和name属性
2）进一步解析bean中其他所有的属性，这些属性包含scope、singleton、abstract、lazy-init、autowire、dependency-check、depends-on、autowire-candidate、primary、init-method、destroy-method、factory-method、factory-bean。并且解析bean下面所有的元素，其中包含：meta、lookup-method、replace-method、constructor-arg、property、qualifier。解析完成这些属性和元素之后（元素和属性很多，所以这是一个庞大的工作量），统一封装到GeneicBeanDefinition类型的实例中。
3）如果检测到bean没有指定的beanName，那么便使用默认的规则为bean生成一个beanName。
4）将获取到的信息封装到BeanDeinitionHolder里面去。

自定义标签的解析

关于自定义标签的解析流程的话我的博客也有介绍，这里就不重复介绍了，想温习一下的朋友可以去看看，spring源码剖析（四）自定义标签解析流程。


注册BeanDefinition

让我们回到processBeanDefinition方法，找到beanDefinition的注册的方法BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());让我们来看看里面的详细实现：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Register the given bean definition with the given bean factory. 
  3.  * @param definitionHolder the bean definition including name and aliases 
  4.  * @param registry the bean factory to register with 
  5.  * @throws BeanDefinitionStoreException if registration failed 
  6.  */  
  7. public static void registerBeanDefinition(  
  8.         BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)  
  9.         throws BeanDefinitionStoreException {   
  10.   
  11.     // Register bean definition under primary name.  
  12.     String beanName = definitionHolder.getBeanName();  
  13.     registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());  
  14.   
  15.     // Register aliases for bean name, if any.  
  16.     String[] aliases = definitionHolder.getAliases();  
  17.     if (aliases != null) {  
  18.         for (String aliase : aliases) {  
  19.             registry.registerAlias(beanName, aliase);  
  20.         }  
  21.     }  
  22. }  

通过上面可以看出，解完之后的beandefinition都会被注册到BeanDefinitionRegistry里面去，其中BeanDefinition的注册分两部分，一种是通过beanName注册，一种是通过别名aliase注册。

通过beanName注册BeanDefinition

通过beanName注册BeanDefinition Spring究竟做了哪些事情呢，让我们来看看：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. //---------------------------------------------------------------------  
  2. // Implementation of BeanDefinitionRegistry interface  
  3. //---------------------------------------------------------------------  
  4.   
  5. public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
  6.         throws BeanDefinitionStoreException {  
  7.   
  8.     Assert.hasText(beanName, "Bean name must not be empty");  
  9.     Assert.notNull(beanDefinition, "BeanDefinition must not be null");  
  10.   
  11.     if (beanDefinition instanceof AbstractBeanDefinition) {  
  12.         try {  
  13.             ((AbstractBeanDefinition) beanDefinition).validate();  
  14.         }  
  15.         catch (BeanDefinitionValidationException ex) {  
  16.             throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,  
  17.                     "Validation of bean definition failed", ex);  
  18.         }  
  19.     }  
  20.   
  21.     BeanDefinition oldBeanDefinition;  
  22.   
  23.     synchronized (this.beanDefinitionMap) {  
  24.         oldBeanDefinition = this.beanDefinitionMap.get(beanName);  
  25.         if (oldBeanDefinition != null) {  
  26.             if (!this.allowBeanDefinitionOverriding) {  
  27.                 throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,  
  28.                         "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +  
  29.                         "': There is already [" + oldBeanDefinition + "] bound.");  
  30.             }  
  31.             else {  
  32.                 if (this.logger.isInfoEnabled()) {  
  33.                     this.logger.info("Overriding bean definition for bean '" + beanName +  
  34.                             "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");  
  35.                 }  
  36.             }  
  37.         }  
  38.         else {  
  39.             this.beanDefinitionNames.add(beanName);  
  40.             this.frozenBeanDefinitionNames = null;  
  41.         }  
  42.         this.beanDefinitionMap.put(beanName, beanDefinition);  
  43.     }  
  44.   
  45.     if (oldBeanDefinition != null || containsSingleton(beanName)) {  
  46.         resetBeanDefinition(beanName);  
  47.     }  
  48. }  

1）对AbstractBeanDefinition进行校验。在解析XML文件的时候我们进行过校验，之前是对XML格式的校验，现在做的校验是对AbstractBeanDefinition的MethodOverrides的校验
2）对beanName已经注册的情况做处理，如果设置了不允许覆盖bean，那么会直接抛出异常，否则是直接覆盖
3）加入map缓存
4）清楚解析之前留下的beanName的缓存。

通过别名alias注册BeanDefinition

首先我们看具体的代码实现：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. public void registerAlias(String name, String alias) {  
  2.         Assert.hasText(name, "'name' must not be empty");  
  3.         Assert.hasText(alias, "'alias' must not be empty");  
  4.         if (alias.equals(name)) {  
  5.             this.aliasMap.remove(alias);  
  6.         }  
  7.         else {  
  8.             if (!allowAliasOverriding()) {  
  9.                 String registeredName = this.aliasMap.get(alias);  
  10.                 if (registeredName != null && !registeredName.equals(name)) {  
  11.                     throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +  
  12.                             name + "': It is already registered for name '" + registeredName + "'.");  
  13.                 }  
  14.             }  
  15.             checkForAliasCircle(name, alias);  
  16.             this.aliasMap.put(alias, name);  
  17.         }  
  18.     }  

1）alias和beanName名字一样的情况处理，如果是名字一样，那么直接删除别名。
2）alias覆盖处理。若aliasName已经指向了另一beanName则需要用户的设置进行处理。
3）alias循环检查。当A->B存在时候，如果出现了A->C->B那么直接抛出异常。
4）注册alias


通知监听器解析注册已完成

让我们回顾下processBeanDefinition方法，里面有说到，当bean注册完成之后便会调用getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));这里便提供了途径给开发人员对bean完成注册之后进行相应的拓展，目前Spring里面是空实现。


总结

上面只对spring的bean标签的解析做了说明，其他的默认标签，像import，alias，beans标签，其实解析的方式大同小异，如果想探个究竟的朋友也可以跟着程序源代码走上几遍。
spring默认的标签的解析及注册的大体逻辑就这样，其实认真阅读过源码的同学，很容易理解里面的逻辑，看起来复杂，其实也不是很难，不过有一点可以认同的是，spring的源代码写的的确很严谨，值得我们去学习。
0 0
js实现tab切换 js实现tab切换
原创粉丝点击
热门IT博客
跟阿铭学linux pdf跟阿铭学linux pdf
毛丝鼠淘宝毛丝鼠淘宝
字体管家mac版
苹果看视频软件
sql语句大全举例alter
齐鲁石化网络电视台
托福网站数据维护
经济数据公布时间表
彩票预测软件下载
ubuntu php 环境变量
淘宝上ios充值的原理
mac怎么增加桌面窗口
能透视的软件
国际域名和国别域名
linux创建json文件
js window事件绑定
网络舆情监测
工作证在线制作软件
豫品软件
java如何 私有构造方法
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 文登房产 文登房子 文登信息港招聘 文登招聘信息 文登南海新区 文登骨科医院 文登旅游景点大全 文登到济南火车时刻表 文登集市时间表2019 文登中心医院 文登火车时刻表 文登汽车站电话 杭州文登考研 文登信息港招聘信息 2018文登附近招聘临时工信息 文登南海新区房地产 天津文登考研 文登属于哪个市 文登信息之窗 去皱文的好方法 文盛 文盲 假文盲300字 穿书之文盲女配逆袭记 文盲是什么意思 穿书之文盲女配逆袭记 小冬叶 文盲怎么考驾照 大塔防时代 文盲哥 假文盲作文200字 半文盲是什么学历 易碎品文盲土拨鼠 六年级作文假文盲400字 穿成民国文豪的文盲妻 穿成民国文豪的文盲妻子 这个女婿会修真 文盲小书童 六年级下册语文作文假文盲 文睿 文祥 文秀 文秀书记 文种

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里