Java解析XML的四种方式-CSDN博客

本文链接：https://blog.csdn.net/u014438534/article/details/53946502

四种解析方式:
DOM、SAX、 (系统提供，与平台无关)
DOM4J、JDOM (第三方提供，只在java中使用)

DOM:

创建一个DocumentBuilderFactory对象，静态方法newInstance()
创建一个DocumentBuilder对象，DocumentBuilderFactory实例的newDocumentBuilder()方法
通过DocumentBuilder对象的parse(String fileName)方法解析xml文件

getElementsByTagName(string s) //返回nodelist             
    循环{
            item()方法;//返回Node(或Element是Node的子接口)
            getAttributes();//获得所有属性 返回NameNodeMap
            循环{
            item();//返回属性
                }
            }
            getChildNodes();//返回nodelist    ----注：*空格也算子节点作为text类型，<></>之间的内容都是该标签的子节点，不是其value*
            ……
更多层的解析

    /**
     * DOM方法解析xml
     * 
     * @throws Exception
     */
    public static void DOMAnalysis() throws Exception {
        DocumentBuilderFactory dBuilderFactory = DocumentBuilderFactory
                .newInstance();
        DocumentBuilder dBuilder = dBuilderFactory.newDocumentBuilder();
        Document doc = dBuilder.parse(new File("F:\\JAVA\\XML操作\\book.xml"));
        NodeList list = doc.getElementsByTagName("book");
        for (int i = 0; i < list.getLength(); i++) {
            Node book = list.item(i);
            // 获取属性
            NamedNodeMap attributes = book.getAttributes();
            for (int j = 0; j < attributes.getLength(); j++) {
                Node attribute = attributes.item(j);
                System.out.print(attribute.getNodeName() + " ");
                System.out.println(attribute.getNodeValue());
            }
            // 获取子节点
            NodeList childs = book.getChildNodes();
            for (int j = 0; j < childs.getLength(); j++) {
                Node node = childs.item(j);
                if (node.getNodeType() == Node.ELEMENT_NODE) {
                    System.out.print(node.getNodeName() + "\t");
                    System.out.println(node.getFirstChild().getNodeValue());
                }
            }
        }

    }

SAX:

通过SAXPareseFactory的静态newInstance()方法获取SAXParserFactory实例
通过SAXParserFactory实例的newSAXParser()方法返回SAXParser实例
创建一个类继承DefaultHandler，重写其中的一些方法进行业务处理并创建这个类的实例

startDocument:文档开始 endDocument:文档结束 startElement:标签开始 endElement:标签结束
    qName 元素名 attributes 元素属性
characters: 标签                  --->注:*空格也算节点元素*
ch:内容数组, start:标签里的0位置,length:标签内容长度

    /**
     * SAX方法解析xml
     * 
     * @throws Exception
     */
    public static void SAXAnalysis() throws Exception {
        SAXParserFactory sFactory = SAXParserFactory.newInstance();
        SAXParser sParser = sFactory.newSAXParser();
        SaxParserHandler handler = new SaxParserHandler();
        sParser.parse(new File("F:\\JAVA\\XML操作\\book.xml"), handler);
        for (Book book : handler.getBooks()) {
            System.out.println(book.getId());
            System.out.println(book.getName());
            System.out.println(book.getAuthor());
            System.out.println(book.getYear());
            System.out.println(book.getPrice());
            System.out.println(book.getLanguage())
    }

SAXParserHander类:

import java.util.ArrayList;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import entity.Book;

    public class SaxParserHandler extends DefaultHandler{
        private Book book=null;
        private String value=null;
        private ArrayList<Book> books=new ArrayList<Book>();


        public ArrayList<Book> getBooks() {
            return books;
        }

        public void startElement(String uri, String localName, String qName,
                Attributes attributes) throws SAXException {
            // TODO Auto-generated method stub
            super.startElement(uri, localName, qName, attributes);
            if(qName.equals("book")){
                book=new Book();
                for (int i = 0; i < attributes.getLength(); i++) {
                    if(attributes.getQName(i).equals("id")){
                        book.setId(Integer.parseInt(attributes.getValue(i)));
                    }
                }
                books.add(book);
            }
        };

        public void endElement(String uri, String localName, String qName)
                throws SAXException {
            // TODO Auto-generated method stub
            super.endElement(uri, localName, qName);
            if(qName.equals("name")){
                book.setName(value);
            }
            if(qName.equals("author")){
                book.setAuthor(value);
            }
            if(qName.equals("year")){
                book.setYear(value);
            }
            if(qName.equals("price")){
                book.setPrice(Integer.parseInt(value));
            }
            if(qName.equals("language")){
                book.setLanguage(value);
            }
        }

        public void startDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.startDocument();
            System.out.println("开始解析");
        }

        public void endDocument() throws SAXException {
            // TODO Auto-generated method stub
            super.endDocument();
            System.out.println("结束解析");
        }

        public void characters(char[] ch, int start, int length)
                throws SAXException {
            // TODO Auto-generated method stub
            super.characters(ch, start, length);
            value=new String(ch, start, length);
/*          if(!value.trim().equals("")){
                System.out.println(value);
            }*/
        }
    }

