`
toreking
  • 浏览: 36914 次
  • 性别: Icon_minigender_1
  • 来自: 西安
社区版块
存档分类
最新评论

java解析xml常用的三种方法

xmldom解析、sax解析 
阅读更多
(I)Java通过DOM解析XML
 
1>得到DOM解析器的工厂实例
　　DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();
　　得到javax.xml.parsers.DocumentBuilderFactory;类的实例就是我们要的解析器工厂
　　
2>从DOM工厂获得DOM解析器
　　DocumentBuilder dombuilder=domfac.newDocumentBuilder();
　　通过javax.xml.parsers.DocumentBuilderFactory实例的静态方法newDocumentBuilder()得到DOM解析器
　　
3>把要解析的XML文档转化为输入流，以便DOM解析器解析它
　　InputStream is=new FileInputStream("bin/library.xml");
　　InputStream是一个接口。
4>解析XML文档的输入流，得到一个Document
　　Document doc=dombuilder.parse(is);
　　由XML文档的输入流得到一个org.w3c.dom.Document对象，以后的处理都是对Document对象进行的
　　
5>得到XML文档的根节点
　　Element root=doc.getDocumentElement();
　　在DOM中只有根节点是一个org.w3c.dom.Element对象。
　　
6>得到节点的子节点
　　NodeList books=root.getChildNodes();
　　for(int i=0;i<books.getLength();i++){
 Node book=books.item(i);
　　}
　　 这是用一个org.w3c.dom.NodeList接口来存放它所有子节点的，还有一种轮循子节点的方法，后面有介绍
　　
7>取得节点的属性值
　　String email=book.getAttributes().getNamedItem("email").getNodeValue();
　　System.out.println(email);
　　注意，节点的属性也是它的子节点。它的节点类型也是Node.ELEMENT_NODE
　　
8>轮循子节点
　　for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling()){
　　
　　　　if(node.getNodeType()==Node.ELEMENT_NODE){
　　
　　　　    if(node.getNodeName().equals("name")){
　　
 　　　　String name=node.getNodeValue();
 　　
 　　　　String name1=node.getFirstChild().getNodeValue();
 　　
 　　　...
 　　
 　　　　if(node.getNodeName().equals("price")){
 　　
 　　　　String price=node.getFirstChild().getNodeValue();
...
　　
 
<?xml version="1.0" encoding="UTF-8"?> 
<xml> 
    <conn-params> 
        <conn-url>jdbc:mysql://192.168.101.7:3306/bbs</conn-url> 
        <conn-driver>com.mysql.jdbc.Driver</conn-driver> 
        <conn-username>root</conn-username> 
        <conn-password>root</conn-password> 
    </conn-params> 
      
    <person> 
        <user> 
            <username>xzc</username> 
            <password>sdf23223</password> 
            <birthday>2012-01-23</birthday> 
        </user> 
        <user> 
            <username>误闯</username> 
            <password>wuchuang3223</password> 
            <birthday>2002-01-03</birthday> 
        </user> 
    </person> 
</xml>
  
////////////////////////////////////////////////////////////////////////////////////
  
package com.xcz.xml; 
  
import java.io.File; 
import java.io.IOException; 
import java.util.List; 
  
import javax.xml.parsers.ParserConfigurationException; 
  
import org.xml.sax.SAXException; 
  
import com.xcz.po.User; 
import com.xcz.xml.util.DomUtil; 
  
public class Dom4Xml { 
  
    private DomUtil domUtil = new DomUtil(); 
      
    public static void main(String[] args) { 
        try { 
            File f = new File("src/jdbc-params.xml"); 
            List<User> list = new Dom4Xml().domUtil.parseXml(f); 
            for (User user : list) { 
                System.out.println(user); 
            } 
        } catch (ParserConfigurationException e) { 
            e.printStackTrace(); 
        } catch (SAXException e) { 
            e.printStackTrace(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
          
    } 
}
 
  
////////////////////////////////////////////////////////////////////////////////////
  
package com.xcz.xml.util; 
  
import java.io.File; 
import java.io.IOException; 
import java.util.ArrayList; 
import java.util.List; 
  
import javax.xml.parsers.DocumentBuilder; 
import javax.xml.parsers.DocumentBuilderFactory; 
import javax.xml.parsers.ParserConfigurationException; 
  
import org.w3c.dom.Document; 
import org.w3c.dom.Element; 
import org.w3c.dom.Node; 
import org.w3c.dom.NodeList; 
import org.xml.sax.SAXException; 
  
import com.xcz.po.User; 
  
public class DomUtil { 
  
    private DocumentBuilderFactory factory; 
    private DocumentBuilder builder; 
    private Document document; 
      
    private List<User> list; 
      
    /** 
     * 创建一个DocumentBuilderFactory 对象 
     * @return DocumentBuilderFactory 
     */ 
    private DocumentBuilderFactory getDocumentBuilderFactory(){ 
        return DocumentBuilderFactory.newInstance(); 
    } 
      
    /** 
     * 创建一个DocumentBulider 对象 
     * @param DocumentBuilderFactory fac  
     * @return DocumentBuilder 
     * @throws ParserConfigurationException 
     */ 
    private DocumentBuilder getDocumentBuilder(DocumentBuilderFactory fac) throws ParserConfigurationException{ 
        return fac.newDocumentBuilder(); 
    } 
      
    /** 
     * 功能：解析XML文件 
     * @param file xml文件 
     * @return List<User> 
     * @throws ParserConfigurationException 
     * @throws SAXException 
     * @throws IOException 
     */ 
    public List<User> parseXml(File file) throws ParserConfigurationException, SAXException, IOException{ 
        factory = getDocumentBuilderFactory(); 
        builder = getDocumentBuilder(factory); 
        document = builder.parse(file); 
        List<User> list = parseXmlProcess(document); 
        return list; 
    } 
      
    /** 
     * 功能：xml文件具体解析过程 
     * @param document 
     * @return List<User> 
     */ 
    private List<User> parseXmlProcess(Document document){ 
        list = new ArrayList<User>(); 
          
        //获取根节点 
        Element root = document.getDocumentElement(); 
        //获取根节点下面的所有孩子节点 
        NodeList childNodes = root.getChildNodes(); 
          
        for(int i=0; i<childNodes.getLength(); i++){//获取节点集合长度：getLength() 
            Node node = childNodes.item(i);//获取第index 节点：item(index) 
              
            if("person".equals(node.getNodeName())){//获取当前节点tagName:getNodeName() 
                NodeList pChildNodes = node.getChildNodes(); 
              
                for(int p=0; p<pChildNodes.getLength(); p++){ 
                    Node pNode = pChildNodes.item(p); 
                  
                    if("user".equals(pNode.getNodeName())){ 
                        User user = new User(); 
                        NodeList uChildNodes = pNode.getChildNodes(); 
                      
                        for(int u=0;u<uChildNodes.getLength();u++){ 
                              
                            Node uNode = uChildNodes.item(u); 
                          
                            if("username".equals(uNode.getNodeName())){ 
                                user.setUsername(uNode.getTextContent());//获取当前节点的具体内容：getTextContent() 
                            } 
                            if("password".equals(uNode.getNodeName())){ 
                                user.setPassword(uNode.getTextContent()); 
                            } 
                            if("birthday".equals(uNode.getNodeName())){ 
                                user.setBirthday(uNode.getTextContent()); 
                            } 
                        } 
                        list.add(user); 
                    } 
                } 
            } 
        } 
          
        return list; 
    } 
}
 
 
 
 
(II)Java通过SAX解析XML
    Simple API for XML（简称SAX）是个循序存取XML的解析器API。

    一个实现SAX的解析器（也就是“SAX Parser”）以一个串流解析器的型式作用，拥有事件驱动API。由使用者定义回调函数，解析时，若发生事件的话会被调用。SAX事件包括：

  • XML 文字 节点
  • XML 元素 节点
  • XML 处理指令
  • XML 注释

 

<person> 
    <user> 
        <username>谢成志</username> 
        <password>6626310xie</password> 
        <sex>男</sex> 
        <birthday>1988/11/28</birthday> 
        <headpic> 
            <pictitle>ermao</pictitle> 
            <picurl>images/head1.jpg</picurl> 
        </headpic> 
    </user> 
</person>
 此为下面即将解析度简单xml结构，并将其封装成一个User对象。
 
//////////////////////////////////////////////////////////////////////////////////// 
package com.xcz.xml; 
  
import java.io.File; 
import java.io.IOException; 
  
import javax.xml.parsers.ParserConfigurationException; 
import javax.xml.parsers.SAXParser; 
import javax.xml.parsers.SAXParserFactory; 
  
import org.xml.sax.SAXException; 
  
import com.xcz.util.SaxUtil; 
  
public class Sax4XML { 
  
    public static void main(String[] args) { 
          
        try { 
            //1.获取factory 
            SAXParserFactory factory = SAXParserFactory.newInstance(); 
            //2.获取parser 
            SAXParser parser = factory.newSAXParser(); 
            //3.获取解析时的监听器对象 
            SaxUtil su = new SaxUtil(); 
            //4.开始解析 
            parser.parse(new File("src/user-params.xml"), su); 
              
            System.out.println(su.getUser()); 
          
        } catch (ParserConfigurationException e) { 
            e.printStackTrace(); 
        } catch (SAXException e) { 
            e.printStackTrace(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
          
    } 
}
 
//////////////////////////////////////////////////////////////////////////////////// 
package com.xcz.util; 
  
import java.text.ParseException; 
import java.text.SimpleDateFormat; 
  
import org.xml.sax.Attributes; 
import org.xml.sax.SAXException; 
import org.xml.sax.helpers.DefaultHandler; 
  
import com.xcz.po.HeadPic; 
import com.xcz.po.User; 
  
/** 
 * 定义xml解析时的监听类 
 *  
 * 实现方式有很多，可以实现接口：ContentHandler，DTDHandler， EntityResolver 和 ErrorHandler  
 * 但我们常用的继承：DefaultHandler  
 */ 
public class SaxUtil extends DefaultHandler { 
  
    private User user; 
    private HeadPic headPic; 
    private String content; 
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); 
      
    @Override 
    public void characters(char[] ch, int start, int length) 
            throws SAXException { 
        content = new String(ch, start, length); 
    } 
      
    //当解析到文本开始时触发 
    @Override 
    public void startDocument() throws SAXException { 
        super.startDocument(); 
    } 
      
    //当解析到文本结束时触发 
    @Override 
    public void endDocument() throws SAXException { 
        super.endDocument(); 
    } 
      
    //当解析到元素开始时触发 
    @Override 
    public void startElement(String uri, String localName, String name, 
            Attributes attributes) throws SAXException  
    { 
        if("user".equals(name)) 
        { 
            user = new User(); 
        } 
        if("headpic".equals(name)) 
        { 
            headPic = new HeadPic(); 
        } 
    } 
      
    //当解析到元素结束时触发 
    @Override 
    public void endElement(String uri, String localName, String name) 
            throws SAXException  
    { 
        if("username".equals(name)) 
        { 
            user.setUsername(content); 
        } 
        if("password".equals(name)) 
        { 
            user.setPassword(content); 
        } 
        if("sex".equals(name)) 
        { 
            user.setSex(content); 
        } 
        if("birthday".equals(name)) 
        { 
            try { 
                user.setBirthday(sdf.parse(content)); 
            } catch (ParseException e) { 
                // TODO Auto-generated catch block 
                e.printStackTrace(); 
            } 
        } 
        if("pictitle".equals(name)) 
        { 
            headPic.setPicTitle(content); 
        } 
        if("picurl".equals(name)) 
        { 
            headPic.setPicUrl(content); 
            user.setHeadPic(headPic); 
        } 
          
    } 
  
    public User getUser(){ 
        return user; 
    } 
      
}
 

[优点]

    (1).节约内存开销   

    SAX解析器在某些方面优于DOM风格解析器，因为SAX解析器的内存使用量一般远低于DOM解析器使用量。DOM解析器在任何处理开始之前，必须将xml以整棵树放在内存，所以DOM解析器的内存使用量完全根据输入资料的大小。相对来说，SAX解析器的内存内容，是只基于XML档案的最大深度（XML树的最大深度）和单一XML项目上XML属性储存的最大资料。

    (2)解析速度快

    因为SAX事件驱动的本质，处理文件通常会比DOM风格的解析器快。 

[缺点]

    SAX事件驱动的模型对于XML解析很有用，但它确实有某些缺点。

    某些种类的XML验证需要存取整份文件。例如，一个DTD IDREF属性需要文件内有项目使用指定字串当成DTD ID属性。要在SAX解析器内验证，必须追踪每个之前遇过的ID和IDREF属性，检查是否有任何相符。更甚者，一个IDREF找不到对应的ID，使用者只会在整份文件都解析完后才发现，若这种连结对于建立有效输出是重要的，那用在处理整份文件的时间只是浪费。

    另外，某些XML处理仅要求存取整份文件。举例来说，XSLT及XPath需要能够任何时间存取任何解析过的XML树。当SAX以用来建构此树时，DOM解析器在设计上已经是如此了。

分享到：
| spring(I)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java解析xml的四种经典方法

    Java解析XML的四种经典方法是XML处理中常用的技术，它们分别是DOM、SAX、StAX和JDOM。每种方法都有其独特的特性和适用场景，下面将详细介绍这四种方法。 1. DOM（Document Object Model）解析： DOM是W3C制定的一种...

    java解析xml的4种方法和json格式

    总结，Java解析XML有DOM、SAX、StAX和JAXB四种常见方法，每种方法各有优缺点，应根据实际需求选择合适的方法。对于JSON格式，Java提供了多种库如Gson和Jackson来方便地进行序列化和反序列化操作。理解并掌握这些知识...

    java解析xml文档的常用方法

    "java解析xml文档的常用方法" Java 解析 XML 文档的常用方法有四种：DOM、SAX、JDOM 和 DOM4J。下面对这四种方法进行详细的介绍： 1. 使用 DOM（JAXP Crimson 解析器） DOM（Document Object Model）是一种以层次...

    java解析xml及4种常用解析比较

    因此，掌握如何使用Java解析XML是非常必要的技能。本文将详细介绍Java中四种常用的XML解析技术：SAX、DOM、StAX以及JAXB，并对它们的特点、适用场景进行对比分析。 ### 1. SAX 解析器 #### 1.1 定义 SAX（Simple ...

    java解析xml例子

    DOM（Document Object Model）解析器是Java中的一种常用方法，它将整个XML文档加载到内存中，形成一个树形结构。以下是一个简单的DOM解析XML的例子： ```java import javax.xml.parsers.DocumentBuilderFactory; ...

    java解析xml——dom

    ### Java解析XML——DOM详解 #### 一、DOM解析概念 **Document Object Model (DOM)**是一种平台和语言中立的接口，它允许程序和脚本动态地访问和更新文档的内容、结构和样式。DOM最初是为HTML设计的，但后来也被...

    详解Java解析XML的四种方法

    Java解析XML的四种方法分别是DOM、SAX、JDOM和DOM4J，它们各自具有不同的特点和适用场景。本文将详细探讨这四种方法，并通过一个简单的XML示例来展示其用法。 首先，DOM（Document Object Model）是W3C制定的一种...

    java解析xml包

    本主题将深入探讨Java中常用的两种XML解析库：DOM4J和JDOM。 首先，我们来看DOM4J。DOM4J是一个灵活且功能强大的Java XML API，它基于DOM（Document Object Model）模型，但提供了更多的高级特性，如XPath支持和XML...

    JAVA解析XML

    本文介绍了Java解析XML的两种主要方式：DOM和SAX。DOM适合于需要频繁访问和修改XML数据的场景，而SAX适用于数据量大且只需读取的场景。开发者可以根据实际需求选择合适的解析方式。此外，还介绍了如何使用Java代码...

    Java and XML(英文第三版)_java_xml_birdsolc_源码

    1. **DOM解析**：DOM（Document Object Model）是W3C推荐的一种解析XML的标准方式，它将XML文档映射为一个树形结构，开发者可以通过API遍历和修改这个结构。 2. **SAX解析**：SAX（Simple API for XML）是另一种...

    java_dom解析xml xml java

    标题“java_dom解析xml xml java”表明了本文档的主题是关于如何使用Java中的DOM技术来解析XML文件。 #### 描述分析 描述中提到这是一个适合新手入门的内容，并给出了一个简单的XML示例。该XML文档包含了一个`...

    Java解析XML的方法

    通过对Java解析XML的四种方法——DOM、SAX、StAX和JDOM的介绍，我们可以看到每种方法都有其适用的场景。在实际应用中，根据具体的项目需求和资源限制，选择合适的解析方式是非常重要的。希望本文能够帮助开发者更好...

    java jdom解析xml

    Java JDOM解析XML是Java开发中处理XML文档的一种方法，JDOM全称为Java Document Object Model，它是一个基于Java语言的API，用于创建、修改和读取XML文档。JDOM为XML处理提供了一种高效且方便的解决方案，尤其适用于...

    Java更新XML的四种常用方法简介

    Java更新XML文档的方法主要包括四种，本文将探讨这些方法并分析其优缺点。首先，我们要了解JAXP（Java API for XML Processing），这是一个用于XML处理的Java编程接口，支持DOM、SAX和XSLT等标准。JAXP的可插拔层...

    用java读取xml文件的四种方法

    以下是四种常用的方法，每种都有其适用场景和特点： 1. **DOM解析器（Document Object Model）** DOM解析器将整个XML文件加载到内存中，创建一个树形结构，允许我们通过节点遍历和操作XML数据。使用Java的`javax....

    java 解析XML修改路径值

    本篇文章将详细讲解如何使用Java解析XML文件，并修改其中的特定路径值。 首先，我们需要了解Java中解析XML的两个主要库：DOM（Document Object Model）和SAX（Simple API for XML）。DOM一次性加载整个XML文档到...

    java通用解析XML工具类

    为了处理XML文档，Java提供了多种解析XML的方法，包括DOM（Document Object Model）、SAX（Simple API for XML）和StAX（Streaming API for XML）。本文将详细介绍如何创建一个Java通用的XML解析工具类，以便于在...

    Java解析Xml文件

    Java解析XML文件是一种常见的任务，尤其在处理结构化数据或者与服务器进行数据交换时。XML（eXtensible Markup Language）是一种标记语言，用于存储和传输数据，具有良好的可读性和可扩展性。在Java中，有多种方式来...

Magicbox
Global site tag (gtag.js) - Google Analytics