一
XML用以存储数据,做数据交互的。
1. 申明/抬头 必须在第一行
2. 标签(元素),注意一个XML文件只能有一个根标签
3. 实体字符:在xml文件中,我们不能直接写小于号,等一些特殊字符会与xml文件本身的内容冲突报错,此时必须用转义的实体字符。
4. 字符数据区:在xml文件中,我们不能直接写小于号,等一些特殊字符会与xml文件本身的内容冲突报错,此时必须用转义的实体字符或者也可以选择使用字符数据区,里面的内容可以随便了!
<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/css" href="../css/xml.css" ?>
<!-- 7.处理指令:导入外部的css样式控制xml的界面效果,没有啥用,xml不是为了展示好看的!-->
<!-- 1.申明 抬头 必须在第一行-->
<!-- 2.注释,本处就是注释,必须用前后尖括号围起来 -->
<!-- 3.标签(元素),注意一个XML文件只能有一个根标签-->
<student>
<!-- 4.属性信息:id , desc-->
<name id="1" desc="高富帅">西门庆</name>
<age>32</age>
<!-- 5.实体字符:在xml文件中,我们不能直接写小于号,等一些特殊字符
会与xml文件本身的内容冲突报错,此时必须用转义的实体字符。
-->
<sql>
<!-- select * from student where age < 18 && age > 10; -->
select * from student where age < 18 && age > 10;
</sql>
<!-- 6.字符数据区:在xml文件中,我们不能直接写小于号,等一些特殊字符
会与xml文件本身的内容冲突报错,此时必须用转义的实体字符
或者也可以选择使用字符数据区,里面的内容可以随便了!
-->
<sql2>
<![CDATA[
select * from student where age < 18 && age > 10;
]]>
</sql2>
</student>
二
1. XML的约束技术:DTD(后缀:.dtd)
DTD是XML的约束文件
作用:约束XML文件格式的规范性
也就是说,生成根标签模板,框架中有规定好的子标签内容供填写。
缺陷:不能约束数据类型,数据可以瞎写。
2. XML的约束技术:Schema(后缀:.xsd)
Schema本身是XML文件
1. 相比于DTD,可以约束数据类型
2. 引用多个xsd文件时,xsd文件之中标签之间有冲突时,可以用别名区别
三
1.XML文件的解析方式
1. DOM解析
--JAXP
--JDOM
--Dom4J
--jsoup
2. SAX解析
2.DOM的解析原理:
- 将整个XML文件加载到内存中,生成一棵DOM树,下面是根节点。
- 通过Document对象来访问整个DOM树的节点和对应的数据!
3.Dom4J框架入门使用
使用前需要导入dom4j包
1.Dom4J解析根、子元素
步骤:
- 创建一个dom4j的解析器对象
- 通过解析器对象去加载xml文件数据,成为一个Document文档树对象
- 获取根元素对象
- 随后解析各级元素的解析
Element元素的API:
1. String getName():取元素的名称。
2. List<Element> elements():获取当前元素下的全部子元素(一级)
3. List<Element> elements(String name):获取当前元素下的指定名称的全部子元素(一级)
4. Element element(String name):获取当前元素下的指定名称的某个子元素,默认取第一个
(一级)
public class Dom4JDemo {
public static void main(String[] args) throws Exception {
// 需求:解析books.xml文件成为一个Document文档树对象,得到根元素对象。
// 1.创建一个dom4j的解析器对象:代表整个dom4j框架。
SAXReader saxReader = new SAXReader();
// 2.第一种方式(简单):通过解析器对象去加载xml文件数据,成为一个Document文档树对象。
Document document = saxReader.read(new File("Day13Demo/src/books.xml"));
// 3.获取根元素对象
Element root = document.getRootElement();
System.out.println(root.getName());
// 4.获取根元素下的全部子元素
List<Element> sonElements = root.elements();
for (Element sonElement : sonElements) {
System.out.println(sonElement.getName());
}
System.out.println("-------------------");
// 5.获取根源下的全部book子元素
List<Element> sonElements1 = root.elements("book");
for (Element sonElement : sonElements1) {
System.out.println(sonElement.getName());
}
System.out.println("-------------------");
// 6.获取根源下的指定的某个元素
Element son = root.element("user");
System.out.println(son.getName());
// 默认会提取第一个名称一样的子元素对象返回!
Element son1 = root.element("book");
System.out.println(son1.attributeValue("id"));
}
}
5.Dom4J解析属性
步骤:
- 创建一个dom4j的解析器对象
- 通过解析器对象去加载xml文件数据,成为一个Document文档树对象
- 获取根元素对象
- 随后获取元素的属性对象
(5. 可以直接获取元素的属性对象)
Element元素的API:
- List
attributes(): 获取元素的全部属性对象。 - Attribute attribute(String name):根据名称获取某个元素的属性对象。
- String attributeValue(String var1):直接获取某个元素的某个属性名称的值。
Attribute对象的API:
String getName(): 获取属性名称。
String getValue(): 获取属性值。
public class Dom4JDemo {
public static void main(String[] args) throws Exception {
// 1.创建一个dom4j的解析器对象:代表整个dom4j框架。
SAXReader saxReader = new SAXReader();
// 2.第一种方式(简单):通过解析器对象去加载xml文件数据,成为一个Document文档树对象。
Document document = saxReader.read(new File("Day13Demo/src/books.xml"));
// 3.获取根元素对象。
Element root = document.getRootElement();
// 4.获取book子元素
Element bookEle = root.element("book");
// 5.获取book元素的全部属性对象
List<Attribute> attributes = bookEle.attributes();
for (Attribute attribute : attributes) {
System.out.println(attribute.getName()+"=>"+attribute.getValue());
}
// 6.获取Book元素的某个属性对象
Attribute descAttr = bookEle.attribute("desc");
System.out.println(descAttr.getName()+"--->"+descAttr.getValue());
// 7.可以直接获取元素的属性值
System.out.println(bookEle.attributeValue("id"));
System.out.println(bookEle.attributeValue("desc"));
}
}
5.Dom4J解析文本值
步骤:
- 创建一个dom4j的解析器对象
- 通过解析器对象去加载xml文件数据,成为一个Document文档树对象
- 获取根元素对象
- 随后获取所需的元素的文本值
API:
1. String elementText(String name): 可以直接获取当前元素的子元素的文本内容
2. String elementTextTrim(String name):去前后空格,直接获取当前元素的子元素的文本内容
3. String getText():直接获取当前元素的文本内容。
4. String getTextTrim():去前后空格,直接获取当前元素的文本内容。
public class Dom4JDemo {
public static void main(String[] args) throws Exception {
// 1.创建一个dom4j的解析器对象:代表整个dom4j框架。
SAXReader saxReader = new SAXReader();
// 2.第一种方式(简单):通过解析器对象去加载xml文件数据,成为一个Document文档树对象。
Document document = saxReader.read(new File("Day13Demo/src/books.xml"));
// 3.获取根元素对象。
Element root = document.getRootElement();
// 4.得到第一个子元素book
Element bookEle = root.element("book");
// 5.直接拿到当前book元素下的子元素文本值
System.out.println(bookEle.elementText("name"));
System.out.println(bookEle.elementTextTrim("name")); // 去前后空格
System.out.println(bookEle.elementText("author"));
System.out.println(bookEle.elementTextTrim("author")); // 去前后空格
System.out.println(bookEle.elementText("sale"));
System.out.println(bookEle.elementTextTrim("sale")); // 去前后空格
// 6.先获取到子元素对象,再获取该文本值
Element bookNameEle = bookEle.element("name");
System.out.println(bookNameEle.getText());
System.out.println(bookNameEle.getTextTrim());// 去前后空格
}
}
6.Dom4J解析案例
步骤:
- 创建一个dom4j的解析器对象
- 通过解析器对象去加载xml文件数据,成为一个Document文档树对象
- 获取根元素对象
- 获取根元素下的全部子元素
- 遍历子元素,封装成List集合对象(注意:Char类型转成String,用,.charAt(0))
public class Dom4JDemo {
public static void main(String[] args) throws Exception {
// 1.创建一个dom4j的解析器对象:代表整个dom4j框架。
SAXReader saxReader = new SAXReader();
// 2.第一种方式(简单):通过解析器对象去加载xml文件数据,成为一个Document文档树对象。
Document document = saxReader.read(new File("Day13Demo/src/Contacts.xml"));
// 3.获取根元素对象。
Element root = document.getRootElement();
// 4.获取根元素下的全部子元素
List<Element> sonElements = root.elements();
// 5.遍历子元素 封装成List集合对象
List<Contact> contactList = new ArrayList<>();
if(sonElements != null && sonElements.size() > 0) {
for (Element sonElement : sonElements) {
Contact contact = new Contact();
contact.setId(Integer.valueOf(sonElement.attributeValue("id")));
contact.setVip(Boolean.valueOf(sonElement.attributeValue("vip")));
contact.setName(sonElement.elementText("name"));
contact.setSex(sonElement.elementText("gender").charAt(0));
contact.setEmail(sonElement.elementText("email"));
contactList.add(contact);
}
}
System.out.println(contactList);
}
}
public class Contact {
private int id ;
private boolean vip;
private String name ;
private char sex ;
private String email ;
public Contact() {
}
public Contact(int id, boolean vip, String name, char sex, String email) {
this.id = id;
this.vip = vip;
this.name = name;
this.sex = sex;
this.email = email;
}
/**
* 获取
* @return id
*/
public int getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(int id) {
this.id = id;
}
/**
* 获取
* @return vip
*/
public boolean isVip() {
return vip;
}
/**
* 设置
* @param vip
*/
public void setVip(boolean vip) {
this.vip = vip;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return sex
*/
public char getSex() {
return sex;
}
/**
* 设置
* @param sex
*/
public void setSex(char sex) {
this.sex = sex;
}
/**
* 获取
* @return email
*/
public String getEmail() {
return email;
}
/**
* 设置
* @param email
*/
public void setEmail(String email) {
this.email = email;
}
public String toString() {
return "Contact{id = " + id + ", vip = " + vip + ", name = " + name + ", sex = " + sex + ", email = " + email + "}";
}
}
四、Xpath
- Dom4J可以用于解析整个XML的数据。
- 但是如果要检索XML中的某些信息,建议使用Xpath。
XPath使用步骤:
- 导入dom4j框架。(XPath依赖于Dom4j技术,必须先导入dom4j框架!)
- 导入XPath独有的框架包。jaxen-1.1.2.jar
XPath常用API:
List
Node selectSingleNode(String var1):检索出一个节点返回。
XPath提供的四种检索数据的写法:
1. 绝对路径: /根元素/子元素/子元素。
2. 相对路径: ./子元素/子元素。 (.代表了当前元素) 不常用
3. 全文搜索:
//元素 在全文找这个元素
//元素1/元素2 在全文找元素1下面的一级元素2
//元素1//元素2 在全文找元素1下面的全部元素2
4. 属性查找
//@属性名称 在全文检索属性对象。
//元素[@属性名称] 在全文检索包含该属性的元素对象。
//元素[@属性名称=值] 在全文检索包含该属性的元素且属性值为该值的元素对象。
public class XPathDemo {
// 1.绝对路径: /根元素/子元素/子元素。
@Test
public void path01() throws Exception {
// 1.创建一个dom4j的解析器对象:代表整个dom4j框架。
SAXReader saxReader = new SAXReader();
// 2.第二种方式(代码多点)先把xml文件读成一个字节输入流
// 这里的“/”是直接去src类路径下寻找文件。
InputStream is = Dom4JDemo01.class.getResourceAsStream("/Contact.xml");
Document document = saxReader.read(is);
// 3.使用绝对路径定位全部的name名称
List<Node> nameNodes = document.selectNodes("/contactList/contact/name");
for (Node nameNode : nameNodes) {
System.out.println(nameNode.getText());
}
}
// 2.相对路径: ./子元素/子元素。 (.代表了当前元素)
@Test
public void path02() throws Exception {
// 1.创建一个dom4j的解析器对象:代表整个dom4j框架。
SAXReader saxReader = new SAXReader();
// 2.第二种方式(代码多点)先把xml文件读成一个字节输入流
// 这里的“/”是直接去src类路径下寻找文件。
InputStream is = Dom4JDemo01.class.getResourceAsStream("/Contact.xml");
Document document = saxReader.read(is);
// 3.得到根元素对象
Element root = document.getRootElement();
// 4.从根元素开始检索
// .代表当前根元素对象路径!直接找其下的contact下的name
List<Node> nameNodes = root.selectNodes("./contact/name");
for (Node nameNode : nameNodes) {
System.out.println(nameNode.getText());
}
}
// 3.全文搜索:
// "//元素" 在全文找这个元素
// "//元素1/元素2" 在全文找元素1下面的一级元素2
// "//元素1//元素2" 在全文找元素1下面的全部元素2
@Test
public void path03() throws Exception {
// 1.创建一个dom4j的解析器对象:代表整个dom4j框架。
SAXReader saxReader = new SAXReader();
// 2.第二种方式(代码多点)先把xml文件读成一个字节输入流
// 这里的“/”是直接去src类路径下寻找文件。
InputStream is = Dom4JDemo01.class.getResourceAsStream("/Contact.xml");
Document document = saxReader.read(is);
// 3.//name是指在整个xml文件中检索name节点!
List<Node> nameNodes = document.selectNodes("//name");
for (Node nameNode : nameNodes) {
System.out.println(nameNode.getText());
}
System.out.println("-----------------");
// 4.在全文中检索所有contact下的直接name节点
List<Node> nameNodes1 = document.selectNodes("//contact/name");
for (Node nameNode : nameNodes1) {
System.out.println(nameNode.getText());
}
System.out.println("-----------------");
// 5.在全文中检索所有contact下的所有name节点
List<Node> nameNodes2 = document.selectNodes("//contact//name");
for (Node nameNode : nameNodes2) {
System.out.println(nameNode.getText());
}
}
// 4.属性查找。
// //@属性名称 在全文检索属性对象。
// //元素[@属性名称] 在全文检索包含该属性的元素对象。
// //元素[@属性名称=值] 在全文检索包含该属性的元素且属性值为该值的元素对象。
@Test
public void path04() throws Exception {
// 1.创建一个dom4j的解析器对象:代表整个dom4j框架。
SAXReader saxReader = new SAXReader();
// 2.第二种方式(代码多点)先把xml文件读成一个字节输入流
// 这里的“/”是直接去src类路径下寻找文件。
InputStream is = Dom4JDemo01.class.getResourceAsStream("/Contact.xml");
Document document = saxReader.read(is);
// 3.检索全部属性对象
List<Node> attributs = document.selectNodes("//@id");
for (Node attribut : attributs) {
Attribute attr = (Attribute) attribut;
System.out.println(attr.getName() + "--->"+attr.getValue());
}
System.out.println("---------------");
// 4.//元素[@属性名称] 在全文检索包含该属性的元素对象
List<Node> nodeEles = document.selectNodes("//contact[@id]");
for (Node nodeEle : nodeEles) {
System.out.println(nodeEle.getName());
}
System.out.println("---------------");
// 5. //元素[@属性名称=值] 在全文检索包含该属性的元素且属性值为该值的元素对象。
Node nodeEle = document.selectSingleNode("//contact[@id=2]");
Element ele = (Element) nodeEle;
System.out.println(ele.elementTextTrim("name"));
}
}
案例
Mybatis配置文件的解析
public class ParseXMLConfig {
@Test
public void parseXML() throws Exception {
// 1.创建一个解析器对象
SAXReader saxReader = new SAXReader();
// 2.加载类路径下的xml文件成为一个document文档对象。
Document document = saxReader.read(ParseXMLConfig.class.getResourceAsStream("/sqlMapConfig.xml"));
// 3.得到根元素对象
Element root = document.getRootElement();
// 4.获取子元素environments
Element environments = root.element("environments");
// 5.获取子元素environment
Element environment = environments.element("environment");
// 6.获取子元素dataSource
Element dataSource = environment.element("dataSource");
// 7.获取 dataSource下的全部子元素
List<Element> properties = dataSource.elements();
// 8.遍历他们
for (Element property : properties) {
System.out.println(property.attributeValue("name")
+"==>"+property.attributeValue("value"));
}
}
}
标签:XML,name,对象,元素,System,println,十四,out
From: https://www.cnblogs.com/Gege-1/p/17138863.html