Java XML文件解析

树结构

DOM
Dociment Object Model文档对象模型，擅长（小规模）读/写。本质是将XML文件以树结构的方式放到缓存中进行读写。
DOM读写实例

流结构

SAX
Simple API for XML流机制解释器（推模式），擅长读。
采用事件/流模型来解析 XML 文档，更快速、更轻量。
有选择的解析和访问，不像 DOM 加载整个文档，内存要求较低。
SAX 对 XML 文档的解析为一次性读取，不创建/不存储文档对象，很难同时访问文档中的多处数据。
推模型。当它每发现一个节点就引发一个事件，而我们需要编写这些事件的处理程序。
SAX读实例
Stax
TheStreaming API for XML流机制解释器（拉模式），擅长读。
流模型中的拉模型
在遍历文档时，会把感兴趣的部分从读取器中拉出，不需要引发事件，允许我们选择性地处理节点。这大大提高了灵活性，以及整体效率。
两套处理API
基于指针的API， XMLStreamReader
基于迭代器的API，XMLEventReader
STAX读实例

DOM读写实例

读取：

public class DomRead {
    public static void main(String[] args) {
        //自上而下依次进行访问
        recursiveTraverse();
        System.out.println("====================");
        //根据名称进行搜索访问
        traverseBySearch();
    }
 
