zoukankan      html  css  js  c++  java

  • JavaEE实战——XML文档DOM、SAX、STAX解析方式详解

    原

    JavaEE实战——XML文档DOM、SAX、STAX解析方式详解

    2016年06月22日 23:10:35 阅读数：3445 
    													<span class="tags-box artic-tag-box">
							<span class="label">标签：</span>
															<a data-track-click="{&quot;mod&quot;:&quot;popu_626&quot;,&quot;con&quot;:&quot;DOM&quot;}" class="tag-link" href="http://so.csdn.net/so/search/s.do?q=DOM&amp;t=blog" target="_blank">DOM																</a><a data-track-click="{&quot;mod&quot;:&quot;popu_626&quot;,&quot;con&quot;:&quot;SAX&quot;}" class="tag-link" href="http://so.csdn.net/so/search/s.do?q=SAX&amp;t=blog" target="_blank">SAX																</a><a data-track-click="{&quot;mod&quot;:&quot;popu_626&quot;,&quot;con&quot;:&quot;STAX&quot;}" class="tag-link" href="http://so.csdn.net/so/search/s.do?q=STAX&amp;t=blog" target="_blank">STAX																</a><a data-track-click="{&quot;mod&quot;:&quot;popu_626&quot;,&quot;con&quot;:&quot;JAXP&quot;}" class="tag-link" href="http://so.csdn.net/so/search/s.do?q=JAXP&amp;t=blog" target="_blank">JAXP																</a><a data-track-click="{&quot;mod&quot;:&quot;popu_626&quot;,&quot;con&quot;:&quot;XML Pull&quot;}" class="tag-link" href="http://so.csdn.net/so/search/s.do?q=XML Pull&amp;t=blog" target="_blank">XML Pull																</a>
						<span class="article_info_click">更多</span></span>
																				<div class="tags-box space">
							<span class="label">个人分类：</span>
															<a class="tag-link" href="https://blog.csdn.net/zhongkelee/article/category/6278290" target="_blank">JavaEE																</a>
						</div>
																							</div>
			<div class="operating">
													</div>
		</div>
	</div>
