XML解析
DOM：(Document Object Model, 文档对象模型) 是 W3C 组织推荐的处理 XML 的一种方式。
SAX：(Simple API for XML) 不是官方标准，但它是XML社区事实上的标准(相当于是一个民间标准)，几乎所有的 XML 解析器都支持它。
Jdom：是第一个java特定模型，简化了与xml的交互并且比使用dom实现更快。
Dom4j：是一个简单、灵活的开放源代码的库。Dom4j是由早期开发JDOM的人分离出来而后独立开发的。与JDOM不同的是，dom4j使用接口和抽象基类，虽然Dom4j的API相对要复杂一些，但它提供了比JDOM更好的灵活性。Dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极易使用的特点。
（一）DOM解析:
采用dom解析，会将xml文档全部载入到内存当中，然后将xml文档
中的所有内容转换为tree上的节点(对象)。
优点：
可以随机解析
可以修改文件
可以创建xml文件
适合解析小文件
缺点：
不适合解析大文件，对内存要求高
（二）SAX解析：
SAX：基于事件处理的机制
sax解析xml文件时，遇到开始标签，结束标签，字符内容，空白字符等都会触发各自的方法。
优点：
适合解析大文件，对内存要求不高
轻量级的解析数据方式，效率更高
缺点：
不能随机解析
不能修改XML文件，只能进行查询
JAXP介绍(Java API for XMLProcessing)
JAXP 是J2SE的一部分，它由javax.xml、org.w3c.dom 、org.xml.sax 包及其子包组成.
在 javax.xml.parsers 包中，定义了几个工厂类，程序员调用这些工厂类，可以得到对xml文档进行解析的 DOM 或 SAX 的解析器对象。
------------------------------------------------------------------------------------------
DOM解析：
1调用DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。
2调用工厂对象的newDocumentBuilder方法得到 DOM 解析器对象。
3调用DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进而可以利用DOM特性对整个XML文档进行操作。
例:
//获得生产DocumentBuilder对象的工厂实例
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
//设置是否支持名称空间 默认是不支持
factory.setNamespaceAware(true);
//通过工厂获得一个DocumentBuilder对象
DocumentBuilder builder = factory.newDocumentBuilder();
//如果xml中声明了对DTD的引用,则可以这样忽略掉DTD,否则会自动根据地址查找DTD
//其实就是给builder设置一个自定义的实体解析器(匿名内部类)
builder.setEntityResolver(new EntityResolver() {
@Override
public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
byte[] data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>".getBytes();
return new InputSource(new ByteArrayInputStream(data));
}
});
//获得Document对象,可以表示一个xml文档
Document document = builder.parse(fileName);
//获得根元素
//注意Document和Element都是Node的子接口
Element root = document.getDocumentElement();
//获取根元素的相关属性
root.getNodeName()
//获得根元素下面的所有子元素
//注意回车换行也算是一个节点(文本节点)
//xml文件中主要是文本节点和元素节点
//元素节点中还包含属性节点
//我们要解析的值就在这些节点中
//这一步之后就是循环解析节点中的数据（获取节点名称 属性名 属性值...）
NodeList rootChildNodes = root.getChildNodes();
System.out.println(root.getNodeName());
DOM创建xml：
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(fileName);
//创建一个stu元素 并且设置属性
Element stu = document.createElement("stu");
stu.setAttribute("id", s.getId()+"");
//创建name和age元素
Element name = document.createElement("name");
Element age = document.createElement("age");
//设置name和age元素中的文本值
name.setTextContent(s.getName());
age.setTextContent(s.getAge()+"");
//name和age元素追加到stu元素里面
stu.appendChild(name);
stu.appendChild(age);
//stu元素追加到根元素里面（此时文档中并没有真正添加一个元素）
document.getDocumentElement().appendChild(stu);
//得到TransformerFactory工厂实例
TransformerFactory tff = TransformerFactory.newInstance();
//通过工厂得到一个转换器
Transformer tf = tff.newTransformer();
//设置编码
tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
//设置格式
tf.setOutputProperty(OutputKeys.INDENT, "yes");
//把一个dom模型转换成对应的xml文件
tf.transform(new DOMSource(document), new StreamResult(fileName));
DOM删除xml的某个节点：
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(fileName);
NodeList elementsByTagName = document.getElementsByTagName("stu");
for(int i=0;i<elementsByTagName.getLength();i++){
Node node = elementsByTagName.item(i);
String idValue = node.getAttributes().getNamedItem("id").getNodeValue();
if(idValue.equals(stu_id)){
node.getParentNode().removeChild(node);
break;
}
}
//得到TransformerFactory工厂实例
TransformerFactory tff = TransformerFactory.newInstance();
//通过工厂得到一个转换器
Transformer tf = tff.newTransformer();
//设置编码
tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
//设置格式
tf.setOutputProperty(OutputKeys.INDENT, "yes");
//把一个dom模型转换成对应的xml文件
tf.transform(new DOMSource(document), new StreamResult(fileName));
在使用DOM解析XML文档时，需要读取整个XML文档，在内存中构建代表整个DOM 树的Doucment对象，从而再对XML文档进行操作。此种情况下，如果XML 文档特别大，就会消耗计算机的大量内存，严重情况下可能还会导致内存溢出。
------------------------------------------------------------------------------------------
SAX解析：
SAX解析允许在读取文档的时候，即对文档进行处理，而不必等到整个文档装载完才会文档进行操作。
SAX解析器在发现XML文档中的内容时就会调用程序员自己重写之后的方法， 如何处理这些内容，由自己决定。
在基于SAX的程序中,有五个最常用SAX事件
startDocument() ---> 解析器发现了文档的开始标签
endDocument() ---> 解析器发现了文档结束标签
startElement() ---> 解析器发现了一个起始标签
character() ---> 解析器发现了标签里面的文本值
endElement() ---> 解析器发现了一个结束标签
SAX采用事件处理的方式解析XML文件，利用 SAX 解析 XML 文档，涉及两个部分，解析器和事件处理器。
解析器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个XML文档。
解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的XML文件内容作为方法的参数传递给事件处理器。
事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以得到SAX解析器解析到的数据，从而可以决定如何对数据进行处理。
SAX解析步骤：
使用SAXParserFactory创建SAX解析工厂
SAXParserFactory spf = SAXParserFactory.newInstance();
通过SAX解析工厂得到解析器对象
SAXParser sp = spf.newSAXParser();
将解析对象和事件处理器对象关联
sp.parse("src/class.xml", new DefaultHandler(){...});
// DefaultHandler中有五个方法需要重写
//解析器发现了文档的开始标签调用的方法
public void startDocument() throws SAXException {
}
//解析器发现了文档的结束标签调用的方法
@Override
public void endDocument() throws SAXException {
}
//解析器发现了一个起始标签调用的方法
//uri 命名空间
//localName 本地名称（不带前缀）
//qName 限定的名称（带有前缀）
//attributes 附加到元素的属性
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
}
//解析器发现了一个结束标签 调用的方法
//uri 命名空间
//localName 本地名称 （不带前缀）
//qName 限定的名称（带有前缀）
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
}
//解析器发现了标签里面的文本值调用的方法
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
}
------------------------------------------------------------------------------------------
Dom4j解析：
*使用Dom4j解析，需要dom4j的jar包。
DOM4j中，获得Document对象的方式有三种：
1.读取XML文件,获得document对象
SAXReader reader = new SAXReader();
Document document = reader.read(new File(“src/input.xml"));
2.解析XML形式的文本,得到document对象
String text = "<members></members>";
Document document = DocumentHelper.parseText(text);
3.主动创建document对象
Document document = DocumentHelper.createDocument();
//创建根节点
Element root = document.addElement("members");
root.addAttribute("name", "上海");
Element num = root.addElement("peopleNumber");
num.addText("23343");
==========================================================================================
Dom4j解析实例：
------------------------------------------------------------------------------------------
xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<test>
<hang1 id="h1">
<lie1 class="1l1">第1行第1列</lie1>
<lie2 class="1l2">第1行第2列</lie2>
</hang1>
<hang2 id="h2">
<lie1 class="2l1">第2行第1列</lie1>
<lie2 class="2l2">第2行第2列</lie2>
</hang2>
</test>
------------------------------------------------------------------------------------------
java文件：
package dom4j;
import java.io.File;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
public class dom4j {
public static void main(String[] args) throws Exception {
//获得Document对象
SAXReader reader=new SAXReader();
Document document=reader.read(new File("src/dom4j/test.xml"));
//获得根节点
Element root=document.getRootElement();
//输出根节点名称
System.out.println(root.getName());
//获取根节点下的hang1节点（名称已知）
Element hang1=root.element("hang1");
//获取hang1节点的id属性值（名称已知）
System.out.println(hang1.attributeValue("id"));
//获取hang1下的lie1节点（名称已知）
Element lie1=hang1.element("lie1");
//获取lie1节点的class属性值（名称已知）
System.out.println(lie1.attributeValue("class"));
//获取lie1节点中的内容
System.out.println(lie1.getText());
System.out.println("-----------");
//遍历root下的子节点
Iterator i=root.elementIterator();
while(i.hasNext()){
Element e = (Element) i.next();
System.out.println(e.getName());
}
System.out.println("-----------");
//遍历hang1下的子节点
Iterator j=hang1.elementIterator();
while(j.hasNext()){
Element e = (Element) j.next();
System.out.println(e.getName());
}
}
}
------------------------------------------------------------------------------------------
控制台输出：
test
h1
1l1
第1行第1列
-----------
hang1
hang2
-----------
lie1
lie2
====================================================================================
XML有四种解析方式：DOM，SAX，Jdom，Dom4j
SAX：(Simple API for XML) 不是官方标准，但它是XML社区事实上的标准(相当于是一个民间标准)，几乎所有的 XML 解析器都支持它。
Jdom：是第一个java特定模型，简化了与xml的交互并且比使用dom实现更快。
Dom4j：是一个简单、灵活的开放源代码的库。Dom4j是由早期开发JDOM的人分离出来而后独立开发的。与JDOM不同的是，dom4j使用接口和抽象基类，虽然Dom4j的API相对要复杂一些，但它提供了比JDOM更好的灵活性。Dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极易使用的特点。
（一）DOM解析:
采用dom解析，会将xml文档全部载入到内存当中，然后将xml文档
中的所有内容转换为tree上的节点(对象)。
优点：
可以随机解析
可以修改文件
可以创建xml文件
适合解析小文件
缺点：
不适合解析大文件，对内存要求高
（二）SAX解析：
SAX：基于事件处理的机制
sax解析xml文件时，遇到开始标签，结束标签，字符内容，空白字符等都会触发各自的方法。
优点：
适合解析大文件，对内存要求不高
轻量级的解析数据方式，效率更高
缺点：
不能随机解析
不能修改XML文件，只能进行查询
JAXP介绍(Java API for XMLProcessing)
JAXP 是J2SE的一部分，它由javax.xml、org.w3c.dom 、org.xml.sax 包及其子包组成.
在 javax.xml.parsers 包中，定义了几个工厂类，程序员调用这些工厂类，可以得到对xml文档进行解析的 DOM 或 SAX 的解析器对象。
------------------------------------------------------------------------------------------
DOM解析：
1调用DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。
2调用工厂对象的newDocumentBuilder方法得到 DOM 解析器对象。
3调用DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进而可以利用DOM特性对整个XML文档进行操作。
例:
//获得生产DocumentBuilder对象的工厂实例
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
//设置是否支持名称空间 默认是不支持
factory.setNamespaceAware(true);
//通过工厂获得一个DocumentBuilder对象
DocumentBuilder builder = factory.newDocumentBuilder();
//如果xml中声明了对DTD的引用,则可以这样忽略掉DTD,否则会自动根据地址查找DTD
//其实就是给builder设置一个自定义的实体解析器(匿名内部类)
builder.setEntityResolver(new EntityResolver() {
@Override
public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
byte[] data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>".getBytes();
return new InputSource(new ByteArrayInputStream(data));
}
});
//获得Document对象,可以表示一个xml文档
Document document = builder.parse(fileName);
//获得根元素
//注意Document和Element都是Node的子接口
Element root = document.getDocumentElement();
//获取根元素的相关属性
root.getNodeName()
//获得根元素下面的所有子元素
//注意回车换行也算是一个节点(文本节点)
//xml文件中主要是文本节点和元素节点
//元素节点中还包含属性节点
//我们要解析的值就在这些节点中
//这一步之后就是循环解析节点中的数据（获取节点名称 属性名 属性值...）
NodeList rootChildNodes = root.getChildNodes();
System.out.println(root.getNodeName());
DOM创建xml：
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(fileName);
//创建一个stu元素 并且设置属性
Element stu = document.createElement("stu");
stu.setAttribute("id", s.getId()+"");
//创建name和age元素
Element name = document.createElement("name");
Element age = document.createElement("age");
//设置name和age元素中的文本值
name.setTextContent(s.getName());
age.setTextContent(s.getAge()+"");
//name和age元素追加到stu元素里面
stu.appendChild(name);
stu.appendChild(age);
//stu元素追加到根元素里面（此时文档中并没有真正添加一个元素）
document.getDocumentElement().appendChild(stu);
//得到TransformerFactory工厂实例
TransformerFactory tff = TransformerFactory.newInstance();
//通过工厂得到一个转换器
Transformer tf = tff.newTransformer();
//设置编码
tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
//设置格式
tf.setOutputProperty(OutputKeys.INDENT, "yes");
//把一个dom模型转换成对应的xml文件
tf.transform(new DOMSource(document), new StreamResult(fileName));
DOM删除xml的某个节点：
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(fileName);
NodeList elementsByTagName = document.getElementsByTagName("stu");
for(int i=0;i<elementsByTagName.getLength();i++){
Node node = elementsByTagName.item(i);
String idValue = node.getAttributes().getNamedItem("id").getNodeValue();
if(idValue.equals(stu_id)){
node.getParentNode().removeChild(node);
break;
}
}
//得到TransformerFactory工厂实例
TransformerFactory tff = TransformerFactory.newInstance();
//通过工厂得到一个转换器
Transformer tf = tff.newTransformer();
//设置编码
tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
//设置格式
tf.setOutputProperty(OutputKeys.INDENT, "yes");
//把一个dom模型转换成对应的xml文件
tf.transform(new DOMSource(document), new StreamResult(fileName));
在使用DOM解析XML文档时，需要读取整个XML文档，在内存中构建代表整个DOM 树的Doucment对象，从而再对XML文档进行操作。此种情况下，如果XML 文档特别大，就会消耗计算机的大量内存，严重情况下可能还会导致内存溢出。
------------------------------------------------------------------------------------------
SAX解析：
SAX解析允许在读取文档的时候，即对文档进行处理，而不必等到整个文档装载完才会文档进行操作。
SAX解析器在发现XML文档中的内容时就会调用程序员自己重写之后的方法， 如何处理这些内容，由自己决定。
在基于SAX的程序中,有五个最常用SAX事件
startDocument() ---> 解析器发现了文档的开始标签
endDocument() ---> 解析器发现了文档结束标签
startElement() ---> 解析器发现了一个起始标签
character() ---> 解析器发现了标签里面的文本值
endElement() ---> 解析器发现了一个结束标签
SAX采用事件处理的方式解析XML文件，利用 SAX 解析 XML 文档，涉及两个部分，解析器和事件处理器。
解析器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个XML文档。
解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的XML文件内容作为方法的参数传递给事件处理器。
事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以得到SAX解析器解析到的数据，从而可以决定如何对数据进行处理。
SAX解析步骤：
使用SAXParserFactory创建SAX解析工厂
SAXParserFactory spf = SAXParserFactory.newInstance();
通过SAX解析工厂得到解析器对象
SAXParser sp = spf.newSAXParser();
将解析对象和事件处理器对象关联
sp.parse("src/class.xml", new DefaultHandler(){...});
// DefaultHandler中有五个方法需要重写
//解析器发现了文档的开始标签调用的方法
public void startDocument() throws SAXException {
}
//解析器发现了文档的结束标签调用的方法
@Override
public void endDocument() throws SAXException {
}
//解析器发现了一个起始标签调用的方法
//uri 命名空间
//localName 本地名称（不带前缀）
//qName 限定的名称（带有前缀）
//attributes 附加到元素的属性
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
}
//解析器发现了一个结束标签 调用的方法
//uri 命名空间
//localName 本地名称 （不带前缀）
//qName 限定的名称（带有前缀）
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
}
//解析器发现了标签里面的文本值调用的方法
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
}
------------------------------------------------------------------------------------------
Dom4j解析：
*使用Dom4j解析，需要dom4j的jar包。
DOM4j中，获得Document对象的方式有三种：
1.读取XML文件,获得document对象
SAXReader reader = new SAXReader();
Document document = reader.read(new File(“src/input.xml"));
2.解析XML形式的文本,得到document对象
String text = "<members></members>";
Document document = DocumentHelper.parseText(text);
3.主动创建document对象
Document document = DocumentHelper.createDocument();
//创建根节点
Element root = document.addElement("members");
root.addAttribute("name", "上海");
Element num = root.addElement("peopleNumber");
num.addText("23343");
==========================================================================================
Dom4j解析实例：
------------------------------------------------------------------------------------------
xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<test>
<hang1 id="h1">
<lie1 class="1l1">第1行第1列</lie1>
<lie2 class="1l2">第1行第2列</lie2>
</hang1>
<hang2 id="h2">
<lie1 class="2l1">第2行第1列</lie1>
<lie2 class="2l2">第2行第2列</lie2>
</hang2>
</test>
------------------------------------------------------------------------------------------
java文件：
package dom4j;
import java.io.File;
import java.util.Iterator;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
public class dom4j {
public static void main(String[] args) throws Exception {
//获得Document对象
SAXReader reader=new SAXReader();
Document document=reader.read(new File("src/dom4j/test.xml"));
//获得根节点
Element root=document.getRootElement();
//输出根节点名称
System.out.println(root.getName());
//获取根节点下的hang1节点（名称已知）
Element hang1=root.element("hang1");
//获取hang1节点的id属性值（名称已知）
System.out.println(hang1.attributeValue("id"));
//获取hang1下的lie1节点（名称已知）
Element lie1=hang1.element("lie1");
//获取lie1节点的class属性值（名称已知）
System.out.println(lie1.attributeValue("class"));
//获取lie1节点中的内容
System.out.println(lie1.getText());
System.out.println("-----------");
//遍历root下的子节点
Iterator i=root.elementIterator();
while(i.hasNext()){
Element e = (Element) i.next();
System.out.println(e.getName());
}
System.out.println("-----------");
//遍历hang1下的子节点
Iterator j=hang1.elementIterator();
while(j.hasNext()){
Element e = (Element) j.next();
System.out.println(e.getName());
}
}
}
------------------------------------------------------------------------------------------
控制台输出：
test
h1
1l1
第1行第1列
-----------
hang1
hang2
-----------
lie1
lie2
====================================================================================