XMLTools

package com.indigopacific.util;

import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.InputSource;

import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import com.sun.org.apache.xerces.internal.parsers.DOMParser;

public class XMLTools {

 public static final String DOCUMENT_HEAD = "<?xml version=/"1.0/" encoding=/"GB2312/"?>";
 public static final String LINE_SEPERATOR = System
   .getProperty("line.separator");

 /**
  * 根据文件名创建一个文档对象
  *
  * @param filePath
  *            String
  * @return Document
  */

 public static Document createDocument(String filePath) {
  // 输入参数校验
  if (filePath == null) {
   return null;
  }

  Document document = null;
  try {
   // 解析文件，获取一个document对象
   DocumentBuilderFactory factory = DocumentBuilderFactory
     .newInstance();
   DocumentBuilder parser = factory.newDocumentBuilder();
   document = parser.parse(filePath);
  } catch (Exception e) {
   System.err.println("Exception: " + e.getMessage());
  }

  return document;
 }

 // 创建一个文档对象
 public static Document createDocument(InputStream is) {
  // 输入参数校验
  if (is == null) {
   return null;
  }

  Document document = null;
  try {
   // 解析文件，获取一个document对象
   DocumentBuilderFactory factory = DocumentBuilderFactory
     .newInstance();
   factory.setIgnoringComments(true);
   factory.setIgnoringElementContentWhitespace(true);
   DocumentBuilder parser = factory.newDocumentBuilder();
   document = parser.parse(is);
  } catch (Exception e) {
   System.err.println("Exception: " + e.getMessage());
  }

  return document;

 }

 /**
  * 将document写入到输入流中
  *
  * @param document
  * @param out
  */
 public static void writeDocument(String document, OutputStream out)
   throws java.io.IOException {
  out.write(document.getBytes());
  out.flush();
 }

 /**
  * <company> <person> <name>alan</name> </person> </company>
  * 倘若要读取name的值，path应该为company/person/name/
  *
  * @path:xml中从根节点开始到要操作元素的路径
  * @defaultValue:如果没有找到指定元素的text值，返回缺省值
  */

 public static String readElementTextValue(Document document, String path,
   String defaultValue) {
  // 输入参数校验
  if ((path == null) || (path.trim().length() == 0)) {
   return defaultValue;
  }
  // 找到该元素
  Element element = findElement(document, path);
  // 获取文本子节点
  NodeList children = element.getChildNodes();
  if (children == null) {
   return defaultValue;
  }
  // 遍历找到文本节点
  for (int i = 0; i < children.getLength(); i++) {
   Node _node = children.item(i);
   if (_node.getNodeType() == Node.TEXT_NODE) {
    return _node.getNodeValue();
   }
  }
  // 如果没有文本节点，返回缺省值
  return defaultValue;
 }

 /**
  * 从根节点开始查找指定位置的节点。 <company> <person> <name>tiger</name> </person>
  * </company> 比如要查找name节点，path应该为“company/person/name”
  *
  * @param root:根节点
  * @param path：节点从根节点开始的路径。如
  *            root/a/b
  * @return:如果没有找到，在该位置创建一个新的Element。
  */
 public static Element findElement(Document document, String path) {
  // 根据path，一层层查找指定路径的Element
  StringTokenizer token = new StringTokenizer(path, "/");
  Element parent = null;
  // 根据path一层层的查找，直到找到需要的element，如果没有，则创建新的
  while (token.hasMoreTokens()) {
   // 如果parent为null，将根节点作为父节点
   if (parent == null) {
    parent = document.getDocumentElement();
    token.nextToken();
    continue;
   }

   // 如果要查找的子节点名称为空，不处理
   String elementName = token.nextToken();
   if (elementName.trim() == "") {
    continue;
   }

   // 查找子节点，如果不存在，则创建一个
   Element[] childElements = findChildElement(parent, elementName);
   if (childElements.length == 0) {
    Element childElement = document.createElement(elementName);
    parent.appendChild(childElement);
    parent = childElement;
   } else {
    parent = childElements[0];
   }
  }// end for
  return parent;
 }

 /**
  * 在element的孩子节点中，找到所有符合条件的孩子。 例如： <company> <person> <name>alan</name>
  * <age>25</age> </person> <person> <name>alan</name> <age>25</age>
  * </person> </company>
  * element为person节点，childName指定为person。那么两个person节点就会被加入结果集合中
  *
  * @param element
  * @param <any>
  * @return：如果有，则返回符合条件的子节点集合；否则返回空集合
  */
 public static Element[] findChildElement(Element element, String childPath) {
  // 输入参数校验
  if ((element == null) || (childPath == null)) {
   return new Element[0];
  }

  // 保存结果集合
  List parents = new ArrayList();
  parents.add(element);
  // 分析childpath
  StringTokenizer stringToken = new StringTokenizer(childPath, "/");
  while (stringToken.hasMoreTokens()) {
   // 保存找到的父节点的子节点集合
   List childs = new ArrayList();

   // 获取当前应该找父节点的哪一个子节点了
   String childName = stringToken.nextToken();
   // 如果节点为空，返回
   if (childName == null || childName.trim().length() == 0) {
    continue;
   }

   // 对于父节点集合进行遍历
   for (int iParent = 0; iParent < parents.size(); iParent++) {
    Element parent = (Element) parents.get(iParent);
    // 查找父节点的所有子节点
    NodeList childNodes = parent.getChildNodes();
    // 如果parent没有子元素，返回空集合
    if ((childNodes == null) || (childNodes.getLength() == 0)) {
     continue;
    }
    // 遍历所有子节点，找到和elementName匹配的节点
    for (int i = 0; i < childNodes.getLength(); i++) {
     // 如果子节点不是element，不处理
     if (childNodes.item(i).getNodeType() != Node.ELEMENT_NODE) {
      continue;
     }
     Element child = (Element) childNodes.item(i);
     if (childName.equals(child.getNodeName())) {
      childs.add(child);
     }
    } // 结束对于子节点集合的遍历
   }// 结束对于父节点集合的遍历

   // 找到父节点本层的所有子节点后，当前的所有子节点就是下一次遍历的父节点
   parents = childs;
  }// 结束所有层的遍历

  // 将list转换为数组
  Element[] objectArray = new Element[parents.size()];
  for (int i = 0; i < objectArray.length; i++) {
   objectArray[i] = (Element) parents.get(i);
  }

  return objectArray;
 }