</div>
<article>
	<div id="article_content" class="article_content clearfix csdn-tracking-statistics" data-pid="blog" data-mod="popu_307" data-dsm="post">
							<div class="article-copyright">
				版权声明：本文为博主原创文章，未经博主允许不得转载。					https://blog.csdn.net/zhongkelee/article/details/51737710				</div>
							            <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-f76675cdea.css">
					<div class="htmledit_views">

    前言

        本文接着上一篇博客进行XML文档解析处理语法的介绍。在上一篇博客XML语法中我们提到了，XML技术在企业中主要应用在存储、传输数据和作为框架的配置文件这两块领域。本博客介绍的技术主要就是应用在通过XML进行存储和传输数据这一块。大致分为：JAXP DOM 解析、JAXP SAX 解析、XML PULL 进行 STAX 解析这三个方面。

    简介

    使用xml 存储和传输数据

    1、通过程序生成xml
    2、读取xml中数据 ---- xml 解析

    XML解析方式有三种：DOM、SAX、StAX

    三种解析方式对应着三种解析思想，表述如下。

    什么是DOM、SAX、StAX ？

    DOM Document Object Model ----- 文档对象模型 
    DOM思想： 将整个xml 加载内存中，形成文档对象，所有对xml操作都对内存中文档对象进行
    DOM 是官方xml解析标准
    * 所以DOM是所有开发语言都支持的 ---- Java、JavaScript 都支持DOM

    SAX Simple API for XML ----- XML 简单 API 

    程序员为什么发明sax解析方式？？ 当xml 文档非常大，不可能将xml所有数据加载到内存 
    SAX 思想：一边解析 ，一边处理，一边释放内存资源 ---- 不允许在内存中保留大规模xml 数据

    StAX The Stream API for XML ----- XML 流 API ---- JDK6.0新特性
    STAX 是一种 拉模式 XML 解析方式，SAX 是一种 推模式 XML 解析方式（SAX性能不如STAX，STAX技术较新）

    注解：
    推push模式：由服务器为主导，向客户端主动发送数据( 推送 )
    拉pull模式: 由客户端为主导，主动向服务器申请数据( 轮询 )

    三种解析开发包

    掌握了三种思想后，程序员在实际开发中，使用已经开发好工具包 ----- JAXP 、DOM4j 、XML PULL

    注解：
    解析方式 与 解析开发包 关系？

    解析方式是解析xml 思想，没有具体代码

    解析开发包是解析xml思想具体代码实现。

    JAXP 是sun官方推出实现技术 同时支持 DOM SAX STAX
    DOM4j 是开源社区开源框架  支持 DOM 解析方式
    XML PULL Android 移动设备内置xml 解析技术 支持 STAX 解析方式

    DOM和SAX/STAX区别

    |--DOM 支持回写
          |--会将整个XML载入内存，以树形结构方式存储
          |--XML比较复杂的时候，或者当你需要随机处理文档中数据的时候不建议使用
    |--SAX/STAX
          |--相比DOM是一种更为轻量级的方案
          |--采用穿行方法读取 -- 文件输入流(字节、字符)读取
          |--编程较为复杂
          |--无法再读取过程中修改XML数据
    注意：
    当SAX和STAX 读取xml数据时，如果读取到内存数据不释放 ----- 内存中将存在整个xml文档数据（这种情况下就类似DOM 可以支持修改和回写）

    DOM、SAX、STAX 在实际开发中选择？

    在javaee日常开发中 ---- 优先使用DOM （编程简单）
    当xml 文档数据非常多，不可能使用DOM ---造成内存溢出  ------ 优先使用STAX 
    移动开发 使用 STAX ---- Android XML PULL 

    JAXP DOM 解析

    JAXP开发包简介

    JAXP(Java API for XML Processing)：
        DOM、SAX、STAX 只是XML解析方式，没有API
        JAXP是 Sun 提供的一套XML解析API，它很好的支持DOM和SAX解析方式，JDK6.0开始支持STAX解析方式，JAXP 开发包是JavaSE的一部分，它由javax.xml、org.w3c.dom 、org.xml.sax 包及其子包组成，在 javax.xml.parsers 包中，定义了几个工厂类，程序员调用这些工厂类，可以得到对xml文档进行解析的 DOM 或 SAX 的解析器对象。

    JAXP 开发 进行 xml解析 软件包： 
    javax.xml.parsers  存放 DOM 和 SAX 解析器 
    javax.xml.stream  存放 STAX 解析相关类 
    org.w3c.dom 存放DOM解析时 数据节点类
    org.xml.sax 存放SAX解析相关工具类

    DOM解析模型

    DOM 是以层次结构组织的节点或信息片断的集合，是 XML 数据的一种树型表示
    XML文档中所有的元素、属性、文本都会被解析成node节点 ---- 从而在内存中形成XML文档树型模型 ---- 所有的解析操作都围绕着这个模型进行
    (属性节点不属于任何节点的父节点或者子节点！)
    节点之间关系：parent、children、sibling(兄弟)


    DOM 解析快速入门

    1、创建 xml 文档 books.xml 
    在企业实际开发中，为了简化xml 生成和解析 ---- xml 数据文件通常不使用约束的

    2、使用DOM解析xml 
    将整个xml文档加载到内存中 ： 工厂 --- 解析器 ---解析加载 

    1. DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();//工厂
    2. DocumentBuilder builder = builderFactory.newDocumentBuilder();//解析器
    3. Document document = builder.parse("books.xml");//装载进内存

    3、Document通过 getElementsByTagName("")  获得 指定标签的节点集合 NodeList 

    通过 NodeList 提供 getLength 和 item遍历 节点集合
    1. 遍历ArrayList
    2. for (int i=0;i<arraylist.size();i++){
    3.    arraylist.get(i);
    4. }
    5.  
    6. 遍历NodeList
    7. for (int i=0;i<nodelist.getLength();i++){
    8.   nodelist.item(i);  ----- 将遍历的每个节点转换子接口类型
    9. }

    什么是 Node? 

    对于xml 来说，xml所有数据都是node节点 （元素节点、属性节点、文本节点、注释节点、CDATA节点、文档节点）

    Element Attr Text Comment CDATASection Document  ----- 都是 Node 子接口

    、Node对象提供了一系列常量来代表节点的类型（查看org.w3c.dom.Node接口源码）：


    当开发人员获得某个Node类型后，就可以把Node节点转换成相应的节点对象（Element、Attr、Text）。

    注解：

    node有三个通用API ： 
          |--getNodeName()：返回节点的名称
          |--getNodeType()：返回节点的类型 ---- ELEMENT_NODE=1、ATTRIBUTE_NODE=2、TEXT_NODE=3
          |--getNodeValue()：返回节点的值  ---- 所有元素节点value都是 null

    另外，对于元素节点ELEMENT来说：

    |--获得元素节点中的属性值
          |--element.getAttribute(属性名称)
    |--获得元素节点内部文本内容
          |--element.getTextContent()
          |--element.getFirstChild().getNodeValue()

    代码示例：

    books.xml：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <books>
    3. 	<book>
    4. 		<name>java编程基础</name>
    5. 		<price>80</price>
    6. 	</book>
    7. 	<book>
    8. 		<name>java高级应用</name>
    9. 		<price>100</price>
    10. 	</book>
    11. </books>

    测试程序：

    1. package cn.itcast.dom.jaxp;
    2.  
    3. import java.io.File;
    4. import java.io.IOException;
    5.  
    6. import javax.xml.parsers.DocumentBuilder;
    7. import javax.xml.parsers.DocumentBuilderFactory;
    8. import javax.xml.transform.dom.DOMSource;
    9. import javax.xml.transform.stream.StreamResult;
    10.  
    11. import org.junit.Test;
    12. import org.w3c.dom.Document;
    13. import org.w3c.dom.Element;
    14. import org.w3c.dom.Node;
    15. import org.w3c.dom.NodeList;
    16.  
    17. public class DOMTest {
    18. 	@Test
    19. 	// 查询 java编程基础 书 售价
    20. 	public void demo3() throws Exception {
    21. 		// 装载xml 加载内存 --- Document对象
    22. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    23. 				.newInstance();
    24. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    25. 		Document document = builder.parse("books.xml");
    26.  
    27. 		// 利用全局查询 锁定 每个name节点
    28. 		NodeList nodelist = document.getElementsByTagName("name");
    29. 		for (int i = 0; i < nodelist.getLength(); i++) {
    30. 			Element name = (Element) nodelist.item(i);
    31. 			if (name.getTextContent().equals("java编程基础")) {
    32. 				// 图书 找到了
    33. 				// price 是 name 节点 兄弟的兄弟,三个换行符也是子节点
    34. 				Element price = (Element) name.getNextSibling()
    35. 						.getNextSibling();
    36. 				System.out.println(price.getTextContent());
    37. 			}
    38. 		}
    39. 	}
    40.  
    41. 	@Test
    42. 	// 查询 java编程基础 书 售价
    43. 	public void demo2() throws Exception {
    44. 		// 装载xml 加载内存 --- Document对象
    45. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    46. 				.newInstance();
    47. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    48. 		Document document = builder.parse("books.xml");
    49.  
    50. 		// 全局查询 作为程序 切入
    51. 		NodeList nodelist = document.getElementsByTagName("book");
    52. 		// 遍历 强制转换 Element
    53. 		for (int i = 0; i < nodelist.getLength(); i++) {
    54. 			Element book = (Element) nodelist.item(i);
    55. 			// 找 哪个 book 节点 当中 name 节点值 java编程基础 ---- 查找book的name 子节点
    56. 			NodeList chidren = book.getChildNodes();
    57. 			//System.out.println(chidren.getLength());//注意:回车、空格也是子元素
    58. 			Element name = (Element) chidren.item(1); // book的第二个子节点就是name
    59. 			if (name.getTextContent().equals("java编程基础")) {
    60. 				// 当前for循环 这本书 是目标图书
    61. 				// 打印图书价格 price 是 book 第四个子节点
    62. 				Element price = (Element) chidren.item(3);
    63. 				System.out.println(price.getTextContent());
    64. 			}
    65. 		}
    66. 	}
    67.  
    68. 	@Test
    69. 	public void demo1() throws Exception {
    70. 		// 通过DOM 解析 XML --- 载入整个xml 工厂 -- 解析器 --- 加载
    71.  
    72. 		// 构造工厂
    73. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    74. 				.newInstance();
    75. 		// 通过工厂 获得解析器
    76. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    77.  
    78. 		// 使用解析器 加载 xml文档
    79. 		Document document = builder.parse("books.xml");
    80.  
    81. 		// Document代表整个xml 文档，通过操作Document，操作xml数据
    82.  
    83. 		// 将所有图书名称打印出来
    84. 		// 这里 nodelist 代表节点的集合
    85. 		// 查询所有 name标签
    86. 		NodeList nodelist = document.getElementsByTagName("name");
    87. 		// 遍历集合中 所有 node
    88. 		System.out.println("图书name节点数量：" + nodelist.getLength());
    89. 		for (int i = 0; i < nodelist.getLength(); i++) {
    90. 			// 获得每个 node 节点
    91. 			Node node = nodelist.item(i); // 这里每个node 都是 <name></name> ---- 元素
    92. 			Element e = (Element) node; // 将 节点转换为 子类型 节点
    93. 			System.out.println(e.getNodeName()); // 节点元素名称
    94. 			System.out.println(e.getNodeType()); // 节点元素 类型
    95. 			System.out.println(e.getNodeValue()); // 节点元素 值
    96. 			// 输出 name 元素 子节点文本节点值
    97. 			System.out.println(e.getFirstChild().getNodeValue());
    98. 			System.out.println(e.getTextContent());
    99. 			System.out.println("------------------------------------");
    100. 		}
    101. 	}
    102. }

    DOM 编程思路小结

    1、装载XML文档 ---- Document (工厂--解析器--解析加载)

    2、Document 获得指定元素 ----- getElementsByTagName （返回 NodeList）
    3、遍历NodeList 获得 每个 Node
    4、将每个Node 强制转换 Element 
    5、通过元素节点API 操作属性和文本内容 
          |--getAttribute  获得属性值
          |--getTextContent 获得元素内部文本内容

    这其中，第一步是固定套路：

    1. DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();//工厂
    2. DocumentBuilder builder = builderFactory.newDocumentBuilder();//解析器
    3. Document document = builder.parse("books.xml");//装载进内存

    DOM的增删改查 ---- CURD

    XML元素查询

    节点对象的查询总结：

        先用全局查找锁定范围，再用相对关系查找 得到需要数据。

    |--全局查找元素节点
          |--document.getElementByTagName
          |--document.getElementById( 需要带约束的XML)
    |--相对节点位置查找节点
          |--getChildNodes()：返回这个节点的所有子节点列表
          |--getFirstChild()：返回这个节点的第一个子节点
          |--getParentNode()：返回这个节点的父节点对象
          |--getNextSibling()：返回这个节点的下一个兄弟节点(注意空白也是节点)
          |--getPreviousSibling()：返回这个节点的前一个兄弟节点

    注意：getElementById 方法 必须用于带有约束 xml文档中 ！！！！！！！

    例如：

    books.xml：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE books [
    3. 	<!ELEMENT books (book+) >
    4. 	<!ELEMENT book (name,price) >
    5. 	<!ELEMENT name (#PCDATA) >
    6. 	<!ELEMENT price (#PCDATA) >
    7. 	<!ATTLIST book
    8. 	   id ID #REQUIRED <!--就是这个东西-->
    9. 	>
    10. ]>
    11. <books>
    12. 	<book id="b001">
    13. 		<name>java编程基础</name>
    14. 		<price>80</price>
    15. 	</book>
    16. 	<book id="b002">
    17. 		<name>java高级应用</name>
    18. 		<price>100</price>
    19. 	</book>
    20. </books>

    getElementById 代码示例：

    1. package cn.itcast.dom.jaxp;
    2.  
    3. import java.io.File;
    4. import java.io.IOException;
    5.  
    6. import javax.xml.parsers.DocumentBuilder;
    7. import javax.xml.parsers.DocumentBuilderFactory;
    8. import javax.xml.transform.Transformer;
    9. import javax.xml.transform.TransformerFactory;
    10. import javax.xml.transform.dom.DOMSource;
    11. import javax.xml.transform.stream.StreamResult;
    12.  
    13. import org.junit.Test;
    14. import org.w3c.dom.Document;
    15. import org.w3c.dom.Element;
    16. import org.w3c.dom.Node;
    17. import org.w3c.dom.NodeList;
    18.  
    19. public class DOMTest {
    20. 	@Test
    21. 	// getElementById 用法 --- 查找 id b002 图书 名称
    22. 	public void demo4() throws Exception {
    23. 		// 装载xml 加载内存 --- Document对象
    24. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    25. 				.newInstance();
    26. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    27. 		Document document = builder.parse("books.xml");
    28.  
    29. 		// 直接通过id 查找 ----- 文档必须使用 约束 --- 不用约束xml文档 不能 使用getElementById
    30. 		Element book = document.getElementById("b002");
    31. 		System.out.println(book);
    32. 		System.out.println(book.getChildNodes().item(1).getTextContent());
    33. 	}

    所有开发语言默认支持DTD，当使用Schema时，单独编程导入schema ！

    如何对xml文件进行schema约束？
    1. DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
    2. SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    3. StreamSource ss = new StreamSource("books.xsd");
    4. Schema schema = factory.newSchema(ss);
    5. builderFactory.setSchema(schema);
    6. builderFactory.setNamespaceAware(true);

    XML回写

    XML DOM 增加 、修改 和 删除操作 ------ 操作 内存中文档对象 ---- 操作内存结束后要回写进某一文件中

    更新XML文档步骤：
    |--javax.xml.transform包中的Transformer类用于把代表XML文件的Document对象转换成XML格式进行输出
    |--Transformer对象通过TransformerFactory获得
    |--Transformer类通过transform方法完成转换操作，该方法接收一个源和一个目的地。我们可以通过：
          |--javax.xml.transform.dom.DOMSource类来关联要转换的document对象， 
          |--javax.xml.transform.stream.StreamResult 对象来表示数据的目的地。

    代码示例：

    1. package cn.itcast.dom.jaxp;
    2.  
    3. import java.io.File;
    4. import java.io.IOException;
    5.  
    6. import javax.xml.parsers.DocumentBuilder;
    7. import javax.xml.parsers.DocumentBuilderFactory;
    8. import javax.xml.transform.Transformer;
    9. import javax.xml.transform.TransformerFactory;
    10. import javax.xml.transform.dom.DOMSource;
    11. import javax.xml.transform.stream.StreamResult;
    12.  
    13. import org.junit.Test;
    14. import org.w3c.dom.Document;
    15. import org.w3c.dom.Element;
    16. import org.w3c.dom.Node;
    17. import org.w3c.dom.NodeList;
    18.  
    19. public class DOMTest {
    20. 	@Test
    21. 	// 将 books.xml 加载内存中，将文档内容写入另一个xml books_bak.xml(回写)
    22. 	public void demo5() throws Exception, IOException {
    23. 		// 将 文档 载入内存
    24. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    25. 				.newInstance();
    26. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    27. 		Document document = builder.parse("books.xml");
    28.  
    29. 		// 回写xml 用到 Transformer
    30. 		TransformerFactory transformerFactory = TransformerFactory
    31. 				.newInstance();
    32. 		Transformer transformer = transformerFactory.newTransformer();
    33.  
    34. 		DOMSource domSource = new DOMSource(document);// 用document构造数据源
    35. 		StreamResult result = new StreamResult(new File("books_bak.xml"));
    36.  
    37. 		transformer.transform(domSource, result);
    38. 	}
    39. }

    其实你可以发现回写也是固定套路：

    1. TransformerFactory transformerFactory = TransformerFactory.newInstance();
    2. Transformer transformer = transformerFactory.newTransformer();
    3. DOMSource domSource = new DOMSource(document);// 用document构造数据源
    4. StreamResult result = new StreamResult(new File("books_bak.xml"));
    5. transformer.transform(domSource, result);

    XML元素添加

    |--创建节点元素
          |--document.createXXX()创建节点
    |--将节点元素加入指定位置
          |--element.getDocumentElement()获得根节点
          |--element.appendChild(org.w3c.dom.Node)添加节点
    |--回写XML

    XML元素修改

    |--加载xml到内存
    |--查询到指定元素 
    |--修改元素的属性值
          |--element.setAttribute(name,value);
    |--修改元素内文本内容
          |--element.setTextContent(value);
    |--回写XML

    XML元素删除

    |--删除节点.getParentNode().removeChild(删除节点)
          (删除必须通过父节点、注意每次删完之后修复nodelist长度！)

    代码示例：

    1. package cn.itcast.dom.jaxp;
    2.  
    3. import java.io.File;
    4.  
    5. import javax.xml.parsers.DocumentBuilder;
    6. import javax.xml.parsers.DocumentBuilderFactory;
    7. import javax.xml.transform.Transformer;
    8. import javax.xml.transform.TransformerFactory;
    9. import javax.xml.transform.dom.DOMSource;
    10. import javax.xml.transform.stream.StreamResult;
    11.  
    12. import org.junit.Test;
    13. import org.w3c.dom.Document;
    14. import org.w3c.dom.Element;
    15. import org.w3c.dom.NodeList;
    16.  
    17. /**
    18.  * CURD create update read delete
    19.  * 
    20.  * @author seawind
    21.  * 
    22.  */
    23. public class DOMCURDTest {
    24. 	@Test
    25. 	// 删除所有 java书名 ----- 图书
    26. 	public void testDelete() throws Exception {
    27. 		// 加载xml 到内存
    28. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    29. 				.newInstance();
    30. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    31. 		Document document = builder.parse("books.xml");
    32.  
    33. 		NodeList nodelist = document.getElementsByTagName("name");
    34. 		for (int i = 0; i < nodelist.getLength(); i++) {
    35. 			Element name = (Element) nodelist.item(i);
    36. 			if (name.getTextContent().contains("java")) {
    37. 				// 这本书删除 --- 通过name 获得图书
    38. 				Element book = (Element) name.getParentNode();
    39. 				// 删除 必须 通过父节点
    40. 				book.getParentNode().removeChild(book);
    41. 				i--; // 修复list长度
    42. 			}
    43. 		}
    44.  
    45. 		// 回写
    46. 		TransformerFactory transformerFactory = TransformerFactory
    47. 				.newInstance();
    48. 		Transformer transformer = transformerFactory.newTransformer();
    49. 		DOMSource domSource = new DOMSource(document);// 用document构造数据源
    50. 		StreamResult result = new StreamResult(new File("books_bak.xml"));
    51. 		transformer.transform(domSource, result);
    52. 	}
    53.  
    54. 	@Test
    55. 	// 将 java高级应用 价格上调 20%
    56. 	public void testUpdate() throws Exception {
    57. 		// 加载xml 到内存
    58. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    59. 				.newInstance();
    60. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    61. 		Document document = builder.parse("books.xml");
    62.  
    63. 		// 查找 java高级应用书
    64. 		NodeList nodelist = document.getElementsByTagName("name");
    65. 		for (int i = 0; i < nodelist.getLength(); i++) {
    66. 			Element name = (Element) nodelist.item(i);
    67. 			if (name.getTextContent().equals("java高级应用")) {
    68. 				// 找到了 --- 获得价格节点
    69. 				Element price = (Element) name.getNextSibling()
    70. 						.getNextSibling();
    71. 				double money = Double.parseDouble(price.getTextContent());
    72. 				money = money * 1.2;
    73.  
    74. 				price.setTextContent(money + "");
    75. 			}
    76. 		}
    77.  
    78. 		// 回写
    79. 		TransformerFactory transformerFactory = TransformerFactory
    80. 				.newInstance();
    81. 		Transformer transformer = transformerFactory.newTransformer();
    82. 		DOMSource domSource = new DOMSource(document);// 用document构造数据源
    83. 		StreamResult result = new StreamResult(new File("books_bak.xml"));
    84. 		transformer.transform(domSource, result);
    85. 	}
    86.  
    87. 	@Test
    88. 	// 向xml 添加一个 book元素
    89. 	public void testAdd() throws Exception {
    90. 		// 1 将原来 books.xml 加载到内容
    91. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    92. 				.newInstance();
    93. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    94. 		Document document = builder.parse("books.xml");
    95.  
    96. 		// 2、添加节点 创建节点 books
    97. 		Element newBook = document.createElement("book"); // <book></book>
    98. 		newBook.setAttribute("id", "b003");
    99.  
    100. 		// 创建name节点
    101. 		Element newName = document.createElement("name"); // <name></name>
    102. 		newName.setTextContent("编程高手秘笈");
    103.  
    104. 		// 将 新 name 放入 新 book
    105. 		newBook.appendChild(newName);
    106.  
    107. 		// 3、添加节点到指定位置 ---- 获得books根节点
    108. 		Element root = document.getDocumentElement();
    109. 		root.appendChild(newBook);
    110.  
    111. 		// 4、回写xml
    112. 		TransformerFactory transformerFactory = TransformerFactory
    113. 				.newInstance();
    114. 		Transformer transformer = transformerFactory.newTransformer();
    115. 		DOMSource domSource = new DOMSource(document);// 用document构造数据源
    116. 		StreamResult result = new StreamResult(new File("books_bak.xml"));
    117. 		transformer.transform(domSource, result);
    118. 	}
    119. }

    DOM总结：



    JAXP SAX 解析

    SAX 和 STAX 都是 基于事件驱动 ----- SAX推模式 STAX拉模式

    SAX解析处理器的常用事件

    |--DefaultHandler类（在 org.xml.sax.helpers 软件包中）来实现所有这些回调，并提供所有回调方法默认的空实现 
          |--startDocument()  ---- 文档开始事件
          |--startElement() ---- 元素开始事件
          |--characters() ---- 文本元素事件
          |--endElement() ---- 元素结束事件
          |--endDocument()  ----- 文档结束事件

    SAX解析原理

    SAX和DOM不同：
    DOM解析器 ---- 将整个XML文档全部加载到内存，返回文档对象Document
          解析器DocumentBuilder ---- Document document = builder.parse(file)
    SAX解析器 ---- 一边读取XML一边解析一边处理，并没有返回值
          解析器SAXParser ---- 将XML文档和文档解析处理器(DefaultHandler及其子类)同时传递给SAX解析器 ---- 解析器调用处理器相应的事件处理方法来处理文档


    为什么说SAX是推模式解析？ 解析器控制xml文件解析，由解析器调用相应事件方法
    由位于服务器端的解析器内部主导的事件方法调用 ---- 推模式

    SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，发生相应事件时，将调用一个回调方法，例如：

    1. <?xml version=“1.0” encoding=“utf-8”?>
    2. <config>
    3. 	<server>UNIX</server>
    4. </config>

    依次触发的事件：

    Start document
    Start element (config)
    Characters (whitespace)
    Start element (server)
    Characters (UNIX)
    End element (server)
    Characters (whitespace)
    End element (config)
    End document

    代码示例：

    server.xml：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <config>
    3. 	<server id="s100">UNIX</server>
    4. </config>
    SAX解析：

    1. package cn.itcast.sax.jaxp;
    2.  
    3. import javax.xml.parsers.SAXParser;
    4. import javax.xml.parsers.SAXParserFactory;
    5.  
    6. import org.xml.sax.Attributes;
    7. import org.xml.sax.SAXException;
    8. import org.xml.sax.helpers.DefaultHandler;
    9.  
    10. /**
    11.  * 编写sax解析xml 实例
    12.  * 
    13.  * @author seawind
    14.  * 
    15.  */
    16. public class SAXTest {
    17. 	public static void main(String[] args) throws Exception {
    18. 		// 1、工厂
    19. 		SAXParserFactory factory = SAXParserFactory.newInstance();
    20. 		// 2、通过工厂获得解析器
    21. 		SAXParser parser = factory.newSAXParser();
    22.  
    23. 		// 3 、创建 Handler
    24. 		MyHandler handler = new MyHandler();
    25.  
    26. 		// 4、将xml 文档 和 handler 同时传递给 解析器
    27. 		parser.parse("server.xml", handler);
    28. 	}
    29. }
    30.  
    31. /**
    32.  * 继承 DefaultHandler 重写 5 个事件方法
    33.  * 
    34.  * @author seawind
    35.  * 
    36.  */
    37. class MyHandler extends DefaultHandler {
    38. 	@Override
    39. 	public void startDocument() throws SAXException {
    40. 		System.out.println("start document...");
    41. 	}
    42.  
    43. 	@Override
    44. 	public void startElement(String uri, String localName, String qName,
    45. 			Attributes attributes) throws SAXException {
    46. 		System.out.println("start element(" + qName + ")...");
    47. 		// 打印server元素 id 属性 --- 判断当前开始元素是 server
    48. 		if (qName.equals("server")) {
    49. 			System.out.println("id属性的值：" + attributes.getValue("id"));
    50. 		}
    51. 	}
    52.  
    53. 	@Override
    54. 	public void characters(char[] ch, int start, int length)
    55. 			throws SAXException {
    56. 		String content = new String(ch, start, length);
    57. 		System.out.println("characters: " + content);
    58. 	}
    59.  
    60. 	@Override
    61. 	public void endElement(String uri, String localName, String qName)
    62. 			throws SAXException {
    63. 		System.out.println("end element(" + qName + ")...");
    64. 	}
    65.  
    66. 	@Override
    67. 	public void endDocument() throws SAXException {
    68. 		System.out.println("end document...");
    69. 	}
    70.  
    71. }

    使用SAX方式解析XML步骤

    |--使用SAXParserFactory创建SAX解析工厂
          |--SAXParserFactory spf = SAXParserFactory.newInstance();
    |--通过SAX解析工厂得到解析器对象
          |--SAXParser sp = spf.newSAXParser();
    |--通过解析器对象解析xml文件
          |--sp.parse("book.xml“,new XMLContentHandler());
          |--这里的XMLContentHandler 继承 DefaultHandler
                |--在startElement() endElement() 获得 开始和结束元素名称
                |--在characters() 获得读取到文本内容
                |--在startElement() 读取属性值 

    XML PULL 解析

    STAX 拉模式xml 解析方式 ----- 客户端程序，自己控制xml事件，主动调用相应事件方法

    XML PULL 解析器开发包简介

    当使用XML PULL，如果使用Android系统，系统内置无需下载任何开发包；如果想JavaSE、JavaEE使用pull解析技术下载单独pull 开发工具包。、

    xpp3 ----- XML Pull Parser 3 是pull API 代码实现

    使用pull 解析器
    1、去网站上 下载 pull 解析器的实现 xpp3 (Android 内置)
    2、将 xpp3-1.1.3.4.C.jar 导入 java工程 
    良好习惯：要导入jar包应当位于当前工程内部。
    方法：在工程内新建lib文件夹，将jar复制过来，然后将pull解析器xpp3.jar包添加至Java Build Path (Libraries--Add JARs 或右键jar包 Add to Build Path)，这样pull解析器才能使用。
    注解：jar 包就是.class文件 集合压缩包 （采用zip格式压缩）
    3、创建pull 解析器 ---- XmlPullParser
    4、将xml 文档内容传递 pull 解析器
    5、需要客户端程序手动完成解析，XmlPullParser存放解析方法next()，用于解析器解析下一事件

    STAX解析原理

    Pull解析器 使用 stax 解析方式 ---- 拉模式解析


    SAX解析器当接收到XML文件内容，服务器端解析器SAXParser自动开始解析，自动解析过程中调用处理器相应方法 ---- 推模式
    Pull采用将xml文档传递解析器，解析器XmlPullParser不会自动解析，需要手动通过next触发文档解析事件，在客户端代码中获取当前事件 ，从而调用相应事件处理方法。

    为什么 STAX 解析方式 效率 好于 SAX ？

    1、SAX 无选择性的，所有事件都会处理的解析方式，解析器控制事件的调用；StAX由用户自主控制需要处理事件类型以及事件的调用。
    2、在使用Stax进行数据解析时，随时终止解析。

    使用XML Pull解析 XML

    |--参考官方文档
          |--http://www.xmlpull.org/v1/download/unpacked/doc/quick_intro.html
          |--Xpp3 XmlPullParser javadoc
    |--关键代码
          |--创建解析器工厂
                |--XmlPullParserFactory factory =  XmlPullParserFactory.newInstance();
                |--factory.setNamespaceAware(true); 
          |--根据工厂创建解析器
                |--XmlPullParser xpp = factory.newPullParser(); 
          |--读取xml文件
                |--xpp.setInput(inStream, "UTF-8");
          |--当前节点事件类型
                |--int eventType = xpp.getEventType();
          |--下一个节点事件
                |--eventType = xpp.next();
          |--获得元素名称
                |--xpp.getName();
          |--获得标签属性值
                |--xpp.getAttributeValue
          |--获得标签后面文本内容
                |--xpp.nextText();

    代码示例：

    books.xml：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE books [
    3. 	<!ELEMENT books (book+) >
    4. 	<!ELEMENT book (name,price) >
    5. 	<!ELEMENT name (#PCDATA) >
    6. 	<!ELEMENT price (#PCDATA) >
    7. 	<!ATTLIST book
    8. 	   id ID #REQUIRED <!--就是这个东西-->
    9. 	>
    10. ]>
    11. <books>
    12. 	<book id="b001">
    13. 		<name>java编程基础</name>
    14. 		<price>80</price>
    15. 	</book>
    16. 	<book id="b002">
    17. 		<name>java高级应用</name>
    18. 		<price>100</price>
    19. 	</book>
    20. 	<book id="boo3">
    21. 		<name>编程高手秘笈</name>
    22. 		<price>200</price>
    23. 	</book>	
    24. </books>

    遍历代码实例、查询某本书的价格：

    1. package cn.itcast.stax.pull;
    2.  
    3. import java.io.FileInputStream;
    4.  
    5. import org.junit.Test;
    6. import org.xmlpull.v1.XmlPullParser;
    7. import org.xmlpull.v1.XmlPullParserFactory;
    8.  
    9. /**
    10.  * 通过 pull 解析器 解析 xml
    11.  * 
    12.  * @author seawind
    13.  * 
    14.  */
    15. public class PullTest {
    16. 	@Test
    17. 	// 通过 pull 解析技术 查看 "编程高手秘笈" 价格
    18. 	public void demo2() throws Exception {
    19. 		// 1. 创建 pull 解析器
    20. 		XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
    21. 		XmlPullParser parser = factory.newPullParser();
    22. 		// 2. 将 xml文档传递 解析器
    23. 		parser.setInput(new FileInputStream("books.xml"), "utf-8");
    24.  
    25. 		// 通过循环 驱动事件解析
    26. 		int event;
    27.  
    28. 		// 查找name 标识位
    29. 		boolean isFound = false;
    30. 		while ((event = parser.getEventType()) != XmlPullParser.END_DOCUMENT) {
    31. 			// 获得 开始元素 name
    32. 			if (event == XmlPullParser.START_TAG
    33. 					&& parser.getName().equals("name")) {
    34. 				// 获得元素后面文本
    35. 				String bookname = parser.nextText();
    36. 				if (bookname.equals("编程高手秘笈")) {
    37. 					isFound = true;
    38. 					// 这本书就是我要找到
    39. 					// parser.next();
    40. 					// System.out.println(parser.getEventType());
    41. 					// parser.next(); // price 开始
    42. 					// System.out.println(parser.getEventType());
    43. 					// String money = parser.nextText();//太麻烦，用标识位简单
    44. 					// System.out.println(money);
    45. 				}
    46. 			}
    47.  
    48. 			if (event == XmlPullParser.START_TAG
    49. 					&& parser.getName().equals("price") && isFound) {
    50. 				System.out.println(parser.nextText());
    51. 				break;
    52. 			}
    53.  
    54. 			parser.next();
    55. 		}
    56. 	}
    57.  
    58. 	@Test
    59. 	public void demo1() throws Exception {
    60. 		// 1、创建 xml pull 解析器
    61. 		// 工厂
    62. 		XmlPullParserFactory xmlPullParserFactory = XmlPullParserFactory
    63. 				.newInstance();
    64.  
    65. 		// 通过工厂 获得解析器
    66. 		XmlPullParser parser = xmlPullParserFactory.newPullParser();
    67.  
    68. 		// 2、将 xml 文件 传递 解析器
    69. 		parser.setInput(new FileInputStream("books.xml"), "utf-8");
    70.  
    71. 		// pull 解析器用得是 拉模式 数据 解析
    72. 		int event;
    73.  
    74. 		while ((event = parser.getEventType()) != XmlPullParser.END_DOCUMENT) {
    75. 			//System.out.println(event);
    76. 			
    77. 			// 打印哪个元素开始了 ---- 判断当前事件 是 元素开始事件
    78. 			if (event == XmlPullParser.START_TAG) {
    79. 				// 所有数据 从解析器 获得
    80. 				System.out.println(parser.getName() + "元素开始了...");
    81. 			}
    82.  
    83. 			// 打印 哪个 元素 结束了
    84. 			if (event == XmlPullParser.END_TAG) {
    85. 				System.out.println(parser.getName() + "元素 结束了...");
    86. 			}
    87.  
    88. 			// 处理下一个事件
    89. 			parser.next();
    90. 		}
    91.  
    92. 		// parser.getEventType()获得当前事件类型
    93. 		// 可以通过查看XmlPullParser源码得到各常量代表意义
    94. 		// int event = parser.getEventType();
    95. 		//
    96. 		// System.out.println(event);//START_DOCUMENT = 0
    97. 		//
    98. 		// parser.next(); // 解析器解析下一个事件
    99. 		//
    100. 		// int event2 = parser.getEventType();
    101. 		//
    102. 		// System.out.println(event2);//START_TAG = 2
    103. 		//
    104. 		// parser.next();
    105. 		//
    106. 		// int event3 = parser.getEventType();
    107. 		//
    108. 		// System.out.println(event3);//TEXT = 4
    109.  
    110. 	}
    111. }

    XML PULL 生成XML文档

    Pull 解析器 生成 xml 文档功能 ---- 通过 XmlSerializer 生成 xml 文档

    解析xml ：文档开始、元素开始、文本元素、元素结束、文档结束
    生成xml ：生成文档声明（文档开始），元素开始、文本内容、元素结束 、文档结束

    代码示例：

    1、生成简单xml
    2、通过对象数据生成xml
    3、通过对象List数据生成xml
          ---- 序列化 XmlSerializer

    1. package cn.itcast.stax.pull;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.util.ArrayList;
    5. import java.util.List;
    6.  
    7. import org.junit.Test;
    8. import org.xmlpull.v1.XmlPullParserFactory;
    9. import org.xmlpull.v1.XmlSerializer;
    10.  
    11. import cn.itcast.domain.Company;
    12.  
    13. /**
    14.  * 生成 xml
    15.  * 
    16.  * @author seawind
    17.  * 
    18.  */
    19. public class SerializerTest {
    20. 	@Test
    21. 	// 根据 List<Company> 生成xml
    22. 	public void demo3() throws Exception {
    23. 		List<Company> companies = new ArrayList<Company>();
    24.  
    25. 		Company company = new Company();
    26. 		company.setName("传智播客");
    27. 		company.setPnum(200);
    28. 		company.setAddress("西二旗软件园！");
    29.  
    30. 		Company company2 = new Company();
    31. 		company2.setName("CSDN");
    32. 		company2.setPnum(1000);
    33. 		company2.setAddress("西二旗 软件园 ");
    34.  
    35. 		companies.add(company);
    36. 		companies.add(company2);
    37.  
    38. 		// 序列化对象
    39. 		XmlSerializer serializer = XmlPullParserFactory.newInstance()
    40. 				.newSerializer();
    41.  
    42. 		// 设置输出文件
    43. 		serializer.setOutput(new FileOutputStream("company.xml"), "utf-8");
    44.  
    45. 		serializer.startDocument("utf-8", true);
    46.  
    47. 		serializer.startTag(null, "companies");
    48.  
    49. 		// 遍历list集合
    50. 		for (Company c : companies) {
    51. 			serializer.startTag(null, "company");
    52.  
    53. 			serializer.startTag(null, "name");
    54. 			serializer.text(c.getName());
    55. 			serializer.endTag(null, "name");
    56.  
    57. 			serializer.startTag(null, "pnum");
    58. 			serializer.text(c.getPnum() + "");
    59. 			serializer.endTag(null, "pnum");
    60.  
    61. 			serializer.startTag(null, "address");
    62. 			serializer.text(c.getAddress());
    63. 			serializer.endTag(null, "address");
    64.  
    65. 			serializer.endTag(null, "company");
    66. 		}
    67.  
    68. 		serializer.endTag(null, "companies");
    69.  
    70. 		serializer.endDocument();
    71.  
    72. 	}
    73.  
    74. 	@Test
    75. 	// 根据company对象数据生成xml
    76. 	public void demo2() throws Exception {
    77. 		Company company = new Company();
    78. 		company.setName("传智播客");
    79. 		company.setPnum(200);
    80. 		company.setAddress("西二旗软件园！");
    81.  
    82. 		/*
    83. 		 * <company>
    84. 		 * 
    85. 		 * <name>传智播客</name>
    86. 		 * 
    87. 		 * <pnum>200</pnum>
    88. 		 * 
    89. 		 * <address>西二旗软件园</address>
    90. 		 * 
    91. 		 * </company>
    92. 		 */
    93.  
    94. 		// 获得序列化对象
    95. 		XmlSerializer serializer = XmlPullParserFactory.newInstance()
    96. 				.newSerializer();
    97.  
    98. 		// 传递 输出目标文件 给序列化对象
    99. 		serializer.setOutput(new FileOutputStream("company.xml"), "utf-8");
    100.  
    101. 		serializer.startDocument("utf-8", true);
    102.  
    103. 		serializer.startTag(null, "company");
    104.  
    105. 		serializer.startTag(null, "name");
    106. 		serializer.text(company.getName());
    107. 		serializer.endTag(null, "name");
    108.  
    109. 		serializer.startTag(null, "pnum");
    110. 		serializer.text(company.getPnum() + "");
    111. 		serializer.endTag(null, "pnum");
    112.  
    113. 		serializer.startTag(null, "address");
    114. 		serializer.text(company.getAddress());
    115. 		serializer.endTag(null, "address");
    116.  
    117. 		serializer.endTag(null, "company");
    118.  
    119. 		serializer.endDocument();
    120. 	}
    121.  
    122. 	@Test
    123. 	public void demo1() throws Exception {
    124. 		// 获得XmlSerializer对象
    125. 		XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
    126. 		XmlSerializer serializer = factory.newSerializer();
    127.  
    128. 		// 设置序列化输出文档
    129. 		serializer.setOutput(new FileOutputStream("company.xml"), "utf-8");
    130.  
    131. 		// 文档开始
    132. 		serializer.startDocument("utf-8", true);
    133.  
    134. 		// 元素开始
    135. 		serializer.startTag(null, "company"); // 没有命名空间 ，"" 或者 null
    136.  
    137. 		// 文本元素
    138. 		serializer.text("传智播客");
    139.  
    140. 		// 元素结束
    141. 		serializer.endTag(null, "company");
    142.  
    143. 		// 文档结束
    144. 		serializer.endDocument();
    145.  
    146. 		/*
    147. 		 * <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    148. 		 * 
    149. 		 * <company>
    150. 		 * 
    151. 		 * 传智播客
    152. 		 * 
    153. 		 * </company>
    154. 		 */
    155. 	}
    156. }

    STAX的增删改查 ---- CURD

    对xml文件通过pull解析器进行CURD操作原理：


    当下问题：pull解析器封装List对象过程 ---- 如何将XML数据 --> List<Object>


    将xml数据通过pull解析器生成List集合，代码示例：

    company源码：

    1. package cn.itcast.domain;
    2.  
    3. /**
    4.  * 公司数据类
    5.  * 
    6.  * @author seawind
    7.  * 
    8.  */
    9. public class Company {
    10. 	private String name;
    11. 	private int pnum;//人数
    12. 	private String address;
    13.  
    14. 	public String getName() {
    15. 		return name;
    16. 	}
    17.  
    18. 	public void setName(String name) {
    19. 		this.name = name;
    20. 	}
    21.  
    22. 	public int getPnum() {
    23. 		return pnum;
    24. 	}
    25.  
    26. 	public void setPnum(int pnum) {
    27. 		this.pnum = pnum;
    28. 	}
    29.  
    30. 	public String getAddress() {
    31. 		return address;
    32. 	}
    33.  
    34. 	public void setAddress(String address) {
    35. 		this.address = address;
    36. 	}
    37.  
    38. }

    测试代码：

    1. package cn.itcast.stax.pull;
    2.  
    3. import java.io.FileInputStream;
    4. import java.util.ArrayList;
    5. import java.util.List;
    6.  
    7. import org.junit.Test;
    8. import org.xmlpull.v1.XmlPullParser;
    9. import org.xmlpull.v1.XmlPullParserFactory;
    10.  
    11. import cn.itcast.domain.Company;
    12.  
    13. public class PullCURD {
    14. 	@Test
    15. 	// 将xml中数据 ---- List集合对象
    16. 	public void demo1() throws Exception {
    17. 		List<Company> companies = new ArrayList<Company>();
    18. 		Company company = null;//定义一个临时Company引用
    19.  
    20. 		// 获得解析器
    21. 		XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
    22. 		XmlPullParser parser = factory.newPullParser();
    23.  
    24. 		// 向解析器传入xml文件
    25. 		parser.setInput(new FileInputStream("company.xml"), "utf-8");
    26.  
    27. 		// 遍历解析
    28. 		int event;
    29. 		while ((event = parser.getEventType()) != XmlPullParser.END_DOCUMENT) {
    30.  
    31. 			if (event == XmlPullParser.START_TAG
    32. 					&& parser.getName().equals("company")) {
    33. 				// company 开始 创建 company 对象
    34. 				company = new Company();
    35. 			}
    36.  
    37. 			if (event == XmlPullParser.START_TAG
    38. 					&& parser.getName().equals("name")) {
    39. 				// name 元素开始 -- 封装name属性
    40. 				company.setName(parser.nextText());
    41. 			}
    42.  
    43. 			if (event == XmlPullParser.START_TAG
    44. 					&& parser.getName().equals("pnum")) {
    45. 				company.setPnum(Integer.parseInt(parser.nextText()));
    46. 			}
    47.  
    48. 			if (event == XmlPullParser.START_TAG
    49. 					&& parser.getName().equals("address")) {
    50. 				company.setAddress(parser.nextText());
    51. 			}
    52.  
    53. 			if (event == XmlPullParser.END_TAG
    54. 					&& parser.getName().equals("company")) {
    55. 				// company 结束
    56. 				companies.add(company);
    57. 			}
    58.  
    59. 			parser.next();
    60. 		}
    61.  
    62. 		for (Company c : companies) {
    63. 			System.out.println(c.getName());
    64. 			System.out.println(c.getPnum());
    65. 			System.out.println(c.getAddress());
    66. 			System.out.println("----------------------");
    67. 		}
    68.  
    69. 	}
    70. }

    当内存中读取到List<Object>后，就可以CURD，最后序列化到XML文件中即可。

    因为上述方法经常使用，所以建议在程序中抽取这两个方法 ----- 1. xml ---> List对象  2. List对象生成xml 

    * XmlPullUtils通用程序（反射+泛型） ------ 编写一个工具类 以后pull解析 

    1. package cn.itcast.stax.pull;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.FileOutputStream;
    5. import java.util.ArrayList;
    6. import java.util.List;
    7.  
    8. import org.xmlpull.v1.XmlPullParser;
    9. import org.xmlpull.v1.XmlPullParserFactory;
    10. import org.xmlpull.v1.XmlSerializer;
    11.  
    12. import cn.itcast.domain.Company;
    13.  
    14. /**
    15.  * 工具类 抽取两个方法 ：1、xml --> List 2 List --> XML
    16.  * 
    17.  * @author seawind
    18.  * 
    19.  */
    20. public class PullUtils {
    21. 	/**
    22. 	 * 接收xml文件，返回 List集合
    23. 	 * 
    24. 	 * @param fileName
    25. 	 * @return
    26. 	 * @throws Exception
    27. 	 */
    28. 	public static List<Company> parseXml2List(String fileName) throws Exception {
    29. 		List<Company> companies = new ArrayList<Company>();
    30.  
    31. 		// 获得解析器
    32. 		XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
    33. 		XmlPullParser parser = factory.newPullParser();
    34.  
    35. 		// 设置 xml 输入文件
    36. 		parser.setInput(new FileInputStream(fileName), "utf-8");
    37.  
    38. 		// 解析遍历
    39. 		int event;
    40. 		// 定义一个临时Company 引用
    41. 		Company company = null;
    42. 		while ((event = parser.getEventType()) != XmlPullParser.END_DOCUMENT) {
    43. 			// 将每个<company> 元素封装 Company对象
    44. 			// 1、在company开始时候，创建对象
    45. 			if (event == XmlPullParser.START_TAG
    46. 					&& parser.getName().equals("company")) {
    47. 				company = new Company();
    48. 			}
    49.  
    50. 			// 2、读取name元素时，向company对象中封装 name属性
    51. 			if (event == XmlPullParser.START_TAG
    52. 					&& parser.getName().equals("name")) {
    53. 				company.setName(parser.nextText());
    54. 			}
    55.  
    56. 			// 3、读取pnum元素时，向company对象保存pnum属性
    57. 			if (event == XmlPullParser.START_TAG
    58. 					&& parser.getName().equals("pnum")) {
    59. 				company.setPnum(Integer.parseInt(parser.nextText()));
    60. 			}
    61.  
    62. 			// 4、读取address元素，向company封装 address属性
    63. 			if (event == XmlPullParser.START_TAG
    64. 					&& parser.getName().equals("address")) {
    65. 				company.setAddress(parser.nextText());
    66. 			}
    67.  
    68. 			// 5、读取company元素结束时，将company对象加入集合
    69. 			if (event == XmlPullParser.END_TAG
    70. 					&& parser.getName().equals("company")) {
    71. 				companies.add(company);
    72. 			}
    73.  
    74. 			// 解析 下一个 事件
    75. 			parser.next();
    76. 		}
    77.  
    78. 		return companies;
    79. 	}
    80.  
    81. 	/**
    82. 	 * 同时接收xml文件和List集合，将集合中数据写入xml文件中
    83. 	 * 
    84. 	 * @param companies
    85. 	 * @param fileName
    86. 	 * @throws Exception
    87. 	 */
    88. 	public static void serializeList2Xml(List<Company> companies,
    89. 			String fileName) throws Exception {
    90. 		// 获得序列化对象
    91. 		XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
    92. 		XmlSerializer serializer = factory.newSerializer();
    93.  
    94. 		// 写文件之前，指定输出文件
    95. 		serializer.setOutput(new FileOutputStream(fileName), "utf-8");
    96.  
    97. 		// 文档开始
    98. 		serializer.startDocument("utf-8", true);
    99.  
    100. 		// 根元素开始 companies
    101. 		serializer.startTag(null, "companies");
    102.  
    103. 		// 遍历集合List ，每个List中Company对象 生成一个片段
    104. 		for (Company company : companies) {
    105. 			// company 开始
    106. 			serializer.startTag(null, "company");
    107.  
    108. 			// name属性开始
    109. 			serializer.startTag(null, "name");
    110.  
    111. 			// 写入name数据
    112. 			serializer.text(company.getName());
    113.  
    114. 			// name属性结束
    115. 			serializer.endTag(null, "name");
    116.  
    117. 			// pnum 属性开始
    118. 			serializer.startTag(null, "pnum");
    119.  
    120. 			// 写入pnum数据
    121. 			serializer.text(company.getPnum() + "");
    122.  
    123. 			// pnum 属性结束
    124. 			serializer.endTag(null, "pnum");
    125.  
    126. 			// address属性开始
    127. 			serializer.startTag(null, "address");
    128.  
    129. 			// 写入 address值
    130. 			serializer.text(company.getAddress());
    131.  
    132. 			// address属性结束
    133. 			serializer.endTag(null, "address");
    134.  
    135. 			// company 结束
    136. 			serializer.endTag(null, "company");
    137. 		}
    138.  
    139. 		// 根元素结束
    140. 		serializer.endTag(null, "companies");
    141.  
    142. 		// 文档结束
    143. 		serializer.endDocument();
    144. 	}
    145. }

    对内存中List进行CURD操作 

    1. package cn.itcast.stax.pull;
    2.  
    3. import java.io.FileInputStream;
    4. import java.util.ArrayList;
    5. import java.util.List;
    6.  
    7. import org.junit.Test;
    8. import org.xmlpull.v1.XmlPullParser;
    9. import org.xmlpull.v1.XmlPullParserFactory;
    10.  
    11. import cn.itcast.domain.Company;
    12.  
    13. /**
    14.  * 完成pull解析器CURD操作
    15.  * 
    16.  * @author seawind
    17.  * 
    18.  */
    19. public class PullCURD {
    20. 	@Test
    21. 	// CSDN 从列表删除
    22. 	public void testDelete() throws Exception {
    23. 		// 1、解析 xml 数据到内存 list
    24. 		List<Company> companies = PullUtils.parseXml2List("company.xml");
    25.  
    26. 		// 2、从list集合中删除 csdn 的company对象
    27. 		for (Company company : companies) {
    28. 			if (company.getName().equals("CSDN")) {
    29. 				companies.remove(company);
    30. 				break;//不写break,会报并发错误
    31. 			}
    32. 		}
    33.  
    34. 		// 3、回写xml
    35. 		PullUtils.serializeList2Xml(companies, "company_bak.xml");
    36. 	}
    37.  
    38. 	@Test
    39. 	// 将传智播客人数 200%
    40. 	public void testUpdate() throws Exception {
    41. 		// 1、解析 xml 数据到内存 list
    42. 		List<Company> companies = PullUtils.parseXml2List("company.xml");
    43.  
    44. 		// 2、增长传智播客人数 200%
    45. 		for (Company company : companies) {
    46. 			if (company.getName().equals("传智播客")) {
    47. 				company.setPnum(company.getPnum() * 2);
    48. 			}
    49. 		}
    50.  
    51. 		// 3、回写xml
    52. 		PullUtils.serializeList2Xml(companies, "company_bak.xml");
    53. 	}
    54.  
    55. 	@Test
    56. 	// 查询 csdn人数
    57. 	public void testSelect() throws Exception {
    58. 		// 1、解析 xml 数据到内存 list
    59. 		List<Company> companies = PullUtils.parseXml2List("company.xml");
    60. 		// 2 遍历集合对象
    61. 		for (Company company : companies) {
    62. 			if (company.getName().equals("CSDN")) {
    63. 				System.out.println(company.getPnum());
    64. 			}
    65. 		}
    66. 	}
    67.  
    68. 	@Test
    69. 	// 向 company插入一个公司信息
    70. 	public void testAdd() throws Exception {
    71. 		// 1、解析 xml 数据到内存 list
    72. 		List<Company> companies = PullUtils.parseXml2List("company.xml");
    73.  
    74. 		// 2、添加company对象
    75. 		Company company = new Company();
    76. 		company.setName("baidu");
    77. 		company.setPnum(5000);
    78. 		company.setAddress("百度大楼！");
    79. 		companies.add(company);
    80.  
    81. 		// 3、将List对象回写xml
    82. 		PullUtils.serializeList2Xml(companies, "company_bak.xml");
    83. 	}
    84.  
    85. 	@Test
    86. 	// 测试工具类 PullUtils中方法
    87. 	public void demo2() throws Exception {
    88. 		// 将 company.xml 复制 company_bak.xml
    89. 		// 解析获得集合
    90. 		List<Company> companies = PullUtils.parseXml2List("company.xml");
    91. 		// 将集合写入 company_bak.xml
    92. 		PullUtils.serializeList2Xml(companies, "company_bak.xml");
    93. 	}
    94. }

    综合案例

        平时的开发过程中，经常涉及到xml文件的解析，实现xml文件到java bean的转换。当前有个xml文件，在不允许使用第三方jar的情况下解析xml文件，并根据member节点建立member对象。文件格式如下：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <root>
    3. 	<member>
    4. 		<name>Jack1</name>
    5. 		<age>18</age>
    6. 		<grade>70</grade>
    7. 	</member>
    8. 	<member>
    9. 		<name>Appl2</name>
    10. 		<age>20</age>
    11. 		<grade>70</grade>
    12. 	</member>
    13. 	<member>
    14. 		<name>Appl2</name>
    15. 		<age>20</age>
    16. 		<grade>70</grade>
    17. 	</member>
    18. 	<member>
    19. 		<name>Appl2</name>
    20. 		<age>20</age>
    21. 		<grade>72</grade>
    22. 	</member>
    23. 	<member>
    24. 		<name>Adpl2</name>
    25. 		<age>20</age>
    26. 		<grade>73</grade>
    27. 	</member>
    28. 	<member>
    29. 		<name>ccpl2</name>
    30. 		<age>20</age>
    31. 		<grade>75</grade>
    32. 	</member>
    33. 	<member>
    34. 		<name>bppl2</name>
    35. 		<age>20</age>
    36. 		<grade>75</grade>
    37. 	</member>
    38. </root>

        在输入文件中（文件类型为xml文件），存放话务员的基本信息。该文件中的话务员信息是乱序并且有可能重复的，现在需要输出每位话务员的信息，对于重复的信息只能输出一次。要求如下：

        1、需要把话务员信息使用集合类缓存起来，并且集合中的信息必须唯一（姓名＋年龄唯一）。

        2、输出话务员信息，输出格式为：姓名（年龄）：成绩|姓名（年龄）：成绩，依次按照成绩、姓名、年龄升序排列。

        3、启动两个线程分别做如下处理：

            线程一：对于话务员年龄小于(包含)18岁的，成绩统一加10分。并把话务员信息依次按照成绩、姓名、年龄升序的方式输出到一个队列中。队列的大小不能超过10个。

            线程二： 现有两个分公司（A,B）依次选择话务员，如：A选择第一个话务员后，B再选择一个，依次类推，直到话务员被选完。最后，分别输出A，B两个分公司所选择的话务员信息，输出格式为：姓名（年龄）：成绩|姓名（年龄）：成绩，依次按照成绩、姓名、年龄升序排列。

    控制台输出：

    1、输出话务员信息，输出格式为：姓名（年龄）：成绩|姓名（年龄）：成绩，依次按照成绩、姓名、年龄升序排列。

    2、输出分公司A选择的话务员信息，输出格式为：姓名（年龄）：成绩|姓名（年龄）：成绩，依次按照成绩、姓名、年龄升序排列。

    3、输出分公司B选择的话务员信息，，输出格式为：姓名（年龄）：成绩|姓名（年龄）：成绩，依次按照成绩、姓名、年龄升序排列。

    上面输出的结果为：

    Appl2(20):70|Jack1(18):70|Adpl2(20):73|bppl2(20):75|ccpl2(20):75

    Appl2(20):70|bppl2(20):75|Jack1(18):80

    Adpl2(20):73|ccpl2(20):75

    分析：

    题目要求 XML 文档
    1、将话务员数据从xml 文件 读取出来 ------ Java 对象 -----  很多 话务员 ----- Java对象 集合
    * 集合中的信息必须唯一（姓名＋年龄唯一） ---- java 对象使用姓名+年龄 排重
    2、输出话务员信息 ---  依次按照成绩、姓名、年龄升序排列
    Appl2(20):70|Jack1(18):70|Adpl2(20):73|bppl2(20):75|ccpl2(20):75
    Appl2(20):70|Jack1(18):70|Adpl2(20):73|bppl2(20):75|ccpl2(20):75|
    3、线程一：对于话务员年龄小于(包含)18岁的，成绩统一加10分。并把话务员信息依次按照成绩、姓名、年龄升序的方式输出到一个队列中。队列的大小不能超过10个。
    4、线程二： 现有两个分公司（A,B）依次选择话务员 ，输出格式为：姓名（年龄）：成绩|姓名（年龄）：成绩，依次按照成绩、姓名、年龄升序排列。
    注：
    HashSet --- 排重集合 排重hashCode 和 equals
    TreeSet ---- 即排重又排序集合 排重和排序 通过compareTo 
    * 当排重和排序字段相同时 ---TreeSet ，否则不可以用TreeSet 

    Comparable<E>接口中的排序方法 ---- public int compareTo(E o)：
    前-后 升序
    后-前 降序

    代码示例：

    Member.java:

    1. package mytest;
    2.  
    3. public class Member implements Comparable<Member>, Cloneable {
    4. 	private String name;
    5. 	private int age;
    6. 	private int grade;
    7.  
    8. 	@Override
    9. 	public int hashCode() {
    10. 		final int prime = 31;
    11. 		int result = 1;
    12. 		result = prime * result + age;
    13. 		result = prime * result + ((name == null) ? 0 : name.hashCode());
    14. 		return result;
    15. 	}
    16.  
    17. 	@Override
    18. 	public boolean equals(Object obj) {
    19. 		if (this == obj)
    20. 			return true;
    21. 		if (obj == null)
    22. 			return false;
    23. 		if (getClass() != obj.getClass())
    24. 			return false;
    25. 		Member other = (Member) obj;
    26. 		if (age != other.age)
    27. 			return false;
    28. 		if (name == null) {
    29. 			if (other.name != null)
    30. 				return false;
    31. 		} else if (!name.equals(other.name))
    32. 			return false;
    33. 		return true;
    34. 	}
    35.  
    36. 	public String getName() {
    37. 		return name;
    38. 	}
    39.  
    40. 	public void setName(String name) {
    41. 		this.name = name;
    42. 	}
    43.  
    44. 	public int getAge() {
    45. 		return age;
    46. 	}
    47.  
    48. 	public void setAge(int age) {
    49. 		this.age = age;
    50. 	}
    51.  
    52. 	@Override
    53. 	public int compareTo(Member o) {
    54. 		// 升序 当前元素 - 传入元素 值
    55. 		// 成绩升序
    56. 		int result1 = this.getGrade() - o.getGrade();
    57. 		if (result1 == 0) {
    58. 			// 姓名升序
    59. 			int result2 = this.name.compareTo(o.name);
    60. 			if (result2 == 0) {
    61. 				// 年龄升序
    62. 				int result3 = this.age - o.age;
    63. 				return result3;
    64. 			} else {
    65. 				return result2;
    66. 			}
    67. 		} else {
    68. 			return result1;
    69. 		}
    70. 	}
    71.  
    72. 	public void setGrade(int grade) {
    73. 		this.grade = grade;
    74. 	}
    75.  
    76. 	public int getGrade() {
    77. 		return grade;
    78. 	}
    79.  
    80. 	@Override
    81. 	public Object clone() throws CloneNotSupportedException {
    82. 		return super.clone();
    83. 	}
    84. }

    MemberTest.java

    1. package mytest;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.HashSet;
    5. import java.util.LinkedList;
    6. import java.util.List;
    7. import java.util.Queue;
    8. import java.util.Set;
    9. import java.util.TreeSet;
    10.  
    11. import javax.xml.parsers.DocumentBuilder;
    12. import javax.xml.parsers.DocumentBuilderFactory;
    13.  
    14. import org.w3c.dom.Document;
    15. import org.w3c.dom.Element;
    16. import org.w3c.dom.NodeList;
    17.  
    18. public class MemberTest {
    19. 	public static void main(String[] args) throws Exception {
    20. 		// 第一问 读取xml数据进行排重
    21. 		// 将xml中数据 保存 Member对象集合
    22. 		Set<Member> members = new HashSet<Member>();
    23.  
    24. 		// 读取xml --- JAXP DOM
    25. 		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
    26. 				.newInstance();
    27. 		DocumentBuilder builder = builderFactory.newDocumentBuilder();
    28. 		Document document = builder.parse("member.xml");
    29.  
    30. 		// 每一个<member>标签 对应 member
    31. 		NodeList nodeList = document.getElementsByTagName("member");
    32. 		for (int i = 0; i < nodeList.getLength(); i++) {
    33. 			Element memberElement = (Element) nodeList.item(i);
    34. 			Member member = new Member();
    35. 			// 第二个元素 name
    36. 			member.setName(memberElement.getChildNodes().item(1)
    37. 					.getTextContent());
    38. 			// 第四个元素 age
    39. 			member.setAge(Integer.parseInt(memberElement.getChildNodes()
    40. 					.item(3).getTextContent()));
    41. 			// 第六个元素 grade
    42. 			member.setGrade(Integer.parseInt(memberElement.getChildNodes()
    43. 					.item(5).getTextContent()));
    44.  
    45. 			// 将 member存入集合
    46. 			members.add(member);
    47. 		}
    48. 		// 检查第一问结果：输出应该是5
    49. 		//System.out.println(members.size());
    50.  
    51. 		// 第二问 ，对 Set中member数据进行排序
    52. 		Set<Member> sortMembers = new TreeSet<Member>();
    53. 		sortMembers.addAll(members);
    54. 		for (Member member : sortMembers) {
    55. 			System.out.print(member.getName() + "(" + member.getAge() + "):"
    56. 					+ member.getGrade() + "|");
    57. 		}
    58. 		System.out.println();
    59.  
    60. 		// 第三问
    61. 		// ，对于话务员年龄小于(包含)18岁的，成绩统一加10分。
    62. 		//并把话务员信息依次按照成绩、姓名、年龄升序的方式输出到一个队列中。
    63. 		//队列的大小不能超过10个
    64. 		new Thread(new MyThread1(sortMembers)).start();
    65.  
    66. 		// 第四问 模拟选人
    67. 		Runnable a = new MyThread2(sortMembers, "A");
    68. 		Runnable b = new MyThread2(sortMembers, "B");
    69.  
    70. 		new Thread(a).start();
    71. 		new Thread(b).start();
    72. 	}
    73. }
    74.  
    75. class MyThread2 implements Runnable {
    76.  
    77. 	private static List<Member> members;//static保证唯一
    78. 	private String companyName;
    79.  
    80. 	private static boolean aturn = true;//static保证唯一
    81.  
    82. 	public MyThread2(Set<Member> members, String companyName) {
    83. 		// 将set中元素转存List中，实现有序取出元素remove(index)
    84. 		this.members = new ArrayList<Member>();
    85. 		this.members.addAll(members);
    86.  
    87. 		this.companyName = companyName;
    88. 	}
    89.  
    90. 	@Override
    91. 	public void run() {
    92. 		synchronized (members) {
    93. 			while (members.size() != 0) {
    94. 				// System.out.println(companyName + "执行");
    95. 				if (aturn && companyName.equals("A")) {
    96. 					Member m = members.remove(0);
    97. 					System.out.println("A公司选择：" + m.getName());
    98.  
    99. 					aturn = false;
    100. 					members.notify();
    101. 					try {
    102. 						System.out.println("A 等待");
    103. 						members.wait();
    104. 					} catch (InterruptedException e) {
    105. 						e.printStackTrace();
    106. 					}
    107. 				}
    108. 				if (!aturn && companyName.equals("B")) {
    109. 					Member m = members.remove(0);
    110. 					System.out.println("B公司选择：" + m.getName());
    111.  
    112. 					aturn = true;
    113. 					members.notify();
    114. 					try {
    115. 						System.out.println("B 等待");
    116. 						members.wait();
    117. 					} catch (InterruptedException e) {
    118. 						e.printStackTrace();
    119. 					}
    120. 				}
    121. 			}
    122. 		}
    123. 		System.exit(0);
    124. 	}
    125.  
    126. }
    127.  
    128. class MyThread1 implements Runnable {
    129.  
    130. 	private Set<Member> members;
    131. 	private Queue<Member> queue = new LinkedList<Member>();
    132.  
    133. 	public MyThread1(Set<Member> members) {
    134. 		this.members = members;
    135. 	}
    136.  
    137. 	@Override
    138. 	public void run() {
    139. 		// 加分排序
    140. 		Set<Member> sortMembers = new TreeSet<Member>();
    141.  
    142. 		// 遍历原来的集合
    143. 		for (Member member : members) {
    144. 			if (member.getAge() <= 18) {
    145. 				// 加分 ---不能在原来对象里加分
    146. 				Member m = null;
    147. 				try {
    148. 					m = (Member) member.clone();
    149. 					m.setGrade(m.getGrade() + 10);
    150. 					sortMembers.add(m);
    151. 				} catch (CloneNotSupportedException e) {
    152. 					e.printStackTrace();
    153. 				}
    154. 			} else {
    155. 				// 不需要克隆
    156. 				sortMembers.add(member);
    157. 			}
    158. 		}
    159.  
    160. 		for (Member member : sortMembers) {
    161. 			System.out.print(member.getName() + "(" + member.getAge() + "):"
    162. 					+ member.getGrade() + "|");
    163. 			// 加入队列
    164. 			queue.add(member);
    165. 		}
    166. 		System.out.println();
    167. 	}
    168. }

    				<script>
					(function(){
						function setArticleH(btnReadmore,posi){
							var winH = $(window).height();
							var articleBox = $("div.article_content");
							var artH = articleBox.height();
							if(artH > winH*posi){
								articleBox.css({
									'height':winH*posi+'px',
									'overflow':'hidden'
								})
								btnReadmore.click(function(){
									articleBox.removeAttr("style");
									$(this).parent().remove();
								})
							}else{
								btnReadmore.parent().remove();
							}
						}
						var btnReadmore = $("#btn-readmore");
						if(btnReadmore.length>0){
							if(currentUserName){
								setArticleH(btnReadmore,3);
							}else{
								setArticleH(btnReadmore,1.2);
							}
						}
					})()
				</script>
				</article>
  • 相关阅读:
    多线程GCD
    根据UITouch 自定义手势
    KVC在数据解析中的应用
    oc 文件读写操作
    oc 字典应用实例-城市查询省份
    oc 字典应用实例-成绩科目排序
    oc 数组应用实例-验证码
    协议 protocol
    概念杂记
    OC 类的继承 方法重载重写
  • 原文地址：https://www.cnblogs.com/jobs-lgy/p/9909187.html
Copyright © 2011-2022 走看看