java环境下读取xml文件的方法主要有4种:DOM、SAX、JDOM、JAXB

    Java中解析XML的工具很多,像JDOM,DOM4J等,但Java标准库提供的两种解析XML文档解析器是:DOM(Document Object Module)解析器 和 SAX(Simple API for XML)解析器。DOM解析器会读入整个XML文档并转换成树结构;SAX解析器会在读入XML文档时生成相应的事件;故也常叫基于文档对象模型的XML解析和基于事件驱动的XML解析;那它们有什么区别呢? 

   DOM解析器会读入整个文档,构建一个驻留在内存中的树型结构,我们就可以使用 DOM 接口来操作这个文档树,其优点是整个文档树在内存中,便于操作,支持删除、修改、重新排列等多种功能;缺点是需将整个文档读入内存中,在文档大时会消耗大量内存; 

   SAX解释器在XML文档读入时能够立即开始,而不是等待所有的数据加载完后处理,解析器通过发现元素开始、元素结束、文本开始、文档结束等来发送事件,通过种基于回调机制的方法来处理数据;其优点是解析速度快,不用事先调入整个文档,占用资源少;其缺点是必须实现事件处理程序,不能修改文档,不能随机访问。 

   DOM4J性能最好,连Sun的JAXM也在用DOM4J.目前许多开源项目中大量采用DOM4J,例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性,那就采用DOM4J. 

    我们就细细的研究这几种方式吧。主要有4种:DOM、SAX、JDOM、JAXB


1.  DOM(Document Object Model) 


 此 方法主要由W3C提供,它将xml文件全部读入内存中,然后将各个元素组成一棵数据树,以便快速的访问各个节点 。 因此非常消耗系统性能 ,对比较大的文档不适宜采用DOM方法来解析。 DOM API 直接沿袭了 XML 规范。每个结点都可以扩展的基于 Node 的接口,就多态性的观点来讲,它是优秀的,但是在 Java 语言中的应用不方便,并且可读性不强,著名的SPRING框架就是采用此方法读取XML。

首先来了解点Java DOM 的 API:
1.解析器工厂类:DocumentBuilderFactory

创建的方法:DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

2.解析器:DocumentBuilder

创建方法:通过解析器工厂类来获得 DocumentBuilder db = dbf.newDocumentBuilder();

3.文档树模型Document

创建方法:a.通过xml文档 Document doc = db.parse("bean.xml");  b.将需要解析的xml文档转化为输入流 InputStream is = new FileInputStream("bean.xml");

 Document doc = db.parse(is); 

Document对象代表了一个XML文档的模型树,所有的其他Node都以一定的顺序包含在Document对象之内,排列成一个树状结构,以后对XML文档的所有操作都与解析器无关,

直接在这个Document对象上进行操作即可;

 包含的方法:

4.节点列表类NodeList

NodeList代表了一个包含一个或者多个Node的列表,根据操作可以将其简化的看做为数组

5.节点类Node

Node对象是DOM中最基本的对象,代表了文档树中的抽象节点。但在实际使用中很少会直接使用Node对象,而是使用Node对象的子对象Element,Attr,Text等

6.元素类Element

是Node类最主要的子对象,在元素中可以包含属性,因而Element中有存取其属性的方法

Node.getNamespaceURI() 返回和给定节点关联的名称空间字符串,如果该元素或属性没有关联的名称空间则返回 null。

7.属性类Attr

代表某个元素的属性,虽然Attr继承自Node接口,但因为Attr是包含在Element中的,但并不能将其看做是Element的子对象,因为Attr并不是DOM树的一部

基本的知识就到此结束,更加具体的大家可以参阅JDK API文档


 实例:

 

