JavaWeb1——XML 编程

文章目录

• 1.XML 基本概念
• • 1.1 性质
  • 1.2 与 HTML 的区别
  • 1.3 作用
• 2. XML 文档结构
• • 2.1 序言
  • 2.2 文档元素
  • 2.3 实例：students.xml
• 3. XML 基本元素
• • 3.1 元素
  • 3.2 格式良好
  • 3.3 使用属性
• 4. XML 解析
• • 4.1 第一种方式——DOM解析器
  • • 4.1.1 什么是 DOM
    • 4.1.2 DOM 原理
    • 4.1.3 常用的 DOM接口和类
  • 4.2 第二种方式——SAX解析器
  • • 4.2.1 定义
    • 4.2.2 原理
• 5. 利用开源 JDOM 对 XML 编程
• • 5.1 SAXBuilder.build("*.xml")
  • 5.2 Element.getChildren()
  • 5.3 Element.getChild(“child 节点名”)
  • 5.4 Element.getAttribute(“属性名”)
  • 5.5 Element.getText()
  • 5.6 Document(new Element(“根节点名”))
  • 5.7 Document.getRootNode()
  • 5.8 Element.addContent(Element)
  • 5.9 Element.setAttribute(“属性名”， “属性值”)
  • 5.10 Element.setText(“文本值”)
  • 5.11 输出 xml文件
• 6. 实战——读写 XML 文档
• • 6.1 安装 jdom.jar包
  • 6.1 读写 students.xml
  • • 6.1.1 students.xml
    • 6.1.2 读取studens.xml
    • 6.1.3 写入，读取 my.xml
    • 6.1.4 读取公式代码段

1.XML 基本概念

1.1 性质

• XML 即可拓展的标记语言。
• 可以定义语义标记，是元标记语言。
• 本质上 XML 文件是一个纯文本文件。
• 平台无关性
• 语言无关性
• 系统无关性

1.2 与 HTML 的区别

• HTML 只能使用规定的标记。
• XML 用户可以定义自己需要的标记。
• XML 语法要求更加严格，HTML 相对宽松。

1.3 作用

1. XML 可用于存储数据

   • 通过 XML ，纯文本文件可用于储存数据。

2. XML 可用于交换数据

   • 通过使用 XML ,可以在互不兼容的系统间交换数据。
   • 通过将数据转换为 XML ,可以创建许多不同类型的应用程序读取的数据。

3. XML 可被用来共享数据

   • 通过使用 XML ，纯文本文件可用于共享数据。
   • XML 提供了独立于软硬件的数据共享解决方案。
   • 这使得不同的应用程序可以更容易的创建数据。

2. XML 文档结构

• XML 文档总体上包括两部分：序言（Prolog）和文档元素（Document Elements）。

2.1 序言

• 序言中： XML声明（XML Declaration）,处理指令（Processing Instructions）和注释（Comments）。

2.2 文档元素

• 文档元素：各种元素（Elements）,属性（Attributes）,文本内容（Textual Content）,字符和实体引用（Charactor and Entity References）,CDATA段等。

2.3 实例：students.xml

<?xml version = "1.0" encoding = "GB2312" ?>
<学生名册>
	<学生 ID = "001">
		<姓名>Jack</姓名>
		<性别>男</性别>
	</学生>
	<学生 ID = "002">
		<姓名>Tom</姓名>
		<性别>男</性别>
	</学生>
	<学生 ID = "003">
		<姓名>陈军</姓名>
		<性别>男</性别>
	</学生>
	<学生 ID = "004">
		<姓名>Bob</姓名>
		<性别>男</性别>
	</学生>
	<学生 ID = "005">
		<姓名>王丽</姓名>
		<性别>女</性别>
	</学生>
</学生名册>

3. XML 基本元素

3.1 元素

• 元素是 XML 内容的基本单元。

• 元素：开始标签，结束标签，标签之间的内容。

  • 整行统称为元素
  • 为标签
  • XML 是可拓展标记语言是字符数据

3.2 格式良好

• 简称”良构“。（well-formed）

• 格式良好，要求 XML 无论文件内容多少，有且仅有一个根元素的元素。

• 一个 XML 文件至少是格式良好的。

• 良构的基本要求：

  1. 文档必须包含一个或多个元素（不能为空）。

  2. 每个 XML 文件有且仅有一个声明。

  3. 每个 XML 文件有且仅有一个根节点。

  4. 每个 XML 标记严格区分大小写，开始标记与结束标记配对出现，空标记要关闭。

  • 
    
  5. 标记可以嵌套，但不可以交叉。
  6. 属性必须由名称与值构成。出现在开始标签里。值必须用引号括起来

