随笔-295  评论-26  文章-1  trackbacks-0
Spring2.0 可扩展XML配置初探
2007-07-18 Spring的事务通知   

Spring2.0 可扩展XML配置初探

关键字: Spring       

Spring 2.0版本支持扩展XML配置，着实兴奋了一下，在我看来，Spring作为目前最流行的框架，不能扩展用户自定义的配置，实在是Spring的一个很不爽的地方，<bean />的方式用起来比较通用，起码到目前为止符合大部分人的使用习惯，并且能完成Spring所有的配置操作,但是对于第三方的提供商或则会经常扩展Spring功能的开发者来说,使用<bean />这样的配置方式或许不是他们最想要的，他们需要使组件的配置更加直观、易阅读、易扩展……试想使用下面的配置方式

代码
  1. <mytag:datasource id= "datasource"     
  2.        databaseType= "oracle"     
  3.        ip= "192.168.1.110"     
  4.        port= "1521"     
  5.        databaseName= "myDB"   
  6.        userName= "admin"   
  7.        password= "password"   
  8.        />   
  9.   
  10. <mytag:ehCache id= "ehcache"     
  11.        cache= "true"     
  12.        maxElements= "100000"     
  13.        timeToIdleSeconds= "120"     
  14.        timeToLiveSeconds= "120"   
  15.        overflowToDisk= "true"   
  16.        />   

上面的代码中配置了两个组件，datasource和cache组件，相比普通的bean&propertiy方式,很显然，这种配置方式更直观，更易读，更重要的是，如果作为组件发布，使用者也可以很方便快捷的开始使用，而不需要关心组件的任何实现细节。

扩展XML配置大致需要一下几个步骤
1、创建一个需要扩展的组件
2、定义一个xsd文件描述组件内容
3、创建一个文件，实现BeanDefinitionParser接口，用来解析xsd文件中的定义和组件定义
4、创建一个Handler文件，扩展自NamespaceHandlerSupport，目的是将组件注册到Spring容器
5、编写spring.handlers和spring.schemas文件

提供一个简单的例子，来说明如何去扩展一个Spring配置，需求如下：使用自定义标签定义一个简单的bean，这个bean有一个或多个属性，标签定义完成后，可以在其他项目中用自定义标签来定义该bean。

首先，创建一个需要扩展的组件，在这里只是一个简单的bean，而且这个bean只有一个属性age.
One.java

代码
  1. package com.mysite.tag;   
  2.   
  3. public class One {   
  4.     private String age;   
  5.        
  6.     public One(){   
  7.            
  8.     }   
  9.   
  10.     public String getAge() {   
  11.         return age;   
  12.     }   
  13.   
  14.     public void setAge(String age) {   
  15.         this.age = age;   
  16.     }   
  17. }   

然后，建立一个xsd文件，来描述这个bean
mytag.xsd

代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <xsd:schema xmlns="http://www.mysite.org/schema/mytag"  
  3.         xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
  4.         xmlns:beans="http://www.springframework.org/schema/beans"  
  5.         targetNamespace="http://www.mysite.org/schema/mytag"  
  6.         elementFormDefault="qualified"  
  7.         attributeFormDefault="unqualified">  
  8.        
  9.     <xsd:import namespace="http://www.springframework.org/schema/beans"/>  
  10.        
  11.     <xsd:element name="one">  
  12.         <xsd:complexType>  
  13.             <xsd:complexContent>  
  14.                 <xsd:extension base="beans:identifiedType">  
  15.                     <xsd:attribute name="age" type="xsd:string" default="99999"/>  
  16.                 </xsd:extension>  
  17.             </xsd:complexContent>  
  18.         </xsd:complexType>  
  19.     </xsd:element>  
  20. </xsd:schema>  

在上面的xsd文件描述了一个新的targetNamespace，并在这个空间中定义了一个name为one的element,one有一个age属性，类型为string，默认值为99999.xsd文件是xml DTD的替代者，使用XML Schema语言进行编写，这里对xsd schema不做太多解释，有兴趣可以参考相关的资料。

