您的位置：360文档中心› dom4j解析XML的基本用法

dom4j解析XML的基本用法

合集下载

使用dom4j解析xml文件

使用dom4j解析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文件

dom4j如何解析XML文件

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 }最后呢，当然是显⽰结果了~~结果如下：到此结束了，以后也许有有其他解析的⽅法，也希望各位同道⼀块学习~~。

使用DOM4J解析XML文档

使用DOM4J解析XML文档

使⽤DOM4J解析XML⽂档使⽤DOM4J时,需要,导⼊专⽤的jar包才可以使⽤------------------------DOM4J也是⽬前⽐较流⾏的⽐较常⽤的解析XML⽂档的⼀种⽅式.package ParseXML;import java.util.Iterator;import org.dom4j.Attribute;import org.dom4j.Document;import org.dom4j.DocumentException;import org.dom4j.Element;import org.dom4j.Node;import org.dom4j.io.SAXReader;/*** DOM4J的使⽤.* @author ⼩王同学.* 简述:* DOM4J是⼀个java XML API 是,JDOM的升级品,⽤来读写XML⽂件.***/public class TestDOM4J {public static void main(String[] args) throws Exception {//1.创建SAXReader对象SAXReader sr =new SAXReader();//2.调⽤read⽅法Document doc = sr.read("book.xml");//3.获取跟元素Element element= doc.getRootElement();//4.通过迭代器遍历直接节点//System.out.println(element.getName());for(Iterator<Element> it = element.elementIterator();it.hasNext();){Element node = it.next();for(Iterator<Attribute> it2= node.attributeIterator();it2.hasNext();){Attribute attr= it2.next();System.out.println(attr.getName()+"\t"+attr.getValue());}for(Iterator<Element> childList =node.elementIterator();childList.hasNext();){Element childElement= childList.next();System.out.println(childElement.getName()+"\t"+childElement.getStringValue());}}}} 运⾏截图......加油!。

java中使用dom4j解析XML文件的方法教程

java中使用dom4j解析XML文件的方法教程

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文档

Dom4j解析XML文档

要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在/ 目前最新dom4j包下载地址:/sourceforge/dom4j/dom4j-1.6.1.zip解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要加入包jaxen-1.1-beta-7.jar.以下是相关操作:一.Document对象相关1.读取XML文件,获得document对象.SAXReader reader = new SAXReader();Document document = reader.read(new File("input.xml"));2.解析XML形式的文本,得到document对象.String text = "<members></members>";Document document = DocumentHelper.parseText(text);3.主动创建document对象.Document document = DocumentHelper.createDocument();Element root = document.addElement("members");// 创建根节点二.节点相关1.获取文档的根节点.Element rootElm = document.getRootElement();2.取得某节点的单个子节点.Element memberElm=root.element("member");// "member"是节点名3.取得节点的文字String text=memberElm.getText();也可以用:String text=root.elementText("name");这个是取得根节点下的name字节点的文字.4.取得某节点下名为"member"的所有字节点并进行遍历.List nodes = rootElm.elements("member");for (Iterator it = nodes.iterator(); it.hasNext();) {Element elm = (Element) it.next();// do something}5.对某节点下的所有子节点进行遍历.for(Iterator it=root.elementIterator();it.hasNext();){Element element = (Element) it.next();// do something}6.在某节点下添加子节点.Element ageElm = newMemberElm.addElement("age");7.设置节点文字.ageElm.setText("29");8.删除某节点.parentElm.remove(childElm);// childElm是待删除的节点,parentElm是其父节点三.属性相关.1.取得某节点下的某属性Element root=document.getRootElement();Attribute attribute=root.attribute("size");// 属性名name2.取得属性的文字String text=attribute.getText();也可以用:String text2=root.element("name").attributeValue("firstname");这个是取得根节点下name字节点的属性firstname的值.3.遍历某节点的所有属性Element root=document.getRootElement();for(Iterator it=root.attributeIterator();it.hasNext();){Attribute attribute = (Attribute) it.next();String text=attribute.getText();System.out.println(text);}4.设置某节点的属性和文字.newMemberElm.addAttribute("name", "sitinspring");5.设置属性的文字Attribute attribute=root.attribute("name");attribute.setText("sitinspring");6.删除某属性Attribute attribute=root.attribute("size");// 属性名nameroot.remove(attribute);四.将文档写入XML文件.1.文档中全为英文,不设置编码,直接写入的形式.XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));writer.write(document);writer.close();2.文档中含有中文,设置编码格式写入的形式.OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("GBK"); // 指定XML编码XMLWriter writer = new XMLWriter(new FileWriter("output.xml"),format);writer.write(document);writer.close();五.字符串与XML的转换1.将字符串转化为XMLString text = "<members> <member>sitinspring</member> </members>"; Document document = DocumentHelper.parseText(text);2.将文档或节点的XML转化为字符串.SAXReader reader = new SAXReader();Document document = reader.read(new File("input.xml"));Element root=document.getRootElement();String docXmlText=document.asXML();String rootXmlText=root.asXML();Element memberElm=root.element("member");String memberXmlText=memberElm.asXML();六.使用XPath快速找到节点.读取的XML文档示例<?xml version="1.0" encoding="UTF-8"?><projectDescription><name>MemberManagement</name><comment></comment><projects><project>PRJ1</project><project>PRJ2</project><project>PRJ3</project><project>PRJ4</project></projects><buildSpec><buildCommand><name>org.eclipse.jdt.core.javabuilder</name><arguments></arguments></buildCommand></buildSpec><natures><nature>org.eclipse.jdt.core.javanature</nature></natures></projectDescription>使用XPath快速找到节点project.public static void main(String[] args){SAXReader reader = new SAXReader();try{Document doc = reader.read(new File("sample.xml"));List projects=doc.selectNodes("/projectDescription/projects/project");Iterator it=projects.iterator();while(it.hasNext()){Element elm=(Element)it.next();System.out.println(elm.getText());}}catch(Exception ex){ex.printStackTrace();}}级别：初级Deepak Vohra (dvohra09@), Web 开发人员2004 年4 月01 日dom4j 是一种解析XML 文档的开放源代码XML 框架。

如何用DOM4J解析XML

如何用DOM4J解析XML

如何⽤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用法

dom4j用法

dom4j用法dom4j是一个开源的JavaXML解析库，用于解析XML文档并提供API来操作XML元素和属性。

它可以轻松地读取、分析和生成XML文件。

dom4j支持使用XPath表达式来访问XML文档中的节点和属性。

XPath是一种用于在XML文档中定位节点的语言。

dom4j还提供了一些高级功能，如XML命名空间的支持和DTD验证。

使用dom4j可以轻松地解析XML文档，例如：```SAXReader reader = new SAXReader();Document document = reader.read(newFile('path/to/xml/file.xml'));Element root = document.getRootElement();List<Element> elements = root.elements();for (Element element : elements) {//访问元素}```在上面的代码中，我们使用SAXReader类读取XML文档，并获取根元素。

然后，我们可以使用getRootElement()方法获取XML文档的根元素，并使用elements()方法获取根元素的所有子元素。

除了解析XML文档外，dom4j还提供了API来创建新的XML文档。

例如：```Document document = DocumentHelper.createDocument();Element root = document.addElement('root');Element child = root.addElement('child');child.addAttribute('attribute', 'value');child.setText('text');```在上面的代码中，我们使用DocumentHelper类创建一个新的XML 文档，并添加根元素和一个子元素。

dom4j解析xml文件

dom4j解析xml文件

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()是指定输出的格式的，这⾥代表内容缩进。

dom4j解析XML的基本用法

dom4j解析XML的基本用法

dom4j解析XML的基本用法dom4j解析XML的基本用法1. 需要的包：dom4j-1.4/dom4j.jar2. 用到的类：import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.XMLWriter;import org.dom4j.DocumentException;import org.dom4j.io.SAXReader;3. 基本操作：创建文档：Document document = DocumentHelper.createDocument();创建根节点：Element catalogElement = document.addElement("catalog");添加注释： catalogElement.addComment("注释");处理指令：catalogElement.addProcessingInstruction("target","text");增加子节点：Element journalElement = catalogElement.addElement("journal");给节点添加属性：journalElement.addAttribute("title", "值");设置节点中的文本：journalElement.setText("值");添加文档类型：document.addDocType("catalog", null,"file://c:/Dtds/catalog.dtd ");创建 xml 文件：XMLWriter output = new XMLWriter(new FileWriter( new File("c:/catalog/catalog.xml") ));output.write( document );output.close();加载 xml 文件：SAXReader saxReader = new SAXReader(); //SAXReader 包含在 org.dom4j.io 包中。

DOM4J详细教程

DOM4J详细教程

DOM4J详细教程
答：
DOM4J是一个Java XML API，它可以用来快速、高效地读取、生成和
修改XML数据。

它支持XPath的完整实现，支持Java5的新功能，并有一
个强大的可扩展的SAX集成，还支持JAXP 1.3、通过支持性能良好的DOM、SAX以及JAXP的结合，它可以提供XML文档的可用性。

1.使用DOM4J
使用DOM4J解析XML文档的主要步骤如下：
（1）创建一个Document对象，该文档对象将描述整个XML文档。

（2）创建一个XMLReader对象，该对象使用DOM4J的API来解析
XML文档。

（3）创建一个DocumentHandler对象，该对象用来处理XML文档内容，如处理XML文档的根元素和子元素等。

（4）使用XMLReader的parse方法来将Document对象与DocumentHandler对象相关联，以便允许访问Document对象的内容。

（5）执行任何必要的处理来解析XML文档中的元素。

2.DOM4J技术
（1）XML读取
DOM4J提供了一组API，可以在处理XML文档时使用。

DOM4J的
org.dom4j.io.XMLReader类可以解析XML文档，将其转换为DOM4J的
Document对象。

它可以使用InputSource或java.io.Reader对象的任何对象，以确保可以将XML文档从字符串、文件或URL读取。

（2）XML写入
（3）XPath查询。

java dom4j 解析

java dom4j 解析

java dom4j 解析
DOM4J是一个用于处理XML文档的Java开源库。

它提供了简单
易用的API，可以方便地解析、创建和操作XML文档。

DOM4J采用了
基于树形结构的解析方式，可以轻松地遍历和操作XML文档的节点。

要使用DOM4J解析XML文档，首先需要引入DOM4J库。

然后，
可以通过以下步骤进行解析：
1. 读取XML文档，使用SAXReader类的read方法加载XML文档，将其转换为Document对象。

2. 获取根节点，通过Document对象的getRootElement方法获
取XML文档的根节点。

3. 遍历节点，可以使用递归或迭代的方式遍历XML文档的节点，获取节点的名称、属性、文本内容等信息。

4. 操作节点，可以对节点进行增删改查操作，例如添加新节点、修改节点内容、删除节点等。

5. 获取节点信息，可以通过节点对象的方法获取节点的名称、文本内容、属性值等信息。

在使用DOM4J解析XML文档时，需要注意处理异常情况，例如文件不存在、格式错误等。

可以使用try-catch块来捕获异常，并进行相应的处理。

总的来说，DOM4J提供了一种简单而强大的方式来解析XML文档，通过上述步骤可以轻松地实现对XML文档的解析和操作。

DOM4J 还支持XPath表达式和XSLT转换等高级特性，可以满足各种复杂的XML处理需求。

希望以上信息能够帮助你更好地理解和应用DOM4J 库。

dom4j xpath语法

dom4j xpath语法

dom4j xpath语法一、什么是dom4j xpath语法dom4j是一个用于操作XML文档的Java开源库，它提供了一种简单而强大的方式来使用xpath语法对XML文档进行解析和查询。

xpath 是一种用于在XML文档中定位节点的语言，它可以通过路径表达式来选择节点或节点集合。

二、dom4j xpath语法的基本用法1. 选择节点使用xpath语法可以选择XML文档中的节点，例如：- 选择根节点：/- 选择当前节点：.- 选择子节点：/- 选择父节点：..- 选择属性节点：/@属性名2. 谓语谓语可以用于过滤节点，例如：- 选择所有属性为id的节点：//节点名[@属性名='属性值']- 选择第一个子节点：/节点名[1]3. 选择节点集合使用xpath语法可以选择多个节点，例如：- 选择所有子节点：/节点名/*- 选择所有后代节点：//节点名- 选择所有具有相同父节点的节点：/节点名1 | /节点名24. 选择文本内容使用xpath语法可以选择节点中的文本内容，例如：- 选择节点中的文本内容：/节点名/text()- 选择节点及其后代节点中的文本内容：//节点名/text()5. 使用通配符通配符可以用于匹配节点名，例如：- 选择所有节点：//*- 选择所有具有相同父节点的节点：/节点名/*三、dom4j xpath语法的高级用法1. 使用函数xpath语法支持多种内置函数，例如：- 选择所有包含指定文本的节点：//节点名[contains(text(),'文本内容')]- 选择所有具有指定属性的节点：//节点名[@属性名]2. 使用轴轴可以用于选择相对于当前节点的节点，例如：- 选择当前节点的所有子节点：child::- 选择当前节点的所有父节点：parent::- 选择当前节点的所有祖先节点：ancestor::- 选择当前节点的所有后代节点：descendant::四、dom4j xpath语法的实例应用假设有以下XML文档：```<bookstore><book category="web"><title lang="en">Learning XML</title><author>Erik T. Ray</author><year>2003</year><price>39.95</price></book><book category="web"><title lang="en">XQuery Kick Start</title> <author>James McGovern</author><year>2003</year><price>49.99</price></book><book category="programming"><title lang="en">Java Programming</title> <author>John Doe</author><year>2005</year><price>59.99</price></book></bookstore>```我们可以使用dom4j xpath语法来查询和操作这个XML文档，例如：- 选择所有book节点：//book- 选择所有category属性为web的book节点：//book[@category='web']- 选择所有title节点的文本内容：//title/text()- 选择第一个book节点的author节点的文本内容：//book[1]/author/text()五、dom4j xpath语法的注意事项1. xpath语法区分大小写，要注意节点名和属性名的大小写。

scala中引用dom4j解析xml

scala中引用dom4j解析xml

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

dom4j解析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结合XPATH解析XML

简单用DOM4J结合XPATH解析XML

简单用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());}}。

