精华内容
下载资源
问答
  • 解析XML文件

    千次阅读 2016-12-27 17:27:54
    在PL/SQL中利用XML ,Oracle提供了几个组件,让开发人员能轻松地利用XML技术。这些组件包括:  1.  XML 分析程序。即用来分析、构造和验证XML文档。. 2. XPath 引擎。 它是使用Xpath(XML标准的另一个元素...

    参考:http://blog.csdn.net/cai_xingyun/article/details/18225427

    PL/SQL中利用XML ,Oracle提供了几个组件,让开发人员能轻松地利用XML技术。这些组件包括:

     1.  XML 分析程序。即用来分析、构造和验证XML文档。.

    2. XPath 引擎。 它是使用XpathXML标准的另一个元素)说明语法在内存中搜索XML文档的实用程序。 SLT 处理器。 它在Oracle数据库中支持XSLT,允许您把XML文档转换成其他格式。

    3. XML SQL 实用程序。可以使用SQL产生XML文档,使您可以在Oracle数据库表格中轻松地插入基于XML的数据。 XSQL 页。一项可以汇集声明性XML数据然后通过XSLT公布这些数据的技术。 对于PL/SQL开发人员而言,XML分析程序是最重要的组件。通过它,您可以在Oracle数据库中分析、操纵和转换XML文档。ML分析程序由一套APIs(应用程序编程接口)构成。


    XML结构

     


    XML常用分析函数


    XMLParser


    包括分析XML文档所需的数据类型和程序。XML Parsing Process


     

    想知道Oracleparser是如何调用Java来做解析的,请查看Oracle® XMLDeveloper's Kit Programmer's Guide
    10g Release 2 (10.2)

    Part Number B14252-01

    网址: http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14252/adx_j_parser.htm#i1013320

    程序中常用的方法:

    Nodelist := dbms_xslprocessor.selectnodesrootnode, xpath

    dbms_xslprocessor.valueof(节点,节点下的元素,)


    XMLDOM


    包括管理和建立XML文档对象模型(DOM)元素所需的数据类型和程序

    Comparing DOM (Tree-Based) and SAX (Event-Based) APIs

    XMLDOM 这个程序包,其实是通过封装Java 程序来解析XML 的一个PL/SQL的包。具体的作用还是要参考Oracle® Database PL/SQLPackages and Types Reference
    10g Release 2 (10.2)

    Part Number B14258-02

    网址: http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14258/d_xmldom.htm


    实例

    <?xml version="1.0" encoding="UTF-8"?>
    <Dfile Status="3">
    <RecCount>200</RecCount>
    <FailCount>1</FailCount>
     <FailInfo>
      <FItem RecErrCode="2901">
         <Item>
           <Name>名称1</Name>
           <Comment>中国银行</Comment>
         </Item>
         <Item>
           <Name>名称2</Name>
           <Comment>建设银行</Comment>
         </Item>
      </FItem>
     </FailInfo>
     <FailInfo>
      <FItem RecErrCode="2902">
         <Item>
           <Name>名称3</Name>
           <Comment>招商银行</Comment>
         </Item>
         <Item>
           <Name>名称4</Name>
           <Comment>平安银行</Comment>
         </Item>
         <Item>
           <Name>名称5</Name>
           <Comment>工商银行</Comment>
         </Item>
      </FItem>
     </FailInfo>
    


     


    文件的结构



    解析方案


     

    XML DOM的解析过程中, 如果想找某个节点(Fitem)的属性(RecErrCode),而该节点又不是根节点时,需要从最小的节点往上找父节点,一直到节点Fitem,然后在得到其属性。如果节点是根节点,则可以直接得到根节点的元素和属性的值。

    根据上图所示,我们要找根节点Dfile的元素和属性的值,直接调用


    Oracle通过调用API xmldomdbms_xmlparser来做XML文件的解析。


    . 建立一个Directory ,假如在EBS上实现则需要在EBS DB的服务器上建立路径 如:


      CreateOr Replace Directory FTP_XXX As '/var/tmp/ftp' 直接在APPS下就可以新建


    要查找当前建立的Directory 可以使用 Select * From all_directories 查找当前系统中的所有的 Directory .

    DECLARE
      p_max_size NUMBER := dbms_lob.lobmaxsize;
      src_offset NUMBER := 1;
      dst_offset NUMBER := 1;
      lang_ctx   NUMBER := nls_charset_id('UTF8');
      default_csid CONSTANT INTEGER := nls_charset_id('ZHS16GBK');
      warning         NUMBER;
      l_file_number   PLS_INTEGER := 0;
      l_count         NUMBER;
      l_bfile         BFILE;
      l_clob          CLOB;
      l_commitelement xmldom.domelement;
      l_parser        dbms_xmlparser.parser;
      l_doc           dbms_xmldom.domdocument;
      l_nl            dbms_xmldom.domnodelist;
      l_n             dbms_xmldom.domnode;
      rootnode        dbms_xmldom.domnode;
      parent_rootnode dbms_xmldom.domnode;
      file_length     NUMBER;
      block_size      BINARY_INTEGER;
      l_rootnode_name VARCHAR2(200);
      l_status        VARCHAR2(1000);
      l_recerrcode    VARCHAR2(1000);
      l_failcount     VARCHAR2(200);
      l_reccount      VARCHAR2(200);
      l_name          VARCHAR2(1000);
      l_comments      VARCHAR2(2000);
      l_exists        BOOLEAN;
    
      FUNCTION convertclobtoxmlelement(p_document IN CLOB)
        RETURN xmldom.domelement IS
        x_commitelement xmldom.domelement;
        l_parser        xmlparser.parser;
      BEGIN
        l_parser := xmlparser.newparser;
        xmlparser.parseclob(l_parser, p_document);
        x_commitelement := xmldom.getdocumentelement(xmlparser.getdocument(l_parser));
        RETURN x_commitelement;
      END convertclobtoxmlelement;
    BEGIN
      -- 检查XML是否在路径FTP_XXX下是否存在
      utl_file.fgetattr('FTP_XXX',
                        'simanhe_test.xml',
                        l_exists,
                        file_length,
                        block_size);
    
      IF NOT l_exists THEN
        dbms_output.put_line('XML文件不存在');
        RETURN;
      END IF;
    
      l_bfile := bfilename('FTP_XXX', 'simanhe_test.xml');
      -- 创建一个Clob
      dbms_lob.createtemporary(l_clob, TRUE);
      dbms_lob.open(l_bfile, dbms_lob.lob_readonly);
      -- 将XML文件上载并转换为Clob类型
      dbms_lob.loadclobfromfile(l_clob,
                                l_bfile,
                                p_max_size,
                                dst_offset,
                                src_offset,
                                default_csid, -- UTF8
                                lang_ctx, -- GBK
                                warning);
      l_file_number := dbms_lob.fileexists(l_bfile);
      IF l_file_number = 0 THEN
        dbms_output.put_line('XML文件未被转换成功');
        RETURN;
      END IF;
      dbms_lob.close(l_bfile);
      -- Create a parser.
      l_parser := dbms_xmlparser.newparser;
      BEGIN
        -- Parse the document and create a new DOM document.
        dbms_xmlparser.parseclob(l_parser, l_clob);
      EXCEPTION
        WHEN OTHERS THEN
          dbms_output.put_line('XML文件不完整');
          RETURN;
      END;
      l_doc := dbms_xmlparser.getdocument(l_parser);
      -- Free resources associated with the CLOB and Parser now they are no longer needed.
      dbms_lob.freetemporary(l_clob);
      -- 得到根节点 
      rootnode        := xmldom.makenode(xmldom.getdocumentelement(xmlparser.getdocument(l_parser)));
      l_rootnode_name := xmldom.getnodename(rootnode);
      dbms_output.put_line('XML文件当前的节点名称为 ' || l_rootnode_name);
      -- 得到根节点元素的值
      dbms_xslprocessor.valueof(rootnode, 'RecCount/text()', l_reccount);
      dbms_xslprocessor.valueof(rootnode, 'FailCount/text()', l_failcount);
      dbms_output.put_line('XML文件当前的节点名称为 ' || l_rootnode_name ||
                           '的要素RecCount,FailCount值为' || l_reccount || ',' ||
                           l_failcount);
      -- 得到根节点Dfile的属性Status的值
      l_status := xmldom.getattribute(xmldom.makeelement(rootnode), 'Status');
      dbms_output.put_line('XML文件当前的节点名称为 ' || l_rootnode_name ||
                           '的属性Status的值为' || l_status);
    
      /*取节点Item下各元素的值,先将Items节点全部存放在 l_nl中 */
      l_nl    := dbms_xmldom.getelementsbytagname(l_doc, 'Item');
      l_count := dbms_xmldom.getlength(l_nl);
      FOR cur_emp IN 0 .. dbms_xmldom.getlength(l_nl) - 1 LOOP
        l_n := dbms_xmldom.item(l_nl, cur_emp);
        -- 得到节点Item下元素的值
        dbms_xslprocessor.valueof(l_n, 'Name/text()', l_name);
        dbms_xslprocessor.valueof(l_n, 'Comment/text()', l_comments);
        -- 得到节点Item的父节点FItem
        parent_rootnode := dbms_xmldom.getparentnode(l_n);
        l_rootnode_name := xmldom.getnodename(parent_rootnode);
        -- 得到节点FItem的属性RecErrCode的值
        l_recerrcode := xmldom.getattribute(xmldom.makeelement(parent_rootnode),
                                            'RecErrCode');
      
        dbms_output.put_line('Name :' || l_name || ' ,Comment = ' ||
                             l_comments || ' ,RecErrCode = ' || l_recerrcode);
      
      END LOOP;
      -- 释放分析函数的资源
      dbms_xmlparser.freeparser(l_parser);
      -- 将DOC清空,释放资源
      dbms_xmldom.freedocument(l_doc);
      /*  utl_file.frename('FTP_XXX',
      'simanhe_test.xml',
      'FTP_XXX',
      'D_simanhe_test.xml',
      FALSE);*/ -- XML文件解析完成后重命名
      /*utl_file.fremove('FTP_XXX', 'simanhe_test.xml'); */ -- -- XML文件解析完成后删除文件
    EXCEPTION
      WHEN OTHERS THEN
        dbms_lob.freetemporary(l_clob);
        dbms_xmlparser.freeparser(l_parser);
        dbms_xmldom.freedocument(l_doc);
    END;
    


     

     

    展开全文
  • Java解析XML文件

    万次阅读 多人点赞 2017-12-27 09:47:29
    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
  • C++解析XML文件

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


    最近在使用C++处理GF-3和RADARSAT-2雷达影像,需要通过解析XML文件获取影像时间,我选用了TinyXML库来解析。参考了网上的一些教程,这个文档个人觉得是解释的很清晰的。(https://www.cnblogs.com/hgwang/p/5833638.html),第一次使用记录一下学习过程,供以后参考。

    TinyXML安装下载

    进入官网下载,解压缩,将其中的tinystr.h、tinystr.cpp、tinyxml.h、tinyxml.cpp、tinyxmlerror.cpp、tinyxmlparser.cpp 6个文件放在你的项目目录下,就是你自己写的.h和.cpp文件所在的目录。

    解析XML文件

    先看一下XML文件内容。下面这个是RADARSAT-2影像的product.xml文件
    在这里插入图片描述
    在XML文档中,每个<></>标签都是一个节点或元素。解析时需要逐层搜索(好像是不能全文检索),直到找到我们要的那个标签。同一层中,可以根据元素名使用IterateChildren方法来查找匹配的节点。

    我的需求是获取rawDataStartTime节点中的时间。直接上代码。

    #include"tinyxml.h"
    #include"tinystr.h"
    
    
    	TiXmlDocument doc;
    	//加载文档
    	if (!doc.LoadFile(xml_file))
    	{
    		std::cerr << doc.ErrorDesc() << std::endl;
    		exit(1);
    	}
    	//获取根节点,也是xml文档的声明部分
    	TiXmlElement* root = doc.FirstChildElement();
    	if (root == NULL)
    	{
    		std::cerr << "Failed to load file: No root element." << std::endl;
    		doc.Clear();
    		exit(1);
    	}
    	std::string xml_time;
    	TiXmlNode *source_node = NULL;
    	//查找sourceAttributes节点
    	source_node = root->IterateChildren("sourceAttributes", source_node);
    
    	TiXmlElement *source_elem = NULL;
    	source_elem = source_node->ToElement();
    
    	TiXmlNode *rawdata_node = NULL;
    	//查找rawDataStarTime节点
    	rawdata_node = source_elem->IterateChildren("rawDataStartTime", rawdata_node);
    	//获取该节点的文本信息。
    	xml_time = rawdata_node->ToElement()->GetText();
    	return xml_time;
    
    展开全文
  • Java解析XML文件的方式

    千次阅读 2020-01-30 18:36:06
    在项目里,我们往往会把一些配置信息放到xml文件里,或者各部门间会通过xml文件来交换业务数据,所以有时候我们会遇到“解析xml文件”的需求。一般来讲,有基于DOM树和SAX的两种解析xml文件的方式,在这部分里,将...

        在项目里,我们往往会把一些配置信息放到xml文件里,或者各部门间会通过xml文件来交换业务数据,所以有时候我们会遇到“解析xml文件”的需求。一般来讲,有基于DOM树和SAX的两种解析xml文件的方式,在这部分里,将分别给大家演示通过这两种方式解析xml文件的一般步骤。

    1 XML的文件格式

        XML是可扩展标记语言(Extensible Markup Language)的缩写,在其中,开始标签和结束标签必须配套地出现,我们来看下book.xml这个例子。   

    1	<?xml version="1.0" encoding="UTF-8" standalone="no"?>
    2	<books>
    3	    <book id="01">
    4	        <name>Java</name>
    5	        <price>15</price>
    6	        <memo>good book</memo>
    7	    </book>
    8	    <book id="02">
    9	       <name>FrameWork</name>
    10	       <price>20</price>
    11	       <memo>new book</memo>
    12	    </book>
    13	</books>
    

        整个xml文件是一个文档(document),其中第1行表示文件头,在第2和第13行里,我们能看到配套出现的books标签,从标签头到标签尾的部分那我们称之为元素(element)。

        所以我们可以这样说,在books元素里,我们分别于第3到第7行和第8到第12行定义了2个book元素,在每个book元素,比如从第4到第6行,又包含着3个元素,比如第一本书的name元素是<name>Java</name>,它的name元素值是Java。

        在第3行里,我们还能看到元素里的属性(attribute),比如这个book元素具有id这个属性,具体id的属性值是01。

    2 基于DOM树的解析方式

        DOM是Document Object Model(文档对象模型)的缩写,在基于DOM树的解析方式里,解析代码会先把xml文档读到内存里,并整理成DOM树的形式,随后再读取。根据之前部分里给出的book.xml文档,我们可以绘制出如下形式的DOM树。

        

     

         其中,books属于根(root)结点,也叫根元素,由于它包含着两个book元素,所以第二层是两个book结点,每个book元素包含着3个元素,所以第三层是6个元素。在下面的ParserXmlByDom.java的代码里,我们来看下通过DOM树方式解析book.xml文档的详细步骤。

    1	//省略import相关类库的代码
    2	public class ParserXmlByDom {
    3		public static void main(String[] args) {
    4	        //创建DOM工厂
    5			DocumentBuilderFactory domFactory=DocumentBuilderFactory.newInstance();
    6			InputStream input = null;
    7	        try {
    8	            //通过DOM工厂获得DOM解析器
    9	            DocumentBuilder domBuilder=domFactory.newDocumentBuilder();
    10	            //把XML文档转化为输入流
    11	            input=new FileInputStream("src/book.xml");            
    12	            //解析XML文档的输入流,得到一个Document
    13	            Document doc=domBuilder.parse(input);
    

        从第5行到第13行,我们完成了用DOM树解析XML文件的准备工作,具体包括,在第5行里创建了DOM工厂,在第9行通过DOM工厂创建了解析xml文件DocumentBuilder类型对象,在第11行把待解析的xml文件放入到一个InputStream类型的对象里,在第13行通过parse方法把xml文档解析成一个基于DOM树结构的Document类型对象。    

    14	            //得到XML文档的根节点,只有根节点是Element类型
    15	            Element root=doc.getDocumentElement();
    16	            // 得到子节点
    17	            NodeList books = root.getChildNodes();
    

        整个XML文件包含在第13行定义的doc对象里,在第15行里,我们通过getDocumentElement方法得到了根节点(也就是books节点),在第17行,通过getChildNoes方法得到该books节点下的所有子节点,随后开始解析整个xml文档。

        需要说明的是,在解析前,我们会通过观察xml文档来了解其中的元素名和属性名,所以在后继的代码里,我们会针对元素名和属性名进行编程。    

    18	            if(books!=null){
    19	                for(int i=0;i<books.getLength();i++){
    20	                    Node book=books.item(i);
    21	                    //获取id属性                      
    22	                    if(book.getNodeType()==Node.ELEMENT_NODE){
    23	                        String id=book.getAttributes().getNamedItem("id").getNodeValue();
    24	                        System.out.println("id is:" + id);
    25	                        //遍历book下的子节点
    26	                        for(Node node=book.getFirstChild(); node!=null;node=node.getNextSibling()){
    27	if(node.getNodeType()==Node.ELEMENT_NODE){
    28	    //依次读取book里的name,price和memo三个子元素
    29	    if(node.getNodeName().equals("name")){
    30	        String name=node.getFirstChild().getNodeValue();
    31	        System.out.println("name is:" + name);                                    
    32	    }
    33	    if(node.getNodeName().equals("price")){
    34	        String price=node.getFirstChild().getNodeValue();
    35	        System.out.println("price is:" + price);
    36	    }
    37	    if(node.getNodeName().equals("memo")){
    38	          String memo=node.getFirstChild().getNodeValue();
    39	          System.out.println("memo is:" + memo);
    40	     }
    41	   }
    42	 }
    43	}
    44	}
    45	}
    

        第19行的for循环里,我们是遍历book元素通过观察xml文件,我们发现book元素出现了2次,所有这个循环会运行两次,而且,book元素有1个id属性,所有我们需要通过第23行的代码,得到id属性的值。

        在文档里,book元素有3个子节点,分别是name,price和memo,所以在代码的26行里,再次使用for循环遍历其中的子节点。在遍历时,我们通过29到32行的代码获取到了book元素里name的值,通过类似的代码后继的33到40行代码里得到了price和memo这两个元素的值。    

    46	        } catch (ParserConfigurationException e) {
    47	            e.printStackTrace();
    48	        } catch (FileNotFoundException e) {
    49	            e.printStackTrace();
    50	        } catch (IOException e) {
    51	            e.printStackTrace();
    52	        } catch (SAXException e) {			
    53				e.printStackTrace();
    54			} catch (Exception e) {			
    55				e.printStackTrace();
    56			}
    57	        //在finally里关闭io流 
    58	        finally{
    59	        	try {
    60					input.close();
    61				} catch (IOException e) {
    62					e.printStackTrace();
    63				}
    64	        }
    65		}
    66	}
    

        同样地,在解析完成后,在finally从句里,我们关闭了之前用到的IO流(input对象)。

    3 基于事件的解析方式

        SAX是Simple API for XML的缩写,不同于DOM的文档驱动,它是事件驱动的,也就是说,它是一种基于回调(callback)函数的解析方式,比如开始解析xml文档时,会调用我们自己定义的startDocument函数,从下表里,我们能看到基于SAX方式里的各种回调函数以及它们被调用的时间点。

    函数名

    调用时间点

    startDocument

    开始解析xml文档时(解析xml文档第一个字符时)会被调用

    endDocument

    当解析完xml文档时(解析到xml文档最后一个字符时)会被调用

    startElement

    当解析到开始标签时会被调用,比如在解析“<name>FrameWork</name>”这个element时,当读到开始标签“<name>”时,会被调用

    endElement

    当解析到结束标签时会被调用,比如在解析“<name>FrameWork</name>”这个element时,当读到结束标签“</name>”时,会被调用

    characters

    1行开始后,遇到开始或结束标签之前存在字符,则会调用

    2两个标签之间,存在字符,则会调用,比如在解析“<name>FrameWork</name>”时,发现存在FrameWork,则会被调用

    3标签和行结束符之前存在字符,则会调用

        从上表里我们能看到characters方法会在多个场合被回调,但我们最期望的调用场景是第2种,这就要求我们最好在解析xml文档前整理下它的格式,尽量避免第1和第3种情况。在ParserXmlBySAX.java这个案例中,我们通过了编写上述的回调函数,实现了SAX方式解析xml文档的功能。    

    1	//省略import的代码
    2	//基于SAX的解析代码需要继承DefaultHandler类
    3	public class ParserXmlBySAX extends DefaultHandler{
    4		// 记录当前解析到的节点名
    5		private String tagName; 
    6		//主方法
    7		public static void main(String[] argv) {
    8			String uri = "src/book.xml";
    9			try {
    10				SAXParserFactory parserFactory = SAXParserFactory.newInstance();
    11				ParserXmlBySAX myParser = new ParserXmlBySAX();
    12				SAXParser parser = parserFactory.newSAXParser();
    13				parser.parse(uri, myParser);
    14			} catch (IOException ex) {
    15				ex.printStackTrace();
    16			} catch (SAXException ex) {
    17				ex.printStackTrace();
    18			} catch (ParserConfigurationException ex) {
    19				ex.printStackTrace();
    20			} catch (FactoryConfigurationError ex) {
    21				ex.printStackTrace();
    22			}		
    23		}
    

        在main方法的第8行里,我们指定了待解析xml文档的路径和文件名,在第10行里,我们创建了SAXParserFactory这个类型的SAX解析工厂对象。在第12行,我们通过SAX解析工厂对象,创建了SAXParser这个类型的解析类。在第13行,通过了parse方法启动了解析。

        在上文里我们就已经知道,在SAX的方式里,是通过调用各种回调函数来完成解析的,所以在代码里,我们还得自定义各个回调函数,代码如下。    

    // 处理到文档结尾时,直接输出,不做任何动作
    25		public void endDocument() throws SAXException {
    26			System.out.println("endDocument");
    27		}
    28		// 处理到结束标签时,把记录当前标签名的tagName设置成null
    29		public void endElement(String uri, String localName, String qName) throws SAXException {
    30			tagName = null;
    31		}
    32		// 开始处理文档时,直接输出,不做任何动作
    33		public void startDocument() throws SAXException {
    34			System.out.println("startDocument");		
    35		}
    36		// 处理开始标签
    37		public void startElement(String uri, String localName, String name,Attributes attributes) throws SAXException {	
    38			if ("book".equals(name)) { //解析book标签的属性 
    39	            for (int i = 0; i < attributes.getLength(); i++) {
    40	                System.out.println("attribute name is:" + attributes.getLocalName(i)  + "  attribute value:" + attributes.getValue(i)); 
    41	            }            
    42	        }
    43	        //把当前标签的名字记录到tagName这个变量里  
    44			tagName = name; 
    45		}
    46	    //通过这个方法解析book的三个子元素的值
    47		public void characters(char[] ch, int start, int length)  
    48	            throws SAXException {  
    49	        if(this.tagName!=null){  
    50	            String val=new String(ch,start,length);            
    51	            //如果是name,price或memo,则输出它们的值
    52	            if("name".equals(tagName))
    53	            { System.out.println("name is:" + val);  }
    54	            if("price".equals(tagName))
    55	            { System.out.println("price is:" + val); }
    56	            if("memo".equals(tagName))
    57	            { System.out.println("memo is:" + val);  }
    58	        }  
    59	    }
    60	}
    

        我们用tagName来保存当前的标签名,是为了解析book元素的name,price和memo这三个子元素。

        <name>FrameWork</name>

        比如当解析到name这个开始标签时,在第44行里,startElement会把tagname值设置成name,当解析到FramWork时,由于它包含在两个标签之间,所以会被触发第47行的characters方法,在其中的第52行的if判断里,由于得知当前的标签名是name,所以会输出FrameWork这个name元素的值,当解析到</name>这个结束标签时,会触发第29行的endElement方法,在其中的30行里,会把tagName值清空。

        这段代码的输出结果如下,其中第1行和第10行分别是在开始解析和完成解析时输出的。

        第2行针对id属性的输出是在startElement方法的第40行里被打印的,第3到第5行针对3个book子元素的输出是在characters方法里被打印的。

        第2到第5行是针对第一个book元素的输出,而第6到第9行是针对第2个book。    

    1	startDocument
    2	attribute name is:id  attribute value:01
    3	name is:Java
    4	price is:15
    5	memo is:good book
    6	attribute name is:id  attribute value:02
    7	name is:FrameWork
    8	price is:20
    9	memo is:new book
    10	endDocument
    

    4 DOM和SAX两种解析方式的应用场景

        在基于DOM的方式里,由于我们会把整个xml文档以DOM树的方式装载到内存里,所以可以边解析边修改,而且还能再次解析已经被解析过的内容。

        而在SAX的方式里,由于我们是以基于回调函数的方式来解析,所以并不需要把整个文档载入到内存,这样能节省内存资源。

        所以说,选择 DOM 还是 SAX,这取决于如下三个个因素。

        第一,如果我们在解析时还打算更新xml里的数据,那么建议使用DOM方式。

        第二,如果待解析的文件过大,把它全部装载到内存时可能会影响到内存性能,那么建议使用SAX的方式。

        第三,如果我们对解析的速度有一定的要求,那么建议使用SAX方式,因为它比DOM方式要快些。

    展开全文
  • python解析xml文件(解析、更新、写入)

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

    千次阅读 2017-11-09 20:26:34
    dom4j解析xml文件、之前用下面的方法,90M的xml,500万行,解析完插入数据库,单线程,不到1小时搞定。
  • 在使用python中的xml.etree.ElementTree库解析xml文件时,默认不会做任何的换行和缩进处理,所有节点堆积在同一行,导致输出的xml文件阅读起来很不方便。本文通过增加换行和缩进来美化xml文件。
  • 在使用python中的xml.etree.ElementTree库解析xml文件时,节点的属性默认会被重新排序。虽然xml文件节点属性顺序并没有什么实际意义,但有时在文件的可读性上会大打折扣。本文介绍如何通过修改ElementTree.py源码...
  • Java进阶(二十七)使用Dom4j解析XML文件

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

    千次阅读 2018-09-19 11:35:35
    最近有个问题需要解析xml文件,以前没接触过,完成后发现原来解析xml很简单,但还是记录一下相关概念与解析过程,日后查看方便查找。 country_data.xml文件如下所示,找的是一个大家常用的demo,貌似是官网公布的...
  • 转载https://blog.csdn.net/chenfengdejuanlian/article/details/47060413在网络存储过程中有很多时候会遇到XML文件解析和使用XML保存一些信息,解析XML文件用的比较多的方法是pull解析和SAX解析,但是我一般只用...
  • GDataXMLNode解析xml文件的使用

    千次阅读 2016-11-15 17:42:17
    GDataXMLNode解析xml文件的使用、GDataXMLNode、IOS解析xml文件解析xml文件
  • java中采用dom4j解析xml文件

    万次阅读 2019-05-22 11:18:55
    在最近的开发中用到了dom4j来解析xml文件,以前听说过来解析xml文件的几种标准方式;但是从来的没有应用过来,所以可以在google中搜索dmo4j解析xml文件的方式,学习一下dom4j解析xml的具体操作。 二.代码详情 ...
  • 解析XML文件(SAX方式解析XML)

    千次阅读 2011-10-10 09:44:20
    解析XML文件(SAX方式解析XML) 对XML文件解析有四种方法:DOM、SAX、JDOM、DOM4J 现着重讲一下SAX解析XML文件。 1、通过一定的方式获取文件名 // 获得文件路径 String xmlFilePath = TIcanServiceAccess
  • 使用SAX或者DOM或者pull解析XML文件 在Android平台上可以使用Simple API for XML(SAX) 、 Document Object Model(DOM)和Android附带的pull解析器解析XML文件。 下面是本例子要解析的XML文件: 文件名称:...
  • tinyxml2之解析xml文件

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

    千次阅读 2016-08-06 16:27:34
    首先写了一个xml文件 c# 张三 1990 60 ...Dom解析xml文件 package com.edu.xynu; import java.io.IOException; import javax.xml.parsers.DocumentBuilder; import javax.xml.par
  • C++ 使用 TinyXml 解析 XML 文件

    千次阅读 2017-12-02 19:00:01
    这个解析库的模型通过解析XML文件,然后在内存中生成DOM模型,从而让我们很方便的遍历这棵XML树。 DOM模型即文档对象模型,是将整个文档分成多个元素(如书、章、节、段等),并利用树型结构表示这些元素之间的顺序...
  • JS解析XML文件和XML字符串

    万次阅读 2018-07-17 15:38:16
    JS解析XML文件 &lt; script type = ' text/javascript ' &gt; loadXML = fu
  • boost解析xml文件

    千次阅读 2016-04-09 17:31:42
    前面我们介绍了xml文件,今天我们试着用boost库来解析xml文件。我们将举两个例子来说明怎么使用。来自boost官方的例子先看xml文件的内容: <filename>debug.log <module>Finance <module>Admin</module>
  • 读取和设置xml配置文件是最常用的操作,试用了几个C++的XML解析器,个人感觉TinyXML是使用起来最舒服的,因为它...这个解析库的模型通过解析XML文件,然后在内存中生成DOM模型,从而让我们很方便的遍历这棵XML树。 ...
  • Java使用SAX解析xml文件详解

    千次阅读 2019-04-27 22:16:20
    xml文件 ...SAX方法是一种流解析的方法,它是以顺序的方式从头至尾的解析xml文件,过一遍之后就结束了,所以应该注意在解析的过程中不断的存储数据。 我们要解析的xml文件内容为: <?xml version="1...
  • c# XElement解析xml文件

    千次阅读 2018-04-15 00:42:22
    再说下工作安排:领导想将每天的采集到的网络拓扑连接信息(即网元A的某端口,有一条连纤,连接至网元B的某端口)保存在数据库里,即解析xml文件并导入数据库。 每天采集到的网络拓扑连接信息xml文件,即...
  • 如果我们要在Java桌面、J2ME等当中使用Pull方式生成xml文件和解析xml文件,需要用到kxml2; KXML解析器是基于普通XML PULL解析器的一个小巧的解析器,官网是http://kxml.org/ 普通XML PULL解析器的官网是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,366
精华内容 15,346
关键字:

解析xml文件