增强Dom4j--让XML处理更容易

package zzvcom.common; 

import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 
import org.dom4j.*; 
import org.dom4j.io.OutputFormat; 
import org.dom4j.io.XMLWriter; 

import java.io.File; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.StringWriter; 
import java.util.List; 

/** 
* XML便捷工具箱 
* 
* @author leizhimin 2009-11-11 16:26:19 
*/ 
public  class XmlToolkit { 
         private  static Log log = LogFactory.getLog(XmlToolkit. class); 


         /** 
         * 根据classpath下xml文件名创建一个XML文档对象，并制定读取字符集 
         * 
         * @param classPathFileName xml文件名称， 
         * @param charset                     xml文件字符集编码 
         * @return xml的字符串 
         */ 
         public  static Document makeDocument(String classPathFileName, String charset) { 
                Document doc =  null; 
                 try { 
                        InputStream in = XmlToolkit. class.getClassLoader().getResourceAsStream(classPathFileName); 
                        String xml = StringFileToolkit.stream2String(in, charset); 
                        doc = DocumentHelper.parseText(xml); 
                }  catch (Exception e) { 
                        log.error( "解析XML发生错误，请检查ClassPath下面的" + classPathFileName +  "文件是否存在，格式是否是正确!"); 
                         throw  new RuntimeException(e); 
                } 
                 return doc; 
        } 

         /** 
         * 创建一个XML文档对象 
         * 
         * @param xmlfile xml文件 
         * @param charset xml文件字符集编码 
         * @return xml的字符串 
         */ 
         public  static Document makeDocument(File xmlfile, String charset) { 
                Document doc =  null; 
                 try { 
                        String xml = StringFileToolkit.file2String(xmlfile, charset); 
                        doc = DocumentHelper.parseText(xml); 
                }  catch (Exception e) { 
                        log.error( "解析XML发生错误，请检查" + xmlfile.getPath() +  "文件是否存在，格式是否是正确!"); 
                         throw  new RuntimeException(e); 
                } 
                 return doc; 
        } 

         /** 
         * 删除文档doc的指定路径下的所有子节点（包含元素，属性等） 
         * 
         * @param doc     文档对象 
         * @param xpath 指定元素的路径 
         * @return 删除成功时返回true，否则false 
         */ 
         public  static  boolean deleteNodes(Document doc, String xpath) { 
                 boolean flag =  true; 
                 try { 
                        List<Node> nlist = doc.selectNodes(xpath); 
                         for (Node node : nlist) { 
                                node.detach(); 
                        } 
                }  catch (Exception e) { 
                        flag =  false; 
                } 
                 return flag; 
        } 

         /** 
         * 删除一个父元素下所有的子节点（包含元素，属性等） 
         * 
         * @param element 父元素 
         * @return 删除成功时返回true，否则false 
         */ 
         public  static  boolean deleteChildren(Element element) { 
                 boolean flag =  true; 
                 try { 
                        List<Node> nlist = element.elements(); 
                         for (Node node : nlist) { 
                                node.detach(); 
                        } 
                }  catch (Exception e) { 
                        flag =  false; 
                } 
                 return flag; 
        } 

         /** 
         * 在指定文档doc的xpath元素下面添加ename子元素，并给出子元素的text值 
         * 
         * @param doc        文档对象 
         * @param xpath    父元素的xpath 
         * @param ename    所加入子元素名称 
         * @param evalue 所加入子元素的text值 
         * @return 加入后的xml元素 
         */ 
         public  static Element addElement(Document doc, String xpath, String ename, String evalue) { 
                Element element =  null; 
                Node n = (Node) doc.selectSingleNode(xpath); 
                 if (n  instanceof Element) { 
                        Element e = (Element) n; 
                        element = e.addElement(ename); 
                        element.setText(evalue); 
                } 
                 return element; 
        } 

         /** 
         * 在指定文档doc的xpath元素下面添加xml文档为子元素 
         * 
         * @param doc     文档对象 
         * @param xpath 父元素的xpath 
         * @param xml     要加入的xml文档 
         * @return 所加入后的xml元素 
         */ 
         public  static Element addElementByString(Document doc, String xpath, String xml) { 
                Element subdoc =  null; 
                 try { 
                        subdoc = DocumentHelper.parseText(xml).getRootElement(); 
                }  catch (DocumentException e) { 
                        e.printStackTrace(); 
                } 
                Node n = (Node) doc.selectSingleNode(xpath); 
                 if (n  instanceof Element) { 
                        Element e = (Element) n; 
                        e.add(subdoc); 
                        System.out.println(subdoc.getPath()); 
                } 
                 return subdoc; 
        } 

         /** 
         * 格式化XML文档 
         * 
         * @param document xml文档 
         * @param charset    字符串的编码 
         * @return 格式化后XML字符串 
         */ 
         public  static String formatXML(Document document, String charset) { 
                OutputFormat format = OutputFormat.createPrettyPrint(); 
                format.setEncoding(charset); 
                StringWriter sw =  new StringWriter(); 
                XMLWriter xw =  new XMLWriter(sw, format); 
                 try { 
                        xw.write(document); 
                        xw.flush(); 
                        xw.close(); 
                }  catch (IOException e) { 
                        log.error( "格式化XML文档发生异常，请检查！", e); 
                } 
                 return sw.toString(); 
        } 
}