实体类book:

package entity;

public class Book {

    private int id;
    private String name;
    private String author;
    private String year;
    private int price;
    private String language;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public String getYear() {
        return year;
    }
    public void setYear(String year) {
        this.year = year;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getLanguage() {
        return language;
    }
    public void setLanguage(String language) {
        this.language = language;
    }

}

JDOM:

创建一个SAXBuilder (new)
创建一个输入流，将xml文件加载到输入流(可选)
调用SAXBuilder的build()方法，返回Document对象
通过Document对象getRootElement获得根节点元素,返回Element对象
通过Element对象getChildren获得子节点，返回List
……遍历解析

    /**
     * JDOM方法解析xml
     * 
     * @throws Exception
     */
    public static void JDOMAnalysis() throws Exception {
        SAXBuilder saxBuilder = new SAXBuilder();
        org.jdom2.Document document = saxBuilder.build(new FileInputStream(
                new File("F:\\JAVA\\XML操作\\book.xml")));
        Element root = document.getRootElement();
        List<Element> list = root.getChildren();// 获得根节点
        for (Element element : list) {
            System.out.print(element.getName() + " ");
            List<Attribute> attributes = element.getAttributes();
            for (Attribute attribute : attributes) {
                System.out.print(attribute.getName() + ":"
                        + attribute.getValue() + "\t");
            }
            List<Element> childerns = element.getChildren();
            for (Element element2 : childerns) {
                System.out.print(element2.getName() + ":" + element2.getValue()
                        + "\t");
            }
            System.out.println();
        }
    }

DOM4J:

创建一个SAXReader对象 (new)
调用SAXReader实例的read()方法，返回Document对象
通过Document对象getRootElement获取根节点，返回Element对象
通过Element对象的elementIterator方法获取迭代器,返回Iterator(可选)
遍历迭代器

    /**
     * DOM4J方法解析xml
     * 
     * @throws Exception
     */
    public static void DOM4JAnalysis() throws Exception {
        SAXReader saxReader = new SAXReader();
        org.dom4j.Document document = saxReader.read(new File(
                "F:\\JAVA\\XML操作\\book.xml"));
        org.dom4j.Element element = document.getRootElement();
        Iterator<?> iterator = element.elementIterator();
        while (iterator.hasNext()) {
            org.dom4j.Element e = (org.dom4j.Element) iterator.next();
            System.out.print(e.getName() + " ");
            List<org.dom4j.Attribute> attributes = e.attributes();
            for (org.dom4j.Attribute attribute : attributes) {
                System.out.println(attribute.getName() + ":"
                        + attribute.getValue());
            }
            Iterator<?> it = e.elementIterator();
            while (it.hasNext()) {
                org.dom4j.Element object = (org.dom4j.Element) it.next();
                System.out.print(object.getName() + ":" + object.getText()
                        + "\t");
            }
            System.out.println();
        }
    }

比较:

    DOM:   一次性加载数据到内存中(消耗内存)
    SAX:   基于事件的解析，针对每个标签解析
    JDOM： 仅使用具体类不使用接口，API大量使用Collections类
    DOM4J: JDOM后的一个分支，功能不止xml解析