解析XML数据

在 Java 程序中读取 XML 文件的过程称为解析 XML

解析 XML 文件的方式

1) DOM 解析 (java 官方提供)

2) SAX 解析(java 官方提供)

3) JDOM 解析(第三方提供)

4) DOM4J 解析(第三方提供)

DOM 解析 XML 的步骤

1) 创建一个 DocumentBuilderFactory 的对象       Document文档  Factory工厂

2) 创建一个 DocumentBuilder 对象

3) 通过DocumentBuilder的parse(...)方法得到Document对象

4) 通过 getElementsByTagName(...)方法获取到节点的列表

5) 通过 for 循环遍历每一个节点

6) 得到每个节点的属性和属性值

7) 得到每个节点的节点名和节点值

 import java.io.IOException;

 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;

 import org.w3c.dom.Document;
 import org.w3c.dom.NamedNodeMap;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.SAXException;

 public class TestDOMParse {
     public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
     //    1)    创建一个DocumentBuilderFactory的对象
         DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
     //    2)    创建一个DocumentBuilder对象
         DocumentBuilder db=dbf.newDocumentBuilder();
     //    3)    通过DocumentBuilder的parse(...)方法得到Document对象
         Document doc=db.parse("book.xml");
     //    4)    通过getElementsByTagName(...)方法获取到节点的列表
         NodeList bookList=doc.getElementsByTagName("book");//有2个book节点
         //System.out.println(bookList.getLength());
     //    5)    通过for循环遍历每一个节点
         for(int i=0;i<bookList.getLength();i++){
             //6)    得到每个节点的属性和属性值
             Node book=bookList.item(i);
             NamedNodeMap attrs=book.getAttributes(); //得到了属性的集合
             //循环遍历每一个属性
             for(int j=0;j<attrs.getLength();j++){
                 //得到每一个属性
                 Node id=attrs.item(j);
                 System.out.println("属性的名称:"+id.getNodeName()+"\t"+id.getNodeValue());
             }
         }
     System.out.println("\n每个节点的名和节点的值");
 //        7)    得到每个节点的节点名和节点值
     for(int i=0;i<bookList.getLength();i++){
         //得到每一个book节点
         Node book=bookList.item(i);
         NodeList subNode=book.getChildNodes();
         System.out.println("子节点的个数:"+subNode.getLength());
         //使用for循环遍历每一book的子节点
         for(int j=0;j<subNode.getLength();j++){
             Node childNode=subNode.item(j);
             //System.out.println(childNode.getNodeName());
             short type=childNode.getNodeType(); //获取节点的类型
             if(type==Node.ELEMENT_NODE){
                 System.out.println("节点的名称:"+childNode.getNodeName()+"\t"+childNode.getTextContent());
             }

         }
     }

     }
 }

------------------------------------------------------------------------------------------------------------------------------------------------------

SAX 方式解析 XML 数据

SAX 的概述

SAX，全称 Simple API for XML，是一种以事件驱动的XMl API,SAX 与 DOM 不同的是它边扫描边解析，自顶向下依次解析，由于边扫描边解析，

所以它解析 XML 具有速度快，占用内存少的优点

SAX 解析 XML 的步骤

1) 创建 SAXParserFactory 的对象
2) 创建 SAXParser 对象 (解析器)
3) 创建一个 DefaultHandler 的子类
4) 调用 parse 方法

 import java.io.IOException;

 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;

 import org.xml.sax.SAXException;

 public class TestSAXParse {
     public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
     //1)    创建SAXParserFactory的对象
         SAXParserFactory spf=SAXParserFactory.newInstance();
     //2)    创建SAXParser对象 (解析器)
         SAXParser parser=spf.newSAXParser();
     //3)    创建一个DefaultHandler的子类
         BookDeaultHandler bdh=new BookDeaultHandler();
     //4)    调用parse方法
         parser.parse("book.xml", bdh);
     }
 }

