import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import org.apache.log4j.Logger;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
import org.jdom.xpath.XPath;
/**
* Provides the the ability to use simple XML property files. Each property is
* in the form X.Y.Z, which would map to an XML snippet of:
*
* <pre>
* <X>
* <Y>
* <Z>someValue</Z>
* </Y>
* </X>
* </pre>
*
* The XML file is passed in to the constructor and must be readable and
* writtable. Setting property values will automatically persist those value to
* disk.
*/
public class XMLProperties {
private Logger m_logger = Logger.getLogger(this.getClass());
private File file;
private Document doc;
private Element root;
// private Element element;
/**
* Parsing the XML file every time we need a property is slow. Therefore, we
* use a Map to cache property values that are accessed more than once.
*/
private static Map propertyCache = new HashMap();
/**
* Creates a new XMLProperties object.
*
* @param file
* the full path the file that properties should be read from and
* written to.
*/
public XMLProperties(String file) {
this.file = new File(file);
try {
SAXBuilder builder = new SAXBuilder();
// Strip formatting
DataUnformatFilter format = new DataUnformatFilter();
builder.setXMLFilter(format);
doc = builder.build(new File(file));
root = doc.getRootElement();
} catch (Exception e) {
m_logger.error("Error creating XML parser in "
+ "PropertyManager.java");
e.printStackTrace();
}
}
/**
* Returns the value of the specified property.
*
* @param name
* the name of the property to get.
* @return the value of the specified property.
*/
public String getProperty(String name) {
//find cache exist name
if (propertyCache.get(name) == null) {
m_logger.warn(name +" not find .");
String[] propName = parsePropertyName(name);
// Search for this property by traversing down the XML heirarchy.
Element element = doc.getRootElement();
for (int i = 0; i < propName.length; i++) {
element = element.getChild(propName[i]);
if (element == null) {
// This node doesn't match this part of the property name
// which
// indicates this property doesn't exist so return null.
return null;
}
}
// At this point, we found a matching property, so return its value.
// Empty strings are returned as null.
String value = element.getText();
if ("".equals(value)) {
return null;
} else {
// Add to cache so that getting property next time is fast.
value = value.trim();
propertyCache.put(name, value);
return value;
}
}
m_logger.info(name +" find .");
return (String) propertyCache.get(name);
}
/**
* 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);
// Search for this property by traversing down the XML heirarchy.
Element element = doc.getRootElement();
for (int i = 0; i < propName.length; i++) {
element = element.getChild(propName[i]);
if (element == null) {
// This node doesn't match this part of the property name which
// indicates this property doesn't exist so return empty array.
return new String[] {};
}
}
// We found matching property, return names of children.
List children = element.getChildren();
int childCount = children.size();
String[] childrenNames = new String[childCount];
for (int i = 0; i < childCount; i++) {
childrenNames[i] = ((Element) children.get(i)).getName();
}
return childrenNames;
}
/**
* Sets the value of the specified property. If the property doesn't
* currently exist, it will be automatically created.
*
* @param name
* the name of the property to set.
* @param value
* the new value for the property.
*/
public void setProperty(String name, String value) {
// Set cache correctly with prop name and value.
propertyCache.put(name, value);
String[] propName = parsePropertyName(name);
// Search for this property by traversing down the XML heirarchy.
Element element = doc.getRootElement();
for (int i = 0; i < propName.length; i++) {
// If we don't find this part of the property in the XML heirarchy
// we add it as a new node
if (element.getChild(propName[i]) == null) {
element.addContent(new Element(propName[i]));
}
element = element.getChild(propName[i]);
}
// Set the value of the property in this node.
element.setText(value);
// write the XML properties to disk
saveProperties();
}
/**
* Deletes the specified property.
*
* @param name
* the property to delete.
*/
public void deleteProperty(String name) {
String[] propName = parsePropertyName(name);
// Search for this property by traversing down the XML heirarchy.
Element element = doc.getRootElement();
for (int i = 0; i < propName.length - 1; i++) {
element = element.getChild(propName[i]);
// Can't find the property so return.
if (element == null) {
return;
}
}
// Found the correct element to remove, so remove it...
element.removeChild(propName[propName.length - 1]);
// .. then write to disk.
saveProperties();
}
/**
* Saves the properties to disk as an XML document. A temporary file is used
* during the writing process for maximum safety.
*/
private synchronized void saveProperties() {
OutputStream out = null;
boolean error = false;
// Write data out to a temporary file first.
File tempFile = null;
try {
tempFile = new File(file.getParentFile(), file.getName() + ".tmp");
// Use JDOM's XMLOutputter to do the writing and formatting. The
// file should always come out pretty-printed.
XMLOutputter outputter = new XMLOutputter();
out = new BufferedOutputStream(new FileOutputStream(tempFile));
outputter.output(doc, out);
} catch (Exception e) {
e.printStackTrace();
// There were errors so abort replacing the old property file.
error = true;
} finally {
try {
out.close();
} catch (Exception e) {
e.printStackTrace();
error = true;
}
}
// No errors occured, so we should be safe in replacing the old
if (!error) {
// Delete the old file so we can replace it.
file.delete();
// Rename the temp file. The delete and rename won't be an
// automic operation, but we should be pretty safe in general.
// At the very least, the temp file should remain in some form.
tempFile.renameTo(file);
}
}
/**
* Returns an array representation of the given Jive property. Jive
* properties are always in the format "prop.name.is.this" which would be
* represented as an array of four Strings.
*
* @param name
* the name of the Jive property.
* @return an array representation of the given Jive property.
*/
private String[] parsePropertyName(String name) {
// Figure out the number of parts of the name (this becomes the size
// of the resulting array).
int size = 1;
for (int i = 0; i < name.length(); i++) {
if (name.charAt(i) == '.') {
size++;
}
}
String[] propName = new String[size];
// Use a StringTokenizer to tokenize the property name.
StringTokenizer tokenizer = new StringTokenizer(name, ".");
int i = 0;
while (tokenizer.hasMoreTokens()) {
propName[i] = tokenizer.nextToken();
i++;
}
return propName;
}
/**
* Return XML File Document Object
*
* @return Document
*/
public Document getDocument() {
return doc;
}
/**
* Return Document Root Element
*
* @return Element
*/
public Element getRootElement() {
return root;
}
/***************************************************************************
* XPATH基础
* XPATH遵循文档对象模型(DOM)的路径格式,基本语法由表达式构成。在计算表达式的值之后产生一个对象,这种对象有以下四种基本类型:节点集合、布尔型、数字型和字符串型。XPATH基本上和在文件系统中寻找文件类似,如果路径是以"/"开头的,就表明该路径表示的是一个绝对路径,这和在UNIX系统中关于文件路径的定义是一致的。以"//"开头
* 则表示在文档中的任意位置查找。
*
* 以样例XML文档(friends.xml)为例来了解XPATH: <?xml version="1.0" encoding="UTF-8"?>
* <friends comment="Friends List"> <friend number="1"> <name>zoof</name>
* <sex value="male" /> <phone>87654321</phone> </friend> <friend
* number="2"> <name>joe</name> <sex value="male" /> <phone>87654322</phone>
* </friend> <friend number="3"> <name>joe</name> <sex value="female" />
* <phone>87654323</phone> </friend> </friends>
*
* 在XML文档中使用位置路径表达式来查找信息,这些表达式有很多种组成方式。一般我们用得最多的恐怕是 节点元素
* 查找。XPATH中用正斜杠(/)来分隔子结点,返回所有与 模式相匹配的元素。下面以几个 表达式 的例子来说明一下返回结果:
* 表达式:/friends/friend 返回:根元素friends下所有的 friend 元素(或节点)。
*
* 表达式:/friends/* 返回:根元素friends下所有的元素(或节点)。(“*”相当于通配符,表示“所有”的)
*
* 表达式://friend 返回:任意元素(或节点)下的所有 friend 元素(或节点)。(注意:不仅仅是1中
* 根元素friends下面的friend元素,如果存在的话)
*
* 表达式:/friends/friend[@number='1'] 返回:根元素下元素名称为
* friend,number属性为'1'的全部元素(或节点)。(对于元素或节点的附加元素,比如属性,函数等都要用方括号"[]"扩起来,属性前面要加
* 上"@"号)
*
* 表达式:/friends/friend/phone[text()='87654321'] 返回:元素friends/friend下电话号码为
* 87654321 的全部元素。(text()是XPATH的函数,功能是取出当前节点的文本内容,即content。)
*
* 表达式://name/parent::* 返回:name元素的所有父元素(或节点)。(parent::* 表示这个元素的所有的父节点的集合)
*
* 上面的介绍对于我们一般的应用基本上够用了,如果你需要进一步的深入,请查看W3C发布的关于XAPH的官方资料。
*
*
* 现在我们开始使用XPATH结合JDOM来操作XML文件了。JDOM的关于XPATH的api主要有一个类:Xpath.java,在org.jdom.xpath这个包中。这个类中的核心方法主要是两个静态方法:selectNodes()和selectSingleNode()。
* 前者根据一个xpath语句返回一组节点:List;后者根据一个xpath语句返回符合条件的第一个节点:Object。 public static
* List selectNodes(Object arg1,String arg2) throws org.jdom.JDOMException;
* public static Object selectSingleNode(Object arg1,String arg2) throws
* org.jdom.JDOMException;
*
* 在使用XPATH之前,请先确定你的classpath路径里面有如下几个JAR包,如果没有,请从JDOM的发行包中lib目录下copy:
* saxpaht.jar jaxen-core.jar jaxen-jdom.jar
**************************************************************************/
/**
* 根据XPATH地址路径获得所有满足条件的对象
*
* @param xPath
*
* @return List
*/
public List selectNodes(String xPath) {
List list = new ArrayList();
list.clear();
try {
list = XPath.selectNodes(root, xPath);
} catch (JDOMException e) {
e.printStackTrace();
}
return list;
}
/**
* 根据XPATH地址路径获得所有满足条件的对象
*
* @param xPath
*
* @return Element
*/
public Element selectSingleNode(String xPath) {
Element element = null;
try {
element = (Element) XPath.selectSingleNode(root, xPath);
} catch (JDOMException e) {
e.printStackTrace();
}
return element;
}
/**
* 根据节点名称获得节点值
*
* @param element
* @param name
* @return String
*/
public String getText(Element element, String name) {
name = element.getText();
return name;
}
/**
* 根据属性名称获得属性值
*
* @param element
* @param name
* @return String
*/
public String getAttributeValue(Element element, String name) {
name = element.getAttributeValue(name);
return name;
}
public static void main(String[] args) {
Logger m_logger = Logger.getLogger(XMLProperties.class);
XMLProperties pp = new XMLProperties(
"E:/Web/WEB-INF/classes/liposs_cfg.xml");
// m_logger.info(pp.getProperty("socket.NetCutover.SendToWhere.IP"));
// m_logger.info(""+pp.getRootElement().get);
}
}
xml文件读取的工具类