解析XML

第一种方法 

对象模型 API 定义了层次化对象模型来表示 XML 文档。换句话说，对应 XML 语法中的每个概念定义相应的类：元素、属性、实体、文档。解析器读入 XML 文档的时候，建立 XML 语法和类之间的一对一映射。比如，每遇到一个标记，就实例化一个元素类。 

毫不奇怪，对哪种数据模型最好存在一些争议。W3C 规范化了 DOM，它的主要优点是可移植性：它是作为一种 CORBA 接口定义的，被映射到很多语言。因此如果了解了 JavaScript 中的 DOM，也就知道了 Java、C++、Perl、Python 和其他语言中的 DOM。 

另一种数据模型是 JDOM，一种针对 Java 优化的 DOM（专用于 Java），和 Java 语言结合得更紧密，但是按照定义缺乏可移植性。 

尽管人们可以继续商讨对 XML 语法来说哪种数据模型最好，但我认为没有多少意义，因为各种基于对象的 API 其优点和不足基本上是一样的。从好的方面来说，如果熟悉 XML 语法的话，对象模型 API 更容易理解。因为它直接从 XML 语法映射到类，很容易学习、使用和调试。 

简单的代价是效率，至少对很多项目而言是这样。读入文档的时候，解析器根据语法结构创建对象。对很多应用程序来说，XML 语法并不是很合适： 

* XML 语法非常罗嗦，即使文档很小，解析器也要创建很多对象。 
* 对 XML 词汇表进行的优化通常针对的是存储和数据传输效率，而不是处理，因而应用程序可能需要对数据进行预处理，比方说，在开始真正的处理之前，先计算部分和或者合并其他来源的数据。很多情况下，在处理之前必须将数据从 XML 对象模型复制到应用程序专用的对象模型或者数据库。 
* 因为这种对象模型是通用的，包含很多应用程序并不需要的对象之间的引用（比如，从子元素到父元素的反向引用）。这些引用进一步增加了内存消耗。 

在桌面上处理小型文档这可能不是大问题，但是在其他环境中，比如服务器上，对象模型固有的低效率是不可接受的。 

第二种方法 

第二种选择是事件 API，比如 SAX。这个概念是上述对象模型方式的一种反映。只不过这种方法不根据 XML 语法定义通用的数据模型，其解析器依赖应用程序程序员建立定制的数据模型。 

因此解析器可以做得更小，因为只需要传递最少量的信息。更重要的是，和一个型号打天下的对象模型（不管对象模型多么好）相比总的效率更高，程序员可以根据应用程序的需要定制对象模型。 

它的优点很明显： 

* 统计应用程序或总结信息的任何应用程序都可以从中获益，因为它们的数据模型只需计算总计而无需复制整个文档。 
* 类似的，即使动态处理文档的应用程序（比如把文档加载到数据库中）不需处理或者只需少量处理，也可从中受益，因为根本不需要存储数据。 

由于减少了内存需求，事件 API 可以处理任意大小的文档，包括大小超过可用内存的文档。基于同样的原因，这类 API 也非常适合多个进程并发执行和共享内存的服务器。 

效率的代价是简单性的损失。事件 API 一向以难用著称，因为应用程序员要负责更多的操作。虽然短期看来如此，但根据我的经验，从中期和长期来看，效率上的改进足以抵消略微增加的复杂度。 

流式 API 有两种形式：推式和拉式。从历史上看，推式方法更加流行，因为这正是 SAX 采用的模型。推式方法正在实现标准化，很快将作为 StAX 集成到 Java 平台中。 

两者有什么区别呢？区别在于由谁控制读循环。和读取文件的任何软件一样，解析器也是围绕着读循环（读入文件的循环）创建的。 

在推 模式（SAX）下，解析器控制循环。实际上应用程序调用解析器的时候，在文件结束之前控制权不会返回给应用程序。前面已经提到，解析器回调应用程序以建立数据模型，解析器处于控制地位。 

在拉 模式下，应用程序控制循环。循环中应用程序负责反复调用解析器，直到文件结束。 

推模式最适合边读入边处理 XML 文档，比如读入 RSS 提要并显示为 HTML 网页。对于使用 XML 存储数据的多数应用程序来说，“读文档”用对解析器的一次调用实现最方便。 

拉模式更适合于处理不同 XML 词汇表的文档。这类应用程序通常需要嗅探输入（读入前几行）以根据词汇表决定调用子例程。 

对于控制解析器的应用程序而言，一次循环是必要的，因为应用程序很容易在嗅探前面几行之后停止读入。 

第三种方法 

如果不提到另一种选择，即 XML 编组库形式的解析，如 Castor，本文就不完整。该方法介于对象模型和事件方法之间。 

