java xml解析方式(DOM、SAX、JDOM、DOM4J)

xml值可扩展标记语言，是用来传输和存储数据的。

xml的特定：

1. xml文档必须包含根元素。该元素是所有其他元素的父元素。xml文档中的元素形成了一颗文档树，树中的每个元素都可存在子元素。
2. 所有xml元素都必须有关闭标签。
3. xml标签对大小写敏感，并且所有属性值date都需加引号。

xml元素：

xml元素是只从包括开始标签到结束标签的部分，元素可包含其他元素、文本或两者都包含，也可拥有属性。

 

xml解析

基础方法：dom、sax

dom解析：平台无关的官方解析方式

sax解析：java中基于事件驱动的解析方式

扩展方法：jdom、dom4j (在基础方法上扩展的，只有java能够使用的解析方式)

 

1.dom解析

　　　　优点：

　　　　　　·形成了树结构，直观好理解

　　　　　　·解析过程中树结构保留在内存中方便修改

　　　　缺点：

　　　　　　·当xml文件较大时，对内存消耗比较大，容易影响解析性能，并造成内存溢出

import org.w3c.dom.*;

import javax.xml.parsers.documentbuilder;
import javax.xml.parsers.documentbuilderfactory;
import java.util.linkedlist;
import java.util.list;

/**
 * dom 解析xml
 */
public class dom {
    public static void main(string[] args) throws exception {
        // 1.创建 documentbuilderfactory 对象
        documentbuilderfactory dbf = documentbuilderfactory.newinstance();
        // 2.通过 documentbuilderfactory对象创建 documentbuilder对象
        documentbuilder db = dbf.newdocumentbuilder();
        // 3.使用 documentbuilder对象来加载xml
        document document = db.parse("bean.xml");
        system.out.println("----------------- dom开始解析 xml -----------------");
        // 获取 xml 文件的根节点
        element element = document.getdocumentelement();
        getnoemsg(element);
        system.out.println("\n\n----------------- dom结束解析 xml -----------------");
    }

    /**
     * 获取node节点信息
     * @param node
     */
    public static void getnoemsg(node node){
        if(node.getnodetype() == node.element_node){
            system.out.print("<" + node.getnodename());
            getnodeattrs(node);
            system.out.print(">\n");
            nodelist nodelist = node.getchildnodes();
            // 筛选出节点类型为element_node 的节点
            list<node> list = getnodelist(nodelist);
            node childnode;
            int len = list.size();
            if(len == 0){
                system.out.print(node.gettextcontent() + "\n");
            }else {
                for (int i = 0; i < len; i++){
                    if(list.get(i).getnodetype() == node.element_node){
                        childnode = list.get(i);
                        getnoemsg(childnode);
                    }
                }
            }
            system.out.println("</" + node.getnodename() + ">");
        }
    }

    /**
     * 获取node节点的属性信息
     * @param node
     */
    public static void getnodeattrs(node node){
        namednodemap attrs = node.getattributes();
        node attr;
        if(attrs.getlength() != 0){
            for (int i = 0, len = attrs.getlength(); i < len; i++){
                attr = attrs.item(i);
                system.out.print(" " + attr.getnodename() + "='");
                system.out.print(attr.getnodevalue() + "'");
            }
        }
    }

    /**
     * 筛选出节点类型为element_node 的节点
     * @param nodelist
     * @return
     */
    public static list<node> getnodelist(nodelist nodelist){
        list<node> list = new linkedlist<>();
        for (int i = 0,len = nodelist.getlength(); i < len; i++){
            if(nodelist.item(i).getnodetype() == node.element_node){
                list.add(nodelist.item(i));
            }
        }
        return list;
    }
}

 

2.sax解析

　　　　优点：

　　　　　　·采用事件驱动模式，对内存消耗比较小

　　　　　　·适用于只需处理xml中数据时

　　　　缺点：

　　　　　　·不易编码

　　　　　　·很难同时访问同一个xml中的多处不同数据

import org.xml.sax.attributes;
import org.xml.sax.saxexception;
import org.xml.sax.helpers.defaulthandler;

import javax.xml.parsers.saxparser;
import javax.xml.parsers.saxparserfactory;

public class sax {
    public static void main(string[] args) throws exception {
        // 1.创建saxparserfactory对象
        saxparserfactory saxparserfactory = saxparserfactory.newinstance();
        // 2.通过saxparserfactory对象创建 saxparser
        saxparser saxparser = saxparserfactory.newsaxparser();
        // 3.通过saxparser加载xml，并传入 defaulthandler 类型的对象进行解析
        saxparser.parse("bean.xml", new saxparserhandler());
    }

    static class saxparserhandler extends defaulthandler{
        /**
         * 解析xml开始执行方法
         * @throws saxexception
         */
        @override
        public void startdocument() throws saxexception {
            super.startdocument();
            system.out.print("============= sax开始解析xml =============\n");
        }

        /**
         * 解析xml结束执行方法
         * @throws saxexception
         */
        @override
        public void enddocument() throws saxexception {
            super.enddocument();
            system.out.print("\n============= sax结束解析xml =============");
        }

