利用反射与dom4j读取javabean生成对应XML和读取XML得到对应的javabean对象集合

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

java读取XML⽂件的四种⽅法总结（必看篇）JAVA操作XML⽂档主要有四种⽅式，分别是DOM、SAX、JDOM和DOM4J，DOM和SAX是官⽅提供的，⽽JDOM和DOM4J 则是引⽤第三⽅库的，其中⽤的最多的是DOM4J⽅式。

运⾏效率和内存使⽤⽅⾯最优的是SAX，但是由于SAX是基于事件的⽅式，所以SAX⽆法在编写XML的过程中对已编写内容进⾏修改，但对于不⽤进⾏频繁修改的需求，还是应该选择使⽤SAX。

下⾯基于这四种⽅式来读取XML⽂件。

第⼀，以DOM的⽅式实现。

package xmls;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.Node;import org.w3c.dom.NodeList;import org.xml.sax.SAXException;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.ParserConfigurationException;import java.io.File;import java.io.IOException;/*** Created by lenovo on 2017-6-3.*/public class DOMReadDemo {public static void main(String[] args){DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();try{DocumentBuilder db = dbf.newDocumentBuilder();Document document = db.parse("src/xmls/DOM.xml");NodeList booklist = document.getElementsByTagName("book");for(int i = 0; i < booklist.getLength(); i++){System.out.println("--------第" + (i+1) + "本书----------");Element ele = (Element) booklist.item(i);NodeList childNodes= ele.getChildNodes();for(int j = 0; j < childNodes.getLength(); j++){Node n = childNodes.item(j);if(n.getNodeName() != "#text"){System.out.println(n.getNodeName() + ":" + n.getTextContent());}}System.out.println("---------------------------------");}}catch (ParserConfigurationException e){e.printStackTrace();}catch (IOException e){e.printStackTrace();}catch (SAXException e){e.printStackTrace();}}}第⼆，以SAX的⽅式实现。