Dom4j解析xml文件-递归遍历所有节点和属性

Dom4j解析xml文件-递归遍历所有节点和属性

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来解析XML文件

⽤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⽂件的⼏种⽅式。

XML解析器——Dom4j

XML解析器——Dom4j

XML解析器——Dom4j⼀、Dom4j 技术概述 先是 Jdom 在 dom 基础上进⾏了封装，⽽ dom4j ⼜对 jdom 进⾏了封装。

DOM4J是⼀个开源的，基于Java的库来解析XML⽂档，它具有⾼度的灵活性，⾼性能和内存效率的API。

这是java的优化，使⽤Java集合像列表和数组。

它可以使⽤DOM，SAX，XPath和XSLT。

它解析⼤型XML⽂档时具有极低的内存占⽤。

⼆、DOM4j 类库 1、类库 官⽹下载需要的 jar 包： 2、使⽤ dom4j 的 jar包： docs 是⽂档⽬录： 在docs ⾥⾯找到 index.html ，快速⼊门三、DOM4j 解析步骤 步骤：1、先加载 xml ⽂件创建 Document 对象2、通过 Document 对象拿到根元素对象3、通过根元素.elelemts(标签名); 可以返回⼀个集合，这个集合⾥放着。

所有你指定的标签名的元素对象4、获取需要操作的元素，进⾏相应的操作 XML ⽂件：1 <?xml version="1.0" encoding="UTF-8"?>2 <books>3 <book sn="123">4 <name>Java</name>5 <price>9.9</price>6 <author>⽼张</author>7 </book>8 <book sn="456">9 <name>Python</name>10 <price>99.99</price>11 <author>⽼李</author>12 </book>13 </books> 测试解析⽂件：1 /*2 * dom4j 获取 Documet 对象3 */4 @Test5 public void getDocument() throws DocumentException {6 // 要创建⼀个 Document 对象，需要我们先创建⼀个 SAXReader 对象7 SAXReader reader = new SAXReader();8 // 这个对象⽤于读取 xml ⽂件，然后返回⼀个 Document。

Dom4j解析XML文档

Dom4j解析XML文档

//使用Dom4j创建XML文档//【1】定义一个XML文档对象Document document=DocumentHelper.createDocument();//【2】定义一个XML元素，添加根结点Element root=document.addElement("根结点名称");///Element接口重要常用方法///addComment 添加注释///addAttribue 添加属性///addElement 添加子元素//【3】通过XMLWriter生成物理文件XMLWriter writer=new XMLWriter(fos,format);writer.write(document);///参数fos是指输出流;参数format为格式化文件//OutputFormat类格式化输出-默认采用createC-//ompactFromat比较紧凑-最好使用createPrettyPrint////DOm4j解析XML文件///【1】构建XML文档对象SAXReader reader=new SAXReader();////创建SAXReader对象--用来读取文档Document document=reader.read(new File("E:/student.xml"));///读取XML文档对象//【2】获取根结点Element root=document.getRootElement();///【3】获取子结点//【--1--】通过element()方法获取指定名称的第一个节点Element student=root.element("student");for(Iterator iterator=student.elementIterator();iterator.hasNext();){Element element=(Element)iterator.next();System.out.println(element.getStringValue());}//【--2--】通过elements()方法获取指定名称的全部节点Element student=root.elements("student");for(Iterator iterator=student.elementIterator();iterator.hasNext();){Element element=(Element)iterator.next();System.out.println(element.getStringValue());}///【4】获取属性的方法Element student=root.element("student");Attribute attribute=student.attribute("id");///按照顺序获取属性//student.attribute(0);List list=student.attribute("id");///获取全部属性///【5】修改XML文档Element root=document.getRootElement();///获取根结点Element student=root.element("studnet");///获取要修改的父结点Element name=student.element("name");///获取修改节点name.setText("--");///修改节点内容name.setName("--");///个性节点名Attribute id=student.attribute("id");id.setText("3");////【6】删除节点或者属性Element root=document.getRootElement();///获取根结点Element student=root.element("studnet");///获取要删除的父结点Element name=student.element("name");///获取删除节点name.remove(name);////删除指定节点studnet.remove(studnet.attribute("id"));//删除节点属性值///使用DOM生成解析XML文件//【1】创建DocumentBuilderFactory工厂-通过该工厂得到//DOM解析器工厂实例DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();///【2】通过解析器工厂获取DOM解析器DocumentBuilder builder=factory.newDocumentBuilder();///【3】从XML文件中解析Document对象语法:XML路径信息Document document=builder.parse(String path);///【4】从XML标签中获得所有属性值语法如下:NodeList nodeList=document.getElementsByTagName(String tagname);。

javadom4j解析xml用到的几个方法

javadom4j解析xml用到的几个方法

javadom4j解析xml⽤到的⼏个⽅法１．读取并解析XML⽂档：SAXReader reader = new SAXReader();Document document = reader.read(new File(fileName));reader的read⽅法是重载的，可以从InputStream, File, Url等多种不同的源来读取。

得到的Document对象就带表了整个XML。

读取的字符编码是按照XML⽂件头定义的编码来转换。

如果遇到乱码问题，注意要把各处的编码名称保持⼀致即可。

２．取得Root节点Element root=document.getRootElement();root元素是xml⽂档的根节点。

⼀切XML分析都是从Root元素开始的。

３．遍历XML树 DOM4J提供⾄少3种遍历节点的⽅法： 1) 枚举(Iterator) // 枚举所有⼦节点 for ( Iterator i = root.elementIterator(); i.hasNext(); ) { Element element = (Element) i.next(); // do something } // 枚举名称为foo的节点 for ( Iterator i = root.elementIterator(foo); i.hasNext();) { Element foo = (Element) i.next(); // do something } // 枚举属性 for ( Iterator i = root.attributeIterator(); i.hasNext(); ) { Attribute attribute = (Attribute) i.next(); // do something }List<Element> elementList=root.elements(); 获得根元素下的所有⼦节点。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

