黑马生活3

                                                                                  Java解析XML

    XML解析方式主要分为两种：DOM方式和SAX方式。
DOM（Document Object Model，文档对象模型）：这种方式是W3C推荐的处理XML的一种方式。
SAX（Simple API for XML）：这种方式不是官方标准，属于开源社区XML-DEV，几乎所有的XML解析器都支持它。
XML解析开发包：
-JAXP：是SUN公司推出的解析标准实现。
-Dom4J：是开源组织推出的解析开发包。
-JDom：是开源组织推出的解析开发包。
一、DOM方式解析XML
1、JAXP
    JAXP(Java API for XML Processing)开发包是JavaSE的一部分，它由以下几个包及其子包组成：
     -org.w3c.dom:提供DOM方式解析XML的标准接口
     -org.xml.sax:提供SAX方式解析XML的标准接口
     -javax.xml:提供了解析XML文档的类
1.1 获得解析器对象
    javax.xml.parsers包中，定义了几个工厂类。我们可以通过调用这些工厂类，得到对XML文档进行解析的DOM和SAX
解析器对象。
    javax.xml.parsers 包中的DocumentBuilderFactory用于创建DOM模式的解析器对象 ， DocumentBuilderFactory是
一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法 ，这个方法会根据本地平台默认安装的解
析器，自动创建一个工厂的对象并返回。
创建DOM解析器对象的步骤：
第一步：调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。
第二步：调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象。
第三步：调用 DOM 解析器对象的 parse() 方法解析XML文档，得到代表整个文档的Document对象，进行可以利用DOM
特性对整个XML文档进行操作了。
1.2 DOM编程
1.2.1 在dom中，节点之间关系如下：
-位于一个节点之上的节点是该节点的父节点(parent)
-一个节点之下的节点是该节点的子节点（children） 
-同一层次，具有相同父节点的节点是兄弟节点（sibling） 
-一个节点的下一个层次的节点集合是节点后代(descendant)
-父、祖父节点及所有位于节点上面的，都是节点的祖先(ancestor) 
1.2.2 节点类型
    Node对象提供了一系列常量来代表结点的类型，当开发人员获得某个Node类型后，就可以把Node节点转换成相应的节点
对象(Node的子类对象)，以便于调用其特有的方法（可以查看java SE的API文档）。Node对象提供了相应的方法去获得它的
父结点或子结点。我们通过这些方法就可以读取整个XML文档的内容，或者添加、修改、删除XML文档的内容了。
1.2.3 更新XML文档
当我们添加、修改、删除XML文档的内容时，都是先通过解析器对象先得到Document，得到Document后保存到了内存中，我们
添加、修改、删除的都是内存中的Document对象中的内容，所以我们在做完添加、修改、删除的动作之后要把内存中的
Document对象更新到XML文档中。javax.xml.transform包中的Transformer类用于把代表XML文件的Document对象转换为某种
格式后进行输出，例如把xml文件应用样式后转成一个html文档。利用这个对象，当然也可以把Document对象又重新写入到一
个XML文件中。Transformer类通过transform方法完成转换操作，该方法接收一个源和一个目的地。我们可以通过：
javax.xml.transform.dom.DOMSource类来关联要转换的document对象，用javax.xml.transform.stream.StreamResult 
对象来表示数据的目的地。Transformer对象通过TransformerFactory获得。
下面是一个使用JAXP进行DOM解析XML的示例：
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;


import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