要使用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 框架。

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。

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⽣成xml字符串，以及解析xml字符串基于dom4j-1.6.1.jarimport java.io.IOException;import java.io.StringWriter;import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Set;import java.util.logging.Level;import java.util.logging.Logger;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.XMLWriter;/**** @author y*/public class Test {/*** @param args the command line arguments*/public static void main(String[] args) throws DocumentException {Map<String, Object> map = new HashMap<String, Object>();map.put("name", "李四");map.put("age", 25);//System.out.println(map2xml(map));List<Object> list = new ArrayList<Object>();list.add("测试1");list.add("测试2");list.add("测试3");//System.out.println(list2xml(list,"items"));List<Map<String,Object>> listMap = new ArrayList<Map<String,Object>>();Map<String,Object> map1 = new HashMap<String,Object>();map1.put("name", "张三");map1.put("age", 23);listMap.add(map1);map1 = new HashMap<String,Object>();map1.put("name", "李四");map1.put("age", 24);listMap.add(map1);map1 = new HashMap<String,Object>();map1.put("name", "王五");map1.put("age", 25);listMap.add(map1);System.out.println(listMap2xml(listMap,"users","user"));}public static String listMap2xml(List<Map<String,Object>> list,String listRoot,String mapRoot){Document doc = DocumentHelper.createDocument();Element rootEle = doc.addElement("result");Element noEle = rootEle.addElement("no");Element msgEle = rootEle.addElement("msg");if(null!=list && !list.isEmpty()){noEle.setText("1");msgEle.setText("成功获取相关信息");Element listRootEle = rootEle.addElement(listRoot);for(Map<String,Object> map:list){Element mapRootELe = listRootEle.addElement(mapRoot);Set<Map.Entry<String,Object>> set = map.entrySet();Iterator<Map.Entry<String,Object>> iter = set.iterator();while(iter.hasNext()){Map.Entry<String,Object> entry = (Map.Entry<String,Object>)iter.next(); Element ele = mapRootELe.addElement(entry.getKey());ele.setText(String.valueOf(entry.getValue()));}}}else{noEle.setText("0");msgEle.setText("没有获取到相关信息");}StringWriter sw = new StringWriter();OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("utf-8");try {XMLWriter xmlWriter = new XMLWriter(sw, format);xmlWriter.write(doc);} catch (IOException ex) {Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);}finally{try {sw.close();} catch (IOException ex) {Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);}}return sw.toString();}public static String list2xml(List<Object> list,String itemRoot){Document doc = DocumentHelper.createDocument();Element rootEle = doc.addElement("result");Element noEle = rootEle.addElement("no");Element msgEle = rootEle.addElement("msg");if(null!=list && !list.isEmpty()){noEle.setText("1");msgEle.setText("成功获取相关信息");Element itemRootEle = rootEle.addElement(itemRoot);for(Object obj:list){Element ele = itemRootEle.addElement("item");ele.setText(String.valueOf(obj));}}else{noEle.setText("0");msgEle.setText("没有获取到相关信息");}StringWriter sw = new StringWriter();OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("utf-8");try {XMLWriter xmlWriter = new XMLWriter(sw, format);xmlWriter.write(doc);} catch (IOException ex) {Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);}finally{try {sw.close();} catch (IOException ex) {Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);}}return sw.toString();}public static String map2xml(Map<String, Object> map) {Document doc = DocumentHelper.createDocument();Element rootEle = doc.addElement("result");Element noEle = rootEle.addElement("no");Element msgEle = rootEle.addElement("msg");if(null!=map && !map.isEmpty()){noEle.setText("1");msgEle.setText("成功获取相关信息");Set<Map.Entry<String, Object>> set = map.entrySet();Iterator<Map.Entry<String, Object>> iter = set.iterator();while(iter.hasNext()){Map.Entry<String, Object> entry = (Map.Entry<String, Object>) iter.next(); Element ele = rootEle.addElement(entry.getKey());ele.setText(String.valueOf(entry.getValue()));}}else{noEle.setText("0");msgEle.setText("没有获取到相关信息");}StringWriter sw = new StringWriter();OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("utf-8");try {XMLWriter xmlWriter = new XMLWriter(sw, format);xmlWriter.write(doc);} catch (IOException ex) {Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);}finally{try {sw.close();} catch (IOException ex) {Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);}}return sw.toString();}public static void test4() {Document doc = DocumentHelper.createDocument();Element rootEle = doc.addElement("sudent");Element nameEle = rootEle.addElement("name");nameEle.setText("张三");Element ageEle = rootEle.addElement("age");ageEle.setText("25");try {StringWriter sw = new StringWriter();OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("utf-8");XMLWriter xmlWriter = new XMLWriter(sw, format);xmlWriter.write(doc);System.out.println(sw.toString());} catch (IOException ex) {Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);}}public static void test3() throws DocumentException {String str = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"+ "<books>"+ " <book>"+ " <name>Think in Java</name>"+ " <price>120.0</price>"+ " <chapters>"+ " <c>001</c>"+ " <c>002</c>"+ " <c>003</c>"+ " </chapters>"+ " </book>"+ " <book>"+ " <name>Think in Java2</name>"+ " <price>220.0</price>"+ " </book>"+ "</books>";Document doc = DocumentHelper.parseText(str);Element books = doc.getRootElement();List<Element> childEles = books.elements();Iterator<Element> iter = childEles.iterator();while (iter.hasNext()) {Element book = iter.next();Element name = book.element("name");Element price = book.element("price");System.out.println("name:" + name.getText() + ",price:" + price.getText()); Element chapters = book.element("chapters");if (null != chapters) {Iterator<Element> chaptersIter = chapters.elementIterator();if (null != chaptersIter) {while (chaptersIter.hasNext()) {Element c = chaptersIter.next();System.out.println("===>" + c.getText());}}}}}public static void test2() throws DocumentException {String str = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"+ "<books>"+ " <book>"+ " <name>Think in Java</name>"+ " <price>120.0</price>"+ " </book>"+ " <book>"+ " <name>Think in Java2</name>"+ " <price>220.0</price>"+ " </book>"+ "</books>";Document doc = DocumentHelper.parseText(str);Element books = doc.getRootElement();List<Element> childEles = books.elements();Iterator<Element> iter = childEles.iterator();while (iter.hasNext()) {Element book = iter.next();Element name = book.element("name");Element price = book.element("price");System.out.println("name:" + name.getText() + ",price:" + price.getText()); }}public static void test1() throws DocumentException {String str = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"+ "<dzswdjz>"+ " <qr_code>"+ " <nsrsbh>nsrsbh</nsrsbh >"+ " <retStatus >retStatus</retStatus>"+ " <img_name>img_name</img_name>"+ " <img_byteString>img_byteString</img_byteString>"+ " </qr_code>"+ "</dzswdjz>";Document doc = DocumentHelper.parseText(str);//获取到⽗节点Element dzswdjz = doc.getRootElement();//定位到qr_code节点Element qr_code = dzswdjz.element("qr_code");Element nsrsbh = qr_code.element("nsrsbh");Element retStatus = qr_code.element("retStatus");Element img_name = qr_code.element("img_name");Element img_byteString = qr_code.element("img_byteString");System.out.println("nsrsbh:" + nsrsbh.getText());System.out.println("retStatus:" + retStatus.getText());System.out.println("img_name:" + img_name.getText());System.out.println("img_byteString:" + img_byteString.getText()); }}。

详解 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节点中属性名称的值。

xml通过dom4j解析成java对象要解析的xml<?xml version="1.0" encoding="UTF-8"?><config><action path="/regAction" type="test.RegAction"><forward name="failed" path="/reg.jsp" redirect="false" /><forward name="success" path="/login.jsp" redirect="true" /></action><action path="/loginAction" type="test.LoginAction"><forward name="failed" path="/login.jsp" redirect="false" /><forward name="success" path="/main.jsp" redirect="true" /></action></config>java代码解析前⼀定要先把jar包导⼊接下来我来定义实体类实体类根据上⾯的xml去定义。

实体类定义的顺序⼀定是由⾥向外去定义的。

定义顺序 forward标签模型 -> actiong标签模型 -> config标签模型forward标签模型public class ForwardModal {public ForwardModal() {super();}public ForwardModal(String name, String path, boolean redirct) {super(); = name;this.path = path;this.redirct = redirct;}private String name;private String path;private boolean redirct;public String getName() {return name;}public void setName(String name) { = name;}public String getPath() {return path;}public void setPath(String path) {this.path = path;}public boolean isRedirct() {return redirct;}public void setRedirct(boolean redirct) {this.redirct = redirct;}@Overridepublic String toString() {return "ForwardModal [name=" + name + ", path=" + path + ", redirct=" + redirct + "]";}}action标签模型/*** Action标签模型* @author 20190313**/public class ActionModal {private String path;private String type;private Map<String, ForwardModal> map = new HashMap<>();public void addForwardModal(ForwardModal forwardModal) {//判断当前的name是不是有重复数据，如果没有则添加，有则跳过if(!map.containsKey(forwardModal.getName())) {map.put(forwardModal.getName(), forwardModal);}}public ForwardModal getForwardModal(String key) {return map.get(key);}public String getPath() {return path;}public void setPath(String path) {this.path = path;}}public String getType() {return type;}public void setType(String type) {this.type = type;}@Overridepublic String toString() {return "ActionModal [path=" + path + ", type=" + type + ", map=" + map + "]";}}config标签模型public class ConfigModal {private Map<String, ActionModal> map = new HashMap<>();public void addActionModal(ActionModal actionModal) {if(!map.containsKey(actionModal.getType())) {map.put(actionModal.getType(), actionModal);}}public ActionModal getActionModal(String key) {return map.get(key);}@Overridepublic String toString() {return "ConfigModal [map=" + map + "]";}}将xml解析成java对象的⼯⼚类记住解析的⽅式⼀定是从外往⾥。

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文件的过程*/ public vo createXML(Map param, List list) { if(null == list) throw new NullPointerException(); DocumentFactoryf=new DocumentFactory(); Document doc=f.createDocument();//文档对象 //在文档对象中添加一棵树 Elementroot=doc.aElement( ufinterface root.addAtibute( billtype , gl root.addAttribute( codechang , yroot.addAttribute( docid , 989898989898root.addAttribute( proc , add root.addAttribute( receiver , 0001 root.addAttribute( roottag , voucherroot.addAttribute( sender , THDH Elementvoucher=root.addElement( voucher //给根添加一个凭证voucher.addAttribute( id ,((Voucher)list.get(0)).getVoucherUniqueId()); //凭证添加一个唯一ID属性 Element voucherHead=voucher.addElement( voucher_head //给凭证添加一个头元素Element company = voucherHead.addElement( company //添加公司子元素 company.Text(((Voucher)list.get(0)).getCompany()); //给公司子元素设定内容 Element voucherType = voucherHead.addElement( voucher_type //添加凭证子元素voucherType.setText( 记账凭证 //给凭证子元素设定内容Element fiscalYear = voucherHead.addElement( fiscal_year //添加凭证子元素fiscalYear.setText(((Voucher)list.get(0)).getFiscalYear()); //给凭证子元素设定内容 Element accountingPeriod = voucherHead.addElement( accounting_period //添加凭证子元素accountingPeriod.setText(((Voucher)list.get(0)).getAccountin gPeriod()); //给凭证子元素设定内容 Element voucherId =第1页共4页。

JavaDOM4J⽅式⽣成XML的⽅法使⽤DOM4J⽅式⽣成XML⽂件的步骤如下：引⼊JAR包通过DocumentHelper类的createDocument()创建Document对象通过Document的addElement()⽅法创建节点通过Element的addAttribute()⽅法为节点添加属性通过Element的setText()⽅法为节点设置内容通过OutputFormat的createPrettyPrint()⽅法创建OutputFormat对象（会⾃动缩进、换⾏）创建XMLWriter对象，将⽬的⽂件包装成OutputStream传⼊构造⽅法中，并将OutputFormat对象⼀并传⼊其中通过XMLWriter的write()⽅法⽣成XML⽂件，并将Document对象作为参数传⼊关闭XMLWriter对象下⾯给出完整代码：package util;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.OutputFormat;import org.dom4j.io.XMLWriter;public class XMLUtils {public void CreateXMLByDOM4J(File dest) {// 创建Document对象Document document = DocumentHelper.createDocument();// 创建根节点Element rss = document.addElement("rss");//为rss根节点添加属性rss.addAttribute("version", "2.0");// 创建channel⼦节点Element channel = rss.addElement("channel");// 创建title⼦节点Element title = channel.addElement("title");// 设置title节点的值title.setText("<![CDATA[上海移动互联⽹产业促进中⼼正式揭牌 ]]>");// 创建输出格式(OutputFormat对象)OutputFormat format = OutputFormat.createPrettyPrint();///设置输出⽂件的编码// format.setEncoding("GBK");try {// 创建XMLWriter对象XMLWriter writer = new XMLWriter(new FileOutputStream(dest), format);//设置不⾃动进⾏转义writer.setEscapeText(false);// ⽣成XML⽂件writer.write(document);//关闭XMLWriter对象writer.close();} catch (IOException e) {e.printStackTrace();}}}若想⾃定义XML⽂件的编码⽅式，可使⽤OutputFormat对象的setEncoding()⽅法设置：///设置输出⽂件的编码format.setEncoding("GBK");DOM4J会对某些特殊字符进⾏⾃动转义，若不想让DOM4J进⾏⾃动转义，我们可以通过XMLWriter的setEscapeText()⽅法进⾏设置。

通过dom4j解析xml字符串（⽰例代码）复制代码代码如下:import java.util.Iterator;import java.util.List;import org.dom4j.Attribute;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;public class Test {@SuppressWarnings("unchecked")public static void main(String[] args) throws Exception {String xml = "<request> <param name='service'>single_trade_query </param><param name='_input_charset'>utf-8</param><param name='partner'>2088001513232645 </param><param name='out_trade_no'>20090422577264 </param> </request>";Document document = DocumentHelper.parseText(xml);Element root = document.getRootElement();List<Element> elements = root.elements();for (Iterator<Element> it = elements.iterator(); it.hasNext();) {Element element = it.next();List<Attribute> attributes = element.attributes();for (int i = 0; i < attributes.size(); i++) {Attribute attribute = attributes.get(i);if ("service".equals(attribute.getText())) {System.out.println(element.getName() + " : "+ element.getText());}}}}}或者：复制代码代码如下:import java.io.StringReader;import java.util.Iterator;import java.util.List;import org.dom4j.Document;import org.dom4j.Element;import org.dom4j.io.SAXReader;import org.xml.sax.InputSource;public class Test {@SuppressWarnings("unchecked")public static void main(String[] args) throws Exception {String xml = "<servlet><description></description><display-name>TestServlet</display-name><servlet-name>TestServlet</servlet-name><servlet-class>test.TestServlet</servlet-class></servlet>";InputSource in = new InputSource(new StringReader(xml));in.setEncoding("UTF-8");SAXReader reader = new SAXReader();Document document = reader.read(in);Element root = document.getRootElement();List<Element> elements = root.elements();for(Iterator<Element> it = elements.iterator();it.hasNext();){Element element = it.next();System.out.println(element.getName()+" : "+element.getTextTrim());}}}或者增加ID属性，直接通过ID获取某个属性值：复制代码代码如下:import java.io.StringReader;import org.dom4j.Document;import org.dom4j.DocumentException;import org.dom4j.Element;import org.dom4j.io.SAXReader;import org.xml.sax.InputSource;public class Test {public static void main(String args[]) {String xml = "<request> <param name='service' ID='tt'>single_trade_query </param><param name='_input_charset'>utf-8 </param><param name='partner'>2088001513232645 </param><param name='out_trade_no'>20090422577264 </param> </request>";InputSource source = new InputSource(new StringReader(xml));SAXReader reader = new SAXReader();Document document = null;try {document = reader.read(source);} catch (DocumentException e) {// TODO Auto-generated catch blocke.printStackTrace();}Element root = document.getRootElement();System.out.println(document.elementByID("tt").getTextTrim());System.out.println(root.elementByID("tt").getTextTrim());}}注意：通过ID获取，元素ID属性名必须为“⼤写ID”，⼩写的“id”会认为是普通属性！。

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的原理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文档变得非常方便。

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⽂件官⽹下载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运⾏结果：。

java---解析XML⽂件，通过反射动态将XML内容封装到⼀个类中本博客讲的XML解析，使⽤的是dom4j。

⾸先建⽴⼀个maven项⽬，在dom.xml中引⼊相应的dom4j的版本。

作者下载的是热度很⾼的1.6.1版本。

maven的使⽤在这⾥不做详细讲解。

引⼊成功后，来简单了解该包提供的API.dom4j.io.SAXReader.class-----该类提供了reader⽅法，可以将xml⽂件读取为Document对象，该⽅法返回值类型为Document.dom4j.Document.class----------该类提供了getRootElement⽅法，可以获得Document对象的根节点，此⽅法返回值类型是Element.dom4j.Element-------该类提供了elements⽅法，获取所有的⼦节点，返回值类型为Element； attributeValue⽅法，获得通过属性名节点的属性值，返回值类型为String getStringValue()⽅法，获得element的⽂本值，返回值类型为String下⾯使⽤上述⽅法来解析XML⽂件。

⼀：新建或者⾃⼰导如XML⽂件。

作者为了⽅便演⽰，新建⼀个新的XML⽂件，如下。

<?xml version="1.0" encoding="UTF-8"?><students><student id="1"><name>Claire</name><age>18</age><gender>⼥</gender></student><student id="2"><name>Leafly</name><age>18</age><gender>男</gender></student><student id="3"><name>Dingdang</name><age>18</age><gender>男</gender></student><student id="4"><name>DingDing</name><age>18</age><gender>男</gender></student><student id="5"><name>DangDang</name><age>18</age><gender>⼥</gender></student></students>2.将上述xml⽂件放到src下⾯。