创建一个Java文件，该文件实现了BeanDefinitionParser接口，用来解析xsd文件中的定义并注册到组件中。
MyBeanDefinitionParser.java

代码
  1. package com.mysite.tag;   
  2.   
  3. import org.springframework.beans.factory.config.BeanDefinition;   
  4. import org.springframework.beans.factory.config.BeanDefinitionHolder;   
  5. import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;   
  6. import org.springframework.beans.factory.support.RootBeanDefinition;   
  7. import org.springframework.beans.factory.xml.BeanDefinitionParser;   
  8. import org.springframework.beans.factory.xml.ParserContext;   
  9. import org.w3c.dom.Element;   
  10.   
  11. public class MyBeanDefinitionParser implements BeanDefinitionParser{   
  12.     public BeanDefinition parse(Element arg0, ParserContext arg1) {   
  13.         RootBeanDefinition def = new RootBeanDefinition();   
  14.                 //设置Bean Class   
  15.         def.setBeanClass(One.class);   
  16.            
  17.                 //注册ID属性   
  18.         String id = arg0.getAttribute("id");   
  19.         BeanDefinitionHolder idHolder= new BeanDefinitionHolder(def,id);   
  20.         BeanDefinitionReaderUtils.registerBeanDefinition(idHolder, arg1.getRegistry());   
  21.            
  22.                 //注册age属性   
  23.         String age = arg0.getAttribute("age");   
  24.         BeanDefinitionHolder ageHolder= new BeanDefinitionHolder(def,age);   
  25.         BeanDefinitionReaderUtils.registerBeanDefinition(ageHolder, arg1.getRegistry());   
  26.         def.getPropertyValues().addPropertyValue("age", age);   
  27.            
  28.         return def;   
  29.     }   
  30. }   
  31.   

上面的代码仅仅实现了一个方法public BeanDefinition parse(Element arg0, ParserContext arg1)，设置相关的Bean Class，解析了对应的xsd文件，并将解析的内容注册到上下文中，同时返回一个BeanDefinition对象（BeanDefinition是Spring的bean定义，提供了bean部分的操作方法，如isSingleton()、isLazyInit()等)。

注意，id属性是一个默认的属性，可以不在xsd文件中描述，但是需要注册它，否则将无法通过getBean方法获取标签定义的bean，也无法被其他bean引用。
另外，下面代码是给bean的属性赋值，这个是不可缺少的，否则在使用标签定义时将无法获取bean属性的值。

代码
  1. def.getPropertyValues().addPropertyValue("age", age);   

然后为组件编写一个Handler文件，扩展自NamespaceHandlerSupport，它的作用是将组件注册到Spring容器
MyNameSpaceHandler.java

代码
  1. package com.mysite.tag;   
  2.   
  3. import org.springframework.beans.factory.xml.NamespaceHandlerSupport;   
  4.   
  5. public class MyNameSpaceHandler extends NamespaceHandlerSupport {   
  6.   
  7.     public void init() {   
  8.          registerBeanDefinitionParser("one",new MyBeanDefinitionParser());   
  9.     }   
  10. }   

实际执行的过程只有一句代码，注册了一个名字为one的扩展配置，包含了MyBeanDefinitionParser所parser相关xsd的内容。

到了这里，一个Spring扩展标签已经完成，但是我们目前还没办法使用它，Spring没那么聪明，它无法知道我们在什么地方定义了哪些扩展标签，这些标签将被谁解析，这个过程要我们通过一些文件来告知Spring知道，它们就是spring.handlers和spring.schemas，它们放在META-INF目录中，Spring.jar的META-INF目录中也有同名的文件，它们的文件内容基本上是相似的，而Spring在执行过程中，如果发现其他jar文件的META-INF文件夹中包含有这两个文件，Spring将会合并它们。
spring.schemas

