java解析xml原理方法对比示例，XML基础

XML是什么

  可扩展的标记语言

  XML能干什么

  描述数据、存储数据、传输（交换）数据。

XML有什么

• 元素
• 属性
• 实体
• PCDATA ：被解析的字符数据（parsed character data），PDATA 是会被解析器解析的文本。这些文本将被解析器检查实体以及标记
• CDATA ：字符数据（character data），CDATA 是不会被解析器解析的文本

 

XML与HTML区别：目的不一样

    XML 被设计用来描述数据，其焦点是数据的内容。

HTML 被设计用来展示数据，其焦点是数据的外观。

HTML可以不关闭标签（即标签可以不成对出现），但XML必须关闭标签（即标签必须成对出现）。

HTML中的标签标识文本如何展示，而XML中的标签标识文本是什么含义（什么类型的文本）。

 

XML注意

XML是无作为的，不会做任何事情，只用于描述数据、存储数据、传输（交换）数据。

如何展示和使用XML数据就需要程序员根据需求来做解析数据并展示和使用。

 

XML文档节点类型

u     文档(document)

u     元素(element)

u     属性(attribute)

u     文本(PCDATA--parsed character data)

u     注释(comment)

u     DOCTYPE ：主要验证文档内容的正确性

u     实体(ENTITIES)

u     CDATA(character data)

XML语法

1、声明：

2、根节点：必须有一个根节点

3、标签：标签必须有结束且区分大小写，标签必须顺序嵌套

4、属性：必须引号引起值

5、空格会被保留，HTML空格最多保留一个

6、命名规则：命名必须见名知意

     a)    名字可包含字母、数字以及其他的字符 

     b)    名字不能以数字或者标点符号开始

     c)    名字不能以字符“xml”（或者XML、Xml）开始

7、名字不能包含空格 

8、 不应在 XML 元素名称中使用 ":" ，这是由于它用于命名空间（namespaces）的保留字。

9、标签优先于属性。

  10、XML 命名空间可提供避免元素命名冲突的方法。

  11、CDATA：字符数据， ，字符数据不进行转义

  12、实体：&实体;

 

DTD

是什么

   DTD（DocType Definition 文档类型定义）的作用是定义 XML 文档的合法构建模块。

它使用一系列的合法元素来定义文档结构。

能干什么

DTD（文档类型定义）的作用是约定XML格式。

主要有什么

   元素、属性、实体定义

 

DTD引用方式

  内部

    [元素声明]>

  外部私有的  SYSTEM   一般是我们自己定义的，可能只是一个公司内部使用

  外部公有的  PUBLIC   一般是一些标准，可能非常多的人用

首先根据“命名空间”去问环境要相应的dtd文件，如果有，直接提供，如果没有再根据dtd文件位置找。

格式

     描述元素之间关系

       定义

       顺序：(seq1,se2) 必须按顺序

  (or1|or2)  两个选一个

           个数：?          零个或一个

                 标签       必须一个

                 *          零个或多个

                 +          一个或多个

 

    描述元素属性

      格式：    

    属性类型：

CDATA	值为字符数据 (character data)
(en1|en2|..)	此值是枚举列表中的一个值
ID	值为唯一的 id
IDREF	值为另外一个元素的 id
IDREFS	值为其他 id 的列表
NMTOKEN	值为合法的 XML 名称
NMTOKENS	值为合法的 XML 名称的列表
ENTITY	值是一个实体
ENTITIES	值是一个实体列表
#PCDATA	定义文本元素，没有子元素

 

 

 

 

 

 

 

 

 

 

 

 

    默认值：

值	解释
值	属性的默认值
#REQUIRED	属性值是必需的
#IMPLIED	属性不是必需的
#FIXED value	属性值是固定的

 

 

 

 

 

 

    实体：

Schema

是什么

    XML Schema 是基于 XML 的 DTD 替代者。XML Schema 描述 XML 文档的结构。XML Schema 语言也称作 XML Schema 定义（XML Schema Definition，XSD）。

   DTD不是通过XML语法定义文档结构， 不能定义数据类型和限制

  Schema通过XML语法定义文档结构，可以定义数据类型和限制

能干什么

       约定XML格式

 

