精华内容
下载资源
问答
  • 1、java代码: 主要采用dom来进行操作 代码如下: package test; import java.io.IOException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml....
  • java读取xml文件

    2018-03-15 14:59:22
    文档中有代码案例,详细讲解了使用java读取xml,并附带有关于xml的dtd讲解,里面包含详细的文档和代码案例。和读取xml所需的jar。
  • 使用java解析XML文件解析完之后将解析结果导入mysql数据库
  • Java SAX解析Xml文档Demo

    2017-08-18 14:12:00
    Java SAX解析Xml Demo(详细注释)
  • java xml文件解析

    2019-07-21 12:34:44
    java xml文件DOM、SAX、DOM4j四种解析方式与性能对比。
  • Java中四种XML解析技术详解.
  • java实现xml解析word文档代码实现,通过解析word书签实现java动态写入word文档。方便使用。
  • NULL 博文链接:https://suky.iteye.com/blog/621169
  • java解析xml文件生成json对象,方便操作,下载后导入eclipse,加入相关的jar包后加载至类路径便可测试该工具类,很好用!!!
  • 主要介绍了java实现简单解析XML文件功能,结合实例形式分析了java针对xml文件的读取、遍历节点及输出等相关操作技巧,需要的朋友可以参考下
  • 本篇文章主要介绍了java中利用Dom4j解析和生成XML文档,dom4j是一套非常优秀的Java开源api,主要用于读写xml文档,具有性能优异、功能强大、和非常方便使用的特点。有兴趣的可以了解一下。
  • 用WC3的DOM实现对XML文件的读取。 方法摘要: //通过文件路径及文件名读取xml public XMLReader(String path, String filename); //初始化读取包下的的XML文件 public XMLReader(Package package1, String fileName)...
  • 此资源是利用DOM,SAX,JDOM,DOM4J解析XML文件的完整项目。
  • 支持把需要的pdf图片文件解析xml串输出。请严格根据里面提供的maven依赖以及com.itextpdf该目录层级名称进行测试
  • 采用DOM与DOM4j两种方式针对XML文档进行增、删、改查的操作,转换方式在Test测试类实现另一个管理类就可以了!
  • 主要介绍了java读取解析xml文件实例,本文创建了一个XML解析类同时讲解了循环节点输出方式,需要的朋友可以参考下
  • DOM将整个XML文件加载到...应用程序可以通过遍历节点树的方式来解析XML文件中的各个节点、属性等信息;这种方式便于对XML节点的添加修改等,而且解析也很方便,然后它比较耗费内存,解析速度也不快,下面看使用示例吧
  • 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


    展开全文
  • 主要介绍了Java web xml文件读取解析方式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java解析调用webservice服务的返回XML串详解的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • XML交互时方便进行XML格式转换,包含XML格式数据转换成list对象方法,参数拼接成XML方法
  • 主要介绍了Java生成和解析XML格式文件和字符串的实例代码,需要的朋友可以参考下
  • JavaXML文件解析

    千次阅读 2018-08-12 22:18:27
    今天主要讲解的是对XML文件解析 二、对XML文件的介绍    在百度百科定义为可扩展标记语言,标准通用标记语言的子集,是一种用于标记电子文件使其具有结构性的标记语言。它的文件结构包括了节点、元素、...

    一、前言

    HTTP网络传输中的数据组织方式有三种方式:

    (1)HTML方式 (2)XML方式  (3)JSON方式

    今天主要讲解的是对XML文件的解析

    二、对XML文件的介绍

     

             在百度百科中定义为可扩展标记语言,标准通用标记语言的子集,是一种用于标记电子文件使其具有结构性的标记语言。它的文件结构中包括了节点、元素、属性和属性值,其语法规则为(1)开始和结束标签匹配  (2)嵌套标签不能互相嵌套 (3) 区分大小写。

    三、解析XML数据的方式

    1、DOM(org.w3c.dom)
    “文档对象模型”方式,解析完的Xml将生成一个树状结构的对象。
    2、SAX(org.xml.sax)
    以事件的形式通知程序,对Xml进行解析。

    3、XMLPULL(org.xmlpull.v1)
    程序以“拉取”的方式对Xml进行解析。

    四、实例分析(以DOM方式解析XML文件为例)

            这次要实现的使用java编写以DOM方式解析本地某目录下的特定XML文件。                   

                 

                             图一 Java工程目录                                                                             图二 XML文件的内容

    (1)首先需要新建一个用于存储xml文件中各节点的属性和属性值的类

    public class Book {
    
    	private int id;
    	private String name;
    	private float price;
    	
    	public Book() {
    		// TODO Auto-generated constructor stub
    	}
    
    	@Override
    	public String toString() {
    		return "Book [id=" + id + ", name=" + name + ", price=" + price + "]";
    	}
    
    	public int getId() {
    		return id;
    	}
    
    	public void setId(int id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public float getPrice() {
    		return price;
    	}
    
    	public void setPrice(float price) {
    		this.price = price;
    	}
    
    }
    

    (2)紧接着就是创建一个使用DOM方式解析的工具类

    public class DomService {
    
    	public DomService() {
    		// TODO Auto-generated constructor stub
    	}
        public static List<Book> getBooks(InputStream inputStream) throws Exception{
        	List<Book> list = new ArrayList<Book>();
        	
        	//创建一个document解析工厂
        	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            //实例化一个DocumentBuilder对象
        	DocumentBuilder builder = factory.newDocumentBuilder();
            //使用DocumentBuilder对象获取一个Document的对象
        	Document document = builder.parse(inputStream);
        	Element element = document.getDocumentElement();  //获得元素节点
        	NodeList nodeList = element.getElementsByTagName("book"); //获取book节点
            for(int i=0; i<nodeList.getLength(); i++){
            	Element bookElement = (Element) nodeList.item(i);
            	Book book = new Book();  //实例化 Book 对象      	
                    book.setId(Integer.parseInt(bookElement.getAttribute("id")));
            	NodeList childNodes = bookElement.getChildNodes();
            	for(int j=0; j<childNodes.getLength(); j++){
            		if(childNodes.item(j).getNodeType() == Node.ELEMENT_NODE){
            			if("name".equals(childNodes.item(j).getNodeName())){
            				    book.setName(childNodes.item(j).getFirstChild().getNodeValue());	
            			}else if("price".equals(childNodes.item(j).getNodeName())){
            				book.setPrice(Float.parseFloat(childNodes.item(j).getFirstChild().getNodeValue()));
            			}
            		}
            	}
            	list.add(book);
            }
        	return list;
        }
        //xml文件的路径
    	private static String FilePath = "E:/JavaCode/javaCode/android_dom_xml/book.xml";
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		try {
    			File file = new File(FilePath);
    			InputStream inputStream = new FileInputStream(file);
    			List<Book> list = getBooks(inputStream);
    			for(Book book:list){
    				System.out.println(book.toString());
    			}
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    
    }

    这个使用DOM方式解析XML文件的源码下载链接:https://download.csdn.net/download/nxc_boy/10599443

    展开全文
  • java 解析xml 多级

    2013-08-07 09:09:13
    企业级应用 java 解析多级xml 多么复杂的都可以, 一个类,一个jar 包,非常实用,希望大家顶起..
  • 今天小编就为大家分享一篇java 解析由String类型拼接的XML文件方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Java解析XML.zip

    2020-02-02 18:25:53
    压缩包内包含jaxen-1.1.1.jar和dom4j-1.6.1.jar两个jar包文件。这两个文件用于Java解析XML文件。涵盖了Java解析XML文件的主要类
  • java xml解析Java XML parser is used to work with xml data. XML is widely used technology to transport or store data. That’s why there are many java xml parsers available. Java XML解析器用于处理xml...

    java xml解析器

    Java XML parser is used to work with xml data. XML is widely used technology to transport or store data. That’s why there are many java xml parsers available.

    Java XML解析器用于处理xml数据。 XML是广泛用于传输或存储数据的技术。 这就是为什么有许多可用的Java xml解析器的原因。

    Java XML解析器 (Java XML Parser)

    java xml parser

    Some of the commonly used java xml parsers are;


    一些常用的java xml解析器是:

    1. DOM Parser

      DOM解析器
    2. SAX Parser

      SAX解析器
    3. StAX Parser

      StAX解析器
    4. JAXB

      杰克斯

    There are some other APIs also available for XML parsing in java, for example JDOM and JiBX.

    还有一些其他API可用于Java中的XML解析,例如JDOMJiBX

    This java xml parser tutorial is aimed to explore different kinds of XML processing API’s and to learn some common tasks we need to perform with XML such as read, write and edit.

    该java xml解析器教程旨在探索各种XML处理API,并学习我们需要使用XML执行的一些常见任务,例如读取,写入和编辑。

    Java XML分析器– DOM (Java XML Parser – DOM)

    DOM Parser is the easiest java xml parser to learn. DOM parser loads the XML file into memory and we can traverse it node by node to parse the XML. DOM Parser is good for small files but when file size increases it performs slow and consumes more memory.

    DOM解析器是最容易学习的Java xml解析器。 DOM解析器将XML文件加载到内存中,我们可以逐节点遍历该文件以解析XML。 DOM解析器非常适合小型文件,但是当文件大小增加时,它的执行速度会变慢,并占用更多内存。

    1. Read XML File
      This article shows how to use DOM Parser to parse XML file to Object.

      读取XML文件
      本文介绍如何使用DOM解析器将XML文件解析为对象。
    2. Write XML File
      This article explains how to use DOM Parser to write Object data to XML file.

      写入XML档案
      本文介绍了如何使用DOM分析器将对象数据写入XML文件。
    3. Edit XML File
      DOM Parser can be used to edit XML data also. This article shows how to add elements, remove elements, edit element values, edit attributes in an XML document using DOM Parser.

      编辑XML档案
      DOM分析器还可用于编辑XML数据。 本文介绍了如何使用DOM分析器在XML文档中添加元素,删除元素,编辑元素值以及编辑属性。

    Java XML分析器– SAX (Java XML Parser – SAX)

    Java SAX Parser provides API to parse XML documents. SAX Parsers are different than DOM parser because it doesn’t load complete XML into memory and read xml document sequentially. It’s an event based parser and we need to implement our Handler class with callback methods to parse XML file. It’s more efficient than DOM Parser for large XML files in terms of time and memory usage.

    Java SAX Parser提供了用于解析XML文档的API。 SAX解析器与DOM解析器不同,因为它不会将完整的XML加载到内存中并不会顺序读取xml文档。 这是一个基于事件的解析器,我们需要使用回调方法实现Handler类以解析XML文件。 就时间和内存使用而言,对于大型XML文件,此方法比DOM分析器更有效。

    1. Read XML File
      Learn how to create our Callback Handler class to read XML file to list of Objects using SAX Parser.

      读取XML文件
      了解如何创建我们的回调处理程序类,以使用SAX Parser将XML文件读取到对象列表。

    StAX Java XML解析器 (StAX Java XML Parser)

    Java Streaming API for XML (Java StAX) provides implementation for processing XML in java. StAX consists of two sets of API – cursor based API and iterator based API. I have covered this java xml parser extensively in different posts.

    用于XML的Java Streaming API( Java StAX )提供了用于在Java中处理XML的实现。 StAX由两组API组成- 基于游标的API基于迭代器的API 。 我已经在不同的文章中广泛介绍了此java xml解析器。

    1. Read XML File Using StAX Iterator API
      In this tutorial we will learn how to read XML iteratively using Java StAX (XMLEventReader).

      使用StAX Iterator API读取XML文件
      在本教程中,我们将学习如何使用Java StAX( XMLEventReader )迭代读取XML。
    2. Write XML File Using StAX Iterator API
      In this tutorial we will see how we can write XML file in java using StAX Iterator based API (XMLEventWriter).

      使用StAX Iterator API写入XML文件
      在本教程中,我们将看到如何使用基于StAX Iterator的API( XMLEventWriter )在Java中编写XML文件。
    3. Read XML File Using StAX Cursor API
      This article shows how to use StAX Cursor API (XMLStreamReader) to read XML data to Object.

      使用StAX Cursor API读取XML文件
      本文介绍如何使用StAX Cursor API( XMLStreamReader )将XML数据读取到Object。
    4. Write XML File Using StAX Cursor API
      Java StAX Cursor API is very straight forward in creating XML and outputting it. We need to create XMLStreamWriter object and write data into it. This tutorial explains it in detail with example.

      使用StAX Cursor API编写XML文件
      Java StAX Cursor API在创建XML和输出XML方面非常直接。 我们需要创建XMLStreamWriter对象并将数据写入其中。 本教程将通过示例对其进行详细说明。

    Java XML解析器– JDOM (Java XML Parser – JDOM)

    JDOM provides a great Java XML parser API to read, edit and write XML documents easily. JDOM provides wrapper classes to chose your underlying implementation from SAX Parser, DOM Parser, STAX Event Parser and STAX Stream Parser.
    Benefit of using JDOM is that you can switch from SAX to DOM to STAX Parser easily, you can provide factory methods to let client application chose the implementation.

    JDOM提供了一个出色的Java XML解析器API,可以轻松读取,编辑和写入XML文档。 JDOM提供包装器类,以从SAX分析器,DOM分析器,STAX事件分析器和STAX流分析器中选择基础实现。
    使用JDOM的好处是,您可以轻松地从SAX切换到DOM,再切换到STAX Parser,可以提供工厂方法来让客户端应用程序选择实现。

    1. JDOM Read XML File
      In this tutorial, we will learn how to read XML file to Object using JDOM XML Parser.

      JDOM读取XML文件
      在本教程中,我们将学习如何使用JDOM XML Parser将XML文件读取到Object。
    2. JDOM Write XML File
      In this tutorial we will learn how to write XML file in Java using JDOM. JDOM Document provides methods to easily create elements and attributes. XMLOutputter class can be used to write the Document to any OutputStream or Writer object.

      JDOM写入XML文件
      在本教程中,我们将学习如何使用JDOM用Java编写XML文件。 JDOM Document提供了轻松创建元素和属性的方法。 XMLOutputter类可用于将Document写入任何OutputStreamWriter对象。
    3. JDOM Edit XML File
      JDOM provides very neat way to manipulate XML files, using JDOM is very easy and the code looks clean and readable. In this tutorial we will learn how to add element, remove element, edit element value and edit attribute value.

      JDOM编辑XML文件
      JDOM提供了一种非常整洁的方式来处理XML文件,使用JDOM非常容易,并且代码看起来清晰易读。 在本教程中,我们将学习如何添加元素,删除元素,编辑元素值和编辑属性值。

    Java XML解析器– JAXB (Java XML Parser – JAXB)

    Java Architecture for XML Binding (JAXB) provides API for converting Object to XML and XML to Object easily. JAXB was developed as a separate project but it was used widely and finally became part of JDK in Java 6.

    XML绑定Java体系结构(JAXB)提供了API,可轻松地将Object转换为XML并将XML转换为Object。 JAXB是作为一个单独的项目开发的,但得到了广泛的使用,最终成为Java 6中JDK的一部分。

    1. JAXB Tutorial
      Using JAXB is very easy and it uses annotations. We need to annotate Java Object to provide instructions for XML creation and then we have to create Marshaller to convert Object to XML. Unmarshaller is used to convert XML to java Object. In this tutorial we will learn most widely used JAXB annotations and how to convert a Java Object to XML (Marshalling) and XML to Java Object (Unmarhsalling).

      JAXB教程
      使用JAXB非常容易,并且使用批注。 我们需要注释Java Object以提供XML创建的说明,然后我们必须创建Marshaller将Object转换为XML。 Unmarshaller用于将XML转换为Java Object。 在本教程中,我们将学习使用最广泛的JAXB批注,以及如何将Java对象转换为XML( 编组 )以及如何将XML对象转换为Java对象( Unmarhsalling )。

    Java XML解析器– JiBX (Java XML Parser – JiBX)

    JiBX is a very powerful framework for converting XML data to java object and vice versa. It is very useful in applications integration where XML is the format for data transfer, for example, Web Services and Legacy Systems Integration based on Message Oriented Model (MOM).

    JiBX是一个非常强大的框架,用于将XML数据转换为Java对象,反之亦然。 它在XML是数据传输格式的应用程序集成中非常有用,例如,基于消息定向模型(MOM)的Web服务和旧系统集成。

    1. JiBX Tutorial
      There are many frameworks available for XML transformation such as JAXB and XMLBeans but JiBX differs in the approach for XML binding and transformation process. JiBX performs these tasks via utility classes generated at compile time via ant scripts. This approach reduces the processing time by moving away from the traditional two-step process with other parsers to a single step.

      JiBX教程
      有许多可用于XML转换的框架,例如JAXB和XMLBeans,但是JiBX在XML绑定和转换过程的方法上有所不同。 JiBX通过在编译时通过ant脚本生成的实用程序类来执行这些任务。 这种方法通过将与其他解析器一起使用的传统两步处理转移到一个步骤,从而减少了处理时间。

    XPath (XPath)

    XPath provides syntax to define part of an XML document. XPath Expression is a query language to select part of the XML document based on the query String. Using XPath Expressions, we can find nodes in any xml document satisfying the query string.

    XPath提供了定义XML文档一部分的语法。 XPath Expression是一种查询语言,用于根据查询字符串选择XML文档的一部分。 使用XPath表达式,我们可以在任何xml文档中找到满足查询字符串的节点。

    • XPath Tutorial
      javax.xml.xpath package provides XPath support in Java. To create XPathExpression, XPath API provide factory methods. In this tutorial we will use XPath query language to find out elements satisfying given criteria.

      XPath教程
      javax.xml.xpath包在Java中提供了XPath支持。 为了创建XPathExpression,XPath API提供了工厂方法。 在本教程中,我们将使用XPath查询语言找出满足给定条件的元素。

    杂项Java XML解析器任务 (Miscellaneous Java XML parser tasks)

    1. Generate Sample XML from XSD in Eclipse
      If you work on web services, you must have been using XSD’s and to test the webservice, you need to generate XML from XSD file. Eclipse provide a very easy way to generate XML from XSD.

      在Eclipse中从XSD生成示例XML
      如果您使用Web服务 ,则必须一直在使用XSD,并且要测试Web服务,需要从XSD文件生成XML。 Eclipse提供了一种非常容易的方法来从XSD生成XML。
    2. Validate XML against XSD
      Java XML Validation API can be used to validate XML against an XSD. javax.xml.validation.Validator class is used in this tutorial to validate xml file against xsd file.

      针对XSD验证XML
      Java XML验证API可用于针对XSD验证XML。 本教程中使用javax.xml.validation.Validator类针对xsd文件验证xml文件。
    3. Java XML Property File
      Usually we store configurations parameters for java applications in a property file. In java property file can be a normal property file with key-value pairs or it can be an XML file also.
      In this example, we will learn how to write property XML file and then read properties from XML property files.

      Java XML属性文件
      通常,我们将Java应用程序的配置参数存储在属性文件中。 在java中,属性文件可以是具有键值对的普通属性文件,也可以是XML文件。
      在此示例中,我们将学习如何编写XML属性文件,然后从XML属性文件读取属性。
    4. SOAP XML
      Soap is an Xml based transport protocol. Soap stands for Simple Object Access Protocol. Soap is a lightweight mechanism for exchanging structured and typed information. As it is XML based so it is language and platform independent.
      In this tutorial you will learn about SOAP XML and how can we create it using Liquid XML Studio software.

      SOAP XML
      肥皂是一种基于Xml的传输协议。 肥皂代表简单对象访问协议。 Soap是用于交换结构化和类型化信息的轻量级机制。 由于它基于XML,所以它与语言和平台无关。
      在本教程中,您将学习SOAP XML以及如何使用Liquid XML Studio软件创建它。
    5. Format XML Document
      A utility class with methods for pretty printing XML and converting XML Document to String and String to XML document.

      格式化XML文档
      一个实用程序类,其中包含用于漂亮地打印XML并将XML Document转换为String以及将String转换为XML文档的方法。
    6. Convert Document to String and String to Document
      Sometimes while programming in java, we get String which is actually an XML and to process it, we need to convert it to XML Document (org.w3c.dom.Document). Also for debugging purpose or to send to some other function, we might need to convert Document object to String. Two utility methods to convert String to XML Document and XML Document to String.

      将文档转换为字符串并将字符串转换为文档
      有时在用Java编程时,我们得到的String实际上是XML,并且要对其进行处理,我们需要将其转换为XML Document(org.w3c.dom.Document)。 同样出于调试目的或发送给其他功能,我们可能需要将Document对象转换为String。 将String转换为XML Document和将XML Document转换为String的两种实用方法。

    I will be adding more java XML parser tutorials here as and when I post more, so don’t forget to bookmark it for future use.

    当我发表更多文章时,我将在这里添加更多的Java XML解析器教程,因此请不要忘记将其添加书签以供将来使用。

    翻译自: https://www.journaldev.com/1240/java-xml-parser

    java xml解析器

    展开全文
  • Java解析xml所需jar包

    2018-03-06 19:56:58
    Java解析xml所需jar包
  • 主要介绍了通过Java读取xml文件内容过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 361,837
精华内容 144,734
关键字:

java中xml文件解析

java 订阅