XML基础介绍【二】
1、schema约束
dtd语法： <!ELEMENT 元素名称 约束>
schema符合xml的语法，xml语句。一个xml中可以有多个schema，多个schema使用名称空间区分（类似于java包名）
dtd里面有PCDATA类型，但是在schema里面可以支持更多的数据类型
比如 年龄 只能是整数，在schema可以直接定义一个整数类型
schema语法更加复杂，schema目前不能替代dtd
2、schema的快速入门
创建一个schema文件 后缀名是 .xsd
根节点 <schema>
在schema文件里面
属性 xmlns="http://www.w3.org/2001/XMLSchema"
- 表示当前xml文件是一个约束文件
targetNamespace="http://www.boom.cn/2015112401"
- 使用schema约束文件，直接通过这个地址引入约束文件
elementFormDefault="qualified"
步骤：
（1）看xml中有多少个元素
<element>
（2）看简单元素和复杂元素
如果复杂元素
<complexType>
<sequence>
子元素
</sequence>
</complexType>
（3）简单元素，写在复杂元素的
<element name="person">
<complexType>
<sequence>
<element name="name" type="string"></element>
<element name="age" type="int"></element>
</sequence>
</complexType>
</element>
（4）在被约束文件里面引入约束文件
<person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.boom.cn/2015112401"
xsi:schemaLocation="http://www.boom.cn/2015112401 1.xsd">
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-- 表示xml是一个被约束文件
xmlns="http://www.boom.cn/2015112401"
-- 是约束文档里面 targetNamespace
xsi:schemaLocation="http://www.boom.cn/2015112401 1.xsd">
-- targetNamespace 空格 约束文档的地址路径
<sequence>：表示元素的出现的顺序
<all>: 元素只能出现一次
<choice>：元素只能出现其中的一个
maxOccurs="unbounded"： 表示元素的出现的次数 unbounded:无限次数
<any></any>:表示任意元素
可以约束属性
写在复杂元素里面
写在 </complexType>之前
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
<attribute name="id1" type="int" use="required"></attribute>
- name: 属性名称
- type：属性类型 int stirng
- use：属性是否必须出现 required
复杂的schema约束
<company xmlns = "http://www.example.org/company"
xmlns:dept="http://www.example.org/department"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.example.org/company company.xsd http://www.example.org/department department.xsd" >
<employee age="30">
<!-- 部门名称 -->
<dept:name>100</dept:name>
想要引入部门的约束文件里面的name，使用部门的别名 detp:元素名称
<!-- 员工名称 -->
<name>王晓晓</name>
</employee>
e-code
3、sax解析的原理（********）
解析xml有两种技术 dom 和sax
根据xml的层级结构在内存中分配一个树形结构，把xml中标签，属性，文本封装成对象
sax方式：事件驱动，边读边解析。在javax.xml.parsers包里面
SAXParser
此类的实例可以从 SAXParserFactory.newSAXParser() 方法获得
- parse(File f, DefaultHandler dh)
两个参数
a. 第一个参数：xml的路径
b. 事件处理器
SAXParserFactory
实例 newInstance() 方法得到
画图分析一下sax执行过程
* 当解析到开始标签时候，自动执行startElement方法
* 当解析到文本时候，自动执行characters方法
* 当解析到结束标签时候，自动执行endElement方法
4、使用jaxp的sax方式解析xml（**会写***）
sax方式不能实现增删改操作，只能做查询操作
1、打印出整个文档
步骤：
1、创建解析器工厂
2、创建解析器
3、执行Parser()方法，第一个参数xml路径，第二个参数是 事件处理器
a. 创建一个类，继承事件处理器的类，
b. 重写里面的三个方法
4、创建一个类，继承事件处理器的类
5、重写里面的三个方法
2、获取到所有的name元素的值
定义一个成员变量 flag= false
判断开始方法是否是name元素，如果是name元素，把flag值设置成true
如果flag值是true，在characters方法里面打印内容
当执行到结束方法时候，把flag值设置成false
3、获取第一个name元素的值
定义一个成员变量 idx=1
在结束方法时候，idx+1 idx++
想要打印出第一个name元素的值，
- 在characters方法里面判断，
- 判断flag=true 并且 idx==1，在打印内容
e-code
1 package boom.jaxpsax; 2 3 import javax.swing.text.DefaultCaret; 4 import javax.xml.parsers.ParserConfigurationException; 5 import javax.xml.parsers.SAXParser; 6 import javax.xml.parsers.SAXParserFactory; 7 8 import org.xml.sax.Attributes; 9 import org.xml.sax.SAXException; 10 import org.xml.sax.helpers.DefaultHandler; 11 12 public class TestSax { 13 14 /** 15 * 打印不同元素的a.xml文档 16 * @param args 17 * @throws SAXException 18 * @throws ParserConfigurationException 19 */ 20 public static void main(String[] args) throws Exception { 21 // 1、创建解析器工厂 22 SAXParserFactory saxParserFactory = SAXParserFactory.newInstance(); 23 // 2、创建解析器 24 SAXParser saxParser = saxParserFactory.newSAXParser(); 25 // 3、执行Parser()方法 26 saxParser.parse("src/a.xml", new MyDefault3()); 27 // 4、创建一个类，继承事件处理器的类 28 // 5、重写里面的三个方法 29 30 } 31 32 } 33 //创建一个类，继承事件处理器的类 34 //1、打印整个a.xml文档 35 class MyDefault1 extends DefaultHandler{ 36 // 重写startElement、characters、endElement的三个方法 37 @Override 38 public void startElement(String uri, String localName, String qName, 39 Attributes attributes) throws SAXException { 40 System.out.print("<"+qName+">"); 41 } 42 43 @Override 44 public void characters(char[] ch, int start, int length) 45 throws SAXException { 46 System.out.print(new String(ch,start,length)); 47 } 48 49 @Override 50 public void endElement(String uri, String localName, String qName) 51 throws SAXException { 52 System.out.print("</"+qName+">"); 53 } 54 55 } 56 57 //2、获取所有的name元素值 58 class MyDefault2 extends DefaultHandler{ 59 // 定义一个成员变量 60 boolean flag = false; 61 @Override 62 public void startElement(String uri, String localName, String qName, 63 Attributes attributes) throws SAXException { 64 // 进行判断qName是否为name 65 if ("name".equals(qName)){ 66 flag = true; 67 } 68 } 69 70 @Override 71 public void characters(char[] ch, int start, int length) 72 throws SAXException { 73 // 当flag值为true时，表示解析到name值 74 if (flag == true){ 75 System.out.println(new String(ch,start,length)); 76 } 77 } 78 79 @Override 80 public void endElement(String uri, String localName, String qName) 81 throws SAXException { 82 // flag设置成false,表示name元素结束 83 if ("name".equals(qName)){ 84 flag = false; 85 } 86 } 87 88 } 89 90 //3、获取第一个的name元素值 91 class MyDefault3 extends DefaultHandler{ 92 // 定义一个成员变量 93 boolean flag = false; 94 int idx =1; 95 @Override 96 public void startElement(String uri, String localName, String qName, 97 Attributes attributes) throws SAXException { 98 // 进行判断qName是否为name 99 if ("name".equals(qName)){ 100 flag = true; 101 } 102 } 103 104 @Override 105 public void characters(char[] ch, int start, int length) 106 throws SAXException { 107 // 当flag值为true时，表示解析到name值 108 // 索引是1 109 if (flag == true && idx == 1){ 110 System.out.println(new String(ch,start,length)); 111 } 112 } 113 114 @Override 115 public void endElement(String uri, String localName, String qName) 116 throws SAXException { 117 // flag设置成false,表示name元素结束 118 if ("name".equals(qName)){ 119 flag = false; 120 idx++; 121 } 122 } 123 124 }
5、使用dom4j解析xml
dom4j，是一个组织，针对xml解析，提供解析器 dom4j
dom4j不是javase的一部分，想要使用第一步需要怎么做？
导入dom4j提供jar包
-- 创建一个文件夹 lib
-- 复制jar包到lib下面，
-- 右键点击jar包，build path -- add to build path
-- 看到jar包，变成奶瓶样子，表示导入成功
得到document
SAXReader reader = new SAXReader();
Document document = reader.read(url);
document的父接口是Node
如果在document里面找不到想要的方法，到Node里面去找
document里面的方法 getRootElement() ：获取根节点 返回的是Element
Element也是一个接口，父接口是Node
- Element和Node里面方法
getParent()：获取父节点
addElement：添加标签
element(qname)
表示获取标签下面的第一个子标签
qname：标签的名称
elements(qname)
获取标签下面是这个名称的所有子标签（一层）
qname：标签名称
elements()
获取标签下面的所有一层子标签
6、使用dom4j查询xml
* 解析是从上到下解析
* 查询所有name元素里面的值
1、创建解析器
2、得到document
3、得到根节点 getRootElement() 返回Element
4、得到所有的p1标签
* elements("p1") 返回list集合
* 遍历list得到每一个p1
5、得到name
* 在p1下面执行 element("name")方法 返回Element
6、得到name里面的值
* getText方法得到值
*查询第一个name元素的值
1、创建解析器
2、得到document
3、得到根节点
4、得到第一个p1元素
* element("p1")方法 返回Element
5、得到p1下面的name元素
* element("name")方法 返回Element
6、得到name元素里面的值
* getText方法
* 获取第二个name元素的值
1、创建解析器
2、得到document
3、得到根节点
4、得到所有的p1
* 返回 list集合
5、遍历得到第二个p1
* 使用list下标得到 get方法，集合的下标从 0 开始，想要得到第二个值，下标写 1
6、得到第二个p1下面的name
* element("name")方法 返回Element
7、得到name的值
* getText方法
7、使用dom4j实现添加操作
* 在第一个p1标签末尾添加一个元素 <sex>nv</sex>
步骤:
1、创建解析器
2、得到document
3、得到根节点
4、获取到第一个p1
* 使用element方法
5、在p1下面添加元素
* 在p1上面直接使用 addElement("标签名称")方法 返回一个Element
6、在添加完成之后的元素下面添加文本
* 在sex上直接使用 setText("文本内容")方法
7、回写xml
* 格式化 OutputFormat,使用 createPrettyPrint方法，表示一个漂亮的格式
* 使用类XMLWriter 直接new 这个类 ，传递两个参数
*** 第一个参数是xml文件路径 new FileOutputStream("路径")
*** 第二个参数是格式化类的值
8、使用dom4j实现在特定位置添加元素
* 在第一个p1下面的age标签之前添加 <school>ahszu.edu.cn</schlool>
步骤:
1、创建解析器
2、得到document
3、得到根节点
4、获取到第一个p1
5、获取p1下面的所有的元素
** elements()方法 返回 list集合
** 使用list里面的方法，在特定位置添加元素
** 首先创建元素 在元素下面创建文本
- 使用DocumentHelper类方法createElement创建标签
- 把文本添加到标签下面 使用 setText("文本内容")方法
** list集合里面的 add(int index, E element)
* - 第一个参数是 位置 下标，从0开始
* - 第二个参数是 要添加的元素
6、回写xml
封装的总结：
** 可以对得到document的操作和 回写xml的操作，封装成方法
** 也可以把传递的文件路径，封装成一个常量
*** 好处：可以提高开发速度，可以提交代码可维护性
- 比如想要修改文件路径（名称），这个时候只需要修改常量的值就可以了，其他代码不需要做任何改变
9、使用dom4j实现修改节点的操作
* 修改第一个p1下面的age元素的值 <age>30</age>
步骤：
1、得到document
2、得到根节点，然后再得到第一个p1元素
3、得到第一个p1下面的age
element("")方法
4、修改值是 300
* * 使用setText("文本内容")方法
5、回写xml
10、使用dom4j实现删除节点的操作
* 删除第一个p1下面的<school></school>元素
步骤：
1、得到document
2、得到根节点
3、得到第一个p标签
4、得到第一个p下面的school元素
5、删除（使用p1删除school）
* 得到school的父节点
- 第一种直接得到p
- 使用方法 getParent方法得到
* 删除操作
- 在p上面执行remove方法删除节点
6、回写xml
11、使用dom4j获取属性的操作
* 获取第一个name里面的属性id1的值
步骤：
1、得到document
2、得到根节点
3、得到第一个p元素
5、得到p标签下层级的name
6、得到name里面的属性值
- name.attributeValue("id1");
- 在name上面执行这个方法，里面的参数是属性名称
e-code【a.xml】
e-code【封装工具类:Dom4jUtils】
1 package boom.utils; 2 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 import java.io.OutputStreamWriter; 6 7 import org.dom4j.Document; 8 import org.dom4j.DocumentException; 9 import org.dom4j.io.OutputFormat; 10 import org.dom4j.io.SAXReader; 11 import org.dom4j.io.XMLWriter; 12 13 public class Dom4jUtils { 14 public static final String PATH="src/a.xml"; 15 // 返回document 16 public static Document getDocument(String path){ 17 try { 18 // 创建解析器 19 SAXReader reader = new SAXReader(); 20 // 得到document 21 Document document = reader.read(path); 22 return document; 23 } catch (Exception e) { 24 e.printStackTrace(); 25 } 26 return null; 27 } 28 29 // 回写xml的方法 30 public static void xmlWriter(String path,Document document){ 31 try { 32 OutputFormat format = OutputFormat.createPrettyPrint(); 33 XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(path), format); 34 xmlWriter.write(document); 35 xmlWriter.close(); 36 } catch (Exception e) { 37 e.printStackTrace(); 38 } 39 } 40 }
e-code【dom4j.java】
1 package boom.dom4j; 2 3 import java.util.List; 4 5 import org.dom4j.Document; 6 import org.dom4j.DocumentHelper; 7 import org.dom4j.Element; 8 9 import boom.utils.Dom4jUtils; 10 11 public class Dom4j { 12 13 /** 14 * dom4j常规操作 15 * @param args 16 * @throws Exception 17 */ 18 public static void main(String[] args) throws Exception{ 19 /** 20 * 主函数调用方法 21 */ 22 // selectName(); 23 // selectSingle(); 24 // selectSecond(); 25 // addSex(); 26 // addAgeBefore(); 27 // modifyAge(); 28 // delSch(); 29 getValue(); 30 31 } 32 /** 33 *1、查询a.xml中所有name的值 34 * @throws Exception 35 */ 36 public static void selectName() throws Exception{ 37 /*// 1. 创建解析器 38 SAXReader reader = new SAXReader(); 39 // 2. 得到document 40 Document document = reader.read("src/a.xml");*/ 41 42 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 43 // 3. 得到根节点 44 Element root = document.getRootElement(); 45 // 4. 得到所有的p1 46 List<Element> list = root.elements("p"); 47 // 5. 遍历list[增强for循环] 48 for (Element element : list) {// element是每一个p元素 49 // 得到p1下面的name元素 50 Element name = element.element("name"); 51 // 6. 得到name里面的值 52 String s = name.getText(); 53 System.out.println(s); 54 } 55 56 } 57 /** 58 * 59 *2、查询第一个name元素的值 60 * @throws Exception 61 */ 62 public static void selectSingle() throws Exception{ 63 /*// 1. 创建解析器 64 SAXReader reader = new SAXReader(); 65 // 2. 得到document 66 Document document = reader.read("src/a.xml");*/ 67 68 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 69 // 3. 得到根节点 70 Element root = document.getRootElement(); 71 // 4. 得到第一个p标签 72 Element p = root.element("p"); 73 // 5. 得到p1下面的name元素 74 Element name = p.element("name"); 75 // 6. 得到name元素里面的值 76 String s= name.getText(); 77 System.out.println(s); 78 } 79 /** 80 *获取第二个name元素的值 81 * @throws Exception 82 */ 83 84 public static void selectSecond() throws Exception{ 85 /*// 1. 创建解析器 86 SAXReader reader = new SAXReader(); 87 // 2. 得到document 88 Document document = reader.read("src/a.xml");*/ 89 90 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 91 // 3. 得到根节点 92 Element root = document.getRootElement(); 93 // 4. 得到所有的p标签 94 List<Element> list = root.elements("p"); 95 // 5. 得到第二个p标签 list集合下标从0开始 96 Element p = list.get(1); 97 // 6. 得到第二个p标签下的name 98 Element name = p.element("name"); 99 // 7. 得到name元素里面的值 100 String s = name.getText(); 101 System.out.println(s); 102 103 } 104 /** 105 * 4、在第一个p标签末尾添加一个元素 <sex>nv</sex> 106 * @throws Exception 107 */ 108 public static void addSex() throws Exception{ 109 /*// 1. 创建解析器 110 SAXReader reader = new SAXReader(); 111 // 2. 得到document 112 Document document = reader.read("src/a.xml");*/ 113 114 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 115 // 3. 得到根节点 116 Element root = document.getRootElement(); 117 // 4. 得到第一个p标签 118 Element p = root.element("p"); 119 // 5. 在p标签下直接添加新的标签元素sex 120 Element sex = p.addElement("sex"); 121 // 6. 直接在sex新创建的元素下添加元素值 122 sex.addText("男"); 123 124 /*// 7. 回写xml 125 OutputFormat format = OutputFormat.createPrettyPrint(); //createPrettyPrint可以有缩进的效果 126 // OutputFormat format =OutputFormat.createCompactFormat();//createCompactFormat压缩格式[一行显示] 127 XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/a.xml"),format); 128 xmlWriter.write(document);// 返回document 129 xmlWriter.close();// 关闭流*/ 130 131 Dom4jUtils.xmlWriter(Dom4jUtils.PATH, document); 132 } 133 /** 134 * 5、使用dom4j实现在特定位置添加元素 135 * // 在第一个p下面的age标签之前添加 <school>ahszu.edu.cn</schlool> 136 * @throws Exception 137 */ 138 public static void addAgeBefore() throws Exception{ 139 /*// 1. 创建解析器 140 SAXReader reader = new SAXReader(); 141 // 2. 得到document 142 Document document = reader.read("src/a.xml");*/ 143 144 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 145 // 3. 得到根节点 146 Element root = document.getRootElement(); 147 // 4. 得到第一个p标签 148 Element p = root.element("p"); 149 // 5. 得到p标签下的所有元素 150 List<Element> list = p.elements(); 151 // 6. 创建一个新标签 152 Element school = DocumentHelper.createElement("school"); 153 // 7. 在school下面创建文本 154 school.setText("安徽宿州学院"); 155 // 8. 在特定的位置添加 156 list.add(1, school); 157 158 /*// 9. 回写xml 159 OutputFormat format =OutputFormat.createPrettyPrint(); // createPrettyPrint 可以有缩进的效果 160 // OutputFormat format =OutputFormat.createCompactFormat();// createCompactFormat压缩格式[一行显示] 161 XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/a.xml"), format); 162 xmlWriter.write(document);// 返回document 163 xmlWriter.close();// 关闭流*/ 164 Dom4jUtils.xmlWriter(Dom4jUtils.PATH, document); 165 } 166 /** 167 * 6、使用dom4j实现修改节点的操作 168 * 修改第一个p下面的age元素的值 <age>30</age> 169 * @throws Exception 170 */ 171 public static void modifyAge() throws Exception{ 172 // 得到document 173 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 174 // 得到根节点 175 Element root = document.getRootElement(); 176 // 得到第一个p标签 177 Element p = root.element("p"); 178 // 得到p标签下的age标签 179 Element age = p.element("age"); 180 // 修改age值为30 181 age.setText("300"); 182 // 回写xml文档 183 Dom4jUtils.xmlWriter(Dom4jUtils.PATH, document); 184 } 185 /** 186 * 7、使用dom4j实现删除节点的操作 187 * 删除第一个p1下面的<school></school>元素 188 * @throws Exception 189 */ 190 public static void delSch() throws Exception{ 191 // 得到document 192 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 193 // 得到根节点 194 Element root = document.getRootElement(); 195 // 得到第一个p元素 196 Element p = root.element("p"); 197 // 得到p标签的school元素 198 Element school = p.element("school"); 199 // 删除school(通过父节点进行删除)[school.getParent(); // 获取school父节点] 200 p.remove(school); // 已得到元素，直接在p标签上执行remove方法 201 // 回写xml文件 202 Dom4jUtils.xmlWriter(Dom4jUtils.PATH, document); 203 } 204 /** 205 * 8、使用dom4j获取属性的操作 206 * 获取第一个name里面的属性id的值 207 * @throws Exception 208 */ 209 public static void getValue() throws Exception{ 210 // 得到document 211 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 212 // 得到根节点 213 Element root = document.getRootElement(); 214 // 得到第一个p元素[如果获取p标签下面的name，继续层级获取元素。] 215 Element p = root.element("p"); 216 // 得到p标签下层级的name 217 Element name = p.element("name"); 218 // 得到name的属性值 219 String stringId = name.attributeValue("id"); 220 System.out.println("stringId="+stringId); 221 } 222 223 }
12、使用dom4j支持xpath的操作
* 可以直接获取到某个元素
* 第一种形式
/AAA/DDD/BBB： 表示一层一层的，AAA下面 DDD下面的BBB
* 第二种形式
//BBB： 表示和这个名称相同，表示只要名称是BBB，都得到
* 第三种形式
/*: 所有元素
* 第四种形式
** BBB[1]： 表示第一个BBB元素
** BBB[last()]：表示最后一个BBB元素
* 第五种形式
** //BBB[@id]： 表示只要BBB元素上面有id属性，都得到
* 第六种形式
** //BBB[@id='b1'] 表示元素名称是BBB,在BBB上面有id属性，并且id的属性值是b1
13、使用dom4j支持xpath具体操作
默认的情况下，dom4j不支持xpath，如果想要在dom4j里面使用xpath
* 第一步需要，引入支持xpath的jar包，使用 jaxen-1.1-beta-6.jar
** 需要把jar包导入到项目中
* 在dom4j里面提供了两个方法，用来支持xpath
** selectNodes("xpath表达式")
- 获取多个节点
** selectSingleNode("xpath表达式")
- 获取一个节点
使用xpath实现：查询xml中所有name元素的值
* 所有name元素的xpath表示： //name
* 使用selectNodes("//name");
* 代码和步骤：
1、得到document
2、直接使用selectNodes("//name")方法得到所有的name元素
//得到document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//使用selectNodes("//name")方法得到所有的name元素
List<Node> list = document.selectNodes("//name");
//遍历list集合
for (Node node : list) {
//node是每一个name元素
//得到name元素里面的值
String s = node.getText();
System.out.println(s);
}
使用xpath实现：获取第一个p1下面的name的值
* //p1[@id1='aaaa']/name
* 使用到 selectSingleNode("//p1[@id1='aaaa']/name")
* 步骤和代码
1、得到document
2、直接使用selectSingleNode方法实现
- xpath ： //p[@id1='aaaa']/name
//得到document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//直接使用selectSingleNode方法实现
Node name1 = document.selectSingleNode("//p[@id='aaaa']/name"); //name的元素
//得到name里面的值
String s1 = name1.getText();
System.out.println(s1);
e-code【a.xml 和封装工具类:Dom4jUtils】上例子一样
e-code【dom4jXPath.java】
1 package boom.dom4j; 2 3 4 import java.util.List; 5 6 import org.dom4j.Document; 7 import org.dom4j.Element; 8 import org.dom4j.Node; 9 10 import boom.utils.Dom4jUtils; 11 12 public class Dom4jXpath { 13 14 /** 15 * @param args 16 * @throws Exception 17 */ 18 public static void main(String[] args) throws Exception { 19 test1(); 20 // test2(); 21 } 22 /** 23 * 2、查询xml中所有第一个name元素的值 24 * @throws Exception 25 */ 26 public static void test2() throws Exception{ 27 // 得到document 28 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 29 // 得到第一个name元素[selectSingleNode方法实现] 30 Node name = document.selectSingleNode("//p[@id='frist']/name"); 31 String string =name.getText(); 32 System.out.println(string); 33 } 34 /** 35 * 1、查询xml中所有name元素的值 36 * @throws Exception 37 */ 38 public static void test1() throws Exception{ 39 // 得到document 40 Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH); 41 // 得到所有name元素[selectNodes("xpath表达式")] 42 List<Node> list = document.selectNodes("//name"); 43 // 遍历集合 之前for循环实现 44 for (Node node : list) { 45 // node是每一个name元素 46 String getName =node.getText(); // 得到name元素值 47 System.out.println(getName); 48 } 49 } 50 51 }