• 定义可出现在文档中的元素
• 定义可出现在文档中的属性
• 定义哪个元素是子元素
• 定义子元素的次序
• 定义子元素的数目
• 定义元素是否为空，或者是否可包含文本
• 定义元素和属性的数据类型
• 定义元素和属性的默认值以及固定值

 

为何使用Schema？

XML Schema 是 DTD 的继任者

我们认为 XML Schema 很快会在大部分网络应用程序中取代 DTD。

理由如下：

• XML Schema 可针对未来的需求进行扩展
• XML Schema 更完善，功能更强大
• XML Schema 基于 XML 编写
• XML Schema 支持数据类型和限制
• XML Schema 支持命名空间

 

有什么

       元素、属性、限定的定义。

    可以约束我们写XML文件。

 

Schema引用方式

 
  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 
  
        xsi:schemaLocation="命名空间  Schema位置">
 
  
    如何找Schema，和DTD一样，首先根据命名空间问环境要，找不到再根据Schema位置找。
 
  
 
  
 
  
 
  
Java解析XML
 
  
推模型和拉模型
 
  
推模型是当通知消息来之时，把所有相关信息都通过参数的形式“推给”观察者。
 
  
事件驱动编程（Event-driven programming），基于回调（callback）机制，也就是推模型，即使不需要也把数据推给你。
 
  
 
 
  
拉模型是当通知消息来之时，通知的函数不带任何相关的信息，而是要观察者主动去“拉”信息。
 
  
通过轮询（Loop check）实现就是拉模型，，给你一个引用，数据在拉之前全部准备好了，需要时拉需要。
 
  
 
 
  
 
 
  
JAXP
 
  
DOM解析
 
  
DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找 特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。
 
  
DOM解析器把XML文档转化为一个包含其内容的树，并可以对树进行遍历。
 
  
DOM是拉模型，在遍历文档时，会把感兴趣的部分从读取器中拉出，不需要引发事件，允许我们选择性地处理节点。这大大提高了灵活性，以及整体效率。
 
  

 
  
 
   java代码： 
   
public static void domParse() throws Exception {
File file =
new File("F:/javass/web项目/workspace/xml/src/users.xml");
        //1、创建DocumentBuilder工厂
        DocumentBuilderFactory dbf =
DocumentBuilderFactory.newInstance();
        //2、创建DocumentBuilder
        DocumentBuilder db = dbf.newDocumentBuilder();
        //3、将xml文件解析为Document对象，代表DOM树
        Document document = db.parse(file);
        //将文档标准化，去除无用的空格和空行，即删除无用的text node
        document.normalize();
        NodeList nodeList = document.getElementsByTagName("user");
        for(int i = 0; i < nodeList.getLength(); i++) {

            Element element = (Element) nodeList.item(i);
            System.out.println("======user start=======");
            String uuid = element.getElementsByTagName("uuid").item(0).getTextContent();
            System.out.println(uuid);
            String name = element.getElementsByTagName("name").item(0).getTextContent();
            System.out.println(name);
            System.out.println("======user end=======");
        }
    }
 
   
public static void domParse() throws Exception {
File file = 
new File("F:/javass/web项目/workspace/xml/src/users.xml");
		//1、创建DocumentBuilder工厂
		DocumentBuilderFactory dbf = 
DocumentBuilderFactory.newInstance();
		//2、创建DocumentBuilder
		DocumentBuilder db = dbf.newDocumentBuilder();
		//3、将xml文件解析为Document对象，代表DOM树
		Document document = db.parse(file);
		//将文档标准化，去除无用的空格和空行，即删除无用的text node
		document.normalize();
		NodeList nodeList = document.getElementsByTagName("user");
		for(int i = 0; i < nodeList.getLength(); i++) {

			Element element = (Element) nodeList.item(i);
			System.out.println("======user start=======");
			String uuid = element.getElementsByTagName("uuid").item(0).getTextContent();
			System.out.println(uuid);
			String name = element.getElementsByTagName("name").item(0).getTextContent();
			System.out.println(name);
			System.out.println("======user end=======");
		}
	}
 
  
 
  
DOM的基本对象有5个：Document，Node，NodeList，Element和Attr。
 
  
 
 
  
