JAVA解析XML文件

最新推荐文章于 2025-04-03 17:00:00 发布

原创最新推荐文章于 2025-04-03 17:00:00 发布 · 1.1k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

JAVA学习专栏收录该内容

7 篇文章

订阅专栏

java中XML文件的四种解析方式：

DOM SAX DOM4J JDOM（DOM，SAX是官方提供的）

如果想在程序中保存xml的结构，建议建立相应的对象将其存储下来（这也符合面向对象的思想）

我解析的XML文件

DOM: DOM的全称是Document Object Model（文档对象模型），

基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合（DOM树），

应用程序正是通过这个对象模型的操作，来实现对xml文档数据的操作，通过DOM接口，

应用程序可以在任何时候访问XML文档中的任何一部分数据，因此，这种利用DOM接口的机制也被称为随机访问机制。

无论XML文档所描述的是什么类型的信息，利用DOM生成的模型都是节点树的形式。

DOM树提供的随机访问方式给应用程序的开发带来了很大的灵活性，但是由于每次解析的时候都是将整个xml文档加载到内存中，

如果xml文件的数据量很大的话，对内存的需求会比较高。对于复杂的数的遍历也是一项耗时的操作，

所以DOM解析方式对机器的要求比较高，实现的效率不怎么理想，

但是由于DOM所采用的树结构的思想与xml文档的结果相吻合，同时鉴于随机访问所带来的方便，

因此DOM的思想还是比较流行。

导包的时候记住是导w3c的包。

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

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

/**
 * Created by Administrator on 2015/1/9.
 */
public class DOMTest {

    public static void main(String[] args) throws Exception{
        //获得dom解析器工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        //获取dom的解析器
        DocumentBuilder domBuilder = factory.newDocumentBuilder();
        //获取一个xml文档的document对象
        Document document = domBuilder.parse("src/test.xml");

        NodeList list = document.getElementsByTagName("bookstore");
        for(int i = 0; i < list.getLength(); ++i) {
            Element element =  (Element)list.item(i);

            /*
            //方法一:谨记下面的方式有空白text节点
            NodeList childNode = element.getChildNodes();
            System.out.println(childNode.getLength());
            */
            //方法二:推荐使用下面的方式（但是这种方式仅限于知道子节点的标签名）
            NodeList childNode = element.getElementsByTagName("book");

            //遍历书
            for(int bk = 0; bk < childNode.getLength(); ++bk) {
                Element book = (Element)childNode.item(bk);
                System.out.println("第" + (bk + 1) + "本书的id：" + book.getAttribute("id"));
                //因为子节点的标签名不定，可以使用上面所述的方法一
                NodeList bookChildList = book.getChildNodes();
                for(int j = 0; j < bookChildList.getLength(); ++j)
                if((j&1) == 1) { //只访问奇数节点， 这样就可以避开空白的text节点了
                    Element element1 = (Element)bookChildList.item(j);
                    System.out.print(element1.getNodeName() + "：");
                    //获取NodeValue值的时候需要注意
                    //下面的这种方式访问的都是null， element获取NodeValue会返回null（请仔细查看“常用的节点类型”）
                    //System.out.println(element1.getNodeValue());
                    //解决的方式有两种
                    //方法一：获取第一个text节点，然后text节点的值
                    //System.out.println(element1.getFirstChild().getNodeName());
                    //方法二：直接调用element节点的getTextContext方法
                    System.out.println(element1.getTextContent());
                }
                System.out.println();
            }
        }
    }
}

SAX：SAX的全称是Simple APIs for XML (简单应用程序接口)。与DOM不同，SAX提供的访问模式是一种顺序模式，

这是一种快速读写XML数据的方式。当使用SAX分析器对XML文档进行分析时，会触发一系列事件，并激活相应的事件处理函数，

应用程序通过这些事件处理函数实现对XML文档的访问，因而SAX接口也被称作事件驱动接口。

SAX是借助Handler来进行解析xml文档的，平常使用的时候很少看见直接使用SAX，都是基于SAX的延伸。

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

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.IOException;
import java.util.Stack;

/**
 * Created by Administrator on 2015/1/9.
 */
public class SAXTest1 {
    public static void main(String[] args)  throws ParserConfigurationException, SAXException, IOException {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = factory.newSAXParser();
        parser.parse("src/test.xml", new MyHandler());
    }

    static class MyHandler extends DefaultHandler {

