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

Java代码 复制代码
  1. import java.io.BufferedWriter;   
  2. import java.io.FileNotFoundException;   
  3. import java.io.FileOutputStream;   
  4. import java.io.FileWriter;   
  5. import java.io.IOException;   
  6. import java.io.OutputStreamWriter;   
  7. import java.io.PrintWriter;   
  8. import java.io.StringWriter;   
  9. import java.io.UnsupportedEncodingException;   
  10. import java.util.List;   
  11.   
  12. import javax.xml.parsers.DocumentBuilder;   
  13. import javax.xml.parsers.DocumentBuilderFactory;   
  14. import javax.xml.parsers.ParserConfigurationException;   
  15. import javax.xml.stream.XMLEventReader;   
  16. import javax.xml.stream.XMLOutputFactory;   
  17. import javax.xml.stream.XMLStreamException;   
  18. import javax.xml.stream.XMLStreamWriter;   
  19. import javax.xml.transform.OutputKeys;   
  20. import javax.xml.transform.Result;   
  21. import javax.xml.transform.Transformer;   
  22. import javax.xml.transform.TransformerConfigurationException;   
  23. import javax.xml.transform.TransformerException;   
  24. import javax.xml.transform.TransformerFactory;   
  25. import javax.xml.transform.dom.DOMSource;   
  26. import javax.xml.transform.sax.SAXTransformerFactory;   
  27. import javax.xml.transform.sax.TransformerHandler;   
  28. import javax.xml.transform.stax.StAXSource;   
  29. import javax.xml.transform.stream.StreamResult;   
  30.   
  31. import org.dom4j.DocumentFactory;   
  32. import org.dom4j.io.OutputFormat;   
  33. import org.dom4j.io.XMLWriter;   
  34. import org.jdom.Document;   
  35. import org.jdom.Element;   
  36. import org.jdom.output.XMLOutputter;   
  37. import org.w3c.dom.Node;   
  38. import org.w3c.dom.Text;   
  39. import org.xml.sax.SAXException;   
  40. import org.xml.sax.helpers.AttributesImpl;   
  41.   
  42. /**  
  43.  * DOM、SAX、DOM4J、JDOM、StAX生成XML,返回各种方式生成XML的字符串形式  
  44.  * <p>  
  45.  * <cities><city><id>151</id><name>长沙市</name></city><city><id>152</id><name>永州市  
  46.  
  47. </name></city></cities>  
  48.  * </p>  
  49.  * @author [email protected]  
  50.  *  
  51.  */  
  52. public class CreateXMLText {   
  53.   
  54.     /**  
  55.      * DOM方式生成XML  
  56.      * @param cityList  
  57.      * @return  
  58.      */  
  59.     public String domToXml(List<City> list) {   
  60.         String xmlStr = null;   
  61.         try {   
  62.             if (null != list && !list.isEmpty()) {   
  63.   
  64.                 // 实例化DOM生成工厂   
  65.                 DocumentBuilderFactory dbf = DocumentBuilderFactory   
  66.                         .newInstance();   
  67.                 // 由工厂实例化文档创建器   
  68.                 DocumentBuilder db = dbf.newDocumentBuilder();   
  69.   
  70.                 // 由文档创建器实例化文档对象   
  71.                 org.w3c.dom.Document doc = db.newDocument();   
  72.                 // 文档对象创建一个根元素<cities>   
  73.                 org.w3c.dom.Element cities = doc.createElement("cities");   
  74.                 doc.appendChild(cities);   
  75.   
  76.                 for (City po : list) {   
  77.   
  78.                     // 创建<cities>的子元素<city>   
  79.                     org.w3c.dom.Element cityElt = doc.createElement   
  80.   
  81. ("city");   
  82.                     cities.appendChild(cityElt);   
  83.   
  84.                     // 创建<city>的子元素<id>   
  85.                     org.w3c.dom.Element idElt = doc.createElement   
  86.   
  87. ("id");   
  88.                     cityElt.appendChild(idElt);   
  89.   
  90.                     // 创建子元素<id>的文本值   
  91.                     // 第一种方式   
  92.                     // Text idTxt = doc.createTextNode(String.valueOf   
  93.   
  94. (c.getId()));   
  95.                     // idElt.appendChild(idTxt);   
  96.                     // 第二种方式   
  97.                     idElt.setTextContent(String.valueOf(po.getId()));   
  98.   
  99.                     // 创建<city>的子元素<name>   
  100.                     org.w3c.dom.Element nameElt = doc.createElement   
  101.   
  102. ("name");   
  103.                     cityElt.appendChild(nameElt);   
  104.   
  105.                     // 创建子元素<name>的文本值   
  106.                     Text nameTxt = doc.createTextNode(po.getName());   
  107.                     nameElt.appendChild(nameTxt);   
  108. //                  nameElt.setTextContent(po.getName());   
  109.   
  110.                 }   
  111.                 xmlStr = getDomXml(doc);   
  112.             }   
  113.         } catch (ParserConfigurationException e) {   
  114.             e.printStackTrace();   
  115.         }   
  116.         System.out.println("DOM:" + xmlStr);   
  117.         return xmlStr;   
  118.     }   
  119.   
  120.     /**  
  121.      * 将org.w3c.dom.Document内容转化成String  
  122.      *   
  123.      * @param doc  
  124.      * @return  
  125.      */  
  126.     private String getDomXml(Node doc) {   
  127.         String xmlStr = null;   
  128.         try {   
  129. // 以 Document Object Model(DOM)树的形式充当转换 Source 树的持有者   
  130.             DOMSource source = new DOMSource(doc);   
  131.                
  132.             //用来生成XML文件   
  133.                                // 要生成文件需构造PrintWriter的writer,   
  134. //DOM中这种方式name的值没有写进去,由于编码的问题   
  135. //          PrintWriter writerXml = new PrintWriter(new FileOutputStream   
  136.   
  137. ("city-dom.xml"));   
  138.             //用OutputStreamWriter加了编码就OK了   
  139.             PrintWriter writerXml = new PrintWriter(new OutputStreamWriter(new    
  140.   
  141. FileOutputStream("city-jdom.xml"),"utf-8"));   
  142.             Result resultXml = new StreamResult(writerXml);   
  143.             // 实现此接口的对象包含构建转换结果树所需的信息   
  144. //          Result resultXml = new StreamResult(new FileOutputStream("city-   
  145.   
  146. dom.xml"));   
  147.   
  148.             //用来得到XML字符串形式   
  149.     // 一个字符流,可以用其回收在字符串缓冲区中的输出来构造字符串。   
  150.             StringWriter writerStr = new StringWriter();   
  151.             Result resultStr = new StreamResult(writerStr);   
  152.                
  153.             // 此抽象类的实例能够将源树转换为结果树。   
  154.             Transformer transformer = TransformerFactory.newInstance()   
  155.                     .newTransformer();   
  156.             // 设置编码   
  157.             transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");   
  158.             // 是否缩进   
  159.             transformer.setOutputProperty(OutputKeys.INDENT, "yes");   
  160.             // 将 XML Source 转换为 Result   
  161.             transformer.transform(source, resultXml);   
  162.             transformer.transform(source, resultStr);   
  163.   
  164.             //获取XML字符串   
  165.             xmlStr = writerStr.getBuffer().toString();   
  166.         } catch (TransformerException e) {   
  167.             e.printStackTrace();   
  168.         } catch (Exception e) {   
  169.             e.printStackTrace();   
  170.         }   
  171.         return xmlStr;   
  172.     }   
  173.   
  174.     /**  
  175.      * SAX方式生成XML  
  176.      *   
  177.      * @param list  
  178.      * @return  
  179.      */  
  180.     public String saxToXml(List<City> list) {   
  181.         String xmlStr = null;   
  182.         try {   
  183.             //用来生成XML文件   
  184.             // 要生成文件需构造PrintWriter的writer   
  185. //          PrintWriter writerXml = new PrintWriter("city-sax.xml");   
  186. //          Result resultXml = new StreamResult(writerXml);   
  187.             // 实现此接口的对象包含构建转换结果树所需的信息   
  188.             Result resultXml = new StreamResult(new FileOutputStream("city-   
  189.   
  190. sax.xml"));   
  191.                
  192.             //用来得到XML字符串形式   
  193.     // 一个字符流,可以用其回收在字符串缓冲区中的输出来构造字符串   
  194.             StringWriter writerStr = new StringWriter();   
  195.             // 构建转换结果树所需的信息。   
  196.             Result resultStr = new StreamResult(writerStr);   
  197.                
  198.             // 创建SAX转换工厂   
  199.             SAXTransformerFactory sff = (SAXTransformerFactory)    
  200.   
  201. SAXTransformerFactory   
  202.                     .newInstance();   
  203.             // 转换处理器,侦听 SAX ContentHandler    
  204. //解析事件,并将它们转换为结果树 Result   
  205.             TransformerHandler th = sff.newTransformerHandler();   
  206.             // 将源树转换为结果树   
  207.             Transformer transformer = th.getTransformer();   
  208.             // 设置字符编码   
  209.             transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");   
  210.             // 是否缩进   
  211.              transformer.setOutputProperty(OutputKeys.INDENT, "yes");   
  212.                 
  213.         //设置与用于转换的此 TransformerHandler 关联的 Result   
  214.                   //注:这两个th.setResult不能同时启用   
  215. //          th.setResult(resultXml);            th.setResult(resultStr);   
  216.                
  217.             th.startDocument();   
  218.             AttributesImpl attr = new AttributesImpl();   
  219.             th.startElement("""""cities", attr);   
  220.             if (null != list && !list.isEmpty()) {   
  221.                 for (int i = 0; i < list.size(); i++) {   
  222.                     th.startElement("""""city", attr);   
  223.   
  224.                     th.startElement("""""id", attr);   
  225.                     String id = String.valueOf(list.get(i).getId());   
  226.                     th.characters(id.toCharArray(), 0, id.length());   
  227.                     th.endElement("""""id");   
  228.   
  229.                     th.startElement("""""name", attr);   
  230.                     String name = String.valueOf(list.get(i).getName   
  231.   
  232. ());   
  233.                     th.characters(name.toCharArray(), 0, name.length   
  234.   
  235. ());   
  236.                     th.endElement("""""name");   
  237.   
  238.                     th.endElement("""""city");   
  239.                 }   
  240.             }   
  241.   
  242.             th.endElement("""""cities");   
  243.             th.endDocument();   
  244.             xmlStr = writerStr.getBuffer().toString();   
  245.         } catch (TransformerConfigurationException e) {   
  246.             e.printStackTrace();   
  247.         } catch (SAXException e) {   
  248.             e.printStackTrace();   
  249.         } catch (Exception e) {   
  250.             e.printStackTrace();   
  251.         }   
  252.         System.out.println("SAX:" + xmlStr);   
  253.         return xmlStr;   
  254.     }   
  255.   
  256.     /**  
  257.      * StAX生成XML,它是The Streaming API for XML简称  
  258.      * JDK1.6的新增  
  259.      * @param list  
  260.      * @return  
  261.      */  
  262.     public String stAXToXml( List<City> list ){   
  263.         String xmlStr = null;   
  264.         try {   
  265.             if (null != list && !list.isEmpty()) {   
  266.                 StringWriter writerStr = new StringWriter();   
  267.                    
  268.                 PrintWriter writerXml = new PrintWriter(new    
  269.   
  270. OutputStreamWriter(new FileOutputStream("city-StAX.xml"),"utf-8"));   
  271.                    
  272. //定义用于获取 XMLEventWriter 和 XMLStreamWriter 的工厂抽象实现   
  273.                 XMLOutputFactory xof = XMLOutputFactory.newInstance();   
  274.         //指定如何写XML,注:以下两行只能启用一行   
  275. //              XMLStreamWriter xmlsw = xof.createXMLStreamWriter   
  276.   
  277. (writerStr);   
  278.                 XMLStreamWriter xmlsw = xof.createXMLStreamWriter   
  279.   
  280. (writerXml);   
  281.                    
  282.                 //写入XML文档声明   
  283.                 xmlsw.writeStartDocument("UTF-8""1.0");   
  284.                 xmlsw.writeStartElement("cities");   
  285.                 // 写入注释到xml文档   
  286.                 xmlsw.writeComment("省和城市信息");   
  287.                 for (City po : list) {   
  288.                     xmlsw.writeStartElement("city");   
  289.                     //添加<id>节点   
  290.                     xmlsw.writeStartElement("id");   
  291.                     xmlsw.writeCharacters(String.valueOf(po.getId()));   
  292.                     // 结束<id>节点   
  293.                     xmlsw.writeEndElement();   
  294.                     //添加<name>节点   
  295.                     xmlsw.writeStartElement("name");   
  296.                     xmlsw.writeCharacters(po.getName());   
  297.                     // 结束<name>节点   
  298.                     xmlsw.writeEndElement();   
  299.                        
  300.                     xmlsw.writeEndElement();   
  301.                 }   
  302.                 // 结束<cities>节点   
  303.                 xmlsw.writeEndElement();   
  304.                 // 结束 XML 文档   
  305.                 xmlsw.writeEndDocument();   
  306.                 xmlsw.flush();   
  307.                 xmlsw.close();   
  308.                    
  309.                 xmlStr = writerStr.getBuffer().toString();   
  310.                 writerStr.close();   
  311.             }   
  312.         } catch (XMLStreamException e) {   
  313.             e.printStackTrace();   
  314.         } catch (IOException e) {   
  315.             e.printStackTrace();   
  316.         }   
  317.         System.out.println("StAX:" + xmlStr  );   
  318.         return xmlStr;   
  319.     }   
  320.        
  321.     /**  
  322.      * JDOM方式生成XML  
  323.      *   
  324.      * @param list  
  325.      * @return  
  326.      */  
  327.     public String jdomToXml(List<City> list) {   
  328.         String xmlStr = null;   
  329.         try {   
  330.             // 创建文档根节点<cities>   
  331.             Element citiesElt = new Element("cities");   
  332.             if (null != list && !list.isEmpty()) {   
  333.                 for (City po : list) {   
  334.                     // 创建子元素节点<city>   
  335.                     Element cityElt = new Element("city");   
  336.                     // 创建子元素节点<id>   
  337.                     Element idElt = new Element("id");   
  338.                     // 向元素<city>中添加子元素<id>   
  339.                     cityElt.addContent(idElt);   
  340.                     // 添加id文本   
  341.                     idElt.addContent(String.valueOf(po.getId()));   
  342.        
  343.                     // 创建元素节点<name>   
  344.                     Element nameElt = new Element("name");   
  345.                     // 向元素<city>中添加子元素<name>   
  346.                     cityElt.addContent(nameElt);   
  347.                     // 添加name文本   
  348.                     nameElt.addContent(po.getName());   
  349.        
  350.                     // 在文档根节点添加子节点<city>   
  351.                     citiesElt.addContent(cityElt);   
  352.                 }   
  353.             }   
  354.                
  355.             Document doc = new Document(citiesElt);   
  356.             XMLOutputter out = new XMLOutputter();   
  357.             //获得XML字符串形式   
  358.             xmlStr = out.outputString(doc);   
  359.                
  360.             //生成XML文件   
  361.             PrintWriter writer = new PrintWriter(new OutputStreamWriter(new    
  362.   
  363. FileOutputStream("city-jdom.xml"),"utf-8"));   
  364.                
  365.             out.output(doc, writer);   
  366.             writer.flush();   
  367.             writer.close();   
  368.                
  369.         } catch (UnsupportedEncodingException e) {   
  370.             e.printStackTrace();   
  371.         } catch (FileNotFoundException e) {   
  372.             e.printStackTrace();   
  373.         } catch (IOException e) {   
  374.             e.printStackTrace();   
  375.         }   
  376.         System.out.println("JDOM:" + xmlStr);   
  377.         return xmlStr;   
  378.     }   
  379.   
  380.     /**  
  381.      * DOM4J生成XML  
  382.      *   
  383.      * @param list  
  384.      * @return  
  385.      */  
  386.     public String dom4jToXml(List<City> list) {   
  387.         String strXml = null;   
  388.         try {   
  389.             if (null != list && !list.isEmpty()) {   
  390.                 DocumentFactory df = DocumentFactory.getInstance();   
  391.                 // org.dom4j.Document doc = DocumentHelper.createDocument   
  392.   
  393. ();   
  394.                 org.dom4j.Document doc = df.createDocument("UTF-8");   
  395.                 // 创建根节点   
  396.                 org.dom4j.Element citiesElt = doc.addElement("cities");   
  397.        
  398.                 for (City po : list) {   
  399.             // 在节点<cities>下增加子节点<city>   
  400.                     org.dom4j.Element cityElt = citiesElt.addElement   
  401.   
  402. ("city");   
  403.        
  404.             // 在节点<city>下增加子节点<id>   
  405.                     org.dom4j.Element idElt = cityElt.addElement   
  406.   
  407. ("id");   
  408.                     idElt.addText(String.valueOf(po.getId()));   
  409.        
  410.             // 在节点<city>下增加子节点<name>   
  411.                     org.dom4j.Element nameElt = cityElt.addElement   
  412.   
  413. ("name");   
  414.                     nameElt.addText(po.getName());   
  415.                 }   
  416.        
  417.                 // 有样式(缩进)的写出   
  418.                 OutputFormat opf = OutputFormat.createPrettyPrint();   
  419.                 opf.setEncoding("UTF-8");   
  420.                 opf.setTrimText(true);   
  421.                    
  422.                 //生成XML文件   
  423.                 XMLWriter xmlOut = new XMLWriter(new FileOutputStream   
  424.   
  425. ("city-dom4j.xml"), opf);   
  426.                 xmlOut.write(doc);   
  427.                 xmlOut.flush();   
  428.                 xmlOut.close();   
  429.                    
  430.                 //获取XML字符串形式   
  431.                 StringWriter writerStr = new StringWriter();   
  432.                 XMLWriter xmlw = new XMLWriter(writerStr, opf);   
  433.                 xmlw.write(doc);   
  434.                 strXml = writerStr.getBuffer().toString();   
  435.                    
  436.                 // 无样式的   
  437.     //          strXml = doc.asXML();   
  438.             }   
  439.         } catch (IOException e) {   
  440.             e.printStackTrace();   
  441.         }   
  442.         System.out.println("DOM4J:" + strXml);   
  443.         return strXml;   
  444.     }   
  445.   
  446.     public static void main(String[] args) throws Exception {   
  447.         List<City> list = City.getCityList(101L);   
  448.         CreateXMLText xml = new CreateXMLText();   
  449.         xml.domToXml(list);   
  450.         xml.saxToXml(list);   
  451.         xml.stAXToXml(list);   
  452.         xml.dom4jToXml(list);   
  453.         xml.jdomToXml(list);   
  454.     }   
  455.   
  456. }  
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 [email protected]
 *
 */
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);
	}

}


依赖的JAVABEAN对象City.java
Java代码 复制代码
  1. import java.util.ArrayList;   
  2. import java.util.List;   
  3.   
  4. public class City {   
  5.   
  6.     // 主键   
  7.     private Long id;   
  8.   
  9.     // parentId为0代表是省份,否则为城市   
  10.     private Long parentId;   
  11.   
  12.     // 名字   
  13.     private String name;   
  14.   
  15.     // City对象列表   
  16.     private List<City> citys;   
  17.   
  18.     /**  
  19.      * 默认构造器  
  20.      */  
  21.     public City() {   
  22.   
  23.     }   
  24.   
  25.     /**  
  26.      * @param id  
  27.      * @param parentId  
  28.      * @param name  
  29.      */  
  30.     public City(Long id, Long parentId, String name) {   
  31.         super();   
  32.         this.id = id;   
  33.         this.parentId = parentId;   
  34.         this.name = name;   
  35.     }   
  36.   
  37.     /**  
  38.      * @return the 
分享到:
评论

你可能感兴趣的:(xml,Blog,sun)