1.1、Document对象
 
  
代表了整个XML的文档，所有其它的Node，都以一定的顺序包含在Document对象之内，排列成一个树形的结构，程序员可以通过遍历这颗树来得到XML文档的所有的内容，这也是对XML文档操作的起点。我们总是先通过解析XML源文件而得到一个Document对象，然后再来执行后续的操作。此外，Document还包含了创建其它节点的方法，比如createAttribut()用来创建一个Attr对象。它所包含的主要的方法有：
 
  
createAttribute(String)：用给定的属性名创建一个Attr对象，并可在其后使用setAttributeNode方法来放置在某一个Element对象上面。
 
  
createElement(String)：用给定的标签名创建一个Element对象，代表XML文档中的一个标签，然后就可以在这个Element对象上添加属性或进行其它的操作。
 
  
createTextNode(String)：用给定的字符串创建一个Text对象，Text对象代表了标签或者属性中所包含的纯文本字符串。如果在一个标签内没有其它的标签，那么标签内的文本所代表的Text对象是这个Element对象的唯一子对象。
 
  
getElementsByTagName(String)：返回一个NodeList对象，它包含了所有给定标签名字的标签。
 
  
getDocumentElement()：返回一个代表这个DOM树的根节点的Element对象，也就是代表XML文档根元素的那个对象。
 
  
 
 
  
1.2、Node对象
 
  
是DOM结构中最为基本的对象，代表了文档树中的一个抽象的节点。在实际使用的时候，很少会真正的用到Node这个对象，而是用到诸如Element、Attr、Text等Node对象的子对象来操作文档。Node对象为这些对象提供了一个抽象的、公共的根。虽然在Node对象中定义了对其子节点进行存取的方法，但是有一些Node子对象，比如Text对象，它并不存在子节点，这一点是要注意的。Node对象所包含的主要的方法有：
 
  
appendChild(org.w3c.dom.Node)：为这个节点添加一个子节点，并放在所有子节点的最后，如果这个子节点已经存在，则先把它删掉再添加进去。
 
  
getFirstChild()：如果节点存在子节点，则返回第一个子节点，对等的，还有getLastChild()方法返回最后一个子节点。
 
  
getNextSibling()：返回在DOM树中这个节点的下一个兄弟节点，对等的，还有getPreviousSibling()方法返回其前一个兄弟节点。
 
  
getNodeName()：根据节点的类型返回节点的名称。
 
  
getNodeType()：返回节点的类型。
 
  
getNodeValue()：返回节点的值。
 
  
hasChildNodes()：判断是不是存在有子节点。
 
  
hasAttributes()：判断这个节点是否存在有属性。
 
  
getOwnerDocument()：返回节点所处的Document对象。
 
  
insertBefore(org.w3c.dom.Node new，org.w3c.dom.Node ref)：在给定的一个子对象前再插入一个子对象。
 
  
removeChild(org.w3c.dom.Node)：删除给定的子节点对象。
 
  
replaceChild(org.w3c.dom.Node new，org.w3c.dom.Node old)：用一个新的Node对象代替给定的子节点对象。
 
  
 
 
  
1.3、NodeList对象
 
  
顾名思义，就是代表了一个包含了一个或者多个Node的列表。可以简单的把它看成一个Node的数组，我们可以通过方法来获得列表中的元素：
 
  
getLength()：返回列表的长度。
 
  
item(int)：返回指定位置的Node对象。
 
  
 
 
  
1.4、Element对象
 
  
代表的是XML文档中的标签元素，继承于Node，亦是Node的最主要的子对象。在标签中可以包含有属性，因而Element对象中有存取其属性的方法，而任何Node中定义的方法，也可以用在Element对象上面。
 
  
getElementsByTagName(String)：返回一个NodeList对象，它包含了在这个标签中其下的子孙节点中具有给定标签名字的标签。
 
  
getTagName()：返回一个代表这个标签名字的字符串。
 
  
getAttribute(String)：返回标签中给定属性名称的属性的值。在这儿需要主要的是，应为XML文档中允许有实体属性出现，而这个方法对这些实体属性并不适用。这时候需要用到getAttributeNodes()方法来得到一个Attr对象来进行进一步的操作。
 
  
getAttributeNode(String)：返回一个代表给定属性名称的Attr对象。
 
  
 
 
  
