java解析xml之一:使用SAX与DOM

一.概要

　　用Java解析XML文档，最常用的有两种方法：使用基于事件的XML简单API（Simple API for XML）称为SAX和基于树和节点的文档对象模型（Document Object Module）称为DOM。Sun公司提供了Java API for XML Parsing（JAXP）接口来使用SAX和DOM，通过JAXP，我们可以使用任何与JAXP兼容的XML解析器。
　　
　　JAXP接口包含了三个包：
　　
　　（1）org.w3c.dom　W3C推荐的用于XML标准规划文档对象模型的接口。
　　
　　（2）org.xml.sax　 用于对XML进行语法分析的事件驱动的XML简单API（SAX）
　　
　　（3）javax.xml.parsers解析器工厂工具，程序员获得并配置特殊的特殊语法分析器。

二.实例

1.所需xml文件

Test.xml

<?xml version="1.0" encoding="UTF-8"?>
<books>
  <book email="[email protected]">
  <name>C++编程思想</name>
  <price>60.0</price>
  </book>
</books>

students.xml

<?xml version="1.0" encoding="gb2312"?>
<?xml-stylesheet type="text/xsl" href="students.xsl"?>
<students>
  <student sn="04378066">
     <name>ldz</name>
     <age>23</age>
  </student>
  <student sn="04378069">
     <name>zeh</name>
     <age>21</age>
  </student>
</students>

 2.将xml文件转化为dom：

package domParser;

import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
//下面主要是org.xml.sax包的类
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;


public class DOMConvert {

    public static void main(String[] args) {
        //DOM解析器的工厂实例
        DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
        try {
            //从DOM工厂获得DOM解析器
            DocumentBuilder db=dbf.newDocumentBuilder();
            //解析XML文档的输入流，得到一个Document
            Document doc=db.parse(new File("xmlFil/students.xml"));
            //建立一个XML节点
            Element eltStu=doc.createElement("student");
            Element eltName=doc.createElement("name");
            Element eltAge=doc.createElement("age");

            Text textName=doc.createTextNode("yyr");
            Text textAge=doc.createTextNode("22");

            eltName.appendChild(textName);
            eltAge.appendChild(textAge);

            eltStu.appendChild(eltName);
            eltStu.appendChild(eltAge);
            eltStu.setAttribute("sn","04378072");
            //将此节点插入根的孩子中
            Element root=doc.getDocumentElement();
            root.appendChild(eltStu);
            //获取stuent标签节点
            NodeList nl=root.getElementsByTagName("student");
            //删除第一个节点
            root.removeChild(nl.item(0));
            //获取第一个节点
            Element eltStuChg=(Element)nl.item(0);
            //获取age标签节点
            Node nodeAgeChg=eltStuChg.getElementsByTagName("age").item(0);
            nodeAgeChg.getFirstChild().setNodeValue("20");

            int len=nl.getLength();
            for(int i=0;i
                Element elt=(Element)nl.item(i);
                System.out.println("编号：" + elt.getAttribute("sn"));

                Node nodeName=elt.getElementsByTagName("name").item(0);
                Node nodeAge=elt.getElementsByTagName("age").item(0);

                String name=nodeName.getFirstChild().getNodeValue();
                String age=nodeAge.getFirstChild().getNodeValue();

                System.out.println("姓名："+name);
                System.out.println("年龄：" + age);

                System.out.println("--------------------");
            }
            //实例化一个转换工厂
            TransformerFactory tff=TransformerFactory.newInstance();
            //获取一个转换实例
            Transformer tf=tff.newTransformer();
            //设置输出属性
            tf.setOutputProperty("encoding","gb2312");
            //根据Document对象新建一个DOM数据源
            DOMSource source=new DOMSource(doc);
            //定义输出流
            StreamResult result=new StreamResult(new File("convert.xml"));
            //从数据源转换至输出流
            tf.transform(source,result);
        }
        catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        catch (SAXException e) {
            e.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        catch (TransformerConfigurationException e) {
            e.printStackTrace();
        }
        catch (TransformerException e) {
            e.printStackTrace();
        }
    }
}

3.解析DOM树

package domParser;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
//下面主要是org.xml.sax包的类
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;


public class DomParser {

