Java的XML创建、解析文档

1、使用DOM

优点：可以在内存直接操作节点。

缺点：当文档较大时，消耗内存大。

/**
*
*/
package com.ee.xml;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
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.stream.StreamResult;

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;

/**
* <pre>
* 使用DOM来创建文档，读取文档等。
* </pre>
* @author ps
*
*/
public class XmlDocument {
private Document document;
/**
* 创建文档
*/
public void createXmlDocument(){
try {
//使用工厂类创建
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
document = builder.newDocument();
} catch (ParserConfigurationException e) {
e.printStackTrace();;
}
}

/**
* <pre>
* 创建XML文档
* 生成的内容如下：
* <?xml version="1.0" encoding="utf-8" standalone="no"?>
* <employees>
* <employee>
* <name>pansen</name>
* <sex>男</sex>
* <age>26</age>
* </employee>
* </employees>
* </pre>
*/
public void createXml(){
Element element = document.createElement("employee");
Element name = document.createElement("name");
Node node = document.createTextNode("pansen");
name.appendChild(node);
element.appendChild(name);

Element sex = document.createElement("sex");
Node sexText = document.createTextNode("男");
sex.appendChild(sexText);
element.appendChild(sex);

Element age = document.createElement("age");
Node ageText = document.createTextNode("26");
age.appendChild(ageText);
element.appendChild(age);

Element root = document.createElement("employees");
root.appendChild(element);
document.appendChild(root);

try {
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();

DOMSource domSource = new DOMSource(document);

//设置文档的编码
transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");

File file = new File("d:\\my.xml");//文件名

StreamResult result = new StreamResult(file);
transformer.transform(domSource, result);//生成XML文件
} catch (TransformerConfigurationException e) {
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
}
}

/**
* 解析XML文档
*/
public void parseXML(){
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
File file = new File("d:\\my.xml");
Document document = builder.parse(file);//把XML文档转换为Document
NodeList employees = document.getChildNodes();

//遍历输出
for (int i = 0; i < employees.getLength(); i++) {
Node employe = employees.item(i);
NodeList nodeList = employe.getChildNodes();
for (int j = 0; j < nodeList.getLength(); j++) {
Node node = nodeList.item(j);

NodeList employeeMeta = node.getChildNodes();
for (int k = 0; k < employeeMeta.getLength(); k++) {
System.out.println(employeeMeta.item(k).getNodeName()
+ ":" + employeeMeta.item(k).getTextContent());
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

2、使用SAX

优点：不必解析整个文档，消耗内存较小。

缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知该文本属于哪个元素。

例子：

/**
*
*/
package com.ee.xml;

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.SAXException;

import com.ee.xml.handle.EmployeeHandler;

/**
* <pre>
* 使用SAX来创建文档，读取文档等。
* </pre>
* @author ps
*
*/
public class SaxXmlDocument extends XmlDocument{
/**
* 解析XML文档
*/
public void parseXML(){
try {
SAXParserFactory parserFactory = SAXParserFactory.newInstance();
SAXParser saxParser = parserFactory.newSAXParser();
File file = new File("d:\\my.xml");

EmployeeHandler handler = new EmployeeHandler();
saxParser.parse(file, handler);
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

package com.ee.xml.handle;

import java.util.ArrayList;
import java.util.List;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import com.ee.xml.entity.Employee;
/**
*
* @author ps
*
*/
public class EmployeeHandler extends DefaultHandler{
private Employee employee;
private List<Employee> employeeLists;
private String tagName;

public Employee getEmployee() {
return employee;
}

public void setEmployee(Employee employee) {
this.employee = employee;
}

public List<Employee> getEmployeeLists() {
return employeeLists;
}

public void setEmployeeLists(List<Employee> employeeLists) {
this.employeeLists = employeeLists;
}

@Override
public void startDocument() throws SAXException {
//文档开始，可以做一些初始化的内容
System.err.println("文档开始，可以做一些初始化的内容");
employeeLists = new ArrayList<Employee>();
}

@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
//开始节点调用
System.err.println("开始节点调用");
if("employee".equals(qName)){
employee = new Employee();
//在此可以用来判断获取tagName上的属性值
}
tagName = qName;
System.err.println(qName);
}

@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
//结束节点调用
System.err.println("结束节点调用");
employeeLists.add(employee);
tagName = null;
}

@Override
public void endDocument() throws SAXException {
//文档结束
System.err.println("文档结束");
}

@Override
public void characters(char[] ch, int start, int length)
throws SAXException {

String val = new String(ch, start, length);
System.err.println(val);
if("name".equals(tagName)){
employee.setName(val);
}else if("sex".equals(tagName)){
employee.setSex(val);
}else if("age".equals(tagName)){
employee.setAge(Integer.parseInt(val));
}

}
}

/**
*
*/
package com.ee.xml.entity;

/**
* @author ps
*
*/
public class Employee {
private String name;
private String sex;
private int age;

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

3、使用DOM4J，需要导入dom4j-1.6.1.jar

DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J

/**
*
*/
package com.ee.xml;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.Iterator;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
* @author ps
*
*/
public class Dom4jXmlDocument {

public void createXml(){
Document document = DocumentHelper.createDocument();
Element employees = document.addElement("employees");
Element employee = employees.addElement("employee");
Element name = employee.addElement("name");
name.setText("pansen");
Element sex = employee.addElement("sex");
sex.setText("男");
Element age = employee.addElement("age");
age.setText("26");

try {
File file = new File("d:\\dom4j.xml");
OutputStream out = new FileOutputStream(file);
Writer writer = new OutputStreamWriter(out, "utf-8");
//Writer writer = new FileWriter(file);//2 字节的 UTF-8 序列的字节 2 无效。
XMLWriter xmlWriter = new XMLWriter(writer);

xmlWriter.write(document);
xmlWriter.close();
} catch (IOException e) {
e.printStackTrace();
}

}

public void parseXml(){
File file = new File("d:\\dom4j.xml");
SAXReader saxReader = new SAXReader();

try {
Document document = saxReader.read(file);

Element employees = document.getRootElement();

Iterator<Element> iterator = employees.elementIterator();

while(iterator.hasNext()){
Element employee = iterator.next();

Iterator<Element> iter = employee.elementIterator();
while(iter.hasNext()){
Element node = iter.next();

System.err.println(node.getName() + "||" + node.getText());
}
}
} catch (DocumentException e) {
e.printStackTrace();
}
}
}