精华内容
下载资源
问答
  • Java Sax解析xml

    万次阅读 2018-01-23 10:06:24
     SAX,全称Simple API for XML,是一种以事件驱动的XMl API,是XML解析的一种新的替代方法,解析XML常用的还有DOM解析,PULL解析(Android特有),SAX与DOM不同的是它边扫描边解析,自顶向下依次解析,由于边扫描边...

    一、概述

     SAX,全称Simple API for XML,是一种以事件驱动的XMl API,是XML解析的一种新的替代方法,解析XML常用的还有DOM解析,PULL解析(Android特有),SAX与DOM不同的是它边扫描边解析,自顶向下依次解析,由于边扫描边解析,所以它解析XML具有速度快,占用内存少的优点,对于Android等CPU资源宝贵的移动平台来说是一个巨大的优势。

    • SAX的优点:

      1. 解析速度快
      2. 占用内存少
    • SAX的缺点:

      1. 无法知道当前解析标签(节点)的上层标签,及其嵌套结构,仅仅知道当前解析的标签的名字和属性,要知道其他信息需要程序猿自己编码
      2. 只能读取XML,无法修改XML
      3. 无法随机访问某个标签(节点)
    • SAX解析适用场合 
      1. 对于CPU资源宝贵的设备,如Android等移动设备
      2. 对于只需从xml读取信息而无需修改xml

    二、SAX解析的步骤

    解析步骤很简单,可分为以下四个步骤

    1. 得到xml文件对应的资源,可以是xml的输入流,文件和uri
    2. 得到SAX解析工厂(SAXParserFactory
    3. 由解析工厂生产一个SAX解析器(SAXParser
    4. 传入输入流和handler给解析器,调用parse()解析

    知道了SAX解析的优缺点和解析步骤,下面我们通过一个简单的Demo学习一下SAX解析XML

    三、SAX解析实战

    新建一个Android工程叫SaxParseXmlDemo,将sax.jar下载放到工程的lib下面并添加到构建路径中,为了方便,我先将工程的目录结构列一下:

    这里写图片描述

    1、新建一个xml文件叫users.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <users>
        <user id="1">
            <name>毕向东</name>
            <password>bxd123</password>
        </user>
        <user id="2">
            <name>韩顺平</name>
            <password>hsp123</password>
        </user>
        <user id="3">
            <name>马士兵</name>
            <password>msb123</password>
        </user>
    </users>

    2、新建一个JavaBean

    package com.example.saxparsexmldemo;
    
    public class User {
        private long id;
        private String name;
        private String password;
    
        public long getId() {
            return id;
        }
        public void setId(long id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getPassword() {
            return password;
        }
        public void setPassword(String password) {
            this.password = password;
        }
    }
    

    3、新建一个类XmlParseHandler.java,该类需要继承DefaultHandler或者实现ContentHandler接口,这里我们通过继承DefaultHandler(实现了ContentHandler接口)的方式,该类是SAX解析的核心所在,我们要重写以下几个我们关心的方法。

    • startDocument():文档解析开始时调用,该方法只会调用一次
    • startElement(String uri, String localName, String qName, 
      Attributes attributes):标签(节点)解析开始时调用

      1. uri:xml文档的命名空间
      2. localName:标签的名字
      3. qName:带命名空间的标签的名字
      4. attributes:标签的属性集
    • characters(char[] ch, int start, int length):解析标签的内容的时候调用

      1. ch:当前读取到的TextNode(文本节点)的字节数组
      2. start:字节开始的位置,为0则读取全部
      3. length:当前TextNode的长度
    • endElement(String uri, String localName, String qName):标签(节点)解析结束后调用
    • endDocument():文档解析结束后调用,该方法只会调用一次

     重写startDocument(),我们在这里初始化User集合,该集合用来存放解析出来的user

    Log.e("startDocument", "startDocument()");
    users = new ArrayList<User>();
    • 1
    • 2

     重写startElement,在startElement中先判断当前的标签是否user,如果是user标签则说明接下来是一个user的信息,所以我们新建一个User对象用来存放这个user的信息,在这里我们得到当前user标签的id属性,封装到user对象中。并记录当前的标签

            Log.e("startElement", localName + "-startElement()");
            if ("user".equals(localName)) { // 是一个用户
                for (int i = 0; i < attributes.getLength(); i++) {
                    Log.e("attributes", "attribute_name:" + attributes.getLocalName(i)
                            + "  attribute_value:" + attributes.getValue(i));
                    user = new User();
                    if("id".equals(attributes.getLocalName(i))){
                        user.setId(Long.parseLong(attributes.getValue(i)));
                    }
                }
            }
            currentTag = localName; // 把当前标签记录下来

     重写characters,在characters中解析出当前标签的内容,如果当前标签为name标签,则解析name标签的内容封装到当前User对象的name属性中,如果当前标签为password标签,则解析password标签的内容封装到当前User对象的password属性中

            String value = new String(ch,start,length); // 将当前TextNode转换为String
            Log.e("characters", value+"");
            if("name".equals(currentTag)){  // 当前标签为name标签,该标签无子标签,直接将上面获取到的标签的值封装到当前User对象中
                // 该节点为name节点
                user.setName(value);
            }else if("password".equals(currentTag)){  // 当前标签为password标签,该标签无子标签,直接将上面获取到的标签的值封装到当前User对象中
                // 该节点为password节点
                user.setPassword(value);
            }

     重写endElement,在这个方法中判断当前是否是user标签的结束,如果是user标签结束,则这个user信息解析结束,并将当前的User对象和当前的标签重置

            Log.e("endElement", localName + "-endElement()");
            if("user".equals(localName)){
                users.add(user);
                user = null;
            }
            currentTag = null;

     重写endDocument,这里直接给个空实现,我们只需观察Log输出

    Log.e("endDocument",  "-endDocument()");

    XmlParseHandler.java完整代码:

    package com.example.saxparsexmldemo;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    import android.util.Log;
    
    public class XmlParseHandler extends DefaultHandler {
    
        private List<User> users;
        private String currentTag; // 记录当前解析到的节点名称
        private User user; // 记录当前的user
    
        /**
         * 文档解析结束后调用
         */
        @Override
        public void endDocument() throws SAXException {
            super.endDocument();
            Log.e("endDocument",  "-endDocument()");
        }
    
        /**
         * 节点解析结束后调用
         * @param uri : 命名空间的uri
         * @param localName : 标签的名称
         * @param qName : 带命名空间的标签名称
         */
        @Override
        public void endElement(String uri, String localName, String qName)
                throws SAXException {
            super.endElement(uri, localName, qName);
            Log.e("endElement", localName + "-endElement()");
            if("user".equals(localName)){
                users.add(user);
                user = null;
            }
            currentTag = null;
        }
    
        /**
         * 文档解析开始调用
         */
        @Override
        public void startDocument() throws SAXException {
            super.startDocument();
            Log.e("startDocument", "startDocument()");
            users = new ArrayList<User>();
        }
    
        /**
         * 节点解析开始调用
         * @param uri : 命名空间的uri
         * @param localName : 标签的名称
         * @param qName : 带命名空间的标签名称
         */
        @Override
        public void startElement(String uri, String localName, String qName,
                Attributes attributes) throws SAXException {
            super.startElement(uri, localName, qName, attributes);
            Log.e("startElement", localName + "-startElement()");
            if ("user".equals(localName)) { // 是一个用户
                for (int i = 0; i < attributes.getLength(); i++) {
                    Log.e("attributes", "attribute_name:" + attributes.getLocalName(i)
                            + "  attribute_value:" + attributes.getValue(i));
                    user = new User();
                    if("id".equals(attributes.getLocalName(i))){
                        user.setId(Long.parseLong(attributes.getValue(i)));
                    }
                }
            }
            currentTag = localName; // 把当前标签记录下来
        }
    
        @Override
        public void characters(char[] ch, int start, int length)
                throws SAXException {
            super.characters(ch, start, length); 
            String value = new String(ch,start,length); // 将当前TextNode转换为String
            Log.e("characters", value+"");
            if("name".equals(currentTag)){  // 当前标签为name标签,该标签无子标签,直接将上面获取到的标签的值封装到当前User对象中
                // 该节点为name节点
                user.setName(value);
            }else if("password".equals(currentTag)){  // 当前标签为password标签,该标签无子标签,直接将上面获取到的标签的值封装到当前User对象中
                // 该节点为password节点
                user.setPassword(value);
            }
        }
    
        public List<User> getUsers() {
            return users;
        }
    }
    

    4、新建一个类XmlParseUtils.java,写一个方法进行xml解析

    public static List<User> getUsers() throws ParserConfigurationException, SAXException, IOException {
            // 加载文件返回文件的输入流
            InputStream is = XmlParseUtils.class.getClassLoader().getResourceAsStream("users.xml");
            XmlParseHandler handler = new XmlParseHandler();
            // 1. 得到SAX解析工厂
            SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
            // 2. 让工厂生产一个sax解析器
            SAXParser newSAXParser = saxParserFactory.newSAXParser();
            // 3. 传入输入流和handler,解析
            newSAXParser.parse(is, handler);
            is.close();
            return handler.getUsers();
        }

     其中第三步也可以通过XMLReader来完成

    XMLReader xmlReader = newSAXParser.getXMLReader();
    InputSource input = new InputSource(is);
    xmlReader.parse(input );

    到这里SAX解析XML的代码完成了,OK,万事具备,只欠测试了

    这里我们用Android的单元测试,只需完成调用XmlParseUtilsgetUsers()方法测试输出即可

    Android的单元测试(需要连接模拟器或者手机)

    • 环境搭建

      • 在 AndroidManifest.xml的根节点下面添加一个instrumentation

        <instrumentation android:targetPackage="com.example.saxparsexmldemo" android:name="android.test.InstrumentationTestRunner"></instrumentation>
      • 在 AndroidManifest.xml的application节点下面添加uses-library

        <uses-library android:name="android.test.runner"/>
    • com.example.saxparsexmldemo下面新建一个测试类SAXParseXmlTest.java,写一个测试方法
        public void testSAXgetUsers() throws Exception{
            List<User> users = XmlParseUtils.getUsers();
            for(User user : users){
                Log.e(TAG, "name:"+user.getName());
                Log.e(TAG, "password:"+user.getPassword());
            }
        }

     OK,右键该类的testSAXgetUsers,Run As Android JUnit Test,我们可以看到XML解析成功

    这里写图片描述

    通过上面的这个小Demo的完成,我们可以看到SAX解析代码不多也不难理解,关键是Handler的几个方法的使用,即遇到什么符号会触发什么事件,以及触发过程,掌握了SAX的事件触发,那么就掌握了SAX解析XML,下面我们来分析一下SAX解析的原理或流程

    四、SAX解析XML原理

    在分析SAX解析原理之前,我们先看一下上面的demo的日志输出

    这里写图片描述

    这里写图片描述

    以users.xml的解析过程为例,结合上面的日志输出,我们可以分析出SAX解析的流程

    1、xml解析开始,startDocument被调用,这个方法在整个xml解析过程中调用了一次,所以我们可以在这个方法里面初为解析XML做一些准备,比如初始化变量 
    2、解析每遇到一个标签都会经历startElement-characters-endElement这个过程,即每一个标签都会触发startElement-characters-endElement 
    3、通过users这个根节点的解析,user标签解析以及name,password标签解析过程,我们知道user标签是users的子标签,name和password标签是user标签的子标签,我们知道当解析一个标签的时候,如果该标签有子标签,则先回调用该标签的startElement方法,这里面可以先得到该标签的属性信息,然后触发characters解析该标签的内容(值),然后子标签触发startElement-characters-endElement(子标签触发),最后该标签触发endElement,该标签解析结束

    下面画一个图让我们进一步理解SAX解析XML的原理:

    这里写图片描述

    对上图做个简单说明,当当前标签有子标签的时候,该标签先触发characters,然后子标签触发startElement-characters-endElement事件,这个过程可以理解为一个不断递归的过程。

    OK,SAX解析原理分析完了,最后用一句话描述SAX解析过程

    startDocument-startElement-characters-endElement-endDocument

    总结,SAX解析XML具有解析速度快,占用内存少,对于Android等移动设备来说有巨大的优势,深入了解SAX的事件触发机制是掌握SAX解析的关键,掌握了SAX的事件触发就掌握了SAX解析XML

    转至http://blog.csdn.net/ydxlt/article/details/50183693

    展开全文
  • JavaScript解析XML,js解析xml字符串

    万次阅读 2016-12-06 16:54:16
    JavaScript解析XML,js解析xml字符串

    XMl

    可扩展的文本标记语言,用来传输数据和保存数据
    整个文档是一个文档节点
    每个XMl标签是一个元素节点
    包含在xml标签内的文本是文本节点
    每个xml属性是一个属性节点
    注释属于一个注释节点
    
    XML 文档形成了一种树结构,它从“根部”开始,然后扩展到“枝叶”。
    
    <?xml version="1.0" encoding="utf-8"?>//声明版本和字符集
        <root>//根元素
            <child>
                <subchild>.....</subchild>
            </child>
        </root>
    
    ps:
        xml的主要作用是为了信息传递
        xml必须有根元素
        所有的xml标签必须由关闭标签
        xml对大小写敏感
        xml必须正确的嵌套
        xml属性加引号

    JS解析Xml

    JS解析xml文件
    //创建文档  
    var xmldoc=document.implementation.createDocument('','',null);
    //是否异步,true同步,false异步
    xmldoc.async=false;
    //xml文件
    xmldoc.load('1.xml');
    JS解析字符串
    var str="<?xml version='1.0' ...........";
    
    //创建文档对象
    var parser=new DOMParser();//创建文档对象
    var xmldoc=parser.parser.parserFromString(str,'text/xml')


    代码部分:


    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="UTF-8">
        <title>js解析xml文档</title>
    </head>
    <body>
        <script type="text/javascript">
            //创建文档
            var xmlDoc=document.implementation.createDocument("","",null);
            //是否异步 true同步  false 异步
            xmlDoc.async=false;
            //xml文件
            xmlDoc.load("1.xml");
     
            //解析文档中的内容
            // console.log(xmlDoc);
            //获取文档中标签元素对象
            var names = xmlDoc.getElementsByTagName('name');
            // console.log(names);
            var arr  = [];
            for (var i = 0; i < names.length; i++) {
                arr[arr.length] = names[i].innerHTML;
            };
            console.log(arr);
     
            //获取属性
            console.log(names[0].getAttribute('class'));
        </script>
    </body>
    </html>

    1. xml

    <?xml version='1.0' encoding='utf-8'?>
    <movies>
        <movie>
            <name class='iloveyou'>辩护人</name>
            <country>韩国</country>
        </movie>
        <movie>
            <name>V字仇杀队</name>
            <country>美国</country>
        </movie>
        <movie>
            <name>盗梦空间</name>
            <country>美国</country>
        </movie>
    </movies>


    代码解析xml字符串:

    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="UTF-8">
        <title>js解析xml字符串</title>
    </head>
    <body>
        <script type="text/javascript">
        var str = "<?xml version='1.0' encoding='utf-8'?> <movies> <movie> <name>辩护人</name> <country>韩国</country> </movie> <movie> <name>V字仇杀队</name> <country>美国</country> </movie> <movie> <name>盗梦空间</name> <country>美国</country> </movie> </movies>"; 
        //创建文档对象
        var parser=new DOMParser();
        var xmlDoc=parser.parseFromString(str,"text/xml");
     
        //提取数据
        var countrys = xmlDoc.getElementsByTagName('country');
     
        var arr = [];
     
        for (var i = 0; i < countrys.length; i++) {
            arr.push(countrys[i].textContent);
        };
        console.log(arr);
         
        </script>
    </body>
    </html>


    展开全文
  • Java解析XML文件

    万次阅读 多人点赞 2017-12-27 09:47:29
    1.DOM方式解析XML Dom解析是将xml文件全部载入到内存,组装成一颗dom树,然后通过节点以及节点之间的关系来解析xml文件,与平台无关,java提供的一种基础的解析XML文件的API,理解较简单,但是由于整个文档都需要载入...
    1.DOM方式解析XML
    Dom解析是将xml文件全部载入到内存,组装成一颗dom树,然后通过节点以及节点之间的关系来解析xml文件,与平台无关,java提供的一种基础的解析XML文件的API,理解较简单,但是由于整个文档都需要载入内存,不适用于文档较大时。

    2.SAX方式解析XML
    基于事件驱动,逐条解析,适用于只处理xml数据,不易编码,而且很难同时访问同一个文档中的多处不同数据

    3.JDOM方式解析XML
    简化与XML的交互并且比使用DOM实现更快,仅使用具体类而不使用接口因此简化了API,并且易于使用

    4.DOM4j方式解析XML
    JDOM的一种智能分支,功能较强大,建议熟练使用

    下面给出例子:

    books.xml

    1. <?xml version=“1.0” encoding=“UTF-8”?>  
    2. <bookstore>  
    3.     <book id=“1”>  
    4.         <name>冰与火之歌</name>  
    5.         <author>乔治马丁</author>  
    6.         <year>2014</year>  
    7.         <price>89</price>  
    8.     </book>  
    9.     <book id=“2”>  
    10.         <name>安徒生童话</name>  
    11.         <author>安徒生</author>  
    12.         <year>2004</year>  
    13.         <price>77</price>  
    14.     </book>  
    15.     <book id=“3”>  
    16.         <name>think think think</name>  
    17.         <author>aaa</author>  
    18.         <year>1997</year>  
    19.         <price>100</price>  
    20.     </book>  
    21. </bookstore>  
    <?xml version="1.0" encoding="UTF-8"?>
    <bookstore>
        <book id="1">
            <name>冰与火之歌</name>
            <author>乔治马丁</author>
            <year>2014</year>
            <price>89</price>
        </book>
        <book id="2">
            <name>安徒生童话</name>
            <author>安徒生</author>
            <year>2004</year>
            <price>77</price>
        </book>
        <book id="3">
            <name>think think think</name>
            <author>aaa</author>
            <year>1997</year>
            <price>100</price>
        </book>
    </bookstore>
    bean类:Book.java

    1. public class Book {  
    2.       
    3.     /** 
    4.      * @author lune 
    5.      */  
    6.       
    7.     private int id;  
    8.     private String name;  
    9.     private String author;  
    10.     private int year;  
    11.     private double price;  
    12.       
    13.     /** 
    14.      * @return the id 
    15.      */  
    16.     public int getId() {  
    17.         return id;  
    18.     }  
    19.     /** 
    20.      * @param id the id to set 
    21.      */  
    22.     public void setId(int id) {  
    23.         this.id = id;  
    24.     }  
    25.     /** 
    26.      * @return the name 
    27.      */  
    28.     public String getName() {  
    29.         return name;  
    30.     }  
    31.     /** 
    32.      * @param name the name to set 
    33.      */  
    34.     public void setName(String name) {  
    35.         this.name = name;  
    36.     }  
    37.     /** 
    38.      * @return the author 
    39.      */  
    40.     public String getAuthor() {  
    41.         return author;  
    42.     }  
    43.     /** 
    44.      * @param author the author to set 
    45.      */  
    46.     public void setAuthor(String author) {  
    47.         this.author = author;  
    48.     }  
    49.     /** 
    50.      * @return the year 
    51.      */  
    52.     public int getYear() {  
    53.         return year;  
    54.     }  
    55.     /** 
    56.      * @param year the year to set 
    57.      */  
    58.     public void setYear(int year) {  
    59.         this.year = year;  
    60.     }  
    61.     /** 
    62.      * @return the price 
    63.      */  
    64.     public double getPrice() {  
    65.         return price;  
    66.     }  
    67.     /** 
    68.      * @param price the price to set 
    69.      */  
    70.     public void setPrice(double price) {  
    71.         this.price = price;  
    72.     }  
    73.       
    74.     @Override  
    75.     public String toString() {  
    76.         return “Book [id=” + id + “, name=” + name + “, author=” + author + “, year=” + year + “, price=” + price + “]”;  
    77.     }  
    78.           
    79. }  
    public class Book {
    
        /**
         * @author lune
         */
    
        private int id;
        private String name;
        private String author;
        private int year;
        private double price;
    
        /**
         * @return the id
         */
        public int getId() {
            return id;
        }
        /**
         * @param id the id to set
         */
        public void setId(int id) {
            this.id = id;
        }
        /**
         * @return the name
         */
        public String getName() {
            return name;
        }
        /**
         * @param name the name to set
         */
        public void setName(String name) {
            this.name = name;
        }
        /**
         * @return the author
         */
        public String getAuthor() {
            return author;
        }
        /**
         * @param author the author to set
         */
        public void setAuthor(String author) {
            this.author = author;
        }
        /**
         * @return the year
         */
        public int getYear() {
            return year;
        }
        /**
         * @param year the year to set
         */
        public void setYear(int year) {
            this.year = year;
        }
        /**
         * @return the price
         */
        public double getPrice() {
            return price;
        }
        /**
         * @param price the price to set
         */
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Book [id=" + id + ", name=" + name + ", author=" + author + ", year=" + year + ", price=" + price + "]";
        }
    
    }
    

    1.DOM方式解析XML

    1. import java.util.ArrayList;  
    2. import java.util.List;  
    3.   
    4. import javax.xml.parsers.DocumentBuilder;  
    5. import javax.xml.parsers.DocumentBuilderFactory;  
    6. import javax.xml.parsers.ParserConfigurationException;  
    7.   
    8. import org.w3c.dom.Document;  
    9. import org.w3c.dom.NamedNodeMap;  
    10. import org.w3c.dom.NodeList;  
    11.   
    12. import com.lune.bean.Book;  
    13.   
    14. /** 
    15.  * 用DOM方式读取xml文件 
    16.  * @author lune 
    17.  */  
    18. public class ReadxmlByDom {  
    19.     private static DocumentBuilderFactory dbFactory = null;  
    20.     private static DocumentBuilder db = null;  
    21.     private static Document document = null;  
    22.     private static List<Book> books = null;  
    23.     static{  
    24.         try {  
    25.             dbFactory = DocumentBuilderFactory.newInstance();  
    26.             db = dbFactory.newDocumentBuilder();  
    27.         } catch (ParserConfigurationException e) {  
    28.             e.printStackTrace();  
    29.         }  
    30.     }  
    31.       
    32.     public static List<Book> getBooks(String fileName) throws Exception{  
    33.         //将给定 URI 的内容解析为一个 XML 文档,并返回Document对象  
    34.         document = db.parse(fileName);  
    35.         //按文档顺序返回包含在文档中且具有给定标记名称的所有 Element 的 NodeList  
    36.         NodeList bookList = document.getElementsByTagName(”book”);  
    37.         books = new ArrayList<Book>();  
    38.         //遍历books  
    39.         for(int i=0;i<bookList.getLength();i++){  
    40.             Book book = new Book();  
    41.             //获取第i个book结点  
    42.             org.w3c.dom.Node node = bookList.item(i);  
    43.             //获取第i个book的所有属性  
    44.             NamedNodeMap namedNodeMap = node.getAttributes();  
    45.             //获取已知名为id的属性值  
    46.             String id = namedNodeMap.getNamedItem(”id”).getTextContent();//System.out.println(id);  
    47.             book.setId(Integer.parseInt(id));  
    48.               
    49.             //获取book结点的子节点,包含了Test类型的换行  
    50.             NodeList cList = node.getChildNodes();//System.out.println(cList.getLength());9  
    51.               
    52.             //将一个book里面的属性加入数组  
    53.             ArrayList<String> contents = new ArrayList<>();  
    54.             for(int j=1;j<cList.getLength();j+=2){  
    55.                   
    56.                 org.w3c.dom.Node cNode = cList.item(j);  
    57.                 String content = cNode.getFirstChild().getTextContent();  
    58.                 contents.add(content);  
    59.                 //System.out.println(contents);  
    60.             }  
    61.               
    62.             book.setName(contents.get(0));  
    63.             book.setAuthor(contents.get(1));  
    64.             book.setYear(Integer.parseInt(contents.get(2)));  
    65.             book.setPrice(Double.parseDouble(contents.get(3)));  
    66.             books.add(book);  
    67.         }  
    68.           
    69.         return books;  
    70.           
    71.     }  
    72.       
    73.     public static void main(String args[]){  
    74.         String fileName = ”src/res/books.xml”;  
    75.         try {  
    76.             List<Book> list = ReadxmlByDom.getBooks(fileName);  
    77.             for(Book book :list){  
    78.                 System.out.println(book);  
    79.             }  
    80.         } catch (Exception e) {  
    81.             // TODO Auto-generated catch block  
    82.             e.printStackTrace();  
    83.         }  
    84.     }  
    85.           
    86. }  
    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.NamedNodeMap;
    import org.w3c.dom.NodeList;
    
    import com.lune.bean.Book;
    
    /**
     * 用DOM方式读取xml文件
     * @author lune
     */
    public class ReadxmlByDom {
        private static DocumentBuilderFactory dbFactory = null;
        private static DocumentBuilder db = null;
        private static Document document = null;
        private static List<Book> books = null;
        static{
            try {
                dbFactory = DocumentBuilderFactory.newInstance();
                db = dbFactory.newDocumentBuilder();
            } catch (ParserConfigurationException e) {
                e.printStackTrace();
            }
        }
    
        public static List<Book> getBooks(String fileName) throws Exception{
            //将给定 URI 的内容解析为一个 XML 文档,并返回Document对象
            document = db.parse(fileName);
            //按文档顺序返回包含在文档中且具有给定标记名称的所有 Element 的 NodeList
            NodeList bookList = document.getElementsByTagName("book");
            books = new ArrayList<Book>();
            //遍历books
            for(int i=0;i<bookList.getLength();i++){
                Book book = new Book();
                //获取第i个book结点
                org.w3c.dom.Node node = bookList.item(i);
                //获取第i个book的所有属性
                NamedNodeMap namedNodeMap = node.getAttributes();
                //获取已知名为id的属性值
                String id = namedNodeMap.getNamedItem("id").getTextContent();//System.out.println(id);
                book.setId(Integer.parseInt(id));
    
                //获取book结点的子节点,包含了Test类型的换行
                NodeList cList = node.getChildNodes();//System.out.println(cList.getLength());9
    
                //将一个book里面的属性加入数组
                ArrayList<String> contents = new ArrayList<>();
                for(int j=1;j<cList.getLength();j+=2){
    
                    org.w3c.dom.Node cNode = cList.item(j);
                    String content = cNode.getFirstChild().getTextContent();
                    contents.add(content);
                    //System.out.println(contents);
                }
    
                book.setName(contents.get(0));
                book.setAuthor(contents.get(1));
                book.setYear(Integer.parseInt(contents.get(2)));
                book.setPrice(Double.parseDouble(contents.get(3)));
                books.add(book);
            }
    
            return books;
    
        }
    
        public static void main(String args[]){
            String fileName = "src/res/books.xml";
            try {
                List<Book> list = ReadxmlByDom.getBooks(fileName);
                for(Book book :list){
                    System.out.println(book);
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }
    


    2.SAX方式解析XML
    需要自定义DefaultHandler处理器

    1. import java.util.ArrayList;  
    2. import java.util.List;  
    3.   
    4. import org.xml.sax.Attributes;  
    5. import org.xml.sax.SAXException;  
    6. import org.xml.sax.helpers.DefaultHandler;  
    7.   
    8. import com.lune.bean.Book;  
    9.   
    10. /** 
    11.  * 用SAX解析xml文件时需要的handler 
    12.  * @author lune 
    13.  */  
    14. public class SAXParseHandler extends DefaultHandler {  
    15.     private List<Book> list;         //存放解析到的book数组  
    16.     private Book book;               //存放当前解析的book  
    17.       
    18.     private String content = null;   //存放当前节点值  
    19.       
    20.     /** 
    21.      * 开始解析xml文档时调用此方法 
    22.      */  
    23.     @Override  
    24.     public void startDocument() throws SAXException {  
    25.           
    26.         super.startDocument();  
    27.         System.out.println(”开始解析xml文件”);  
    28.         list = new ArrayList<Book>();  
    29.     }  
    30.   
    31.   
    32.   
    33.     /**  
    34.      * 文档解析完成后调用此方法 
    35.      */  
    36.     @Override  
    37.     public void endDocument() throws SAXException {  
    38.           
    39.         super.endDocument();  
    40.         System.out.println(”xml文件解析完毕”);  
    41.     }  
    42.   
    43.   
    44.   
    45.     /** 
    46.      * 开始解析节点时调用此方法 
    47.      */  
    48.     @Override  
    49.     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
    50.           
    51.         super.startElement(uri, localName, qName, attributes);  
    52.           
    53.         //当节点名为book时,获取book的属性id  
    54.         if(qName.equals(“book”)){  
    55.             book = new Book();  
    56.             String id = attributes.getValue(”id”);//System.out.println(“id值为”+id);  
    57.             book.setId(Integer.parseInt(id));  
    58.         }  
    59.           
    60.     }  
    61.   
    62.   
    63.     /** 
    64.      *节点解析完毕时调用此方法 
    65.      * 
    66.      *@param qName 节点名 
    67.      */  
    68.     @Override  
    69.     public void endElement(String uri, String localName, String qName) throws SAXException {  
    70.           
    71.         super.endElement(uri, localName, qName);  
    72.         if(qName.equals(“name”)){  
    73.             book.setName(content);  
    74.             //System.out.println(“书名”+content);  
    75.         }else if(qName.equals(“author”)){  
    76.             book.setAuthor(content);  
    77.         //  System.out.println(“作者”+content);  
    78.         }else if(qName.equals(“year”)){  
    79.             book.setYear(Integer.parseInt(content));  
    80.         //  System.out.println(“年份”+content);  
    81.         }else if(qName.equals(“price”)){  
    82.             book.setPrice(Double.parseDouble(content));  
    83.         //  System.out.println(“价格”+content);  
    84.         }else if(qName.equals(“book”)){         //当结束当前book解析时,将该book添加到数组后置为空,方便下一次book赋值  
    85.             list.add(book);  
    86.             book = null;  
    87.         }     
    88.           
    89.     }  
    90.   
    91.   
    92.   
    93.     /**  
    94.      * 此方法用来获取节点的值 
    95.      */  
    96.     @Override  
    97.     public void characters(char[] ch, int start, int length) throws SAXException {  
    98.           
    99.         super.characters(ch, start, length);  
    100.           
    101.         content = new String(ch, start, length);  
    102.         //收集不为空白的节点值  
    103. //      if(!content.trim().equals(“”)){  
    104. //          System.out.println(“节点值为:”+content);  
    105. //      }  
    106.           
    107.     }  
    108.   
    109.     public List<Book> getBooks(){  
    110.         return list;  
    111.     }  
    112.       
    113. }  
    import java.util.ArrayList;
    import java.util.List;
    
    import org.xml.sax.Attributes;
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.DefaultHandler;
    
    import com.lune.bean.Book;
    
    /**
     * 用SAX解析xml文件时需要的handler
     * @author lune
     */
    public class SAXParseHandler extends DefaultHandler {
        private List<Book> list;         //存放解析到的book数组
        private Book book;               //存放当前解析的book
    
        private String content = null;   //存放当前节点值
    
        /**
         * 开始解析xml文档时调用此方法
         */
        @Override
        public void startDocument() throws SAXException {
    
            super.startDocument();
            System.out.println("开始解析xml文件");
            list = new ArrayList<Book>();
        }
    
    
    
        /** 
         * 文档解析完成后调用此方法
         */
        @Override
        public void endDocument() throws SAXException {
    
            super.endDocument();
            System.out.println("xml文件解析完毕");
        }
    
    
    
        /**
         * 开始解析节点时调用此方法
         */
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
    
            super.startElement(uri, localName, qName, attributes);
    
            //当节点名为book时,获取book的属性id
            if(qName.equals("book")){
                book = new Book();
                String id = attributes.getValue("id");//System.out.println("id值为"+id);
                book.setId(Integer.parseInt(id));
            }
    
        }
    
    
        /**
         *节点解析完毕时调用此方法
         *
         *@param qName 节点名
         */
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
    
            super.endElement(uri, localName, qName);
            if(qName.equals("name")){
                book.setName(content);
                //System.out.println("书名"+content);
            }else if(qName.equals("author")){
                book.setAuthor(content);
            //  System.out.println("作者"+content);
            }else if(qName.equals("year")){
                book.setYear(Integer.parseInt(content));
            //  System.out.println("年份"+content);
            }else if(qName.equals("price")){
                book.setPrice(Double.parseDouble(content));
            //  System.out.println("价格"+content);
            }else if(qName.equals("book")){         //当结束当前book解析时,将该book添加到数组后置为空,方便下一次book赋值
                list.add(book);
                book = null;
            }   
    
        }
    
    
    
        /** 
         * 此方法用来获取节点的值
         */
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
    
            super.characters(ch, start, length);
    
            content = new String(ch, start, length);
            //收集不为空白的节点值
    //      if(!content.trim().equals("")){
    //          System.out.println("节点值为:"+content);
    //      }
    
        }
    
        public List<Book> getBooks(){
            return list;
        }
    
    }


    1. import java.io.IOException;  
    2. import java.util.List;  
    3.   
    4. import javax.xml.parsers.ParserConfigurationException;  
    5. import javax.xml.parsers.SAXParser;  
    6. import javax.xml.parsers.SAXParserFactory;  
    7.   
    8. import org.xml.sax.SAXException;  
    9. import org.xml.sax.helpers.ParserFactory;  
    10.   
    11. import com.lune.bean.Book;  
    12. import com.lune.handler.SAXParseHandler;  
    13.   
    14. /** 
    15.  * 用SAX方式读取xml文件 
    16.  * @author lune 
    17.  */  
    18. public class ReadXmlBySAX {  
    19.   
    20.     private static List<Book> books = null;  
    21.       
    22.     private  SAXParserFactory sParserFactory = null;  
    23.     private  SAXParser parser = null;  
    24.       
    25.       
    26.     public List<Book> getBooks(String fileName) throws Exception{  
    27.         SAXParserFactory sParserFactory = SAXParserFactory.newInstance();  
    28.         SAXParser parser = sParserFactory.newSAXParser();  
    29.           
    30.         SAXParseHandler handler = new SAXParseHandler();  
    31.         parser.parse(fileName, handler);  
    32.           
    33.         return handler.getBooks();  
    34.           
    35.     }  
    36.     /** 
    37.      * @param args 
    38.      */  
    39.     public static void main(String[] args) {  
    40.         try {  
    41.             books = new ReadXmlBySAX().getBooks(“src/res/books.xml”);  
    42.             for(Book book:books){  
    43.                 System.out.println(book);  
    44.             }  
    45.               
    46.         } catch (Exception e) {  
    47.             e.printStackTrace();  
    48.         }  
    49.   
    50.     }  
    51.   
    52. }  
    import java.io.IOException;
    import java.util.List;
    
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.parsers.SAXParser;
    import javax.xml.parsers.SAXParserFactory;
    
    import org.xml.sax.SAXException;
    import org.xml.sax.helpers.ParserFactory;
    
    import com.lune.bean.Book;
    import com.lune.handler.SAXParseHandler;
    
    /**
     * 用SAX方式读取xml文件
     * @author lune
     */
    public class ReadXmlBySAX {
    
        private static List<Book> books = null;
    
        private  SAXParserFactory sParserFactory = null;
        private  SAXParser parser = null;
    
    
        public List<Book> getBooks(String fileName) throws Exception{
            SAXParserFactory sParserFactory = SAXParserFactory.newInstance();
            SAXParser parser = sParserFactory.newSAXParser();
    
            SAXParseHandler handler = new SAXParseHandler();
            parser.parse(fileName, handler);
    
            return handler.getBooks();
    
        }
        /**
         * @param args
         */
        public static void main(String[] args) {
            try {
                books = new ReadXmlBySAX().getBooks("src/res/books.xml");
                for(Book book:books){
                    System.out.println(book);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    
    }
    
    3.JDOM方式解析XML

    1. import java.io.FileInputStream;  
    2. import java.io.FileNotFoundException;  
    3. import java.io.IOException;  
    4. import java.util.ArrayList;  
    5. import java.util.List;  
    6.   
    7. import org.jdom2.JDOMException;  
    8. import org.jdom2.input.SAXBuilder;  
    9.   
    10. import com.lune.bean.Book;  
    11.   
    12. import org.jdom2.*;  
    13.   
    14. /** 
    15.  * 用JDOM方式读取xml文件 
    16.  * @author lune 
    17.  */  
    18. public class ReadXMLByJDom {  
    19.       
    20.     private List<Book> books = null;  
    21.     private Book book = null;  
    22.       
    23.     public List<Book> getBooks(String fileName){  
    24.         SAXBuilder saxBuilder = new SAXBuilder();  
    25.         try {  
    26.             Document document = saxBuilder.build(new FileInputStream(fileName));  
    27.             //获取根节点bookstore  
    28.             Element rootElement = document.getRootElement();  
    29.             //获取根节点的子节点,返回子节点的数组  
    30.             List<Element> bookList = rootElement.getChildren();  
    31.             books = new ArrayList<Book>();  
    32.             for(Element bookElement : bookList){  
    33.                 book = new Book();  
    34.                 //获取bookElement的属性  
    35.                 List<Attribute> bookAttributes = bookElement.getAttributes();  
    36.                 for(Attribute attribute : bookAttributes){  
    37.                     if(attribute.getName().equals(“id”)){  
    38.                         String id = attribute.getValue(); //System.out.println(id);  
    39.                         book.setId(Integer.parseInt(id));  
    40.                     }  
    41.                 }  
    42.                 //获取bookElement的子节点  
    43.                 List<Element> children = bookElement.getChildren();  
    44.                 for(Element child : children){  
    45.                     if(child.getName().equals(“name”)){  
    46.                         String name = child.getValue();//System.out.println(name);  
    47.                         book.setName(name);  
    48.                     }else if(child.getName().equals(“author”)){  
    49.                         String author = child.getValue();  
    50.                         book.setAuthor(author);//System.out.println(author);  
    51.                     }else if(child.getName().equals(“year”)){  
    52.                         String year = child.getValue();  
    53.                         book.setYear(Integer.parseInt(year));  
    54.                     }else if(child.getName().equals(“price”)){  
    55.                         String price = child.getValue();  
    56.                         book.setPrice(Double.parseDouble(price));  
    57.                     }  
    58.                       
    59.                 }  
    60.                   
    61.                 books.add(book);  
    62.                 book = null;  
    63.                   
    64.             }  
    65.               
    66.         } catch (FileNotFoundException e) {  
    67.               
    68.             e.printStackTrace();  
    69.         } catch (JDOMException e) {  
    70.               
    71.             e.printStackTrace();  
    72.         } catch (IOException e) {  
    73.               
    74.             e.printStackTrace();  
    75.         }  
    76.           
    77.         return books;  
    78.           
    79.     }  
    80.   
    81.       
    82.     public static void main(String[] args) {  
    83.         // TODO Auto-generated method stub  
    84.         String fileName = ”src/res/books.xml”;  
    85.         List<Book> books= new ReadXMLByJDom().getBooks(fileName);  
    86.         for(Book book : books){  
    87.             System.out.println(book);  
    88.         }  
    89.     }  
    90.   
    91. }  
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    import org.jdom2.JDOMException;
    import org.jdom2.input.SAXBuilder;
    
    import com.lune.bean.Book;
    
    import org.jdom2.*;
    
    /**
     * 用JDOM方式读取xml文件
     * @author lune
     */
    public class ReadXMLByJDom {
    
        private List<Book> books = null;
        private Book book = null;
    
        public List<Book> getBooks(String fileName){
            SAXBuilder saxBuilder = new SAXBuilder();
            try {
                Document document = saxBuilder.build(new FileInputStream(fileName));
                //获取根节点bookstore
                Element rootElement = document.getRootElement();
                //获取根节点的子节点,返回子节点的数组
                List<Element> bookList = rootElement.getChildren();
                books = new ArrayList<Book>();
                for(Element bookElement : bookList){
                    book = new Book();
                    //获取bookElement的属性
                    List<Attribute> bookAttributes = bookElement.getAttributes();
                    for(Attribute attribute : bookAttributes){
                        if(attribute.getName().equals("id")){
                            String id = attribute.getValue(); //System.out.println(id);
                            book.setId(Integer.parseInt(id));
                        }
                    }
                    //获取bookElement的子节点
                    List<Element> children = bookElement.getChildren();
                    for(Element child : children){
                        if(child.getName().equals("name")){
                            String name = child.getValue();//System.out.println(name);
                            book.setName(name);
                        }else if(child.getName().equals("author")){
                            String author = child.getValue();
                            book.setAuthor(author);//System.out.println(author);
                        }else if(child.getName().equals("year")){
                            String year = child.getValue();
                            book.setYear(Integer.parseInt(year));
                        }else if(child.getName().equals("price")){
                            String price = child.getValue();
                            book.setPrice(Double.parseDouble(price));
                        }
    
                    }
    
                    books.add(book);
                    book = null;
    
                }
    
            } catch (FileNotFoundException e) {
    
                e.printStackTrace();
            } catch (JDOMException e) {
    
                e.printStackTrace();
            } catch (IOException e) {
    
                e.printStackTrace();
            }
    
            return books;
    
        }
    
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            String fileName = "src/res/books.xml";
            List<Book> books= new ReadXMLByJDom().getBooks(fileName);
            for(Book book : books){
                System.out.println(book);
            }
        }
    
    }

    4.DOM4j方式解析XML

    1. import java.io.File;  
    2. import java.util.ArrayList;  
    3. import java.util.Iterator;  
    4. import java.util.List;  
    5.   
    6. import org.dom4j.Attribute;  
    7. import org.dom4j.Document;  
    8. import org.dom4j.DocumentException;  
    9. import org.dom4j.Element;  
    10. import org.dom4j.io.SAXReader;  
    11.   
    12. import com.lune.bean.Book;  
    13.   
    14. /** 
    15.  * 用DOM4J方法读取xml文件 
    16.  * @author lune 
    17.  */  
    18. public class ReadXMLByDom4j {  
    19.       
    20.     private List<Book> bookList = null;  
    21.     private Book book = null;  
    22.       
    23.     public List<Book> getBooks(File file){  
    24.           
    25.         SAXReader reader = new SAXReader();  
    26.         try {  
    27.             Document document = reader.read(file);  
    28.             Element bookstore = document.getRootElement();  
    29.             Iterator storeit = bookstore.elementIterator();  
    30.               
    31.             bookList = new ArrayList<Book>();  
    32.             while(storeit.hasNext()){  
    33.                   
    34.                 book = new Book();  
    35.                 Element bookElement = (Element) storeit.next();  
    36.                 //遍历bookElement的属性  
    37.                 List<Attribute> attributes = bookElement.attributes();  
    38.                 for(Attribute attribute : attributes){  
    39.                     if(attribute.getName().equals(“id”)){  
    40.                         String id = attribute.getValue();//System.out.println(id);  
    41.                         book.setId(Integer.parseInt(id));  
    42.                     }  
    43.                 }  
    44.                   
    45.                 Iterator bookit = bookElement.elementIterator();  
    46.                 while(bookit.hasNext()){  
    47.                     Element child = (Element) bookit.next();  
    48.                     String nodeName = child.getName();  
    49.                     if(nodeName.equals(“name”)){  
    50.                         //System.out.println(child.getStringValue());  
    51.                         String name = child.getStringValue();  
    52.                         book.setName(name);  
    53.                     }else if(nodeName.equals(“author”)){  
    54.                         String author = child.getStringValue();  
    55.                         book.setAuthor(author);  
    56.                     }else if(nodeName.equals(“year”)){  
    57.                         String year = child.getStringValue();  
    58.                         book.setYear(Integer.parseInt(year));  
    59.                     }else if(nodeName.equals(“price”)){  
    60.                         String price = child.getStringValue();  
    61.                         book.setPrice(Double.parseDouble(price));  
    62.                     }  
    63.                 }  
    64.                 bookList.add(book);  
    65.                 book = null;  
    66.                   
    67.             }  
    68.         } catch (DocumentException e) {  
    69.           
    70.             e.printStackTrace();  
    71.         }  
    72.           
    73.           
    74.         return bookList;  
    75.           
    76.     }  
    77.       
    78.   
    79.     /** 
    80.      * @param args 
    81.      */  
    82.     public static void main(String[] args) {  
    83.         // TODO Auto-generated method stub  
    84.         File file = new File(“src/res/books.xml”);  
    85.         List<Book> bookList = new ReadXMLByDom4j().getBooks(file);  
    86.         for(Book book : bookList){  
    87.             System.out.println(book);  
    88.         }  
    89.     }  
    90.   
    91. }  
    import java.io.File;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    import com.lune.bean.Book;
    
    /**
     * 用DOM4J方法读取xml文件
     * @author lune
     */
    public class ReadXMLByDom4j {
    
        private List<Book> bookList = null;
        private Book book = null;
    
        public List<Book> getBooks(File file){
    
            SAXReader reader = new SAXReader();
            try {
                Document document = reader.read(file);
                Element bookstore = document.getRootElement();
                Iterator storeit = bookstore.elementIterator();
    
                bookList = new ArrayList<Book>();
                while(storeit.hasNext()){
    
                    book = new Book();
                    Element bookElement = (Element) storeit.next();
                    //遍历bookElement的属性
                    List<Attribute> attributes = bookElement.attributes();
                    for(Attribute attribute : attributes){
                        if(attribute.getName().equals("id")){
                            String id = attribute.getValue();//System.out.println(id);
                            book.setId(Integer.parseInt(id));
                        }
                    }
    
                    Iterator bookit = bookElement.elementIterator();
                    while(bookit.hasNext()){
                        Element child = (Element) bookit.next();
                        String nodeName = child.getName();
                        if(nodeName.equals("name")){
                            //System.out.println(child.getStringValue());
                            String name = child.getStringValue();
                            book.setName(name);
                        }else if(nodeName.equals("author")){
                            String author = child.getStringValue();
                            book.setAuthor(author);
                        }else if(nodeName.equals("year")){
                            String year = child.getStringValue();
                            book.setYear(Integer.parseInt(year));
                        }else if(nodeName.equals("price")){
                            String price = child.getStringValue();
                            book.setPrice(Double.parseDouble(price));
                        }
                    }
                    bookList.add(book);
                    book = null;
    
                }
            } catch (DocumentException e) {
    
                e.printStackTrace();
            }
    
    
            return bookList;
    
        }
    
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            File file = new File("src/res/books.xml");
            List<Book> bookList = new ReadXMLByDom4j().getBooks(file);
            for(Book book : bookList){
                System.out.println(book);
            }
        }
    
    }

    其中后两者需要导入外部jar包.

    文章中的源码可在下面地址下载:

    http://github.com/clemontine/XMLParser


    展开全文
  • Android解析XML文件

    千次下载 热门讨论 2012-07-27 22:23:16
    本例使用多种方式获取本地XML文件,还有通过url获取XML文件,使用Android内置的PULL解析器对XML文件进行解析,例子是解析我国... 《Android解析XML文件》博文路径:http://blog.csdn.net/zzp16/article/details/7795410
  • XML解析之SAX方式解析xml文件

    万次阅读 2017-11-02 12:24:33
    SAX解析方式会逐行地去扫描XML文档,当遇到标签时会触发解析处理器,采用事件处理的方式解析XML (Simple API for XML) ,不是官方标准,但它是 XML 社区事实上的标准,几乎所有的 XML 解析器都支持它。优点是:在...

    SAX解析方式会逐行地去扫描XML文档,当遇到标签时会触发解析处理器,采用事件处理的方式解析XML (Simple API for XML) ,不是官方标准,但它是 XML 社区事实上的标准,几乎所有的 XML 解析器都支持它。优点是:在读取文档的同时即可对XML进行处理,不必等到文档加载结束,相对快捷。不需要加载进内存,因此不存在占用内存的问题,可以解析超大XML。缺点是:只能用来读取XML中数据,无法进行增删改。
    SAX解析原理图
    SAX解析可分四个步骤进行:
    1、得到xml文件对应的资源,可以是xml的输入流,文件和uri
    2、得到SAX解析工厂(SAXParserFactory)
    3、由解析工厂生产一个SAX解析器(SAXParser)
    4、传入输入流和handler给解析器,调用parse()解析

    public static void main(String[] args) throws Exception {
            //1.创建解析工厂
    SAXParserFactoryfactory=SAXParserFactory.newInstance();
            //2.得到解析器
            SAXParser sp=factory.newSAXParser();
            //3得到解读器
            XMLReader reader=sp.getXMLReader();
            //设置内容处理器
            reader.setContentHandler(new ListHandler());
            //读取xml的文档内容
            reader.parse("src/Book.xml");
    
        }
    
    }
    

    1.创建一个Book.xml的 xml文档

    <?xml version="1.0" encoding="UTF-8"?>
    <书架>
        <>
            <书名 name="dddd">java web就业</书名>
            <作者>张三</作者>
            <售价>40</售价> 
        </>
        <>
            <书名 name="xxxx">HTML教程</书名>
            <作者>自己</作者>
            <售价>50</售价> 
        </>
    </书架>

    2.创建一个javaBean实体类

    package sax;
    public class Book {
        private String name;
        private String author;
        private String price;
        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 getPrice() {
            return price;
        }
        public void setPrice(String price) {
            this.price = price;
        }
        @Override
        public String toString() {
            return "Book [name=" + name + ", author=" + author + ", price=" + price + "]";
        }
    }
    

    3.新建一个ListHandler类,这个类需要DefaultHandler或者实现ContentHandler接口。该类是SAX解析的核心所在,我们要重写以下几个我们关心的方法。
    1、startDocument():文档解析开始时调用,该方法只会调用一次
    2、startElement(String uri, String localName, String qName,
    3、Attributes attributes):标签(节点)解析开始时调用

    uri:xml文档的命名空间
    localName:标签的名字
    qName:带命名空间的标签的名字
    attributes:标签的属性集
    characters(char[] ch, int start, int length):解析标签的内容的时候调用
    
    ch:当前读取到的TextNode(文本节点)的字节数组
    start:字节开始的位置,为0则读取全部
    length:当前TextNode的长度
    

    4、endElement(String uri, String localName, String qName):标签(节点)解析结束后调用
    5、endDocument():文档解析结束后调用,该方法只会调用一次

    新建的ListHandler类实现完整代码如下:

    class ListHandler implements ContentHandler{
    
        /**
         * 当读取到第一个元素时开始做什么
         */
    
        @Override
        public void startElement(String uri, String localName, String qName,
                Attributes atts) throws SAXException {
            System.out.print("<"+qName);
            for(int i=0;atts!=null&&i<atts.getLength();i++){
                String attName=atts.getQName(i);
                String attValueString=atts.getValue(i);
                System.out.print(" "+attName+"="+attValueString);
                System.out.print(">");
            }
    
        }
        /**
         * 表示读取到第一个元素结尾时做什么
         */
        @Override
        public void endElement(String uri, String localName, String qName)
                throws SAXException {
            System.out.print("</"+qName+">");
    
        }
        /**
         * 表示读取字符串时做什么
         */
        @Override
        public void characters(char[] ch, int start, int length)
                throws SAXException {
            System.out.print(new String(ch,start,length));
    
        }
    
        @Override
        public void setDocumentLocator(Locator locator) {
            // TODO Auto-generated method stub
    
        }
    
    
        @Override
        public void startDocument() throws SAXException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void endDocument() throws SAXException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void startPrefixMapping(String prefix, String uri)
                throws SAXException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void endPrefixMapping(String prefix) throws SAXException {
            // TODO Auto-generated method stub
    
        }
    
    
        @Override
        public void ignorableWhitespace(char[] ch, int start, int length)
                throws SAXException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void processingInstruction(String target, String data)
                throws SAXException {
            // TODO Auto-generated method stub
    
        }
    
        @Override
        public void skippedEntity(String name) throws SAXException {
            // TODO Auto-generated method stub
    
        }
    
    }
    

    到此,sax方式解析XML文档结束。
    总结,SAX解析XML具有解析速度快,占用内存少,对于Android等移动设备来说有巨大的优势,深入了解SAX的事件触发机制是掌握SAX解析的关键,掌握了SAX的事件触发就掌握了SAX解析XML,附上运行结果图!本文如有理解不当之处,还请各位指出,并共勉!
    sax解析xml文档效果图

    展开全文
  • XML简介与Dom4j解析XML

    2021-01-26 19:33:23
    树结构与xml文件的解析技术1.1树结构1.2xml文件的解析技术2.Dom4j解析XML 一.XML简介 首先我们先简单介绍一下什么是xml,如果对这方面已有所了解的小伙伴们可以跳过标题一。 比较着急的小伙伴可以直接看标题二中的2....
  • anglurJs解析XML

    2016-10-11 16:44:13
    这里解析XML并不是直接解析XML,而是先把XML转换为JSON再使用!
  • Java 解析 XML

    千次阅读 2016-01-31 07:23:08
    Java 解析 XML标签: Java基础XML解析技术有两种 DOM SAX DOM方式 根据XML的层级结构在内存中分配一个树形结构,把XML的标签,属性和文本等元素都封装成树的节点对象 优点: 便于实现增 删 改 查 缺点: XML文件过大...
  • 使用BeautifulSoup4解析XML

    万次阅读 多人点赞 2018-11-22 10:04:59
    Beautiful Soup 是一个用来从HTML或XML文件中提取数据的Python库,它利用大家所喜欢的解析器提供了许多惯用方法用来对文档树进行导航、查找和修改。 帮助文档英文版:...
  • 解析XML文件(SAX方式解析XML

    千次阅读 2011-10-10 09:44:20
    解析XML文件(SAX方式解析XML) 对XML文件解析有四种方法:DOM、SAX、JDOM、DOM4J 现着重讲一下SAX解析XML文件。 1、通过一定的方式获取文件名 // 获得文件路径 String xmlFilePath = TIcanServiceAccess
  • C++解析XML文件

    千次阅读 2019-04-10 23:58:27
    C++解析XML文件TinyXML安装下载解析XML文件 最近在使用C++处理GF-3和RADARSAT-2雷达影像,需要通过解析XML文件获取影像时间,我选用了TinyXML库来解析。参考了网上的一些教程,这个文档个人觉得是解释的很清晰的。...
  • 解析XML的方法

    千次阅读 2014-07-21 23:15:57
    解析XML的方法 1、DOM生成和解析XML 2、SAX生成和解析XML 3、DOM4J生成和解析XML 4、JDOM生成和解析XML
  • Java进阶(二十七)使用Dom4j解析XML文件

    万次阅读 2016-04-23 21:24:11
    使用Dom4j解析XML文件写在前面的话 由于论文实验要求,需要实现操作XML文档,为此想到了dom4j这个工具,使用之后深感受益。在此分享给大家,以此共勉。 注:本文转载自...
  • QT解析XML

    千次阅读 2018-08-27 17:11:16
    必要的准备环境: //在QT中 //Pro中添加 Qt += xml // 在VS中属性中添加 Qt5Xml.lib//或 Qt5Xmld.lib //头文件 #include &...解析xml有三种解析方式,分别是: 1、通过QXmlStreamReader的方式 ...
  • XML解析(三),PULL解析XML

    千次阅读 2015-12-06 08:52:55
    昨天写了【XML解析(一)】SAX解析XML 和【XML解析(二)】DOM解析XML两篇文章,有兴趣的朋友可以去看一下,今天我们来学习一下PULL解析XML,刚好可以跟SAX和DOC解析XML的两种方式对比学习,其实Android里面解析XML...
  • Java SAX 解析 XML

    千次阅读 2016-12-26 23:16:09
    与 DOM 建立树形结构的方式不同,SAX 采用事件模型来解析 XML 文档,是解析 XML 文档的一种更快速、更轻量的方法。 利用 SAX 可以对 XML 文档进行有选择的解析和访问,而...在解析xml文件之前,我们要先了解xml文件的
  • XML解析(二),DOM解析XML

    千次阅读 2015-12-05 13:56:24
    上篇文章向大家介绍了SAX解析XML,为了这篇文章理解起来更加方便,所以还没看过SAX解析XML文章的,请戳这【XML解析(一)】SAX解析XML ,这次给大家带来XML解析系列之DOM解析XML 一、概述 DOM,擦,这什么鬼,肯定又...
  • vue 怎么解析xml

    千次阅读 2020-02-09 17:48:35
    vue 怎么解析xml 用vue请求接口的时候有时会遇到xml格式的返回数据,例如 <id>1111</id><name>lucy</name> 这样的格式用正则表达式或者截取的话都会很麻烦的,那怎么做呢??? 就使用x2js...
  • XML解析(一),SAX解析XML

    万次阅读 2015-12-05 09:38:59
    一、概述 SAX,全称Simple API for XML,是一种以事件驱动的XMl API,是XML解析的一种新的替代方法,解析XML常用的还有DOC解析,PULL解析(Android特有),SAX与DOC不同的是它边扫描边解析,自顶向下依次解析,由于...
  • Java解析XML文件的方式

    千次阅读 2020-01-30 18:36:06
    在项目里,我们往往会把一些配置信息放到xml文件里,或者各部门间会通过xml文件来交换业务数据,所以有时候我们会遇到“解析xml文件”的需求。一般来讲,有基于DOM树和SAX的两种解析xml文件的方式,在这部分里,将...
  • 一、一般解析XML文件的方法有SAX和DOM、PULL(1)DOM(JAXP Crimson解析器)DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中...
  • 解析 XML格式数据

    万次阅读 2017-11-18 10:43:58
    解析 XML格式数据
  • java解析XML——Pull解析

    千次阅读 2017-09-03 09:39:46
    除了可以使用SAX或DOM解析XML文件之外,在Android中可以使用Android内置的Pull解析器解析XML文件。 Pull解析器是一个开源的java项目,既可以用于android,也可以用于JavaEE。如果用在javaEE需要把其jar文件放入类...
  • python解析xml文件(解析、更新、写入)

    万次阅读 多人点赞 2019-04-24 11:24:36
    这篇博客内容将包括对XML文件的解析、追加新元素后写入到XML,以及更新原XML文件中某结点的值。使用的是python的xml.dom.minidom包,详情可见其官方文档:xml.dom.minidom官方文档。全文都将围绕以下的customer.xml...
  • tinyxml2之解析xml文件

    千次阅读 2018-06-04 22:49:23
     tinyXML2是一个开源的解析XML的C++库,用于c++项目里面解析xml文件使用。下载地址:https://github.com/leethomason/tinyxml2 ,使用git直接将源码下载下来。使用方法:将下载的源码包里面的tinyxml2.h,tinyxml2....
  • oracle 解析XML

    千次阅读 2017-09-26 19:58:56
    --解析xml,并获得xml数据的值  select x.wf_orunid,extractvalue(xmltype(X.XMLDATA),'/Items/WFItem[@name="WH"]') as wh  ,b.swh as swh from bpm_archiveddata x,oa_bpm_docincome b --多表关联查询更新...
  • DocumentBuilderFactory解析xml

    千次阅读 2016-11-30 23:40:28
    使用DocumentBuilderFactory来解析xml文件 首先是主函数代码: public static void main(String[] args) { try { final Document xml = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse
  • C++ 使用 TinyXml 解析 XML 文件

    千次阅读 2017-12-02 19:00:01
    TinyXML是一个开源的解析XML的解析库,能够用于C++,能够在Windows或Linux中编译,使用TinyXML进行C++ XML解析,使用简单,容易上手。这个解析库的模型通过解析XML文件,然后在内存中生成DOM模型,从而让我们很方便的...
  • python解析xml超简单

    千次阅读 2019-06-18 15:51:38
    Python解析XML 软件测试老师布置的实验,解析xml,因为是小白,所以刚做这题很棘手,百度搜了好多python解析xml,都相对而言太基础,举的例子,就是一个父节点带一个子节点,标签屈指可数,直接get标签名就得到了,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,111
精华内容 33,244
关键字:

解析xml