关闭

JDom解析和生成XML文档

标签: jdomxml
187人阅读 评论(0) 收藏 举报
分类:

一、前言

    JDom是一套非常优秀的java开源api,主要用于读写xml文档,具有性能优异、功能强大、和非常方便使用的特点,并且把jdk自带的解析方式SAX和Dom的功能有效地结合起来。经过实践操作发现dom4j和jdom解析xml的时候有一些相似的地方,故可以比对一下解析的性能和实现方式的效率。


二、准备条件

   jdom.jar

下载地址:http://download.csdn.net/detail/ch656409110/6334543


三、使用JDom实战


1、解析xml文档

实现思路:

   <1>创建SAX创建者对象的实例;

   <2>根据读取的xml路径,传递给SAXBuilder的实例之后 返回一个Document文档对象;

   <3>然后操作这个Document对象,获取下面的节点以及子节点的信息。

具体代码如下:

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileNotFoundException;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.InputStream;  
  7. import java.io.OutputStream;  
  8. import java.util.List;  
  9.   
  10. import org.jdom.DocType;  
  11. import org.jdom.Document;  
  12. import org.jdom.Element;  
  13. import org.jdom.JDOMException;  
  14. import org.jdom.input.SAXBuilder;  
  15. import org.jdom.output.XMLOutputter;  
  16. import org.xml.sax.InputSource;  
  17.   
  18.   
  19. /** 
  20.  * 使用JDom操作xml的简单例子 
  21.  * @author Administrator 
  22.  * 
  23.  */  
  24. public class JDomOperateXmlDemo {  
  25.   
  26.     public void parseXml01(){  
  27.         String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document01.xml";    
  28.         String xmlName = xmlPath.substring(xmlPath.lastIndexOf("\\"));   
  29.         try {  
  30.             //创建SAX建造者对象,该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。   
  31.             SAXBuilder saxBuilder = new SAXBuilder(false);  
  32.             //1、直接指定绝对路径获取文件输入流对象   
  33.             //InputStream inputStream = new FileInputStream(xmlPath);   
  34.             //2、使用类的相对路径查找xml路径   
  35.             //InputStream inputStream = this.getClass().getResourceAsStream(xmlName);   
  36.             //3、也可以指定路径完成InputStream输入流的实例化操作     
  37.             InputStream inputStream = new FileInputStream(new File(xmlPath));    
  38.             //4、使用InputSource输入源作为参数也可以转换xml     
  39.             InputSource inputSource = new InputSource(inputStream);  
  40.             //解析xml文档,返回document文档对象   
  41.             Document document = saxBuilder.build(inputSource);  
  42.             Element rootElement = document.getRootElement();//根节点   
  43.               
  44.             System.out.println("根节点名称:" + rootElement.getName());//获取节点的名称     
  45.             System.out.println("根节点有多少属性:" + rootElement.getAttributes().size());//获取节点属性数目     
  46.             System.out.println("根节点id属性的值:" + rootElement.getAttributeValue("id"));//获取节点的属性id的值     
  47.             System.out.println("根节点内文本:" + rootElement.getText());//如果元素有子节点则返回空字符串,否则返回节点内的文本     
  48.             //rootElement.getText() 之所以会换行是因为 标签与标签之间使用了tab键和换行符布局,这个也算是文本所以显示出来换行的效果。     
  49.             System.out.println("根节点内文本(1):" + rootElement.getTextTrim());//去掉的是标签与标签之间的tab键和换行符等等,不是内容前后的空格   
  50.             System.out.println("根节点内文本(2):" + rootElement.getTextNormalize()); //目前发现和getTextTrim()方法效果一样      
  51.             System.out.println("根节点内文本(3):" + rootElement.getValue());  //返回节点下所有内容   
  52.     
  53.             Element element = rootElement.getChild("Element"); //获取子节点,如果有多个Element节点,那么返回最先读取到的element   
  54.             if(element != null){    
  55.                 System.out.println("子节点的文本:" + element.getText());//因为子节点和根节点都是Element对象所以它们的操作方式都是相同的     
  56.             }   
  57.             //但是有些情况xml比较复杂,规范不统一,某个节点不存在直接java.lang.NullPointerException,所以获取到element对象之后要先判断一下是否为空     
  58.             List<Element> list = rootElement.getChildren("Element");//返回的是List集合   
  59.             for (Element ele : list) {  
  60.             }             
  61.         } catch (JDOMException e) {  
  62.             e.printStackTrace();  
  63.         } catch (IOException e) {  
  64.             e.printStackTrace();  
  65.         }  
  66.     }  
  67.       
  68.     public static void main(String[] args) {  
  69.         JDomOperateXmlDemo demo = new JDomOperateXmlDemo();  
  70.         demo.parseXml01();  
  71.     }  
  72. }  