DefaultHandler的子类

 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
 import org.xml.sax.helpers.DefaultHandler;

 public class BookDeaultHandler extends DefaultHandler {
     //重写第一个方法
     /**解析xml文档开始时调用*/
     @Override
     public void startDocument() throws SAXException {
         // TODO Auto-generated method stub
         super.startDocument();
         System.out.println("解析xml文档开始");
     }
     /*解析xml文档结束时调用*/
     @Override
     public void endDocument() throws SAXException {
         // TODO Auto-generated method stub
         super.endDocument();
         System.out.println("解析xml文档结束");
     }
     /**解析xml文档中的节点时调用*/
     @Override
     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
         // TODO Auto-generated method stub
         super.startElement(uri, localName, qName, attributes);
         //System.out.println("解析xml文档中的节点时调用");
         /**判断，如果是book节点，获取节点的属性和属性值*/
         if("book".equals(qName)){
             //获取所有的属性
             int count=attributes.getLength();//属性的个数
             //循环获取每个属性
             for(int i=0;i<count;i++){
                 String attName=attributes.getQName(i);//属性名称
                 String attValue=attributes.getValue(i);//属性值
                 System.out.println("属性名称:"+attName+"\t属性值为:"+attValue);
             }
         }else if(!"books".equals(qName)&&!"book".equals(qName)){
             System.out.print("节点的名称:"+qName+"\t");
         }

     }
     /**解析xml文档中的节点结束调用*/
     @Override
     public void endElement(String uri, String localName, String qName) throws SAXException {
         // TODO Auto-generated method stub
         super.endElement(uri, localName, qName);
         //System.out.println("解析xml文档中的节点结束调用");
     }
     @Override
     public void characters(char[] ch, int start, int length) throws SAXException {
         // TODO Auto-generated method stub
         super.characters(ch, start, length);
         String value=new String(ch,start,length);
         if(!"".equals(value.trim())){
             System.out.println(value);
         }

     }
 }

---------------------------------------------------------------------------------------------------------------------------------------

JDOM 解析 XML 数据

JDOM 概述

JDOM 是一种解析 XML 的 Java 工具包，它基于树型结构，利用纯Java的技术对XML文档实现解析。所以中适合于Java语言

导入jar包

选中复制

粘贴到lib，之后选中Jdom右键构建路径，添加至构建路径

JDOM 解析 XML 的步骤

1) 创建一个 SAXBuilder 对象

2) 调用 build 方法，得到 Document 对象(通过 IO 流)

3) 获取根节点

4) 获取根节点的直接子节点的集合

5) 遍历集合

 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.List;

 import org.jdom.Attribute;
 import org.jdom.Document;
 import org.jdom.Element;
 import org.jdom.JDOMException;
 import org.jdom.input.SAXBuilder;

 public class TestJDOM {
     public static void main(String[] args) throws FileNotFoundException, JDOMException, IOException {
 //        1)    创建一个SAXBuilder对象
         SAXBuilder sb=new SAXBuilder();
 //    2)    调用build方法，得到Document对象(通过IO流)
         Document doc=sb.build(new FileInputStream("book.xml"));
 //    3)    获取根节点
         Element root=doc.getRootElement(); //books元素
 //    4)    获取根节点的直接子节点的集合
         List<Element> bookEle=root.getChildren();//book，2个book
 //    5)    遍历集合,得到book的每一个子节点（子元素）
         for(int i=0;i<bookEle.size();i++){
             Element book=bookEle.get(i);
             //得到属性集合
             List<Attribute> attList=book.getAttributes();
             //遍历属性的集合得到每一个属性
             for (Attribute attr : attList) {
                 System.out.println(attr.getName()+"\t"+attr.getValue());
             }
         }

         //得到每一个子节点
         System.out.println("\n-----------------------");
         for(int i=0;i<bookEle.size();i++){
             Element book=bookEle.get(i);//得到每一个book节点
             List<Element> subBook=book.getChildren();
             //遍历每一个节点，获取节点名称节点值
             for (Element ele : subBook) {
                 System.out.println(ele.getName()+"\t"+ele.getValue());
             }
             System.out.println("=========================================");
         }

     }
 }