Java代码   收藏代码
  1. import javax.xml.parsers.*;   
  2. //XML解析器接口   
  3. import org.w3c.dom.*;   
  4. //XML的DOM实现   
  5. import org.apache.crimson.tree.XmlDocument;  
  6. //写XML文件,很明显该类是一个单例,先获取产生DocumentBuilder工厂的工厂,在通过这个工厂产生一个DocumentBuilder,  
  7. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
  8.  //允许名字空间  
  9.  factory.setNamespaceAware(true);  
  10.  //允许验证  
  11.  factory.setValidating(true);  
  12.  //获得DocumentBuilder的一个实例  
  13. try {   
  14.  DocumentBuilder builder = factory.newDocumentBuilder();  
  15. catch (ParserConfigurationException pce) {   
  16. System.err.println(pce);  
  17. //  出异常时输出异常信息,然后退出,下同  
  18. System.exit(1);  
  19. }   
  20. //解析文档,并获得一个Document实例。   
  21. try {   
  22. //Document可以看作是XML在内存中的一个镜像,那么一旦获取这个Document 就意味着可以通过对   
  23. //内存的操作来实现对XML的操作,首先第一步获取XML相关的Document
  24. Document doc = builder.parse(fileURI);  
  25. catch (DOMException dom) {  
  26. System.err.println(dom.getMessage());  
  27. System.exit(1);  
  28. catch (IOException ioe) {  
  29. System.err.println(ioe);  
  30. System.exit(1);       
  31. }  
  32. //获得根节点StuInfo,在xml文件里,只有一个根元素,先把根元素拿出来看看  
  33. Element elmtStuInfo = doc.getDocumentElement();  
  34. //得到所有student节点  
  35.  NodeList nlStudent = elmtStuInfo.getElementsByTagNameNS(  
  36.                                        strNamespace, "student");  
  37. for (……){  
  38.      //当前student节点元素  
  39.      Element elmtStudent = (Element)nlStudent.item(i);  
  40.      NodeList nlCurrent =              elmtStudent.getElementsByTagNameNS(  
  41.                                      strNamespace, "name");  
  42. }  

 对于读取得方法其实是很简单的,写入xml文件也是一样不复杂。

 

 

Java代码   收藏代码
  1. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();   
  2. DocumentBuilder builder = null;   
  3. try {   
  4. builder = factory .newDocumentBuilder();   
  5. catch (ParserConfigurationException pce) {   
  6. System.err.println(pce);   
  7. System.exit(1);   
  8. }  
  9. Document doc = null;   
  10. doc = builder .newDocument();  
  11. //下面是建立XML文档内容的过程,  
  12. //先建立根元素"学生花名册"   
  13. Element root = doc.createElement("学生花名册");   
  14. //根元素添加上文档   
  15. doc.appendChild(root);   
  16. //建立"学生"元素,添加到根元素   
  17. Element student = doc.createElement("学生");   
  18. student.setAttribute("性别", studentBean.getSex());   
  19. root.appendChild(student);   
  20. //建立"姓名"元素,添加到学生下面,下同   
  21. Element name = doc.createElement("姓名");   
  22. student.appendChild(name);   
  23. Text tName = doc.createTextNode(studentBean.getName());   
  24. name.appendChild(tName);  
  25. Element age = doc.createElement("年龄");   
  26. student.appendChild(age);   
  27. Text tAge = doc.createTextNode(String.valueOf(studentBean.getAge()));   
  28. age.appendChild(tAge);  

 2.SAX (Simple API for XML) 

 

 

此方法主要由XML-DEV 邮件列表的成员开发的,SAX是基于事件的方法,它很类似于标签库的处理机制,在标签开始、结束以及错误发生等等地方调用相应的接口实现方法,不是全部文 档都读入内存。 SAX具有优异的性能和利用更少的存储空间特点。SAX 的设计只考虑了功能的强大性,却没有考虑程序员使用起来是否方便。

使用必须扩展ContentHandler、ErrorHandler、DTDHandler等,但是必须扩展ContentHandler(或者DefaultHandler )。

 

Java代码   收藏代码
  1. import org.xml.sax.*;  
  2. public  class  MyContentHandler implements ContentHandler {  
  3.   … …  
  4. }  
  5. /** 
  6.      * 当其他某一个调用事件发生时,先调用此方法来在文档中定位。 
  7.      * @param locator 
  8.      */  
  9.     public void setDocumentLocator(Locator locator){  
  10.     }  
  11. /** 
  12.      * 在解析整个文档开始时调用 
  13.      * @throws SAXException 
  14.      */  
  15.     public void startDocument() throws SAXException{  
  16.         System.out.println("** Student information start **");  
  17.     }  
  18. /** 
  19.      * 在解析整个文档结束时调用 
  20.      * @throws SAXException 
  21.      */  
  22.     public void endDocument() throws SAXException{  
  23.         System.out.println("**** Student information end ****");  
  24.     }  
  25. /** 
  26.      * 在解析名字空间开始时调用 
  27.      * @param prefix 
  28.      * @param uri 
  29.      * @throws SAXException 
  30.      */  
  31.     public void startPrefixMapping(String prefix  
  32.         , String uri) throws SAXException{  
  33.     }  
  34. /** 
  35.      * 在解析名字空间结束时调用 
  36.      * @param prefix 
  37.      * @throws SAXException 
  38.      */  
  39.     public void endPrefixMapping(String prefix) throws SAXException{  
  40.     }  
  41. /** 
  42.      * 在解析元素开始时调用 
  43.      * @param namespaceURI 
  44.      * @param localName 
  45.      * @param qName 
  46.      * @param atts 
  47.      * @throws SAXException 
  48.      */  
  49.     public void startElement(String namespaceURI, String localName  
  50.         , String qName, Attributes atts) throws SAXException{  
  51.     }  
  52. /** 在解析元素结束时调用 
  53.      * @param namespaceURI 
  54.      * @param localName 本地名,如student 
  55.      * @param qName 原始名,如LIT:student 
  56.      * @throws SAXException   */  
  57.     public void endElement(String namespaceURI, String localName,String qName) throws SAXException{  
  58.   if (localName.equals(“student”)){  
  59.             System.out.println(localName+":"+currentData);  
  60.         }  
  61. }  

取得元素数据的方法——characters

 

取得元素数据中的空白的方法——ignorableWhitespace
在解析到处理指令时调用的方法——processingInstruction
当未验证解析器忽略实体时调用的方法——skippedEntity
运行时,只需要使用下列代码:

 

Java代码   收藏代码
  1. MySAXParser mySAXParser = new MySAXParser();  
  2. mySAXParser.parserXMLFile("SutInfo.xml");  

 3.JDOM

 

JDOM的处理方式有些类似于DOM,但它主要是用SAX实现的 。JDOM用Java的数据类型来定义操作数据树的各个节点 。JDOM的性能也很优越。

 

Java代码   收藏代码
  1. import org.jdom.*;  
  2. import org.jdom.input.*;  
  3. import org.jdom.output.*;  
  4. SAXBuilder builder = new SAXBuilder(false);  
  5. //得到Document  
  6. Document doc = builder.build(fileURI);  
  7. //名字空间  
  8. Namespace ns = Namespace.getNamespace("LIT" , "http://www.lit.edu.cn/student/ ");  
  9. //取得所有LIT:student节点的集合  
  10. List lstStudents = elmtStuInfo.getChildren("student",ns);  
  11. for ( … ){  
  12.  Element elmtStudent = (Element)lstStudents.get(i);  
  13.  elmtStudent.getChildTextTrim("name", ns);  
  14. }  
  15. //修改  
  16. elmtLesson.getChild("lessonScore" , ns).setText("100");  
  17. //删除  
  18. elmtStuInfo.removeChild("master", ns);  
  19. //添加  
  20. elmtStuInfo.addContent(new Element("master" , ns).addContent(new Entity("masterName")));  
  21. //输出文档  
  22. //第一个参数是缩进字符串,这里是4个空格。  
  23. //第二个参数是true,表示需要换行。  
  24. XMLOutputter printDoc = new XMLOutputter(" "true);  
  25.  printDoc.output(doc, new FileOutputStream("StuInfo.xml"));  

 4.JAXB (Java And XML Binding)

 

 

JAXB 是以SUN为主的一些公司公布的。JAXB将schema(或者DTD)映射为java对象(.java文件),然后使用这些java对象来解析xml文件。需要使用之前生成java文件,因而要有固定的schema,无法处理动态的xml文件。

首先使用xjc命令,生成java文件
xjc  [-options ...]

(生成的文件较多)

Java代码   收藏代码
  1. JAXBContext jc = JAXBContext.newInstance(“packageName");  
  2.  Unmarshaller unmarshaller = jc.createUnmarshaller();  
  3. Collection collection= (Collection)unmarshaller.unmarshal(new File( "books.xml"));  
  4. CollectionType.BooksType booksType =collection.getBooks();  
  5. List bookList = booksType.getBook();  
  6. for( … ){  
  7.  test.jaxb.BookType book =(test.jaxb.BookType) bookList.get(i);  
  8.  System.out.println("Book Name: " + book.getName().trim());  
  9.    System.out.println("Book ISBN: " +  book.getISBN());  
  10. }  

 

 

补充另一种方法:

 

据悉dom4j在xml解析方面是性能最好的,hibernate等框架都使用它作为解析的工具。

 

要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/

目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip

 

解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要加入包jaxen-1.1-beta-7.jar

 

 

写了简单的dom4j的使用的demo,以备回忆,有些是dom4j的文挡里例子改编的 
使用dom4j解析下面的xml文件。

 

Xml代码   收藏代码
  1. <?xml version="1.0" encoding="GB2312"?>   
  2.   
  3. <?xml-stylesheet type="text/xsl" href="students.xsl"?>  
  4.   
  5. <students>  
  6.     <student sn="01">  
  7.         <name>张三</name>  
  8.         <age>18</age>  
  9.     </student>  
  10.       
  11.     <student sn="02">  
  12.         <name>李四</name>  
  13.         <age>20</age>  
  14.     </student>  
  15. </students>  

 

 Parse.java 

Java代码   收藏代码
  1. import java.io.File;  
  2.   
  3. import org.dom4j.Attribute;  
  4. import org.dom4j.Document;  
  5. import org.dom4j.DocumentException;  
  6. import org.dom4j.Element;  
  7. import org.dom4j.ProcessingInstruction;  
  8. import org.dom4j.VisitorSupport;  
  9. import org.dom4j.io.SAXReader;  
  10.   
  11. public class Parse {  
  12.   
  13.     public static void main(String[] args) {  
  14.         SAXReader reader = new SAXReader();  
  15.         File file = new File("src/students.xml");  
  16.         try {  
  17.             Document doc = reader.read(file);  
  18.             doc.accept(new MyVistor());  
  19.         } catch (DocumentException e) {  
  20.             // TODO Auto-generated catch block  
  21.             e.printStackTrace();  
  22.         }  
  23.     }  
  24.   
  25.     public static class MyVistor extends VisitorSupport {  
  26.         public void visit(Attribute node) {  
  27.             System.out.println("Attibute:---" + node.getName() + "="+ node.getValue());  
  28.         }  
  29.   
  30.         public void visit(Element node) {  
  31.             if (node.isTextOnly()) {  
  32.                 System.out.println("Element:---" + node.getName() + "="  
  33.                         + node.getText());  
  34.             }else{  
  35.                 System.out.println("--------" + node.getName() + "-------");  
  36.             }  
  37.         }  
  38.   
  39.         @Override  
  40.         public void visit(ProcessingInstruction node) {  
  41.             System.out.println("PI:"+node.getTarget()+" "+node.getText());  
  42.         }  
  43.     }  
  44. }  

 使用dom4j来将属性写入xml 

Java代码   收藏代码
  1. import java.io.FileWriter;  
  2. import java.io.IOException;  
  3.   
  4. import org.dom4j.Document;  
  5. import org.dom4j.DocumentHelper;  
  6. import org.dom4j.Element;  
  7. import org.dom4j.io.OutputFormat;  
  8. import org.dom4j.io.XMLWriter;  
  9.   
  10. public class DWriter {  
  11.   
  12.     public static void main(String[] args) {  
  13.         // TODO Auto-generated method stub  
  14.         try {  
  15.             XMLWriter writer = new XMLWriter(new FileWriter("src/author.xml"));  
  16.             Document doc = createDoc();  
  17.             writer.write(doc);  
  18.             writer.close();  
  19.   
  20.             // Pretty print the document to System.out  
  21.             // 设置了打印的格式,将读出到控制台的格式进行美化  
  22.             OutputFormat format = OutputFormat.createPrettyPrint();  
  23.             writer = new XMLWriter(System.out, format);  
  24.             writer.write(doc);  
  25.   
  26.         } catch (IOException e) {  
  27.             // TODO Auto-generated catch block  
  28.             e.printStackTrace();  
  29.         }  
  30.     }  
  31.   
  32.     public static Document createDoc() {  
  33.         Document doc = DocumentHelper.createDocument();  
  34.         Element root = doc.addElement("root");  
  35.         Element author1 = root.addElement("author").addAttribute("name",  
  36.                 "Kree").addAttribute("location""UK")  
  37.                 .addText("Kree Strachan");  
  38.         Element author2 = root.addElement("author").addAttribute("name""King")  
  39.                 .addAttribute("location""US").addText("King McWrirter");  
  40.         return doc;  
  41.     }  
  42. }  

 使用dom4j写入到author.xml文件的内容

Java代码   收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <root>  
  3. <author name="Kree" location="UK">Kree Strachan</author>  
  4. <author name="King" location="US">King McWrirter</author>  
  5. </root>  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值