day 02xml解析

JAXP DOM 解析
JAXP SAX 解析
XML PULL 进行 STAX 解析

XML 技术主要企业应用
1、存储和传输数据
2、作为框架的配置文件

使用xml 存储和传输数据
1、通过程序生成xml
2、读取xml 中数据 ---- xml 解析

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

Java、JavaScript 都支持DOM

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

StAX The Stream API for XML ----- XML 流 API
STAX 是一种 拉模式 xml 解析方式，SAX 是一种 推模式 XML 解析方式

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

程序员在实际开发中，使用已经开发好工具包 ----- JAXP 、DOM4j 、XML PULL

解析方式 与 解析开发包 关系？
解析方式是解析xml 思想，没有具体代码，解析开发包是解析xml思想具体代码实现

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

当SAX和STAX 读取xml数据时，如果读取到内存数据不释放 ----- 内存中将存在整个xml文档数据 （类似DOM 支持修改和回写）

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

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

DOM 解析快速入门
1、创建 xml 文档 books.xml
在企业实际开发中，为了简化xml 生成和解析 ---- xml 数据文件通常不使用约束的
2、使用DOM解析xml
将整个xml文档加载到内存中 ： 工厂 --- 解析器 --- 解析加载
3、Document通过 getElementsByTagName 获得 节点集合 NodeList
通过 NodeList 提供 getLength 和 item 遍历 节点集合

遍历ArrayList
for (int i=0;i<arraylist.size();i++){
arraylist.get(i);
}

遍历NodeList
for (int i=0;i<nodelist.getLength();i++){
nodelist.item(i); ----- 将遍历每个节点转换子接口类型
}
例如:

// 将 文档 载入内存
DocumentBuilderFactory builderFactory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
Document document = builder.parse("books.xml");

// 回写xml 用到 Transformer
TransformerFactory transformerFactory = TransformerFactory
.newInstance();
Transformer transformer = transformerFactory.newTransformer();

DOMSource domSource = new DOMSource(document);// 用document构造数据源
StreamResult result = new StreamResult(new File("books_bak.xml"));

transformer.transform(domSource, result);
}

@Test
// getElementById 用法 --- 查找 id b002 图书 名称
public void demo4() throws Exception {
// 装载xml 加载内存 --- Document对象
DocumentBuilderFactory builderFactory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
Document document = builder.parse("books.xml");

// 直接通过id 查找 ----- 文档必须使用 约束 --- 不用约束xml文档 不能 使用getElementById
Element book = document.getElementById("b002");
System.out.println(book);
System.out.println(book.getChildNodes().item(1).getTextContent());
}

@Test
// 查询 java编程基础 书 售价
public void demo3() throws Exception {
// 装载xml 加载内存 --- Document对象
DocumentBuilderFactory builderFactory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
Document document = builder.parse("books.xml");

// 利用全局查询 锁定 每个name节点
NodeList nodelist = document.getElementsByTagName("name");
for (int i = 0; i < nodelist.getLength(); i++) {
Element name = (Element) nodelist.item(i);
if (name.getTextContent().equals("java编程基础")) {
// 图书 找到了
// price 是 name 节点 兄弟的兄弟
Element price = (Element) name.getNextSibling()
.getNextSibling();
System.out.println(price.getTextContent());
}
}
}

@Test
// 查询 java编程基础 书 售价
public void demo2() throws Exception {
// 装载xml 加载内存 --- Document对象
DocumentBuilderFactory builderFactory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
Document document = builder.parse("books.xml");

// 全局查询 作为程序 切入
NodeList nodelist = document.getElementsByTagName("book");
// 遍历 强制转换 Element
for (int i = 0; i < nodelist.getLength(); i++) {
Element book = (Element) nodelist.item(i);
// 找 哪个 book 节点 当中 name 节点值 java编程基础 ---- 查找book的name 子节点
NodeList chidren = book.getChildNodes();
Element name = (Element) chidren.item(1); // book的第二个子节点就是 name
if (name.getTextContent().equals("java编程基础")) {
// 当前for循环 这本书 是目标图书
// 打印图书价格 price 是 book 第四个子节点
Element price = (Element) chidren.item(3);
System.out.println(price.getTextContent());
}
}
}

