xmlutil.java

Java写的一个学员系统

package cn.st.util;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
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 javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;


/**
 * 初始化一个空Document对象返回。
 *
 * @return a Document
 */
public class XMLUtil {
	private static Logger logger = Logger.getLogger("XMLUtil");


	public static Document newXMLDocument() {
		try {
			return (Document) newDocumentBuilder().newDocument();
		} catch (ParserConfigurationException e) {
			throw new RuntimeException(e.getMessage());
		}
	}

	/**
	 * 初始化一个DocumentBuilder
	 *
	 * @return a DocumentBuilder
	 * @throws ParserConfigurationException
	 */
	private static DocumentBuilder newDocumentBuilder()
			throws ParserConfigurationException {
		return newDocumentBuilderFactory().newDocumentBuilder();
	}

	/**
	 * 初始化一个DocumentBuilderFactory
	 *
	 * @return a DocumentBuilderFactory
	 */
	public static DocumentBuilderFactory newDocumentBuilderFactory() {
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		dbf.setNamespaceAware(true);
		return dbf;
	}

	/**
	 * 将传入的一个XML String转换成一个org.w3c.dom.Document对象返回。
	 *
	 * @param xmlString
	 *            一个符合XML规范的字符串表达。
	 * @return a Document
	 */
	public static Document parseXMLDocument(String xmlString) {
		if (xmlString == null) {
			throw new IllegalArgumentException();
		}
		try {
			return (Document) newDocumentBuilder().parse(
					new InputSource(new StringReader(xmlString)));
		} catch (Exception e) {
			throw new RuntimeException(e.getMessage());
		}
	}

	/**
	 * 给定一个输入流，解析为一个org.w3c.dom.Document对象返回。
	 *
	 * @param input
	 * @return a org.w3c.dom.Document
	 */
	public  static Document parseXMLDocument(InputStream input) {
		if (input == null) {
			throw new IllegalArgumentException("参数为null！");
		}
		try {
			return (Document) newDocumentBuilder().parse(input);
		} catch (Exception e) {
			throw new RuntimeException(e.getMessage());
		}
	}

	/**
	 * 给定一个文件名，获取该文件并解析为一个org.w3c.dom.Document对象返回。
	 *
	 * @param fileName
	 *            待解析文件的文件名
	 * @return a org.w3c.dom.Document
	 * @throws ParserConfigurationException
	 * @throws IOException
	 * @throws SAXException
	 */
	public static Document loadXMLDocumentFromFile(String fileName) throws SAXException, IOException, ParserConfigurationException {
		if (fileName == null) {
			throw new IllegalArgumentException("未指定文件名及其物理路径！");
		}
		//return (Document) newDocumentBuilder().parse(new File(fileName));

		try {
			return (Document) newDocumentBuilder().parse(new File(fileName));
		} catch (SAXException e) {
			throw new IllegalArgumentException("目标文件（" + fileName
					+ "）不能被正确解析为XML！\n" + e.getMessage());
		} catch (IOException e) {
			throw new IllegalArgumentException("不能获取目标文件（" + fileName + "）！\n"
					+ e.getMessage());
		} catch (ParserConfigurationException e) {
			throw new RuntimeException(e.getMessage());
		}

	}

	/**
	 * 给定一个节点，将该节点加入新构造的Document中。
	 *
	 * @param node
	 *            a Document node
	 * @return a new Document
	 * @throws Exception
	 */
	public static Document  newXMLDocument(Node node)  {
		Document doc = newXMLDocument();
		((Node) doc).appendChild(((org.w3c.dom.Document) doc).importNode(node,
				true));
		return doc;
	}

	/**
	 * 将传入的一个DOM Node对象输出成字符串。如果失败则返回一个空字符串""。
	 *
	 * @param node
	 *            DOM Node 对象。
	 * @return a XML String from node
	 */

	public static String nodeToString(Node node) {
		if (node == null) {
			throw new IllegalArgumentException();
		}
		Transformer transformer = newTransformer();
		if (transformer != null) {
			try {
				StringWriter sw = new StringWriter();
				transformer
						.transform(new DOMSource(node), new StreamResult(sw));
				String ss = sw.toString();
				ss = ss.substring(ss.indexOf(">") + 1);
				return ss;
			} catch (TransformerException te) {
				throw new RuntimeException(te.getMessage());

			}
		}
		return errXMLString("不能生成XML信息！");
	}