代码
  1. http\://www.mysite.org/schema/mytag.xsd=com/mysite/tag/mytag.xsd   

spring.handlers

代码
  1. http\://www.mysite.org/schema/mytag=com.mysite.tag.MyNameSpaceHandler   

spring.schemas将告诉Spring配置文件知道，如果在配置中引用http://www.mysite.org/schema/mytag.xsd，它应该去什么地方找相应的xsd文件。
而spring.handlers文件将告诉Spring，应该使用哪个Handler注册扩展标签。

现在为止，一个完整的xml扩展标签全部完成，做一个小应用测试一下。
将整个项目打包成jar文件（别忘记META-INF内的两个文件），然后新建一个项目，引用刚才打包的jar文件，并引用Spring相关文件。
需要注意,自定义xml扩展配置只有xsd方式的引用才可以使用.
application.xml

代码
  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:tag="http://www.mysite.org/schema/mytag"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
  6.     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd   
  7.     http://www.mysite.org/schema/mytag   
  8.     http://www.mysite.org/schema/mytag.xsd">  
  9.   
  10.     <tag:one id="oneBean" age="99"/>  
  11. </beans>  

在xml文件引用上可以看到,配置了一个名字为tag的名称空间,目标为http://www.mysite.org/schema/mytag命名空间,这个目标名称空间必须是存在于项目的引用中的(mytag.xsd中所定义的).
代码
  1. <tag:one id="oneBean" age="99"/>   

上面定义了一个id为oneBean的组件，使用了“one”扩展标签，也就是我们在handler中所注册的，组件age属性的值为99。

Main.java

代码
  1. package com.test;   
  2.   
  3. import org.springframework.context.ApplicationContext;   
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  5.   
  6. import com.mysite.tag.One;   
  7.   
  8. public class Main {   
  9.   
  10.     public static void main(String[] args) {   
  11.         ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");   
  12.         One tag = (One) ctx.getBean("oneBean");   
  13.         System.out.println("oneBean age is "+tag.getAge());   
  14.     }   
  15. }   

运行测试程序，结果如下
代码
  1. oneBean age is 99  

Spring的xml扩展是一个非常有用的特性，在Spring2.0的版本中也提供了一些新的标签使用，如<aop>,<tx>等,但就目前来讲受大家关注程度并不高，我想大部分使用Spring的开发人员都在使用Spring开发企业应用，而Spring所提供的<bean />定义的方式对于开发人员来说已经能够满足需要，但是如果看的更远一些，在Spring以后的发展过程中，xml扩展应该会成为spring的核心特性之一，或许到时大家会习惯这样的方式来编写Spring配置文件吧

代码
  1. <XXCompany:XXXModule id="">   
  2. ...   
  3. ...   
最后更新：2007-07-18 16:03
15:42  |   永久链接  |   浏览 (481)  |   评论 (2)  |    收藏  |   进入论坛  |  
评论    共 2 条 发表评论
baallee     2007-07-18 15:53

代码
  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:p = "http://www.springframework.org/schema/p"        
  5. xsi:schemaLocation ="http://www.springframework.org/schema/beans           
  6. http://www.springframework.org/schema/beans/spring-beans.xsd" >      
  7. < bean   class = "com.interface21.spring2.ioc.Person"         
  8. p:name = "Tony"        
  9. p:age = "53"         
  10. p:house-ref = "number10"   />       
  11. < bean   class = "com.interface21.spring2.ioc.House"         
  12. id = "number10"        
  13. p:name = "10 Downing Street" />      
  14. </ beans >   

对于简单的应用可以用p标签就好了。
自定意扩展应该用在更多的高级应用上


大盘预测 国富论
posted on 2007-08-29 15:08 华梦行 阅读(247) 评论(0)  编辑  收藏 所属分类: Spring

只有注册用户登录后才能发表评论。
网站导航:
 
Powered by: 博客园 模板提供：沪江博客 Copyright ©2024 华梦行