欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-04-29 22:20:22
XML值可扩展标记语言,是用来传输和存储数据的。 XMl的特定: XML元素: XMl元素是只从包括开始标签到结束标签的部分,元素可包含其他元素、文本或两者都包含,也可拥有属性。 XML解析 基础方法:DOM、SAX DOM解析:平台无关的官方解析方式 SAX解析:Java中基于事件驱动的解析方式 ......

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

xml的特定:

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

xml元素:

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

 

xml解析

基础方法:domsax

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

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

扩展方法:jdomdom4j (在基础方法上扩展的,只有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() + "'");
        }
    }
}