	/**
	 * 获取一个Transformer对象，由于使用时都做相同的初始化，所以提取出来作为公共方法。
	 *
	 * @return a Transformer encoding gb2312
	 */
	public static Transformer newTransformer() {
		try {
			Transformer transformer = TransformerFactory.newInstance()
					.newTransformer();
			/*
			 * Properties properties = transformer.getOutputProperties();
			 * properties.setProperty(OutputKeys.ENCODING, "gb2312");
			 * properties.setProperty(OutputKeys.METHOD, "xml");
			 * properties.setProperty(OutputKeys.VERSION, "1.0");
			 * properties.setProperty(OutputKeys.INDENT, "no");
			 * transformer.setOutputProperties(properties);
			 */
			return transformer;
		} catch (TransformerConfigurationException tce) {
			throw new RuntimeException(tce.getMessage());
		}
	}

	/**
	 * 返回一段XML表述的错误信息。提示信息的TITLE为：系统错误。之所以使用字符串拼装，主要是这样做一般 不会有异常出现。
	 *
	 * @param errMsg
	 *            提示错误信息
	 * @return a XML String show err msg
	 */
	public static String errXMLString(String errMsg) {
		StringBuffer msg = new StringBuffer(100);
		msg.append("<?xml version=\"1.0\" encoding=\"gb2312\" ?>");
		msg.append("<errNode title=\"系统错误\" errMsg=\"" + errMsg + "\"/>");
		return msg.toString();
	}

	/**
	 * 返回一段XML表述的错误信息。提示信息的TITLE为：系统错误
	 *
	 * @param errMsg
	 *            提示错误信息
	 * @param errClass
	 *            抛出该错误的类，用于提取错误来源信息。
	 * @return a XML String show err msg
	 */
	public static String errXMLString(String errMsg, Class errClass) {
		StringBuffer msg = new StringBuffer(100);
		msg.append("<?xml version=\"1.0\" encoding=\"gb2312\" ?>");
		msg.append("<errNode title=\"系统错误\" errMsg=\"" + errMsg
				+ "\" errSource=\"" + errClass.getName() + "\"/>");
		return msg.toString();
	}

	/**
	 * 返回一段XML表述的错误信息。
	 *
	 * @param title
	 *            提示的title
	 * @param errMsg
	 *            提示错误信息
	 * @param errClass
	 *            抛出该错误的类，用于提取错误来源信息。
	 * @return a XML String show err msg
	 */
	public static String errXMLString(String title, String errMsg,
			Class errClass) {
		StringBuffer msg = new StringBuffer(100);
		msg.append("<?xml version=\"1.0\" encoding=\"gb2312\" ?>");
		msg.append("<errNode title=\"" + title + "\" errMsg=\"" + errMsg
				+ "\" errSource=\"" + errClass.getName() + "\"/>");
		return msg.toString();
	}
	/**
	 *
	 * @return
	 */
	public static XPath createNewXpathprocessor(){
        XPathFactory xpfactory = XPathFactory.newInstance();
        XPath xpathProcessor = xpfactory.newXPath();
        return xpathProcessor;
	}
	/**
	 * 根据xpath获取节点文档相应的节点
	 * @param Element elementDoc 被解析的节点文档
	 * @param String xpath1 解析路径
	 * @param XPath xpathProcessor 解析器
	 * @return Element
	 */
	public static Element getSpecialPropertyElement(Element elementDoc,String xpath1,XPath xpathProcessor){
		try{
            XPathExpression nodeXPath = xpathProcessor.compile(xpath1);
            NodeList tmpNodes = (NodeList)nodeXPath.evaluate(elementDoc,
                    XPathConstants.NODESET);
    	    return (Element)tmpNodes.item(0);
        }catch(XPathExpressionException e){
        	e.printStackTrace();
        	return null;
        }
	}
	/**
	 * 根据xpath获取节点文档相应的节点集
	 * @param elementDoc
	 * @param xpath1
	 * @param xpathProcessor
	 * @return NodeList
	 */
	public static NodeList getSpecialPropertyNodeList(Element elementDoc,String xpath1,XPath xpathProcessor){
		try{
            XPathExpression nodeXPath = xpathProcessor.compile(xpath1);
            NodeList tmpNodes = (NodeList)nodeXPath.evaluate(elementDoc,
                    XPathConstants.NODESET);
    	    return tmpNodes;
        }catch(XPathExpressionException e){
        	e.printStackTrace();
        	return null;
        }
	}


	public static Document loadXMLIgnoreException(String file) {
		try {
			return DocumentBuilderFactory.newInstance().newDocumentBuilder()
					.parse(file);
		} catch (SAXException e) {
			logger.log(Level.SEVERE,"SAXException",e);
		} catch (IOException e) {
			logger.log(Level.SEVERE,"IOException",e);
		} catch (ParserConfigurationException e) {
			logger.log(Level.SEVERE,"ParserConfigurationException",e);
		}
		return null;
	}