其思想是从 XML Schema 生成一个对象模型而不是通用模型（如 DOM），解析器生成更加针对所用词汇表的数据模型。比方说，如果词汇表处理的是发货单，那么可以预料其中会包含发送方、接收方、日期、产品类别、产品标识、单价和总价。DOM 将这些元素映射到一个一般性的元素类。编组库 为发送方、接收方、日期、产品类别、产品标识、单价、总价和文档中出现的其他元素创建专门的类。 

从处理的是根据词汇表定制（与根据应用程序的需要定制可能相同，也可能不同）的而不是通用数据模型这方面来讲，编组库具备事件 API 的一些优点。

----------------------------------------------------------------------------------------------------

目前常用的XML的解析器主要有:SAX,DOM,Xerces

1、SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX 还比它的替代者 DOM 快许多。另一方面，由于应用程序没有以任何方式存储数据，使用 SAX 来更改数据或在数据流中往后移是不可能的。

2、DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单得多。另一方面，在内存中构造这样的树涉及大量的开销。大型文件完全占用系统内存容量的情况并不鲜见。此外，创建一棵 DOM 树可能是一个缓慢的过程。

3、选择 DOM 还是选择 SAX，这取决于下面几个因素:
应用程序的目的：如果打算对数据作出更改并将它输出为 XML，那么在大多数情况下，DOM 是适当的选择。并不是说使用 SAX 就不能更改数据，但是该过程要复杂得多，因为您必须对数据的一份拷贝而不是对数据本身作出更改。
数据容量： 对于大型文件，SAX 是更好的选择。数据将如何使用：如果只有数据中的少量部分会被使用，那么使用 SAX 来将该部分数据提取到应用程序中可能更好。 另一方面，如果您知道自己以后会回头引用已处理过的大量信息，那么 SAX 也许不是恰当的选择。
对速度的需要：SAX 实现通常要比 DOM 实现更快。
SAX 和 DOM 不是相互排斥的，记住这点很重要。您可以使用 DOM 来创建 SAX 事件流，也可以使用 SAX 来创建 DOM 树。事实上，用于创建 DOM 树的大多数解析器实际上都使用 SAX 来完成这个任务！

4、SAX,DOM是两种对XML文档进行分析的方法（没有具体的实现，只有接口），所以不是解释器，如果光有他们，你是完成不了对xml文档的处理的。SAX的包是org.xml.sax，DOM的包是org.w3c.dom，包的名称很重要，它有助于你理解他们之间的关系。

5、jaxp是api，他封装了sax/dom两种接口。并在sax/dom的基础之上，作了一套比较简单的api以供开发人员使用。jaxp的包是javax.xml.parsers，可以看看jaxp的源文件，它的文件中包含了对sax或者dom的引用（import）jaxp也不是具体的实现，他只是一套api。如果你仅仅有jaxp那是无法工作的，（其实jaxp只是完成对sax、dom的包装，生成了DocumentBuilderFactory/DocumentBuilder和SAXParserFactory SAXParser。也就是设计模式中的工厂模式，他的好处就是具体的对象（ 解释器）建立由子类完成）

6、xerces解释器（号称地球上最快的xml解释器）在xerces中对jaxp中定义的SAXParser SAXParserFactory DocumentBuilder DocumentBuilderFactory进行了继承（extends）对应SAXParserImpl XParserFactoryImpl DocumentBuilderImpl DocumentBuilderFactoryImpl这就是为什么你的classpath中只要有xerces.jar（其中包含了sax dom jaxp ）和 xercesImpl.jar就可以的原因了.

----------------------------------------------------------------------------------------------------

[java]   view plain copy