public class DemoTest {
/**
* 
* 利用JAXP进行DOM方式解析XML文档
* @throws Exception 
*/
public static void main(String[] args) throws Exception {
//得到解析器
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
//得到代表整个DOM树的document对象
Document document = builder.parse("src/demo.xml");
//test1(document);
//test2(document);
//test3(document);
//test4(document);
//test5(document);
//test6(document);
test7(document);

}
// 1、得到某个具体的节点内容
private static void test1(Document document){
NodeList nodeList = document.getElementsByTagName("作者");
Node node = nodeList.item(0);
System.out.println(node.getNodeName()+":"+node.getTextContent());
}
// 2、遍历所有元素节点（运用递归）
private static void test2(Node node){
//判断节点是否是元素节点，如果是，打印
if(node.getNodeType()==Node.ELEMENT_NODE){
System.out.println(node.getNodeName());
}
//如果不是，判断是否有子节点
NodeList nodelist = node.getChildNodes();
for(int i=0;i<nodelist.getLength();i++){
Node n = nodelist.item(i);
test2(n);
}
}
// 3、修改某个元素节点的主体内容
private static void test3(Document document) throws Exception{
Node node = document.getElementsByTagName("售价").item(1);
node.setTextContent("40.00");
//更新XML文档
Transformer tf = TransformerFactory.newInstance().newTransformer();
tf.transform(new DOMSource(document), new StreamResult("src/demo.xml"));
}
// 4、向指定元素节点中增加子元素节点
private static void test4(Document document) throws Exception{
//获得指定元素节点
Node node = document.getElementsByTagName("书").item(0);
//创建新节点
Element e = document.createElement("特价");
//设置主体内容
e.setTextContent("45.00");
//建立父子关系
node.appendChild(e);
//更新XML文档
Transformer tf = TransformerFactory.newInstance().newTransformer();
tf.transform(new DOMSource(document), new StreamResult("src/demo.xml"));
}
// 5、向指定元素节点上增加同级元素节点
private static void test5(Document document) throws Exception{
//获得指定元素节点
Node node = document.getElementsByTagName("售价").item(1);
//创建新节点
Element e = document.createElement("特价");
//设置主体内容
e.setTextContent("35.00");
//建立兄弟关系
node.getParentNode().insertBefore(e, node);
//更新XML文档
Transformer tf = TransformerFactory.newInstance().newTransformer();
tf.transform(new DOMSource(document), new StreamResult("src/demo.xml"));

}
// 6、删除指定元素节点
private static void test6(Document document) throws Exception{
//获得指定元素节点
Node node = document.getElementsByTagName("特价").item(0);
//删除元素
node.getParentNode().removeChild(node);
//更新XML文档
Transformer tf = TransformerFactory.newInstance().newTransformer();
tf.transform(new DOMSource(document), new StreamResult("src/demo.xml"));
}
// 7、操作XML文件属性
private static void test7 (Document document) throws Exception{
//获得元素节点
Node node = document.getElementsByTagName("书").item(0);
//转换成元素
Element e = (Element) node;
//获得属性值
String value = e.getAttribute("出版社");
System.out.println(value);
//增加属性
e.setAttribute("类别", "计算机");
//更新XML文档
Transformer tf = TransformerFactory.newInstance().newTransformer();
tf.transform(new DOMSource(document), new StreamResult("src/demo.xml"));
}
}
demo.xml如下：
<?xml version="1.0" encoding="UTF-8"?>
<书店>
<书 出版社="清华大学出版社">
<书名>Java编程思想</书名>
<作者>Bruce Eckel</作者>
<售价>60.00元</售价>
</书>
<书 出版社="机械工业出版社">
<书名>android基础教程</书名>
<作者>Ed_Burnette</作者>
<售价>59.00元</售价>
</书>
</书店>
二、SAX方式解析XML
    在使用 DOM 解析 XML 文档时，需要读取整个XML文档，在内存中构架代表整个 DOM 树的Doucment对象，从而
再对XML文档进行操作。此种情况下，如果XML文档特别大，就会消耗计算机的大量内存，并且容易导致内存溢出。
SAX解析允许在读取文档的时候，就对文档进行处理，而不必等到整个文档装载完才会文档进行操作。
    SAX采用事件处理的方式解析XML文件，利用 SAX 解析 XML 文档，涉及两个部分：解析器和事件处理器。解析
器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个XML文档。
解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方
法，解析器在调用事件处理器的方法时，会把当前解析到的xml文件内容作为方法的参数传递给事件处理器。事件处
理器由程序员编写，程序员通过事件处理器中方法的参数，就可以很轻松地得到sax解析器解析到的数据，从而可以
决定如何对数据进行处理。
    SAX方式解析XML文档的步骤：
第一步：使用SAXParserFactory创建SAX解析工厂
        SAXParserFactory spf = SAXParserFactory.newInstance();
第二步：通过SAX解析工厂得到解析器对象
        SAXParser sp = spf.newSAXParser();
第三步：通过解析器对象得到一个XML的读取器
        XMLReader xmlReader = sp.getXMLReader();
第四步：设置读取器的事件处理器
        xmlReader.setContentHandler(new BookParserHandler());
第五步：解析xml文件
        xmlReader.parse("book.xml");
下面是一个利用SAX方式解析XMl的示例：
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;


import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;


public class SAXTest1 {


public static void main(String[] args) throws Exception {
SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
XMLReader reader = parser.getXMLReader();
reader.setContentHandler(new DefaultHandler(){
int index = 0;
boolean isAuthor = false;


@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
if(qName.equals("作者")){
isAuthor = true;
}
}

@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
if(index==1&&isAuthor){
System.out.println(new String(ch,start,length));
}
}


@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
if(qName.equals("作者")){
index++;
isAuthor = false;
}
}

});
reader.parse("src/demo.xml");


}
}
三、使用Dom4j解析XML
    Dom4j是一个简单、灵活的开放源代码的库。Dom4j是由早期开发JDOM的人分离出来而后独立开发的。与JDOM不同的
