初学Java.关于XML的学习

XML

XML概述

Extensible Markup Language 可拓展标记语言
用途:

1. 数据存储，小型数据库，存在一定的CRUD操作可行性
2. 网络端数据的传输
3. JavaWEB框架项目配置文件
   Spring Druid …

w3c万维网联盟指定的规范

基本语法

1. XML文件后缀名是.xml
2. XML第一行是对于当前文件的定义声明
3. XML文件中有且只有一个根标签
4. 属性值必须使用引号包含，这里推荐使用双引号
5. 标签必须正确匹配，正确开始和关闭
6. XML标签内严格区分大小写

//简单的XML文件代码
<?xml version="1.0" encoding="utf-8"?>
<users>
	<user id="1">
		<name>骚磊</name>
		<age>16</age>
		<gender>male</gender>
	</user>
	<user id="2">
		<name>骚杰</name>
		<age>16</age>
		<gender>male</gender>
	</user>
</users>

XML文件组成部分

1. 文档声明:

格式:

<?xml 属性列表 ?>
<?xml version="1.0" encoding="utf-8" ?>
version: 当前XML文件版本号
encoding: 编码方式，这里建议XML文件的保存编码集和对应的解析编辑一致。
standalone:是否依赖于其他文件 [了解]
yes 不依赖， no 依赖

2. 指令(了解)

这里可以导入一些CSS样式

<?xml-stylesheet type="text/css" href="test.css" ?>

3. 标签内容自定义

规则:
a. 自定义标签允许使用英文字母，数字和其他标点符号(_ - .)
b. 不允许使用数组和标点符号开头，只能用英文字母
c. 不允许在自定义标签内使用xml标记，XML也不行
d. 名字不允许出现空格

4. 属性
   可以给标签一个属性，有时候要求ID属性是惟一的
5. 文本(了解)
   CDATA区，所见即所得，CDATA区内容是完整展示的

格式:

<![CDATA[ 数据 ]]>

XML文件数据约束

1. DTD
   一种简单的约束方式，但是存在一定的约束问题
2. Schema
   一种复杂XML文件约束方式，非常严谨

DTD约束

