XMLBEANS的使用总结

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

XMLBEANS的使用总结的相关文章

xmlbeans解析XML文件全流程+Altova XMLSpy破解

xmlbeans解析XML详细介绍的说明很多,官方也有很多参考,不多废话,主要流程如下: </pre><p>1. 下载 xmlbean 文件 <a target=_blank href="http://download.csdn.net/detail/q119909033/8813173">官方或者直接点击</a></p><p>2. 根据XML生成<span style="font-family:M

使用 XMLBeans 进行编程

深入考察 XMLBeans 的特性和功能.本文通过一个简单的例子介绍 XMLBeans 技术,然后一步一步地介绍编译和绑定的过程,讨论 XML 游标.标记和 XQuery 表达式等高级特性.本文还将讨论 XMLBeans 与其他 XML-Java 数据绑定技术相比所具有的优点. 随着企业应用程序的复杂性不断加剧,XML 文档的约束和规则变得越来越严格.此外,随着业界越来越迅速地采用 Web 服务,XML 开始成为跨越多种平台的不可忽视的重要角色.所有这一切意味着,应用程序迫切需要一种简单而强大的

解决：java.lang.ClassNotFoundException: org.apache.xmlbeans.XmlObject报错问题。

利用POI操作PPT一直报如下错误java.lang.ClassNotFoundException: org.apache.xmlbeans.XmlObject 是因为项目中缺少一个包xmlbeans-2.3.0.jar,加上后就可以正常操作了. 官方下载地址:http://xmlbeans.apache.org 导入XMLBEANS包即可 原文地址:https://www.cnblogs.com/yang-xiansen/p/11972187.html

[SoapUI] SoapUI+Groovy中&quot;org.apache.xmlbeans.XmlException: error:

把 def holder = groovyUtils.getXmlHolder("Get Token#Response") 改为 def holder = groovyUtils.getXmlHolder( "Get Token#ResponseAsXml" ),即加了AsXml就可以了

org.apache.xmlbeans.XmlException: error: does not close tag

使用myeclipse的jax自动生成webservice , 或者serviceImpl通过@webservice来实现webservice时, 使用soap UI (我测试使用的版本 5.2.1),提示出现does not close tag错误提示 总结一下:原因发现有二: 1.情况二:可能是你使用的是jax版本过低,因为在soap UI 5.4 和 soap UI 4.5 在实现上是有区别的: 具体区别描述可以看一下这位兄弟:http://blog.csdn.net/a19881029/

java 解析excel，带合并单元的excel

首先,mavn导入jar包 <!-- 解析excel需要导入的 jar包    begin -->          <dependency>            <groupId>org.apache.poi</groupId>            <artifactId>poi</artifactId>            <version>3.11</version>        </dep

Spring---介绍

核心容器:Core.Beans.Context.EL模块 1.     Core模块:封装了框架依赖的最底层部分,包括访问资源.类型转换及一些常用工具类 2.     Beans模块:提供了框架的基础部分,包括反转控制和依赖注入.其中BeanFactory是容器的核心,本质是"工厂设计模式"的实现,而且无需编程实现"单例设计模式",单例完全由容器控制,而且提倡面向接口编程,而非面向实现编程:所有应用程序对象以及对象间关系由框架管理,从而真正的把维护对象之间的依赖关系

转:java 解析excel，带合并单元的excel

收集了一些对博主有帮助的博文,如下 >>>>>>>>>>>第一部分: 首先,mavn导入jar包 <!-- 解析excel需要导入的 jar包    begin -->          <dependency>            <groupId>org.apache.poi</groupId>            <artifactId>poi</artifactI

poi 详细demo

import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.math.BigInteger;import java.util.ArrayList;import java.util.Iterator;import java.util.List; import or