1.5、Attr对象
 
  
代表了某个标签中的属性。Attr继承于Node，但是因为Attr实际上是包含在Element中的，它并不能被看作是Element的子对象，因而在DOM中Attr并不是DOM树的一部分，所以Node中的getParentNode()，getPreviousSibling()和getNextSibling()返回的都将是null。也就是说，Attr其实是被看作包含它的Element对象的一部分，它并不作为DOM树中单独的一个节点出现。这一点在使用的时候要同其它的Node子对象相区别。
 
  

 
  
SAX解析
 
  
       SAX是Simple API for XML的缩写，它并不是由W3C官方所提出的标准，可以说是“民间”的事实标准。实际上，它是一种社区性质的讨论产物。虽然如此，在XML中对SAX的应用丝毫不比DOM少，几乎所有的XML解析器都会支持它。
 
  
与DOM比较而言，SAX是一种轻量型的方法。我们知道，在处理DOM的时候，我们需要读入整个的XML文档，然后在内存中创建DOM树，生成DOM树上的每个Node对象。当文档比较小的时候，这不会造成什么问题，但是一旦文档大起来，处理DOM就会变得相当费时费力。特别是其对于内存的需求，也将是成倍的增长，以至于在某些应用中使用DOM是一件很不划算的事（比如在applet中）。这时候，一个较好的替代解决方法就是SAX。
 
  
SAX在概念上与DOM完全不同。首先，不同于DOM的文档驱动，它是事件驱动的，也就是说，它并不需要读入整个文档，而文档的读入过程也就是SAX的解析过程。所谓事件驱动，是指一种基于回调（callback）机制的程序运行方法。（如果你对Java新的代理事件模型比较清楚的话，就会很容易理解这种机制了）  
 
  
 
 
  
回调：由我们在组件中定义，而不由我们调用，由容器或框架调用
 
  
 
 
  
SAX是推模型，它是一种靠事件驱动的模型。当它每发现一个节点就引发一个事件，而我们需要编写这些事件的处理程序。这样的做法很麻烦，且不灵活。
 
  
 
 
  
 
   java代码： 
   
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class UserSaxHandler extends DefaultHandler {

    boolean isOkTag = false;

    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        if(qName.equals("user")) {
            System.out.println("=============user start============");
        }

        if(qName.equals("uuid") || qName.equals("name")) {
            isOkTag = true;
            System.out.print(qName + ":");
        }
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        if(isOkTag) {
            System.out.println(new String(ch, start, length));
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        isOkTag = false;
        if(qName.equals("user")) {
            System.out.println("=============user end============");
        }
    }
}
 
   
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class UserSaxHandler extends DefaultHandler {
	
	boolean isOkTag = false;
	
	@Override
	public void startElement(String uri, String localName, String qName,
			Attributes attributes) throws SAXException {
		if(qName.equals("user")) {
			System.out.println("=============user start============");
		}
		
		if(qName.equals("uuid") || qName.equals("name")) {
			isOkTag = true;
			System.out.print(qName + ":");
		}
	}

	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		if(isOkTag) {
			System.out.println(new String(ch, start, length));
		}
	}
	
	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {
		isOkTag = false;
		if(qName.equals("user")) {
			System.out.println("=============user end============");
		}
	}
}
 
  
 
  
 
 
  
 
 
  
 
   java代码： 
   
import java.io.File;

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


public class SaxTest {
    public static void main(String[] args) throws Exception {
        saxParse();
    }

    private static void saxParse() throws Exception {

        File file = new File("F:/javass/web项目/workspace/xml/src/users.xml");

        //1、创建SAXParserFactory 工厂
        SAXParserFactory spf = SAXParserFactory.newInstance();

        //2、创建SAXParser
        SAXParser sp = spf.newSAXParser();
        //3、解析XML文档，并回调处理器的相应事件
        sp.parse(file, new UserSaxHandler());

    }

}
 
   
import java.io.File;

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


public class SaxTest {
	public static void main(String[] args) throws Exception {
		saxParse();
	}

	private static void saxParse() throws Exception {
		
		File file = new File("F:/javass/web项目/workspace/xml/src/users.xml");
		
		//1、创建SAXParserFactory 工厂
		SAXParserFactory spf = SAXParserFactory.newInstance();
		
		//2、创建SAXParser
		SAXParser sp = spf.newSAXParser();
		//3、解析XML文档，并回调处理器的相应事件
		sp.parse(file, new UserSaxHandler());
		
	}
	
}
 
  
 
  
 
 
  
 
 
  
StAX 解析
 
  
   针对于XML的流式API(StAX)，是在2004年3月的JSR 173规范中引入，这是一种针对XML的流式拉分析API。StAX是JDK 6.0提供的一种新特征。
 
  