3.3 使用属性

<?xml version = "1.0" encoding = "gb2312" ?>
<教师列表>
	<教师 id = "1001">
		<姓名 类别 = "兼职">赵尚志</姓名>
		<工资 货币 = "人民币">5000</工资>
	</教师>
	<教师 id = "1002">
		<姓名 类别 = "专职">陈军</姓名>
		<工资 货币 = "人民币">4000</工资>
	</教师>
</教师列表>

4. XML 解析

4.1 第一种方式——DOM解析器

4.1.1 什么是 DOM

• DOM 是基于树形结构的节点或信息片段的集合。
• 允许开发人员使用 DOM API 遍历 XML树、检索所需要的数据。
• 不足：DOM是一个接口定义语言。不为Java特别设计。

4.1.2 DOM 原理

• DOM 原理是使用 DOM对 XML文件进行操作。

  1. 首先解析文件，将文件分为独立的元素，属性，和注释等。
     （DOM 实现时首先为 XML文档的解析定义一组接口，
     解析器读入整个文档，
     然后构造一个驻留内存的树结构，
     这样代码就可以使用 DOM接口来操作整个树结构。）

  2. 然后以节点树的形式在内存中对 XML 文件进行表示。
     （这样就可以通过节点树访问文档的内容，并根据需要修改文档）。

4.1.3 常用的 DOM接口和类

• Document : 该接口定义分析并创建 DOM 文档的一系列方法，它是文档树的根。
• Element: 该接口继承 Node接口，提供了获取，修改 XML元素名字和属性的方法。
• Node: 该接口提供处理并获取节点和子节点值的方法。
• NodeList: 提供获得节点个数和当前节点的方法。这样就可以迭代地访问各个节点。
• DOMParser: 该类是 Apache的 Xerces中的 DOM解析器类，可直接解析 XML文件。

4.2 第二种方式——SAX解析器

4.2.1 定义

• SAX(Simple API for XML) 解析器是一个基于事件的解析器。
• 事件驱动的流式解析方式是：从文件的开始顺序解析到文档的结束，不可暂停或倒退。
• 解析速度快，占用内存少，适合 Android。
• 不足：没有文档修改，随机访问，输出功能。

4.2.2 原理

• 他的核心是事件处理模式。

• 主要围绕着事件源以及事件处理器来工作。

• SAX 工作原理就是：

  1. 对文档进行顺序扫描

  2. 当扫描到开始与结束，元素开始与结束等位置时通知事件处理函数。

  3. 由事件处理函数做相应的动作，然后继续同样的扫描，直至文档结束。

5. 利用开源 JDOM 对 XML 编程

5.1 SAXBuilder.build("*.xml")

获取XML 文件，返回 Document 实例，用于读取 xml 文件。

5.2 Element.getChildren()

获取该节点的所有子节点。

5.3 Element.getChild(“child 节点名”)

获取子节点实例。

5.4 Element.getAttribute(“属性名”)

获取该节点属性的 Value值。

5.5 Element.getText()

获取 该节点的节点文本。

5.6 Document(new Element(“根节点名”))

新建 xml 文本文档。

5.7 Document.getRootNode()

获取根节点。

5.8 Element.addContent(Element)

添加子节点。

5.9 Element.setAttribute(“属性名”， “属性值”)

添加节点属性。

5.10 Element.setText(“文本值”)

添加该节点的文本值。

5.11 输出 xml文件

XMLOutPutter outputter = new XMLOutPutter(Format.getPrettyFormat());
outputter.output(Document, FileOutPutStream);

6. 实战——读写 XML 文档

6.1 安装 jdom.jar包

• 第一步，下载 jdom.zip, 下载资源很简单，下载就行。

• 第二部，得到个压缩包文件。
  

• 第三步，解压得到 jdom-2.0.6.1.jar

• 只有这个文件，对我们有用，其他的不要。

• 打开 eclipse, 找到自己建的项目，右键，构建路径。

• 添加 外部归档文件。

• 把刚才那个jar文件添加上就行了。

• 如何使用？

• 导入三连：

  import org.jdom2.;
  import org.jdom2.input.;
  import org.jdom2.output.*;

• 如果项目里面由 module-info.java

• 添加：

• 安装完毕

