本文目录一览：
- 1、java 解析xml？
- 2、java的xml的解析方式有什么，他们的解析流程是怎么样的，有什么区别
- 3、java中xml有什么作用，用在什么地方？
- 4、在java中解析xml有哪几种方法
- 5、java解析xml的几种方式哪种最好？
- 6、java解析xml有几种方法
java 解析xml？
可以用dom4j解析
dependency
groupIdorg.dom4j/groupId
artifactIddom4j/artifactId
version2.1.3/version
/dependency
参考代码：
import java.io.File;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.CDATA;
import org.dom4j.Comment;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.Text;
import org.dom4j.io.SAXReader;
public class XmlTest {
public static void main(String[] args) {
String xmlFile = "d:/test.xml";
try {
SAXReader reader = new SAXReader();
Document doc = reader.read(new File(xmlFile));
// 递归打印xml文档信息
StringBuffer buffer = new StringBuffer();
parseElement(doc.getRootElement(), buffer);
System.out.println(buffer.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
public static void parseElement(Element element, StringBuffer buffer) {
buffer.append("" + element.getName());
ListAttribute attrs = element.attributes();
if (attrs != null) {
for (Attribute attr : attrs) {
buffer.append(" " + attr.getName() + "=\"" + attr.getValue() + "\"");
}
}
buffer.append("");
IteratorNode iterator = element.nodeIterator();
while (iterator.hasNext()) {
Node node = iterator.next();
if (node instanceof Element) {
Element eleNode = (Element) node;
parseElement(eleNode, buffer);
}
if (node instanceof Text) {
Text text = (Text) node;
buffer.append(text.getText());
}
if (node instanceof CDATA) {
CDATA dataNode = (CDATA) node;
buffer.append(dataNode.getText());
}
if (node instanceof Comment) {
Comment comNode = (Comment) node;
buffer.append(comNode.getText());
}
}
buffer.append("/" + element.getName() + "");
}
}
java的xml的解析方式有什么，他们的解析流程是怎么样的，有什么区别
答：4种。（或者说是两种，因为JDOM和DOM4J是DOM的两个特殊情况）
1.SAX解析
解析方式是事件驱动机制！
SAX解析器，逐行读取XML文件解析，每当解析到一个标签的开始/结束/内容/属性时，触发事件。
可以在这些事件发生时，编写程序进行相应的处理。
优点：
分析能够立即开始，而不是等待所有的数据被处理。
逐行加载，节省内存，有助于解析大于系统内存的文档。
有时不必解析整个文档，它可以在某个条件得到满足时停止解析。
缺点：
1.单向解析，无法定位文档层次，无法同时访问同一个文档的不同部分数据（因为逐行解析，当解析第n行时，第n-1行）已经被释放了，无法再对其进行操作）。
2. 无法得知事件发生时元素的层次, 只能自己维护节点的父/子关系。
3. 只读解析方式, 无法修改XML文档的内容。
2. DOM解析
是用与平台和语言无关的方式表示XML文档的官方W3C标准，分析该结构通常需要加载整个 文档和内存中建立文档树模型。程序员可以通过操作文档树, 来完成数据的获取 修改 删除等。
优点:
文档在内存中加载, 允许对数据和结构做出更改。访问是双向的，可以在任何时候在树中双向解析数据。
缺点:
文档全部加载在内存中 , 消耗资源大。
3. JDOM解析
目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一 个Java特定模型，JDOM一直得到大力推广和促进。
JDOM文档声明其目的是“使用20%（或更少）的精力解决80%（或更多）Java/XML问题” （根据学习曲线假定为20%）
优点:
使用具体类而不是接口，简化了DOM的API。
大量使用了Java集合类，方便了Java开发人员。
缺点:
没有较好的灵活性。
性能不是那么优异。
4. DOM4J解析
它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath 支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项， DOM4J是一个非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一 个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML。
目前许多开源项目中大量采用DOM4J , 例如:Hibernate。
java中xml有什么作用，用在什么地方？
java中xml一般是用来当做配置文件的，比方说struts的struts.xml、spring的application.xml，这里面记录的一般是配置信息，比方说servlet配置，映射注入配置等等都可以用xml来配置，当然配置也可以写入数据库，如果配置和程序的业务无关，也和系统配置无关，仅仅和系统构架有关，那就可以把配置写入xml里面来存储这些配置。
在java中解析xml有哪几种方法
(1)DOM解析
DOM是html和xml的应用程序接口(API)，以层次结构（类似于树型）来组织节点和信息片段，映射XML文档的结构，允许获取
和操作文档的任意部分，是W3C的官方标准
【优点】
①允许应用程序对数据和结构做出更改。
②访问是双向的，可以在任何时候在树中上下导航，获取和操作任意部分的数据。
【缺点】
①通常需要加载整个XML文档来构造层次结构，消耗资源大。
【解析详解】
①构建Document对象：
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = bdf.newDocumentBuilder();
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(xml文件);
Document doc = bd.parse(is);
②遍历DOM对象
Document： XML文档对象，由解析器获取
NodeList： 节点数组
Node： 节点(包括element、#text)
Element： 元素，可用于获取属性参数
(2)SAX(Simple API for XML)解析
流模型中的"推"模型分析方式。通过事件驱动，每发现一个节点就引发一个事件，事件推给事件处理器，通过回调方法
完成解析工作，解析XML文档的逻辑需要应用程序完成
【优势】
①不需要等待所有数据都被处理，分析就能立即开始。
②只在读取数据时检查数据，不需要保存在内存中。
③可以在某个条件得到满足时停止解析，不必解析整个文档。
④效率和性能较高，能解析大于系统内存的文档。
【缺点】
①需要应用程序自己负责TAG的处理逻辑（例如维护父/子关系等），文档越复杂程序就越复杂。
②单向导航，无法定位文档层次，很难同时访问同一文档的不同部分数据，不支持XPath。
【原理】
简单的说就是对文档进行顺序扫描，当扫描到文档(document)开始与结束、元素(element)开始与结束时通知事件
处理函数(回调函数)，进行相应处理，直到文档结束
【事件处理器类型】
①访问XML DTD：DTDHandler
②低级访问解析错误：ErrorHandler
③访问文档内容：ContextHandler
【DefaultHandler类】
SAX事件处理程序的默认基类，实现了DTDHandler、ErrorHandler、ContextHandler和EntityResolver接口，通常
做法是，继承该基类，重写需要的方法，如startDocument()
【创建SAX解析器】
SAXParserFactory saxf = SAXParserFactory.newInstance();
SAXParser sax = saxf.newSAXParser();
注：关于遍历
①深度优先遍历(Depthi-First Traserval)
②广度优先遍历(Width-First Traserval)
(3)JDOM(Java-based Document Object Model)
Java特定的文档对象模型。自身不包含解析器，使用SAX
【优点】
①使用具体类而不是接口，简化了DOM的API。
②大量使用了Java集合类，方便了Java开发人员。
【缺点】
①没有较好的灵活性。
②性能较差。
(4)DOM4J(Document Object Model for Java)
简单易用，采用Java集合框架，并完全支持DOM、SAX和JAXP
【优点】
①大量使用了Java集合类，方便Java开发人员，同时提供一些提高性能的替代方法。
②支持XPath。
③有很好的性能。
【缺点】
①大量使用了接口，API较为复杂。
(5)StAX(Streaming API for XML)
流模型中的拉模型分析方式。提供基于指针和基于迭代器两种方式的支持,JDK1.6新特性
【和推式解析相比的优点】
①在拉式解析中，事件是由解析应用产生的，因此拉式解析中向客户端提供的是解析规则，而不是解析器。
②同推式解析相比，拉式解析的代码更简单，而且不用那么多库。
③拉式解析客户端能够一次读取多个XML文件。
④拉式解析允许你过滤XML文件和跳过解析事件。
【简介】
StAX API的实现是使用了Java Web服务开发（JWSDP）1.6，并结合了Sun Java流式XML分析器(SJSXP)-它位于
javax.xml.stream包中。XMLStreamReader接口用于分析一个XML文档，而XMLStreamWriter接口用于生成一个
XML文档。XMLEventReader负责使用一个对象事件迭代子分析XML事件-这与XMLStreamReader所使用的光标机制
形成对照。
java解析xml的几种方式哪种最好？
在java中解析xml有哪几种方法?
1、JDOM生成和解析XML
为减少DOM、SAX的编码量,出现了JDOM
优点:20-80原则,极大减少了代码量。
使用场合:要实现的功能简单,如解析、创建等,但在底层,JDOM还是使用SAX(最常用)、DOM、Xanan文档。
2、SAX生成和解析XML文档
为解决DOM的问题,出现了SAX,SAX
事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时发送事件,程序员编写响应这些事件的代码,保存数据。
优点:不用事先调入整个文档,占用资源少。SAX解析器代码比DOM解析器代码小,适于Applet下载。
缺点:不是持久的,事件过后若没保存数据,那么数据就丢了。无状态性,从事件中只能得到文本,但不知该文本属于哪个元素。
使用场合:Applet。只需XML文档的少量内容,很少回头访问,机器内存少。
3、DOM生成和解析XML文档
为XML文档的已解析版本定义了一组接口。解析器读入整个文档,然后构建一个驻留内存的树结构,然后代码就可以使用 DOM 接口来操作这个树结构。
优点:整个文档树在内存中,便于操作,支持删除、修改、重新排列等多种功能。
缺点:将整个文档调入内存(包括无用的节点),浪费时间和空间。
使用场合:一旦解析了文档还需多次访问这些数据,硬件资源充足(内存、CPU)。
java解析xml有几种方法
DOM（Document Object Model）解析
优点
允许应用程序对数据和结构做出更改
访问是双向的，可以在任何时候在树中上、下导航获取、操作任意部分的数据
缺点
解析XML文档的需要加载整个文档来构造层次结构，消耗内存资源大。
应用范围
遍历能力强，常应用于XML文档需要频繁改变的服务中。
解析步骤
创建一个 DocumentBuilderFactory 对象
创建一个 DocumentBuilder 对象
通过 DocumentBuilder 的 parse() 方法加载 XML 到当前工程目录下
通过 getElementsByTagName() 方法获取所有 XML 所有节点的集合
遍历所有节点
通过 item() 方法获取某个节点的属性
通过 getNodeName() 和 getNodeValue() 方法获取属性名和属性值
通过 getChildNodes() 方法获取子节点，并遍历所有子节点
通过 getNodeName() 和 getTextContent() 方法获取子节点名称和子节点值
package Paint;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class DOMTest {
public static void main(String[] args) {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try {
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse("./src/Paint/hello.xml");
NodeList bookList = document.getElementsByTagName("book"); //节点集
int bookCnt = bookList.getLength();
System.err.println("一共获取到" + bookCnt +"本书");
for(int i=0; i Node book = bookList.item(i);
NamedNodeMap attrs = book.getAttributes();
for(int j=0; j Node attr = attrs.item(j);
System.err.println(attr.getNodeName()+"---"+attr.getNodeValue());//id
}
NodeList childNodes = book.getChildNodes();
for(int k=0; k if(childNodes.item(k).getNodeType() == Node.ELEMENT_NODE){
System.out.println(childNodes.item(k).getNodeName()+"---" + childNodes.item(k).getTextContent());
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
SAX（Simple API for XML）解析
优点
不需要等待所有的数据被处理，解析就可以开始
只在读取数据时检查数据，不需要保存在内存中
可以在某一个条件满足时停止解析，不必要解析整个文档
效率和性能较高，能解析大于系统内存的文档
缺点
解析逻辑复杂，需要应用层自己负责逻辑处理，文档越复杂程序越复杂
单向导航，无法定位文档层次，很难同时同时访问同一文档的不同部分数据，不支持 XPath
解析步骤
获取一个 SAXParserFactory 的实例
通过 factory() 获取 SAXParser 实例
创建一个 handler() 对象
通过 parser 的 parse() 方法来解析 XML
SAXTest.java
package Paint;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.SAXException;
public class SAXTest {
public static void main(String[] args) {
// 获取实例
SAXParserFactory factory = SAXParserFactory.newInstance();
try {
SAXParser parser = factory.newSAXParser();
SAXParserHandler handler = new SAXParserHandler();
parser.parse("./src/Paint/hello.xml", handler);
System.err.println("共有"+ handler.getBookList().size()+ "本书");
for(Book book : handler.getBookList()){
System.out.println(book.getName());
System.out.println("id=" + book.getId());
System.out.println(book.getAuthor());
System.out.println(book.getYear());
System.out.println(book.getPrice());
System.out.println(book.getLanguage());
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
SAXParserHandler.java
package Paint;
import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class SAXParserHandler extends DefaultHandler {
String value = null;
Book book = null;
private ArrayList bookList = new ArrayList();
public ArrayList getBookList() {
return bookList;
}
/*
* XML 解析开始
*/
public void startDocument() throws SAXException {
super.startDocument();
System.out.println("xml 解析开始");
}
/*
* XML 解析结束
*/
public void endDocument() throws SAXException {
super.endDocument();
System.out.println("xml 解析结束");
}
/*
* 解析 XML 元素开始
*/
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
super.startElement(uri, localName, qName, attributes);
if(qName.equals("book")){
book = new Book();
for(int i=0; i System.out.println(attributes.getQName(i)+"---"+attributes.getValue(i));
if(attributes.getQName(i).equals("id")){
book.setId(attributes.getValue(i));
}
}
}else if(!qName.equals("bookstore")){
System.out.print("节点名："+ qName + "---");
}
}
/*
*解析 XML 元素结束
*/
public void endElement(String uri, String localName, String qName)
throws SAXException {
super.endElement(uri, localName, qName);
if(qName.equals("book")){
bookList.add(book);
book = null;
}
else if(qName.equals("name")){
book.setName(value);
}else if(qName.equals("year")){
book.setYear(value);
}else if(qName.equals("author")){
book.setAuthor(value);
}else if(qName.equals("price")){
book.setPrice(value);
}else if(qName.equals("language")){
book.setLanguage(value);
}
}
public void characters(char[] ch, int start, int length)
throws SAXException {
super.characters(ch, start, length);
// 获取节点值数组
value = new String(ch, start, length);
if(!value.trim().equals("")){
System.out.println("节点值："+value);
}
}
}