一个推模型分析器不断地生成事件，直到XML文档被完全分析结束。但是，拉分析由应用程序进行调整；因此，分析事件是由应用程序生成的。这意味着，使用StaX，你可以推迟分析-在分析时跳过元素并且分析多个文档。在使用DOM API的时候，你必须把整个的XML文档分析成一棵DOM结构，这样也就降低了分析效率。而借助于StAX，在分析XML文档时
 
  
生成分析事件。
 
  
JDOM
 
  
JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和 促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。 
     JDOM与DOM主要有两方面不同。首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。 
     JDOM文档声明其目的是“使用20%（或更少）的精力解决80%（或更多）Java/XML问题”（根据学习曲线假定为20%）。JDOM对于大多数 Java/XML应用程序来说当然是有用的，并且大多数开发者发现API比DOM容易理解得多。JDOM还包括对程序行为的相当广泛检查以防止用户做任何 在XML中无意义的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。这也许是比学习DOM或JDOM接口 都更有意义的工作。 
     JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档（尽管它还可以将以前构造的DOM表示作为输入）。它包含一些转换器以将 JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。 
 
  
DOM4J http://dom4j.sourceforge.net 
 
  
虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、 XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始，它就一直处于开发之中。 
 
  
为支持所有这些功能，DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类，但是在许多情况下，它还提供一些替 代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然DOM4J付出了更复杂的API的代价，但是它提供了比JDOM大得多的灵活性。 
     在添加灵活性、XPath集成和对大文档处理的目标时，DOM4J的目标与JDOM是一样的：针对Java开发者的易用性和直观操作。它还致力于成为比 JDOM更完整的解决方案，实现在本质上处理所有Java/XML问题的目标。在完成该目标时，它比JDOM更少强调防止不正确的应用程序行为。 
     DOM4J是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写 XML，特别值得一提的是连Sun的JAXM也在用DOM4J. 
 
  
 
 
  
 
 
  
   
 
  
XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object Model),DTD(Document Type Definition),SAX(Simple API for XML),XSD(Xml Schema Definition),XSLT(Extensible Stylesheet Language Transformations),具体可参阅w3c官方网站文档http://www.w3.org获取更多信息。
 
  
XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。基本的解析方式有两种,一种叫SAX，另一种叫DOM。SAX是基于事件流的解析,DOM是基于XML文档树结构的解析
 
  
区别
 
  
一、DOM：拉模型，把整个文档加载到内存中
        优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；
        缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；
       使用场合：一旦解析了文档还需多次访问这些数据；
                           硬件资源充足（内存、CPU）
二、SAX：推模型，事件驱动编程，基于回调
 
  
       SAX ，事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。
       优点：不用事先调入整个文档，占用资源少；
 
  
       缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；
                    无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；
      使用场合：
 
  
数据量较大的XML文档，占用内存高，机器内存少，无法一次加载XML到内存；
 
  
只需XML文档的少量内容，很少回头访问；
                           
 
  
三、JDOM 
        为减少DOM、SAX的编码量，出现了JDOM；
         优点：20-80原则，极大减少了代码量，提供常用API减少重复劳动
        使用场合：要实现的功能简单，如解析、创建等
                            Java程序
         但在底层，JDOM还是使用SAX（最常用）、DOM
 
  
性能比较 
 
  
1）  DOM4J性能最好，连Sun的JAXM也在用DOM4J.目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J. 

 2）JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明 他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语 言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐（与基于非标准的Java模型相对），所以在某些类型的项目中可能也需要它（如在 javascript中使用DOM）。 

 3）SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。 
 
  
 
 
  
将XML保存到文件中
 
  
 
 
  
