用DOM/JDOM解析XML文件

夜已经深了，可是我仍未眠。明天就要回家过年了，对于一个飘荡在外的游子来说，回家过年是一件多么激动人心的事啊！这才是我心中真正的年啊！
真希望新的一年快点到来，因为有太多的不愉快需要忘记、因为有太多的梦想需要去实现……
前一段时间要解析一个XML文件，就是对XML进行增、删、改的操作。以前做J2EE时一直都是用第三方的类库来辅助解决的，但这次却要求自己用DOM来解析，只能用JDK自带的类库！
一直到现在还没有想通：为什么要重复发明轮子呢？？？但是事情还是要做的，我只是俗人，我也要吃饭……
又或许，这只是我的又一个自我解嘲的借口罢了！
下边的类其实有很多不足的地方的，但我却始终不能说服我自己， 我就是这样一个倔强又刚愎自用的人，期待来年吧，希望走过本命年的我能成熟起来，对于一些事情的控制更自由一些。。。
import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.StringTokenizer;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
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;

/**
* <p>ConfigParser</p>
* 1. read the config XML,or update the file.</br>
* 2. query a property from the config file,the property name fromat:lss.agent.version etc.</br>
* 3. add properties into the config file.</br>
*
* <p>@author javer QQ:84831612</p>
*/
public class ConfigParser
{
private File xmlFile = null;

private Document doc = null;

private Element root = null;

public ConfigParser(String filename)
{
xmlFile = new File(filename);
try
{
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
doc = builder.parse(xmlFile);
root = doc.getDocumentElement();
}
catch(Exception e)
{
System.err.println("Error creating XML parser in ConfigParser.java");
e.printStackTrace();
}
}

/**
* Return the value of the specified property.
*
* @param name the name of the property to get.
* @return the value of the specified property.
*/
public String getValue(String name)
{
String[] propName = parsePropertyName(name);

NodeList nodes = root.getElementsByTagName(propName[0]);
if(nodes == null || nodes.getLength() < 1)
return null;
for(int i = 1; i < propName.length; i++)
{
nodes = ((Element)nodes.item(0)).getElementsByTagName(propName[i]);
if(nodes == null || nodes.getLength() < 1)
return null;
}

Node node = nodes.item(0).getChildNodes().item(0);
if(node != null)
return node.getNodeValue();
else
return null;
}

/**
* <p>Add the values by the specified properties.</p>
* For example:</br>
* if values is existed as follow</br>
* x.y.z1=1</br>
* .z2=2</br>
* .z3=3</br>
* and now, you need add new values as a new group,like as follow values</br>
* x.y.z1=11</br>
* .z2=22</br>
* .z3=33</br>
* you need call this function like as follow:</br>
* addValue("x.y",new String[]{"z1","z2","z3"},new String[]{"11","22","33"})</br>
* and the XML will have a result as follow:</br>
* <xml>
* <x>
* <y>
* <z1>1</z1>
* <z2>2</z2>
* <z2>3</z2>
* </y>
* <y>
* <z1>11</z1>
* <z2>22</z2>
* <z2>33</z2>
* </y>
* </x>
* </xml>
*
* @param parentName
* @param subNames
* @param values
*/
public void addValue(String parentName, String[] subNames, String[] values)
{
String[] propName = parsePropertyName(parentName);

NodeList nodes = root.getElementsByTagName(propName[0]);
if(nodes == null || nodes.getLength() < 1)
{
root.appendChild(doc.createElement(propName[0]));
nodes = root.getElementsByTagName(propName[0]);
}
Element tempElement = ((Element)nodes.item(0));
for(int i = 1; i < propName.length - 1; i++)
{
tempElement = ((Element)nodes.item(0));
nodes = tempElement.getElementsByTagName(propName[i]);
if(nodes == null || nodes.getLength() < 1)
{
tempElement.appendChild(doc.createElement(propName[i]));
nodes = tempElement.getElementsByTagName(propName[i]);
}
}

tempElement = (Element)tempElement.appendChild(doc.createElement(propName[propName.length - 1]));
Node node = null;
for(int i = 0; i < subNames.length; i++)
{
node = tempElement.appendChild(doc.createElement(subNames[i]));
node.appendChild(doc.createTextNode(values[i]));
}

store();
}

/**
* Update the value of the specified property.
* @param name
* @param value
*/
public void updateValue(String name, String value)
{
String[] propName = parsePropertyName(name);

NodeList nodes = root.getElementsByTagName(propName[0]);
if(nodes == null || nodes.getLength() < 1)
return;
for(int i = 1; i < propName.length; i++)
{
nodes = ((Element)nodes.item(0)).getElementsByTagName(propName[i]);
if(nodes == null || nodes.getLength() < 1)
return;
}

Node node = nodes.item(0).getChildNodes().item(0);
if(node != null)
node.setNodeValue(value);
else
return;

store();
}

/**
* Deletes the specified property.
*
* @param name the property to delete.
*/
public void deleteProperty(String name)
{
String[] propName = parsePropertyName(name);
if(propName.length == 1)
root.removeChild(root.getElementsByTagName(propName[0]).item(0));
else
{
NodeList nodes = root.getElementsByTagName(propName[0]);
for(int i = 1; i < propName.length - 1; i++)
{
nodes = ((Element)nodes.item(0)).getElementsByTagName(propName[i]);
if(nodes == null || nodes.getLength() < 1)
return;
}

nodes.item(0).removeChild(((Element)nodes.item(0)).getElementsByTagName(
propName[propName.length - 1]).item(0));
}

store();
}

/**
* Return all children property names of a parent property as a String array,
* or an empty array if the if there are no children. For example, given
* the properties <tt>X.Y.A</tt>, <tt>X.Y.B</tt>, and <tt>X.Y.C</tt>, then
* the child properties of <tt>X.Y</tt> are <tt>A</tt>, <tt>B</tt>, and
* <tt>C</tt>.
*
* @param parent the name of the parent property.
* @return all child property values for the given parent.
*/
public String[] getChildrenProperties(String parent)
{
String[] propName = parsePropertyName(parent);
NodeList nodes = root.getElementsByTagName(propName[0]);
if(nodes == null || nodes.getLength() < 1)
return null;
for(int i = 1; i < propName.length; i++)
{
nodes = ((Element)nodes.item(0)).getElementsByTagName(propName[i]);
if(nodes == null || nodes.getLength() < 1)
return null;
}

nodes = nodes.item(0).getChildNodes();
ArrayList list = new ArrayList();
for(int i = 0; i < nodes.getLength(); i++)
{
if(nodes.item(i).getNodeType() == Node.ELEMENT_NODE)
list.add(nodes.item(i).getNodeName());
}

if(list == null)
return null;
else
return (String[])list.toArray(new String[list.size()]);
}

/**
* Return the value when the specified property key and value is existent,
* and return null if the specified property key and value is not existent
*
* @param name
* @param value
* @return
*/
public String findValue(String name, String value)
{
String[] propName = parsePropertyName(name);
return findValue(root, 0, propName, value);
}

private String findValue(Element element, int depth, String[] propName,String value)
{
String _value = null;
if(depth == propName.length)
{
_value = element.getChildNodes().item(0).getNodeValue();
if(_value.equals(value))
return value;
else
return null;
}

NodeList children = element.getElementsByTagName(propName[depth]);
if(children == null || children.getLength() < 1)
return null;
else
++depth;

for(int i = 0; i < children.getLength(); i++)
{
if(children.item(i).getNodeType() != Node.ELEMENT_NODE)
continue;

element = (Element)children.item(i);
_value = findValue(element, depth, propName, value);
if(_value != null)
{
return value;
}
}

return null;
}

// public static void main(String[] args) throws Exception
// {
// System.out.println("Start****************************");
// ConfigParser test = new
// ConfigParser("/test.xml");

// update
// System.out.println(test.getValue("x.y"));
// test.updateValue("x.y","xyz");
// System.out.println(test.getValue("x.y"));

// delete
// System.out.println(test.getValue("x.y"));
// test.deleteProperty("x.y");
// System.out.println(test.getValue("x.y"));

// getChildrenProperties
// String[] childrenNames = test.getChildrenProperties("x.y");
// if(childrenNames!=null)
// for(int i=0;i<childrenNames.length;i++)
// {
// System.out.println("childrenNames["+i+"]=" + childrenNames[i]);
// }

// find
// System.out.println(test.findValue("x.y.z1","cc22"));

// add
// test.addValue("x.y",new String[]{"z1","z2","z3","z4"},new String[]{"11","22","33","44"}
// );
//
// System.out.println("End****************************");
// }

private synchronized void store()
{
boolean error = false;
File tempFile = new File(xmlFile.getParentFile(), xmlFile.getName() + ".tmp");
FileOutputStream out = null;
try
{
DOMSource ds = new DOMSource(root);
out = new FileOutputStream(tempFile);
StreamResult sr = new StreamResult(out);
TransformerFactory tff = TransformerFactory.newInstance();
Transformer tf = tff.newTransformer();
tf.transform(ds, sr);
}
catch(Exception e)
{
e.printStackTrace();
error = true;
}
finally
{
try
{
out.flush();
out.close();
}
catch(Exception e)
{
e.printStackTrace();
error = true;
}
}

if(!error)
{
xmlFile.delete();
tempFile.renameTo(xmlFile);
}
}

private String[] parsePropertyName(String name)
{
int size = 1;
for(int i = 0; i < name.length(); i++)
{
if(name.charAt(i) == '.')
{
size++;
}
}
String[] propName = new String[size];
StringTokenizer tokenizer = new StringTokenizer(name, ".");
int i = 0;
while(tokenizer.hasMoreTokens())
{
propName[i] = tokenizer.nextToken();
i++;
}
return propName;
}
}

既然提到了JDOM，就不得不搞清楚它和DOM的关系，免得被人问及为何选择此种解决方案时再次无言 ；） （具体的理论性质的比较，google、baidu上有一堆堆的说明，这里就不再copy）同样的类，还有一个用JDOM的实现版本，同样多的代码量下，JDOM的容错性、可扩展性似乎更好些。这一页的内容太多，还是放到下一页吧……