创建和解析xml文件大致有三种方法：
sax方法
dom方法
pull方法
一般在java开发环境中用dom方法
1.接口
[java]
1. package cn.com.shine;
2.
3. public interface xmlInfo {
4. /**
5. * 建立XML文档
6. * @param fileName 文件全路径名称
7. */
8. public void createXml(String fileName);
9. /**
10. * 解析XML文档
11. * @param fileName 文件全路径名称
12. */
13. public void parserXml(String fileName);
14.
15. }
2.
[java]
1. package cn.com.shine;
2.
3. import java.io.FileNotFoundException;
4. import java.io.FileOutputStream;
5. import java.io.IOException;
6. import java.io.OutputStream;
7. import java.io.PrintWriter;
8. import java.util.List;
9.
10. import javax.xml.bind.Element;
11. import javax.xml.parsers.DocumentBuilder;
12. import javax.xml.parsers.DocumentBuilderFactory;
13. import javax.xml.parsers.ParserConfigurationException;
14. import javax.xml.transform.OutputKeys;
15. import javax.xml.transform.Transformer;
16. import javax.xml.transform.TransformerConfigurationException;
17. import javax.xml.transform.TransformerException;
18. import javax.xml.transform.TransformerFactory;
19. import javax.xml.transform.dom.DOMSource;
20. import javax.xml.transform.stream.StreamResult;
21.
22. import org.w3c.dom.Document;
23. import org.w3c.dom.Node;
24. import org.w3c.dom.NodeList;
25. import org.xml.sax.SAXException;
26.
27.
28.
29. public class Xml implements xmlInfo{
30.
31. private Document document;
32.
33. public void init() {
34. try {
35. DocumentBuilderFactory factory = DocumentBuilderFactory
36. .newInstance();
37. DocumentBuilder builder = factory.newDocumentBuilder();
38. this.document = builder.newDocument();
39. catch (ParserConfigurationException e) {
40. System.out.println(e.getMessage());
41. }
42. }
43.
44. @Override
45. public void createXml(String fileName) {
46. this.document.createElement("scores");
47. this.document.appendChild(root);
48. this.document.createElement("employee");
49. this.document.createElement("name");
50. this.document.createTextNode("wangchenyang"));
51. employee.appendChild(name);
52. this.document.createElement("sex");
53. this.document.createTextNode("m"));
54. employee.appendChild(sex);
55. this.document.createElement("age");
56. this.document.createTextNode("26"));
57. employee.appendChild(age);
58. root.appendChild(employee);
59. TransformerFactory tf = TransformerFactory.newInstance();
60. try {
61. Transformer transformer = tf.newTransformer();
62. new DOMSource(document);
63. "gb2312");
64. "yes");
65. new PrintWriter(new FileOutputStream(fileName));
66. new StreamResult(pw);
67. transformer.transform(source, result);
68. "生成XML文件成功!");
69. catch (TransformerConfigurationException e) {
70. System.out.println(e.getMessage());
71. catch (IllegalArgumentException e) {
72. System.out.println(e.getMessage());
73. catch (FileNotFoundException e) {
74. System.out.println(e.getMessage());
75. catch (TransformerException e) {
76. System.out.println(e.getMessage());
77. }
78. }
79.
80. public void parserXml(String fileName) {
81. try {
82. DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
83. DocumentBuilder db = dbf.newDocumentBuilder();
84. Document document = db.parse(fileName);
85.
86. NodeList employees = document.getChildNodes();
87. for (int i = 0; i < employees.getLength(); i++) {
88. Node employee = employees.item(i);
89. NodeList employeeInfo = employee.getChildNodes();
90. for (int j = 0; j < employeeInfo.getLength(); j++) {
91. Node node = employeeInfo.item(j);
92. NodeList employeeMeta = node.getChildNodes();
93. for (int k = 0; k < employeeMeta.getLength(); k++) {
94. System.out.println(employeeMeta.item(k).getNodeName()
95. ":" + employeeMeta.item(k).getTextContent());
96. }
97. }
98. }
99. "解析完毕");
100. catch (FileNotFoundException e) {
101. System.out.println(e.getMessage());
102. catch (ParserConfigurationException e) {
103. System.out.println(e.getMessage());
104. catch (SAXException e) {
105. System.out.println(e.getMessage());
106. catch (IOException e) {
107. System.out.println(e.getMessage());
108. }
109. }
110.
111.
112. }
3
[java]
1. package cn.com.shine;
2.
3. public class Mainone {
4.
5. /**
6. * @param args
7. */
8. public static void main(String[] args) {
9. // TODO Auto-generated method stub
10. new Xml();
11. "D:/grade.xml";
12. dd.init();
13. //创建xml
14. //读取xml
15.
16. }
17.
18. }
================
[java]
1. public class Java2XML {
2.
3. public void BuildXMLDoc() throws IOException, JDOMException {
4.
5. // 创建根节点 list;
6. new Element("list");
7.
8. // 根节点添加到文档中；
9. new Document(root);
10.
11. // 此处 for 循环可替换成 遍历 数据库表的结果集操作;
12. for (int i = 0; i < 5; i++) {
13.
14. // 创建节点 user;
15. new Element("user");
16.
17. // 给 user 节点添加属性 id;
18. "id", "" + i);
19.
20. // 给 user 节点添加子节点并赋值；
21. // new Element("name")中的 "name" 替换成表中相应字段，setText("xuehui")中 "xuehui 替换成表中记录值；
22. new Element("name").setText("xuehui"));
23. new Element("age").setText("28"));
24. new Element("sex").setText("Male"));
25.
26. // 给父节点list添加user子节点;
27. root.addContent(elements);
28.
29. }
30. new XMLOutputter();
31.
32. // 输出 user.xml 文件；
33. new FileOutputStream("user.xml"));
34. }
35.
36. public static void main(String[] args) {
37. try {
38. new Java2XML();
39. "生成 mxl 文件...");
40. j2x.BuildXMLDoc();
41. catch (Exception e) {
42. e.printStackTrace();
43. }
44. }
[java]
1. 生成的 user.xml 文件
2. <?xml version="1.0" encoding="UTF-8"?>
3. <list>
4. "0">
5. <name>xuehui</name>
6. 28</age>
7. <sex>Male</sex>
8. </user>
9. "1">
10. <name>xuehui</name>
11. 28</age>
12. <sex>Male</sex>
13. </user>
14. </list>
15. 生成XML时候处理缩进，对输出格式进行美化
16. 只需要将上面生成XML时候的带吗修改成如下代码：
17. Format format = Format.getPrettyFormat();
18. XMLOutputter XMLOut = new XMLOutputter(format);
19. XMLOut.output(Doc, new FileOutputStream("user.xml"));
20. 生成XML的时候，处理特殊字符
21. element.addContent(new CDATA("<xml> content"));
22. 生成XML的时候，设置编码
23. XMLOutputter XMLOut = new XMLOutputter();
24. XMLOut.setEncoding("gb2312");
25. XMLOut.output(Doc, new FileOutputStream("test1.xml"));
一般在android开发中用sax方法
[java]
1. package com.shine.victor;
2.
3. import java.io.OutputStream;
4. import java.util.List;
5.
6. import org.xmlpull.v1.XmlSerializer;
7.
8. import android.util.Xml;
9.
10. public class PullBuildXMLService {
11. public void buildXML(List<Person> persons,OutputStream outputStream)throws Exception{
12. XmlSerializer serializer = Xml.newSerializer();
13. "utf-8");
14. "utf-8", true);
15. null, "perisons");
16. for(Person person:persons){
17. null, "perison");
18. null, "id",String.valueOf(person.id));
19.
20. null, "name");
21. serializer.text(person.name);
22. null, "name");
23.
24. null, "age");
25. serializer.text(String.valueOf(person.age));
26. null, "age");
27.
28. null, "perison");
29. }
30. null, "perisons");
31. serializer.endDocument();
32. outputStream.close();
33. }
34. }
2
[java]
1. package com.shine.victor;
2.
3. import java.io.File;
4. import java.io.FileOutputStream;
5. import java.util.ArrayList;
6. import java.util.List;
7.
8. import android.os.Bundle;
9. import android.app.Activity;
10. import android.view.Menu;
11. import android.view.View;
12. import android.widget.Button;
13.
14. public class MainActivity extends Activity {
15.
16. @Override
17. protected void onCreate(Bundle savedInstanceState) {
18. super.onCreate(savedInstanceState);
19. setContentView(R.layout.activity_main);
20. this.findViewById(R.id.bt);
21. new View.OnClickListener() {
22.
23. @Override
24. public void onClick(View arg0) {
25. // TODO Auto-generated method stub
26. try {
27. writeFile();
28. catch (Throwable e) {
29. // TODO Auto-generated catch block
30. e.printStackTrace();
31. }
32. }
33. });
34. }
35.
36. @Override
37. public boolean onCreateOptionsMenu(Menu menu) {
38. // Inflate the menu; this adds items to the action bar if it is present.
39. getMenuInflater().inflate(R.menu.activity_main, menu);
40. return true;
41. }
42. public void writeFile() throws Throwable{
43. new ArrayList<Person>();
44. for(int i =0;i<10;i++){
45. new Person();
46. 1;
47. "ant";
48. 12;
49. list.add(person);
50. }
51. new File(MainActivity.this.getFilesDir(),"person.xml");
52. new FileOutputStream(file);
53. new PullBuildXMLService();
54. service.buildXML(list, outputStream);
55. }
56.
57. }==================================================================================
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
XML文件解析技术详解总结：
XML文件的解析技术。现在我们就总结一下在这方面的学习所得。
XML简介
XML的是eXtensible Market Language(即可扩展的标记语言)的缩写，它是标准通用标记语言(Standard Generalized Markup Language, SGML)的一个子集。
SGML功能非常的强大，它是可以定义标记语言的元语言。而由于它的复杂，不适合于应用。于是W3C组织在1996年开始设计一种可扩展的标记语言，从而将SGML的丰富功能与HTML的易用性结合在Web应用中，于是就有了XML。XML它是一种开放的、自我描述的方式定义了数据结构。在描述数据内容的同时能突出对结构的描述，从而体现出数据与数据之间的关系。
HTML。但与HTML相比，XML有下列优点：
XML将数据和显示分开
HTML文档将数据、页面的排版、以及页面的表现形式混合在一起，如果要增加新的数据，相应地就要调整数据排版与显示方式。这样不利于数据的交换以及数据的操作，例如插入数据和删除数据。随着电子商务等网络应用的普及，不同系统、不同平台的信息交换日益频繁，而HTML本身的不足，限制了它在Web开发中的应用。
XML只描述数据和数据的结构。从而将数据和显示分开，我们就可以为同一份数据设计不同的排版和显示风格，而数据本身不做任何的改变。
XML对文档的格式要求更加严格
HTML文档格式的松散，导致了HTML文档解析的复杂性，当然也造成了浏览器的兼容的问题。
XML文档对格式有非常严格的要求，凡是符合标准的文档就是格式良好的XML文档（Well-Formed XML Document）。
XML有且只能有一个根元素
这减少了在解析文档时的难度。
对XML文档的解析
XML文档时通常是利用XML解析器对文档进行分析，而应用程序就是通过解析器提供的API而得到XML数据。
XML解析器提供的API都不一样，那么应用程序只能使用一个特定的解析器。一旦更改解析器，就要重新更改代码，这是相当痛苦的。所以目前几乎所有的解析器都对两套标准的API提供了支持，它们就是DOM和SAX（标准的威力啊）。
DOM和SAX只是定义了一套标准的接口，以及一些默认的实现。而解析器的开发商在开发解析器的时候就要实现这些接口。用户只要根据这些接口就能访问XML文档，却不必去知道具体的实现（这就是面向对象编程思想中的：针对接口编程，而不是对类编程）。
Apache的Xerces是一个使用非常广泛的解析器。它都支持DOM和SAX，并提供了相应的接口。它更是提供了多种语言的实现版本。
....
org.xml.sax.XMLReader sp = new org.apache.xerce.parsers.SAXParser();
FileInputStream fis = new FileInputStream("some.xml");
InputSource is = new InputSource(fis);
sp.setContentHandler();
sp.parse(is);
....Xerces访问XML文档，只需在应用程序中构造一个解析器的实现类的对象。例如：SAX定义的解析器接口是org.xml.sax.XMLReader，Xerces中提供的实现类是org.apache.xerces.parsers.SAXParser。
org.apache.xerce.parsers.SAXParser( )这段代码。而JAXP API可以帮助我们在改动解析器时无需改动代码。JAXP提供了在解析器之上一个抽象层，并未提供任何解析XML的方法和实现。从而屏蔽了具体开发商的实现，允许开发人员以独立于厂商的API调用访问XML数据。
从JAXP 1.1开始，JAXP就成为了J2SE 和J2EE的一部分。JAXP开发包有javax.xml包及其子包、org.xml.sax包及其子包、org.w3c.dom及其子包组成。在javax.xml.parsers包中，定义了几个工厂类，用于加载DOM和SAX的实现类。只要符合JAXP规范的解析器实现其中的接口和抽象类，开发人员就可以在不改动代码的前提下，任意切换底层的实现类。
上面介绍了xml的相关解析技术，下面我们介绍解析器模型及案例
DOM
DOM是W3C组织以IDL（Interface Definition Language,接口定义语言）的形式定义了DOM中的接口。某种语言要实现DOM，需要将DOM接口转换为本语言中的适当结构。
DOM结构模型
DOM中的核心概念是节点，它把XML文档的各个部分（元素、属性、文本、注释和处理指令等）都抽象为节点。在内存中整个文档是一个树的结构存储的，整棵树是个节点，树中的每一个节点也是一个树。我们通过访问树中的节点来存取XML文档的内容。
DOM定义了一个Node接口，用于表示文档树中一个节点。从Node接口派生出了更多的具体接口，例如Document接口、Element接口、Attr接口。
DOM中表示XML文档中各组成部分的接口继承关系
Node对象，而是Document、Text、Element和Attr等Node对象的子对象来操作文档。当然在顶层的Node接口声明了对节点进行操作的方法。下面就列出了Node接口的主要方法：
public String getNodeName();
返回该节点的名字
public short getNodeType();
返回表示该节点类型的代码
public String getNodeValue() throws DOMException;
返回该节点的值
public void setNodeValue(String nodeValue) throws DOMException;
设置该节点的值
public boolean hasChildNodes();
判断该节点是否还有子节点
public NodeList getChildNodes();
以列表的形式返回该节点的所有子节点
………等等
DOM解析器工厂
javax.xml.parsers包中定义了DOM解析器工厂类DocumentBuildFactory，用于产生DOM解析器。DocumentBuildFactory是一个抽象类，在这个类中提供了一个静态的方法newInstance( )，用于创建工厂类的一个实例。
DocumentBuildFactory factory = DocumentBuildFactory.newInstance();
DoucmentBuild build = factory.newDocumentBuilder();
DocumentBuild类也是一个抽象类，调用DocumentBuildFactory的newInstance( )方法得到具体厂商的工厂类的实例后，再利用其newDocumentBuilder( )方法，得到具体厂商的DOM解析器对象。
DocumentBuilder类提供了parse()方法，用于解析XML文档的内容，返回一个表示整个文档的Document对象。Parse()方法的参数可以是File类、InputSource类、InputStream类或表示XML文件的URI。
DOM树中的节点类型
DOM本质上是节点的集合。由于一个文档中可能包含不同类型的信息。
节点类型 | DOM中的接口 | 说明 |
注释 | Comment | Comment接口继承自CharacterData接口，表示注释的内容 |
处理指令 | ProcessingInstruction | ProcessingInstruction接口表示XML文档中的处理指令部分 |
文档类型 | DocumentType | 每一个Document都有一个docType属性，其值是null或是DocumentType对象。DocumentType接口为DTD中声明的实体列表和记号(notation)提供了一个接口 |
文档片断 | DocuementFragment | 文档其实是“最小”的Document对象。DocumentFragment对象和Document对象的主要区别是，DocumentFragment可以不是格式良好的。可以通过移动文档的片断来重新排列文档。 |
CDATA | CDATASection | CDATASection接口继承自Text接口，表示XML文档的CDATA段 |
实体 | Entity | Entity接口表示一个在XML文档中已分析的或未分析的实体。 |
实体引用 | EntityReference | EntityReference节点可以用于表示DOM树中的一个实体引用。 |
记号 | Notation | Notation接口表示了在DTD中声明的记号 |
例子
package org.jackkp.dom;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
publicclass DOMTest {
publicstaticvoid main(String[] args){
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
try{
DocumentBuilder db = dbf.newDocumentBuilder();
File file = new File("student.xml");
Document doc = db.parse(file);
NodeList nl = doc.getElementsByTagName("student");
for(int i = 0; i < nl.getLength(); i++){
Element stu = (Element)nl.item(i);
Node name = stu.getElementsByTagName("name").item(0);
Node age = stu.getElementsByTagName("age").item(0);
System.out.print("姓名： ");
System.out.println(name.getFirstChild().getNodeValue());
System.out.print("年龄： ");
System.out.println(age.getFirstChild().getNodeValue());
System.out.println("****************************");
}
}catch(ParserConfigurationException e){
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}catch(SAXException e){
e.printStackTrace();
}
}
}下面是运行结果：
SAX
DOM解析XML文档是，需要读入整个XML文档，然后在内存中创建DOM树，生成DOM树上的每个节点对象。只有在整个DOM树创建完成后，才能进行其它的操作。当XML文档比较大时，构建DOM树将花费大量的时间和内存。
SAX允许你在读取文档的时候对它进行处理。
SAX处理机制
SAX是一种基于事件驱动的API。用SAX模型来解析XML文档时，要涉及到解析器和事件处理器。解析器负责读取XML文档，并向事件处理器发送请求；而事件处理器负责对事件作出响应，对传递的XML数据进行处理。
SAX在解析文档时，一般会依次产生下列事件：
文档开始
元素开始
字符数据（可能是XML文档中的空白部分）
元素开始
字符数据
元素结束
字符数据
元素结束
文档结束
callback method）。
解析器
XMLReader是SAX2.0解析器必须实现的接口，这个接口允许应用程序设置和查询解析器的功能和特性，可以注册用户自定义的事件处理器，以及文档的解析。XMLReader接口中的主要方法如下：
void setEntityResolver(EntityResolver resolver)：允许应用程序注册一个实体解析器。如果应用程序没有注册实体解析器，XMLReader将执行它自己的默认实体解析器。
EntityResolver getEntityResolver( )：返回当前的实体解析器。
void setContentHandler(ContentHandler handler)：允许应用程序注册一个内容事件处理器。如果应用程序没有注册内容事件处理器，那么SAX解析器报告的所有内容事件都将被忽略。
ContentHandler getHandler( )：返回当前的内容处理器。
void parse(InputSource input) throws IOException, SAXException
void parse(String systemId) throws IOException, SAXException
parse( )方法用于解析XML文档。应用程序可以使用这个方法来通知XMLReader开始解析从任何有效的输入源（URI、字节流或字符流）读取的XML文档。在解析过程中XMLReader通过注册的事件处理器来提供XML文档的信息。
事件解析器
XMLReader接口的解析器类，用户只需编写事件处理器程序即可。ContentHandler接口是一个主要的处理器接口。如果应用程序要获得基本的解析事件，它就要实现这个接口，并使用XMLReader对象的setContentHandler()方法向解析器注册一个ContentHandler实例。解析器使用这个实例来报告与文档相关的基本事件。ContentHandler( )的主要方法如下：
void setDocumentLocation(Locator locator)：接收一个获取文档分析时产生的SAX事件对象定位信息的对象。该方法将在解析器报告任何其它文档事件之前被调用。定位器对象允许应用程序测试任何与文档相关的事件的结束位置。
void startDocument( ) throws SAXException;
void endDocument( ) throws SAXException;
void startElement(String uri, String localName, String qName, Attributes atts) throws SAXException：XML文档的每一个元素开始时调用这个方法。startElement()方法的参数取决于SAX本身的http://xml.org/sax/features/namspaces和http://xml.org/sax/features/namespace-prefixs属性值
namespaces属性值是true时，名称空间(uri)和本地名(localName)是必需的。为false时，两者是可选的（默认是true）
namespace-prefixes属性值是true，那么限定名是必需的，否则是可选的（默认是false）。
void endElement(String uri, String localName, String qName) throws SAXException：解析器在XML文档的每一个元素结束时调用这个方法。
void processingInstruction(String arget, String data) throws SAXException：解析器每遇到一个处理指令就调用这个方法。
JAXP也为SAX解析器提供了工厂类——SAXParserFactory类。SAX解析器工厂类的实例与DOM解析器工厂类的实例类似，都是通过newInstance( )方法来创建的。JAXP中定义的SAX解析器类是SAXParser（相当于DOM中的DocumentBuilder类，获取方法也类似）。实际上SAXParser是JAXP对XMLReader实现类的一个包装类。在SAXParser中定义了返回XMLReader实例的方法getXMLReader( )。
public abstract XMLReader getXMLReader( );
XMLReader和SAXParser中都有parse( )方法，并且是等效的。但SAXParser中的parse( )方法使用范围更广，因为它能接受更多的参数，对不同的XML文档数据源进行解析。
public void parse(InputSource is, DefaultHandler dh) throws SAXException, IOException
public void parse(InputStream is, DefaultHandler dh, String systemId) throws SAXException, IOException
public void parse(String uri, DefaultHandler dh) throws SAXException, IOException
public void parse(File f, DefaultHandler dh) throws SAXException, IOException
public void parse(InputSource is, DefaultHandler dh) throws SAXExcepiton, IOException例子
package org.jackkp.sax;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
publicclass SAXParserTestextends DefaultHandler{
publicvoid startDocument()throws SAXException{
System.out.println("This is the starting of the document");
System.out.println("<?xml version='1.0' encoding='GB2312'?>");
}
publicvoid processingInstruction(String target, String data)
throws SAXException{
System.out.println("Processing the instructions");
System.out.println("<?" + target +" " + data +"?>");
}
publicvoid startElement(String uri,
String localname,
String qName,
Attributes attrs) throws SAXException{
System.out.println("Output the tabs and their attributes");
System.out.print("<" + qName);
int length = attrs.getLength();
for (int i = 0; i < length; i++) {
System.out.print(" ");
System.out.print(attrs.getQName(i));
System.out.print(attrs.getValue(i));
System.out.print("/"");
}
System.out.println(">");
}
publicvoid characters(char[] ch, int start,int length)
throws SAXException{
//输出元素的数据内容
System.out.println(new String(ch, start, length));
}
publicvoid endElement(String uri, String localName, String qName)
throws SAXException{
//输出元素的结束标签
System.out.println("</" + qName +">");
}
publicstaticvoid main(String[] args) {
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = null;
try{
sp = spf.newSAXParser();
File file = new File("student.xml");
sp.parse(file, new SAXParserTest());
}catch(ParserConfigurationException e){
e.printStackTrace();
}catch(SAXException e){
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}
}
}下面是这个程序的运行结果：
===========================
[java]
1. import org.w3c.dom.*;
2. import org.xml.sax.*;
3. import javax.xml.parsers.*;
4. import java.io.*;
5. import javax.xml.transform.*;
6. import javax.xml.transform.dom.*;
7. import javax.xml.transform.stream.*;
8.
9. /**author 汤锐*/
10. public class pxml
11. {
12. static String xmlpath = "D:/tr/xml/";
13. public static void main(String args[])
14. {
15. try
16. {
17.
18. new xml();
19. xx.ProuduceXml(xmlpath);
20. }
21. catch(Exception e)
22. {
23. "main:\n"+e.getMessage());
24. }
25. }
26. }
27.
28.
29.
30.
31.
32.
33. class xml
34. {
35. null;
36. null;
37. null;
38. null;
39. null;
40. null;
41. null;
42. null;
43.
44. public xml()throws Exception
45. {
46.
47. //实例化工厂类
48. false);//不进行有效性检查
49. true);
50.
51. //实例化DocumentBuilder类
52.
53. //实例化Document类
54.
55. tff = TransformerFactory.newInstance();
56. tf = tff.newTransformer();
57.
58. new DOMSource(doc);
59. }
60.
61. /*=====================================================
62. *============生成xml文件
63. *=====================================================*/
64. public void ProuduceXml(String axmlpath)
65. {
66.
67. try
68. {
69.
70. "sudents");//生产根元素students
71. //将根元素添加到根节点后面
72. "001", "张君宝","男","2");
73.
74. students.appendChild(student);
75.
76. "002", "张无忌","女","3");
77. students.appendChild(student);
78.
79. xmlpath = axmlpath;
80. new StreamResult(new FileOutputStream(xmlpath+"tr.xml"));//生成输出源
81. tf.transform(in,out);
82. }
83. catch(Exception e)
84. {
85. System.out.println(e.getMessage());
86. }
87. }
88.
89. public Element ProuduceElement(String aid, String aname,String asex,String aage) throws Exception
90. {
91.
92. "student");//生成student元素(students的子元素)
93. "id",aid);//设置student的属性id的值
94.
95. "name");//创建name子元素
96. //在name元素后添加文本节点
97. //添加student的子元素name
98.
99. "sex");
100. sex.appendChild(doc.createTextNode(asex));
101. student.appendChild(sex);
102.
103. "age");
104. age.appendChild(doc.createTextNode(aage));
105. student.appendChild(age);
106. return student;
107. }
108. }
109.