    private static void traverseBySearch() {
        try {
            //采用DOM解析XML文件
            documentBuilderFactory dbf = documentBuilderFactory.newInstance();
            documentBuilder db = dbf.newdocumentBuilder();
            document document = db.parse("domusers.xml");
 
            //调出根节点
            Element rootElement = document.getdocumentElement();
 
            //列出XML文件中所有的name节点
            NodeList nodeList = rootElement.getElementsByTagName("name");
            if (nodeList != null) {
                for (int i = 0; i < nodeList.getLength(); i++) {
                    Element element = (Element) nodeList.item(i);
                    System.out.println(element.getNodeName() + "=" + element.getTextContent());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    private static void recursiveTraverse() {
        try {
            //采用DOM解析XML文件
            documentBuilderFactory dbf = documentBuilderFactory.newInstance();
            documentBuilder db = dbf.newdocumentBuilder();
            document document = db.parse("domusers.xml");
 
            //获取所有的一级子节点
            NodeList usersList = document.getChildNodes();
            //打印一级子节点的个数（可能会包含空格的个数）
            System.out.println(usersList.getLength());
 
            //遍历一级子节点
            for (int i = 0; i < usersList.getLength(); i++) {
                Node users = usersList.item(i);
                //获取二级子节点user的列表
                NodeList userList = users.getChildNodes();
                //打印二级子节点的个数（可能包含空格的个数）
                System.out.println(userList.getLength());
 
                //遍历二级子节点
                for (int j = 0; j < userList.getLength(); j++) {
                    Node user = userList.item(j);
                    //如果当前节点是元素节点的话，进行下一步
                    if (user.getNodeType() == Node.ELEMENT_NODE) {
                        NodeList metaList = user.getChildNodes();
                        //打印出三级节点的个数
                        System.out.println(metaList.getLength());
 
                        //遍历三级节点
                        for (int k = 0; k < metaList.getLength(); k++) {
                            Node meta = metaList.item(k);
                            //如果当前节点是元素节点的话，进行下一步
                            if (meta.getNodeType() == Node.ELEMENT_NODE) {
                                System.out.println(metaList.item(k).getNodeName() + ":" + metaList.item(k).getTextContent());
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

写入：

public class DomWrite {
    public static void main(String[] args) {
        write();
    }
 
    private static void write() {
        try {
            //采用DOM解析XML文件
            documentBuilderFactory dbf = documentBuilderFactory.newInstance();
            documentBuilder db = dbf.newdocumentBuilder();
            //创建一个document节点
            document document = db.newdocument();
 
            if (document != null) {
                //创建新节点document
                Element docx = document.createElement("document");
                //创建新节点element
                Element element = document.createElement("element");
                //为新节点element添加两个属性，type=paragraph,alignment=left
                element.setAttribute("type", "paragraph");
                element.setAttribute("alignment", "left");
                //创建新节点object
                Element object = document.createElement("object");
                //为新节点object添加一条属性，type=text
                object.setAttribute("type", "text");
                //创建新节点text
                Element text = document.createElement("text");
                //为新节点text添加abcdefg的内容
                text.appendChild(document.createTextNode("abcdefg"));
                //创建新节点bold
                Element bold = document.createElement("bold");
                //为新节点bold添加true的内容
                bold.appendChild(document.createTextNode("true"));
 
                //设置object的子节点为text
                object.appendChild(text);
                //设置object的子节点为bold
                object.appendChild(bold);
                //设置element的子节点为object
                element.appendChild(object);
                //设置docx的子节点为element
                docx.appendChild(element);
                //设置document的子节点为docx
                document.appendChild(docx);
 
                TransformerFactory transformerFactory = TransformerFactory.newInstance();
                Transformer transformer = transformerFactory.newTransformer();
                DOMSource source = new DOMSource(document);
 
                //定义目标文件
                File file = new File("dom_result.xml");
                StreamResult result = new StreamResult(file);
 
                //将XML内容写到文件中
                transformer.transform(source, result);
 
                System.out.println("write xml file successfully");
            }
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

SAX读实例

package xml;

import org.dom4j.Attribute;
import org.dom4j.document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Test;

import java.io.File;
import java.util.Iterator;


public class TestSAXReader {
    @Test
    public void test() throws Exception {
        //创建SAXReader对象，用于读取XML文件
        SAXReader reader = new SAXReader();
        //读取XML文件，得到document对象
        document document = reader.read(new File("test.xml"));
        //获取根元素
        Element root = document.getRootElement();
        //获取根元素下所有子元素
        Iterator ite = root.elementIterator();
        while (ite.hasNext()) {
            //取出元素
            Element e = (Element) ite.next();
            System.out.println(e.getName());
            //获取id属性
            Attribute id = e.attribute("id");
            System.out.println(id.getName() + "=" + id.getValue());
            //获取student的子元素
            Element name = e.element("name");
            Element course = e.element("course");
            Element score = e.element("score");
            //打印
            System.out.println(name.getName() + "=" + name.getStringValue());
            System.out.println(course.getName() + "=" + course.getText());
            System.out.println(score.getName() + "=" + score.getText());
        }
    }
}

STAX读实例

package xml;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;


public class StaxReader {

    public static void main(String[] args) {
        StaxReader.readByStream();
        System.out.println("===========分割线==========");
        StaxReader.readByEvent();
    }

    //流模式
    public static void readByStream() {
        String xmlFile = "books.xml";
        XMLInputFactory factory = XMLInputFactory.newFactory();
        XMLStreamReader streamReader = null;
        try {
            streamReader = factory.createXMLStreamReader(new FileReader(xmlFile));
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 基于指针遍历
        try {
            while (streamReader.hasNext()) {
                int event = streamReader.next();
                // 如果是元素的开始
                if (event == XMLStreamConstants.START_ELEMENT) {
                    // 列出所有书籍名称
                    if ("title".equalsIgnoreCase(streamReader.getLocalName())) {
                        System.out.println("title:" + streamReader.getElementText());
                    }
                }
            }
            streamReader.close();
        } catch (XMLStreamException e) {
            e.printStackTrace();
        }
    }

    // 事件模式
    public static void readByEvent() {
        String xmlFile = "books.xml";
        XMLInputFactory factory = XMLInputFactory.newInstance();
        boolean titleFlag = false;
        try {
            // 创建基于迭代器的事件读取器对象
            XMLEventReader eventReader = factory.createXMLEventReader(new FileReader(xmlFile));
            // 遍历Event迭代器
            while (eventReader.hasNext()) {
                XMLEvent event = eventReader.nextEvent();
                // 如果事件对象是元素的开始
                if (event.isStartElement()) {
                    // 转换成开始元素事件对象
                    StartElement start = event.asStartElement();
                    // 打印元素标签的本地名称

                    String name = start.getName().getLocalPart();
                    //System.out.print(start.getName().getLocalPart());
                    if (name.equals("title")) {
                        titleFlag = true;
                        System.out.print("title:");
                    }

                    // 取得所有属性
                    Iterator attrs = start.getAttributes();
                    while (attrs.hasNext()) {
                        // 打印所有属性信息
                        Attribute attr = (Attribute) attrs.next();
                        //System.out.print(":" + attr.getName().getLocalPart() + "=" + attr.getValue());
                    }
                    //System.out.println();
                }
                //如果是正文
                if (event.isCharacters()) {
                    String s = event.asCharacters().getData();
                    if (null != s && s.trim().length() > 0 && titleFlag) {
                        System.out.println(s.trim());
                    }
                }
                //如果事件对象是元素的结束
                if (event.isEndElement()) {
                    EndElement end = event.asEndElement();
                    String name = end.getName().getLocalPart();
                    if (name.equals("title")) {
                        titleFlag = false;
                    }
                }
            }
            eventReader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Java XML文件解析

树结构

DOM Dociment Object Model文档对象模型，擅长（小规模）读/写。本质是将XML文件以树结构的方式放到缓存中进行读写。DOM读写实例

流结构

Java相关栏目本月热门文章

DOM
Dociment Object Model文档对象模型，擅长（小规模）读/写。本质是将XML文件以树结构的方式放到缓存中进行读写。
DOM读写实例