	/**
	 * 创建一个父Element。同时创建它的字节点，并将创建的字节点插入到这个父节点。
	 * @param ownerDoc Document
	 * @param parentElmetName 父节点的名字
	 * @param childElementNames 字节点名字数组。每个名字创建一个新的Element。
	 * @return 返回根据parentEleName所创建的父Element。
	 */
	public static Element insertElement(Document ownerDoc, String parentEleName, String... childElementNames) {
		if(ownerDoc != null) {
			Element parent = ownerDoc.createElement(parentEleName);
			for(String str : childElementNames) {
				Element child = ownerDoc.createElement(str);
				parent.appendChild(child);
			}
			return parent;
		}
		return null;
	}

	/**
	 * 创建子节点并插入到指定的父节点里.
	 * @param parent 父Element
	 * @param childElementNames 字节点名字数组。每个名字创建一个新的Element。
	 * @return parent Element。
	 */
	public static Element insertElement(Element parent, String... childElementNames) {
		if(parent != null) {
			for(String str : childElementNames) {
				Element child = parent.getOwnerDocument().createElement(str);
				parent.appendChild(child);
			}
			return parent;
		}
		return null;
	}
	/**
	 * 向一个parent里装填子节点。传入的子节点将使用原件的复制品放到父节点里
	 * @param parent 父Element
	 * @param childElements 子节点Element。
	 * @return parent Element。
	 */
	public static Element insertElement(Element parent, Element... childElements) {
		if(parent != null) {
			for(Element child : childElements) {
				parent.appendChild(parent.getOwnerDocument().importNode(child, true));
			}
			return parent;
		}
		return null;
	}
//	/**
//	 * 创建一个Element,并将这个Element添加到parent里.
//	 * @param parent 父节点
//	 * @param elementName 子节点名
//	 * @return 返回子节点
//	 */
//	public static Element createElement(Element parent, String eleName) {
//		Element child = null;
//		if(parent != null) {
//				child = parent.getOwnerDocument().createElement(eleName);
//				parent.appendChild(child);
//			}
//		return child;
//	}
	/**
	 * 创建一个Element
	 * @param ownerDoc Document
	 * @param eleName the element name
	 * @return 一个Element
	 */
	public static Element createElement(Document ownerDoc, String eleName) {
		if(ownerDoc != null) {
			Element parent = ownerDoc.createElement(eleName);
			return parent;
		}
		return null;
	}

	/**
	 * 删除指定父节点下一级的子节点
	 * @author:zn
	 * @datetime:2007-3-12-下午05:10:34
	 * @param parentEle
	 * @param childEles
	 * @return
	 */
	public static Element removeChilds(Element parentEle, Element... childEles) {
		for(Element ele : childEles) {
			parentEle.removeChild(ele);
		}

		return parentEle;
	}

	/**
	 * 删除指定父节点下一级的子节点
	 * @author:zn
	 * @datetime:2007-3-12-下午05:10:31
	 * @param parentEle
	 * @param childNames
	 * @return
	 */
	public static Element removeChilds(Element parentEle, String... childNames) {
		for(String name : childNames) {
			NodeList list = parentEle.getElementsByTagName(name);
			for(int i = 0; i < list.getLength(); i ++) {
				Element ele = (Element) list.item(i);
				parentEle.removeChild(ele);
			}
		}

		return parentEle;
	}



	/**
	 *
	 * @param ownerDoc
	 * @param eleName
	 * @param textContent 节点文本内容
	 * @return
	 */
	public static Element createElement(Document ownerDoc, String eleName, String textContent) {

		Element parent = createElement(ownerDoc, eleName);
		parent.setTextContent(textContent);

		return parent;
	}
	/**
	 * 等价拷贝xml文档
	 * @param destination 目的地
	 * @param doc 源
	 */
	public static void transform(String destination, Document doc) {
		try {
		javax.xml.transform.stream.StreamResult sr = new StreamResult (new File(destination));
		// 等价转换
        TransformerFactory tf = TransformerFactory.newInstance();
		Transformer t = null;

		t = tf.newTransformer ();
		DOMSource doms = new DOMSource (doc);
		t.transform(doms,sr);
		} catch (TransformerConfigurationException e) {
			e.printStackTrace();
		} catch (TransformerException e) {
			e.printStackTrace();
		}

	}

	public static void tranfromXML(Document sourceDoc, String destPath) {

		try {
			TransformerFactory factory = TransformerFactory.newInstance();
			Transformer transformer;
			transformer = factory.newTransformer();
			DOMSource source= new DOMSource(sourceDoc);
			StreamResult result = new StreamResult(new FileOutputStream(destPath));
			transformer.transform(source,result);

		} catch (TransformerConfigurationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (TransformerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}