JAVA解析xml的四种方式比较

1)DOM解析

	DOM是html和xml的应用程序接口(API)，以层次结构（类似于树型）来组织节点和信息片段，映射XML文档的结构，允许获取

和操作文档的任意部分，是W3C的官方标准

	【优点】
		①允许应用程序对数据和结构做出更改。
		②访问是双向的，可以在任何时候在树中上下导航，获取和操作任意部分的数据。
	【缺点】
		①通常需要加载整个XML文档来构造层次结构，消耗资源大。
以下实例采用这个XML文件内容,例如（demo.xml）

<province>
<city code="027">武汉</city>
<city code="0716">荆州</city>
<city code="0718">宜昌</city>
</province>

JAVA代码如下：

//使用前请先导入w3c-dom.jar包。省略导入步骤。

//注意，DOM解析时会将注释部分和空格换行读入子节点中,注意check。

package com.phone1000.lq.xml_demo;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

/**

 * @author lq

 *XML文件内容读取，转换成流，然后转换成对应的子节点类型字符串。

 */

public class Xml_demo {

    private static final String PROVINCE="province";

    public static void main(String[] args) {

        try {

            FileInputStream fin=new FileInputStream(new File("src/demo.xml"));

             DocumentBuilderFactory docFac=DocumentBuilderFactory.newInstance();

             DocumentBuilder builder=docFac.newDocumentBuilder();

             //解析流

             Document doc= builder.parse(fin);

             NodeList docNodePar=doc.getChildNodes();

             //获取父节点长度

             int parNum=docNodePar.getLength();

             System.out.println(parNum);

             for(int i=0;i<parNum;i++){

                 Node parNode= docNodePar.item(i);

                 System.out.println(parNode.getNodeName());

                 if(PROVINCE.equals(parNode.getNodeName())){

                     NodeList childNode= parNode.getChildNodes();

                    int childNum= childNode.getLength();

                     for(int j=0;j<childNum;j++){

                         Node childNodeName=childNode.item(j);

                         if(childNodeName.hasAttributes()){

                             NamedNodeMap childNode_child= childNodeName.getAttributes();

                            Node childNode_childNode=childNode_child.getNamedItem("code");

                            String codeStr=childNode_childNode.getNodeValue();

                            String text= childNodeName.getTextContent();

                            System.out.println(codeStr+"\t"+text);

                         }

                     }

                 }

             }

        } catch (ParserConfigurationException | SAXException | IOException e) {

            //

            e.printStackTrace();

        }

    }

}

(2)SAX解析XML
	流模型中的"推"模型分析方式。通过事件驱动，每发现一个节点就引发一个事件，事件推给事件处理器，通过回调方法
	完成解析工作，解析XML文档的逻辑需要应用程序完成
	【优势】
		①不需要等待所有数据都被处理，分析就能立即开始。
		②只在读取数据时检查数据，不需要保存在内存中。
		③可以在某个条件得到满足时停止解析，不必解析整个文档。
		④效率和性能较高，能解析大于系统内存的文档。
	【缺点】
		①需要应用程序自己负责TAG的处理逻辑（例如维护父/子关系等），文档越复杂程序就越复杂。
		②单向导航，无法定位文档层次，很难同时访问同一文档的不同部分数据，不支持XPath。

以下实例采用这个XML文件内容,例如（demo.xml）

<province>
<city code="027">武汉</city>
<city code="0716">荆州</city>
<city code="0718">宜昌</city>
</province>

JAVA代码如下：

//使用前请先导入sax.jar包。省略导入步骤。

//此处创建内部类重写了DefaultHandler的startDocument()，endDocument()，startElement()，endElement() ，characters()，五种方法。

//注意，SAX解析时会将注释部分和空格换行读入子节点中。所以要check。

package com.phone1000.lq.xml_sax;

import java.io.File;

import java.io.FileInputStream;

import java.util.ArrayList;

import java.util.List;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

/**

 * @author lq

 *另一种XML解析方法，内存占用少

 */

public class Xml_Sax {

    private static List<CityList> list=new ArrayList<>();

    public static void execute() throws Exception{

        FileInputStream fiin=new FileInputStream(new File("src/demo.xml"));

        SAXParserFactory saxF=SAXParserFactory.newInstance();

        SAXParser saxP=saxF.newSAXParser();

        saxP.parse(fiin, new myHandler());

        for(CityList city:list){

            System.out.println(city.getName());

        }

    }

    static class myHandler extends  DefaultHandler{

        private CityList citylist;

        @Override

        public void startDocument() throws SAXException {

            System.out.println("开始标签");

        }

        @Override

        public void endDocument() throws SAXException {

            System.out.println("结束标签");

        }

        @Override

        public void startElement(String uri, String localName, String qName, Attributes attributes)

                throws SAXException {

            String attr=attributes.getValue("code");

            if("city".equals(qName)){

                citylist=new CityList();

                citylist.setCode(attr);

            }

        }

        @Override

        public void endElement(String uri, String localName, String qName) throws SAXException {

            if("city".equals(qName)){

                list.add(citylist);

            }

            citylist=null;

        }

        @Override

        public void characters(char[] ch, int start, int length) throws SAXException {

            String str=new String(ch,start,length);

            System.out.println(str);

            if(citylist != null){

                citylist.setName(str);

            }

        }

    }

}

