XMLBEANS使用总结

  1. 在本文中,我们将详细了解最好的数据对象XMLBean。从传统角度来说,在Java应用程序中使用XML,就是在从 XML文档向Java导入数据的技术或从数据模型层向XML导出数据技术之间架起了一座桥梁。对于这种方法,Java通常是作为传统数据存储(RDBMS)和文档之间的中间表示来使用的。本文将研究这种方法的局限性,并介绍另一种选择,即克服了这些局限性的XMLBean,同时也分析了一些 XMLBean的实际应用。  
  2.  
  3. 现有Java/XML解决方案的主要局限性在于,使用XML导致了在开发中的额外开销。也许XML最强大的功能就是可以使数据以一种结构化的、容易阅读的文档进行传递。实际上,这种功能会引起Web服务的增殖;为了提供某种服务,供应商必须接受某种可读的文档,而不是定义一种自定义的二进制数据格式。对开发者来说,这通常意味着要用XML分析器来提取相关的部分,把它们转化成Java的表示,然后通过系统使用这些Java对象。难以置信的是,实际上Java中许多服务的实现并没有使用XML分析器,而是分析了传入的HTTPInputStream并使用了 StringTokenizer或此类方法来提取数据。  
  4.  
  5. 在导出端,当一项新业务需要向其他客户端导出数据时,XML通常是候补方法。在这种情况下,最常见的方法就是自由地使用System.out.println()。如果幸运的话,可以使用像Velocity之类的模板工具。  
  6.  
  7. 除了开发的系统开销外,用这种方法处理XML还容易犯错误。即使确实存在表示XML数据的XML架构,那么开发者也不一定会得到类型安全(type-safe)数据所带来的好处,因为使用导入导出方法时,只有当XML数据进入或离开系统时才会应用有效性检验。因此,当开发者可能会选择使用XML架构时,XML有效性检验只对该文档有效;对Java对象来说,开发者必须在setter方法中手动创建前置条件(pre condition)和后置条件(post condition)来检验数据。  
  8.  
  9. 处理XML所带来的开发开销和数据有效性检验的困难一起产生了第三个困难:数据的表示不可能改变。当业务需求变化时,使用导入和导出方法所带来的实现就不够灵活,以至跟不上这些变化。修改架构会导致对语法分析代码、XML生成代码和有效性检验代码进行重构,而这些代码可能分散在系统的许多Java对象中。  
  10.  
  11. 这里有更好的解决方案。XMLBean通过把Java和XML作为整体来克服了这些困难。通过利用XML Schema的功能来提供结构化和约束性数据类型,开发者可以像Java对象那样直接访问XML文档。通过使用XMLBean,Java开发者不需要花时间来编写导入/导出和有效性检验代码。相反,XML文档被视作以类似于Java-Bean 的方式访问的最好的数据对象。  
  12.  
  13. 除了消除了 "粘合" 的代码和手动的数据有效性检验这些优点外,XMLBean在设计时的另一个优点是,它提供了拥有可执行规范的能力。XMLBean提供了在架构和Java类型系统间的自动映射。对开发者来说,这意味着设计不需要转化成Java的实现。数据模型或对象的设计完全可以在架构规范中完成;XMLBean自动地把架构类型和它们之间的关系转换成Java对象及其关系。这样当Java应用程序接收到遵守给定架构的XML文档时,XMLBean创建相应的Java实例,实例是直接在底层文档上创建的,因而原文档不会有任何损失。当Java实例被修改,XMLBean修改文档以保持二者的同步。因此,Java对象和XML 文档是相同的。  
  14.  
  15.  
  16. 为了强调XMLBean的实用性,有必要看一些XMLBean真正发挥作用的实例:  
  17.  
  18. 持久性:几乎所有的应用程序都把用户或应用程序的数据存储在某些文件里,这些内容通常存在于XML之中。XMLBean可以使您不需要手动创建Java对象来表示文件内容就可以处理这些文件。   
  19. 通讯:优秀的面向服务的体系结构从系统内部提取出数据,并通过在Web服务之间传递的XML文档来表示业务状态。通过XMLBean 和WebLogic Web服务堆栈,Java开发者可以通过Java接口、由成为XMLBean实例的服务使用的XML文档来与服务通讯。   
  20. 更好的数据转换对象(DTO):DTO在J2EE应用程序中被广泛使用,通过Session Fa?0?4ade 提供了对实体bean 的粗粒度访问。DTO表示了实体集合状态的快照。在XMLBean出现之前,Java对象和它们的内容必须通过手动检验有效性来创建。现在有了XMLBean,可以只通过编写XML架构就可创建具有固有的有效性检验的DTO。   
  21.  
  22. 这些示例表明,XMLBean是真正的下一代Java数据对象。通过高性能、开放源代码的实现,XMLBean克服了将XML和 Java一起使用的传统困难,此外,它还提供了有效性检验和可执行规范的功能。最后,通过保持XML文档和Java对象的同步,XMLBean提供了面向服务开发所需的Java和XML的结合。  
  23.  
  24. 利用XMLBean轻轻松松读写XML  
  25.  
  26. 一、关于XML解析  
  27.  
  28.   XML在Java应用程序里变得越来越重要, 广泛应用于数据存储和交换. 比如我们常见的配置文件,都是以XML方式存储的. XML还应用于Java Message Service和Web Services等技术作为数据交换.因此,正确读写XML文档是XML应用的基础.  
  29.  
  30.   Java提供了SAX和DOM两种方式用于解析XML,但即便如此,要读写一个稍微复杂的XML,也不是一件容易的事.  
  31.  
  32.   二、XMLBean简介  
  33.  
  34.   Hibernate已经成为目前流行的面向Java环境的对象/关系数据库映射工具.在Hibernate等对象/关系数据库映射工具出现之前,对数据库的操作是通过JDBC来实现的,对数据库的任何操作,开发人员都要自己写SQL语句来实现. 对象/关系数据库映射工具出现后, 对数据库的操作转成对JavaBean的操作,极大方便了数据库开发. 所以如果有一个类似的工具能够实现将对XML的读写转成对JavaBean的操作,将会简化XML的读写,即使对XML不熟悉的开发人员也能方便地读写XML. 这个工具就是XMLBean.  
  35.  
  36.   三、准备XMLBean和XML文档  
  37.  
  38.   XMLBean是Apache的一个开源项目,可以从http: //www.apache.org下载,最新的版本是2.0. 解压后目录如下:  
  39.  
  40. xmlbean2. 0.0  
  41.      +---bin  
  42.      +---docs  
  43.      +---lib  
  44.      +---samples  
  45.      +---schemas  
  46.  
  47.   另外还要准备一个XML文档(customers.xml),  
  48.  
  49.   在本文的例子里,我们将对这个文档进行读写操作. 文档源码如下:  
  50.  
  51. "1.0" encoding= "UTF-8" ?>  
  52.   
  53.       
  54.             1   
  55.             female  
  56.             Jessica  
  57.             Lim  
  58.             1234567   
  59.            
      
  60.                   
  61.                         350106   
  62.                         # 25 - 1   
  63.                         SHINSAYAMA 2 -CHOME  
  64.                   
  65.                   
  66.                         Ms Danielle  
  67.                         350107   
  68.                         # 167   
  69.                         NORTH TOWER HARBOUR CITY  
  70.                   
  71.               
  72.       
  73.       
  74.             2   
  75.             male  
  76.             David  
  77.             Bill  
  78.             808182   
  79.            
      
  80.                   
  81.                         319087   
  82.                         1033 WS St.  
  83.                         Tima Road  
  84.                   
  85.                   
  86.                         Mr William  
  87.                         672993   
  88.                         1033 WS St.  
  89.                         Tima Road  
  90.                   
  91.               
  92.       
  93.   
  94.  
  95.   这是一个客户的数据模型,每个客户都有客户编号(ID),姓名,性别(gender),电话号码(phoneNumber)和地址,其中地址有两个: 首要地址(PrimaryAddress)和帐单地址(BillingAddress),每个地址有邮编,地址 1 ,和地址 2 组成.其中帐单地址还有收件人(receiver).此外,还要准备一个配置文件(文件名customer.xsdconfig),这个文件的作用我后面会讲,它的内容如下:  
  96.  
  97. "http://xml.apache.org/xmlbeans/2004/02/xbean/config" >  
  98.  
  99.     
  100.     package >sample.xmlbean package >  
  101.     
  102.  
  103.   
  104.  
  105.   四、XMLBean使用步骤  
  106.  
  107.   和其他面向Java环境的对象/关系数据库映射工具的使用步骤一样,在正式使用XMLBean前,我们要作两个准备.  
  108.  
  109.    1 . 生成XML Schema文件  
  110.  
  111.   什么是XML Schema文件? 正常情况下,每个XML文件都有一个Schema文件,XML Schema文件是一个 XML的约束文件,它定义了XML文件的结构和元素.以及对元素和结构的约束. 通俗地讲,如果说XML文件是数据库里的记录,那么Schema就是表结构定义.  
  112.  
  113.   为什么需要这个文件? XMLBean需要通过这个文件知道一个XML文件的结构以及约束,比如数据类型等. 利用这个 Schema文件,XMLBean将会产生一系列相关的Java Classes来实现对XML的操作. 而作为开发人员,则是利用XMLBean产生的 Java Classes来完成对XML的操作而不需要SAX或DOM.怎样产生这个Schema文件呢? 如果对于熟悉XML的开发人员,可以自己来写这个Schema文件,对于不熟悉XML的开发人员,可以通过一些工具来完成.比较有名的如XMLSPY和Stylus Studio都可以通过XML文件来生成Schema文件. 加入我们已经生成这个Schema文件(customer.xsd):  
  114.  
  115.        "1.0" encoding= "UTF-8" ?>  
  116.        "http://www.w3.org/2001/XMLSchema"  
  117.                   elementFormDefault= "qualified" >  
  118.          "Customers" >  
  119.              
  120.                
  121.                "unbounded" name= "customer"  
  122.                            type= "customerType" />  
  123.                
  124.              
  125.            
  126.        "customerType" >  
  127.                
  128.                "id" type= "xs:int" />  
  129.                "gender" type= "xs:string" />  
  130.                "firstname" type= "xs:string" />  
  131.                "lastname" type= "xs:string" />  
  132.                "phoneNumber" type= "xs:string" />  
  133.                "address" type= "addressType" />  
  134.                
  135.          
  136.          "addressType" >  
  137.                
  138.                "primaryAddress" type= "primaryAddressType" />  
  139.                "billingAddress" type= "billingAddressType" />  
  140.                
  141.            
  142.  
  143.    "primaryAddressType" >  
  144.                
  145.                "postalCode" type= "xs:string" />  
  146.                "addressLine1" type= "xs:string" />  
  147.                "addressLine2" type= "xs:string" />  
  148.                
  149.            
  150.          "billingAddressType" >  
  151.                
  152.                    "receiver" type= "xs:string" />  
  153.                "postalCode" type= "xs:string" />  
  154.                "addressLine1" type= "xs:string" />  
  155.                "addressLine2" type= "xs:string" />  
  156.                
  157.            
  158.          
  159.  
  160.    2 . 利用scomp来生成Java Classes  
  161.  
  162.   scomp是XMLBean提供的一个编译工具,它在bin的目录下. 通过这个工具,我们可以将以上的Schema文件生成Java Classes.scomp的语法如下:-  
  163.  
  164.   scomp [options] [dirs]* [schemaFile.xsd]* [service.wsdl]* [config.xsdconfig]*  
  165.  
  166.   主要参数说明:  
  167.  
  168.   -src [dir] -- 生成的Java Classes存放目录  
  169.  
  170.   -srconly -- 不编译Java Classes,不产生Jar文件  
  171.  
  172.   -out [jarFileName] -- 生成的Jar文件,缺省是xmltypes.jar  
  173.  
  174.   -compiler -- Java编译器的路径,即Javac的位置  
  175.  
  176.   schemaFile.xsd -- XML Schema文件位置  
  177.  
  178.   config.xsdconfig -- xsdconfig文件的位置, 这个文件主要用来制定生成的Java Class的一些文件名规则和Package的名称,在本文, package 是sample.xmlbean  
  179.  
  180.   在本文,我是这样运行的:  
  181.  
  182.       scomp -src build/src  -out build/customerXmlBean.jar schema/customer.xsd  
  183.              -compiler C:/jdk142_04/bin/javac customer.xsdconfig  
  184.  
  185.   这个命令行的意思是告诉scomp生成customerXmlBean.jar,放在build目录下,同时生成源代码放在 build/src下, Schema文件是customer.xsd,xsdconfig文件是customer.xsdconfig.其实, 生成的 Java源代码没有多大作用,我们要的是jar文件.我们先看一下build/src/sample/xmlbean下生成的Classes.  
  186.  
  187.   CustomersDocument.java -- 整个XML文档的Java Class映射  
  188.  
  189.   CustomerType.java -- 节点sustomer的映射  
  190.  
  191.   AddressType.java -- 节点address的映射  
  192.  
  193.   BillingAddressType.java -- 节点billingAddress的映射  
  194.  
  195.   PrimaryAddressType.java -- 节点primaryAddress的映射  
  196.  
  197.   好了,到此我们所有的准备工作已经完成了. 下面就开始进入重点:利用刚才生成的jar文件读写XML.  
  198.  
  199.   五、利用XMLBean读XML文件  
  200.  
  201.   新建一个Java Project,将XMLBean2. 0.0 /lib/下的Jar文件和刚才我们生成的customerXmlBean.jar加入到Project的ClassPath.  
  202.  
  203.   新建一个Java Class: CustomerXMLBean. 源码如下:  
  204.  
  205.     package com.sample.reader;  
  206.  
  207.     import java.io.File;  
  208.       
  209.     import sample.xmlbean.*;  
  210.     import org.apache.commons.beanutils.BeanUtils;  
  211.     import org.apache.xmlbeans.XmlOptions;  
  212.     public class CustomerXMLBean {  
  213.     private String filename = null ;  
  214.       
  215.     public CustomerXMLBean(String filename) {  
  216.             super ();  
  217.             this .filename = filename;  
  218.     }  
  219.  
  220.     public void customerReader() {  
  221.             try {  
  222.               File xmlFile = new File(filename);  
  223.               CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);  
  224.               CustomerType[] customers = doc.getCustomers().getCustomerArray();  
  225.             
  226.               for ( int i = 0 ; i < customers.length; i++) {  
  227.                 CustomerType customer = customers[i];  
  228.                 println( "Customer#" + i);  
  229.                 println( "Customer ID:" + customer.getId());  
  230.                 println( "First name:" + customer.getFirstname());  
  231.                 println( "Last name:" + customer.getLastname());  
  232.                 println( "Gender:" + customer.getGender());  
  233.                 println( "PhoneNumber:" + customer.getPhoneNumber());  
  234.                 // Primary address  
  235.                 PrimaryAddressType primaryAddress = customer.getAddress().getPrimaryAddress();  
  236.                 println( "PrimaryAddress:" );  
  237.                 println( "PostalCode:" + primaryAddress.getPostalCode());  
  238.                 println( "AddressLine1:" + primaryAddress.getAddressLine1());  
  239.                 println( "AddressLine2:" + primaryAddress.getAddressLine2());  
  240.                 // Billing address  
  241.                 BillingAddressType billingAddress = customer.getAddress().getBillingAddress();  
  242.                 println( "BillingAddress:" );  
  243.                 println( "Receiver:" + billingAddress.getReceiver());  
  244.                 println( "PostalCode:" + billingAddress.getPostalCode());  
  245.                 println( "AddressLine1:" + billingAddress.getAddressLine1());  
  246.                 println( "AddressLine2:" + billingAddress.getAddressLine2());  
  247.               
  248.               }  
  249.             } catch (Exception ex) {  
  250.                     ex.printStackTrace();  
  251.             }  
  252.     }  
  253.     private void println(String str) {  
  254.           System.out.println(str);  
  255.     }  
  256.    public static void main(String[] args) {  
  257.       String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers.xml" ;  
  258.                      
  259.      CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);  
  260.                    customerXMLBean.customerReader();  
  261.     }  
  262.  
  263. }  
  264.  
  265.   运行它,参看输出结果:  
  266.  
  267.        Customer# 0  
  268.        Customer ID: 1  
  269.        First name:Jessica  
  270.        Last name:Lim  
  271.        Gender:female  
  272.        PhoneNumber: 1234567  
  273.        PrimaryAddress:  
  274.        PostalCode: 350106  
  275.        AddressLine1:# 25 - 1  
  276.        AddressLine2:SHINSAYAMA 2 -CHOME  
  277.        BillingAddress:  
  278.        Receiver:Ms Danielle  
  279.        PostalCode: 350107  
  280.        AddressLine1:# 167  
  281.        AddressLine2:NORTH TOWER HARBOUR CITY  
  282.  
  283.        Customer# 1  
  284.        Customer ID: 2  
  285.        First name:David  
  286.        Last name:Bill  
  287.        Gender:male  
  288.        PhoneNumber: 808182  
  289.        PrimaryAddress:  
  290.        PostalCode: 319087  
  291.        AddressLine1: 1033 WS St.  
  292.        AddressLine2:Tima Road  
  293.        BillingAddress:  
  294.        Receiver:Mr William  
  295.        PostalCode: 672993  
  296.        AddressLine1: 1033 WS St.  
  297.        AddressLine2:Tima Road  
  298.  
  299.   怎么样,是不是很轻松? XMLBean的威力.  
  300.  
  301.   六、利用XMLBean写XML文件  
  302.  
  303.   利用XMLBean创建一个XML文档也是一件轻而易举的事.我们再增加一个Method,  
  304.  
  305.   请看一下的Java Class:  
  306.  
  307.     public void createCustomer() {  
  308.     try {  
  309.         // Create Document  
  310.         CustomersDocument doc = CustomersDocument.Factory.newInstance();  
  311.         // Add new customer  
  312.         CustomerType customer = doc.addNewCustomers().addNewCustomer();  
  313.         // set customer info  
  314.         customer.setId( 3 );  
  315.         customer.setFirstname( "Jessica" );  
  316.         customer.setLastname( "Lim" );  
  317.         customer.setGender( "female" );  
  318.         customer.setPhoneNumber( "1234567" );  
  319.         // Add new address  
  320.         AddressType address = customer.addNewAddress();  
  321.         // Add new PrimaryAddress  
  322.         PrimaryAddressType primaryAddress = address.addNewPrimaryAddress();  
  323.         primaryAddress.setPostalCode( "350106" );  
  324.         primaryAddress.setAddressLine1( "#25-1" );  
  325.         primaryAddress.setAddressLine2( "SHINSAYAMA 2-CHOME" );  
  326.  
  327. // Add new BillingAddress  
  328.         BillingAddressType billingAddress = address.addNewBillingAddress();  
  329.         billingAddress.setReceiver( "Ms Danielle" );  
  330.         billingAddress.setPostalCode( "350107" );  
  331.         billingAddress.setAddressLine1( "#167" );  
  332.         billingAddress.setAddressLine2( "NORTH TOWER HARBOUR CITY" );  
  333.  
  334.         File xmlFile = new File(filename);  
  335.         doc.save(xmlFile);  
  336.         } catch (Exception ex) {  
  337.                 ex.printStackTrace();  
  338.         }  
  339.  
  340.   }  
  341.  
  342.   修改main method.  
  343.  
  344.     public static void main(String[] args) {  
  345.     String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml" ;  
  346.         CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);  
  347.         customerXMLBean.createCustomer();  
  348.     }  
  349.  
  350.   运行,打开customers_new.xml:  
  351.  
  352.     "1.0" encoding= "UTF-8" ?>  
  353.       
  354.       
  355.             3   
  356.             female  
  357.             Jessica  
  358.             Lim  
  359.             1234567   
  360.            
      
  361.                       
  362.                          350106   
  363.                          # 25 - 1   
  364.                                        SHINSAYAMA 2 -CHOME  
  365.                       
  366.                       
  367.                         Ms Danielle  
  368.                         350107   
  369.                        # 167   
  370.                        NORTH TOWER HARBOUR CITY  
  371.                       
  372.                       
  373.               
  374.       
  375.  
  376.   七、利用XMLBean修改XML文件  
  377.  
  378.   我们再增加一个Method:  
  379.  
  380.       public void updateCustomer( int id,String lastname) {  
  381.          try {  
  382.         File xmlFile = new File(filename);  
  383.         CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);  
  384.         CustomerType[] customers = doc.getCustomers().getCustomerArray();  
  385.         
  386.         for ( int i = 0 ; i < customers.length; i++) {  
  387.            CustomerType customer = customers[i];  
  388.           if (customer.getId()==id){  
  389.                 customer.setLastname(lastname);  
  390.                 break ;  
  391.             }  
  392.         }  
  393.         doc.save(xmlFile);  
  394.          } catch (Exception ex) {  
  395.           ex.printStackTrace();  
  396.          }  
  397.            }  
  398.  
  399.   main method:  
  400.  
  401.     public static void main(String[] args) {  
  402.      String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml" ;  
  403.                       
  404.     CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);  
  405.                       
  406.     customerXMLBean.updateCustomer( 3 , "last" );  
  407.     }  
  408.  
  409.   运行之后,我们将会看到客户编号为 3 的客户的lastname已经改为last.  
  410.  
  411.   八、利用XMLBean删除一个customer  
  412.  
  413.   再增加一个Method:  
  414.  
  415.     public void deleteCustomer( int id) {  
  416.      try {  
  417.       File xmlFile = new File(filename);  
  418.      CustomersDocument doc = CustomersDocument.Factory.parse(xmlFile);  
  419.     CustomerType[] customers = doc.getCustomers().getCustomerArray();  
  420.  
  421.    for ( int i = 0 ; i < customers.length; i++) {  
  422.         CustomerType customer = customers[i];  
  423.         if (customer.getId()==id){  
  424.                         customer.setNil() ;  
  425.                         break ;  
  426.                }  
  427.    }  
  428.    doc.save(xmlFile);  
  429.    } catch (Exception ex) {  
  430.         ex.printStackTrace();  
  431.         }  
  432.    }  
  433.  
  434. main method:  
  435.  
  436.     public static void main(String[] args) {  
  437.     String filename = "F://JavaTest//Eclipse//XMLBean//xml//customers_new.xml" ;  
  438.                       
  439.     CustomerXMLBean customerXMLBean = new CustomerXMLBean(filename);  
  440.                       
  441.     customerXMLBean.deleteCustomer( 3 );  
  442.     }  
  443.  
  444.   运行,我们将会看到客户编号为 3 的客户的资料已经被删除.  
  445.  
  446.   九、查询XML  
  447.  
  448.   除了本文在以上讲述的,利用XMLBean能轻轻松松完成XML的读写操作外,结合XPath和XQuery,XMLBean还能完成象SQL查询数据库一样方便地查询XML数据. 关于XML查询以及如何创建XML数据库, 我将在另一篇文章里讨论.  
  449.  
  450.   十、结束语  
  451.  
  452.   XMLBean能帮助我们轻易读写XML,这将有助于我们降低XML的学习和使用,有了这个基础,开发人员将为学习更多地XML相关技术和Web Services,JMS等其他J2EE技术打下良好地基础.

转自 http://blog.csdn.net/yanglidong/article/details/5223267

你可能感兴趣的:(xml)