java 解析xml 并导入数据库(dom4j )

学习：Dom4j1、DOM4J简介DOM4J是 出品的一个开源XML 解析包。

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

DOM4J 使用起来非常简单。

只要你了解基本的XML-DOM 模型，就能使用。

Dom：把整个文档作为一个对象。

DOM4J 最大的特色是使用大量的接口。

它的主要接口都在org.dom4j里面定义：接口之间的继承关系如下：interface ng.Cloneableinterface org.dom4j.Nodeinterface org.dom4j.Attributeinterface org.dom4j.Branchinterface org.dom4j.Documentinterface org.dom4j.Elementinterface org.dom4j.CharacterDatainterface org.dom4j.CDATAinterface mentinterface org.dom4j.Textinterface org.dom4j.DocumentTypeinterface org.dom4j.Entityinterface org.dom4j.ProcessingInstruction2、XML文档操作12.1、读取XML文档：读写XML文档主要依赖于org.dom4j.io包，有DOMReader和SAXReader两种方式。

因为利用了相同的接口，它们的调用方式是一样的。

public static Docum ent load(String filenam e) {Document docum ent =null;try {SAXReader saxReader = new SAXReader();docum ent =saxReader.read(new File(filename)); //读取XML文件,获得docum ent 对象} catch (Exception ex) {ex.printStackTrace();}return docum ent;}或public static Docum ent load(URL url) {Document docum ent =null;try {SAXReader saxReader = new SAXReader();docum ent =saxReader.read(url); //读取XML文件,获得docum ent对象} catch (Exception ex) {ex.printStackTrace();}return docum ent;}//读取指定的xml文件之后返回一个Document对象，这个对象代表了整个XML文档，用于各种Do m运算。

java dom4j 解析DOM4J是一个用于处理XML文档的开源Java库，提供了一种基于树形结构的XML文档处理方式。

通过DOM4J库，我们可以方便地读取、修改和生成XML 文档。

在Java中，使用DOM4J解析XML文档通常需要以下步骤：1. 导入DOM4J库：首先需要将DOM4J库导入到项目中，可以通过Maven或手动下载jar包的方式导入。

2. 创建Document对象：在DOM4J中，XML文档的顶层结构是Document对象，我们需要先创建一个Document对象来表示整个XML文档。

3. 读取XML文档：通过DOM4J提供的SAXReader类，我们可以读取XML 文档并将其解析为Document对象。

可以使用SAXReader的read方法来读取XML 文档。

4. 获取根节点：通过Document对象的getRootElement方法可以获取XML文档的根节点，从而可以通过根节点逐级遍历XML文档的结构。

5. 遍历XML文档：可以通过递归遍历XML文档的节点，获取节点的名称、属性、文本内容等信息。

可以使用Element对象的elements方法获取子节点，使用attributeValue方法获取节点属性的值，使用getText方法获取节点的文本内容。

6. 修改XML文档：通过DOM4J可以方便地修改XML文档的内容，包括添加节点、修改节点属性、修改节点文本内容等操作。

可以使用Element对象的addElement方法添加子节点，setAttributeValue方法修改节点属性的值，setText方法修改节点的文本内容。

7. 生成XML文档：通过DOM4J可以将Document对象生成为XML文档，可以通过OutputFormat类设置XML文档的格式，通过XMLWriter类将Document对象输出为XML文档。

总的来说，使用DOM4J解析XML文档可以方便地读取、修改和生成XML文档，提供了一种便捷的XML文档处理方式。

Java中Dom4j解析XML与利⽤DOM、SAX、JAXP机制来解析xml相⽐DOM4J表现更优秀，具有性能优异、功能强⼤和极端易⽤使⽤的特点，只要懂得DOM基本概念，就可以通过dom4j的api⽂档来解析xml.dom4j是⼀套开源的api。

实际项⽬中，往往选择dom4j来作为解析xml的利器。

sax解析:jdom解析:dom解析:1package com.test;23import java.io.File;4import java.util.ArrayList;5import java.util.Iterator;6import java.util.List;78import org.dom4j.Document;9import org.dom4j.Element;10import org.dom4j.io.SAXReader;1112public class Dom4jXML {1314public static void main(String[] args) {15 SAXReader saxReader = new SAXReader();16 File file = new File("e:/People.xml");1718try {19 Document document = saxReader.read(file);20 Element root = document.getRootElement();21 List<People> peoples = new ArrayList<People>();22for (Iterator iterator = root.elementIterator(); iterator.hasNext();) {23 People people = new People();24 Element peopleElement = (Element) iterator.next();25 people.setId(peopleElement.attribute("id").getValue());26for (Iterator childIterator = peopleElement.elementIterator(); childIterator.hasNext();) {27 Element childPeopleElement = (Element) childIterator.next();28if (childPeopleElement.getName().equals("Name")) {29 people.setEnglishName(childPeopleElement.attribute("en").getValue());30 people.setName(childPeopleElement.getText());31 } else if (childPeopleElement.getName().equals("Age")) {32 people.setAge(childPeopleElement.getText());33 }34 }35 peoples.add(people);36 }3738for (People p : peoples) {39 System.out.println(p.getId()+"\t"+p.getName()+"\t"+p.getEnglishName()+"\t"+p.getAge());40 }4142 } catch (Exception e) {43// TODO Auto-generated catch block44 e.printStackTrace();45 }4647 }48 }People对象1package com.test;23public class People {4private String id;5private String name;6private String englishName;7private String age;8public String getId() {9return id;10 }11public void setId(String id) {12this.id = id;13 }14public String getName() {15return name;16 }17public void setName(String name) { = name;19 }20public String getEnglishName() {21return englishName;22 }23public void setEnglishName(String englishName) { 24this.englishName = englishName;25 }26public String getAge() {27return age;28 }29public void setAge(String age) {30this.age = age;31 }3233 }xml:1<?xml version="1.0" encoding="UTF-8"?>2<PeopleList>3<People id="1">4<Name en='zhangsan'>张三</Name>5<Age>20</Age>6</People>7<People id="2">8<Name en='lisi'>李四</Name>9<Age>30</Age>10</People>11</PeopleList>。

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 文档，并添加根元素和一个子元素。

Xml文件：<?xml version="1.0" encoding="UTF-8"?><student><!--first xml--><call show="no"><name>studentname</name><English>78</English><Chinese>78</Chinese><Japan>98</Japan></call><call show="no"><name>studentname</name><English>77</English><Chinese>68</Chinese><Japan>88</Japan></call></student>JAVA文件：import java.io.File;import java.io.FileWriter;import java.io.IOException;import java.util.Iterator;import java.util.List;import org.dom4j.Attribute;import org.dom4j.Document;import org.dom4j.DocumentException;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.OutputFormat;import org.dom4j.io.SAXReader;import org.dom4j.io.XMLWriter;/***DOM4j对xml文件的操作*操作DOM4j的时候注意要导入3个jar包，否则会报异常*dom4j-1.6.1.jar*jaxen-1.1-beta-6.jar*saxpath.jar**/public class ReaderDom4j {/***创建一个xml文件**/public static void createxml() {//使用 DocumentHelper 类创建一个文档实例。

java解析XML⽂件Java解析XML⽂件可以使⽤DOM4J这⾥记录⼀下使⽤DOM4J-2.1.1解析XML⽂件的基本⽅法第⼀步，下载所需jar包Jar包下载地址：下载后将jar包导⼊⼯程第⼆步，编写测试⽤XML1<?xml version="1.0" encoding="UTF-8"?>2<commands>3<command condition="text" targetIndex="0" action="input" value="minchen">4</command>5<command condition="button" targetIndex="0" action="click" value="">6</command>7</commands>第三步，解析解析代码如下：1 SAXReader reader = new SAXReader();2 Document document = null;3try {4 document = reader.read(new File("test.xml"));5 } catch (DocumentException e) {6// TODO Auto-generated catch block7 e.printStackTrace();8 }910 Element rootNode = document.getRootElement();1112 Iterator<Element> elementIterator = rootNode.elementIterator();1314while(elementIterator.hasNext()) {15 Element commandElem = elementIterator.next();16 System.out.println(commandElem.attributeValue("condition"));17 System.out.println(commandElem.attributeValue("targetIndex"));18 System.out.println(commandElem.attributeValue("action"));19 System.out.println(commandElem.attributeValue("value"));20 }。

java解析xml并导入数据库（dom4j）java 解析xml 并导入数据库（dom4j ) import java.io.File;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.util.Iterator;import java.util.List;import org.dom4j.Document;import org.dom4j.Element;import org.dom4j.io.SAXReader;public class TestXMLImport {/*** @param args*/public static void main(String[] args) {String sql = "insert into T_XML(NUMERO, REPOSICION, NOMBRE, TURNOS) values (?, ?, ?, ?)";Connection conn = null;PreparedStatement pstmt = null;try {conn = DbUtil.getConnection();pstmt = conn.prepareStatement(sql);Document doc = new SAXReader().read(newFile("D:/share/JavaProjects/drp/test_xmlImport/xml/test01.X ML "));List itemList = doc.selectNodes("/ACCESOS/item/SOCIO");for (Iterator iter=itemList.iterator(); iter.hasNext();) { Element el = (Element)iter.next();String numero = el.elementText("NUMERO");String reposicion = el.elementText("REPOSICION");String nombre = el.elementText("NOMBRE");List turnosList = el.elements("TURNOS");StringBuffer sbString = new StringBuffer();for (Iterator iter1=turnosList.iterator(); iter1.hasNext();) {Element turnosElt = (Element)iter1.next();String lu = turnosElt.elementText("LU");String ma = turnosElt.elementText("MA");String mi = turnosElt.elementText("MI");String ju = turnosElt.elementText("JU");String vi = turnosElt.elementText("VI");String sa = turnosElt.elementText("SA");String doo = turnosElt.elementText("DO");sbString.append(lu + "," + ma + "," + mi + "," + ju + "," + vi + "," + sa + "," + doo);}pstmt.setString(1, numero);pstmt.setString(2, reposicion);pstmt.setString(3, nombre);pstmt.setString(4, sbString.toString());pstmt.addBatch();}pstmt.executeBatch();System.out.println("将XML导入数据库成功！");} catch (Exception e) {e.printStackTrace();} finally {DbUtil.close(pstmt);DbUtil.close(conn);}}}--------------------------------------------------------------------------------------------------------------------------------- 00045050MOISES MORENOT1T2T3T4T5T6T7。

Java解析XML文件使用Dome4J解析1，必须下载Dome4j包，（自行百度）2，导包3，就可以开始解析了import java.io.FileWriter;import java.io.IOException;import java.util.Iterator;import org.dom4j.Document;import org.dom4j.DocumentException; import org.dom4j.Element;import org.dom4j.io.OutputFormat; import org.dom4j.io.SAXReader; import org.dom4j.io.XMLWriter;public class Dome04 {private Document doc;public void document() {SAXReader saxReader = new SAXReader();try {doc = saxReader.read("NewFile.xml");} catch (DocumentException e) {e.printStackTrace();}}// 读取XML文件public void shouinfo() {Element dome = doc.getRootElement();Iterator<?> it = dome.elementIterator();while (it.hasNext()) {Element a = (Element) it.next();System.out.println(a.attributeValue("name"));Iterator<?> its = a.elementIterator();while (its.hasNext()) {Element b = (Element) its.next();System.out.println(b.attributeValue("name"));}}}// 写入XML文件public void saver(String path) {OutputFormat format = new OutputFormat();format.setEncoding("GBK");try {XMLWriter writer = new XMLWriter(new FileWriter(path), format);writer.write(doc);writer.close();} catch (IOException e) {e.printStackTrace();}}// 增加元素public void add() {// 获得XML节点Element dome = doc.getRootElement();// Brand创建标签Element e1 = dome.addElement("Brand");// 设置标签属性e1.addAttribute("name", "三星");// 创建type标签Element e2 = e1.addElement("type");// 设置标签属性e2.addAttribute("name", "Noad");saver("dome2.xml");}// 添加属性值public void upDelete() {Element dome = doc.getRootElement();int i = 0;Iterator<?> it = dome.elementIterator();while (it.hasNext()) {Element elen = (Element) it.next();++i;elen.addAttribute("ID", i + "");saver("dome2.xml");}}// 删除元素public void delete() {Element dome = doc.getRootElement();Iterator<?> it = dome.elementIterator();while (it.hasNext()) {Element eln = (Element) it.next();if (eln.attributeValue("name").equals("华为")) {eln.getParent().remove(eln);}}saver("dome2.xml");}public static void main(String[] args) { Dome04 dome = new Dome04();dome.document();dome.delete();}}。

Java解析xml字符串（dom4j、jdom）1.dom4j解析xml字符串需要jar包dom4j-1.6.1.jarpackage com.example.xmlresovler;import java.util.HashMap;import java.util.Map;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.SAXReader;public class Demo4jXmlResovlerDao {/*** demo4j解析xml*/public static Map xmlResovlerDao(String xml) {Map map=new HashMap();SAXReader saxReader=new SAXReader();Document doc=null;try {//字符串转xmldoc=DocumentHelper.parseText(xml);//获取根节点Element rootElt = doc.getRootElement(); // 获取根节点//打印根节点名字System.out.println("根节点名字："+rootElt.getName());//获取根节点下的所有⼦节点//<?xml version="1.0" encoding="UTF-8"?>//<root>//<returnCode>922609</returnCode>//<message>会员创建成功</message>//</root>String returnCode=rootElt.elementTextTrim("returnCode");String message=rootElt.elementTextTrim("message");map.put("returnCode", returnCode);map.put("message", message);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();} // 将字符串转为XMLreturn map;}}2.JDOM解析xml字符串需要导⼊jar包jdom-1.1.3.jarpackage com.example.xmlresovler;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStream;import java.io.StringReader;import java.util.HashMap;import java.util.List;import java.util.Map;import org.jdom.Document;import org.jdom.Element;import org.jdom.JDOMException;import org.jdom.input.SAXBuilder;import org.xml.sax.InputSource;/*** JDOM解析* @author admin**/public class JDOMXmlResovlerDao {public static Map xmlResovlerDao(String xml) throws Exception {Map map=new HashMap();SAXBuilder saxBuilder = new SAXBuilder();//创建⼀个输⼊流,加载xml⽂件//InputStream in = new FileInputStream("src/mm.xml");//解析xml字符串StringReader read = new StringReader(xml);// 创建新的输⼊源SAX 解析器将使⽤ InputSource 对象来确定如何读取 XML 输⼊ InputSource in = new InputSource(read);Document document = saxBuilder.build(in);//获取根节点Element rootElement = document.getRootElement();List<Element> elements = rootElement.getChildren();//获取属性值for (Element element : elements) {map.put(element.getName(), element.getValue());}return map;}}。

javadom4j解析xml实例1.要解析的xml⽂件data.xml：<?xml version="1.0" encoding="UTF-8"?><ReturnInfo><userlist><item index="1" level="60" nickname="凄惨的⽼⽣" country="⾦"weiwang="136929" /><item index="2" level="85" nickname="哭泣的⾄尊宝" country="⾦"weiwang="97490" /><item index="3" level="85" nickname="⽼公" country="⾦"weiwang="91103" /><item index="4" level="78" nickname="冉闵" country="⾦"weiwang="82828" /><item index="5" level="55" nickname="erggh" country="⾦"weiwang="77440" /><item index="6" level="60" nickname="孤峰" country="⾦"weiwang="67821" /><item index="7" level="60" nickname="乱世" country="⾦"weiwang="67675" /><item index="8" level="62" nickname="叛逆之神" country="⾦"weiwang="61839" /><item index="9" level="60" nickname="双乔主⼈" country="⾦"weiwang="61647" /><item index="10" level="60" nickname="视觉效果" country="⾦"weiwang="50200" /><item index="11" level="60" nickname="⿁⿁" country="⾦"weiwang="49537" /><item index="12" level="59" nickname="狂龙在天" country="⾦"weiwang="46687" /><item index="13" level="60" nickname="⼩⼦" country="⾦"weiwang="46152" /><item index="14" level="52" nickname="zzy" country="⾦"weiwang="39017" /><item index="15" level="53" nickname="ycf" country="⾦"weiwang="30333" /><item index="16" level="52" nickname="⽆界之魂" country="⾦"weiwang="20294" /><item index="17" level="42" nickname="⼑锋狼" country="⾦"weiwang="18842" /><item index="18" level="60" nickname="mnbvc" country="⾦"weiwang="18102" /><item index="19" level="41" nickname="赢政" country="⾦"weiwang="16331" /><item index="20" level="52" nickname="徐匡胤" country="⾦"weiwang="16156" /></userlist></ReturnInfo>2、具体解析程序如下：package demo4;import java.io.File;import java.util.Iterator;import java.util.List;import org.dom4j.Document;import org.dom4j.DocumentException;import org.dom4j.Element;import org.dom4j.io.SAXReader;public class TestJava {public static void main(String args[]) throws DocumentException {SAXReader reader = new SAXReader();Document document = reader.read(new File("D:/data.xml"));Element rootElm = document.getRootElement();Element root1Elm = rootElm.element("userlist");List nodes = root1Elm.elements("item");for (Iterator it = nodes.iterator(); it.hasNext();) {Element elm = (Element) it.next();System.out.println("index:" + elm.attributeValue("index")+ " level:" + elm.attributeValue("level") + " nickname:"+ elm.attributeValue("nickname") + " country:"+ elm.attributeValue("country") + " weiwang:"+ elm.attributeValue("weiwang"));}try {Document doc = reader.read(new File("D:/data.xml"));List projects = doc.selectNodes("ReturnInfo/userlist/item");Iterator it = projects.iterator();while (it.hasNext()) {Element elm = (Element) it.next();System.out.println("index:" + elm.attributeValue("index")+ " level:" + elm.attributeValue("level")+ " nickname:" + elm.attributeValue("nickname")+ " country:" + elm.attributeValue("country")+ " weiwang:" + elm.attributeValue("weiwang"));}} catch (Exception ex) {ex.printStackTrace();}}}3、运⾏结果如下图所⽰：<1>、jaxen-1.1-beta-7.jar架包导⼊后不报异常，正常得到结果：<2>、jaxen-1.1-beta-7.jar架包不导⼊后报异常，但也能得到结果：。

详解 Dom4j进行读取JAVA XML文件详解dom4j进行读取javaxml文件dom4j进行读取javaxml文件首先引入dom4jjar圣塞雷县建立xml文件，例如图：创建好xml文件后，我们根据其逻辑关系，建立如下类：country(实体国家类:建立province(省份)实体类创建city(城市)实体类不好，我们须要的guo.xml，和三个对应的实体类以建，下面我们建立个法，具体内容和注解如下：packagetest;importjava.io.inputstream;importjava.util.arraylist;importjava.util.list;importorg.dom4j.document;importorg.dom4j.documentexception;importorg.dom4j.element;importorg.dom4j.io.s axreader;importentity.country;importentity.province;publicclasstestmain{main()方/***@paramargs*/publicstaticvoidmain(string[]args){//todoauto-generatedmethodstub//创建saxreader的对象saxreadersr=newsaxreader();//根据文件流加载xml文件inputstreamis=testmain.class.getresourceasstream(\);try{//利用saxreader的对象的read方法展开加载documentdt=sr.read(is);//document对象的getrootelement()获得xml文件中的第一层节点，即binggoelementbinggo=dt.getrootelement();//我们对其进行输出如下输出：binggosystem.out.println(\第一层节点名称：\+binggo.getname());/***如下是获得单个节点下的所有内容，*获取其它单个节点同理*///以获取其它名称相似，下一步我们将要赢得country节点中属性名称的值。

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的原理XML（Extensible Markup Language）是一种可扩展的标记语言，主要用于数据的存储和传输。

而dom4j是一种基于Java的XML解析器，它提供了一种简单且高效的方法来解析和处理XML文档。

本文将介绍dom4j解析XML的原理以及它的主要特点。

一、dom4j简介dom4j是一个开源的XML解析器，它采用Java语言开发。

相比于其他XML解析器，dom4j具有更高的性能和更简洁的API。

它能够将XML文档解析成一个树形结构，通过遍历这个结构来获取XML中的各个元素和属性。

二、dom4j的原理1. 加载XML文档dom4j使用SAX解析器，它可以逐行读取XML文档并将其转换成事件流。

首先，需要创建一个SAXReader对象，通过调用其read()方法，将XML文档加载到内存中。

2. 构建Document对象在加载XML文档后，dom4j会解析它，并将其转换成一个Document对象。

这个对象代表了整个XML文档的根节点，通过它可以获取XML文档中的各个节点和属性。

3. 遍历XML树拿到Document对象之后，我们可以通过它来遍历整个XML树。

dom4j提供了一系列的方法，如elementIterator()、attributeIterator()等，用于获取当前节点的子节点或属性。

4. 获取节点内容一旦获取到具体的节点，我们可以通过调用其getText()方法或getStringValue()方法来获取节点的文本内容。

5. 获取节点属性类似地，要获取节点的属性，可以通过调用attributeValue()方法或getAttributes()方法来获取。

6. 增删改查dom4j还支持对XML文档进行增删改查的操作。

我们可以通过调用相应的API来添加新节点、删除节点、修改节点内容等。

三、dom4j的特点1. 简洁而灵活的API：dom4j提供了一套简洁而强大的API，使得操作XML文档变得非常方便。

javaAPI解析XML文件--DOM4JjavaAPI解析XML文件有两种方式1、DOM (Document Object Model 文档对象模型)优点：把XML文件在内存中构造成树型结构，支持删除、修改、重新排列等多种功能;缺点：如果文件比较大，内存有压力，解析时间会比较长。

2、SAX (Simple API for Xml 基于Xml的简单API)把XML文件作为输入流。

SAX ，事件驱动。

当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。

优点：解析可以立即开始，速度快，没有内存压力缺点：不能对节点进行修改目前市面上两种解析XML文件的API： DOM4J/JDOMDOM4J解析xml文件：1、创建空白document文档对象//创建一个空的文档对象Document doc = DocumentHelper.createDocument();2、读取xml文件，返回document对象//解析器SAXReader reader = new SAXReader();//指定XML文件File file = new File(fileName);//开始解析，构建树型结构并返回Document doc = reader.read(file);3、分析元素//获得根元素,员工列表Element rootElmt = doc.getRootElement();//获取所有的员工列表List list = rootElmt.elements("emp");//解析所有员工的元素集合Iterator it = list.iterator();while(it.hasNext()){//员工的元素Element empElmt = (Element)it.next();//员工的子节点"id"的值String empId = empElmt.elementText("id");//员工的属性迭代器Iterator attrIt = empElmt.attributeIterator();while(attrIt.hasNext()){//员工的属性Attribute attr = (Attribute)attrIt.next();//打印员工的属性的名和值System.out.println(attr.getName()+"="+attr.getValue()); }}4、增加元素，并为元素设置数据或属性，删除元素//为empElmt元素增加一个"id"子元素Element idElmt = empElmt.addElement("id");//为"id"子元素设置值idElmt.setText("3");//为emp元素增加type属性empElmt.addAttribute("type", "leader");//为empElmt元素删除一个叫"id"的子元素empElmt.remove(idElmt);5、输出xml文件//创建一个java.io包中的FileWriter对象，指定目标文件 FileWriter fw = new FileWriter(filename);//指定XML文件的输出格式OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("utf-8");//写出xml文件到操作系统XMLWriter xw = new XMLWriter(fw,format);//指定参数xw.write(doc); //写出文档对象xw.close();6、dom4j对XPath的支持(w3c的标准)SAXReader reader = new SAXReader();Document doc = reader.read(new File(fileName));// 获得根元素,员工列表，绝对路径 "/emps"Node node = doc.selectSingleNode("/emps");// 获取所有的员工列表，相对路径 "emp"List list = node.selectNodes("emp");// 根据条件获取员工列表// 相对路径 emp/id// 过滤条件 [@type='admin'] @后面跟属性，如果是元素直接写// 运算符可以是 "=",">","<","or","and"List list = node.selectNodes("emp/id[@type='admin']");。

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

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);}}}。

java中利⽤dom4j解析XML⽂件官⽹下载Dom4j地址：注意：使⽤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 + '\'' +'}';}}View Code@Test 代码：public class StudentDaoTest {@Testpublic void testlistStudent(){List<Student> list = new XmlUtil().listStudent();for (Student student : list) {System.out.println(student);}}}View Code运⾏结果：。

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(); 获得根元素下的所有⼦节点。

JAVADOM4j解析XML数据到⾃定义javabean我们获取xml中的数据，⼀般以⾯向对象的思想去处理这些数据。

因此，我们需要⾃定义类来封装解析出来的数据，以⽅便我们操作这些数据。

⾃定义的java类，称为javabean。

⾃定义Contact类代码如下：这个类是⽤来封装解析出来的数据的。

package gz.itcast.a_dom4j_read;public class Contact {private String id;private String name;private String age;private String phone;private String email;private String qq;public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}public String getPhone() {return phone;}public void setPhone(String phone) {this.phone = phone;}public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}public String getQq() {return qq;}public void setQq(String qq) {this.qq = qq;}@Overridepublic String toString() {return "Contact [age=" + age + ", email=" + email + ", id=" + id+ ", name=" + name + ", phone=" + phone + ", qq=" + qq + "]";}}接下来把xml⽂档信息封装到对象中。