XMLBEANS的使用总结

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