6.1 读写 students.xml

6.1.1 students.xml

<?xml version = "1.0" encoding = "GB2312" ?>
<学生名册>
	<学生 ID = "001">
		<姓名>Jack</姓名>
		<性别>男</性别>
	</学生>
	<学生 ID = "002">
		<姓名>Tom</姓名>
		<性别>男</性别>
	</学生>
	<学生 ID = "003">
		<姓名>陈军</姓名>
		<性别>男</性别>
	</学生>
	<学生 ID = "004">
		<姓名>Bob</姓名>
		<性别>男</性别>
	</学生>
	<学生 ID = "005">
		<姓名>王丽</姓名>
		<性别>女</性别>
	</学生>
</学生名册>

6.1.2 读取studens.xml

	public void readXML() {

		/*
		 * 1. 读取 xml 文件
		 * 
		 * 2. 读取 xml 文件所用的工具
		 */
		SAXBuilder builder = new SAXBuilder(); // 获取 xml的实例
		Document doc = null; // 读取 xml文件
		try {
			doc = builder.build("D:\JavaHome\NoBug\src\javaweb\xml\students.xml");
		} catch (JDOMException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		Element root = doc.getRootElement(); // 获取根节点
		List<Element> list = root.getChildren(); // 获取所有子节点

		for (int i = 0; i < list.size(); i++) {
			Element student = list.get(i);
			String id = student.getAttributeValue("ID");
			String name = student.getChildren().get(0).getValue();
			String sex = student.getChildren().get(1).getValue();

			System.out.println("学生 ID = " + id);
			System.out.println("	姓名：" + name + "
	性别：" + sex);
		}

	}


学生 ID = 001
	姓名：Jack
	性别：男
学生 ID = 002
	姓名：Tom
	性别：男
学生 ID = 003
	姓名：陈军
	性别：男
学生 ID = 004
	姓名：Bob
	性别：男
学生 ID = 005
	姓名：王丽
	性别：女

6.1.3 写入，读取 my.xml

	/**
	 * 1. 构造 xml 节点的逻辑
	 * 
	 * 2. 打印结果至控制台
	 * 
	 * 3. 输出结果至文件
	 */
	public void writeXML() {

		// 1. 获取根节点
		Document doc = new Document();
		Element root = new Element("学生列表");
		doc.setRootElement(root);

		// 2. 添加第一个学生
		Element student1 = new Element("学生");
		student1.setAttribute("ID", "006");

		// 姓名
		Element name1 = new Element("姓名");
		name1.setText("张三");
		root.addContent(student1);
		student1.addContent(name1);

		// 性别
		Element sex1 = new Element("性别");
		sex1.setText("男");
		student1.addContent(sex1);

		// 3. 添加第二个
		Element student2 = new Element("学生");
		student2.setAttribute("ID", "007");

		Element name2 = new Element("姓名");
		name2.setText("李四");
		root.addContent(student2);
		student2.addContent(name2);

		Element sex2 = new Element("性别");
		sex2.setText("男");
		student2.addContent(sex2);

		/*
		 * 1. 写入——控制台
		 * 
		 * 2. Format.getPrettyFormat().setEncoding("gb2312"),为了整齐的输出。
		 */
		XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat().setEncoding("gb2312"));
		try {
			outputter.output(doc, System.out);
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}

		// 5. 写入——文件里面 Format.getPrettyFormat().setEncoding("gb2312")
		FileWriter writer = null;
		try {
			writer = new FileWriter("D:\my.xml");
		} catch (IOException e1) {
			// TODO 自动生成的 catch 块
			e1.printStackTrace();
		}
		XMLOutputter outputter1 = new XMLOutputter(Format.getPrettyFormat().setEncoding("gb2312"));
		try {
			outputter1.output(doc, writer);
			writer.close();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}

控制台输出：

<?xml version="1.0" encoding="gb2312"?>
<学生列表>
  <学生 ID="006">
    <姓名>张三</姓名>
    <性别>男</性别>
  </学生>
  <学生 ID="007">
    <姓名>李四</姓名>
    <性别>男</性别>
  </学生>
</学生列表>

my.xml文件：

6.1.4 读取公式代码段

		/*
		 * 1. 写入——控制台
		 * 
		 * 2. Format.getPrettyFormat().setEncoding("gb2312"),为了整齐的输出。
		 */
		XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat().setEncoding("gb2312"));
		try {
			outputter.output(doc, System.out);
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}