1. //xml解析的几种方式
2. //相关搜索: xml, 解析
3. //1.dom解析：
4. package com.yzt.xml.lixin;
5. import javax.xml.parsers.*;
6. //import org.xml.sax.*;
7. import java.io.*;
8. import org.w3c.dom.*;
9. public class DomParserDemo {
10. static Document document;
11. public static void main(String[] args) {
12. //DOM解释器总类，用他创建DOM解释器
13. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
14. try {
15. //创建DOM解释器
16. DocumentBuilder builder = factory.newDocumentBuilder();
17. //取得xml文件
18. document = builder.parse(new File("F:/XmlProject/src/com/lixin/Test.xml"));
19. //取得结构树的根节点、
20. Element persons = document.getDocumentElement();
21. //取得标识为Persons的集合
22. NodeList personList = persons.getElementsByTagName("Person");
23. //声明属性数组
24. String [] personAttributes = {"id","name","genda","birthday","occupation","email"};
25. //循环访问没个person
26. for(int i=0;i<personList.getLength();++i){
27. //取得数据
28. //把里面的方法写上注释；用自己的理解写*********
29. Element onePerson = (Element) personList.item(i);
30. for(int j=0;j<personAttributes.length;j++){
31. NodeList data = onePerson.getElementsByTagName(personAttributes[j]);
32. Node oneData = data.item(0).getFirstChild();
33. String nodeValue = oneData.getNodeValue();
34. //显示person数据
35. // System.out.println(nodeValue);
36. System.out.println(" "+personAttributes[j]+ "=" +nodeValue);
37. }
38. //在新的一行显示下一个数据
39. System.out.println("");
40. }
41. } catch (Exception ex) {
42. ex.printStackTrace();
43. }
44. }
45. }
46. //2.sax解析：
47. package com.yzt.xml.lixin;
48. import java.io.*;
49. import org.xml.sax.*;
50. import org.xml.sax.helpers.DefaultHandler;
51. import javax.xml.parsers.*;
52. class SaxContentHandler extends DefaultHandler{
53. static private Writer out; //声明文件写出器
54. private String indentString = " ";//显示不同层次的元素空格
55. private int indentLevel = 0; //标识元素的层次
56. //创建SAX解释器，并激活ContentHanddler事件的处理机制
57. public static void main(String[] args) {
58. //创建ContentHandler事件接口
59. DefaultHandler handler = new SaxContentHandler();
60. //SAX解释器总类，用来创建SAX解释器
61. SAXParserFactory factory = SAXParserFactory.newInstance();
62. try {
63. //将System.out写出器，使用GBK的编码方式，赋给变量out
64. out = new OutputStreamWriter(System.out,"GB2312");
65. //创建SAX解释器
66. SAXParser saxParser = factory.newSAXParser();
67. //取得xml文件，将激活ContentHandler事件
68. //saxParser.parse(new File("Test.xml"),handler); F:/XmlProject/src/com/lixin
69. saxParser.parse(new File("D:/workspace/review/WebRoot/Test.xml"),handler);
70. } catch (Exception ex) {
71. ex.printStackTrace();
72. }
73. System.exit(0);//清空程序占用的内存，推出程序 ; 终止当前正在运行的 Java 虚拟机。
74. }
75. //XML文档节点开始事件
76. /**startElement(String namepaceURI,String IName,String qName,Attributes attrs)接收元素开始的通知。
77. *
78. * IName 包含前缀名的元素名字
79. * qName 不包含前缀名的元素名字
80. * attrs 元素的属性名字
81. * */
82. public void startElement(String namepaceURI,String IName,String qName,Attributes attrs){
83. try {
84. indentLevel++;
85. newLine();
86. String eName = IName; //取得元素的名称
87. if("".equals(eName)){
88. eName = qName;
89. printOut("<"+eName+">");
90. }
91. } catch (Exception ex) {
92. ex.printStackTrace();
93. }
94. }
95. //读入元素之间数据的方法 ;;;接收元素中字符数据的通知。
96. public void characters(char buf[],int offset,int len){
97. try {
98. /**
99. * String(char[] value, int offset, int count)
100. * 分配一个新的 String，它包含来自该字符数组参数的一个子数组的字符。
101. * */
102. String s = new String(buf,offset,len);
103. if(!s.trim().equals("")){
104. printOut(" "+s+" ");
105. }
106. } catch (Exception ex) {
107. ex.printStackTrace();
108. }
109. }
110. //xml文档节点的结束事件
111. public void endElement(String namespaceURI,String sName,String qName){
112. try {
113. if(qName.equals("")|qName.equals("")){
114. newLine();
115. }
116. printOut("</"+qName+">");
117. indentLevel--;
118. } catch (Exception ex) {
119. ex.printStackTrace();
120. }
121. }
122. //显示xml文档内容的方法
123. private void printOut(String s){
124. try {
125. out.write(s);
126. out.flush();
127. } catch (Exception ex) {
128. ex.printStackTrace();
129. }
130. }
131. //显示新的一行的方法
132. public void newLine(){
133. //System.getProperty("line.separator");获得指定键指示的系统属性。 line 有各种控件
134. String lineEnd = System.getProperty("line.separator");
135. try {
136. out.write(lineEnd);
137. for(int i=0;i<indentLevel;i++){
138. out.write(indentString);
139. }
140. } catch (Exception ex) {
141. ex.printStackTrace();
142. }
143. }
144. }
145. ============================================
146. package com.yzt.xml.lixin;
147. import java.io.IOException;
148. import javax.xml.parsers.*;
149. import org.xml.sax.SAXException;
150. import org.xml.sax.helpers.DefaultHandler;
151. public class SaxParser1 extends DefaultHandler {
152. public static void main(String[] args) {
153. String uri ="D:/workspace/review/WebRoot/Test.xml";
154. try {
155. SAXParserFactory parserFactory = SAXParserFactory.newInstance();
156. parserFactory.setValidating(false);
157. parserFactory.setNamespaceAware(false);
158. SaxParser1 SaxParser1Instance = new SaxParser1();
159. SAXParser parser = parserFactory.newSAXParser();
160. parser.parse(uri, SaxParser1Instance);
161. } catch (IOException exception) {
162. exception.printStackTrace();
163. } catch (SAXException exception) {
164. exception.printStackTrace();
165. } catch (ParserConfigurationException exception) {
166. exception.printStackTrace();
167. } catch (FactoryConfigurationError exception) {
168. exception.printStackTrace();
169. }
170. }
171. /**
172. * @接收元素中字符数据的通知。
173. */
174. public void characters(char[] ch, int start, int length) throws
175. SAXException {
176. String s = new String(ch,start,length);
177. System.out.print(""+s+"");
178. }
179. }
181. //3.dom4j生成xml和修改（修改还有点问题没能实现）：
182. package com.yzt.xml;
183. import java.io.*;
184. import java.util.List;
185. import java.util.Iterator;
186. import org.dom4j.*;
187. import org.dom4j.io.OutputFormat;
188. import org.dom4j.io.SAXReader;
189. import org.dom4j.io.XMLWriter;
190. public class dom4j {
191. /*dom4j 是一种解析 XML 文档的开放源代码 XML 框架。
192. *与 W3C DOM API 相比，使用 dom4j 所包含的解析器的好处是 dom4j 拥有本地的 XPath 支持。
193. *DOM 解析器不支持使用 XPath 选择节点。
194. **/
196. public dom4j(){
197. }
198. //创建自己的xml
199. public int createXMLFile(String filename){
200. int returnValue=0;
201. Document document=DocumentHelper.createDocument();
202. Element booksElement=document.addElement("books");
203. booksElement.addComment("作者：yzt2008812");
204. Element bookElement=booksElement.addElement("book");
206. bookElement.addAttribute("show", "YES");
207. Element titleElement=bookElement.addElement("title");
208. titleElement.setText("Dom4j实例应用");
210. bookElement=booksElement.addElement("book");
211. bookElement.addAttribute("show", "yes");
212. titleElement.setText("Lucene学习指南");
214. bookElement=booksElement.addElement("book");
215. bookElement.addAttribute("show", "no");
216. titleElement=bookElement.addElement("title");
217. titleElement.setText("spring全攻略");
219. Element ownerElement=booksElement.addElement("owner");
220. ownerElement.setText("我的测试xml");
221. try{
222. XMLWriter writer=new XMLWriter(new FileWriter(new File(filename)));
223. writer.write(document);
224. writer.close();
225. returnValue=1;
226. }catch(Exception ex){
227. ex.printStackTrace();
228. }
231. return returnValue;
232. }
233. //格式化xml文档，并解决中文问题
234. public int formatXMLFile(String filename){
235. int returnValue=0;
236. try{
237. SAXReader saxReader =new SAXReader();
238. Document document=saxReader.read(new File(filename));
239. XMLWriter output=null;
240. OutputFormat format=OutputFormat.createPrettyPrint();
241. format.setEncoding("GBK");
242. output.write(document);;
243. output.close();
244. returnValue=1;
245. }catch(Exception ex){
246. ex.printStackTrace();
247. }
248. return returnValue;
249. }
250. //修改并另存为xml
251. public int change_XMLFile(String filename,String newfilename){
252. int returnValue=0;
253. try{
254. SAXReader saxReader=new SAXReader();
255. Document document=saxReader.read(new File(filename));
256. /* 修改内容之一: 如果book节点中show参数的内容为yes,则修改成no
257. *
258. * 先用xpath查找对象
259. *
260. * 注意：selectNodes()参数的格式：
261. * 节点名[@属性名='属性值']，如：book[@url='dom4j.com']
262. * 如果有多个节点，用“/”分开，如：book[@url='dom4j.com']/title[@id='123']
263. **/
264. List list=document.selectNodes("books/book/@show");
265. Iterator iter=list.iterator();
266. while(iter.hasNext()){
267. Attribute attribute=(Attribute)iter.next();
268. if(attribute.getValue().equals("YES")){
269. attribute.setValue("Noooooo");
270. }
271. }
273. }catch(Exception ex){
274. ex.printStackTrace();
275. }
276. return returnValue;
277. }
278. //main方法执行操作
279. public static void main(String []args){
280. dom4j temp=new dom4j();
281. System.out.println(temp.createXMLFile("c:/catalog/yzt.xml"));
282. System.out.println(temp.change_XMLFile("c:/catalog/yzt.xml","c:/catalog/yzt22.xml"));
283. }
284. }
286. /jdom解析修改xml（修改部分还是有点问题！）：
287. package com.yzt.xml;
288. import java.io.IOException;
289. import org.jdom.Document;
290. import org.jdom.Element;
291. import org.jdom.input.SAXBuilder;
292. import org.jdom.output.Format;
293. import org.jdom.output.XMLOutputter;
295. import java.io.*;
296. import java.io.FileWriter;
297. import org.jdom.input.*;
298. import org.jdom.output.*;
299. import java.util.List;
300. import org.jdom.*;
301. public class jdom {
302. private Element customer,name,age,sex,address,street,city,district;
303. //构造方法生成xml
304. public jdom(){
305. customer=new Element("customer");
306. Document document =new Document(customer);
308. name=new Element("name");
309. age=new Element("age");
310. sex=new Element("sex");
311. address=new Element("address");
312. street=new Element("street");
313. city=new Element("city");
314. district=new Element("district");
316. name.addContent("张三");
317. age.addContent("25");
318. sex.addContent("湖北");
319. city.addContent("北京");
320. street.addContent("上地三街");
321. district.addContent("海淀区");
323. address.addContent(street);
324. address.addContent(city);
325. address.addContent(district);
327. customer.addContent(name);
328. customer.addContent(age);
329. customer.addContent(sex);
330. customer.addContent(address);
332. XMLOutputter fmt=new XMLOutputter();
333. try{
334. FileWriter writer=new FileWriter("c:/catalog/customer.xml");
335. Format f=Format.getPrettyFormat();
336. f.setEncoding("GB2312");
337. fmt.output(document, writer);
338. }catch(IOException e){
339. e.printStackTrace();
340. }
341. jdom_change_xml();
342. }
343. //修改xml
344. public int jdom_change_xml(){
345. int returnValue=0;
346. System.out.println(returnValue+"*********");
347. try{
348. SAXBuilder sab=new SAXBuilder();
349. Document doc=sab.build(new FileInputStream("c:/catalog/sampleA.xml"));
350. Element root=doc.getRootElement();
351. List books=root.getChildren();
352. Element book=(Element)books.get(0);
353. Attribute newattribute=new Attribute("QQQQ","WWWW");
354. book.setAttribute(newattribute);
355. Element author=(Element)book.getChild("author");
356. author.setText("yztxlty");
357. System.out.println(author.getText().toString()+"7777");
358. Element price =book.getChild("price");
359. price.setText(Float.toString(1000000));
360. String indent =" ";
361. boolean newLines=true;
362. XMLOutputter outp=new XMLOutputter();
363. outp.output(doc, new FileOutputStream("c:/catalog/exampleB_yzt.xml"));
364. System.out.print(returnValue+"+++++++++++");
365. return returnValue=1;
366. }catch(Exception ex){
367. ex.printStackTrace();
368. //System.out.print(returnValue+"999999999");
369. }
370. System.out.print(returnValue+"^^^^^^^^^^");
371. return returnValue;
372. }
376. public static void main(String []args){
377. new jdom();
378. //System.out.print(new jdom_change_xml());
379. }
380. }
381. //用到的xml文件 请参考 附件或者文档
382. //from： http://javalive.5d6d.com/frame.php?frameon=yes&referer=http://javalive.5d6d.com/thread-257-1-1.html