------------------------------------------------------------------------------------------------------------------------------------------------------------

DOM4J 方式解析 XML 数据

DOM4J 是一个 Java 的 XML API，是 JDOM 的升级品，用来读写 XML 文件的

DOM4J 解析 XML 的步骤

1) 创建 SAXReader 对象

2) 调用 read 方法

3) 获取根元素

4) 通过迭代器遍历直接节点

 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.bjsxt.entity.Book;

 public class TestDOM4J {
     public static void main(String[] args) throws DocumentException {
 //        1)    创建SAXReader对象
         SAXReader reader=new SAXReader();
 //    2)    调用read方法
         Document doc=reader.read(new File("book.xml"));
 //    3)    获取根元素
         Element root=doc.getRootElement();//books
 //    4)    通过迭代器遍历直接节点
         for(Iterator<Element> iteBook=root.elementIterator();iteBook.hasNext();){
             Element bookEle=iteBook.next();
             //System.out.println(bookEle.getName());
             //得到book的属性
             for(Iterator<Attribute> iteAtt=bookEle.attributeIterator();iteAtt.hasNext();){
                 Attribute att=iteAtt.next();
                 System.out.println(att.getName()+"\t"+att.getText());
             }
         }

         System.out.println("\n------------------------------------");
         List<Book> bookList=new ArrayList<Book>();
         for(Iterator<Element> iteBook=root.elementIterator();iteBook.hasNext();){
             //创建Book对象
             Book book=new Book();
             Element bookEle=iteBook.next();//得到每一个book
             //使用for循环继续遍历
             for(Iterator<Element> subBookEle=bookEle.elementIterator();subBookEle.hasNext();){
                 //得到每一个子元素
                 Element subEle=subBookEle.next();
                 System.out.println(subEle.getName()+"\t"+subEle.getText());
                 /**
                  * 封装成Book对象
                  * */
                 //获取节点的名称
                 String nodeName=subEle.getName();//name,author,price
                 //使用switch判断
                 switch (nodeName) {
                 case "name":
                     book.setName(subEle.getText());
                     break;
                 case "author":
                     book.setAuthor(subEle.getText());
                     break;
                 case "price":
                     book.setPrice(Double.parseDouble(subEle.getText()));
                     break;
             }

         }
                 //添加到集合中
             bookList.add(book);
         }

         //遍历集合
         System.out.println("\n遍历集合-----------------------\n");
         for (Book b : bookList) {
             System.out.println(b.getName()+"\t"+b.getAuthor()+"\t"+b.getPrice());
         }
     }
 }

 public class Book {
     //私有属性
     private String name;
     private String author;
     private double price;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getAuthor() {
         return author;
     }
     public void setAuthor(String author) {
         this.author = author;
     }
     public double getPrice() {
         return price;
     }
     public void setPrice(double price) {
         this.price = price;
     }
     public Book(String name, String author, double price) {
         super();
         this.name = name;
         this.author = author;
         this.price = price;
     }
     public Book() {
         super();
     }

 }

四种解析 XML 的特点

1)DOM 解析:

形成了树结构，有助于更好的理解、掌握，且代码容易编写。解析过程中，树结构保存在内存中，方便修改。

2)SAX 解析:

采用事件驱动模式，对内存耗费比较小。适用于只处理 XML 文件中的数据时

3)JDOM 解析:

仅使用具体类，而不使用接口。API 大量使用了 Collections 类。

4)DOM4J 解析:

JDOM 的一种智能分支，它合并了许多超出基本 XML 文档表示的功能。

它使用接口和抽象基本类方法。

具有性能优异、灵活性好、功能强大和极端易用的特点。

是一个开放源码的文件