        private Stack<String> stack = new Stack<String>();

        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
            stack.push(qName);
            System.out.print(qName + " ([ ");
            for(int i = 0; i < attributes.getLength(); ++i) {
                String attrName = attributes.getQName(i);
                String attrValue = attributes.getValue(i);
                System.out.print(attrName + "=" + attrValue);
            }
            System.out.println("])");
        }

        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            String name = stack.pop();
            if(name.equals("book")) {
                System.out.println();
            }
        }
    }
}

JDOM：JDOM基于树形结构，利用纯文本的JAVA技术对XML文档实现解析，生成，序列化以及多种操作。

JDOM是用JAVA语言读，写，操作XML的新API函数，结合了DOM和SAX的特性，JDOM中没有text节点。

使用一：用JDOM创建xml文件

import org.jdom.Attribute;
import org.jdom.Comment;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * Created by Administrator on 2015/1/9.
 */
public class JDOMTest {
    public static void main(String[] args) throws IOException{
        Document document = new Document();
        Element root = new Element("bookstore");
        document.addContent(root);
        Comment comment = new Comment("hello world");
        root.addContent(comment);
        Element book = new Element("book");
        root.addContent(book);
        Attribute attr = new Attribute("id", "1");
        book.setAttribute(attr);
        Element name = new Element("name");
        name.addContent("麦田的守望者");
        Element author = new Element("author");
        author.addContent("佚名");
        Element price = new Element("price");
        price.addContent("100");
        book.addContent(name);
        book.addContent(author);
        book.addContent(price);
        Format format = Format.getPrettyFormat();
        format.setIndent("  ");
        XMLOutputter out = new XMLOutputter(format);
        out.output(document, new FileWriter("src/jdom.xml"));
    }
}

使用二：使用JDOM解析XML文档

import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

import java.io.File;
import java.io.IOException;
import java.util.List;

/**
 * Created by Administrator on 2015/1/9.
 */
public class JDOMTest2 {
    public static void main(String[] args) throws IOException, JDOMException {
        SAXBuilder builder = new SAXBuilder();
        Document document = builder.build(new File("src/test.xml"));
        Element root = document.getRootElement();
        System.out.println(root.getName());
        //JDOM 中不会产生text节点, 所以这里也不需要节点类型的判断
        List<Element> children = root.getChildren();
        for(Element book : children) {
            System.out.print(book.getName() + " ([");
            List<Attribute> attrs = book.getAttributes();
            for(Attribute attr : attrs) {
                System.out.print(attr.getName() + "=" + attr.getValue() + " ");
            }
            System.out.println("])");
            List<Element> elements = book.getChildren();
            for(Element element : elements) {
                System.out.println(element.getName() + " " + element.getValue());
            }
            System.out.println();
        }
    }
}

DOM4J：全称是Document Object Model For Java， dom4j是一个十分优秀的JavaXML API，具有性能优异、功能强大和极其易使用的特点，

特别值得一提的是连SunJAXM也在用dom4j。这已经是必须使用的jar包， Hibernate也用它来读写配置文件，一般项目中都要提前导入。

用DOM4J创建XML文件：

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;


/**
 * Created by Administrator on 2015/1/9.
 */
public class DOM4JTest1 {
    
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException, IOException {
        Element root = DocumentHelper.createElement("bookstore");
        Document document = DocumentHelper.createDocument(root);
        Element book = DocumentHelper.createElement("book");
        book.addAttribute("id", "1");
        root.add(book);
        Element name = book.addElement("name");
        Element author = book.addElement("author");
        Element price = book.addElement("price");
        name.setText("麦田的守望者");
        author.setText("佚名");
        price.setText("100");
        OutputFormat format = new OutputFormat("    ", true);
        XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/dom4j.xml"), format);
        xmlWriter.write(document);
        xmlWriter.close();
    }
}

使用DOM4J来解析XML文件：

import org.dom4j.*;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.List;

/**
 * Created by Administrator on 2015/1/9.
 */
public class DOM4JTest2 {

    public static void main(String[] args) throws DocumentException{
        SAXReader saxReader = new SAXReader();
        Document document = saxReader.read(new File("src/test.xml"));
        Element root = document.getRootElement();
        System.out.println(root.getName());
        List<Element> children = root.elements();
        for(Element book : children) {
            System.out.print(book.getName() + " ([ ");
            List<Attribute> attrs = book.attributes();
            for(Attribute attr : attrs) {
                System.out.print(attr.getName() + "=" + attr.getValue() + " ");
            }
            System.out.println(" ])");
            List<Element> elements = book.elements();
            for(Element element : elements) {
                System.out.println(element.getName() + " " + element.getText());
            }
            System.out.println();
        }
    }
}