attribute.setValue("Introductory");
}
获取某节点的子节点
Iterator iterator=element.elementIterator("title");
while(iter.hasNext()){
Attribute attribute=(Attribute)iter.next();
if(attribute.getValue().equals("Intermediate"))
1. 需要的包：dom4j-1.4/dom4j.jar
2. 用到的类：import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.XMLWriter;
增加子节点：Element journalElement = catalogElement.addElement("journal");
给节点添加属性：journalElement.addAttribute("title", "值");
设置节点中的文本：journalElement.setText("值");
添加文档类型：document.addDocType("catalog", null,"file://c:/Dtds/catalog.dtd ");
创建 xml 文件：
XMLWriter output = new XMLWriter(
加载 xml 文件：
SAXReader saxReader = new SAXReader(); //SAXReader 包含在 org.dom4j.io 包中。
Document document = saxReader.read(new File("c:/catalog/catalog.xml"));
或者读取字节数组
Document document = reader.read(new ByteArrayInputStream(string.getBytes("UTF-8")));
使用 XPath 表达式从 article 元素中获得 level 节点列表
new FileWriter( new File("c:/catalog/catalog.xml") ));
output.write( document );
output.close();
如果 level 属性值是“Intermediate”则改为“Introductory”。
List list = document.selectNodes("//article/@level " );
Iterator iter=list.iterator();
创建根节点：Element catalogElement = document.addElement("catalog");
添加注释： catalogElement.addComment("注释");
Hale Waihona Puke 处理指令： catalogElement.addProcessingInstruction("target","text");
�
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
3. 基本操作：
创建文档： Document document = DocumentHelper.createDocument();
相关文档
最新文档