w3c xml 操作类

以下从网上找的，自己最近在一个小功能上需要应用
记录下来。

package rochoc.xml.oper;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.log4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;

/**
* 类名：XmlBuilder  <p>
* 类描述：根据传入的XML文件生成Document和root结点 <p>
* 主要public成员变量：<p>
* 主要public方法：   <p>
**/

public class XmlBuilder
{
    /**
     *构造函数说明：       <p>
     *参数说明：@param path   <p>
    **/
    public XmlBuilder(String path)
    {
        this.path=path;
        init();
    }
   
    /**
    * 方法名称：init<p>
    * 方法功能：初始化函数<p>
    * 参数说明： <p>
    * 返回：void <p>
    **/
    public void init()
    {
        buildDocument();
        buildRoot();
    }
   
    /**
    * 方法名称：buildDocument<p>
    * 方法功能：将XML文件生成Document <p>
    * 参数说明： <p>
    **/
    private void buildDocument()
    {
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
        try
        {
            DocumentBuilder builder=factory.newDocumentBuilder();
            logger.debug("Construct document builder success.");
            doc=builder.parse(new File(path));           
            logger.debug("Build xml document success.");
        }catch(ParserConfigurationException e)
        {
            logger.error("Construct document builder error:"+e);
        }catch(SAXException e)
        {
            logger.error("Parse xml file error:"+e);
        }catch(IOException e)
        {
            logger.error("Read xml file error:"+e);
        }
    }
   
 
    private void buildRoot()
    {
        root=doc.getDocumentElement();
    }
   
    /**
     * @return 返回 doc。
     */
    public Document getDoc()
    {
        return doc;
    }
    /**
     * @param doc 要设置的 doc。
     */
    public void setDoc(Document doc)
    {
        this.doc = doc;
    }
    /**
     * @return 返回 path。
     */
    public String getPath()
    {
        return path;
    }
    /**
     * @param path 要设置的 path。
     */
    public void setPath(String path)
    {
        this.path = path;
    }
    /**
     * @return 返回 root。
     */
    public Element getRoot()
    {
        return root;
    }
    /**
     * @param root 要设置的 root。
     */
    public void setRoot(Element root)
    {
        this.root = root;
    }
    /*全局变量*/
    private String path=null;//xml文件路径
    private Document doc=null;//xml文件对应的document
    private Element root=null;//xml文件的根结点
    private Logger logger=Logger.getLogger(getClass().getName());
}


package rochoc.xml.oper;

import java.util.ArrayList;

import org.apache.log4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
* 类名：XmlOper  <p>
* 类描述：对XML文件进行读写操作,均为静态函数 <p>
* 主要public成员变量：<p>
* 主要public方法：   <p>
**/

public class XmlOper
{
    /**
     *构造函数说明：       <p>
     *参数说明：   <p>
    **/
    private XmlOper()
    {       
    }
   
    /**
    * 方法名称：getNodeList<p>
    * 方法功能：获取父结点parent的所有子结点<p>
    * 参数说明：@param parent
    * 参数说明：@return <p>
    * 返回：NodeList <p>
    **/
    public static NodeList getNodeList(Element parent)
    {
        return parent.getChildNodes();
    }
   
    /**
    * 方法名称：getElementsByName<p>
    * 方法功能：在父结点中查询指定名称的结点集            <p>
    * 参数说明：@param parent
    * 参数说明：@param name
    * 参数说明：@return <p>
    * 返回：Element[] <p>
    **/
    public static Element [] getElementsByName(Element parent,String name)
    {
        ArrayList resList=new ArrayList();
        NodeList nl=getNodeList(parent);
        for(int i=0;i<nl.getLength();i++)
        {
            Node nd=nl.item(i);
            if(nd.getNodeName().equals(name))
            {
                resList.add(nd);
            }
        }
        Element [] res=new Element [resList.size()];
        for(int i=0;i<resList.size();i++)
        {
            res[0]=(Element)resList.get(i);
        }       
        logger.debug(parent.getNodeName()+"'s children of "+name+
                "'s num:"+res.length);
        return res;
    }
   
    /**
    * 方法名称：getElementName<p>
    * 方法功能：获取指定Element的名称            <p>
    * 参数说明：@param element
    * 参数说明：@return <p>
    * 返回：String <p>
    **/
    public static String getElementName(Element element)
    {
        return element.getNodeName();
    }
   
