Java操作Xml

  1 XMLBuilder.java
  2  
  3  用于创建ＤＯＭ，Root结点
  4  
  5 /********************************************************************
  6  * 项目名称    ：rochoc   <p>
  7  * 包名称      ：rochoc.xml.oper <p>
  8  * 文件名称    ：XmlBuilder   <p>
  9  * 编写者     ：luoc    <p>
 10  * 编写日期    ：2005-6-22    <p>
 11  * 程序功能（类）描述 ： 根据传入的XML文件生成Document和root结点<p>
 12  *
 13  * 程序变更日期   ：
 14  * 变更作者    ：
 15  * 变更说明    ：
 16 ********************************************************************/
 17 package rochoc.xml.oper;
 18  
 19 import java.io.File;
 20 import java.io.IOException;
 21  
 22 import javax.xml.parsers.DocumentBuilder;
 23 import javax.xml.parsers.DocumentBuilderFactory;
 24 import javax.xml.parsers.ParserConfigurationException;
 25  
 26 import org.apache.log4j.Logger;
 27 import org.w3c.dom.Document;
 28 import org.w3c.dom.Element;
 29 import org.xml.sax.SAXException;
 30  
 31 /**
 32  * 类名：XmlBuilder  <p>
 33  * 类描述：根据传入的XML文件生成Document和root结点 <p>
 34  * 编写者 ：luoc<p>
 35  * 编写日期 ：2005-6-22<p>
 36  * 主要public成员变量：<p>
 37  * 主要public方法：   <p>
 38  **/
 39  
 40 public class XmlBuilder
 41 {
 42     /**
 43      *构造函数说明：       <p>
 44      *参数说明：@param path   <p>
 45     **/
 46     public XmlBuilder(String path)
 47     {
 48         this.path=path;
 49         init();
 50     }
 51      
 52     /**
 53     * 方法名称：init<p>
 54     * 方法功能：初始化函数<p>
 55     * 参数说明： <p>
 56     * 返回：void <p>
 57     * 作者：luoc
 58     * 日期：2005-6-22
 59     **/
 60     public void init()
 61     {
 62         buildDocument();
 63         buildRoot();
 64     }
 65      
 66     /**
 67     * 方法名称：buildDocument<p>
 68     * 方法功能：将XML文件生成Document <p>
 69     * 参数说明： <p>
 70     * 返回：void <p>
 71     * 作者：luoc
 72     * 日期：2005-6-22
 73     **/
 74     private void buildDocument()
 75     {
 76         DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
 77         try
 78         {
 79             DocumentBuilder builder=factory.newDocumentBuilder();
 80             logger.debug("Construct document builder success.");
 81             doc=builder.parse(new File(path));           
 82             logger.debug("Build xml document success.");
 83         }catch(ParserConfigurationException e)
 84         {
 85             logger.error("Construct document builder error:"+e);
 86         }catch(SAXException e)
 87         {
 88             logger.error("Parse xml file error:"+e);
 89         }catch(IOException e)
 90         {
 91             logger.error("Read xml file error:"+e);
 92         }
 93     }
 94      
 95     /**
 96     * 方法名称：buildRoot<p>
 97     * 方法功能：生成XML的根结点<p>
 98     * 参数说明： <p>
 99     * 返回：void <p>
100     * 作者：luoc
101     * 日期：2005-6-22
102     **/
103     private void buildRoot()
104     {
105         root=doc.getDocumentElement();
106     }
107      
108     /**
109      * @return 返回 doc。
110      */
111     public Document getDoc()
112     {
113         return doc;
114     }
115     /**
116      * @param doc 要设置的 doc。
117      */
118     public void setDoc(Document doc)
119     {
120         this.doc = doc;
121     }
122     /**
123      * @return 返回 path。
124      */
125     public String getPath()
126     {
127         return path;
128     }
129     /**
130      * @param path 要设置的 path。
131      */
132     public void setPath(String path)
133     {
134         this.path = path;
135     }
136     /**
137      * @return 返回 root。
138      */
139     public Element getRoot()
140     {
141         return root;
142     }
143     /**
144      * @param root 要设置的 root。
145      */
146     public void setRoot(Element root)
147     {
148         this.root = root;
149     }
150     /*全局变量*/
151     private String path=null;//xml文件路径
152     private Document doc=null;//xml文件对应的document
153     private Element root=null;//xml文件的根结点
154     private Logger logger=Logger.getLogger(getClass().getName());
155 }

  1 XmlOper.java
  2  
  3  用于操作ＸＭＬ文件，包括查找、新增、删除、修改结点
  4  
  5  /********************************************************************
  6  * 项目名称    ：rochoc   <p>
  7  * 包名称      ：rochoc.xml.oper <p>
  8  * 文件名称    ：XmlOper   <p>
  9  * 编写者     ：luoc    <p>
 10  * 编写日期    ：2005-6-22    <p>
 11  * 程序功能（类）描述 ： 对XML进行读写操作      <p>
 12  *
 13  * 程序变更日期   ：
 14  * 变更作者    ：
 15  * 变更说明    ：
 16 ********************************************************************/
 17 package rochoc.xml.oper;
 18  
 19 import java.util.ArrayList;
 20  
 21 import org.apache.log4j.Logger;
 22 import org.w3c.dom.Document;
 23 import org.w3c.dom.Element;
 24 import org.w3c.dom.Node;
 25 import org.w3c.dom.NodeList;
 26  
 27 /**
 28  * 类名：XmlOper  <p>
 29  * 类描述：对XML文件进行读写操作,均为静态函数 <p>
 30  * 编写者 ：luoc<p>
 31  * 编写日期 ：2005-6-22<p>
 32  * 主要public成员变量：<p>
 33  * 主要public方法：   <p>
 34  **/
 35  
 36 public class XmlOper
 37 {
 38     /**
 39      *构造函数说明：       <p>
 40      *参数说明：   <p>
 41     **/
 42     private XmlOper()
 43     {       
 44     }
 45      
 46     /**
 47     * 方法名称：getNodeList<p>
 48     * 方法功能：获取父结点parent的所有子结点<p>
 49     * 参数说明：@param parent
 50     * 参数说明：@return <p>
 51     * 返回：NodeList <p>
 52     * 作者：luoc
 53     * 日期：2005-6-22
 54     **/
 55     public static NodeList getNodeList(Element parent)
 56     {
 57         return parent.getChildNodes();
 58     }
 59      
 60     /**
 61     * 方法名称：getElementsByName<p>
 62     * 方法功能：在父结点中查询指定名称的结点集            <p>
 63     * 参数说明：@param parent
 64     * 参数说明：@param name
 65     * 参数说明：@return <p>
 66     * 返回：Element[] <p>
 67     * 作者：luoc
 68     * 日期：2005-6-22
 69     **/
 70     public static Element [] getElementsByName(Element parent,String name)
 71     {
 72         ArrayList resList=new ArrayList();
 73         NodeList nl=getNodeList(parent);
 74         for(int i=0;i<nl.getLength();i++)
 75         {
 76             Node nd=nl.item(i);
 77             if(nd.getNodeName().equals(name))
 78             {
 79                 resList.add(nd);
 80             }
 81         }
 82         Element [] res=new Element [resList.size()];
 83         for(int i=0;i<resList.size();i++)
 84         {
 85             res[0]=(Element)resList.get(i);
 86         }       
 87         logger.debug(parent.getNodeName()+"‘s children of "+name+
 88                 "‘s num:"+res.length);
 89         return res;
 90     }
 91      
 92     /**
 93     * 方法名称：getElementName<p>
 94     * 方法功能：获取指定Element的名称            <p>
 95     * 参数说明：@param element
 96     * 参数说明：@return <p>
 97     * 返回：String <p>
 98     * 作者：luoc
 99     * 日期：2005-6-22
100     **/
101     public static String getElementName(Element element)
102     {
103         return element.getNodeName();
104     }
105      
106     /**
107     * 方法名称：getElementValue<p>
108     * 方法功能：获取指定Element的值<p>
109     * 参数说明：@param element
110     * 参数说明：@return <p>
111     * 返回：String <p>
112     * 作者：luoc
113     * 日期：2005-6-22
114     **/
115     public static String getElementValue(Element element)
116     {
117         NodeList nl=element.getChildNodes();
118         for(int i=0;i<nl.getLength();i++)
119         {
120             if(nl.item(i).getNodeType()==Node.TEXT_NODE)//是一个Text Node
121             {           
122                 logger.debug(element.getNodeName()+" has a Text Node.");
123                 return element.getFirstChild().getNodeValue();
124             }
125         }  
126         logger.error(element.getNodeName()+" hasn‘t a Text Node.");
127         return null;
128     }
129      
130     /**
131     * 方法名称：getElementAttr<p>
132     * 方法功能：获取指定Element的属性attr的值            <p>
133     * 参数说明：@param element
134     * 参数说明：@param attr
135     * 参数说明：@return <p>
136     * 返回：String <p>
137     * 作者：luoc
138     * 日期：2005-6-22
139     **/
140     public static String getElementAttr(Element element,String attr)
141     {
142         return element.getAttribute(attr);
143     }
144      
145     /**
146     * 方法名称：setElementValue<p>
147     * 方法功能：设置指定Element的值            <p>
148     * 参数说明：@param element
149     * 参数说明：@param val <p>
150     * 返回：void <p>
151     * 作者：luoc
152     * 日期：2005-6-22
153     **/
154     public static void setElementValue(Element element,String val)
155     {
156         Node node=element.getOwnerDocument().createTextNode(val);
157         NodeList nl=element.getChildNodes();
158         for(int i=0;i<nl.getLength();i++)
159         {
160             Node nd=nl.item(i);
161             if(nd.getNodeType()==Node.TEXT_NODE)//是一个Text Node
162             {           
163                   nd.setNodeValue(val);
164                   logger.debug("modify "+element.getNodeName()+"‘s node value succe.");
165                   return;
166             }
167         }  
168         logger.debug("new "+element.getNodeName()+"‘s node value succe.");
169         element.appendChild(node);       
170     }
171      
172     /**
173     * 方法名称：setElementAttr<p>
174     * 方法功能：设置结点Element的属性<p>
175     * 参数说明：@param element
176     * 参数说明：@param attr
177     * 参数说明：@param attrVal <p>
178     * 返回：void <p>
179     * 作者：luoc
180     * 日期：2005-6-22
181     **/
182     public static void setElementAttr(Element element,
183             String attr,String attrVal)
184     {
185         element.setAttribute(attr,attrVal);
186     }
187      
188      
189     /**
190     * 方法名称：addElement<p>
191     * 方法功能：在parent下增加结点child<p>
192     * 参数说明：@param parent
193     * 参数说明：@param child <p>
194     * 返回：void <p>
195     * 作者：luoc
196     * 日期：2005-6-22
197     **/
198     public static void addElement(Element parent,Element child)
199     {
200         parent.appendChild(child);
201     }
202      
203     /**
204     * 方法名称：addElement<p>
205     * 方法功能：在parent下增加字符串tagName生成的结点<p>
206     * 参数说明：@param parent
207     * 参数说明：@param tagName <p>
208     * 返回：void <p>
209     * 作者：luoc
210     * 日期：2005-6-22
211     **/
212     public static void addElement(Element parent,String tagName)
213     {       
214         Document doc=parent.getOwnerDocument();
215         Element child=doc.createElement(tagName);
216         parent.appendChild(child);
217     }
218      
219     /**
220     * 方法名称：addElement<p>
221     * 方法功能：在parent下增加tagName的Text结点，且值为text<p>
222     * 参数说明：@param parent
223     * 参数说明：@param tagName
224     * 参数说明：@param text <p>
225     * 返回：void <p>
226     * 作者：luoc
227     * 日期：2005-6-22
228     **/
229     public static void addElement(Element parent,String tagName,String text)
230     {
231         Document doc=parent.getOwnerDocument();
232         Element child=doc.createElement(tagName);
233         setElementValue(child,text);
234         parent.appendChild(child);
235     }
236      
237     /**
238     * 方法名称：removeElement<p>
239     * 方法功能：将父结点parent下的名称为tagName的结点移除<p>
240     * 参数说明：@param parent
241     * 参数说明：@param tagName <p>
242     * 返回：void <p>
243     * 作者：luoc
244     * 日期：2005-6-22
245     **/
246     public static void removeElement(Element parent,String tagName)
247     {
248         logger.debug("remove "+parent.getNodeName()+"‘s children by tagName "+tagName+" begin...");
249         NodeList nl=parent.getChildNodes();
250         for(int i=0;i<nl.getLength();i++)
251         {
252             Node nd=nl.item(i);
253             if(nd.getNodeName().equals(tagName))
254             {
255                 parent.removeChild(nd);
256                 logger.debug("remove child ‘"+nd+"‘ success.");
257             }
258         }
259         logger.debug("remove "+parent.getNodeName()+"‘s children by tagName "+tagName+" end.");
260     }
261      
262      
263     /*全局变量*/   
264     static Logger logger=Logger.getLogger("XmlOper");
265 }

  1 XmlCreater.java
  2  
  3  用于创建ＸＭＬ文件
  4  
  5 /********************************************************************
  6  * 项目名称    ：rochoc   <p>
  7  * 包名称      ：rochoc.xml.oper <p>
  8  * 文件名称    ：XmlCreater   <p>
  9  * 编写者     ：luoc    <p>
 10  * 编写日期    ：2005-6-22    <p>
 11  * 程序功能（类）描述 ： 创建DOM并生成XML文件      <p>
 12  *
 13  * 程序变更日期   ：
 14  * 变更作者    ：
 15  * 变更说明    ：
 16 ********************************************************************/
 17 package rochoc.xml.oper;
 18  
 19 import java.io.File;
 20  
 21 import javax.xml.parsers.DocumentBuilder;
 22 import javax.xml.parsers.DocumentBuilderFactory;
 23 import javax.xml.parsers.ParserConfigurationException;
 24 import javax.xml.transform.Transformer;
 25 import javax.xml.transform.TransformerConfigurationException;
 26 import javax.xml.transform.TransformerException;
 27 import javax.xml.transform.TransformerFactory;
 28 import javax.xml.transform.dom.DOMSource;
 29 import javax.xml.transform.stream.StreamResult;
 30  
 31 import org.apache.log4j.Logger;
 32 import org.w3c.dom.Document;
 33 import org.w3c.dom.Element;
 34  
 35 /**
 36  * 类名：XmlCreater  <p>
 37  * 类描述： 创建DOM并生成XML文件<p>
 38  * 编写者 ：luoc<p>
 39  * 编写日期 ：2005-6-22<p>
 40  * 主要public成员变量：<p>
 41  * 主要public方法：   <p>
 42  **/
 43  
 44 public class XmlCreater
 45 {
 46     /**
 47      *构造函数说明：       <p>
 48      *参数说明：@param path  xml文件路径 <p>
 49     **/
 50     public XmlCreater(String path)
 51     {
 52         this.path=path;
 53         init();
 54     }
 55      
 56     /**
 57     * 方法名称：init<p>
 58     * 方法功能： 初始化函数           <p>
 59     * 参数说明： <p>
 60     * 返回：void <p>
 61     * 作者：luoc
 62     * 日期：2005-6-22
 63     **/
 64     private void init()
 65     {
 66         DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
 67         try
 68         {
 69             DocumentBuilder builder=factory.newDocumentBuilder();
 70             doc=builder.newDocument();//新建DOM
 71         }catch(ParserConfigurationException e)
 72         {
 73             logger.error("Parse DOM builder error:"+e);
 74         }
 75     }
 76      
 77     /**
 78     * 方法名称：createRootElement<p>
 79     * 方法功能：创建根结点，并返回            <p>
 80     * 参数说明：@param rootTagName <p>
 81     * 返回：Element <p>
 82     * 作者：luoc
 83     * 日期：2005-6-22
 84     **/
 85     public Element createRootElement(String rootTagName)
 86     {    
 87         if(doc.getDocumentElement()==null)
 88         {
 89             logger.debug("create root element ‘"+rootTagName+"‘ success.");
 90             Element root=doc.createElement(rootTagName);
 91             doc.appendChild(root);
 92             return root;
 93         }
 94         logger.warn("this dom‘s root element is exist,create fail.");
 95         return doc.getDocumentElement();
 96     }
 97      
 98     /**
 99     * 方法名称：createElement<p>
100     * 方法功能：在parent结点下增加子结点tagName<p>
101     * 参数说明：@param parent
102     * 参数说明：@param tagName <p>
103     * 返回：Element <p>
104     * 作者：luoc
105     * 日期：2005-6-22
106     **/
107     public Element createElement(Element parent,String tagName)
108     {
109         Document doc=parent.getOwnerDocument();
110         Element child=doc.createElement(tagName);
111         parent.appendChild(child);       
112         return child;
113     }
114      
115     /**
116     * 方法名称：createElement<p>
117     * 方法功能：在parent结点下增加值为value的子结点tabName<p>
118     * 参数说明：@param parent
119     * 参数说明：@param tagName
120     * 参数说明：@param value <p>
121     * 返回：Element <p>
122     * 作者：luoc
123     * 日期：2005-6-22
124     **/
125     public Element createElement(Element parent,String tagName,String value)
126     {
127         Document doc=parent.getOwnerDocument();
128         Element child=doc.createElement(tagName);
129         XmlOper.setElementValue(child,value);
130         parent.appendChild(child);
131         return child;
132     }
133      
134     /**
135     * 方法名称：createAttribute<p>
136     * 方法功能：在parent结点下增加属性 <p>
137     * 参数说明：@param parent
138     * 参数说明：@param attrName 属性名
139     * 参数说明：@param attrValue 属性值<p>
140     * 返回：void <p>
141     * 作者：luoc
142     * 日期：2005-6-22
143     **/
144     public void createAttribute(Element parent,String attrName,String attrValue)
145     {
146         XmlOper.setElementAttr(parent,attrName,attrValue);       
147     }
148      
149     /**
150     * 方法名称：buildXmlFile<p>
151     * 方法功能：根据DOM生成XML文件<p>
152     * 参数说明： <p>
153     * 返回：void <p>
154     * 作者：luoc
155     * 日期：2005-6-22
156     **/
157     public void buildXmlFile()
158     {
159         TransformerFactory tfactory=TransformerFactory.newInstance();
160         try
161         {
162             Transformer transformer=tfactory.newTransformer();
163             DOMSource source=new DOMSource(doc);
164             logger.debug("New DOMSource success.");
165             StreamResult result=new StreamResult(new File(path));
166             logger.debug("New StreamResult success.");
167             transformer.setOutputProperty("encoding","GBK");
168             transformer.transform(source,result);
169             logger.debug("Build XML File ‘"+path+"‘ success.");
170         }catch(TransformerConfigurationException e)
171         {
172             logger.error("Create Transformer error:"+e);
173         }catch(TransformerException e)
174         {
175             logger.error("Transformer XML file error:"+e);
176         }
177     }
178      
179     /**
180      * @return 返回 doc。
181      */
182     public Document getDoc()
183     {
184         return doc;
185     }
186     /**
187      * @param doc 要设置的 doc。
188      */
189     public void setDoc(Document doc)
190     {
191         this.doc = doc;
192     }
193     /**
194      * @return 返回 path。
195      */
196     public String getPath()
197     {
198         return path;
199     }
200     /**
201      * @param path 要设置的 path。
202      */
203     public void setPath(String path)
204     {
205         this.path = path;
206     }
207     /*全局变量*/
208     private Logger logger = Logger.getLogger(getClass().getName());
209     private Document doc=null;//新创建的DOM
210     private String path=null;//生成的XML文件绝对路径
211 }