        /**
         * 解析节点开始执行方法
         * @param uri
         * @param localname
         * @param qname
         * @param attributes
         * @throws saxexception
         */
        @override
        public void startelement(string uri, string localname, string qname, attributes attributes) throws saxexception {
            super.startelement(uri, localname, qname, attributes);
            system.out.print("<" + qname);
            for (int i = 0,len = attributes.getlength(); i < len; i++){
                system.out.print(" " + attributes.getqname(i) + "='");
                system.out.print(attributes.getvalue(i) + "'");
            }
            system.out.print(">");
        }

        /**
         * 解析节点结束执行方法
         * @param uri
         * @param localname
         * @param qname
         * @throws saxexception
         */
        @override
        public void endelement(string uri, string localname, string qname) throws saxexception {
            super.endelement(uri, localname, qname);
            system.out.print("</" + qname + ">");
        }

        @override
        public void characters(char[] ch, int start, int length) throws saxexception {
            super.characters(ch, start, length);
            string str = new string(ch, start, length);
            system.out.print(str);
        }
    }
}

3.jdom解析

　　　　特征：

　　　　　　·使用了具体类，不使用接口。

　　　　　　·api大量使用了collections类，源码开源

import org.jdom.attribute;
import org.jdom.document;
import org.jdom.element;
import org.jdom.jdomexception;
import org.jdom.input.saxbuilder;

import java.io.fileinputstream;
import java.io.filenotfoundexception;
import java.io.ioexception;
import java.io.inputstream;
import java.util.list;

/**
 * <!--  引入jdom依赖包 -->
 * <dependency>
 *     <groupid>org.jdom</groupid>
 *     <artifactid>jdom</artifactid>
 *     <version>1.1</version>
 * </dependency>
 */
public class jdom {
    public static void main(string[] args) throws ioexception, jdomexception {
        // 1.创建saxbuilder对象
        saxbuilder saxbuilder = new saxbuilder();
        // 2.获取xml文件输入流
        inputstream in = new fileinputstream("bean.xml");
        // 3.通过saxbuilder对象的build方法，将xml文件输入流添加到saxbuilder对象中
        document document = saxbuilder.build(in);
        // 4.获取xml根节点
        element rootelement = document.getrootelement();
        // 5.根据根节点解析xml
        printnodemsg(rootelement);
    }

    public static void printnodemsg(element element){
        system.out.print("<" + element.getname());
        // 获取节点的属性
        printattrmsg(element);
        system.out.print(">\n");
        list<element> elements = element.getchildren();
        for (element e : elements){
            if(e.getchildren().size() > 0){
                printnodemsg(e);
            }else {
                system.out.print("<" + e.getname());
                printattrmsg(e);
                system.out.print(">");
                system.out.print(e.getvalue());
                system.out.print("</" + e.getname() + ">\n");
            }
        }
        system.out.print("</" + element.getname() + ">\n");
    }

    /**
     * 获取节点的属性
     * @param element
     */
    public static void printattrmsg(element element){
        list<attribute> attributes = element.getattributes();
        for (attribute attribute : attributes){
            system.out.print(" " + attribute.getname() + "='" + attribute.getvalue() + "'");
        }
    }
}

4.dom4j解析

　　　　特征：

　　　　·使用了接口和抽象基本类方法

　　　　·具有性能优异、灵活性好、功能强大和极端易用的特点。

　　　　·开源

import org.dom4j.attribute;
import org.dom4j.document;
import org.dom4j.documentexception;
import org.dom4j.element;
import org.dom4j.io.saxreader;

import java.io.fileinputstream;
import java.io.filenotfoundexception;
import java.util.iterator;

/**
 * <!-- dom4j依赖包 -->
 * <dependency>
 *     <groupid>dom4j</groupid>
 *     <artifactid>dom4j</artifactid>
 *     <version>1.6.1</version>
 * </dependency>
 */
public class dom4j {
    public static void main(string[] args) throws filenotfoundexception, documentexception {
        // 1.创建saxreader对象
        saxreader saxreader = new saxreader();
        // 2.通过saxreader对象的read方法，加载xml输入流
        document document = saxreader.read(new fileinputstream("bean.xml"));
        // 3.通过document对象获取xml的根节点
        element rootelement = document.getrootelement();
        // 4.通过根节点解析xml
        printnodemsg(rootelement);
    }

    public static void printnodemsg(element element){
        system.out.print("<" + element.getname());
        // 获取节点的属性
        printattrmsg(element);
        system.out.print(">\n");
        iterator<element> elementiterator = element.elementiterator();
        element e;
        while (elementiterator.hasnext()){
            e = elementiterator.next();
            if(e.elementiterator().hasnext()){
                printnodemsg(e);
            }else {
                system.out.print("<" + e.getname());
                printattrmsg(e);
                system.out.print(">");
                system.out.print(e.getstringvalue());
                system.out.print("</" + e.getname() + ">\n");
            }
        }
        system.out.print("</" + element.getname() + ">\n");
    }

    /**
     * 获取节点的属性
     * @param element
     */
    public static void printattrmsg(element element){
        iterator<attribute> attributeiterator = element.attributeiterator();
        attribute attribute;
        while (attributeiterator.hasnext()){
            attribute = attributeiterator.next();
            system.out.print(" " + attribute.getname() + "='" + attribute.getvalue() + "'");
        }
    }
}