下载文档原格式
JAXB（Java API for XML Binding），提供了一个快速便捷的方式将Java对象与XML进行转换。
在JAX-WS（Java的WebService规范之一）中，JDK1.6 自带的版本JAX-WS2.1，其底层支持就是JAXB。
JAXB 可以实现Java对象与XML的相互转换，在JAXB中，将一个Java对象转换为XML 的过程称之为Marshal，将XML转换为Java对象的过程称之为UnMarshal。
我们可以通过在Java 类中标注注解的方式将一个Java对象绑定到一段XML，也就是说，在Java类中标注一些注解，这些注解定义了如何将这个类转换为XML，怎么转换，以及一段XML如何被解析成这个类所定义的对象；也可以使用JAXB的XJC工具，通过定义schema的方式实现Java 对象与XML的绑定（这个下次研究）。
下面来了解一下如何通过标注注解来完成 Marshal 和 UnMarshal 的过程。
我用的是JAXB2_20101209.jar ，可以到[url]/[/url] 下载最新版本。
首先看个小例子定义一个java类Java代码package com.why.jaxb;import javax.xml.bind.annotation.XmlRootElement;@XmlRootElementpublic class People {public String id = "001";public String name = "灰太狼";public int age = 26;}Java To XML（Marshal）Java代码package com.why.jaxb;import javax.xml.bind.JAXBContext;import javax.xml.bind.JAXBException;import javax.xml.bind.Marshaller;public class Java2XML {/*** @param args* @throws JAXBException*/public static void main(String[] args) throws JAXBException {JAXBContext context = JAXBContext.newInstance(People.class);Marshaller marshaller = context.createMarshaller();marshaller.setProperty(Marshaller.JAXB_ENCODING,"gb2312");//编码格式marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);//是否格式化生成的xml串marshaller.setProperty(Marshaller.JAXB_FRAGMENT, false);//是否省略xml 头信息（<?xml version="1.0" encoding="gb2312" standalone="yes"?>）People people = new People();marshaller.marshal(people, System.out);}}XML To Java（UnMarshal）Java代码package com.why.jaxb;import java.io.File;import javax.xml.bind.JAXBContext;import javax.xml.bind.JAXBException;import javax.xml.bind.Unmarshaller;import org.xml.sax.SAXException;public class XML2Java {/*** @param args* @throws JAXBException* @throws JAXBException* @throws SAXException*/public static void main(String[] args) throws JAXBException {JAXBContext context = JAXBContext.newInstance(People.class);Unmarshaller unmarshaller = context.createUnmarshaller();File file = new File("src/people.xml");People people = (People)unmarshaller.unmarshal(file);System.out.println(people.id);System.out.println();System.out.println(people.age);}}其实Marshal 和UnMarshal的过程并不复杂，只需要从JAXBContext中获得Marshaller或Unmarshaller对象，就可以让JAXB帮我们来进行转换了。
JAVA写xml文件随着计算机技术的飞速发展，需要在程序中存储和管理大量的信息，并用众多的语言和工具进行交互。
为了解决这个问题，以及为不同的程序语言提供一致的格式来实现数据交换，XML（超文本标记语言）应运而生，并在软件开发中得到广泛运用。
XML用来描述数据的一种文本语言，它可以存储比如用户及其信息，设置，排列，及其他数据的内容。
XML在许多计算机程序中被广泛使用，它可以被用来传递数据，或者以XML标记格式存储信息。
尽管XML可以使用任何编程语言来解析，但是其最常见的用法是使用Java来写。
接下来我们就使用Java来写XML文件，具体步骤如下：第一步：准备好XML文件所需要的相关信息。
第二步：导入Java标准包（javax.xml.parsers.*）。
第三步：实例化DocumentBuilderFactory。
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();第四步：使用builderFactory来实例化DocumentBuilder。
DocumentBuilder builder =builderFactory.newDocumentBuilder();第五步：使用DocumentBuilder来创建文档并且添加元素。
Document document = builder.newDocument();Element rootElement = document.createElement(rootdocument.appendChild(rootElement);第六步：添加属性并写入XML文件。
Element nameElement = document.createElement(amenameElement.setTextContent(EarthrootElement.appendChild(nameElement);Element sizeElement = document.createElement(sizesizeElement.setTextContent(largerootElement.appendChild(sizeElement);TransformerFactory transformerFactory = TransformerFactory.newInstance();Transformer transformer =transformerFactory.newTransformer();DOMSource source = new DOMSource(document);StreamResult result = new StreamResult(newFile(file.xml);transformer.transform(source, result);以上是Java写入XML文件的实例，从上面可以看出JAVA语言是一种非常强大的程序语言，它结合XML技术，可以用来实现大量复杂的数据存储和交互。
jaxbcontext字符串转xml方法【最新版3篇】篇1 目录1.JAXBContext 简介2.字符串转 XML 的实现方法3.示例代码篇1正文1.JAXBContext 简介JAXB（Java Architecture for XML Binding）是 Java 中的一种用于将 Java 对象转换为 XML 格式，以及将 XML 格式转换为 Java 对象的技术。
在 JAXB 中，JAXBContext 是一个非常重要的类，它用于创建和配置 JAXB 实现。
JAXBContext 通过 unmarshal 方法可以将 XML 格式的数据转换为 Java 对象，通过 marshal 方法可以将 Java 对象转换为XML 格式的数据。
2.字符串转 XML 的实现方法要实现字符串转 XML 的功能，我们可以通过以下步骤：（1）创建一个 Java 类，该类的属性与目标 XML 结构相对应。
（2）使用 JAXBContext 的 unmarshal 方法将 XML 字符串转换为Java 对象。
（3）使用 JAXBContext 的 marshal 方法将 Java 对象转换为 XML 字符串。
3.示例代码下面是一个简单的示例，展示了如何使用 JAXBContext 将字符串转换为 XML：```javaimport javax.xml.bind.JAXBContext;import javax.xml.bind.Marshaller;import javax.xml.bind.Unmarshaller;import java.io.StringReader;import java.io.StringWriter;public class JAXBContextStringToXML {public static void main(String[] args) {String xmlString = "<?xml version="1.0" encoding="UTF-8"?>"+ "<学生>"+ "<姓名>张三</姓名>"+ "<年龄>20</年龄>"+ "</学生>";JAXBContext jaxbContext =JAXBContext.newInstance(Student.class);try {// 将字符串转换为 Java 对象Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();Student student = (Student) unmarshaller.unmarshal(new StringReader(xmlString));// 将 Java 对象转换为 XML 字符串Marshaller marshaller =jaxbContext.createMarshaller();StringWriter stringWriter = new StringWriter();marshaller.marshal(student, stringWriter);System.out.println("转换后的 XML 字符串：" + stringWriter.toString());} catch (Exception e) {e.printStackTrace();}}}```在这个示例中，我们首先创建了一个名为 Student 的 Java 类，该类包含姓名和年龄两个属性。
jaxbelement格式-回复JAXBElement格式简介：JAXB（Java Architecture for XML Binding）是一个Java的XML绑定技术，它允许将XML数据与Java对象进行无缝转换。
在JAXB中，JAXBElement是一个用于包装XML元素的类，它允许在绑定过程中处理XML中的元素和属性。
一、什么是JAXBElement格式？JAXBElement是JAXB中的一个类，用于表示XML元素及其属性。
在JAXB 中，XML元素由一个Java类表示，这个类可以包含子元素、属性和值。
JAXBElement提供了对这些包装XML元素的支持，并且可以帮助在XML 和Java对象之间进行转换。
二、JAXBElement的使用方法1. 创建一个JAXBContext对象：首先，需要创建一个JAXBContext对象，以便在转换过程中找到所需的Java类和XML元素。
2. 创建一个Unmarshaller对象：Unmarshaller对象用于从XML中读取数据并将其转换为Java对象。
3. 创建一个JAXBElement对象：JAXBElement类有两个参数，第一个参数是要包装的对象类型，第二个参数是XML元素的类型。
根据XML文档的结构，可以创建一个或多个JAXBElement对象。
4. 使用Unmarshaller对象将XML转换为JAXBElement对象：使用Unmarshaller对象的unmarshal方法，将XML数据输入并将其转换为JAXBElement对象。
5. 通过getValue()方法获取XML元素的值：一旦将XML转换为JAXBElement对象，可以使用getValue()方法获取XML元素的值。
6. 对JAXBElement对象进行操作：可以通过JAXBElement对象的getDeclaredType()方法获取XML元素的类型。
还可以使用getValue()方法获取XML元素的值，并对其进行操作。
jaxbelement格式JAXBElement格式简介及其在Java开发中的应用JAXB（Java Architecture for XML Binding）是Java编程语言中用于将Java对象与XML数据进行绑定的一种技术。
它能够帮助开发人员快速、方便地实现Java对象与XML之间的相互转换。
在JAXB 中，JAXBElement是一个非常重要的类，它提供了一种通用的方式来表示XML元素。
一、JAXBElement的概述JAXBElement是JAXB中的一个类，用于表示XML元素。
XML 元素是XML文档中最基本的组成单元，它由一个元素名称和与之相关联的值组成。
在Java中，我们通常使用DOM、SAX或StAX等API来解析XML文档，这些API将XML元素解析为特定的Java对象。
然而，对于一些复杂的XML结构，这种解析方式可能会变得复杂和繁琐。
这时，JAXBElement就可以发挥作用了。
JAXBElement提供了一种通用的方式来表示XML元素，不论XML元素是简单的还是复杂的。
它包含了一个元素的名称、命名空间以及与之相关联的值。
通过使用JAXBElement，我们可以将XML 元素与特定的Java类进行绑定，从而实现XML与Java之间的相互转换。
二、在Java开发中使用JAXBElement1. 添加JAXB依赖要在Java开发中使用JAXBElement，首先需要将JAXB依赖添加到项目的构建文件中。
可以通过Maven或Gradle等构建工具来实现。
以下是一个Gradle构建文件的示例：dependencies {implementation 'javax.xml.bind:jaxb-api:2.3.1'implementation 'org.glassfish.jaxb:jaxb-runtime:2.3.1' }2. 创建Java类接下来，我们需要创建一个Java类，该类将作为XML元素的绑定类。
利⽤oxygen编辑并⽣成xml⽂件，并使⽤JAVA的JAXB技术完成xml的解析⾸先下载oxygen软件（Oxygen XML Editor），⽬前使⽤的是试⽤版（可以安装好软件以后get trial licence，获得免费使⽤30天的权限，当然这⾥⿎励⼤家⽤正版软件）1 ⾸先建⽴⼀个空⽩XML⽂件，直接点击下图所⽰即可：2 可以使⽤xml⽂本编辑界⾯，或者使⽤xml树状图编辑界⾯ 切换到xml树状图编辑界⾯的⽅法为： 即可调出当前xml⽂件所对应的xml树状图编辑界⾯3 设计并编辑xml⽂件 根据⾃⼰的需要可以利⽤xml树状图操作界⾯来⽅便的设计⾃⼰的xml⽂档格式4 利⽤oxygen软件本⾝提供的转换功能将.xml⽂件⽣成对应的.xsd⽂件，具体操作如下： 这样就会在对应的⽂件夹下⾯⽣成.xml⽂件所对应的.xsd⽂件：5 利⽤xjc命令（Java的JDK提供！）将上⼀步⽣成的.xsd⽂件转化为.java⽂件打开cmd命令⾏⼯具，切换到上⼀步⽣成的.xsd⽂件所在的⽬录；利⽤xjc命令完成转换：xjc 要转换的.xsd完整⽂件名 –p 转化的完整⽬的包名 举例： xjc AtmRadi_Param.xsd –p XMLBean.AtmRadi ⽣成的结果如下： 此时XMLBean⽂件夹中已经⽣成了很多.java⽂件6 改上⼀步中⽣成的.java⽂件中的变量类型。
典型的是将BigInteger、BigDecimal等数据类型改为正常的int、double类型 注意：此步有⼀个稍微简单⼀点的⽅法来替代：就是在第⑤步⽣成.xsd后，可以直接提前改.xsd中的⼀些数据类型，这样避免后⾯⽣成很多.java⽂件，⽽却需要⼀个⼀个打开去改。
改.xsd中的数据类型时可以参考下表：7 到此为⽌即可使⽤ JDK本⾝提供的JAXB技术 + 上⾯形成的诸个.java⽂件 + .xml⽂件来完成xml⽂件中数据的解析 此处可以使⽤现成的⼯具代码：XmlUtil.java 中的XMLToObj函数来完成从xml⽂件到对象的转换。
java xml格式返回报文解析Java中可以使用多种方式解析XML格式的返回报文，常见的方式有DOM解析、SAX解析以及基于XML绑定技术的解析。
每种方式都有不同的特点和适用场景，下面将详细介绍这三种解析方式。
1. DOM解析：DOM（Document Object Model）解析是将整个XML文档加载到内存中，构建成一个树形结构，并提供API来操作这个树。
DOM解析提供了许多API，可以通过节点遍历和搜索、属性读取和设置、节点创建和删除等方式来处理XML文档。
DOM解析适用于对XML文档进行多次读写操作，如增删改查等复杂的操作。
使用Java的DOM解析，可以通过以下几个步骤实现：1)使用DocumentBuilderFactory创建一个DocumentBuilder对象。
2)调用DocumentBuilder的parse方法，传入XML文件的输入流，将XML文档解析为一个Document对象。
3)通过Document对象可以获取XML文档的根元素，从而开始对XML文档进行遍历和操作。
DOM解析的优点是能够将整个XML文档加载到内存中，便于操作和修改。
但是对于较大的XML文件，DOM解析会消耗大量的内存空间。
2. SAX解析：SAX（Simple API for XML）解析是一种基于事件驱动的解析方式，它逐行读取XML文档并触发相应的事件，应用程序根据事件的发生来处理XML文档。
SAX解析的特点是速度快、内存消耗小，适用于对XML文档进行单次顺序读取的操作。
使用Java的SAX解析，可以通过以下几个步骤实现：1)定义一个继承自DefaultHandler的处理器类，重写相应的事件回调方法。
2)使用SAXParserFactory创建一个SAXParser对象。
3)调用SAXParser的parse方法，传入XML文件的输入流和处理器对象，开始解析XML文档。
SAX解析的优点是速度快，内存消耗小，适用于大型XML文件的解析。
javax.xml用法javax.xml是Java语言中用于处理XML（可扩展标记语言）的标准扩展。
它提供了一组类和接口，用于解析、生成和操作XML文档。
下面从多个角度来介绍javax.xml的用法：1. XML解析，javax.xml提供了许多类和接口，如DocumentBuilder和XPath，可以用于解析XML文档。
你可以使用DocumentBuilder来将XML文档解析为DOM（文档对象模型）树，然后使用XPath来查询和操作DOM树中的元素和属性。
2. XML生成，除了解析外，javax.xml还提供了一些类和接口，如Transformer和XMLStreamWriter，用于生成XML文档。
你可以使用Transformer将DOM树转换为XML文档，也可以使用XMLStreamWriter来以流的方式生成XML文档。
3. 数据绑定，javax.xml.bind包提供了将Java对象与XML文档相互转换的功能。
你可以使用注解来标记Java类，然后使用JAXBContext和Unmarshaller/Marshaller来实现Java对象与XML文档之间的转换。
4. 验证，javax.xml.validation包中的类和接口可以用于对XML文档进行验证。
你可以使用Schema来定义XML文档的结构，并使用Validator来验证XML文档是否符合指定的结构。
5. Web服务，javax.xml.ws包提供了用于开发基于XML的Web 服务的API。
你可以使用其中的类和接口来创建、发布和调用基于XML的Web服务。
总之，javax.xml提供了丰富的功能和API，用于处理XML文档和开发基于XML的应用程序。
通过使用这些类和接口，你可以轻松地解析、生成、操作和验证XML文档，以及开发基于XML的Web服务。
希望这些信息能够帮助你更好地理解javax.xml的用法。
如何利用Java语言进行XML编程的研究报告随着计算机技术的不断发展，XML（可扩展标记语言）已经成为Web数据交换的一种标准方式。
它是一种使用标签描述数据的语言，具有自我描述性以及能够方便地扩展的特点。
而Java语言可以很好地与XML技术相结合，用于XML编程。
本文将介绍如何利用Java语言进行XML编程的方法和技巧。
一、读取XML文件Java语言中提供了许多读取XML文件的工具，如DOM、SAX、JDOM、XMLBeans等。
其中DOM（文档对象模型）是最常用的读取XML文件的方式。
DOM是一种树状结构，将XML文档中的标签、属性、内容等信息以节点的形式表示，每个节点都有一个唯一的节点名和一个节点值。
通过使用DOM解析器，Java程序可以将XML文档转换为DOM树，然后通过遍历DOM树的方式实现对XML文档的读取。
二、创建XML文档Java语言中也提供了多种创建XML文档的方式，如DOM、JDOM、XOM、StAX等。
其中DOM仍然是最常用的方式。
通过DOM创建XML文档的过程与读取XML文档的过程类似，只不过是反过来了。
先创建一个空的DOM树，然后按照XML文档的结构，在树中添加标签、属性和文本节点等元素，最后将DOM树转换为XML文档。
三、解析XML文件解析XML文件是将XML文档转换为Java对象，使程序能够方便地使用XML数据。
Java语言中可以使用JAXB、Castor、XMLBeans等工具进行XML文件的解析。
其中，JAXB（Java Architecture for XML Binding）是最常用的XML解析工具之一。
JAXB通过将XML数据映射到Java对象上，实现了XML文档的解析和Java对象的序列化过程。
四、使用XPath查询XML数据XPath是一种用于在XML文档中查询信息的语言，它可以实现XML数据的定位、筛选和排序等操作。
在Java语言中，可以使用JDOM、DOM4J等工具实现XPath查询XML数据的功能。
一、介绍Java是一种广泛使用的编程语言，而XML（可扩展标记语言）则是一种用于标记文档结构的通用格式。
在Java中拼接XML字符串是一项常见的任务，本文将介绍一些在Java中拼接XML字符串的方法。
二、使用字符串拼接在Java中，可以使用字符串拼接的方式来构建XML字符串。
这种方法通常使用String类的加号或者StringBuffer和StringBuilder类的append()方法来实现。
例如：```javaString xml = "<root>";xml += "<element>value</element>";xml += "</root>";```或者```javaStringBuilder xml = new StringBuilder();xml.append("<root>");xml.append("<element>value</element>");xml.append("</root>");```这种方法看起来简单直观，但在处理大量的字符串拼接时，性能会有一定影响。
三、使用XML构建器为了更高效地构建XML字符串，可以使用Java提供的各种XML构建器，例如DOM、SAX和JAXB等。
这些构建器提供了更丰富的API 和更优化的性能。
以下是使用DOM构建XML字符串的示例代码：```javaDocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.newDocument();Element root = doc.createElement("root");doc.appendChild(root);Element element = doc.createElement("element"); element.appendChild(doc.createTextNode("value"));root.appendChild(element);TransformerFactory transformerFactory = TransformerFactory.newInstance();Transformer transformer =transformerFactory.newTransformer();StringWriter writer = new StringWriter();transformer.transform(new DOMSource(doc), new StreamResult(writer));String xml = writer.toString();四、使用模板引擎除了传统的字符串拼接和XML构建器，还可以使用模板引擎来构建XML字符串。
java xml相关操作
Java与XML的结合是一种常见的方式，可以实现数据的存储和传输。
以下是一些Java XML相关操作的详细介绍：
1. 解析XML文件：使用Java中的DOM、SAX或JDOM等API可以解析XML文件并获取其中的数据。
2. 创建XML文件：可以使用Java中的DOM或JDOM等API创建XML文件，并将数据写入其中。
3. 使用XML Schema验证XML文档：可以使用Java中的SAX或DOM API以及一些第三方库，如JAXB或XSDValidator等，来验证XML 文档是否符合XML Schema的规范。
4. 转换XML格式：可以使用Java中的XSLT API将XML文档转换为其他格式，如HTML、PDF等。
5. 使用XPath查询XML文档：可以使用Java中的XPath API来查询XML文档中的数据。
6. 使用JAXB绑定XML和Java对象：可以使用JAXB API将XML 文档中的数据绑定到Java对象上，并进行操作和修改。
7. 使用XML与Web服务交互：可以使用Java中的WebService API 来使用XML和Web服务交互，并获取和发送数据。
总之，Java与XML的结合可以实现许多功能，如数据存储、数据传输、Web服务交互等，是Java开发中的重要部分。
- 1 -。
java解析xml详解及示例java 解析xml的几种方法第一种：DOMDOM的全称是Document Object Model，也即文档对象模型。
在应用程序中，基于DOM 的XML分析器将一个XML文档转换成一个对象模型的集合（通常称DOM树），应用程序正是通过对这个对象模型的操作，来实现对XML文档数据的操作。
通过DOM接口，应用程序可以在任何时候访问XML文档中的任何一部分数据，因此，这种利用DOM接口的机制也被称作随机访问机制。
DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式，这些分层对象模型依据XML的文档结构形成了一棵节点树。
无论XML文档中所描述的是什么类型的信息，即便是制表数据、项目列表或一个文档，利用DOM所生成的模型都是节点树的形式。
也就是说，DOM强制使用树模型来访问XML文档中的信息。
由于XML本质上就是一种分层结构，所以这种描述方法是相当有效的。
DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性，它可以任意地控制整个XML文档中的内容。
然而，由于DOM 分析器把整个XML文档转化成DOM树放在了内存中，因此，当文档比较大或者结构比较复杂时，对内存的需求就比较高。
而且，对于结构复杂的树的遍历也是一项耗时的操作。
所以，DOM分析器对机器性能的要求比较高，实现效率不十分理想。
不过，由于DOM分析器所采用的树结构的思想与XML 文档的结构相吻合，同时鉴于随机访问所带来的方便，因此，DOM分析器还是有很广泛的使用价值的。
Java代码import java.io.File;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.NodeList;public class DomT est1{public static void main(String[] args) throws Exception{// step 1: 获得dom解析器工厂（工作的作用是用于创建具体的解析器）DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();// System.out.println("class name: " + dbf.getClass().getName());// step 2:获得具体的dom解析器DocumentBuilder db = dbf.newDocumentBuilder();// System.out.println("class name: " + db.getClass().getName());// step3: 解析一个xml文档，获得Document对象（根结点）Document document = db.parse(new File("candidate.xml"));NodeList list = document.getElementsByTagName("PERSON");for(int i = 0; i < list.getLength(); i++){Element element = (Element)list.item(i);String content =element.getElementsByTagName("NAME").item(0).getFirstC hild().getNodeValue();System.out.println("name:" + content);content =element.getElementsByTagName("ADDRESS").item(0).getFir stChild().getNodeValue(); System.out.println("address:" + content);content =element.getElementsByTagName("TEL").item(0).getFirstChil d().getNodeValue();System.out.println("tel:" + content);content =element.getElementsByTagName("FAX").item(0).getFirstChil d().getNodeValue();System.out.println("fax:" + content);content =element.getElementsByTagName("EMAIL").item(0).getFirstC hild().getNodeValue();System.out.println("email:" + content);System.out.println("--------------------------------------");}}}Java代码import java.io.File;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Attr;import /doc/723478280.html,ment;import org.w3c.dom.Document;import org.w3c.dom.Element;import/doc/723478280.html,dNodeMap;import org.w3c.dom.Node;import org.w3c.dom.NodeList;/*** 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上* @author*/public class DomT est3{public static void main(String[] args) throws Exception{DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();DocumentBuilder db = dbf.newDocumentBuilder();Document doc = db.parse(new File("student.xml"));//获得根元素结点Element root = doc.getDocumentElement();parseElement(root);}private static void parseElement(Element element){String tagName = element.getNodeName();NodeList children = element.getChildNodes();System.out.print("<" + tagName);//element元素的所有属性所构成的NamedNodeMap对象，需要对其进行判断 NamedNodeMap map = element.getAttributes();//如果该元素存在属性if(null != map){{//获得该元素的每一个属性Attr attr = (Attr)map.item(i);String attrName = attr.getName();String attrValue = attr.getValue();System.out.print(" " + attrName + "=\"" + attrValue + "\""); } }System.out.print(">");for(int i = 0; i < children.getLength(); i++){Node node = children.item(i);//获得结点的类型short nodeType = node.getNodeType();if(nodeType == Node.ELEMENT_NODE){//是元素，继续递归parseElement((Element)node);}else if(nodeType == Node.TEXT_NODE){//递归出口System.out.print(node.getNodeValue());}else if(nodeType == /doc/723478280.html,MENT_NODE) {System.out.print("System.out.print(data);System.out.print("-->");}}System.out.print("");}}第二种 sax：SAX的全称是Simple APIs for XML，也即XML简单应用程序接口。
Java XML绑定技术--- 快速操作XML文档注: 本文系原创, 转载请注明作者 -------- 叶瑞金 /06/10在开发中, 我们常见XML来存储一些数据。
相对于普通的文本文件, XML具有开放性、支持多语言编码、支持结构性数据等优越性, 我们常见它存储配置信息, 甚至直接使用它当作数据库使用。
最近由于项目需要, 我对Java XML绑定技术作了些研究, 现在把一些心得与大家分享一下。
其实用Java读写XML的技术由来已久, 比如Apache的XML API、 xalan、xerces都是很出名的项目, 都有将近十多年历史了吧。
这些API对XML的操作都是基于XML最底层的DOM和SAX模式, 原来也不算很复杂。
我在以前项目中很多关于配置文件的管理部分都是用这些API来完成的。
但不论是用DOM还是SAX,都要求XML的格式是预先定义好的。
也就是说, 如果你已经写好了一份读写XML的程序, 之后如果这个XML的格式作了修改, 那么你必须修改程序, 以保证能够正确地从修改后的XML中读写数据。
如果XML的格式很复杂, 或者牵涉的XML文件类型众多, 那么这种修改将是一个浩大的工程。
如果我们能找到一种自动适应XML格式的方法, 能够根据当前XML的格式定义, 自动地读写XML中的数据, 那么就能够节省我们很多精力和时间。
能够把这种技术称为XML绑定技术(XML Binding), 或者称为Object XML。
真的有这样的程序或框架吗?我们能够用下面的图示来描述Java XML绑定技术:Person <----------------------------> <Person>|----- id<----------------------------> <id>123</id>|___ name<----------------------------> <name>tom</name></Person>使用这种绑定技术能够在Java对象和XML文档之间自由地转换。
比如你能够把一个XML文件转换成Java对象, 然后你读取Java对象中的数据, 实际上就是读取XML文档中的数据。
或者当你把数据放入Java对象时, 实际上是在更新XML文档。
对于Java开发人员而言, 有了这种绑定技术, 你面正确不再是繁琐的XML文档, 而是操作快捷的Java对象。
这样是不是方便很多呢?现在确实已经有一些能够完成这个任务的优秀框架。
比如: JAXB、 XMLBeans、Castor等等。
我最早接触的就是Castor( 大约是就有了Castor 0.9版) 。
Castor本身是一个开源的JDO框架。
它的配置文件都是用XML定义的。
为了能够使配置文件更加灵活, 它的设计者实现了XML<---->Java Bean的绑定技术。
它主要用于快速从XML读取JDO的配置信息。
但它所采用的绑定方式不太好用, 开发者不能自己定义XML格式, 必须由Castor自己生成。
在使用Castor XML时, 开发者先定义好要绑定的Java Bean程序, 然后运行Castor的命令行程序, 生成对应的XML的定义。
用户不能自行定义或修改XML的定义, 是Castor的一大缺陷。
不过对于Castor的目标来说, 这不算什么, 因为它原来就不是为了做XML绑定而产生的。
因为这个原因, Castor XML绑定技术并没有得到广泛应用。
但有一点能够肯定的是, Castor能够在JDK 1.3上完成XML的绑定操作, 这是其它的几种框架都不能做到的。
相比Castor而言, JAXB和XMLBeans都是比较新的框架, 更加灵活, 已经能够根据用户自定义的XML来产生对应的读写程序。
在使用前用户需要先定义好XML的格式信息, 并把这些信息保存在XSD文件中(XSD也是一种XML文件, 专门用于定义XML的格式)。
然后, 用户执行由框架提供的命令行程序, 生成相应的读写程序。
之后, 用户就能够使用生成的程序来操纵XML了。
典型的XSD文件如下所示:<?xml version="1.0" encoding="UTF-8"?><xs:schema targetNamespace=""xmlns:xs=""xmlns:tns=""><xs:complexType name="PersonType"><xs:sequence><xs:element name="id"type="xs:string" minOccurs="0" maxOccurs="1"/><xs:element name="name"type="xs:string" minOccurs="0" maxOccurs="1"/></xs:sequence></xs:complexType><xs:element name="Person" type="tns:PersonType"/></xs:schema>这个XSD文件首先定义了一个PersonType数据类型, 它具有两个字符串类型的属性: id和name。
接下来, 定义XML文档中只有一个数据项, 那就是Person, 它的数据类型就是上面已经定义的PersonType。
根据上面的定义, 那么一个XML文档的内容必须符合下面的形式:<?xml version="1.0" encoding="UTF-8"?><Person><id>123</id><name>tom</name></Person>JAXB或XMLBeans会根据XSD对XML文档进行检查, 如果XML文档符合XSD 中定义的格式, 那么就将它解析出来。
但这两种框架的处理方式还是有所区别的。
最主要的区别在于, XMLBeans 包含了XML解析器部分, 而JAXB则没有包含。
JAXB是由Sun推出的一种绑定标准, 是基于JDK1.5以上版本设计的。
它本身并不提供XML的解析功能, 而是由JDK其它模块来辅助完成XML的操作。
因此用它生成的程序没有解析器部分。
用户只要把生成的源代码包含到工程中, 就能够实现对XML的操作。
XMLBeans中包含了XML解析器部分, 使用它来对XML文档进行解析之前, 先要用它分析XSD文件, 然后它会生成一个用于解析XML文档的jar包。
这个jar 包中包含了XML文档的解析器。
用户在使用XMLBeans对XML文档进行解析时, 必须在CLASSPATH中导入这个jar包。
在实际使用中, 本人觉得使用JAXB更加方便, 毕竟它是已经与JDK整合的东西, 用起来更加顺手。
下面我重点来谈谈JAXB的使用方法及应用。
在我最近的项目中, 客户希望能够把测试系统中的数据迁移到正式环境中。
但又不能把正式环境中的数据整个冲掉, 只能作增量重新。
即只修改有变化的部分。
而且用户能够选择要更新的内容。
因为我们无法知道目标数据库中的数据情况, 因此我们不能采用SQL方式保存要导入或导出的数据。
在这个功能开发中, 为了能够方便地查看导入或导出的数据, 因此我们希望用文本格式来保存数据。
但普通的文本文件又无法保证没有乱码的问题。
因此为了方便数据导入导出, 我设计用XML的形式来保存要导入或导出的数据。
这个功能涉及的数据库表非常多, 如果直接用DOM4J解析XML文档, 那确实是一件痛苦的事情。
于是我决定使用JAXB技术。
我把所有的需要导出的数据结构定义到XSD文件中( 假设XSD文件名为crcdata.xsd) :<?xml version="1.0" encoding="UTF-8"?><xs:schema targetNamespace=""xmlns:xs=""xmlns:tns=""><!-- Base Type --><xs:complexType name="CodeLangue"><xs:sequence><xs:element name="clCdCl"type="xs:string" minOccurs="0" maxOccurs="1"/><xs:element name="clLibCl"type="xs:string" minOccurs="0" maxOccurs="1"/><xs:element name="clSeparateurmilleCl"type="xs:string" minOccurs="0" maxOccurs="1"/><xs:element name="clSeparameurdecimalCl"type="xs:string" minOccurs="0" maxOccurs="1"/><xs:element name="clSeparateurcsv"type="xs:string" minOccurs="0" maxOccurs="1"/></xs:sequence></xs:complexType>...<xs:complexType name="CodeLangueList"><xs:sequence><xs:element name="CodeLangue"type="tns:CodeLangue"minOccurs="0" maxOccurs="unbounded"/></xs:sequence></xs:complexType>...<xs:complexType name="AllData"><xs:sequence><xs:element name="CodeLangueList"type="tns:CodeLangueList" minOccurs="0" maxOccurs="1"/></xs:sequence></xs:complexType><xs:element name="AllDatas" type="tns:AllData"/></xs:schema>在这个XSD文件中, 我定义的数据结构如下:AllData|_______ CodeLangueList|_____________ CodeLangue这里只以CodeLangue为例, 在AllData中列出它的List。