    public DomParser() {
        //DOM解析器的工厂实例
        DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();
        try {
            //从DOM工厂获得DOM解析器
            DocumentBuilder dombuilder=domfac.newDocumentBuilder();
            //把要解析的XML文档转化为输入流
            InputStream is=new FileInputStream("Test.xml");
            //解析XML文档的输入流，得到一个Document
            Document doc=dombuilder.parse(is);
            //得到XML文档的根节点
            Element root=doc.getDocumentElement();
            //得到节点的子节点
            NodeList books=root.getChildNodes();
            if(books!=null) {
                for(int i=0;i
                    Node book=books.item(i);
                    if(book.getNodeType()==Node.ELEMENT_NODE) {
                        //取得节点的属性值
                        String email=book.getAttributes().getNamedItem("email").getNodeValue();
                        System.out.println(email);
                        //轮循子节点
                        for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling()) {
                            if(node.getNodeType()==Node.ELEMENT_NODE) {
                                if(node.getNodeName().equals("name")) {
                                    String name=node.getNodeValue();
                                    node.setNodeValue("Java编程思想");
                                    String name1=node.getFirstChild().getNodeValue();
                                    System.out.println(name);
                                    System.out.println(name1);
                                }
                                if(node.getNodeName().equals("price")) {
                                    String price=node.getFirstChild().getNodeValue();
                                    System.out.println(price);
                                }
                            }
                        }
                    }
                }
            }
        }
        catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        catch (SAXException e) {
            e.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args)
    {
        new DomParser();
    }
}

4.打印DOM树

package domParser;

import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
//下面主要是org.xml.sax包的类
import org.w3c.dom.*;
import org.xml.sax.SAXException;

public class DOMPrinter{
    //打印指定节点(节点名:节点值)
    public static void printNodeInfo(Node node){
        System.out.println(node.getNodeName()+" : "+node.getNodeValue());
    }
    //递归打印全部节点
    public static void printNode(Node node){
        short nodeType=node.getNodeType();
        //判断节点类型
        switch(nodeType){
            //前缀节点
            case Node.PROCESSING_INSTRUCTION_NODE:
                System.out.println("-----------PI start-----------");
                printNodeInfo(node);
                System.out.println("-----------PI end-----------");
                break;
            //元素节点
            case Node.ELEMENT_NODE:
                System.out.println("-----------Element start-----------");
                printNodeInfo(node);
                System.out.println("-----------Element end-----------");
                //打印节点属性值
                NamedNodeMap attrs=node.getAttributes();
                int attrNum=attrs.getLength();
                for(int i=0;i
                    Node attr=attrs.item(i);
                    System.out.println("-----------Attribute start-----------");
                    printNodeInfo(attr);
                    System.out.println("-----------Attribute end-----------");
                }
                break;
            //文本节点
            case Node.TEXT_NODE:
                System.out.println("-----------Text start-----------");
                printNodeInfo(node);
                System.out.println("-----------Text end-----------");
                break;
            default:
                break;
        }
        //递归打印节点信息
        Node child=node.getFirstChild();
        while(child!=null){
            printNode(child);
            child=child.getNextSibling();
        }
    }

    public static void main(String[] args){
        //DOM解析器的工厂实例
        DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
        try{
            //从DOM工厂获得DOM解析器
            DocumentBuilder db=dbf.newDocumentBuilder();
            //解析XML文档的输入流，得到一个Document
            Document doc=db.parse(new File("students.xml"));
            //打印节点
            printNode(doc);
        }
        catch (ParserConfigurationException e){
            e.printStackTrace();
        }
        catch (SAXException e){
            e.printStackTrace();
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }
}