@Test
public void demo1() throws Exception {
// 通过DOM 解析 XML --- 载入整个xml 工厂 -- 解析器 --- 加载

// 构造工厂
DocumentBuilderFactory builderFactory = DocumentBuilderFactory
.newInstance();
// 通过工厂 获得解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();

// 使用解析器 加载 xml文档
Document document = builder.parse("books.xml");

// Document代表整个xml 文档，通过操作Document，操作xml数据

// 将所有图书名称打印出来
// 这里 nodelist 代码 节点的集合
// 查询所有 name标签
NodeList nodelist = document.getElementsByTagName("name");
// 遍历集合中 所有 node
System.out.println("图书name节点数量：" + nodelist.getLength());
for (int i = 0; i < nodelist.getLength(); i++) {
// 获得每个 node 节点
Node node = nodelist.item(i); // 这里每个node 都是 <name></name> ---- 元素
Element e = (Element) node; // 将 节点转换为 子类型 节点
System.out.println(e.getNodeName()); // 节点元素名称
System.out.println(e.getNodeType()); // 节点元素 类型
System.out.println(e.getNodeValue()); // 节点元素 值
// 输出 name 元素 子节点文本节点值
System.out.println(e.getFirstChild().getNodeValue());
System.out.println(e.getTextContent());
System.out.println("------------------------------------");
}
}
}

什么是 Node? 对于xml 来说，xml所有数据都是node节点 （元素节点、属性节点、文本节点、注释节点、CDATA节点、文档节点）
Element Attr Text Comment CDATASection Document ----- 都是 Node 子接口

node有三个通用API ：
getNodeName()：返回节点的名称
getNodeType()：返回节点的类型
getNodeValue()：返回节点的值 ---- 所有元素节点value都是 null

----------------------------------------------------------------------------------------
DOM 编程思路小结
1、装载XML文档 ---- Document
2、Document 获得指定元素 ----- getElementsByTagName （返回 NodeList）
3、遍历NodeList 获得 每个 Node
4、将每个Node 强制转换 Element
5、通过元素节点API 操作属性和文本内容
getAttribute 获得属性值
getTextContent 获得元素内部文本内容

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

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

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

XML DOM 增加 、修改 和 删除操作 ------ 操作 内存中文档对象

XML的回写

XML元素添加 ： 1、创建节点元素 2、将节点元素加入指定位置

XML元素修改 ： 查询到指定元素 1、修改属性 setAttribute 2、修改元素文本内容 setTextContent

XML元素删除 ：删除节点.getParentNode().removeChild(删除节点)

例子：
// 删除所有 java书名 ----- 图书
public void testDelete() throws Exception {
// 加载xml 到内存
DocumentBuilderFactory builderFactory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
Document document = builder.parse("books.xml");

NodeList nodelist = document.getElementsByTagName("name");
for (int i = 0; i < nodelist.getLength(); i++) {
Element name = (Element) nodelist.item(i);
if (name.getTextContent().contains("java")) {
// 这本书删除 --- 通过name 获得图书
Element book = (Element) name.getParentNode();
// 删除 必须 通过父节点
book.getParentNode().removeChild(book);
i--; // 修复list长度
}
}

// 回写
TransformerFactory transformerFactory = TransformerFactory
.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource domSource = new DOMSource(document);// 用document构造数据源
StreamResult result = new StreamResult(new File("books_bak.xml"));
transformer.transform(domSource, result);
}

@Test
// 将 java高级应用 价格上调 20%
public void testUpdate() throws Exception {
// 加载xml 到内存
DocumentBuilderFactory builderFactory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
Document document = builder.parse("books.xml");

// 查找 java高级应用书
NodeList nodelist = document.getElementsByTagName("name");
for (int i = 0; i < nodelist.getLength(); i++) {
Element name = (Element) nodelist.item(i);
if (name.getTextContent().equals("java高级应用")) {
// 找到了 --- 获得价格节点
Element price = (Element) name.getNextSibling()
.getNextSibling();
double money = Double.parseDouble(price.getTextContent());
money = money * 1.2;

price.setTextContent(money + "");
}
}

// 回写
TransformerFactory transformerFactory = TransformerFactory
.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource domSource = new DOMSource(document);// 用document构造数据源
StreamResult result = new StreamResult(new File("books_bak.xml"));
transformer.transform(domSource, result);
}

@Test
// 向xml 添加一个 book元素
public void testAdd() throws Exception {
// 1 将原来 books.xml 加载到内容
DocumentBuilderFactory builderFactory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
Document document = builder.parse("books.xml");

// 2、添加节点 创建节点 books
Element newBook = document.createElement("book"); // <book></book>
newBook.setAttribute("id", "b003");

// 创建name节点
Element newName = document.createElement("name"); // <name></name>
newName.setTextContent("编程高手秘笈");

// 将 新 name 放入 新 book
newBook.appendChild(newName);

// 3、添加节点到指定位置 ---- 获得books根节点
Element root = document.getDocumentElement();
root.appendChild(newBook);

// 4、回写xml
TransformerFactory transformerFactory = TransformerFactory
.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource domSource = new DOMSource(document);// 用document构造数据源
StreamResult result = new StreamResult(new File("books_bak.xml"));
transformer.transform(domSource, result);
}