[java]   view plain copy

1. //xml解析的几种方式  
2. //相关搜索: xml, 解析  
3. //1.dom解析：  
4. package com.yzt.xml.lixin;  
5. import javax.xml.parsers.*;  
6. //import org.xml.sax.*;  
7. import java.io.*;  
8. import org.w3c.dom.*;  
9. public class DomParserDemo {  
10.      static Document document;  
11.     public static void main(String[] args) {  
12.         //DOM解释器总类，用他创建DOM解释器  
13.         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
14.         try {  
15.             //创建DOM解释器  
16.             DocumentBuilder builder = factory.newDocumentBuilder();  
17.             //取得xml文件  
18.             document = builder.parse(new File("F:/XmlProject/src/com/lixin/Test.xml"));  
19.             //取得结构树的根节点、  
20.             Element persons = document.getDocumentElement();  
21.             //取得标识为Persons的集合  
22.             NodeList personList = persons.getElementsByTagName("Person");  
23.             //声明属性数组  
24.             String [] personAttributes = {"id","name","genda","birthday","occupation","email"};  
25.             //循环访问没个person  
26.             for(int i=0;i<personList.getLength();++i){  
27.                 //取得数据  
28.                 //把里面的方法写上注释；用自己的理解写*********  
29.                 Element onePerson = (Element) personList.item(i);  
30.                 for(int j=0;j<personAttributes.length;j++){  
31.                     NodeList data = onePerson.getElementsByTagName(personAttributes[j]);  
32.                     Node oneData = data.item(0).getFirstChild();  
33.                     String nodeValue = oneData.getNodeValue();  
34.                     //显示person数据  
35.                  //   System.out.println(nodeValue);  
36.                 System.out.println(" "+personAttributes[j]+ "=" +nodeValue);  
37.                 }  
38.                //在新的一行显示下一个数据  
39.                System.out.println("");  
40.             }  
41.         } catch (Exception ex) {  
42.             ex.printStackTrace();  
43.         }  
44.     }  
45. }  
46. //2.sax解析：  
47. package com.yzt.xml.lixin;  
48. import java.io.*;  
49. import org.xml.sax.*;  
50. import org.xml.sax.helpers.DefaultHandler;  
51. import javax.xml.parsers.*;  
52. class SaxContentHandler extends DefaultHandler{  
53.     static private Writer out; //声明文件写出器  
54.     private String indentString = " ";//显示不同层次的元素空格  
55.     private int indentLevel = 0; //标识元素的层次  
56.     //创建SAX解释器，并激活ContentHanddler事件的处理机制  
57.     public static void main(String[] args) {  
58.        //创建ContentHandler事件接口  
59.        DefaultHandler handler = new SaxContentHandler();  
60.        //SAX解释器总类，用来创建SAX解释器  
61.        SAXParserFactory factory = SAXParserFactory.newInstance();  
62.        try {  
63.            //将System.out写出器，使用GBK的编码方式，赋给变量out  
64.            out = new OutputStreamWriter(System.out,"GB2312");  
65.            //创建SAX解释器  
66.            SAXParser saxParser = factory.newSAXParser();  
67.            //取得xml文件，将激活ContentHandler事件  
68.            //saxParser.parse(new File("Test.xml"),handler);  F:/XmlProject/src/com/lixin  
69.            saxParser.parse(new File("D:/workspace/review/WebRoot/Test.xml"),handler);  
70.        } catch (Exception ex) {  
71.            ex.printStackTrace();  
72.        }  
73.        System.exit(0);//清空程序占用的内存，推出程序   ; 终止当前正在运行的 Java 虚拟机。  
74.     }  
75.     //XML文档节点开始事件  
76.     /**startElement(String namepaceURI,String IName,String qName,Attributes attrs)接收元素开始的通知。 
77.      * 
78.      * IName 包含前缀名的元素名字 
79.      * qName 不包含前缀名的元素名字 
80.      * attrs 元素的属性名字 
81.      * */  
82.     public void startElement(String namepaceURI,String IName,String qName,Attributes attrs){  
83.         try {  
84.               indentLevel++;  
85.               newLine();  
86.               String eName = IName; //取得元素的名称  
87.               if("".equals(eName)){  
88.                   eName = qName;  
89.                   printOut("<"+eName+">");  
90.               }  
91.         } catch (Exception ex) {  
92.             ex.printStackTrace();  
93.         }  
94.     }  
95.     //读入元素之间数据的方法    ;;;接收元素中字符数据的通知。  
96.     public void characters(char buf[],int offset,int len){  
97.         try {  
98.       /** 
99.        * String(char[] value, int offset, int count) 
100.        * 分配一个新的 String，它包含来自该字符数组参数的一个子数组的字符。 
101.        * */  
102.              String s = new String(buf,offset,len);  
103.              if(!s.trim().equals("")){  
104.                  printOut(" "+s+" ");  
105.              }  
106.         } catch (Exception ex) {  
107.             ex.printStackTrace();  
108.         }  
109.     }  
110.     //xml文档节点的结束事件  
111.     public void endElement(String namespaceURI,String sName,String qName){  
112.           try {  
113.               if(qName.equals("")|qName.equals("")){  
114.                   newLine();  
115.               }  
116.               printOut("</"+qName+">");  
117.               indentLevel--;  
118.           } catch (Exception ex) {  
119.               ex.printStackTrace();  
120.           }  
121.     }  
122.     //显示xml文档内容的方法  
123.      private void printOut(String s){  
124.          try {  
125.              out.write(s);  
126.              out.flush();  
127.          } catch (Exception ex) {  
128.              ex.printStackTrace();  
129.          }  
130.      }  
131.     //显示新的一行的方法  
132.     public void newLine(){  
133.           //System.getProperty("line.separator");获得指定键指示的系统属性。  line 有各种控件  
134.           String lineEnd = System.getProperty("line.separator");  
135.        try {  
136.            out.write(lineEnd);  
137.            for(int i=0;i<indentLevel;i++){  
138.                out.write(indentString);  
139.            }  
140.        } catch (Exception ex) {  
141.            ex.printStackTrace();  
142.        }  
143.     }  
144. }  
145. ============================================  
146. package com.yzt.xml.lixin;  
147. import java.io.IOException;  
148. import javax.xml.parsers.*;  
149. import org.xml.sax.SAXException;  
150. import org.xml.sax.helpers.DefaultHandler;  
151. public class SaxParser1 extends DefaultHandler {  
152.     public static void main(String[] args) {  
153.       String uri ="D:/workspace/review/WebRoot/Test.xml";  
154.         try {  
155.             SAXParserFactory parserFactory = SAXParserFactory.newInstance();  
156.             parserFactory.setValidating(false);  
157.             parserFactory.setNamespaceAware(false);  
158.             SaxParser1 SaxParser1Instance = new SaxParser1();  
159.             SAXParser parser = parserFactory.newSAXParser();  
160.             parser.parse(uri, SaxParser1Instance);  
161.         } catch (IOException exception) {  
162.             exception.printStackTrace();  
163.         } catch (SAXException exception) {  
164.             exception.printStackTrace();  
165.         } catch (ParserConfigurationException exception) {  
166.             exception.printStackTrace();  
167.         } catch (FactoryConfigurationError exception) {  
168.             exception.printStackTrace();  
169.         }  
170.     }  
171.     /** 
172.      * @接收元素中字符数据的通知。 
173.      */  
174.     public void characters(char[] ch, int start, int length) throws  
175.             SAXException {  
176.         String s = new String(ch,start,length);  
177.         System.out.print(""+s+"");  
178.     }  
179. }  
180.   
181. //3.dom4j生成xml和修改（修改还有点问题没能实现）：  
182. package com.yzt.xml;  
183. import java.io.*;  
184. import java.util.List;  
185. import java.util.Iterator;  
186. import org.dom4j.*;  
187. import org.dom4j.io.OutputFormat;  
188. import org.dom4j.io.SAXReader;  
189. import org.dom4j.io.XMLWriter;  
190. public class dom4j {  
191.     /*dom4j 是一种解析 XML 文档的开放源代码 XML 框架。     
192.     *与 W3C DOM API 相比，使用 dom4j 所包含的解析器的好处是 dom4j 拥有本地的 XPath 支持。 
193.     *DOM 解析器不支持使用 XPath 选择节点。 
194.     **/  
195.           
196.     public dom4j(){  
197.     }  
198.     //创建自己的xml  
199.     public int createXMLFile(String filename){  
200.         int returnValue=0;  
201.         Document document=DocumentHelper.createDocument();  
202.         Element booksElement=document.addElement("books");  
203.         booksElement.addComment("作者：yzt2008812");  
204.         Element bookElement=booksElement.addElement("book");  
205.           
206.         bookElement.addAttribute("show", "YES");  
207.         Element titleElement=bookElement.addElement("title");  
208.         titleElement.setText("Dom4j实例应用");  
209.           
210.         bookElement=booksElement.addElement("book");  
211.         bookElement.addAttribute("show", "yes");  
212.         titleElement.setText("Lucene学习指南");  
213.           
214.         bookElement=booksElement.addElement("book");  
215.         bookElement.addAttribute("show", "no");  
216.         titleElement=bookElement.addElement("title");  
217.         titleElement.setText("spring全攻略");  
218.           
219.         Element ownerElement=booksElement.addElement("owner");  
220.         ownerElement.setText("我的测试xml");  
221.         try{  
222.             XMLWriter writer=new XMLWriter(new FileWriter(new File(filename)));  
223.             writer.write(document);  
224.             writer.close();  
225.             returnValue=1;  
226.         }catch(Exception ex){  
227.             ex.printStackTrace();  
228.         }  
229.           
230.           
231.         return returnValue;  
232.     }  
233.     //格式化xml文档，并解决中文问题  
234.     public int formatXMLFile(String filename){  
235.         int returnValue=0;  
236.         try{  
237.             SAXReader saxReader =new SAXReader();  
238.             Document document=saxReader.read(new File(filename));  
239.             XMLWriter output=null;  
240.             OutputFormat format=OutputFormat.createPrettyPrint();  
241.             format.setEncoding("GBK");  
242.             output.write(document);;  
243.             output.close();  
244.             returnValue=1;  
245.         }catch(Exception ex){  
246.             ex.printStackTrace();  
247.         }  
248.         return returnValue;  
249.     }  
250.     //修改并另存为xml  
251.     public int change_XMLFile(String filename,String newfilename){  
252.         int returnValue=0;  
253.         try{  
254.             SAXReader saxReader=new SAXReader();  
255.             Document document=saxReader.read(new File(filename));  
256.              /* 修改内容之一: 如果book节点中show参数的内容为yes,则修改成no  
257.             * 
258.             *  先用xpath查找对象  
259.             *   
260.             *  注意：selectNodes()参数的格式： 
261.             *     节点名[@属性名='属性值']，如：book[@url='dom4j.com'] 
262.             *      如果有多个节点，用“/”分开，如：book[@url='dom4j.com']/title[@id='123'] 
263.             **/   
264.             List list=document.selectNodes("books/book/@show");  
265.             Iterator iter=list.iterator();  
266.             while(iter.hasNext()){  
267.                 Attribute attribute=(Attribute)iter.next();  
268.                 if(attribute.getValue().equals("YES")){  
269.                     attribute.setValue("Noooooo");  
270.                 }  
271.             }  
272.               
273.         }catch(Exception ex){  
274.             ex.printStackTrace();  
275.         }  
276.         return returnValue;  
277.     }   
278.     //main方法执行操作  
279.     public static void main(String []args){  
280.         dom4j temp=new dom4j();  
281.         System.out.println(temp.createXMLFile("c:/catalog/yzt.xml"));  
282.         System.out.println(temp.change_XMLFile("c:/catalog/yzt.xml","c:/catalog/yzt22.xml"));  
283.     }  
284. }  
285.   
286. /jdom解析修改xml（修改部分还是有点问题！）：  
287. package com.yzt.xml;  
288. import java.io.IOException;  
289. import org.jdom.Document;  
290. import org.jdom.Element;  
291. import org.jdom.input.SAXBuilder;  
292. import org.jdom.output.Format;  
293. import org.jdom.output.XMLOutputter;  
294.   
295. import java.io.*;  
296. import java.io.FileWriter;  
297. import org.jdom.input.*;  
298. import org.jdom.output.*;  
299. import java.util.List;  
300. import org.jdom.*;  
301. public class jdom {  
302.     private Element customer,name,age,sex,address,street,city,district;  
303.     //构造方法生成xml  
304.     public jdom(){  
305.         customer=new Element("customer");  
306.         Document document =new Document(customer);  
307.           
308.         name=new Element("name");  
309.         age=new Element("age");  
310.         sex=new Element("sex");  
311.         address=new Element("address");  
312.         street=new Element("street");  
313.         city=new Element("city");  
314.         district=new Element("district");  
315.           
316.         name.addContent("张三");  
317.         age.addContent("25");  
318.         sex.addContent("湖北");  
319.         city.addContent("北京");  
320.         street.addContent("上地三街");  
321.         district.addContent("海淀区");  
322.           
323.         address.addContent(street);  
324.         address.addContent(city);  
325.         address.addContent(district);  
326.           
327.         customer.addContent(name);  
328.         customer.addContent(age);  
329.         customer.addContent(sex);  
330.         customer.addContent(address);  
331.           
332.         XMLOutputter fmt=new XMLOutputter();  
333.         try{  
334.             FileWriter writer=new FileWriter("c:/catalog/customer.xml");  
335.             Format f=Format.getPrettyFormat();  
336.             f.setEncoding("GB2312");  
337.             fmt.output(document, writer);  
338.         }catch(IOException e){  
339.             e.printStackTrace();  
340.         }      
341.         jdom_change_xml();  
342.     }  
343.     //修改xml  
344.     public int jdom_change_xml(){  
345.         int returnValue=0;  
346.         System.out.println(returnValue+"*********");          
347.         try{  
348.             SAXBuilder sab=new SAXBuilder();  
349.             Document doc=sab.build(new FileInputStream("c:/catalog/sampleA.xml"));  
350.             Element root=doc.getRootElement();  
351.             List books=root.getChildren();  
352.             Element book=(Element)books.get(0);  
353.             Attribute newattribute=new Attribute("QQQQ","WWWW");  
354.             book.setAttribute(newattribute);  
355.             Element author=(Element)book.getChild("author");  
356.             author.setText("yztxlty");  
357.             System.out.println(author.getText().toString()+"7777");  
358.             Element price =book.getChild("price");  
359.             price.setText(Float.toString(1000000));  
360.             String indent ="   ";  
361.             boolean newLines=true;  
362.             XMLOutputter outp=new XMLOutputter();  
363.             outp.output(doc, new FileOutputStream("c:/catalog/exampleB_yzt.xml"));  
364.             System.out.print(returnValue+"+++++++++++");  
365.             return returnValue=1;  
366.         }catch(Exception ex){  
367.             ex.printStackTrace();  
368.             //System.out.print(returnValue+"999999999");  
369.         }  
370.         System.out.print(returnValue+"^^^^^^^^^^");  
371.         return returnValue;  
372.     }  
373.       
374.       
375.       
376.     public static void main(String []args){  
377.         new jdom();  
378.     //System.out.print(new jdom_change_xml());  
379.     }  
380. }  
381. //用到的xml文件 请参考 附件或者文档  
382. //from： http://javalive.5d6d.com/frame.php?frameon=yes&referer=http://javalive.5d6d.com/thread-257-1-1.html