【黑马程序员】使用DOM4J+XPATH解析带有schema约束的XML文件

使⽤dom4j解析xml⽂件⼀.读取指定位置下的资源⽂件src根⽬录下类名.class.getResourceAsStream("/⽂件名");与读取配置⽂件的类在同⼀包类名.class.getResourceAsStream("⽂件名");WEB-INF(或其⼦⽬录下)ServletContext servletContext=request.getServletContext();InputStream ins = servletContext.getResourceAsStream("/WEB-INF/⽂件名");⼆.解析指定路径下的资源⽂件：properties⽂件的解析⽅式有java.util.properties这个类来完成（properties⽂件以键值对的形式存在，需通过键名来获取值）import java.io.IOException;import java.io.InputStream;import java.util.Properties;public class PropertiseDemo {public static void main(String[] args) throws IOException {//获取到同包下的资源⽂件将其转化为流对象InputStream ins=PropertiseDemo.class.getResourceAsStream("/db.properties");//需要专业的⼯具类来将流中的数据解析出来Properties p=new Properties();p.load(ins);System.out.println("uname");System.out.println("upass");}}解析xml⽂件xml⽂件传统解析⽅式有dom4解析jdk/jdom解析，sax解析jdk/jdom 和 sax解析⽅式都是由上往下解析dom4j解析是由外到内解析，需要导包（dom4j-1.6.1.jar，）由于jdk/jdom和sax解析解析步骤⽐较复杂，使⽤的⼈较少xpath等同数据库的select语句document.selectNodes(xpath);//查⼀组document.selectSingleNode(xpath);//查单个import java.io.File;import org.dom4j.Document;import org.dom4j.DocumentException;import org.dom4j.Element;import org.dom4j.io.SAXReader;public class Dome02 {public static void main(String[] args) throws Exception {// dom4j+path 解析xml⽂件SAXReader saxReader = new SAXReader();Document document = saxReader.read(new File("D:\\eclipse\\j2ee06\\src\\com\\temp\\config.xml"));// 查⼀组for (Object o : document.selectNodes("/config/action/forward")) {Element element = (Element) o;System.out.print(element.attributeValue("mane"));System.out.print(element.attributeValue("path"));System.out.println(element.attributeValue("redirect"));}//查询⼀个Element element=(Element)document.selectSingleNode("/config/action");System.out.println(element.attributeValue("path"));}}列如：import java.io.InputStream;import java.util.List;import org.dom4j.Document;import org.dom4j.DocumentException;import org.dom4j.Element;import org.dom4j.io.SAXReader;public class Temp {public static void main(String[] args) throws Exception {InputStream inputStream = Temp.class.getResourceAsStream("/config.xml");SAXReader sax = new SAXReader();Document document = sax.read(inputStream);// 1. 获取所有action中type的值List<Element> stuElement = document.selectNodes("/config/action");for (Element element : stuElement) {String type = element.attributeValue("type");System.out.println(type);}// 2.获取第⼆个action中的type的值for (Element element : stuElement) {if ("/loginAction".equals(element.attributeValue("path"))) {String type = element.attributeValue("type");System.out.println(type);}}// 3.获取第⼆个action的所有forward的pathfor (Element element : stuElement) {if ("/loginAction".equals(element.attributeValue("path"))) {List<Element> forward = element.selectNodes("forward");for (Element forwardElement : forward) {String path = forwardElement.attributeValue("path");System.out.println(path);}}}// 4、获取第⼆个action的第⼆个forward的pathfor (Element element : stuElement) {if ("/loginAction".equals(element.attributeValue("path"))) {List<Element> forward = (List<Element>) element.selectNodes("forward");for (Element forwardElement : forward) {if ("success".equals(forwardElement.attributeValue("name"))) {String path = forwardElement.attributeValue("path");System.out.println(path);}}}}}}。

dom4j如何解析XML⽂件最近在⼀些对xml⽂件的操作，下⾯简单写⼀个dom4j解析xml⽂件并将其封装到⼀个javabean中的例⼦，只是具有针对性的，不是通⽤的，仅供参考哦~~⾸先说：dom4j是⼀个java的XML api，性能优异、功能强⼤、易于使⽤。

使⽤dom4j对xml⽂件进⾏解析，并完成对⽂件的封装。

接下来，主要使⽤到的是dom4j中的SAXReader类，在这⾥我的流程是传⼊⼀个xml⽂件，调⽤写好的的⼯具类，完成对xml⽂件的解析。

xml⽂件如下：1<?xml version="1.0" encoding="UTF-8"?>23<school>45<college name="数学">6<class name="1612A" classroom="36306">7<student>8<property name="name" value="张三"></property>9<property name="age" value="23"></property>10<property name="garden" value="男"></property>11</student>12<student>13<property name="name" value="李四"></property>14<property name="age" value="22"></property>15<property name="garden" value="⼥"></property>16</student>17<student>18<property name="name" value="王五"></property>19<property name="age" value="24"></property>20<property name="garden" value="男"></property>21</student>22</class>23</college>2425<college name="英语">26<class name="1612C" classroom="35108">27<student>28<property name="name" value="赵六"></property>29<property name="age" value="21"></property>30<property name="garden" value="男"></property>31</student>32<student>33<property name="name" value="陈七"></property>34<property name="age" value="22"></property>35<property name="garden" value="男"></property>36</student>37<student>38<property name="name" value="郭⼋"></property>39<property name="age" value="25"></property>40<property name="garden" value="男"></property>41</student>42<student>43<property name="name" value="孙九"></property>44<property name="age" value="20"></property>45<property name="garden" value="⼥"></property>46</student>47</class>48</college>4950</school>Junit 测试如下：1public class Dom4jTest {23 @Test4public void test() throws Exception{567 File xmlFile = new File("⽂件位置");8// 调⽤⼯具类返回学⽣集合9 List<Student> studentList = XMLUtil.fileTransferList(xmlFile);1011for (Student student : studentList) {1213 System.out.println("-------------------------");14 System.out.println("姓名："+student.getName());15 System.out.println("年龄："+student.getAge());16 System.out.println("性别："+student.getGarden());1718 }1920 }2122 }⼯具类如下：1public class XMLUtil {23public static List<Student> fileTransferList(File file) throws DocumentException{45// 返回值：学⽣信息集合6 List<Student> studentList=new ArrayList<Student>();78// 创建saxReader对象9 SAXReader reader = new SAXReader();1011// 通过read⽅法读取⼀个⽂件转换成Document对象12 Document document = reader.read(file);1314//获取根节点元素对象15 Element root = document.getRootElement();1617// 获取学院节点集合18 List<Element> collegeElements = root.elements();1920//已知属性名情况下21for (Element college : collegeElements) {2223 List<Student> collegeStudentList = getStudentListFromCollegeElement(college);2425 studentList.addAll(collegeStudentList);26 }2728return studentList;29 }3031private static List<Student> getStudentListFromCollegeElement(Element collegeElement){3233// 返回值：学⽣信息集合34 List<Student> studentList = new ArrayList<Student>();3536 List<Element> classElements = collegeElement.elements();3738for (Element classElement : classElements) {3940 List<Student> classStudentList = getStudentListFromClassElement(classElement);4142 studentList.addAll(classStudentList);43 }4445return studentList;4647 }4849private static List<Student> getStudentListFromClassElement(Element classElement){5051// 返回值：学⽣信息集合52 List<Student> studentList = new ArrayList<Student>();5354 List<Element> studentElements = classElement.elements();5556for (Element student : studentElements) {5758 List<Element> propertyElements = student.elements();5960 Student student2 = studentElementTransferStudentEntity(propertyElements);6162 studentList.add(student2);63 }6465return studentList;66 }6768private static Student studentElementTransferStudentEntity(List<Element> propertyElements){ 6970 Student stu = new Student();7172for (Element property : propertyElements) {7374 String name = property.attributeValue("name");75 String value = property.attributeValue("value");7677if("name".equals(name)){78 stu.setName(value);79 }80if("age".equals(name)){81 stu.setAge(value);82 }83if("garden".equals(name)){84 stu.setGarden(value);85 }86 }8788return stu;89 }9091 }最后呢，当然是显⽰结果了~~结果如下：到此结束了，以后也许有有其他解析的⽅法，也希望各位同道⼀块学习~~。

java中使⽤dom4j解析XML⽂件的⽅法教程前⾔dom4j是⼀个java的XML api，性能优异、功能强⼤、易于使⽤。

以前听说过来解析xml⽂件的⼏种标准⽅式；但是从来的没有应⽤过来，所以可以在google中搜索dmo4j解析xml⽂件的⽅式，学习⼀下dom4j解析xml的具体操作。

下⾯话不多说了，来⼀起看看详细的介绍吧注意：使⽤Dom4j开发，需下载dom4j相应的jar⽂件题⽬：后台利⽤dom4j解析student.xml⽂件，并返回List<Student>集合需要解析的XML：<?xml version="1.0" encoding="UTF-8"?><classes><class name="ST01"><student id="10001">user1</student><student id="10002">user2</student><student id="10003">user3</student></class><class name="ST02"><student id="10004">user4</student><student id="10005">user5</student><student id="10006">user6</student></class><class name="ST03"><student id="10007">user7</student><student id="10008">user8</student><student id="10009">user9</student></class><class name="ST04"><student id="10010">user10</student><student id="10011">user12</student><student id="10012">user13</student></class><class name="ST05"><student id="10013">user14</student><student id="10014">user15</student><student id="10015">user16</student></class></classes>java解析xml代码：/*** @author hh*/public class XmlUtil {/*** 读取xml学⽣列表信息* @return*/public List<Student> listStudent(){//创建SAXReader对象SAXReader reader=new SAXReader();Document document = null;try {//通过read⽅法读取⼀个⽂件转换成Document对象document = reader.read(new File("/Users/mac/Documents/students.xml"));} catch (DocumentException e) {e.printStackTrace();}//获取根节点元素对象Element node = document.getRootElement();return elementMethod(node);}/*** 获取节点中的信息* @param node* @return*/private List<Student> elementMethod(Element node){List<Student> list = new ArrayList<Student>();//获取所有class 节点List<Element> elementClass = node.elements("class"); for (Element aClass : elementClass) {//获取所有student节点List<Element> elelmentStu=aClass.elements("student"); for (Element element : elelmentStu) {//创建学⽣对象Student stu = new Student();//class节点⾥name的值stu.setSclazz(aClass.attribute("name").getValue());//student节点⾥ID的值stu.setSid(element.attribute("id").getValue());//student节点⾥的String值stu.setSname(element.getStringValue());list.add(stu);}}return list;}}实体类：/*** @author hh*/public class Student {private String sname;private String sid;private String sclazz;public String getSname() {return sname;}public void setSname(String sname) {this.sname = sname;}public String getSid() {return sid;}public void setSid(String sid) {this.sid = sid;}public String getSclazz() {return sclazz;}public void setSclazz(String sclazz) {this.sclazz = sclazz;}@Overridepublic String toString() {return "Student{" +"sname='" + sname + '\'' +", sid='" + sid + '\'' +", sclazz='" + sclazz + '\'' +'}';}}@Test 代码：public class StudentDaoTest {@Testpublic void testlistStudent(){List<Student> list = new XmlUtil().listStudent();for (Student student : list) {System.out.println(student);}}}运⾏结果：总结以上就是这篇⽂章的全部内容了，希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值，如果有疑问⼤家可以留⾔交流，谢谢⼤家对的⽀持。

如何⽤DOM4J解析XML认识XML XML是Extensible Markup Language 即可扩展标记语⾔的缩写，是⼀种简单的数据储存语⾔，使⽤⼀系列简单的标记来描述数据<element_name attribute_name="value" .../> // ⾃闭合<element_name attribute_name="value" ...> //对1-String2-<element_name attribute_name="value" .../>3-<element_name attribute_name="value" .../>...</element_name></element_name> 对XML的四种解析　 ⽬前常⽤的XML解析技术有4种：（1）DOM DOM是基于XML的树结构来完成解析的，DOM解析XML的⽅式⾮常适⽤于多次访问XML的应⽤程序，但是其⽐较消耗资源；（2）SAX SAX是⼀种基于事件的解析，其主要是为了解决DOM解析的资源消耗问题⽽出现的，其优势是占⽤资源少，内存消耗⼩，⼀般在处理解析数据量⼤的XML⽂档才会使⽤（3）JDOM JDOM的⽬的是直接为JAVA编程服务，利⽤纯Java技术对XML⽂档实现解析⽣成，序列化以及其他操作；（4）DOM4J DOM4J具有性能优异、功能强⼤和易⽤的特点，同时它也是⼀个开放源代码的软件如何⽤DOM4J解析XML数据注：使⽤DOM4J解析XML，依赖于jar包 dom4j和jaxen 实现的步骤： 指定要解析的XML⽂件； 把XML⽂件转换成Document对象； 获取节点属性或⽂本的值。

File xml = new File("xmlfiles/xxx");SAXReader reader = new SAXReader();Document doc = reader.read(xml);//转换为⽂件Element root = doc.getRootElement();//获取节点属性List<Element> elements = root.elements(); //element 节点下⾯举⼀例分别分析xml⽂档 xml⽂档内容如下<?xml version="1.0" encoding="UTF-8"?><root><student id="1"><name>张飞</name><age>999</age><gender>男</gender></student><student id="2"><name>关⽻</name><age>888</age><gender>男</gender></student><student id="3"><name>刘备</name><age>777</age><gender>男</gender></student></root>若要读取XML⽂档中，可以直接⽤字符串输出的⽅式遍历，⾸先获取⼦元素，再遍历⼦元素⽂本//字符串输出for (Element element : elements) {String id = element.attributeValue("id");//获取当前指定⼦元素System.out.print(id+"\t");List<Element> subEs = element.elements();for (Element subE : subEs) {System.out.print(subE.getText()+"\t");//获取当前⼦元素⽂本}System.out.println("\n");}对于⼀个XML⽂档，我们也许需要检索所有的内容，但有时也可能需要检索某⼀固定节点或某⼀个属性，因此我们需要采取不同的检索⽅式 （1）当我们需要检索所有内容时，可以⽤动态数组的形式遍历出来即可； （2）当需要检索某⼀固定节点 Node node = document.selectSingleNode("//nodeName[@attrName = value]"); （3）检索某⼀属性（多节点检索） List<Element> = document.selecNodes("//nodeName[subEleName/text()='value']"); 取⼀分析结果，输出如下//检索固定节点Node node = doc.selectSingleNode("//student[@id=3]");//任意以student为根的节点if (null != node){Element element =(Element)node;String id = element.attributeValue("id");String name = element.elementText("name");String age = element.elementText("age");String gender = element.elementText("gender");Student student = new Student(Integer.parseInt(id),name,Integer.parseInt(age),gender);System.out.println(student);}当我们需要对XML⽂件进⾏改动时，有三种情况分别为新增、删除以及修改（变动过之后必须落盘） （1）新增 Element ele = root.addElement(...); Element subEle = ele.addElement(String nodeName); （2）删除 Element xxx = ... father.renmove(xxx); （3）修改 xxx.attribute(String attrName).setValue(String value); xxx.element(String subName).setText(String text); 下⾯例⼦为删除操作//删除//内存操作Node node = doc.selectSingleNode("//xxx[@id=3]");if (null != node){root.remove(node);//存盘OutputFormat format = OutputFormat.createPrettyPrint();XMLWriter writer = new XMLWriter(new OutputStreamWriter(new FileOutputStream("xmlfiles/kb.xml"),"UTF-8"),format);writer.write(doc);writer.flush();writer.close();}else {System.out.println("⽤户不存在");}。

dom4j解析xml⽂件⼀、利⽤dom4j创建⼀个内容如下的xml⽂件SqlMapConfig.xml1<?xml version="1.0" encoding="UTF-8" ?>2<!DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN"3 "ibatis-3-config.dtd">4<configuration>5<environments default="development">6<environment id="MySQL">7<transactionManager type="JDBC">123</transactionManager>8<dataSource type="POOLED">9<property name="driver" value="com.mysql.jdbc.Driver"/>10<property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>11<property name="username" value="root"/>12<property name="password" value="admin"/>13</dataSource>14</environment>15</environments>1617<mappers>18<mapper resource="com/pojo/sql/DepMap.xml"/>19<mapper resource="com/pojo/sql/EmpMap.xml"/>20</mappers>21</configuration>步骤：1.创建⼀个输出流，指定创建的SqlMapConfig.xml⽂件的位置-------OutputStreamOutputStream os = new FileOutputStream("d:/SqlMapConfig.xml");2.创建⼀个xml编写器-------XMLWriterXMLWriter writer = new XMLWriter(os,OutputFormat.createPrettyPrint());这⾥os是前⾯新建的⼀个输出流，OutputFormat.createPrettyPrint()是指定输出的格式的，这⾥代表内容缩进。

Xml文件解析方法解析的数据源已经布署完成了（具体可参考xml文件的解析简介），那么接下来就该编写解析该数据源的业务方法了。

1.编写业务bean实体新建一个实体包（com.itheima.weather.domain），编写业务bean。

●定义该业务bean的成员变量，如例1-1所示:例1-1例1-2public int getId() {return id;}public void setId(int id) {this.id = id;}public String getCity() {return city;}public void setCity(String city) {this.city = city;}public String getTemp() {return temp;}public void setTemp(String temp) {this.temp = temp;}public String getWind() {return wind;}public void setWind(String wind) {this.wind = wind;}public int getPm250() {return pm250;}public void setPm250(int pm250) {this.pm250 = pm250;}重写业务bean的toString()方法，如例1-3所示：例1-3@Overridepublic String toString() {return "城市id=" + id + ", 城市名称=" + city + ", 温度=" + temp+ ", 风力=" + wind + ", 埋汰指数=" + pm250 ;}2.编写业务方法新建一个业务包（com.itheima.weather.service），编写解析xml的业务方法。

使⽤dom4j解析xml⽂件使⽤dom4j解析xml⽂件2017-09-12⽬录xml源⽂件<?xml version="1.0" encoding="GB2312" ?><PhoneInfo><Brand name="华为"><Type name="P9"/></Brand><Brand name="苹果"><Type name="iphone5"/><Type name="iphone6"/></Brand></PhoneInfo>代码：import java.io.FileWriter;import java.io.IOException;import java.io.Writer;import java.util.Iterator;import org.dom4j.*;import org.dom4j.io.OutputFormat;import org.dom4j.io.SAXReader;import org.dom4j.io.XMLWriter;public class Dom4jTest {Document dom = null;public static void main(String[] args) {Dom4jTest dom4j = new Dom4jTest();//获得Dom树dom4j.getDom();//添加新的节点dom4j.addNode();//更改元素属性dom4j.modify();//更改三星属性dom4j.modifySan();//删除节点dom4j.delete();//保存xml⽂件dom4j.saveXml("⼿机信息.xml");//显⽰xml⽂件dom4j.showInfo();}// 获得dom树public void getDom() {//通过reader获得Dom树SAXReader reader = new SAXReader();try {dom = reader.read("收藏信息.xml");} catch (DocumentException e) {// TODO Auto-generated catch blocke.printStackTrace();}// 保存xml⽂件public void saveXml(String path) {//设置编码格式//可以直接使⽤⽆参构造,效果也⼀样//OutputFormat encoding=new OutputFormat();OutputFormat encoding = OutputFormat.createPrettyPrint(); encoding.setEncoding("gb2312");Writer writer = null;try {writer = new FileWriter(path);//使⽤XMLWriter类进⾏dom树的输出XMLWriter writerXml = new XMLWriter(writer, encoding);//使⽤Write()进⾏dom树的写writerXml.write(dom);//最后关闭相关流writerXml.close();writer.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}// 显⽰xml⽂件信息public void showInfo() {//获得dom树的根节点Element BrandElements = dom.getRootElement();//获得元素的Iterator集合Iterator elementIterator = BrandElements.elementIterator();//对Interator集合进⾏遍历while (elementIterator.hasNext()) {Element brandElement = (Element) elementIterator.next();//获得元素的属性String brand = brandElement.attributeValue("name");//继续从上⼀个节点获得下⼀节点Iterator集合Iterator typeElements = brandElement.elementIterator();while (typeElements.hasNext()) {Element typeElement = (Element) typeElements.next(); String type = typeElement.attributeValue("name");System.out.println("⼿机：" + brand + ",型号" + type); }}}// 添加节点public void addNode() {//获得根节点Element Root = dom.getRootElement();//添加Brand元素Element brand = Root.addElement("Brand");//为Brand元素添加属性brand.addAttribute("name", "三星");//继续在新加元素添加Type元素Element type = brand.addElement("Type");//为Type元素添加属性type.addAttribute("name", "note");}// 修改属性，添加ID属性public void modify() {Element root = dom.getRootElement();Iterator elementIterator = root.elementIterator();int i = 0;while (elementIterator.hasNext()) {Element brand = (Element) elementIterator.next();brand.addAttribute("id", (++i) + "");}}//修改三星为SAMSUNGpublic void modifySan() {Element rootElement = dom.getRootElement();Iterator elementIterator = rootElement.elementIterator();while (elementIterator.hasNext()) {Element brand = (Element) elementIterator.next();if (brand.attributeValue("name").equals("三星")) {brand.addAttribute("name", "SAMSUNG");}}// 删除SAMSUNG元素public void delete() {Element rootElement = dom.getRootElement();Iterator elementIterator = rootElement.elementIterator();while (elementIterator.hasNext()) {Element brand = (Element) elementIterator.next();if (brand.attributeValue("name").equals("SAMSUNG")) { brand.getParent().remove(brand);}}}}。

如何使用DOM解析XML文件DOM（Document Object Model）是一种用于解析和处理XML文件的常用技术。

DOM API允许开发者以树形的数据结构方式访问和操作XML文件的内容。

1.导入DOMAPI：首先，你需要在你的代码中导入DOMAPI相关的类和方法。

在大多数编程语言中，都有现成的DOM库可供使用。

3. 加载XML文件：将要解析的XML文件加载到解析器中，可以使用解析器的`load(`或`parse(`方法，这个方法会将XML文件读取到内存中。

4. 创建一个DOM树：通过调用解析器的`getDocument(`或`parse(`方法，可以获取解析器对XML文件进行解析后的DOM树对象。

5. 获取根节点：通过DOM树对象的`getDocumentElement(`方法，可以获取XML文件的根节点。

6. 遍历子节点：通过DOM树对象的`getChildNodes(`方法，可以获取根节点的所有子节点。

然后，你可以使用循环遍历这些子节点，获取它们的内容和属性，并进一步操作。

7. 获取节点内容：通过DOM树节点对象的`getNodeValue(`方法，可以获取节点的文本内容。

如果节点有子节点，可以使用`getChildNodes(`方法获取它们的内容。

8. 获取节点属性：通过DOM树节点对象的`getAttribute(`方法，可以获取节点的属性值。

你需要在括号中指定要获取的属性名称。

9. 修改节点内容：通过DOM树节点对象的`setNodeValue(`方法，可以修改节点的文本内容。

10. 修改节点属性：通过DOM树节点对象的`setAttribute(`方法，可以修改节点的属性值。

你需要在括号中指定要修改的属性名称和新值。

11. 创建新节点：通过DOM树节点对象的`createElement(`方法，可以创建一个新节点对象。

你需要在括号中指定节点名称。

12. 添加节点：通过DOM树节点对象的`appendChild(`方法，可以将新节点添加为现有节点的子节点。

scala中引用dom4j解析xml使用Scala中的dom4j库解析XML文件一、引言在软件开发过程中，经常需要处理和解析XML数据。

XML是一种标记语言，用于存储和传输数据。

为了方便处理XML数据，许多编程语言提供了相应的库和工具。

本文将介绍如何使用Scala中的dom4j库来解析XML文件。

二、dom4j简介dom4j是一个用于处理XML数据的Java库。

它提供了简单易用的API，使开发人员能够轻松地读取、修改和创建XML文档。

dom4j库具有高性能和低内存消耗的特点，因此被广泛应用于各种项目中。

三、使用dom4j解析XML1. 导入dom4j库首先，我们需要在Scala项目中导入dom4j库。

可以使用SBT或Maven等构建工具来管理项目依赖。

2. 创建XML解析器在Scala中使用dom4j解析XML文件，首先需要创建一个XML解析器对象。

可以通过如下代码来创建一个解析器对象：```scalaval xmlParser = new SAXReader()```3. 加载XML文件使用解析器对象加载XML文件。

可以通过文件路径或输入流来加载XML文件。

例如，使用文件路径加载XML文件的代码如下：```scalaval document = xmlParser.read(new File("path/to/xml/file.xml"))```4. 解析XML数据通过解析器对象，可以获取XML文档的根元素，并遍历其子元素和属性。

以下示例代码演示了如何解析XML数据：```scalaval rootElement = document.getRootElement()// 遍历子元素val elements = rootElement.elements()for (i <- 0 until elements.size()) {val element = elements.get(i).asInstanceOf[Element]// 处理子元素println("子元素名称：" + element.getName())}// 获取属性val attributes = rootElement.attributes()for (i <- 0 until attributes.size()) {val attribute = attributes.get(i).asInstanceOf[Attribute]// 处理属性println("属性名：" + attribute.getName() + "，属性值：" + attribute.getValue())}```5. 解析XML文档结构dom4j库提供了丰富的API来解析XML文档的结构。

dom4j解析xml现在有很多⼯具包可以解析xml⽂件，但是dom4j⽆疑是其中较为简单的⼀种，下⾯就⽤⼀个例⼦来实际操作⼀下：⾸先得导⼊dom4j.jar这个夹包（⽹上⼀搜⼀⼤⽚）1.随便在⼀个地⽅建⽴⼀个user.xml⽂件，我这⼉是建⽴在d盘根⽬录下：1. <?xml version="1.0" encoding="UTF-8"?>2.3. <users>4. <user username="lisi" password="123"/>5. <user username="张三" password="123"/>6. <user username="zhangsan" password="123"/>7.8. </users><?xml version="1.0" encoding="UTF-8"?><users><user username="lisi" password="123"/><user username="张三" password="123"/><user username="zhangsan" password="123"/></users>2.对该⽂件进⾏模拟查询⽤户（按姓名查询）和添加⽤户：1. package com.easyteam.dao;2.3. import java.io.FileNotFoundException;4. import java.io.FileOutputStream;5. import java.io.IOException;6. import java.io.OutputStream;7. import java.io.OutputStreamWriter;8. import java.io.UnsupportedEncodingException;9.10. import org.dom4j.Document;11. import org.dom4j.DocumentException;12. import org.dom4j.Element;13. import org.dom4j.io.OutputFormat;14. import org.dom4j.io.SAXReader;15. import org.dom4j.io.XMLWriter;16.17. import er;18.19.20. public class Userdao {21.22. String path="d://user.xml";23.24. public User findByName(String username){25. SAXReader red=new SAXReader();//创建解析器26. try {27. Document doc=red.read(path);//得到documet对象28. Element el=(Element) doc.selectSingleNode("//user[@username='"+username+"']");//查询条件，其中//表⽰⽆限深度查询，[]中放⼊是查询条件29. if(el==null) return null;30. String attUsername=el.attributeValue("username");//得到username这个属性的值31. String attPassword=el.attributeValue("password");32. User user=new User();33. user.setUsername(attUsername);34. user.setPassword(attPassword);35. return user;36. } catch (DocumentException e) {37. throw new RuntimeException(e);38. }39. }40. public void addUser(User user){41.42. SAXReader red=new SAXReader();43. try {44. Document doc = red.read(path);45. Element attroot=doc.getRootElement();//得到根节点46. Element userel=attroot.addElement("user");//添加节点47. userel.addAttribute("username", user.getUsername());//给新节点赋值48. userel.addAttribute("password", user.getPassword());49.50. OutputFormat format=new OutputFormat("\t", true);//设置格式51. format.setTrimText(true);//清除原有格式52. XMLWriter writer;53. try {54. writer=new XMLWriter(new OutputStreamWriter(new FileOutputStream(path),"utf-8"),format);//实例化55. writer.write(doc);//保存56. writer.close();57. } catch (Exception e) {58. throw new RuntimeException(e);59. }60.61. } catch (DocumentException e) {62. throw new RuntimeException(e);63. }64. }65. }3.测试类：1. package com.easyteam.test;2.3. import org.junit.Test;4.5. import erdao;6. import er;7.8.9. public class UserDaoTest {10. @Test11.12. public void testfindByName(){13. Userdao dao=new Userdao();14. User user= dao.findByName("lisi");15. System.out.println(user);16.17. }18. @Test19. public void testaddUser(){20. Userdao dao=new Userdao();21. User user=new User();22. user.setUsername("张三");23. user.setPassword("123");24. dao.addUser(user);25.26.27.28. }29. }。

Dom4j解析xml⽂件-递归遍历所有节点和属性Dom4j是中常⽤读取xml⽂件的⼯具，就⽅便性和性能⽅⾯，⼀定程度要优于JDK中Domcument和SAX解析的，感兴趣的童鞋可以看看这篇⽂章，下边我就分享⼀下⽤Dom4j对xml⽂件进⾏遍历，⼀看代码就明⽩了，注释的很详细。

被测试的xml⽂件test.xml<?xml version="1.0" encoding="UTF-8"?><root><user editor="chenleixing" date="2015-02-15"><name>张三</name><year>24</year><sex>男</sex></user><user editor="zhangxiaochao" date="2015-02-15"><name>李四</name><year>24</year><sex>⼥</sex></user></root>创建File,获取根节点/*** 从指定节点开始,递归遍历所有⼦节点* @author chenleixing*/public void getNodes(Element node){System.out.println("--------------------");//当前节点的名称、⽂本内容和属性System.out.println("当前节点名称："+node.getName());//当前节点名称System.out.println("当前节点的内容："+node.getTextTrim());//当前节点名称List<Attribute> listAttr=node.attributes();//当前节点的所有属性的listfor(Attribute attr:listAttr){//遍历当前节点的所有属性String name=attr.getName();//属性名称String value=attr.getValue();//属性的值System.out.println("属性名称："+name+"属性值："+value);}//递归遍历当前节点所有的⼦节点List<Element> listElement=node.elements();//所有⼀级⼦节点的listfor(Element e:listElement){//遍历所有⼀级⼦节点this.getNodes(e);//递归}}从指定节点开始，递归遍历所有节点和属性/*** 从指定节点开始,递归遍历所有⼦节点* @author chenleixing*/public void getNodes(Element node){System.out.println("--------------------");//当前节点的名称、⽂本内容和属性System.out.println("当前节点名称："+node.getName());//当前节点名称System.out.println("当前节点的内容："+node.getTextTrim());//当前节点名称 List<Attribute> listAttr=node.attributes();//当前节点的所有属性的list for(Attribute attr:listAttr){//遍历当前节点的所有属性String name=attr.getName();//属性名称String value=attr.getValue();//属性的值System.out.println("属性名称："+name+"属性值："+value);}//递归遍历当前节点所有的⼦节点List<Element> listElement=node.elements();//所有⼀级⼦节点的list for(Element e:listElement){//遍历所有⼀级⼦节点this.getNodes(e);//递归}}输出结果--------------------当前节点名称：root当前节点的内容：--------------------当前节点名称：user当前节点的内容：属性名称：editor属性值：chenleixing属性名称：date属性值：2015-02-15--------------------当前节点名称：name当前节点的内容：张三--------------------当前节点名称：year当前节点的内容：24--------------------当前节点名称：sex当前节点的内容：男--------------------当前节点名称：user当前节点的内容：属性名称：editor属性值：zhangxiaochao属性名称：date属性值：2015-02-15--------------------当前节点名称：name当前节点的内容：李四--------------------当前节点名称：year当前节点的内容：24--------------------当前节点名称：sex当前节点的内容：⼥。

⽤Dom4j来解析XML⽂件Dom4j jar包地址：提取码：w5om⾸先解压Dom4j jar包，解压后如下然后把 dom4j-1.6.1.jar 复制放到⼯程⽬录下（集成开发⼯具是myeclipse）在myeclipse⼯程下直接右键dom4j-1.6.1.jar，点击Build Path → Add to Build Pathmyeclipse⾃动导⼊jar包，然后就可以使⽤jar包提供的接⼝了。

我们创建⼀个book.xml⽂件放到src⽬录下book.xml⽂件内容如下：<?xml version="1.0" encoding="UTF-8"?><书架> <书 > <书名>时间简史</书名> <作者>霍⾦</作者> <售价>60</售价> </书> <书> <书名>⼴义相对论</书名> <作者>爱因斯坦</作者> <售价>65</售价> </书></书架>Dom4j_parseXML.java编写解析代码需要导⼊的包：import java.io.FileOutputStream;import java.util.List;import org.dom4j.Document;import org.dom4j.Element;import org.dom4j.Node;import org.dom4j.io.OutputFormat;import org.dom4j.io.SAXReader;import org.dom4j.io.XMLWriter;注意：除了FileOutputStream和List不是dom4j包的，其他的都是创建解析器//创建dom4j解析器SAXReader reader = new SAXReader();//加载document对象Document document = reader.read("src/book.xml");得到某个节点的内容//拿到根节点Element root = document.getRootElement();//拿到所有的书节点List<Element> list = root.elements("书");//拿到第⼆本书Element bookE1 = list.get(1);//获取售价⽂本System.out.println(bookE1.elementText("售价"));遍历所有元素节点public static void ergodic(Document document) { treeWalk( document.getRootElement() );}public static void treeWalk(Element element) { for ( int i = 0, size = element.nodeCount(); i < size; i++ ) { Node node = element.node(i); if ( node instanceof Element ) { System.out.println(node.getName()); treeWalk( (Element) node ); } }}修改某个元素节点的主体内容//获取根节点Element root = document.getRootElement();//拿到第⼆种书节点Element bookEL = (Element) root.elements("书").get(1);//拿到售价节点Element priceE1 = bookEL.element("售价");//改变主体内容priceE1.setText("55");//将结果保存到硬盘上XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),OutputFormat.createPrettyPrint()); writer.write(document);writer.close();向指定元素节点中添加⼦元素节点//获取根节点Element root = document.getRootElement();//拿到第⼀种书节点Element bookEL = (Element) root.elements("书").get(0);//拿到售价节点Element priceE1 = bookEL.element("售价");//添加⼦节点priceE1.addElement("内部价").setText("50");//将结果保存到硬盘上XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),OutputFormat.createPrettyPrint()); writer.write(document);writer.close();向指定元素节点上增加同级元素节点//获取根节点Element root = document.getRootElement();//拿到第⼀种书节点Element bookEL = (Element) root.elements("书").get(0);//给书节点添加⼦节点bookEL.addElement("批发价").setText("30");//将结果保存到硬盘上XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),OutputFormat.createPrettyPrint()); writer.write(document);writer.close();删除指定的元素节点Element root = document.getRootElement();Element bookEL = (Element) root.elements("书").get(0);Element insideprice = bookEL.element("售价").element("内部价");//删除insideprice.getParent().remove(insideprice);//将结果保存到硬盘上XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),OutputFormat.createPrettyPrint()); writer.write(document);writer.close();操作⽂件的属性//获取根节点Element root = document.getRootElement();//拿到第⼀种书节点Element bookEL = (Element) root.elements("书").get(0);//增加⼀个属性bookEL.addAttribute("类", "科普");//将结果保存到硬盘上XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),OutputFormat.createPrettyPrint()); writer.write(document);writer.close();以上就是⽤dom4j来解析XML⽂件的⼏种⽅式。

【黑马程序员】Dom4J解析XML的范例浅析前言XML是可扩展标记语言的缩写，在编程领域是非常常用的，我们经常会用它进行数据的传输或者用作配置文件，那么对XML的操作的也会是我们需要掌握的一项技术，本文会使用Java语言，利用DOM4J这个非常优秀的开源库，探讨生成XML格式数据和解析XML数据的两个方面的问题。

1. Dom4J简介在上，是这么介绍的：Dom4j是一个易用的、开源的库，用于XML，XPath 和XSLT。

它应用于Java平台，采用了Java集合框架并完全支持DOM，SAX和JAXP。

简单来说，Dom4j具有性能优秀，操作简单的优点2. Dom4j的使用2.1 导入jar包这个操作非常简单，我们可以在网上下载jar包，或者在https:///projects/dom4j/?source=directory下载了dom4j项目之后，解压缩成jar包，然后导入项目中2.2 案例一：用Java代码生成xml文档代码思路：我们要生成一个XML文档，其实就像我们平时书写文档是一样的道理：创建文档-> 创建根元素-> 添加根元素子元素也是先创建再添加到其他元素中如果元素上有属性则先添加属性下面直接上代码import java.io.FileOutputStream;import java.io.FileWriter;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.OutputFormat;import org.dom4j.io.XMLWriter;public class Dom4JTest1 {public static void main(String[] args) throws Exception {// 第一种方式：创建文档，并创建根元素// 创建文档:使用了一个Helper类Document document = DocumentHelper.createDocument();// 创建根节点并添加进文档Element root = DocumentHelper.createElement("student");document.setRootElement(root);// 第二种方式:创建文档并设置文档的根元素节点Element root2 =DocumentHelper.createElement("student");Document document2 =DocumentHelper.createDocument(root2);// 添加属性root2.addAttribute("name", "zhangsan");// 添加子节点:add之后就返回这个元素Element helloElement = root2.addElement("hello");Element worldElement = root2.addElement("world");helloElement.setText("hello Text");worldElement.setText("world text");// 输出// 输出到控制台XMLWriter xmlWriter = new XMLWriter();xmlWriter.write(document);// 输出到文件// 格式OutputFormat format = new OutputFormat(" ", true);// 设置缩进为4个空格，并且另起一行为trueXMLWriter xmlWriter2 = new XMLWriter(new FileOutputStream("student.xml"), format);xmlWriter2.write(document2);// 另一种输出方式，记得要调用flush()方法,否则输出的文件中显示空白XMLWriter xmlWriter3 = new XMLWriter(newFileWriter("student2.xml"),format);xmlWriter3.write(document2);xmlWriter3.flush();// close()方法也可以}}程序Console输出：<?xml version="1.0" encoding="UTF-8"?><student/>生成的一个xml文档：<?xml version="1.0" encoding="UTF-8"?><student name="zhangsan"><hello>hello Text</hello><world>world text</world></student>小总结到目前为止我们已经完成了对一个xml格式数据的生成，如果要生成其他样式的数据，也是比较类似的操作，本文就不再赘述了。

Java中使⽤DOM4J来⽣成xml⽂件和解析xml⽂件⼀、前⾔现在有不少需求,是需要我们解析xml⽂件中的数据,然后导⼊到数据库中,当然解析xml⽂件也有好多种⽅法,⼩编觉得还是DOM4J⽤的最多最⼴泛也最好理解的吧.⼩编也是最近需求⾥遇到了,就来整理⼀下⾃⼰的理解,只适合刚刚学习的,⼀起理解!今天我们把解析xml⽂件和⽣成xml⽂件在⼀起来展⽰.⼆、准备依赖<dependency><groupId>dom4j</groupId><artifactId>dom4j</artifactId><version>1.6.1</version></dependency>三、⽣成xml⽂件⽣成标准展⽰⽣成xml代码/*** 使⽤DOM4J⽣成xml⽅法*/public static void createXml(){try {// 创建document对象Document document = DocumentHelper.createDocument();// 创建根节点bookRootElement StudentRoot = document.addElement("StudentRoot");// 向根节点中添加第⼀个节点Element book1 = StudentRoot.addElement("student");// 向⼦节点中添加属性book1.addAttribute("id","1");// 向节点中添加⼦节点Element name = book1.addElement("name");// 向⼦节点赋值name.setText("⼩乔");Element price = book1.addElement("age");price.setText("18");// 向根节点中添加第⼆个节点Element book2 = StudentRoot.addElement("student");book2.addAttribute("id","2").addElement("name").setText("⼤桥");book2.addElement("age").setText("20");// 向根节点中添加第三个节点Element book3 = StudentRoot.addElement("student");book3.addAttribute("id","3").addElement("name").setText("孙策");book3.addElement("age").setText("21");// 设置⽣成xml的格式OutputFormat of = OutputFormat.createPrettyPrint();// 设置编码格式of.setEncoding("UTF-8");// ⽣成xml⽂件File file = new File("E:\\student.xml");if (file.exists()){file.delete();}//创建⼀个xml⽂档编辑器XMLWriter writer = new XMLWriter(new FileOutputStream(file), of);//把刚刚创建的document放到⽂档编辑器中writer.write(document);writer.close();} catch (Exception e) {e.printStackTrace();}}四、解析xml⽂件解析xml的⽂件就是刚刚导出的那个样⼦,我们展⽰两种情况,⼀个是知道属性名字和⼦元素名字的我们把解析的xml ⽂件数据放到实体类中.不知道的就直接打印到控制台.实体类展⽰import lombok.Data;@Datapublic class Student {private int id;private String name;private int age;}解析xml⽂件⽅法public static void analysis(){// 把要解析的xml变成file⽂件File file = new File("E:\\student.xml");// 获取解析器对象SAXReader reader = new SAXReader();// 把⽂件解析成document树Document document = null;try {document = reader.read(file);} catch (DocumentException e) {e.printStackTrace();}// 获取根节点Element studentRoot = document.getRootElement();// 获取根节点中所有节点List<Element> elements = studentRoot.elements();// 存放xml中节点的数据集合List<Student> list = new ArrayList<>();// 便利所有节点for (Element child : elements) {Student student = new Student();//已知属性名情况下student.setId(Integer.parseInt(child.attributeValue("id")));//获取属性的数据//已知⼦元素名的情况下student.setName(child.elementText("name"));//获取元素中值student.setAge(Integer.parseInt(child.elementText("age")));//获取元素中值list.add(student);//未知属性名情况下List<Attribute> attributes = child.attributes();for (Attribute attribute : attributes) {System.out.println(attribute.getName() + "---> " + attribute.getValue());}//未知⼦元素名情况下List<Element> elementList = child.elements();for (Element ele : elementList) {System.out.println(ele.getName() + "--->" + ele.getText());}}//把解析xml出来的数据集合打印list.forEach(x-> System.out.println(x));}解析结果展⽰五、总结这样我们就把DOM4J来⽣成xml⽂件和解析xml⽂件就都操作完成了,有什么问题留⾔哦!!谢谢⼤家。

java使⽤dom4j解析xml⽂件关于xml的知识，及作⽤什么的就不说了，直接解释如何使⽤dom4j解析。

假如有如下xml:dom4j解析xml其实很简单，只要你有点java基础，知道xml⽂件。

结合下⾯的xml⽂件和java代码，多看⼏遍（代码很简单，不要嫌看代码烦），把他解析的过程看明⽩，就会很简单<?xml version="1.0" encoding="UTF-8"?><students><student><name type="String">aaa</name><age type="int">22</age></student><student><name type="String">bbb</name><age type="int">23</age></student><student><name type="String">ccc</name><age type="int">21</age></student></students>加⼊我们解析上⾯这个xml⽂件，⽆⾮是想得到其中的 name值，age值，有时候还需要type值使⽤到的类有：org.dom4j.io.SAXReader; --read 提供多种读取xml⽂件的⽅式，返回⼀个Domcument对象 org.dom4j.Document; --iterator 使⽤此法获取node --getRootElement 获取根节点 org.dom4j.Attribute; --getName 获取属性名 --getValue 获取属性值 org.dom4j.Element; --attributes 返回该元素的属性列表 --attributeValue 根据传⼊的属性名获取属性值 --elementIterator 返回包含⼦元素的迭代器 --elements 返回包含⼦元素的列表 下⾯看⼀下java代码public static void domxml() throws Exception {// SAXReader就是⼀个管道，⽤⼀个流的⽅式，把xml⽂件读出来SAXReader reader = new SAXReader();// read 提供多种读取xml⽂件的⽅式，返回⼀个Domcument对象Document document = reader.read(new File("F:" + File.separator + "student.xml"));// 获取根节点Element rootElement = document.getRootElement();System.out.println("根的名称：" + rootElement.getName());// 拿到根节点的名称Iterator iter = rootElement.elementIterator(); // 获取根节点下的⼦节点while (iter.hasNext()) {StringBuffer sb = new StringBuffer("");// ⼦节点Element nodeElement = (Element) iter.next();// System.out.println("-根下第⼀层节点名称："+nodeElement.getName()+",值"+nodeElement.getText());sb.append("" + nodeElement.getName() + ":");// 节点属性Iterator i = nodeElement.elementIterator();while (i.hasNext()) {Element e = (Element) i.next();// System.out.println("--根下第⼆层节点名称："+e.getName()+",节点值："+e.getText());sb.append(e.getName() + "-" + e.getText() + ";");//遍历节点属性值List<Attribute> attr=e.attributes();for(Attribute a:attr){System.out.println("---节点属性："+a.getName()+",属性值"+a.getText());}}System.out.println(sb);sb = null;}}如果你看明⽩了上⾯的代码，看懂了，你肯定会绝得这⾥嵌套了两个while,加⼊有三层的话，是不是得写三个while？不知道你看我上⾯的代码后有什么想法？反正我弄明⽩之后，⽴马就想到了改⽤递归写这个解析的⽅法，于是代码如下：public static void dgXml(Element element) {if (element.nodeCount() > 0) {// 还有⼦节点Iterator<?> it = element.elementIterator();while (it.hasNext()) {Element e = (Element) it.next();String name = e.getName();String value = e.getTextTrim().equals("")? "空": e.getTextTrim();System.out.print(name + "," + value+ ";Data[");if(e.attributeCount()>0){Iterator<?> ait=e.attributeIterator();while(ait.hasNext()){Attribute attribute = (Attribute) ait.next();System.out.print(attribute.getName()+"|"+attribute.getText()+";");}}System.out.println("]");dgXml(e);}}}。

小鲁哥哥白话笔记-XML（解析）上次我们对XML有了一个详细的认识，知道了它是怎么存储数据的，和它的存储结构。

今天我们聊一聊怎么去解析XML文件来获取数据。

XML解析有两种方式：DOM方式和SAX方式，DOM：Document Object Model，文档对象模型。

这种方式是W3C推荐的处理XML的一种方式。

SAX：Simple API for XML。

这种方式不是官方标准，属于开源社区XML-DEV，几乎所有的XML解析器都支持它。

XML解析开发包JAXP：是SUN公司推出的解析标准实现。

Dom4J：是开源组织推出的解析开发包。

(牛，大家都在用，包括SUN公司的一些技术的实现都在用。

)我们能看到上述一共列举了2中解析开发包，但是我们在开发中一般都是使用Dom4J来进行对XML文件的解析，所以我们今天只给大家讲一讲常用的Dom4J，想JAXP我们今天就不做过多的阐述了，感兴趣的同学可以在下方留言，我们在进行解答。

Dom4J：* Dom4J的常用方法：* Document* Element getRootElement() :获取根元素对象（根标签）* Element* List elements() ：获取所有的子元素* List elements(String name)：根据指定的元素名称来获取相应的所有的子元素* Element element(String name)：根据指定的元素名称来获取子元素对象,如果元素名称重复，则获取第一个元素* String elementText(String name) ：根据指定的子元素名称，来获取子元素中的文本* String getText() ：获取当前元素对象的文本* void setText(String text)：设置当前元素对象的文本* String attributeValue(String name)：根据指定的属性名称获取其对应的值* public Element addAttribute(String name,String value)：根据指定的属性名称和值进行添加或者修改BeanUtils的常用方法给大家用Dom4J举个例子：XML文件内容：<?xml version="1.0" encoding="UTF-8"?><State Code="37" Name="河南"description="郑州" GDP="99999亿"><City><Name>郑州</Name><Region>高薪区</Region></City><City>三门峡</City><City>洛阳</City><City>安阳</City><City>南阳</City></State>解析一个XML文件：privatestaticvoid method2() throws Exception {//2、遍历所有元素节点:打印他们的元素名称。

Dom4j使⽤Xpath语法读取xml节点<span style="font-size: small;" mce_style="font-size: small;">package com.wt.dom4j;import java.util.List;import org.dom4j.Document;import org.dom4j.Element;import org.dom4j.io.SAXReader;/*** Dom4j基础操作** @author wTang* @editTime 2011年3⽉16⽇0:38:10**/public class Dom4jParser {public static void main(String[] args) {try {SAXReader sax = new SAXReader();// 获得dom4j的⽂档对象Document root = sax.read(Dom4jParser.class.getClassLoader().getResourceAsStream("employee.xml"));// 得到database节点Element database = (Element) root.selectSingleNode("//employee[@id='2']");List list = database.elements(); // 得到database元素下的⼦元素集合/** 循环遍历集合中的每⼀个元素将每⼀个元素的元素名和值在控制台中打印出来*/for (Object obj : list) {Element element = (Element) obj;// getName()是元素名,getText()是元素值System.out.println(element.getName() + ": " + element.getText());}} catch (Exception e) {e.printStackTrace();}}}</span>表达式:Element database = (Element) root.selectSingleNode("//employee[@id='2']");输出为:name: wTang2age: 20high: 180表达式: Element database = (Element) root.selectSingleNode("/root/employee[1]");输出为:name: wTangage: 19high: 173我们可以给id⾥⾯的值做个参数, 封装为⽅法即可给外界调⽤.// 表⽰从匹配选择的当前节点选择⽂档中的节点，⽽不考虑它们的位置。

java使用xpath和dom4j解析xmlXPath是一门在XML文档中查找信息的语言,下面介绍一下java使用xpath和dom4j解析xml的示例,大家参考使用吧1 XML文件解析的4种方法通常解析XML文件有四种经典的方法。

基本的解析方式有两种，一种叫SAX，另一种叫DOM。

SAX是基于事件流的解析，DOM是基于XML文档树结构的解析。

在此基础上，为了减少DOM、SAX的编码量，出现了JDOM，其优点是，20-80原则（帕累托法则），极大减少了代码量。

通常情况下JDOM使用时满足要实现的功能简单，如解析、创建等要求。

但在底层，JDOM还是使用SAX（最常用）、DOM、Xa nan文档。

另外一种是DOM4J，是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用的特点，同时它也是一个开放源代码的软件。

如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。

具体四种方法的使用，百度一下，会有众多详细的介绍。

2 XPath简单介绍XPath是一门在XML文档中查找信息的语言。

XPath用于在 XML 文档中通过元素和属性进行导航，并对元素和属性进行遍历。

XPath 是 W3C XSLT 标准的主要元素，并且 XQuery 和 XPointer 同时被构建于 XPath 表达之上。

因此，对 XPath 的理解是很多高级 XML 应用的基础。

XPath非常类似对数据库操作的SQL语言，或者说JQuery，它可以方便开发者抓起文档中需要的东西。

其中DOM4J也支持XPath的使用。

3 DOM4J使用XPathDOM4J使用XPath解析XML文档是，首先需要在项目中引用两个JAR包：dom4j-1.6.1.jar：DOM4J软件包，下载地址/projects/dom4j/；jaxen-xx.xx.jar：通常不添加此包，会引发异常（ng.NoClassDefFoundError: org/jaxen/ JaxenException），下载地址/releases.html。

简单用DOM4J结合XPATH解析XML由于DOM4J在解析XML时只能一层一层解析，所以当XML文件层数过多时使用会很不方便，结合XPATH就可以直接获取到某个元素使用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使用dom4j支持xpath具体操作默认的情况下，dom4j不支持xpath，如果想要在dom4j里面是有xpath，第一步需要，引入支持xpath的jar包，如下：在dom4j里面提供了两个方法，用来支持xpathselectNodes("xpath表达式")，获取多个节点selectSingleNode("xpath表达式")，获取一个节点应用简单案例：1.xml文件<?xml version="1.0" encoding="UTF-8"?><class><student><name>张三</name><sid>111111</sid></student><student id="stu1"><name>李四</name><sid>222222</sid></student></class>Java代码import java.util.List;import org.dom4j.Document;import org.dom4j.Node;import org.dom4j.io.SAXReader;public class Dom4jXpath {public static void main(String[] args) throws Exception { select();//查询所有name的值//select2();//查询id=stu1的学生的name的值}//查询所有name的值private static void select() throws Exception { SAXReader saxReader=new SAXReader();Document document=saxReader.read("src/1.xml"); List<Node>list=document.selectNodes("//name");for(int i=0;i<list.size();i++)System.out.println(list.get(i).getT ext());}//查询id=stu1的学生的name的值private static void select2() throws Exception {SAXReader saxReader=new SAXReader();Document document=saxReader.read("src/1.xml");Nodenode=document.selectSingleNode("//student[@id='stu1']/nam e");System.out.println(node.getText());}}。