另外上面的xml在src下面,document01.xml具体如下:

  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <Document id="doc01">  
  3.     根节点的内容  
  4.     <Element>子节点的内容</Element>  
  5.  </Document>  
接下来执行该类的main方法,console效果如下:


根据控制台显示可知:

   <1>如果new SAXBuilder(false)指定为true,指定运行会报错:Document is invalid: no grammar found.  简单的说就是没有导入语法文件,比如dtd文件等等,所以jdom在验证xml规范的时候还是非常严格的;
   <2>这里发现jdom解析xml区分大小写,就是区分指定节点名称,但是dom4j是不区分的;

   <3>有些情况xml比较复杂,规范不统一,某个节点不存在直接报错:java.lang.NullPointerException,所以获取到element对象之后要先判断一下是否为空。


上面只是简单的获取了xml的根目录的元素,接下来使用ArrayList集合循环document文档对象。

具体代码如下:

  1. public void parseXml02(){  
  2.     String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document02.xml";    
  3.     try {  
  4.         //创建SAX建造者对象,该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。   
  5.         SAXBuilder saxBuilder = new SAXBuilder(false);  
  6.         InputStream inputStream = new FileInputStream(new File(xmlPath));    
  7.         //解析xml文档,返回document文档对象   
  8.         Document document = saxBuilder.build(inputStream);  
  9.         Element rootElement = document.getRootElement();//根节点   
  10.           
  11.         List<Element> elementList = rootElement.getChildren("Element");  
  12.         for (Element element : elementList) {  
  13.             System.out.println("【" + element.getName() + "】:" + element.getTextTrim());//如果有子节点就返回空字符串   
  14.             Element nameElement = element.getChild("name");  
  15.             if(nameElement != null){  
  16.                 System.out.println("   " + nameElement.getName() + ":" + nameElement.getTextTrim());  
  17.             }  
  18.             Element valueElement = element.getChild("value");  
  19.             if(valueElement != null){  
  20.                 System.out.println("   " + valueElement.getName() + ":" + valueElement.getTextTrim());  
  21.             }  
  22.             Element descriptElement = element.getChild("descript");  
  23.             if(descriptElement != null){  
  24.                 System.out.println("   " + descriptElement.getName() + ":" + descriptElement.getTextTrim());  
  25.             }  
  26.         }  
  27.     } catch (JDOMException e) {  
  28.         e.printStackTrace();  
  29.     } catch (IOException e) {  
  30.         e.printStackTrace();  
  31.     }  
  32. }  
另外上面的xml在src下面,document02.xml具体如下:

  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <Document id="doc01">  
  3.     根节点的内容  
  4.     <Element>子节点的内容</Element>  
  5.     <Element id="ele01">  
  6.         <name><![CDATA[节点的名称]]></name>  
  7.         <value><![CDATA[节点的值]]></value>  
  8.         <descript><![CDATA[节点的描述]]></descript>  
  9.     </Element>      
  10.     <Element id="ele02">  
  11.         <name><![CDATA[节点的名称<2>]]></name>  
  12.         <value><![CDATA[节点的值<2>]]></value>  
  13.         <descript><![CDATA[节点的描述<2>]]></descript>  
  14.     </Element>  
  15.  </Document>  