-------------------------------------------------------------------------------------------------
SAX 和 STAX 都是 基于事件驱动 ----- SAX推模式 STAX拉模式
SAX常用事件
startDocument() ---- 文档开始事件
startElemen() ---- 元素开始事件
characters() ---- 文本元素事件
endElement() ---- 元素结束事件
endDocument() ----- 文档结束事件

为什么说SAX是推模式解析？ 解析器控制xml文件解析，由解析器调用相应事件方法

在startElemen() endElement() 获得 开始和结束元素名称
在characters() 获得读取到文本内容
在startElemen() 读取属性值
例子：
public class SAXTest {
public static void main(String[] args) throws Exception {
// 1、工厂
SAXParserFactory factory = SAXParserFactory.newInstance();
// 2、通过工厂获得解析器
SAXParser parser = factory.newSAXParser();

// 3 、创建 Handler
MyHandler handler = new MyHandler();

// 4、将xml 文档 和 handler 同时传递给 解析器
parser.parse("server.xml", handler);
}
}

/**
* 继承 DefaultHandler 重写 5 个事件方法
*
* @author seawind
*
*/
class MyHandler extends DefaultHandler {
@Override
public void startDocument() throws SAXException {
System.out.println("start document...");
}

@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
System.out.println("start element(" + qName + ")...");
// 打印server元素 id 属性 --- 判断当前开始元素是 server
if (qName.equals("server")) {
System.out.println("id属性的值：" + attributes.getValue("id"));
}
}

@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
String content = new String(ch, start, length);
System.out.println("characters: " + content);
}

@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
System.out.println("end element(" + qName + ")...");
}

@Override
public void endDocument() throws SAXException {
System.out.println("end document...");
}

}

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

当使用XML PULL 如果使用Android系统，系统内置无需下载任何开发包，如果想JavaSE JavaEE 使用pull 解析技术 下载单独pull 开发工具包官方站点：http://www.xmlpull.org/
下载实现xpp3

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 解析器 jar 添加build path

jar 包就是.class文件 集合压缩包 （采用zip格式压缩）

Pull解析器 使用 stax 解析方式 ---- 拉模式解析
Pull采用将xml文档传递 解析器，手动通过next触发文档解析事件，在客户端代码中获取当前事件 ，从而调用相应事件处理方法

3、创建pull 解析器
4、将xml 文档内容传递 pull 解析器
//查找编程高手秘籍的价格
public void demo2() throws Exception {
// 1. 创建 pull 解析器
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlPullParser parser = factory.newPullParser();
// 2. 将 xml文档传递 解析器
parser.setInput(new FileInputStream("books.xml"), "utf-8");

// 通过循环 驱动事件解析
int event;

// 查找name 标识位
boolean isFound = false;
while ((event = parser.getEventType()) != XmlPullParser.END_DOCUMENT) {
// 获得 开始元素 name
if (event == XmlPullParser.START_TAG
&& parser.getName().equals("name")) {
// 获得元素后面文本
String bookname = parser.nextText();
if (bookname.equals("编程高手秘笈")) {
isFound = true;
// 这本书就是我找到
}
}
if (event == XmlPullParser.START_TAG
&& parser.getName().equals("price") && isFound) {
System.out.println(parser.nextText());
break;
}

parser.next();
}
}

@Test
public void demo1() throws Exception {
// 1、创建 xml pull 解析器
// 工厂
XmlPullParserFactory xmlPullParserFactory = XmlPullParserFactory
.newInstance();

// 通过工厂 获得解析器
XmlPullParser parser = xmlPullParserFactory.newPullParser();

// 2、将 xml 文件 传递 解析器
parser.setInput(new FileInputStream("books.xml"), "utf-8");

// pull 解析器用得是 拉模式 数据 解析
int event;

while ((event = parser.getEventType()) != XmlPullParser.END_DOCUMENT) {
// 打印哪个元素开始了 ---- 判断当前事件 是 元素开始事件
if (event == XmlPullParser.START_TAG) {
// 所有数据 从解析器 获得
System.out.println(parser.getName() + "元素开始了...");
}

// 打印 哪个 元素 结束了
if (event == XmlPullParser.END_TAG) {
System.out.println(parser.getName() + "元素 结束了...");
}

// 处理下一个事件
parser.next();
}
}
}

为什么 STAX 解析方式 效率 好于 SAX ？
1、SAX 无选择性的，所有事件都会处理 解析方式，Stax 由用户控制需要处理事件类型
2、在使用Stax进行数据解析时，随时终止解析