    /**
    * 方法名称：getElementValue<p>
    * 方法功能：获取指定Element的值<p>
    * 参数说明：@param element
    * 参数说明：@return <p>
    * 返回：String <p>
    **/
    public static String getElementValue(Element element)
    {
        NodeList nl=element.getChildNodes();
        for(int i=0;i<nl.getLength();i++)
        {
            if(nl.item(i).getNodeType()==Node.TEXT_NODE)//是一个Text Node
            {           
                logger.debug(element.getNodeName()+" has a Text Node.");
                return element.getFirstChild().getNodeValue();
            }
        }  
        logger.error(element.getNodeName()+" hasn't a Text Node.");
        return null;
    }
   
    /**
    * 方法名称：getElementAttr<p>
    * 方法功能：获取指定Element的属性attr的值            <p>
    * 参数说明：@param element
    * 参数说明：@param attr
    * 参数说明：@return <p>
    * 返回：String <p>
    **/
    public static String getElementAttr(Element element,String attr)
    {
        return element.getAttribute(attr);
    }
   
    /**
    * 方法名称：setElementValue<p>
    * 方法功能：设置指定Element的值            <p>
    * 参数说明：@param element
    * 参数说明：@param val <p>
    * 返回：void <p>
    **/
    public static void setElementValue(Element element,String val)
    {
        Node node=element.getOwnerDocument().createTextNode(val);
        NodeList nl=element.getChildNodes();
        for(int i=0;i<nl.getLength();i++)
        {
            Node nd=nl.item(i);
            if(nd.getNodeType()==Node.TEXT_NODE)//是一个Text Node
            {           
                  nd.setNodeValue(val);
                  logger.debug("modify "+element.getNodeName()+"'s node value succe.");
                  return;
            }
        }  
        logger.debug("new "+element.getNodeName()+"'s node value succe.");
        element.appendChild(node);       
    }
   
    /**
    * 方法名称：setElementAttr<p>
    * 方法功能：设置结点Element的属性<p>
    * 参数说明：@param element
    * 参数说明：@param attr
    * 参数说明：@param attrVal <p>
    * 返回：void <p>
    **/
    public static void setElementAttr(Element element,
            String attr,String attrVal)
    {
        element.setAttribute(attr,attrVal);
    }
   
   
    /**
    * 方法名称：addElement<p>
    * 方法功能：在parent下增加结点child<p>
    * 参数说明：@param parent
    * 参数说明：@param child <p>
    * 返回：void <p>
    **/
    public static void addElement(Element parent,Element child)
    {
        parent.appendChild(child);
    }
   
    /**
    * 方法名称：addElement<p>
    * 方法功能：在parent下增加字符串tagName生成的结点<p>
    * 参数说明：@param parent
    * 参数说明：@param tagName <p>
    * 返回：void <p>
    **/
    public static void addElement(Element parent,String tagName)
    {       
        Document doc=parent.getOwnerDocument();
        Element child=doc.createElement(tagName);
        parent.appendChild(child);
    }
   
    /**
    * 方法名称：addElement<p>
    * 方法功能：在parent下增加tagName的Text结点，且值为text<p>
    * 参数说明：@param parent
    * 参数说明：@param tagName
    * 参数说明：@param text <p>
    * 返回：void <p>
    **/
    public static void addElement(Element parent,String tagName,String text)
    {
        Document doc=parent.getOwnerDocument();
        Element child=doc.createElement(tagName);
        setElementValue(child,text);
        parent.appendChild(child);
    }
   
    /**
    * 方法名称：removeElement<p>
    * 方法功能：将父结点parent下的名称为tagName的结点移除<p>
    * 参数说明：@param parent
    * 参数说明：@param tagName <p>
    * 返回：void <p>
    **/
    public static void removeElement(Element parent,String tagName)
    {
        logger.debug("remove "+parent.getNodeName()+"'s children by tagName "+tagName+" begin...");
        NodeList nl=parent.getChildNodes();
        for(int i=0;i<nl.getLength();i++)
        {
            Node nd=nl.item(i);
            if(nd.getNodeName().equals(tagName))
            {
                parent.removeChild(nd);
                logger.debug("remove child '"+nd+"' success.");
            }
        }
        logger.debug("remove "+parent.getNodeName()+"'s children by tagName "+tagName+" end.");
    }
   
   
    /*全局变量*/   
    static Logger logger=Logger.getLogger("XmlOper");
}

XmlCreater.java

用于创建ＸＭＬ文件

/********************************************************************
* 项目名称    ：rochoc   <p>
* 包名称      ：rochoc.xml.oper <p>
* 文件名称    ：XmlCreater   <p>
* 程序功能（类）描述 ： 创建DOM并生成XML文件      <p>
*
* 程序变更日期   ：
* 变更作者    ：
* 变更说明    ：
********************************************************************/
package rochoc.xml.oper;