接下来执行该类的main方法,console效果如下:


根据控制台显示可知:

   <1>直接解析就会报错:Error on line 11: The content of elements must consist of well-formed character data or markup.  因为标签的内容中包含标签标记符号,使用<![CDATA[]]>标记会被当成文本信息不被解析;
   <2>因为是getChildren("Element");有指定具体元素名称,所以只会获取Element节点,另外节点的子节点包含Element节点不会被获取,所以getChildren("Element");没有递归获取子元素;


jdom不但能够解析xml对象,并且在解析的时候还可以操作document对象,重新构造一个新的Document文档对象。

具体代码如下:

  1. public void operateXml01(){  
  2.        String xmlPath = "D:\\project\\dynamicWeb\\src\\resource\\document03.xml";    
  3.     try {  
  4.         //创建SAX建造者对象,该类构造方法的重载boolean类型的方法中validate表示是否验证xml文档。   
  5.         SAXBuilder saxBuilder = new SAXBuilder(false);  
  6.         InputStream inputStream = new FileInputStream(new File(xmlPath));    
  7.         //4、使用InputSource输入源作为参数也可以转换xml     
  8.         InputSource inputSource = new InputSource(inputStream);  
  9.         //解析xml文档,返回document文档对象   
  10.         Document document = saxBuilder.build(inputSource);  
  11.         Element rootElement = document.getRootElement();//根节点   
  12.         /* 
  13.         rootElement.setName("root");//支持修改节点名称   
  14.         System.out.println("根节点修改之后的名称:" + rootElement.getName());   
  15.         rootElement.setText("text"); //同样修改标签内的文本也一样   
  16.         System.out.println("根节点修改之后的文本:" + rootElement.getText());   
  17.         */  
  18.         //接下来根据id获取元素 添加子元素或者删除子节点   
  19.         List<Element> elementList = rootElement.getChildren();  
  20.         System.out.println("删除节点前的集合个数:"+elementList.size());  
  21.         for (Element element : elementList) {  
  22.             if(element.getAttributeValue("id")!=null){  
  23.                 if(element.getAttributeValue("id").equals("ele01")){  
  24.                     Element element01 = new Element("new_name");  
  25.                     element01.setText("新添加的名称");  
  26.                     Element element02 = new Element("new_value");  
  27.                     element02.setText("新添加的名称");  
  28.                     Element element03 = new Element("new_descript");  
  29.                     element03.setText("新添加的名称");  
  30.                     element.addContent(element01);  
  31.                     element.addContent(element02);  
  32.                     element.addContent(element03);  
  33.                 }else if(element.getAttributeValue("id").equals("ele02")){  
  34.                     /* 
  35.                     rootElement.removeContent(element); 
  36.                     break; 
  37.                     */  
  38.                     element.removeContent();  
  39.                     System.out.println("删除节点后的集合个数:"+elementList.size());  
  40.                 }  
  41.             }  
  42.         }  
  43.         elementList = rootElement.getChildren("Element");  
  44.         for (Element element : elementList) {  
  45.             System.out.println("【" + element.getName() + "】:" + element.getTextTrim());//如果有子节点就返回空字符串   
  46.             Element nameElement = element.getChild("new_name");  
  47.             if(nameElement != null){  
  48.                 System.out.println("   " + nameElement.getName() + ":" + nameElement.getTextTrim());  
  49.             }  
  50.             Element valueElement = element.getChild("new_value");  
  51.             if(valueElement != null){  
  52.                 System.out.println("   " + valueElement.getName() + ":" + valueElement.getTextTrim());  
  53.             }  
  54.             Element descriptElement = element.getChild("new_descript");  
  55.             if(descriptElement != null){  
  56.                 System.out.println("   " + descriptElement.getName() + ":" + descriptElement.getTextTrim());  
  57.             }  
  58.         }  
  59.     } catch (JDOMException e) {  
  60.         e.printStackTrace();  
  61.     } catch (IOException e) {  
  62.         e.printStackTrace();  
  63.     }  
  64. }  
