DOM、SAX、DOM4J、JDOM、StAX生成XML并返回XML字符串形式

轉自:http://dreams75.iteye.com/blog/512319

本文用DOM、SAX、DOM4J、JDOM和JDK1.6中新增的StAX生成XML数据格式，并返回XML字符串形式。这里说一下StAX方式。
JDK6的新特性StAX(JSR 173)是JDK6.0中除了DOM和SAX之外的又一种处理XML文档的API
StAX的来历
在JAXP1.3(JSR 206)有两种处理XML文档的方法:DOM(Document Object Model)和SAX(Simple API forXML).由于JDK6.0中的JAXB2(JSR 222)和JAX-WS 2.0(JSR224)都会用到StAX所以Sun决定把StAX加入到JAXP家族当中来，并将JAXP的版本升级到1.4(JAXP1.4是JAXP1.3的维护版本),JDK6里面JAXP的版本就是1.4。
StAX是The Streaming API for XML的缩写，一种利用拉模式解析(pull-parsing)XML文档的API.StAX通过提供一种基于事件迭代器(Iterator)的API让程序员去控制xml文档解析过程,程序遍历这个事件迭代器去处理每一个解析事件，解析事件可以看做是程序拉出来的，也就是程序促使解析器产生一个解析事件然后处理该事件，之后又促使解析器产生下一个解析事件，如此循环直到碰到文档结束符；SAX也是基于事件处理xml文档，但却是用推模式解析，解析器解析完整个xml文档后，才产生解析事件，然后推给程序去处理这些事件；DOM采用的方式是将整个xml文档映射到一颗内存树，这样就可以很容易地得到父节点和子结点以及兄弟节点的数据，但如果文档很大，将会严重影响性能。
CreateXMLText.java

     

      

       

        

       
       

        

         import java.io.BufferedWriter;
        
       
      

       

        

       
       

        

         import java.io.FileNotFoundException;
        
       
      

       

        

       
       

        

         import java.io.FileOutputStream;
        
       
      

       

        

       
       

        

         import java.io.FileWriter;
        
       
      

       

        

       
       

        

         import java.io.IOException;
        
       
      

       

        

       
       

        

         import java.io.OutputStreamWriter;
        
       
      

       

        

       
       

        

         import java.io.PrintWriter;
        
       
      

       

        

       
       

        

         import java.io.StringWriter;
        
       
      

       

        

       
       

        

         import java.io.UnsupportedEncodingException;
        
       
      

       

        

       
       

        

         import java.util.List;
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         import javax.xml.parsers.DocumentBuilder;
        
       
      

       

        

       
       

        

         import javax.xml.parsers.DocumentBuilderFactory;
        
       
      

       

        

       
       

        

         import javax.xml.parsers.ParserConfigurationException;
        
       
      

       

        

       
       

        

         import javax.xml.stream.XMLEventReader;
        
       
      

       

        

       
       

        

         import javax.xml.stream.XMLOutputFactory;
        
       
      

       

        

       
       

        

         import javax.xml.stream.XMLStreamException;
        
       
      

       

        

       
       

        

         import javax.xml.stream.XMLStreamWriter;
        
       
      

       

        

       
       

        

         import javax.xml.transform.OutputKeys;
        
       
      

       

        

       
       

        

         import javax.xml.transform.Result;
        
       
      

       

        

       
       

        

         import javax.xml.transform.Transformer;
        
       
      

       

        

       
       

        

         import javax.xml.transform.TransformerConfigurationException;
        
       
      

       

        

       
       

        

         import javax.xml.transform.TransformerException;
        
       
      

       

        

       
       

        

         import javax.xml.transform.TransformerFactory;
        
       
      

       

        

       
       

        

         import javax.xml.transform.dom.DOMSource;
        
       
      

       

        

       
       

        

         import javax.xml.transform.sax.SAXTransformerFactory;
        
       
      

       

        

       
       

        

         import javax.xml.transform.sax.TransformerHandler;
        
       
      

       

        

       
       

        

         import javax.xml.transform.stax.StAXSource;
        
       
      

       

        

       
       

        

         import javax.xml.transform.stream.StreamResult;
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         import org.dom4j.DocumentFactory;
        
       
      

       

        

       
       

        

         import org.dom4j.io.OutputFormat;
        
       
      

       

        

       
       

        

         import org.dom4j.io.XMLWriter;
        
       
      

       

        

       
       

        

         import org.jdom.Document;
        
       
      

       

        

       
       

        

         import org.jdom.Element;
        
       
      

       

        

       
       

        

         import org.jdom.output.XMLOutputter;
        
       
      

       

        

       
       

        

         import org.w3c.dom.Node;
        
       
      

       

        

       
       

        

         import org.w3c.dom.Text;
        
       
      

       

        

       
       

        

         import org.xml.sax.SAXException;
        
       
      

       

        

       
       

        

         import org.xml.sax.helpers.AttributesImpl;
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         /**
        
       
      

       

        

       
       

        

          * DOM、SAX、DOM4J、JDOM、StAX生成XML，返回各种方式生成XML的字符串形式
        
       
      

       

        

       
       

        

          * <p>
        
       
      

       

        

       
       

        

          * <cities><city><id>151</id><name>长沙市</name></city><city><id>152</id><name>永州市
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         </name></city></cities>
        
       
      

       

        

       
       

        

          * </p>
        
       
      

       

        

       
       

        

          * @author fzbtshy@163.com
        
       
      

       

        

       
       

        

          *
        
       
      

       

        

       
       

        

          */
        
       
      

       

        

       
       

        

         public 
         class CreateXMLText {
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         /**
        
       
      

       

        

       
       

        

          * DOM方式生成XML
        
       
      

       

        

       
       

        

          * @param cityList
        
       
      

       

        

       
       

        

          * @return
        
       
      

       

        

       
       

        

          */
        
       
      

       

        

       
       

        
 
         public String domToXml(List<City> list) {
        
       
      

       

        

       
       

        

         String xmlStr = 
         null;
        
       
      

       

        

       
       

        
 
         try {
        
       
      

       

        

       
       

        
 
         if (
         null != list && !list.isEmpty()) {
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         // 实例化DOM生成工厂
        
       
      

       

        

       
       

        

         DocumentBuilderFactory dbf = DocumentBuilderFactory
        
       
      

       

        

       
       

        

         .newInstance();
        
       
      

       

        

       
       

        
 
         // 由工厂实例化文档创建器
        
       
      

       

        

       
       

        

         DocumentBuilder db = dbf.newDocumentBuilder();
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         // 由文档创建器实例化文档对象
        
       
      

       

        

       
       

        

         org.w3c.dom.Document doc = db.newDocument();
        
       
      

       

        

       
       

        
 
         // 文档对象创建一个根元素<cities>
        
       
      

       

        

       
       

        

         org.w3c.dom.Element cities = doc.createElement(
         "cities");
        
       
      

       

        

       
       

        

         doc.appendChild(cities);
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         for (City po : list) {
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         // 创建<cities>的子元素<city>
        
       
      

       

        

       
       

        

         org.w3c.dom.Element cityElt = doc.createElement
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         (
         "city");
        
       
      

       

        

       
       

        

         cities.appendChild(cityElt);
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         // 创建<city>的子元素<id>
        
       
      

       

        

       
       

        

         org.w3c.dom.Element idElt = doc.createElement
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         (
         "id");
        
       
      

       

        

       
       

        

         cityElt.appendChild(idElt);
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         // 创建子元素<id>的文本值
        
       
      

       

        

       
       

        
 
         // 第一种方式
        
       
      

       

        

       
       

        
 
         // Text idTxt = doc.createTextNode(String.valueOf
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         (c.getId()));
        
       
      

       

        

       
       

        
 
         // idElt.appendChild(idTxt);
        
       
      

       

        

       
       

        
 
         // 第二种方式
        
       
      

       

        

       
       

        

         idElt.setTextContent(String.valueOf(po.getId()));
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         // 创建<city>的子元素<name>
        
       
      

       

        

       
       

        

         org.w3c.dom.Element nameElt = doc.createElement
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         (
         "name");
        
       
      

       

        

       
       

        

         cityElt.appendChild(nameElt);
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         // 创建子元素<name>的文本值
        
       
      

       

        

       
       

        

         Text nameTxt = doc.createTextNode(po.getName());
        
       
      

       

        

       
       

        

         nameElt.appendChild(nameTxt);
        
       
      

       

        

       
       

        

         // nameElt.setTextContent(po.getName());
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         }
        
       
      

       

        

       
       

        

         xmlStr = getDomXml(doc);
        
       
      

       

        

       
       

        

         }
        
       
      

       

        

       
       

        

         } 
         catch (ParserConfigurationException e) {
        
       
      

       

        

       
       

        

         e.printStackTrace();
        
       
      

       

        

       
       

        

         }
        
       
      

       

        

       
       

        

         System.out.println(
         "DOM:" + xmlStr);
        
       
      

       

        

       
       

        
 
         return xmlStr;
        
       
      

       

        

       
       

        

         }
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         /**
        
       
      

       

        

       
       

        

          * 将org.w3c.dom.Document内容转化成String
        
       
      

       

        

       
       

        

          * 
        
       
      

       

        

       
       

        

          * @param doc
        
       
      

       

        

       
       

        

          * @return
        
       
      

       

        

       
       

        

          */
        
       
      

       

        

       
       

        
 
         private String getDomXml(Node doc) {
        
       
      

       

        

       
       

        

         String xmlStr = 
         null;
        
       
      

       

        

       
       

        
 
         try {
        
       
      

       

        

       
       

        

         // 以 Document Object Model（DOM）树的形式充当转换 Source 树的持有者
        
       
      

       

        

       
       

        

         DOMSource source = 
         new DOMSource(doc);
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        
 
         //用来生成XML文件
        
       
      

       

        

       
       

        
 
         // 要生成文件需构造PrintWriter的writer,
        
       
      

       

        

       
       

        

         //DOM中这种方式name的值没有写进去,由于编码的问题
        
       
      

       

        

       
       

        

         // PrintWriter writerXml = new PrintWriter(new FileOutputStream
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         (
         "city-dom.xml"));
        
       
      

       

        

       
       

        
 
         //用OutputStreamWriter加了编码就OK了
        
       
      

       

        

       
       

        

         PrintWriter writerXml = 
         new PrintWriter(
         new OutputStreamWriter(
         new 
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         FileOutputStream(
         "city-jdom.xml"),
         "utf-8"));
        
       
      

       

        

       
       

        

         Result resultXml = 
         new StreamResult(writerXml);
        
       
      

       

        

       
       

        
 
         // 实现此接口的对象包含构建转换结果树所需的信息
        
       
      

       

        

       
       

        

         // Result resultXml = new StreamResult(new FileOutputStream("city-
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         dom.xml
         "));
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          //用来得到XML字符串形式
        
       
      

       

        

       
       

        

          // 一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。
        
       
      

       

        

       
       

        

          StringWriter writerStr = new StringWriter();
        
       
      

       

        

       
       

        

          Result resultStr = new StreamResult(writerStr);
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          // 此抽象类的实例能够将源树转换为结果树。
        
       
      

       

        

       
       

        

          Transformer transformer = TransformerFactory.newInstance()
        
       
      

       

        

       
       

        

          .newTransformer();
        
       
      

       

        

       
       

        

          // 设置编码
        
       
      

       

        

       
       

        

          transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-
         8
         ");
        
       
      

       

        

       
       

        

          // 是否缩进
        
       
      

       

        

       
       

        

          transformer.setOutputProperty(OutputKeys.INDENT, "yes
         ");
        
       
      

       

        

       
       

        

          // 将 XML Source 转换为 Result
        
       
      

       

        

       
       

        

          transformer.transform(source, resultXml);
        
       
      

       

        

       
       

        

          transformer.transform(source, resultStr);
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          //获取XML字符串
        
       
      

       

        

       
       

        

          xmlStr = writerStr.getBuffer().toString();
        
       
      

       

        

       
       

        

          } catch (TransformerException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          } catch (Exception e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          return xmlStr;
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          /**
        
       
      

       

        

       
       

        

          * SAX方式生成XML
        
       
      

       

        

       
       

        

          * 
        
       
      

       

        

       
       

        

          * @param list
        
       
      

       

        

       
       

        

          * @return
        
       
      

       

        

       
       

        

          */
        
       
      

       

        

       
       

        

          public String saxToXml(List<City> list) {
          
        
       
      

       

        

       
       

        

          String xmlStr = null;
        
       
      

       

        

       
       

        

          try {
          
        
       
      

       

        

       
       

        

          //用来生成XML文件
        
       
      

       

        

       
       

        

          // 要生成文件需构造PrintWriter的writer
        
       
      

       

        

       
       

        

         // PrintWriter writerXml = new PrintWriter("city-sax.xml
         ");
        
       
      

       

        

       
       

        

         // Result resultXml = new StreamResult(writerXml);
        
       
      

       

        

       
       

        

          // 实现此接口的对象包含构建转换结果树所需的信息
        
       
      

       

        

       
       

        

          Result resultXml = new StreamResult(new FileOutputStream("city-
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         sax.xml
         "));
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          //用来得到XML字符串形式
        
       
      

       

        

       
       

        

          // 一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串
        
       
      

       

        

       
       

        

          StringWriter writerStr = new StringWriter();
        
       
      

       

        

       
       

        

          // 构建转换结果树所需的信息。
        
       
      

       

        

       
       

        

          Result resultStr = new StreamResult(writerStr);
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          // 创建SAX转换工厂
        
       
      

       

        

       
       

        

          SAXTransformerFactory sff = (SAXTransformerFactory) 
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         SAXTransformerFactory
        
       
      

       

        

       
       

        

          .newInstance();
        
       
      

       

        

       
       

        

          // 转换处理器，侦听 SAX ContentHandler 
        
       
      

       

        

       
       

        

         //解析事件，并将它们转换为结果树 Result
        
       
      

       

        

       
       

        

          TransformerHandler th = sff.newTransformerHandler();
        
       
      

       

        

       
       

        

          // 将源树转换为结果树
        
       
      

       

        

       
       

        

          Transformer transformer = th.getTransformer();
        
       
      

       

        

       
       

        

          // 设置字符编码
        
       
      

       

        

       
       

        

          transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-
         8
         ");
        
       
      

       

        

       
       

        

          // 是否缩进
        
       
      

       

        

       
       

        

          transformer.setOutputProperty(OutputKeys.INDENT, "yes
         ");
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          //设置与用于转换的此 TransformerHandler 关联的 Result
        
       
      

       

        

       
       

        

          //注：这两个th.setResult不能同时启用
        
       
      

       

        

       
       

        

         // th.setResult(resultXml); th.setResult(resultStr);
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          th.startDocument();
        
       
      

       

        

       
       

        

          AttributesImpl attr = new AttributesImpl();
        
       
      

       

        

       
       

        

          th.startElement("
         ", "
         ", "cities
         ", attr);
        
       
      

       

        

       
       

        

          if (null != list && !list.isEmpty()) {
          
        
       
      

       

        

       
       

        

          for (int i = 0; i < list.size(); i++) {
          
        
       
      

       

        

       
       

        

          th.startElement("
         ", "
         ", "city
         ", attr);
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          th.startElement("
         ", "
         ", "id
         ", attr);
        
       
      

       

        

       
       

        

          String id = String.valueOf(list.get(i).getId());
        
       
      

       

        

       
       

        

          th.characters(id.toCharArray(), 0, id.length());
        
       
      

       

        

       
       

        

          th.endElement("
         ", "
         ", "id
         ");
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          th.startElement("
         ", "
         ", "name
         ", attr);
        
       
      

       

        

       
       

        

          String name = String.valueOf(list.get(i).getName
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         ());
        
       
      

       

        

       
       

        

          th.characters(name.toCharArray(), 0, name.length
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         ());
        
       
      

       

        

       
       

        

          th.endElement("
         ", "
         ", "name
         ");
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          th.endElement("
         ", "
         ", "city
         ");
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          th.endElement("
         ", "
         ", "cities
         ");
        
       
      

       

        

       
       

        

          th.endDocument();
        
       
      

       

        

       
       

        

          xmlStr = writerStr.getBuffer().toString();
        
       
      

       

        

       
       

        

          } catch (TransformerConfigurationException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          } catch (SAXException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          } catch (Exception e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          System.out.println("SAX:
         " + xmlStr);
        
       
      

       

        

       
       

        

          return xmlStr;
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          /**
        
       
      

       

        

       
       

        

          * StAX生成XML，它是The Streaming API for XML简称
        
       
      

       

        

       
       

        

          * JDK1.6的新增
        
       
      

       

        

       
       

        

          * @param list
        
       
      

       

        

       
       

        

          * @return
        
       
      

       

        

       
       

        

          */
        
       
      

       

        

       
       

        

          public String stAXToXml( List<City> list ){
          
        
       
      

       

        

       
       

        

          String xmlStr = null;
        
       
      

       

        

       
       

        

          try {
          
        
       
      

       

        

       
       

        

          if (null != list && !list.isEmpty()) {
          
        
       
      

       

        

       
       

        

          StringWriter writerStr = new StringWriter();
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          PrintWriter writerXml = new PrintWriter(new 
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         OutputStreamWriter(new FileOutputStream("city-StAX.xml
         "),"utf-
         8
         "));
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

         //定义用于获取 XMLEventWriter 和 XMLStreamWriter 的工厂抽象实现
        
       
      

       

        

       
       

        

          XMLOutputFactory xof = XMLOutputFactory.newInstance();
        
       
      

       

        

       
       

        

          //指定如何写XML，注：以下两行只能启用一行
        
       
      

       

        

       
       

        

         // XMLStreamWriter xmlsw = xof.createXMLStreamWriter
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         (writerStr);
        
       
      

       

        

       
       

        

          XMLStreamWriter xmlsw = xof.createXMLStreamWriter
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         (writerXml);
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          //写入XML文档声明
        
       
      

       

        

       
       

        

          xmlsw.writeStartDocument("UTF-
         8
         ", "
         1.0
         ");
        
       
      

       

        

       
       

        

          xmlsw.writeStartElement("cities
         ");
        
       
      

       

        

       
       

        

          // 写入注释到xml文档
        
       
      

       

        

       
       

        

          xmlsw.writeComment("省和城市信息
         ");
        
       
      

       

        

       
       

        

          for (City po : list) {
          
        
       
      

       

        

       
       

        

          xmlsw.writeStartElement("city
         ");
        
       
      

       

        

       
       

        

          //添加<id>节点
        
       
      

       

        

       
       

        

          xmlsw.writeStartElement("id
         ");
        
       
      

       

        

       
       

        

          xmlsw.writeCharacters(String.valueOf(po.getId()));
        
       
      

       

        

       
       

        

          // 结束<id>节点
        
       
      

       

        

       
       

        

          xmlsw.writeEndElement();
        
       
      

       

        

       
       

        

          //添加<name>节点
        
       
      

       

        

       
       

        

          xmlsw.writeStartElement("name
         ");
        
       
      

       

        

       
       

        

          xmlsw.writeCharacters(po.getName());
        
       
      

       

        

       
       

        

          // 结束<name>节点
        
       
      

       

        

       
       

        

          xmlsw.writeEndElement();
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          xmlsw.writeEndElement();
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          // 结束<cities>节点
        
       
      

       

        

       
       

        

          xmlsw.writeEndElement();
        
       
      

       

        

       
       

        

          // 结束 XML 文档
        
       
      

       

        

       
       

        

          xmlsw.writeEndDocument();
        
       
      

       

        

       
       

        

          xmlsw.flush();
        
       
      

       

        

       
       

        

          xmlsw.close();
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          xmlStr = writerStr.getBuffer().toString();
        
       
      

       

        

       
       

        

          writerStr.close();
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          } catch (XMLStreamException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          } catch (IOException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          System.out.println("StAX:
         " + xmlStr );
        
       
      

       

        

       
       

        

          return xmlStr;
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          /**
        
       
      

       

        

       
       

        

          * JDOM方式生成XML
        
       
      

       

        

       
       

        

          * 
        
       
      

       

        

       
       

        

          * @param list
        
       
      

       

        

       
       

        

          * @return
        
       
      

       

        

       
       

        

          */
        
       
      

       

        

       
       

        

          public String jdomToXml(List<City> list) {
          
        
       
      

       

        

       
       

        

          String xmlStr = null;
        
       
      

       

        

       
       

        

          try {
          
        
       
      

       

        

       
       

        

          // 创建文档根节点<cities>
        
       
      

       

        

       
       

        

          Element citiesElt = new Element("cities
         ");
        
       
      

       

        

       
       

        

          if (null != list && !list.isEmpty()) {
          
        
       
      

       

        

       
       

        

          for (City po : list) {
          
        
       
      

       

        

       
       

        

          // 创建子元素节点<city>
        
       
      

       

        

       
       

        

          Element cityElt = new Element("city
         ");
        
       
      

       

        

       
       

        

          // 创建子元素节点<id>
        
       
      

       

        

       
       

        

          Element idElt = new Element("id
         ");
        
       
      

       

        

       
       

        

          // 向元素<city>中添加子元素<id>
        
       
      

       

        

       
       

        

          cityElt.addContent(idElt);
        
       
      

       

        

       
       

        

          // 添加id文本
        
       
      

       

        

       
       

        

          idElt.addContent(String.valueOf(po.getId()));
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          // 创建元素节点<name>
        
       
      

       

        

       
       

        

          Element nameElt = new Element("name
         ");
        
       
      

       

        

       
       

        

          // 向元素<city>中添加子元素<name>
        
       
      

       

        

       
       

        

          cityElt.addContent(nameElt);
        
       
      

       

        

       
       

        

          // 添加name文本
        
       
      

       

        

       
       

        

          nameElt.addContent(po.getName());
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          // 在文档根节点添加子节点<city>
        
       
      

       

        

       
       

        

          citiesElt.addContent(cityElt);
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          Document doc = new Document(citiesElt);
        
       
      

       

        

       
       

        

          XMLOutputter out = new XMLOutputter();
        
       
      

       

        

       
       

        

          //获得XML字符串形式
        
       
      

       

        

       
       

        

          xmlStr = out.outputString(doc);
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          //生成XML文件
        
       
      

       

        

       
       

        

          PrintWriter writer = new PrintWriter(new OutputStreamWriter(new 
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         FileOutputStream("city-jdom.xml
         "),"utf-
         8
         "));
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          out.output(doc, writer);
        
       
      

       

        

       
       

        

          writer.flush();
        
       
      

       

        

       
       

        

          writer.close();
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          } catch (UnsupportedEncodingException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          } catch (FileNotFoundException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          } catch (IOException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          System.out.println("JDOM:
         " + xmlStr);
        
       
      

       

        

       
       

        

          return xmlStr;
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          /**
        
       
      

       

        

       
       

        

          * DOM4J生成XML
        
       
      

       

        

       
       

        

          * 
        
       
      

       

        

       
       

        

          * @param list
        
       
      

       

        

       
       

        

          * @return
        
       
      

       

        

       
       

        

          */
        
       
      

       

        

       
       

        

          public String dom4jToXml(List<City> list) {
          
        
       
      

       

        

       
       

        

          String strXml = null;
        
       
      

       

        

       
       

        

          try {
          
        
       
      

       

        

       
       

        

          if (null != list && !list.isEmpty()) {
          
        
       
      

       

        

       
       

        

          DocumentFactory df = DocumentFactory.getInstance();
        
       
      

       

        

       
       

        

          // org.dom4j.Document doc = DocumentHelper.createDocument
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         ();
        
       
      

       

        

       
       

        

          org.dom4j.Document doc = df.createDocument("UTF-
         8
         ");
        
       
      

       

        

       
       

        

          // 创建根节点
        
       
      

       

        

       
       

        

          org.dom4j.Element citiesElt = doc.addElement("cities
         ");
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          for (City po : list) {
          
        
       
      

       

        

       
       

        

          // 在节点<cities>下增加子节点<city>
        
       
      

       

        

       
       

        

          org.dom4j.Element cityElt = citiesElt.addElement
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         ("city
         ");
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          // 在节点<city>下增加子节点<id>
        
       
      

       

        

       
       

        

          org.dom4j.Element idElt = cityElt.addElement
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         ("id
         ");
        
       
      

       

        

       
       

        

          idElt.addText(String.valueOf(po.getId()));
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          // 在节点<city>下增加子节点<name>
        
       
      

       

        

       
       

        

          org.dom4j.Element nameElt = cityElt.addElement
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         ("name
         ");
        
       
      

       

        

       
       

        

          nameElt.addText(po.getName());
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          // 有样式(缩进)的写出
        
       
      

       

        

       
       

        

          OutputFormat opf = OutputFormat.createPrettyPrint();
        
       
      

       

        

       
       

        

          opf.setEncoding("UTF-
         8
         ");
        
       
      

       

        

       
       

        

          opf.setTrimText(true);
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          //生成XML文件
        
       
      

       

        

       
       

        

          XMLWriter xmlOut = new XMLWriter(new FileOutputStream
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         ("city-dom4j.xml
         "), opf);
        
       
      

       

        

       
       

        

          xmlOut.write(doc);
        
       
      

       

        

       
       

        

          xmlOut.flush();
        
       
      

       

        

       
       

        

          xmlOut.close();
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          //获取XML字符串形式
        
       
      

       

        

       
       

        

          StringWriter writerStr = new StringWriter();
        
       
      

       

        

       
       

        

          XMLWriter xmlw = new XMLWriter(writerStr, opf);
        
       
      

       

        

       
       

        

          xmlw.write(doc);
        
       
      

       

        

       
       

        

          strXml = writerStr.getBuffer().toString();
        
       
      

       

        

       
       

        

          
        
       
      

       

        

       
       

        

          // 无样式的
        
       
      

       

        

       
       

        

          // strXml = doc.asXML();
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          } catch (IOException e) {
          
        
       
      

       

        

       
       

        

          e.printStackTrace();
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

          System.out.println("DOM4J:
         " + strXml);
        
       
      

       

        

       
       

        

          return strXml;
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

          public static void main(String[] args) throws Exception {
          
        
       
      

       

        

       
       

        

          List<City> list = City.getCityList(101L);
        
       
      

       

        

       
       

        

          CreateXMLText xml = new CreateXMLText();
        
       
      

       

        

       
       

        

          xml.domToXml(list);
        
       
      

       

        

       
       

        

          xml.saxToXml(list);
        
       
      

       

        

       
       

        

          xml.stAXToXml(list);
        
       
      

       

        

       
       

        

          xml.dom4jToXml(list);
        
       
      

       

        

       
       

        

          xml.jdomToXml(list);
        
       
      

       

        

       
       

        

          }
        
       
      

       

        

       
       

        

         
        
       
      

       

        

       
       

        

         }