xml小结

一、XML入门
1.XML概述
   XML(Extensible Markup Language):可扩展标记语言.
   XML和HTML都是标准通用标记语言(Standard Generalized Markup Language,SGML)的衍生语言.
   XML没有预定义标签.
   XML的应用：存储和传输复杂的关系模型数据
    在软件系统中，作为配置文件使用.
2.XML语法
   * 文档声明
       格式：<?xml version="1.0"?> 
       encoding:设置当前xml文档内容使用的编码.
       standalone:说明文档是否独立.
   * 元素
       格式：<x></x> 或者 <x />
       名称自定义:严格区分大小写，<P>和<p>是不同的标记
           不能以数字或"_"开头，建议以字母开头
           不能以xml或XML或Xml等开头
           不能包含空格，例<a b>
           不能包含冒号，例<a:b>
           注意：不能交叉嵌套
            有且仅有一个根标签.
   * 属性
         前提：在某元素的基础上，确定相应的属性.
         格式：<x attribute="attrValue" />
         注意：一个标签可以有多个属性，属性值要用双引号或单引号括起来.
   * 注释
         格式：<!--注释内容-->
   * CDATA区、特殊字符
         在xml文档中存放任意内容的区域
         格式：<![CDATA[ 存放的cdata内容，会以原样输出 ]]>
         转义字符：对于一些单个字符，若想显示原始样式，除了cdata也可以用转移的形式
         例如： 特殊字符   替代符号
              &  &amp;
              <  &lt;
              >  &gt;
              "  &quot;
              '  &apos;
            具体可查文档
   * 处理指令(processing instruction，PI)
         它是用来指挥解析引擎如何解析XML文档内容.
         处理指令必须以 <? 开头，以  ?> 作为结尾，XML声明语句就是最常见的一种处理指令.
         例如：引入css文件等
         格式：<?xml-stylesheet type="text/css" href="uri" ?>
        type:类型，内容是MIME类型，例 image/jpeg
        href:确定引用文件的位置
         uri:统一资源标识符 1.html  news/m.html
         url:统一资源定位符 http://www.fengjie.com/news/m.html
二、XML约束
1.概述
    XML约束：编写一个文档来约束一个xml文档的书写规范.
    常用的约束技术：    XML DTD(Document Type Definition)
                                     XML Schema
2.DTD约束
   （1）文档 关联
       * 内部关联
             即在xml文件内部书写DTD规范
             格式：<!DOCTYPE 根元素  [..具体规范内容..]>
       * 外部关联
             即引用的文件不在xml文件内部，而是在本地
             格式：在xml文件内写  <!DOCTYPE 根元素  SYSTEM "DTD文件的URL">
             例如：<!DOCTYPE books SYSTEM "book.dtd">
      * 公共关联
            即引用的文件不在本地
            格式：<DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文件的URL">
  （2）DTD约束语法
      * 元素
            格式：<!ELEMENT 元素名称  元素内容声明>
            注意：其中元素内容声明包含符号和数据类型两部分！
            符号：？ 0次或1次
                       *  >=0次
                       +  >=1次
                       ()  分组
                        |  选择
                       ,  顺序出现
            类型：#PCDATA 只能书写字符，不能包含子元素.注意书写格式：(#PCDATA)
                       EMPTY 元素内容为空
                      AND  元素内容任意
    * 属性
         格式：<!ATTLIST 元素名称
                         属性名  属性类型  约束
                         属性名  属性类型  约束
                          ...
                   >
         属性类型：CDATA  值为字符数据
                            ID  值为唯一的id
                            ()  选择
                          ..其他具体查看文档
        约束的四种形式：
             #REQUIRED  必须填写
             #IMPLIED  可选
             #FIXED value 固定值（value为自己设置的一个固定值）
             DefaultValue 默认值
   *实体（内部实体与外部实体，它们与关联方式无关）
    内部实体
        引用实体
             格式：<!ENTITY 实体名称  "实体内容">
             引用方式：&实体名称;  用在xml中
       参数实体
             格式：<!ENTITY % 实体名称  "实体内容">
             引用方式：%实体名称;  留给DTD文件本身使用的.
    外部实体
            格式：<!ENTITY 实体名称  SYSTEM "URI/URL">
            引用方式：&实体名称;  用在xml中
  （3）DTD约束代码示例