另外上面的xml在src下面,document03.xml具体如下:
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <Document id="doc01">  
  3.     根节点的内容  
  4.     <Element>子节点的内容</Element>  
  5.     <Element id="ele01">  
  6.         <Content>节点内容1</Content>  
  7.     </Element>      
  8.     <Element id="ele02">  
  9.         <Content>节点内容2</Content>  
  10.     </Element>  
  11.  </Document>  
接下来执行该类的main方法,console效果如下:

根据控制台显示可知:

   <1>执行上面的修改根节点操作会影响下面,因为setText()会直接覆盖掉根节点下的子节点;
   <2>开始删除节点使用的是rootElement.removeContent(element);直接删除节点的方法,直接报错:Exception in thread "main" java.util.ConcurrentModificationException  除非删除之后立刻执行break;另外调用element.removeContent();就不会出现这样的问题;

   <3>根据输出节点集合的个数可知,再循环的时候改变集合数量会直接影响循环,因为循环过程中并没有随着数量的修改而改变循环的次数。但element.removeContent(); 不一样,循环至始至终集合数量都没有发生改变,只是将这个节点的引用置为null了。


2、生成xml文档

JDom能够解析xml,同样肯定能生成xml,而且使用起来更加简单方便。

实现思路:

   <1>创建Document对象,添加节点以及节点下的文本、名称和属性值;

   <2>创建XMLOutputter的实例,调用output()方法把document写入磁盘;

具体代码如下:

  1. public void buildXml01(){  
  2.     //自己封装xml文档对象   
  3.     Element rootElement = new Element("Document");  
  4.     Element element = new Element("Element");  
  5.       
  6.     Element nameElement = new Element("name");  
  7.     nameElement.setText("<名称>");  
  8.     Element valueElement = new Element("value");  
  9.     valueElement.setText("<值 >\"\\");  
  10.     Element descriptionElement = new Element("description");  
  11.     descriptionElement.setText("<描述><![CDATA[<查看是否转义保存>]]>");  
  12.     //添加子节点   
  13.     element.addContent(nameElement);  
  14.     element.addContent(valueElement);  
  15.     element.addContent(descriptionElement);  
  16.       
  17.     rootElement.addContent(element);  
  18.       
  19.     Document document = new Document(rootElement);  
  20.     DocType docType = new DocType("Doctype");  
  21.     document.setDocType(docType);  
  22.       
  23.     XMLOutputter xmloutputter = new XMLOutputter();  
  24.     OutputStream outputStream;  
  25.     try {  
  26.         outputStream = new FileOutputStream("c:\\document.xml");  
  27.         xmloutputter.output(document, outputStream);  
  28.         System.out.println("xml文档生成成功!");  
  29.     } catch (FileNotFoundException e) {  
  30.         e.printStackTrace();  
  31.     } catch (IOException e) {  
  32.         e.printStackTrace();  
  33.     }  
  34. }  

接下来执行该类的main方法,console提示生成成功。

然后到c盘根目录寻找document.xml,具体如下:

实践发现:

   <1>如果不指定编码,生成的xml默认是UTF-8编码的;
   <2>节点内的文本内容包含标签标记符都会被转义成&lt; &gt; ,,但是其他特殊符号就不会,比如空格,双引用,单引号,斜杠 等等。


 

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:1821次
    • 积分:52
    • 等级:
    • 排名:千里之外
    • 原创:2篇
    • 转载:10篇
    • 译文:0篇
    • 评论:0条
    文章存档