import java.io.File;

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 org.apache.log4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
* 类名：XmlCreater  <p>
* 类描述： 创建DOM并生成XML文件<p>
* 主要public成员变量：<p>
* 主要public方法：   <p>
**/

public class XmlCreater
{
    /**
     *构造函数说明：       <p>
     *参数说明：@param path  xml文件路径 <p>
    **/
    public XmlCreater(String path)
    {
        this.path=path;
        init();
    }
   
    /**
    * 方法名称：init<p>
    * 方法功能： 初始化函数           <p>
    * 参数说明： <p>
    * 返回：void <p>
    **/
    private void init()
    {
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
        try
        {
            DocumentBuilder builder=factory.newDocumentBuilder();
            doc=builder.newDocument();//新建DOM
        }catch(ParserConfigurationException e)
        {
            logger.error("Parse DOM builder error:"+e);
        }
    }
   
    /**
    * 方法名称：createRootElement<p>
    * 方法功能：创建根结点，并返回            <p>
    * 参数说明：@param rootTagName <p>
    * 返回：Element <p>
    **/
    public Element createRootElement(String rootTagName)
    {    
        if(doc.getDocumentElement()==null)
        {
            logger.debug("create root element '"+rootTagName+"' success.");
            Element root=doc.createElement(rootTagName);
            doc.appendChild(root);
            return root;
        }
        logger.warn("this dom's root element is exist,create fail.");
        return doc.getDocumentElement();
    }
   
    /**
    * 方法名称：createElement<p>
    * 方法功能：在parent结点下增加子结点tagName<p>
    * 参数说明：@param parent
    * 参数说明：@param tagName <p>
    * 返回：Element <p>
    **/
    public Element createElement(Element parent,String tagName)
    {
        Document doc=parent.getOwnerDocument();
        Element child=doc.createElement(tagName);
        parent.appendChild(child);       
        return child;
    }
   
    /**
    * 方法名称：createElement<p>
    * 方法功能：在parent结点下增加值为value的子结点tabName<p>
    * 参数说明：@param parent
    * 参数说明：@param tagName
    * 参数说明：@param value <p>
    * 返回：Element <p>
    **/
    public Element createElement(Element parent,String tagName,String value)
    {
        Document doc=parent.getOwnerDocument();
        Element child=doc.createElement(tagName);
        XmlOper.setElementValue(child,value);
        parent.appendChild(child);
        return child;
    }
   
    /**
    * 方法名称：createAttribute<p>
    * 方法功能：在parent结点下增加属性 <p>
    * 参数说明：@param parent
    * 参数说明：@param attrName 属性名
    * 参数说明：@param attrValue 属性值<p>
    * 返回：void <p>
    **/
    public void createAttribute(Element parent,String attrName,String attrValue)
    {
        XmlOper.setElementAttr(parent,attrName,attrValue);       
    }
   
    /**
    * 方法名称：buildXmlFile<p>
    * 方法功能：根据DOM生成XML文件<p>
    * 参数说明： <p>
    * 返回：void <p>
    **/
    public void buildXmlFile()
    {
        TransformerFactory tfactory=TransformerFactory.newInstance();
        try
        {
            Transformer transformer=tfactory.newTransformer();
            DOMSource source=new DOMSource(doc);
            logger.debug("New DOMSource success.");
            StreamResult result=new StreamResult(new File(path));
            logger.debug("New StreamResult success.");
            transformer.setOutputProperty("encoding","GBK");
            transformer.transform(source,result);
            logger.debug("Build XML File '"+path+"' success.");
        }catch(TransformerConfigurationException e)
        {
            logger.error("Create Transformer error:"+e);
        }catch(TransformerException e)
        {
            logger.error("Transformer XML file error:"+e);
        }
    }
   
    /**
     * @return 返回 doc。
     */
    public Document getDoc()
    {
        return doc;
    }
    /**
     * @param doc 要设置的 doc。
     */
    public void setDoc(Document doc)
    {
        this.doc = doc;
    }
    /**
     * @return 返回 path。
     */
    public String getPath()
    {
        return path;
    }
    /**
     * @param path 要设置的 path。
     */
    public void setPath(String path)
    {
        this.path = path;
    }
    /*全局变量*/
    private Logger logger = Logger.getLogger(getClass().getName());
    private Document doc=null;//新创建的DOM
    private String path=null;//生成的XML文件绝对路径
}