 /**
  * 无属性匹配条件的查找。
  *
  * @param parent
  *            父元素。
  * @param childTagName
  *            待查找的子元素的标记名。
  */
 public static Element findChildElement(Node parent, String childElementName) {
  return findChildElement(parent, childElementName, null, null);
 }

 /**
  * 根据子节点的名称和属性查找一个子节点。如果有多个匹配返回第一个，如果一个 匹配的都没有，返回null。
  *
  * @param parent
  *            父元素。
  * @param childTagName
  *            待查找的子元素的标记名。
  * @param childAttributeName
  *            待查找的子元素要匹配的属性名。
  * @param childAttributeValue
  *            待查找的子元素要匹配的属性值。
  */
 public static Element findChildElement(Node parent,
   String childElementName, String childAttributeName,
   String childAttributeValue) {
  NodeList nl = parent.getChildNodes();
  for (int i = 0; i < nl.getLength(); i++) { // 所有子节点
   Node childNode = nl.item(i);
   if (childNode.getNodeName().equals(childElementName)) { // 名字匹配
    if (childNode instanceof Element) { // 如果是Element(只有它才有属性)
     Element childElement = (Element) childNode;
     if (childAttributeName == null
       || childElement.getAttribute(childAttributeName)
         .equals(childAttributeValue)) { // 属性匹配条件
      return childElement;
     }
    }
   }
  }
  return null; // 没有匹配
 }

 /**
  * @throws Exception
  * @函数名称：${getXmlData}
  * @创建日期：${2008-11-13}
  * @功能说明：解析xml文件获取节点的值
  * @参数说明：节点名称
  * @返回说明：返回xml某个节点的值
  */
 public static String getXmlValue(Document xml, String tagName)
   throws Exception {
  String xmlData = "";
  Element elem = (Element) xml.getDocumentElement();
  xmlData = getElementByTagName(elem, tagName);
  return xmlData;
 }

 /**
  * @函数名称：${getXmlDoc}
  * @创建日期：${2008-11-13}
  * @功能说明：得到要解析的xml文件对象
  * @参数说明：xml文件的路径
  * @返回说明：文件对象
  */
 public static Document getXmlDoc(BufferedReader characterStream)
   throws Exception {
  Document xmlDoc = null;
  DOMParser domparser = new DOMParser();
  InputSource inputsource = new InputSource();
  inputsource.setCharacterStream(characterStream);
  domparser.parse(inputsource);
  xmlDoc = domparser.getDocument();
  if (characterStream != null) {
   characterStream.close();
  }
  return xmlDoc;
 }

 public static Document getXmlDoc(InputStream is) throws Exception {
  Document xmlDoc = null;
  DOMParser domparser = new DOMParser();
  InputSource inputsource = new InputSource();
  inputsource.setByteStream(is);
  domparser.parse(inputsource);
  xmlDoc = domparser.getDocument();
  if (is != null) {
   is.close();
  }
  return xmlDoc;
 }

 /**
  * @函数名称：${getElementByTagName}
  * @创建日期：${2008-11-13}
  * @功能说明：辅助方法，根据节点和节点名称得到节点值
  * @参数说明：父节点、子节点名称
  * @返回说明：节点值
  */
 public static String getElementByTagName(Element parentEle, String tagName)
   throws Exception {
  String retVal = null;
  NodeList theNl = (parentEle).getElementsByTagName(tagName);
  if (theNl.getLength() > 0) {
   if (theNl.item(0).getFirstChild() != null) {
    retVal = theNl.item(0).getFirstChild().getNodeValue();
   }
  }
  return retVal;
 }

 /**
  * @函数名称：${buffer}
  * @创建日期：${2008-11-13}
  * @功能说明：辅助方法，缓冲数据流
  * @参数说明：输入流、输出流
  * @返回说明：空
  */
 public static void buffer(InputStream in, OutputStream out)
   throws IOException {
  BufferedInputStream bin = new BufferedInputStream(in);
  BufferedOutputStream bout = new BufferedOutputStream(out);
  while (true) {
   int datum = bin.read();
   if (datum == -1)
    break;
   bout.write(datum);
  }
  bout.flush();
 }

 public static void main(String[] args) {
  

}

 public XMLTools() {
 }

}