<!-- students 根标签 要求根标签内存放student -->
<!ELEMENT students (student*) >
<!-- student标签包含子标签的内容 -->
<!ELEMENT student (name,age,sex)>
<!-- 所有子标签当前数据都都是文本形式 -->
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ELEMENT sex (#PCDATA)>
<!-- ATTLIST Attribute List 属性列表 student id ID-->
<!ATTLIST student id ID #REQUIRED>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE students SYSTEM "D:\NZ\IEDA\Day25_SL_IDEA\src\com\qfedu\b_dtd\student.dtd">
<!--<!DOCTYPE students [-->
<!-- &lt;!&ndash; students 根标签 要求根标签内存放student &ndash;&gt;-->
<!-- <!ELEMENT students (student*) >-->
<!-- &lt;!&ndash; student标签包含子标签的内容 &ndash;&gt;-->
<!-- <!ELEMENT student (name,age,sex)>-->
<!-- &lt;!&ndash; 所有子标签当前数据都都是文本形式 &ndash;&gt;-->
<!-- <!ELEMENT name (#PCDATA)>-->
<!-- <!ELEMENT age (#PCDATA)>-->
<!-- <!ELEMENT sex (#PCDATA)>-->
<!-- &lt;!&ndash; ATTLIST Attribute List属性列表 student id ID &ndash;&gt;-->
<!-- <!ATTLIST student id ID #REQUIRED>-->
<!-- ]>-->
<!-- 可以约束一些基本id不可重复，标签组合排序，但是无法要求标签内保存的内容 -->
<students>
	<student id="qf1">
		<name>骚磊</name>
		<age>fdasfdsaf</age>
		<sex>male</sex>
	</student>
	<student id="qf2">
		<name>骚磊</name>
		<age>16</age>
		<sex>male</sex>
	</student>
</students>

Schema约束

<?xml version="1.0"?>
<xsd:schema xmlns="http://www.qfedu.com/xml"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema"
	targetNamespace="http://www.qfedu.com/xml"
	elementFormDefault="qualified">
<!-- 根节点名字和包含的内容，内容是自定义studentType -->
<xsd:element name="students" type="studentsType"/>
<!-- studentType类型声明 -->
<xsd:complexType name="studentsType">
<xsd:sequence>
<!-- students根节点中存放的是student类型 type="studentType" 要求student的个数从0开始 个数不限制 -->
<xsd:element name="student" type="studentType" minOccurs="0"
maxOccurs="unbounded"/>
</xsd:sequence>
</xsd:complexType>
<!-- studentType声明 -->
<xsd:complexType name="studentType">
<xsd:sequence>
<!-- 要求student标签内有name，age，sex 子标签，并且要求对一个对应保存的数据类型是type指定 -->
<xsd:element name="name" type="xsd:string"/>
<!-- ageType 和 sexType 是自定义数据约束 -->
<xsd:element name="age" type="ageType" />
<xsd:element name="sex" type="sexType" />
</xsd:sequence>
<!-- 给予Student标签属性 属性为id，要声明idType， use="required"不可缺少的 -->
<xsd:attribute name="id" type="idType" use="required"/>
</xsd:complexType>
<!-- sexType性别类型声明 -->
<xsd:simpleType name="sexType">
<xsd:restriction base="xsd:string">
<!-- 有且只有两个数据 male female -->
<xsd:enumeration value="male"/>
<xsd:enumeration value="female"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="ageType">
<xsd:restriction base="xsd:integer">
<!-- 0 ~ 256 要求范围，是一个integer类型 -->
<xsd:minInclusive value="0"/>
<xsd:maxInclusive value="256"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="idType">
<xsd:restriction base="xsd:string">
<!-- ID类型，要求gp_xxxx(四位数字) -->
<xsd:pattern value="gp_\d{4}"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>
<?xml version="1.0" encoding="utf-8"?>
<!--
1. 填写根节点约束
2. 引入xsi前缀，
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. 引入xsd文件命名空间
xsi:schemaLocation="http://www.qfedu.com/xmlstudent.xsd"
4. 为xsd约束声明一个前缀，作为表示
-->

<students xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.qfedu.com/xml"
	xsi:schemaLocation="http://www.qfedu.com/xmlstudent.xsd" 
	>
	<student id="gp_0001">
		<name>骚磊</name>
		<age>5</age>
		<sex>male</sex>
	</student>
	<student id="gp_0002">
		<name>骚杰</name>
		<age>17</age>
		<sex>male</sex>
	</student>
</students>

XML解析

XML解析思路

DOM解析
Document Object Model 文件对象模型

把XML整个文件看做一个Document对象，每一个节点看做一个Element，节点中有Attribute，或者当前节点中存在Text文本内容。DOM是将整个XML文件读取到计算机内存中，可以进行CRUD操作。
缺点:

占用了大量内存空间

适用的环境：

服务器对于XML文件的解析过程。

SAX解析
逐行读取，给予一定的事件操作。读取一行内容，释放上一行内容，可以有效的节约内存空间
缺点:

不能对XML文件，进行增删改

适用的环境:

手机读取解析XML文件时采用的方式。

DOM图例

XML文件解析工具

1. JAXP : SUN提供的一个基本的解析器，支持DOM和SAX两种解析方式，但是操作很繁琐，不便于程序员开发。
2. Dom4j : DOM For Java 一款非常优秀的解析器Spring，SpringMVC… 框架中集成的XML解析器
3. Jsoup : 基于Java完成的对于HTML解析的工具，因为HTML和XML文件都是标记语言。给Jsoup一个URL，页面地址. Java的小爬虫，API很多很方便
4. PULL : Android手机上集成的XML解析工具，SAX方式解析

Dom4j使用入门

1. 导包:导入第三方Jar包
2. 设置IDEA
3. Dom4j涉及到的方法

SAXReader();

解析XML文件使用的核心类 , read() --> XML文件Document对象

Document document = new SAXReader().read(new File("./xml/User.xml"));

Document对象中可以使用方法

Element getRootElement();

获取当前XML文件的根节点对象

Element对象中可以使用方法

List elements();

当前节点下的所有子节点

List elements(String name);

当前节点下所有指定名字的子节点

Element element();

获取当前节点下的第一个子节点

Element element(String name);

获取当前节点下指定名字的第一个子节点

Attribute getAttribute(String name);

根据属性名获取对应的属性对象Attribute

Attribute节点中可以使用String

getValue();

来获取对应的节点数据

String getName();

获取当前节点的名字

String getText();

获取当前节点对应的文本数据

import jdk.nashorn.internal.ir.CallNode;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.util.List;

/**
* @description Dom4j方法演示
* @author Anonymous
* @data 2020/3/6 15:07
*/
public class Demo1 {
	public static void main(String[] args) throws
		DocumentException {
		// 当前XML文件的Document对象
		Document document = new SAXReader().read(new File("./xml/User.xml"));
		// 获取根节点 Root Element
		Element rootElement = document.getRootElement();
		// 获取Root Element下子节点
		List<Element> elements = rootElement.elements();
		// 可以获取当前节点下的所有子节点
		// System.out.println(elements);
		Element teacher = rootElement.element("teacher");
		// 获取属性节点指定属性值
		System.out.println(teacher.attribute("id").getValue());
		List<Element> elements1 = teacher.elements();
		for (Element element : elements1) {
			// 获取节点的名字
			System.out.println(element.getName() + ":" + element.getText());
		}
	}
}

Dom4j Xpath解析读取XML文件

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.util.List;

/**
* @description Xpath语法解析 XML文件
* @author Anonymous
* @date 2020/3/6 15:55
*/
public class Demo2 {
	public static void main(String[] args) throws
		DocumentException {
		// 当前XML文件的Document对象
		Document document = new SAXReader().read(new File("./xml/User.xml"));
		// 获取根节点 Root Element
		Element rootElement = document.getRootElement();
		// 无视目录结构，无视当前解析状态，直接获取所有的user节点
		List list = rootElement.selectNodes("//user");
		for (Object o : list) {
			Element element = (Element) o;
			int id = Integer.parseInt(element.attributeValue("id"));
			String name = element.element("name").getText();
			int age = Integer.parseInt(element.element("age").getText()
		);
		String gender = element.element("gender").getText();
		System.out.println("User[id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + "]");
		}
		System.out.println("--------------------------------------");
		System.out.println();
		// //user[index] 不考虑路径关系，获取当前XML文件中指定下标的user节点
		Node node = rootElement.selectSingleNode("//user[1]");
		System.out.println(node);
		System.out.println("--------------------------------------");
		System.out.println();
		// //user[@id=9] 不考虑路径关系，获取当前XML文件中指定属性为id，值为9的user节点
		// @之后是属性 @id 这里需要匹配的是属性
		Node node1 = rootElement.selectSingleNode("//user[@id=9]");
		System.out.println(node1);
		System.out.println("--------------------------------------");
		System.out.println();
		// //user[gender='male'] 不考虑路径关系，获取当前XML文件中指定子节点为gender，对应子节点文本数据为male
		// 的user所有节点
		List list1 = rootElement.selectNodes("//user[gender='male']");
		for (Object o : list1) {
			System.out.println(o);
		}
		System.out.println("--------------------------------------");
		System.out.println();
		List list2 = rootElement.selectNodes("//user[age<20]");
		for (Object o : list2) {
			System.out.println(o);
		}
	}
}

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.util.List;

/**
* @description Xpath语法解析 XML文件
* @author Anonymous
* @date 2020/3/6 15:55
*/
public class Demo3 {
	public static void main(String[] args) throws
		DocumentException {
		// 当前XML文件的Document对象
		Document document = new SAXReader().read(new File("./xml/User.xml"));
		// 获取根节点 Root Element
		Element rootElement = document.getRootElement();
		System.out.println("--------------------------------------");
		System.out.println();
		// //user[last()] 这里是不考虑路径关系，获取最后一个user节点
		Node node = rootElement.selectSingleNode("//user[last()]");
		System.out.println(node);
		System.out.println("--------------------------------------");
		System.out.println();
		// //user[last()] 这里是不考虑路径关系，获取前两个User节点
		List list = rootElement.selectNodes("//user[position() < 3]");
		for (Object o : list) {
			System.out.println(o);
		}
		System.out.println("--------------------------------------");
		System.out.println();
		// //name | // age 无视路径关系，获取所有的name节点和age节点
		List list1 = rootElement.selectNodes("//name | // age");
		for (Object o : list1) {
			Element element = (Element) o;
			System.out.println(element.getText());
		}
	}
}

XML文件保存

流程：

1. 创建Document对象
2. 通过Document对象来添加元素

addElment();

addAttribute();

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
* @description: 创建XML文件
* @author: Anonymous
* @time: 2020/3/6 16:29
*
* <students>
* <student id="qf1">
* <name>骚磊</name>
* <age>fdasfdsaf</age>
* <sex>male</sex>
* </student>
* <student id="qf2">
* <name>骚磊</name>
* <age>16</age>
* <sex>male</sex>
* </student>
* </students>
*/
public class Demo1 {
	public static void main(String[] args) throws
		IOException {
		// 1. 创建了一个XML文件对应的Document对象
		Document document = DocumentHelper.createDocument();
		// 2. 放入到XML文件对应的Document对象中
		Element root = document.addElement("students");
		// 3. 在根节点之下添加了一个student节点，同时设置了属性
		Element element = root.addElement("student").addAttribute("id", "qf1");
		// 根节点下添加了对应的子节点，以及对应的文本
		element.addElement("name").addText("骚磊");
		element.addElement("age").addText("16");
		element.addElement("sex").addText("male");
		// 字符输出流
		FileWriter fileWriter = new FileWriter("./xml/student.xml");
		document.write(fileWriter);
		// 4. 关闭资源
		fileWriter.close();
	}
}

反射+XML文件保存读取操作

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Field;
import
java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
/**
* @description:
* @author: Anonymous
* @time: 2020/3/6 16:46
*/
public class MainProject {
public static void main(String[] args)
throws IllegalAccessException,
DocumentException, NoSuchMethodException,
InvocationTargetException, IOException {
ArrayList<Student> list = new ArrayList<>
();
readDataFromXML(list);
for (Student student : list) {
System.out.println(student);
}
}
public static void
saveDateToXML(ArrayList<Student> list) throws
IllegalAccessException, IOException {
// 创建XML文件对应Document对象
Document document =
DocumentHelper.createDocument();
// 明确根节点
Element root =
document.addElement("students");
// 获取所有的成员变量Field对象
Field[] declaredFields =
Student.class.getDeclaredFields();
// 循环遍历Student ArrayList集合
for (Student student : list) {
// 每一个Student对象都要对应一个Student
节点
Element element =
root.addElement("student");
// 遍历所有的Field成员变量
for (Field declaredField :
declaredFields) {
declaredField.setAccessible(true);
// id存储到Student节点中的属性中
if
("id".equals(declaredField.getName())) {
// 所有的数据都是在String类型处
理
element.addAttribute("id",
declaredField.get(student) + "");
} else {
// declaredField.getName() 成
员变量名字 declaredField.get(student) 对应数据
element.addElement(declaredField.getName()).addT
ext(declaredField.get(student) + "");
}
}
}
// 字符流对象+Document对象的write方法写入
XML信息到文件中
FileWriter fileWriter = new
FileWriter("./xml/student.xml");
document.write(fileWriter);
fileWriter.close();
}
public static void
readDataFromXML(ArrayList<Student> list)
throws DocumentException,
NoSuchMethodException, InvocationTargetException,
IllegalAccessException {
Document document = new
SAXReader().read(new File("./xml/student.xml"));
// 找出当前XML文件中的所有student节点
List list1 =
document.selectNodes("//student");
// 得到当前Student类内的所有成员变量对象，注
意使用暴力反射
Field[] declaredFields =
Student.class.getDeclaredFields();
/*
String字符串问题
name String getText
gender String getText
id Integer Attribute ==> Integer
age Integer getText ==> Integer
*/
// 遍历所有的Student节点
for (Object o : list1) {
// Student节点对象
Element element = (Element) o;
Student student = new Student();
// 成员变量Field数组遍历
for (Field declaredField :
declaredFields) {
// 给予暴力反射操作成员变量权限
declaredField.setAccessible(true);
// 获取当前成员变量的数据类型
Class<?> type =
declaredField.getType();
// 如果数据类型是String类型
if (type.equals(String.class)) {
// String
declaredField.set(student,
element.element(declaredField.getName()).getText(
));
} else if
(type.equals(Integer.class)) {
// Integer类型
// 获取Integer类型中的valueOf
方法
Method valueOf =
type.getMethod("valueOf", String.class);
if
("id".equals(declaredField.getName())) {
/*
id是在student节点属性中，从
属性中获取对应是数据，使用valueOf方法转换成对应的
Integer类型
*/
declaredField.set(student,
valueOf.invoke(student,
element.attributeValue("id")));
} else {
/*
非ID数据，从Student指定名字
的子节点下获取，指定名字和成员变量名字一直，同样需要转
换一下
*/
declaredField.set(student,valueOf.invoke(student
,
element.element(declaredField.getName()).getText(
)));
}
6. 作业
}
}
list.add(student);
}
}
}