java加载xml配置文件

//工具类

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

 

/**

 * 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>

 *          &lt;X&gt;

 *              &lt;Y&gt;

 *                  &lt;Z&gt;someValue&lt;/Z&gt;

 *              &lt;/Y&gt;

 *          &lt;/X&gt;

 * </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 static final Logger m_logger = LoggerFactory.getLogger(XMLProperties.class);

 

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 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) {

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;

}

}

 

/**

* 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/config.xml");

// m_logger.debug(pp.getProperty("socket.NetCutover.SendToWhere.IP"));

// m_logger.debug(""+pp.getRootElement().get);

}

}

 

 

//应用

/**

* 获取指点名称的值

* 

* @param name

*            属性名称字符串

* @return 返回指点名称的值

*/

public static String getLipossProperty(String name) {

if (properties == null) {

loadProperties();

}

 

return properties.getProperty(name);

}

 

/**

* 载入XML配置文件到XMLProperties实例中

*/

private synchronized static void loadProperties() {

if (properties == null) {

if (G_ServerHome == null) {

G_ServerHome = LipossGlobals.getLipossHome();

}

m_logger.debug(G_ServerHome);

String path = G_ServerHome + File.separator + "WEB-INF"

+ File.separator + "classes" + File.separator

+ LIPOSS_CONFIG_FILENAME;

m_logger.debug(path);

properties = new XMLProperties(path);

}

}