Pull 解析器 生成 xml 文档功能 ---- 通过 XmlSerializer 生成 xml 文档
解析xml ： 文档开始、元素开始、文本元素、元素结束、文档结束
生成xml ：生成文档声明（文档开始），元素开始、文本内容、元素结束 、文档结束
1、生成简单xml
2、通过对象数据生成xml
3、通过对象List数据生成xml
public class SerializerTest {
@Test
// 根据 List<Company> 生成xml
public void demo3() throws Exception {
List<Company> companies = new ArrayList<Company>();

Company company = new Company();
company.setName("传智播客");
company.setPnum(200);
company.setAddress("西二旗软件园！");

Company company2 = new Company();
company2.setName("CSDN");
company2.setPnum(1000);
company2.setAddress("西二旗 软件园 ");

companies.add(company);
companies.add(company2);

// 序列化对象
XmlSerializer serializer = XmlPullParserFactory.newInstance()
.newSerializer();

// 设置输出文件
serializer.setOutput(new FileOutputStream("company.xml"), "utf-8");

serializer.startDocument("utf-8", true);

serializer.startTag(null, "companies");

// 遍历list集合
for (Company c : companies) {
serializer.startTag(null, "company");

serializer.startTag(null, "name");
serializer.text(c.getName());
serializer.endTag(null, "name");

serializer.startTag(null, "pnum");
serializer.text(c.getPnum() + "");
serializer.endTag(null, "pnum");

serializer.startTag(null, "address");
serializer.text(c.getAddress());
serializer.endTag(null, "address");

serializer.endTag(null, "company");
}

serializer.endTag(null, "companies");

serializer.endDocument();

}

@Test
// 根据company对象数据生成xml
public void demo2() throws Exception {
Company company = new Company();
company.setName("传智播客");
company.setPnum(200);
company.setAddress("西二旗软件园！");

/*
* <company>
*
* <name>传智播客</name>
*
* <pnum>200</pnum>
*
* <address>西二旗软件园</address>
*
* </company>
*/

// 获得序列化对象
XmlSerializer serializer = XmlPullParserFactory.newInstance()
.newSerializer();

// 传递 输出目标文件 给序列化对象
serializer.setOutput(new FileOutputStream("company.xml"), "utf-8");

serializer.startDocument("utf-8", true);

serializer.startTag(null, "company");

serializer.startTag(null, "name");
serializer.text(company.getName());
serializer.endTag(null, "name");

serializer.startTag(null, "pnum");
serializer.text(company.getPnum() + "");
serializer.endTag(null, "pnum");

serializer.startTag(null, "address");
serializer.text(company.getAddress());
serializer.endTag(null, "address");

serializer.endTag(null, "company");

serializer.endDocument();
}

@Test
public void demo1() throws Exception {
// 获得XmlSerializer对象
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlSerializer serializer = factory.newSerializer();

// 设置序列化输出文档
serializer.setOutput(new FileOutputStream("company.xml"), "utf-8");

// 文档开始
serializer.startDocument("utf-8", true);

// 元素开始
serializer.startTag(null, "company"); // 没有命名空间 ，"" 或者 null

// 文本元素
serializer.text("传智播客");

// 元素结束
serializer.endTag(null, "company");

// 文档结束
serializer.endDocument();

/*
* <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
*
* <company>
*
* 传智播客
*
* </company>
*/
}
}

在程序中抽取两个方法 ----- 1. xml --- List对象 2. List对象生成xml

对内存中List进行CURD操作
public class PullCURD {
@Test
// 将xml中数据 ---- List集合对象
public void demo1() throws Exception {
List<Company> companies = new ArrayList<Company>();
Company company = null;

// 获得解析器
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlPullParser parser = factory.newPullParser();

// 向解析器传入xml文件
parser.setInput(new FileInputStream("company.xml"), "utf-8");

// 遍历解析
int event;
while ((event = parser.getEventType()) != XmlPullParser.END_DOCUMENT) {

if (event == XmlPullParser.START_TAG
&& parser.getName().equals("company")) {
// company 开始 创建 company 对象
company = new Company();
}

if (event == XmlPullParser.START_TAG
&& parser.getName().equals("name")) {
// name 元素开始 -- 封装name属性
company.setName(parser.nextText());
}

if (event == XmlPullParser.START_TAG
&& parser.getName().equals("pnum")) {
company.setPnum(Integer.parseInt(parser.nextText()));
}

if (event == XmlPullParser.START_TAG
&& parser.getName().equals("address")) {
company.setAddress(parser.nextText());
}

if (event == XmlPullParser.END_TAG
&& parser.getName().equals("company")) {
// company 结束
companies.add(company);
}

parser.next();
}

for (Company c : companies) {
System.out.println(c.getName());
System.out.println(c.getPnum());
System.out.println(c.getAddress());
System.out.println("----------------------");
}

}
}

作业：
1、整理 DOM 、SAX 、STAX 原理和区别
2、编写商品xml文件 --- 通过JAXP DOM 完成CURD操作
3、编写SAX运行案例 ----- 了解
4、编写商品XML文件 --- 通过Pull解析器完成 CURD操作 ---- 重点 xml2List list2xml 两个方法