private Document newDocument() throws ParserConfigurationException {
 
  
        //1、创建DocumentBuilder工厂
 
  
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 
  
        //2、创建DocumentBuilder
 
  
        DocumentBuilder db;
 
  
        db = dbf.newDocumentBuilder();
 
  
       
 
  
        Document document = db.newDocument();
 
  
        document.setXmlVersion("1.0");
 
  
        Element element = document.createElement("users");
 
  
        document.appendChild(element);
 
  
        return document;
 
  
    }
 
  
   
 
  
    private void createXmlFile(Document document) throws TransformerConfigurationException, TransformerException {
 
  
        //1、创建转换工程
 
  
        TransformerFactory tf = TransformerFactory.newInstance();
 
  
        //2、创建DOM源
 
  
        DOMSource ds = new DOMSource(document);
 
  
        //3、新建一个文件用于存储XML
 
  
        File file = new File(fileName);
 
  
        if(!file.exists()) {
 
  
            try {
 
  
                file.createNewFile();
 
  
            } catch (IOException e) {
 
  
                e.printStackTrace();
 
  
            }
 
  
        }
 
  
        //将文件包装为结果
 
  
        StreamResult sr = new StreamResult(file);
 
  
        //转换
 
  
        tf.newTransformer().transform(ds,sr);
 
  
    }
 
  
   
 
  
    public void saveToXml() {
 
  
        Document document;
 
  
        try {
 
  
            document = newDocument();
 
  
            Element usersElement =
 
  
(Element) document.getElementsByTagName("users").item(0);
 
  
            for(UserModel um : userList) {
 
  
                Element userElement = document.createElement("user");
 
  
                Element uuidElement = document.createElement("uuid");
 
  
                Element nameElement = document.createElement("name");
 
  
                usersElement.appendChild(userElement);
 
  
                userElement.appendChild(uuidElement);
 
  
                userElement.appendChild(nameElement);
 
  
               
 
  
                uuidElement.setTextContent(String.valueOf(um.getUuid()));
 
  
                nameElement.setTextContent(um.getName());  
 
  
            }
 
  
            createXmlFile(document);
 
  
        } catch (Exception e) {
 
  
            e.printStackTrace();
 
  
        }
 
  
           
 
  
    }
 
  

 
  
java SAX方式：
 
  
 
  
package com.lai.chap7.sax;

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

import javax.xml.parsers.ParserConfigurationException;

import org.xml.sax.SAXException;

public class TestSax {

    public static void main(String[] args) throws ParserConfigurationException,
	SAXException, IOException {
    	
    	try{
    		
        SaxParseService sax = new SaxParseService(); 
        InputStream input = new FileInputStream("E:\\android\\eclipsWP\\laiAndroidTestJavaPrj\\src\\com\\lai\\chap7\\sax\\book.xml"); 
        List books = sax.getBooks(input); 
        for(Book book : books){ 
            System.out.println(book.toString()); 
        } 
        
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
    } 
}
 
  
 
  
 
  
 
  

 
  

 
  
 
  
package com.lai.chap7.sax;

import java.io.File;
import java.io.IOException;

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

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

public class SAXParserXMLDemo {

	public static void main(String[] args) throws ParserConfigurationException,
			SAXException, IOException {
		SAXParserFactory spf = SAXParserFactory.newInstance();// 创建SAX解析器工厂
		spf.setNamespaceAware(true);// 设置名称空间属性
		SAXParser sp = spf.newSAXParser();// 创建解析器
		// 开始解析
		sp.parse(new File("student.xml"),
				new DefaultHandler() {
					boolean isStudentId = false;// 是否是学号信息

					@Override
					public void startElement(String uri, String localName,
							String qName, Attributes attributes)
							throws SAXException {
						super.startElement(uri, localName, qName, attributes);
						if ("student_id".equals(localName))// 如果接收到的元素是student_id
						{
							isStudentId = true;// 标记这个是学号信息，在接收字符信息时需要输出学号
							System.out.print(localName + " : ");// 输出元素名称
						}
					}

					@Override
					public void characters(char[] ch, int start, int length)// 接收到字符信息
							throws SAXException {
						super.characters(ch, start, length);
						if (isStudentId)// 如果当前信息是学号
						{
							System.out.println(new String(ch, start, length));// 输出这个学号
						}
					}

					@Override
					public void endElement(String uri, String localName,
							String qName)// 元素终止
							throws SAXException {
						super.endElement(uri, localName, qName);
						isStudentId = false;// 标记当前元素不是学号
					}
				});
	}
}
 
  
 
  
 
  
 
  

 
  
 
  
 
 
     
        thinking in java 
        85.5 
     
     
        Spring in Action 
        39.0