package com.phone1000.lq.xml_sax;

public class CityList {

    String name;

    String code;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getCode() {

        return code;

    }

    public void setCode(String code) {

        this.code = code;

    }

    public CityList(String name, String code) {

        super();

        this.name = name;

        this.code = code;

    }

    public CityList() {

        super();

        // TODO Auto-generated constructor stub

    }

    @Override

    public String toString() {

        return "CityList [name=" + name + ", code=" + code + "]";

    }

}

package com.phone1000.lq.xml_sax;

public class TsetSax {

    public static void main(String[] args) {

        try {

            Xml_Sax.execute();

        } catch (Exception e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

(3)JDOM解析XML
	Java特定的文档对象模型。自身不包含解析器，使用SAX
	【优点】
		①使用具体类而不是接口，简化了DOM的API。
		②大量使用了Java集合类，方便了Java开发人员。
	【缺点】
		①没有较好的灵活性。
		②性能较差。

以下实例采用这个XML文件内容,例如（demo2.xml）

<beans>
<bean name="demo">demo.java</bean>
<bean name="home">home.java</bean>
<bean name="index">index.java</bean>
</beans>

JAVA代码如下：

//使用前请先导入jdom.jar包,省略导入步骤。

//注意，jdom解析时会跳过注释部分和空格换行内容。

package com.phone1000.lq.jdom;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.util.List;

import org.jdom.Document;

import org.jdom.Element;

import org.jdom.JDOMException;

import org.jdom.input.SAXBuilder;

public class Xml_Jdom {

　　public static void main(String[] args) {

　　try {

　　　　SAXBuilder builder=new SAXBuilder(false);

　　　　FileInputStream fin=new FileInputStream(new File("src/demo2.xml"));

　　　　Document doc=builder.build(fin);

　　　　Element ele=doc.getRootElement();

　　　　String str=ele.getName();

　　　　System.out.println(str);

　　　　@SuppressWarnings("unchecked")

　　　　List<Element> list=ele.getChildren();

　　　　for (Element element : list) {

　　　　　　System.out.println(element.getAttributeValue("name")+"\t"+element.getText());

　　　　　　}

　　　　} catch (FileNotFoundException e) {

　　　　　　e.printStackTrace();

　　　　} catch (JDOMException e) {

　　　　　　e.printStackTrace();

　　　　} catch (IOException e) {

　　　　　　e.printStackTrace();

　　　　}

　　}

}

(4)DOM4J解析XML
	简单易用，采用Java集合框架，并完全支持DOM、SAX和JAXP
	【优点】
		①大量使用了Java集合类，方便Java开发人员，同时提供一些提高性能的替代方法。
		②支持XPath。
		③有很好的性能。
	【缺点】
		①大量使用了接口，API较为复杂。

以下实例采用这个XML文件内容,例如（demo2.xml）

<beans>
<bean name="demo">demo.java</bean>
<bean name="home">home.java</bean>
<bean name="index">index.java</bean>
</beans>

JAVA代码如下：

//使用前请先导入dom4j.jar包,省略导入步骤。

//注意，dom4j解析时会跳过注释部分和空格换行内容，直接获得节点内容。

 package com.phone1000.lq.dom4j;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileNotFoundException;

 import java.util.List;

 import org.dom4j.Document;

 import org.dom4j.DocumentException;

 import org.dom4j.Element;

 import org.dom4j.io.SAXReader;

 public class Xml_dom4j {

 　　public static void main(String[] args) {

 　　try {

 　　　　SAXReader sax=new SAXReader();

 　　　　FileInputStream fin=new FileInputStream(new File("src/demo2.xml"));

 　　　　Document doc=sax.read(fin);

 　　　　Element ele=doc.getRootElement();

 　　　　String str=ele.getName();

 　　　　System.out.println(str);

 　　　　@SuppressWarnings("unchecked")

 　　　　List<Element> list=ele.elements();

 　　　　for (Element element : list) {

 　　　　　　System.out.println(element.attributeValue("name")+"\t"+element.getText());

 　　　　　　}

 　　　　} catch (FileNotFoundException | DocumentException e) {

 　　　　　　e.printStackTrace();

 　　　　}

 　　}

 }

附加StAX解析XML
	流模型中的拉模型分析方式。提供基于指针和基于迭代器两种方式的支持,JDK1.6新特性
	【和推式解析相比的优点】
		①在拉式解析中，事件是由解析应用产生的，因此拉式解析中向客户端提供的是解析规则，而不是解析器。
		②同推式解析相比，拉式解析的代码更简单，而且不用那么多库。
		③拉式解析客户端能够一次读取多个XML文件。
		④拉式解析允许你过滤XML文件和跳过解析事件。
	【简介】
		StAX API的实现是使用了Java Web服务开发（JWSDP）1.6，并结合了Sun Java流式XML分析器(SJSXP)-它位于
		javax.xml.stream包中。XMLStreamReader接口用于分析一个XML文档，而XMLStreamWriter接口用于生成一个
		XML文档。XMLEventReader负责使用一个对象事件迭代子分析XML事件-这与XMLStreamReader所使用的光标机制
		形成对照。

巴特西

JAVA解析xml的四种方式比较

最新文章

热门文章