是，dom4j使用接口和抽象基类，虽然Dom4j的API相对要复杂一些，但它提供了比JDOM更好的灵活性。Dom4j是一个非常
优秀的Java XML API，具有性能优异、功能强大和极易使用的特点。现在很多软件采用的Dom4j，例如Hibernate，包括
JAXM也用了Dom4j。使用Dom4j开发，需下载dom4j相应的jar文件。
    DOM4j中，获得Document对象的方式有三种：
1.读取XML文件,获得document对象            
                   SAXReader reader = new SAXReader();
  Document document = reader.read(new File("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");
下面是一个利用Dom4j解析XML的示例：
首先创建一个Dom4jUtil工具类
package com.itheima.day2.util;


import java.io.FileOutputStream;


import org.dom4j.Document;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;


public class Dom4jUtil {


public static Document getDocument() throws Exception{
SAXReader reader = new SAXReader();
Document document = reader.read("src/demo.xml");
return document;
}
public static void write2xml(Document document) throws Exception{
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
XMLWriter writer = new XMLWriter(new FileOutputStream("src/demo.xml"),format);
writer.write(document);
writer.close();
}
}
下面是对XML操作的类：
import java.util.List;


import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.junit.Assert;
import org.junit.Test;


import com.itheima.day2.util.Dom4jUtil;


public class Dom4j {
//得到某个具体的节点内容：
@Test
public void test1() throws Exception{
//得到解析器
Document document = Dom4jUtil.getDocument();
//得到根元素
Element root = document.getRootElement();
//得到第二书的作者
List books = root.elements("书");
Element secondBook = (Element) books.get(1);
String text = secondBook.element("作者").getText();
Assert.assertEquals("美国佬", text);
}
//遍历所有元素节点
@Test
public void test2() throws Exception{
Document document = Dom4jUtil.getDocument();
Element root = document.getRootElement();
treeWalk(root);
}
public void treeWalk(Element e){
//先打印根元素
System.out.println(e.getName());
int count = e.nodeCount();//孩子的个数
for(int i=0;i<count;i++){
Node node = e.node(i);
if(node.getNodeType()==Node.ELEMENT_NODE){
Element element = (Element) node;
treeWalk(element);
}
}
}
//修改某个元素节点的主体内容：第二本书的售价改为45
@Test
public void test3() throws Exception{
//得到解析器
Document document = Dom4jUtil.getDocument();
//得到根元素
Element root = document.getRootElement();
//得到第二书的作者
List books = root.elements("书");
Element secondBook = (Element) books.get(1);
Element price = secondBook.element("售价");
price.setText("45.00");
//更新XML文档
Dom4jUtil.write2xml(document);

}
//向指定元素节点中增加子元素节点:增加<批发价></批发价>
@Test
public void test4() throws Exception{
//得到解析器
Document document = Dom4jUtil.getDocument();
//得到根元素
Element root = document.getRootElement();
Element book = root.element("书");
//建立新元素
Element element = DocumentHelper.createElement("批发价");
element.setText("20.00");
//建立关系
book.add(element);
//更新XML文档
Dom4jUtil.write2xml(document);
}
//向指定元素节点上增加同级元素节点
@Test
public void test5() throws Exception{
//得到解析器
Document document = Dom4jUtil.getDocument();
//得到根元素
Element root = document.getRootElement();
List bookList = root.elements();
Element secondBook = (Element) bookList.get(1);
List list = secondBook.elements();
//建立新元素
Element element = DocumentHelper.createElement("批发价");
element.setText("15.00");
//建立关系
list.add(2, element);
//更新XML文档
Dom4jUtil.write2xml(document);
}
//删除指定元素节点
@Test
public void test6() throws Exception{
//得到解析器
Document document = Dom4jUtil.getDocument();
//得到根元素
Element root = document.getRootElement();
Element element = root.element("书").element("批发价");
element.getParent().remove(element);
//更新XML文档
Dom4jUtil.write2xml(document);
}
//操作XML文件属性:得到属性
@Test
public void test7() throws Exception{
//得到解析器
Document document = Dom4jUtil.getDocument();
//得到根元素
Element root = document.getRootElement();
Element element = root.element("书");
String text = element.attributeValue("出版社");
System.out.println(text);
}
//操作XML文件属性:得到属性
@Test
public void test8() throws Exception{
//得到解析器
Document document = Dom4jUtil.getDocument();
//得到根元素
Element root = document.getRootElement();
Element element = root.element("书");
element.addAttribute("类别", "计算机");
//更新XML文档
Dom4jUtil.write2xml(document);
}
}
注意：要想成功运行以上代码，需要导入Dom4j的jar包和Junit单元测试的jar包。