[html] view plain copy print ?

1. <?xml version="1.0" encoding="UTF-8"?> 
2. <!-- 文档内部关联DTD --> 
3. <!DOCTYPE NEWSPAPER [  
4.  
5. <!ELEMENT NEWSPAPER (ARTICLE+)> 
6. <!ELEMENT ARTICLE (HEADLINE,BYLINE,LEAD,BODY,NOTES)> 
7. <!ELEMENT HEADLINE (#PCDATA)> 
8. <!ELEMENT BYLINE (#PCDATA)> 
9. <!ELEMENT LEAD (#PCDATA)> 
10. <!ELEMENT BODY (#PCDATA)> 
11. <!ELEMENT NOTES (#PCDATA)> 
12.   
13. <!--#REQUIRED必须填写，#IMPLIED可以写可以不写--> 
14. <!ATTLIST ARTICLE AUTHOR CDATA #REQUIRED> 
15. <!ATTLIST ARTICLE EDITOR CDATA #IMPLIED> 
16. <!ATTLIST ARTICLE DATE CDATA #IMPLIED> 
17. <!ATTLIST ARTICLE EDITION CDATA #IMPLIED> 
18.  
19. <!--引用实体，用于xml文档中--> 
20. <!ENTITY NEWSPAPER "Vervet Logic Times"> 
21. <!ENTITY PUBLISHER "Vervet Logic Press"> 
22. <!ENTITY COPYRIGHT "Copyright 1998 Vervet Logic Press"> 
23.  
24. ]> 
25. <NEWSPAPER> 
26.     <ARTICLE AUTHOR="&PUBLISHER;" DATE="9.15"> 
27.         <HEADLINE>&NEWSPAPER;</HEADLINE> 
28.         <BYLINE>science fiction film</BYLINE> 
29.         <LEAD>...</LEAD> 
30.         <BODY>the file is very good</BODY> 
31.         <NOTES>©RIGHT;</NOTES> 
32.     </ARTICLE> 
33. </NEWSPAPER> 

			<?xml version="1.0" encoding="UTF-8"?>
			<!-- 文档内部关联DTD -->
			<!DOCTYPE NEWSPAPER [ 
			
			<!ELEMENT NEWSPAPER (ARTICLE+)>
			<!ELEMENT ARTICLE (HEADLINE,BYLINE,LEAD,BODY,NOTES)>
			<!ELEMENT HEADLINE (#PCDATA)>
			<!ELEMENT BYLINE (#PCDATA)>
			<!ELEMENT LEAD (#PCDATA)>
			<!ELEMENT BODY (#PCDATA)>
			<!ELEMENT NOTES (#PCDATA)>
			 
			<!--#REQUIRED必须填写，#IMPLIED可以写可以不写-->
			<!ATTLIST ARTICLE AUTHOR CDATA #REQUIRED>
			<!ATTLIST ARTICLE EDITOR CDATA #IMPLIED>
			<!ATTLIST ARTICLE DATE CDATA #IMPLIED>
			<!ATTLIST ARTICLE EDITION CDATA #IMPLIED>
			
			<!--引用实体，用于xml文档中-->
			<!ENTITY NEWSPAPER "Vervet Logic Times">
			<!ENTITY PUBLISHER "Vervet Logic Press">
			<!ENTITY COPYRIGHT "Copyright 1998 Vervet Logic Press">
			
			]>
			<NEWSPAPER>
				<ARTICLE AUTHOR="&PUBLISHER;" DATE="9.15">
					<HEADLINE>&NEWSPAPER;</HEADLINE>
					<BYLINE>science fiction film</BYLINE>
					<LEAD>...</LEAD>
					<BODY>the file is very good</BODY>
					<NOTES>©RIGHT;</NOTES>
				</ARTICLE>
			</NEWSPAPER>

3.Schema约束
  （1）在XML文档中引用Schema

[html] view plain copy print ?

1. <!--books.xsd内容如下：--> 
2. <?xml version="1.0" encoding="UTF-8"?> 
3. <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"  
4.     targetNamespace="http://www.example.org/books"  
5.     xmlns:tns="http://www.example.org/books"  
6.     elementFormDefault="qualified"> 
7.     ... 
8.     ... 
9. </xs:schema> 

			<!--books.xsd内容如下：-->
			<?xml version="1.0" encoding="UTF-8"?>
			<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
				targetNamespace="http://www.example.org/books" 
				xmlns:tns="http://www.example.org/books" 
				elementFormDefault="qualified">
				...
				...
			</xs:schema>

   解释：* xmlns（xml namespace）
      应用已有的命名空间，http://www.w3.org/2001/XMLSchema
          官方为自己的schema文档起的名称
      格式1：xmlns：别名
        xmlns：xs
        使用:xs:schema,从当前别名xs所代表的schema文档中定义了schema元素
      格式2：xmlns（默认命名空间引用）
    * targetNamespace
      为当前的schema文档命名，必须全球唯一，采用URL的形式

[html] view plain copy print ?

1. <!-- books.xml文档中的内容：--> 
2. <?xml version="1.0" encoding="UTF-8"?> 
3. <books  xmlns="http://www.example.org/books" 
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
5.     xsi:schemaLocation="http://www.example.org/books books.xsd"> 
6. </books> 

			<!-- books.xml文档中的内容：-->
			<?xml version="1.0" encoding="UTF-8"?>
			<books  xmlns="http://www.example.org/books"
				xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
				xsi:schemaLocation="http://www.example.org/books books.xsd">
			</books>

   解释：* xmlns="http://www.example.org/books"
      确定需要的schema文档的名称  
    * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      将当前xml文档实例化，这样才能使用schemaLocation属性确定其位置
    * xsi:schemaLocation="http://www.example.org/books books.xsd"
      通知xml解析器，自己文档的名称和位置，用空格隔开
  （2）代码示例（引用w3c中的示例）

[html] view plain copy print ?

1. <!-- shiporder.xml文档的内容：--> 
2. <?xml version="1.0" encoding="UTF-8"?> 
3. <shiporder orderid="889923" 
4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
5. xsi:noNamespaceSchemaLocation="shiporder.xsd"> 
6. <orderperson>George Bush</orderperson> 
7. <shipto> 
8.   <name>John Adams</name> 
9.   <address>Oxford Street</address> 
10.   <city>London</city> 
11.   <country>UK</country> 
12. </shipto> 
13. <item> 
14.   <title>Empire Burlesque</title> 
15.   <note>Special Edition</note> 
16.   <quantity>1</quantity> 
17.   <price>10.90</price> 
18. </item> 
19. <item> 
20.   <title>Hide your heart</title> 
21.   <quantity>1</quantity> 
22.   <price>9.90</price> 
23. </item> 
24. </shiporder> 
25.  
26. <!--schema文件内容：--> 
27.  
28. <?xml version="1.0" encoding="UTF-8"?> 
29. <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
30.  
31.     <!-- 简易元素的定义 --> 
32.     <xs:element name="orderperson" type="xs:string" /> 
33.     <xs:element name="name" type="xs:string" /> 
34.     <xs:element name="address" type="xs:string" /> 
35.     <xs:element name="city" type="xs:string" /> 
36.     <xs:element name="country" type="xs:string" /> 
37.     <xs:element name="title" type="xs:string" /> 
38.     <xs:element name="note" type="xs:string" /> 
39.     <xs:element name="quantity" type="xs:positiveInteger" /> 
40.     <xs:element name="price" type="xs:decimal" /> 
41.  
42.     <!-- 属性的定义 --> 
43.     <xs:attribute name="orderid" type="xs:string" /> 
44.  
45.     <!-- 复合元素的定义 --> 
46.     <xs:element name="shipto"> 
47.         <xs:complexType> 
48.             <xs:sequence> 
49.                 <xs:element ref="name" /> 
50.                 <xs:element ref="address" /> 
51.                 <xs:element ref="city" /> 
52.                 <xs:element ref="country" /> 
53.             </xs:sequence> 
54.         </xs:complexType> 
55.     </xs:element> 
56.     <xs:element name="item"> 
57.         <xs:complexType> 
58.             <xs:sequence> 
59.                 <xs:element ref="title" /> 
60.                 <xs:element ref="note" minOccurs="0" /> 
61.                 <xs:element ref="quantity" /> 
62.                 <xs:element ref="price" /> 
63.             </xs:sequence> 
64.         </xs:complexType> 
65.     </xs:element> 
66.  
67.     <xs:element name="shiporder"> 
68.         <xs:complexType> 
69.             <xs:sequence> 
70.                 <xs:element ref="orderperson" /> 
71.                 <xs:element ref="shipto" /> 
72.                 <xs:element ref="item" maxOccurs="unbounded" /> 
73.             </xs:sequence> 
74.             <xs:attribute ref="orderid" use="required" /> 
75.         </xs:complexType> 
76.     </xs:element> 
77.  
78. </xs:schema> 

			<!-- shiporder.xml文档的内容：-->
			<?xml version="1.0" encoding="UTF-8"?>
			<shiporder orderid="889923"
			xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
			xsi:noNamespaceSchemaLocation="shiporder.xsd">
			 <orderperson>George Bush</orderperson>
			 <shipto>
			  <name>John Adams</name>
			  <address>Oxford Street</address>
			  <city>London</city>
			  <country>UK</country>
			 </shipto>
			 <item>
			  <title>Empire Burlesque</title>
			  <note>Special Edition</note>
			  <quantity>1</quantity>
			  <price>10.90</price>
			 </item>
			 <item>
			  <title>Hide your heart</title>
			  <quantity>1</quantity>
			  <price>9.90</price>
			 </item>
			</shiporder>
			
			<!--schema文件内容：-->
			
			<?xml version="1.0" encoding="UTF-8"?>
			<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
			
				<!-- 简易元素的定义 -->
				<xs:element name="orderperson" type="xs:string" />
				<xs:element name="name" type="xs:string" />
				<xs:element name="address" type="xs:string" />
				<xs:element name="city" type="xs:string" />
				<xs:element name="country" type="xs:string" />
				<xs:element name="title" type="xs:string" />
				<xs:element name="note" type="xs:string" />
				<xs:element name="quantity" type="xs:positiveInteger" />
				<xs:element name="price" type="xs:decimal" />
			
				<!-- 属性的定义 -->
				<xs:attribute name="orderid" type="xs:string" />
			
				<!-- 复合元素的定义 -->
				<xs:element name="shipto">
					<xs:complexType>
						<xs:sequence>
							<xs:element ref="name" />
							<xs:element ref="address" />
							<xs:element ref="city" />
							<xs:element ref="country" />
						</xs:sequence>
					</xs:complexType>
				</xs:element>
				<xs:element name="item">
					<xs:complexType>
						<xs:sequence>
							<xs:element ref="title" />
							<xs:element ref="note" minOccurs="0" />
							<xs:element ref="quantity" />
							<xs:element ref="price" />
						</xs:sequence>
					</xs:complexType>
				</xs:element>
			
				<xs:element name="shiporder">
					<xs:complexType>
						<xs:sequence>
							<xs:element ref="orderperson" />
							<xs:element ref="shipto" />
							<xs:element ref="item" maxOccurs="unbounded" />
						</xs:sequence>
						<xs:attribute ref="orderid" use="required" />
					</xs:complexType>
				</xs:element>
			
			</xs:schema>

     
三、XML解析技术概述
1.XML解析方式
  dom:（Document Object Model,即文档对象模型）是W3C组织推荐的方式，但它是把整个文档对象放入内存，如果文档太大会导致溢出.
  sax:（Simple API for XML）不是官方标准，但它是xml社区事实上的标准，几乎所有的xml解析器都支持它，是事件驱动型，解决了可能的溢出问题，但只支持I操作.
2.XML解析器
  Crimson（sun）、Xerces（IBM）、Aelfred2（dom4j）
4.XML解析开发包
  Jaxp（sun）、Jdom、dom4j、pull（android的sdk自带）
  其中jaxp指（Java API for XML processing）
四、XML解析示例
     ----------------------
  声明：books.xml中的内容为：
  <?xml version="1.0" encoding="UTF-8"?>
  <books>
   <book id="001">
    <title>Java Core</title>
    <price>20</price>
   </book>
   <book id="002">
    <title>中文试一下</title>
    <price>30</price>
   </book>
  </books>
-----------------------
1.dom4j解析
注意：使用dom4j开发，需要下载dom4j相应的jar文件.
  如果其中用到XPath表达式，则需要导入jaxen-1.1-beta-6.jar.
  （1）IO操作
   I: SAXReader reader = new SAXReader();
    Document document = reader.read("file.xml"); 
   O: FileOutputStream fos = new FileOutputStream("file.dom4j.xml");
    XMLWriter writer = new XMLWriter();
    writer.write(document);
    writer.close();
  （2）获取Document的三种方式
   a:读取XML文件，获得document对象，上边的I操作.
   b:解析XML形式的文本，得到document对象.
    String text = "<books><book></book></books>";
    Document document = DocumentHelper.parseText(text);
   c:主动创建document对象.
    Document document = DocumentHelper.createDocument();
    //创建根节点 books(名字随意)
    Element root = document.addElement("books");
  （3）常用API
   * 获得根元素
    Element rootElement = document.getRootElement();
   * 获得所有的子元素
    List list = rootElement.elements();
   * 获得指定的子元素
    Element priceElement = bookElement.element("price");
   * 获得指定属性的元素(用到XPath表达式)
    Node bookNode = document.selectSingleNode("//book[@id='b002']");
   * 设置文本
    priceElement.setText("100");
   * 获得节点的名称
    child.getName();
   * 获得指定名称的属性值
    String id = bookElement.attributeValue("id");
   * 在某节点下添加子节点
    Element ageEle = bookElement.addElement("title");
   * 删除某节点(//childElement是待删除节点，parentElement是其父节点)
    parentElement.remove(childElement);
   * 获得某节点下的某属性
    Attribute attribute = rootElement.attribute("id");
   * 获得属性的文字
    String text = attribute.getText();
2.dom4j代码示例

[java] view plain copy print ?

1. import java.io.FileOutputStream; 
2.  
3. import org.dom4j.Attribute; 
4. import org.dom4j.Document; 
5. import org.dom4j.DocumentHelper; 
6. import org.dom4j.Element; 
7. import org.dom4j.Node; 
8. import org.dom4j.io.SAXReader; 
9. import org.dom4j.io.XMLWriter; 
10. //演示Dom4j中的CURD(create update read delete) 
11. public class Demo { 
12.  
13.     public static void main(String[] args) throws Exception { 
14.         //读取指定文件获取Document 
15.         SAXReader reader = new SAXReader(); 
16.         Document document = reader.read("books.xml"); 
17.          
18.         //create(document); 
19.         //update(document); 
20.         //delete(document); 
21.          
22.         //将文档写入XML文件 
23.         FileOutputStream fos = new FileOutputStream("books.dom4j.xml"); 
24.         XMLWriter writer = new XMLWriter(fos); 
25.         writer.write(document); 
26.         writer.close(); 
27.     } 
28.     public static void create(Document document) { 
29.         Element rootElement = document.getRootElement();//获取根节点 
30.         //添加id属性 
31.         Element newBook = DocumentHelper.createElement("book");//创建新元素 
32.         Attribute id = DocumentHelper.createAttribute(newBook, "id", "003"); 
33.         newBook.add(id); 
34.         //添加title元素 
35.         Element newTitle = DocumentHelper.createElement("title"); 
36.         newTitle.setText("News"); 
37.         newBook.add(newTitle); 
38.         //把创建的newBook添加进根节点 
39.         rootElement.add(newBook); 
40.     } 
41.     public static void update(Document document) { 
42.         //将id为002的book节点中的加个修改为444 
43.         Node bookNode = document.selectSingleNode("//book[@id='002']");//XPath表达式 
44.         Element bookElement = (Element)bookNode;//Node中没有适当方法，转换为Element 
45.         Element priceElement = bookElement.element("price");//获取price元素 
46.         priceElement.setText("444");//修改 
47.     } 
48.     public static void delete(Document document) { 
49.         //删除id为001的book节点 
50.         Node bookNode = document.selectSingleNode("//book[@id='001']"); 
51.         Element parent = bookNode.getParent();//获取要删除元素的父级元素 
52.         parent.remove(bookNode); 
53.     } 
54. } 

		import java.io.FileOutputStream;

		import org.dom4j.Attribute;
		import org.dom4j.Document;
		import org.dom4j.DocumentHelper;
		import org.dom4j.Element;
		import org.dom4j.Node;
		import org.dom4j.io.SAXReader;
		import org.dom4j.io.XMLWriter;
		//演示Dom4j中的CURD(create update read delete)
		public class Demo {
		
			public static void main(String[] args) throws Exception {
				//读取指定文件获取Document
				SAXReader reader = new SAXReader();
				Document document = reader.read("books.xml");
				
				//create(document);
				//update(document);
				//delete(document);
				
				//将文档写入XML文件
				FileOutputStream fos = new FileOutputStream("books.dom4j.xml");
				XMLWriter writer = new XMLWriter(fos);
				writer.write(document);
				writer.close();
			}
			public static void create(Document document) {
				Element rootElement = document.getRootElement();//获取根节点
				//添加id属性
				Element newBook = DocumentHelper.createElement("book");//创建新元素
				Attribute id = DocumentHelper.createAttribute(newBook, "id", "003");
				newBook.add(id);
				//添加title元素
				Element newTitle = DocumentHelper.createElement("title");
				newTitle.setText("News");
				newBook.add(newTitle);
				//把创建的newBook添加进根节点
				rootElement.add(newBook);
			}
			public static void update(Document document) {
				//将id为002的book节点中的加个修改为444
				Node bookNode = document.selectSingleNode("//book[@id='002']");//XPath表达式
				Element bookElement = (Element)bookNode;//Node中没有适当方法，转换为Element
				Element priceElement = bookElement.element("price");//获取price元素
				priceElement.setText("444");//修改
			}
			public static void delete(Document document) {
				//删除id为001的book节点
				Node bookNode = document.selectSingleNode("//book[@id='001']");
				Element parent = bookNode.getParent();//获取要删除元素的父级元素
				parent.remove(bookNode);
			}
		}

3.JAXP-DOM解析XML
  （1）IO操作
   I： DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    Document document = builder.parse("file.xml");
   O： TransformerFactory factory = TransformerFactory.newInstance();
    Transformer transformer = factory.newTransformer();
    //将document封装到Source
    Source xmlsource = new DOMSource(document);
    //将file.dom.xml路径封装到Result
    Result outputTarget = new StreamResult("file.dom.xml");
    transformer.transform(xmlSource, outputTarget);
  （2）常用API
   * 获取指定标签的所有元素
    NodeList bookElements = document.getElementsByTagName("book");
   * 获得上边NodeList的长度
    bookElements.getLength();
   * 获得指定索引的节点对象
    bookElements.item(index);
   * 获得当前元素的所有子节点
    NodeList childList = element.getChildNodes();//element为当前元素名称
   * 通过元素获得当前元素指定的属性
    element.getAttribute("id");//element为当前元素名称
   * 获得当前节点的名称
    node.getNodeName();//node为当前节点名称
   * 获得当前节点的子节点的所有文本
    node.getTextContent();
    例如：<book><title>Java</title></book> 获取book节点的子节点的所有文本
    结果:"<title>Java</title>"
   * 返回这个节点的第一个子节点
    getFirstChild();
   * 返回这个节点的父节点对象
    getParentNode();
   * 为这个节点添加一个子节点，并放在所有字节点的最后，如果这个子节点已经存在，则先把它删掉再添加进去.
    appendChild();
   * 删除给定的子节点对象
    removeChild();
  （3）DOM代码示例

[java] view plain copy print ?

1. import javax.xml.parsers.DocumentBuilder; 
2. import javax.xml.parsers.DocumentBuilderFactory; 
3. import javax.xml.transform.Result; 
4. import javax.xml.transform.Source; 
5. import javax.xml.transform.Transformer; 
6. import javax.xml.transform.TransformerFactory; 
7. import javax.xml.transform.dom.DOMSource; 
8. import javax.xml.transform.stream.StreamResult; 
9. import org.w3c.dom.Document; 
10. import org.w3c.dom.Element; 
11. import org.w3c.dom.NodeList; 
12.  
13. public class Demo2 { 
14.  
15.     public static void main(String[] args) throws Exception { 
16.         //获取document 
17.         DocumentBuilderFactory factory1 = DocumentBuilderFactory.newInstance(); 
18.         DocumentBuilder builder = factory1.newDocumentBuilder(); 
19.         Document document = builder.parse("books.xml"); 
20.          
21.         //delete(document); 
22.         //create(document); 
23.          
24.         //保存 
25.         TransformerFactory factory2 = TransformerFactory.newInstance(); 
26.         Transformer transformer = factory2.newTransformer(); 
27.         Source xmlSource = new DOMSource(document); 
28.         Result outputTarget = new StreamResult("books.jaxp.xml"); 
29.         transformer.transform(xmlSource, outputTarget); 
30.     } 
31.     public static void create(Document document) { 
32.         //新建元素 
33.         Element newBook = document.createElement("book"); 
34.         Element newTitle = document.createElement("title"); 
35.         Element newPrice = document.createElement("price"); 
36.         //设置元素内容或属性 
37.         newTitle.setTextContent("Thinking in Java！"); 
38.         newPrice.setTextContent("99"); 
39.         newBook.setAttribute("id", "004"); 
40.         //关联 
41.         newBook.appendChild(newTitle); 
42.         newBook.appendChild(newPrice); 
43.         document.getDocumentElement().appendChild(newBook); 
44.          
45.     } 
46.     public static void delete(Document document) { 
47.         NodeList list = document.getElementsByTagName("book"); 
48.         for(int i = 0; i < list.getLength(); i++) { 
49.             //获取每一本书 
50.             Element element = (Element)list.item(i); 
51.             if("001".equals(element.getAttribute("id"))){ 
52.                 //获取根节点，即book元素的父节点，用来删除book 
53.                 Element rootElement = document.getDocumentElement(); 
54.                 rootElement.removeChild(element); 
55.             } 
56.         } 
57.     } 
58. } 

			import javax.xml.parsers.DocumentBuilder;
			import javax.xml.parsers.DocumentBuilderFactory;
			import javax.xml.transform.Result;
			import javax.xml.transform.Source;
			import javax.xml.transform.Transformer;
			import javax.xml.transform.TransformerFactory;
			import javax.xml.transform.dom.DOMSource;
			import javax.xml.transform.stream.StreamResult;
			import org.w3c.dom.Document;
			import org.w3c.dom.Element;
			import org.w3c.dom.NodeList;
			
			public class Demo2 {
			
				public static void main(String[] args) throws Exception {
					//获取document
					DocumentBuilderFactory factory1 = DocumentBuilderFactory.newInstance();
					DocumentBuilder builder = factory1.newDocumentBuilder();
					Document document = builder.parse("books.xml");
					
					//delete(document);
					//create(document);
					
					//保存
					TransformerFactory factory2 = TransformerFactory.newInstance();
					Transformer transformer = factory2.newTransformer();
					Source xmlSource = new DOMSource(document);
					Result outputTarget = new StreamResult("books.jaxp.xml");
					transformer.transform(xmlSource, outputTarget);
				}
				public static void create(Document document) {
					//新建元素
					Element newBook = document.createElement("book");
					Element newTitle = document.createElement("title");
					Element newPrice = document.createElement("price");
					//设置元素内容或属性
					newTitle.setTextContent("Thinking in Java！");
					newPrice.setTextContent("99");
					newBook.setAttribute("id", "004");
					//关联
					newBook.appendChild(newTitle);
					newBook.appendChild(newPrice);
					document.getDocumentElement().appendChild(newBook);
					
				}
				public static void delete(Document document) {
					NodeList list = document.getElementsByTagName("book");
					for(int i = 0; i < list.getLength(); i++) {
						//获取每一本书
						Element element = (Element)list.item(i);
						if("001".equals(element.getAttribute("id"))){
							//获取根节点，即book元素的父节点，用来删除book
							Element rootElement = document.getDocumentElement();
							rootElement.removeChild(element);
						}
					}
				}
			}

4.JAXP-SAX解析XML
  （1）SAX解析概述
   SAX是事件驱动的XML处理方法，它逐行扫描文档，一边扫描一边解析.
   在I操作时会用到DefaultHandler类，需要定义自定义类继承此类，并实现需要的方法.
   DefaultHandler默认的是空实现.
  （2）SAX解析需要用到的方法
   * startDocument: 文档开始
   * startElement: 元素开始
    uri: 名称空间URI，如果元素没有则为空字符串.
    localName: 本地名称，如果没有名称空间，则为空字符串.
    qName： 限定的名称.
    attributes: 附加到元素的属性.
   * characters: 文本
    通过new String(ch, start, length)获得字符串.
   * endElement： 元素结束
   * endDocument: 文档结束
   还有很多方法，可以查看API文档，如果需要可以在自定义类中覆盖未实现的方法.
  
  （3）SAX解析的I操作代码示例

[java] view plain copy print ?

1. import javax.xml.parsers.SAXParser; 
2. import javax.xml.parsers.SAXParserFactory; 
3. import org.xml.sax.helpers.DefaultHandler; 
4.  
5. public class Demo3 { 
6.     public static void main(String[] args) throws Exception { 
7.         SAXParserFactory factory = SAXParserFactory.newInstance(); 
8.         SAXParser parser = factory.newSAXParser(); 
9.         //这里需要编写自定义处理事件  
10.         DefaultHandler dh = new MyDefaultHandler(); 
11.         parser.parse("books.xml", dh); 
12.     } 
13. } 
14. ------------------------- 
15. //自定义类 
16. import org.xml.sax.Attributes; 
17. import org.xml.sax.SAXException; 
18. import org.xml.sax.helpers.DefaultHandler; 
19.  
20. public class MyDefaultHandler extends DefaultHandler{ 
21.      
22.     @Override 
23.     public void startDocument() throws SAXException { 
24.         System.out.println("文档开始"); 
25.     } 
26.     @Override 
27.     /**
28.      * 如果xml文件使用了schema约束 <xs:element>
29.      *   * uri:schema -- targetNameSpace  
30.      *   * localName--element
31.      *   * qName---xs:element
32.      * 如果不使用
33.      *   * uri:null
34.      *   * localName:null
35.      *   * qName : element
36.      * Attributes:当前元素的所有的属性的集合
37.      */ 
38.     public void startElement(String uri, String localName, String qName, 
39.             Attributes attributes) throws SAXException { 
40.         System.out.println("元素开始" + qName + " *** " + attributes.getValue("id")); 
41.     } 
42.     @Override 
43.     public void characters(char[] ch, int start, int length) 
44.             throws SAXException { 
45.         System.out.println(new String(ch ,start, length)); 
46.     } 
47.     @Override 
48.     public void endElement(String uri, String localName, String qName) 
49.             throws SAXException { 
50.         System.out.println("元素结束：" + qName); 
51.     } 
52.     @Override 
53.     public void endDocument() throws SAXException { 
54.         System.out.println("文档结束"); 
55.     } 
56. } 

			import javax.xml.parsers.SAXParser;
			import javax.xml.parsers.SAXParserFactory;
			import org.xml.sax.helpers.DefaultHandler;
			
			public class Demo3 {
				public static void main(String[] args) throws Exception {
					SAXParserFactory factory = SAXParserFactory.newInstance();
					SAXParser parser = factory.newSAXParser();
					//这里需要编写自定义处理事件 
					DefaultHandler dh = new MyDefaultHandler();
					parser.parse("books.xml", dh);
				}
			}
			-------------------------
			//自定义类
			import org.xml.sax.Attributes;
			import org.xml.sax.SAXException;
			import org.xml.sax.helpers.DefaultHandler;
			
			public class MyDefaultHandler extends DefaultHandler{
				
				@Override
				public void startDocument() throws SAXException {
					System.out.println("文档开始");
				}
				@Override
				/**
				 * 如果xml文件使用了schema约束 <xs:element>
				 * 	 * uri:schema -- targetNameSpace   
				 *   * localName--element
				 *   * qName---xs:element
				 * 如果不使用
				 *   * uri:null
				 *   * localName:null
				 *   * qName : element
				 * Attributes:当前元素的所有的属性的集合
				 */
				public void startElement(String uri, String localName, String qName,
						Attributes attributes) throws SAXException {
					System.out.println("元素开始" + qName + " *** " + attributes.getValue("id"));
				}
				@Override
				public void characters(char[] ch, int start, int length)
						throws SAXException {
					System.out.println(new String(ch ,start, length));
				}
				@Override
				public void endElement(String uri, String localName, String qName)
						throws SAXException {
					System.out.println("元素结束：" + qName);
				}
				@Override
				public void endDocument() throws SAXException {
					System.out.println("文档结束");
				}
			}

 

原文地址：http://blog.youkuaiyun.com/wyply115/article/details/7990210