java 如何使用org.w3c.dom操作XML文件

本篇介绍在java中，如何使用org.w3c.dom中的相关内容来操作xml文件。包括：

• 如何在内存中构建xml文件并写入磁盘；
• 如何从磁盘读取xml文件到内存；
• 如何添加注释，读取注释；
• 如何添加属性，读取属性；
• 如何添加子元素，读取子元素；

下面直接贴出样例代码：

import javax.xml.parsers.documentbuilder;
import javax.xml.parsers.documentbuilderfactory;
import javax.xml.parsers.parserconfigurationexception;
import javax.xml.transform.outputkeys;
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.w3c.dom.document;
import org.w3c.dom.element;
import org.w3c.dom.namednodemap;
import org.w3c.dom.node;
import org.w3c.dom.nodelist;
import java.io.bufferedreader;
import java.io.bufferedwriter;
import java.io.file;
import java.io.fileinputstream;
import java.io.filenotfoundexception;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstreamreader;
import java.io.outputstream;
import java.io.outputstreamwriter;
import java.lang.reflect.field;
import java.lang.reflect.method;
import java.lang.reflect.modifier;
import java.lang.reflect.type;
import java.util.arraylist;
import java.util.arrays;
import java.util.collections;
import java.util.date;
import java.util.hashset;
import java.util.linkedhashmap;
import java.util.linkedhashset;
import java.util.list;
import java.util.map;
import java.util.scanner;
import java.util.set;
public class xmlsample{
	private static void writexml(document document, string filepath) {
 
		transformerfactory transfactory = transformerfactory.newinstance();
		transformer transformer = null;
		try {
			string parent = new file(filepath).getparent();
			file pdir = new file(parent);
			if (!pdir.exists()) {
				pdir.mkdirs();
			}
			outputstream os = new fileoutputstream(new file(filepath));
			transformer = transfactory.newtransformer();
			transformer.setoutputproperty(outputkeys.indent, "yes");
			transformer.setoutputproperty(outputkeys.encoding, "utf-8");
			domsource source = new domsource();
			source.setnode(document);
			streamresult result = new streamresult();
			result.setoutputstream(os);
			transformer.transform(source, result);
			os.flush();
		} catch (transformerconfigurationexception e) {
			e.printstacktrace();
		} catch (transformerexception e) {
			e.printstacktrace();
		} catch (filenotfoundexception e) {
			e.printstacktrace();
		} catch (ioexception e) {
			e.printstacktrace();
		}
	}
 
	private static document readxml(string file) {
 
		try {
            // 得到dom解析器的工厂实例
			documentbuilderfactory dbfactory = documentbuilderfactory.newinstance();
            // 从dom工厂中获得dom解析器
			documentbuilder dbbuilder = dbfactory.newdocumentbuilder();
            // 把要解析的xml文档读入dom解析器
			document doc = dbbuilder.parse(file);
			return doc;
		} catch (exception e) {
			e.printstacktrace();
		}
		return null;
	}
 
	public static void showxmldetail() { 
		document document = readxml(mapperfilepath);
        // 获取标签名为"dataset"的元素
		node mapper = document.getelementsbytagname("dataset").item(0);
 
        // 下面依次读取dataset元素的每个子元素，每个子元素的标签名字为node
		for (int i = 0; i < mapper.getchildnodes().getlength(); i++) {
			node node = mapper.getchildnodes().item(i);
			string s = item.getnodename();
			if(s.tolowercase().equals("#comment")){
				system.out.println("这是注释内容: "+node.gettextcontent());
			}else if(s.tolowercase().equals("#text")){
				system.out.println("呐，这是标签之外的文本: "+node.gettextcontent());
			}else if ("node".equals(s)) {
				// 获取元素属性的值
				string column = item.getattributes().getnameditem("column").getnodevalue();
				string field = item.getattributes().getnameditem("property").getnodevalue();
			}else{
				// 其他的就不要了
			} 
		} 
	}
 
	public static void generatexml(){
		try {
			element root;
			set<string> set = new hashset<>();
			set.add("node");
			documentbuilderfactory factory = documentbuilderfactory.newinstance();
			factory.setnamespaceaware(true);
			documentbuilder documentbuilder = null;
			documentbuilder = factory.newdocumentbuilder();
			document document = documentbuilder.newdocument();
			root = document.createelement("dataset");
			document.appendchild(root);
			set.foreach(p -> {
				element element = document.createelement(p);
				element.setattribte("column","haha");
				element.setattribte("property","heihei");
				root.appendchild(element);
			});
			writexml(document, "d:/alltables.xml");
		} catch (parserconfigurationexception e) {
			e.printstacktrace();
		}
	}
}

java操作xml（使用org.w3c.dom）

一、创建dom

xmlbuilder.java
 
 用于创建ｄｏｍ，root结点 
/********************************************************************
 * 项目名称    ：rochoc   <p>
 * 包名称      ：rochoc.xml.oper <p>
 * 文件名称    ：xmlbuilder   <p>
 * 编写者     ：luoc    <p>
 * 编写日期    ：2005-6-22    <p>
 * 程序功能（类）描述 ： 根据传入的xml文件生成document和root结点<p>
 * 
 * 程序变更日期   ：
 * 变更作者    ：
 * 变更说明    ：
********************************************************************/
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>
 * 编写者 ：luoc<p>
 * 编写日期 ：2005-6-22<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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    public void init()
    {
        builddocument();
        buildroot();
    }
     
    /**
    * 方法名称：builddocument<p>
    * 方法功能：将xml文件生成document <p>
    * 参数说明： <p>
    * 返回：void <p>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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);
        }
    }
     
    /**
    * 方法名称：buildroot<p>
    * 方法功能：生成xml的根结点<p>
    * 参数说明： <p>
    * 返回：void <p>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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());
}

二、查找，插入，删除，修改

xmloper.java
 
 用于操作ｘｍｌ文件，包括查找、新增、删除、修改结点 
 /********************************************************************
 * 项目名称    ：rochoc   <p>
 * 包名称      ：rochoc.xml.oper <p>
 * 文件名称    ：xmloper   <p>
 * 编写者     ：luoc    <p>
 * 编写日期    ：2005-6-22    <p>
 * 程序功能（类）描述 ： 对xml进行读写操作      <p>
 * 
 * 程序变更日期   ：
 * 变更作者    ：
 * 变更说明    ：
********************************************************************/
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>
 * 编写者 ：luoc<p>
 * 编写日期 ：2005-6-22<p>
 * 主要public成员变量：<p>
 * 主要public方法：   <p>
 **/
 
public class xmloper
{
    /**
     *构造函数说明：       <p>
     *参数说明：   <p>
    **/
    private xmloper()
    {        
    }
     
    /**
    * 方法名称：getnodelist<p>
    * 方法功能：获取父结点parent的所有子结点<p>
    * 参数说明：@param parent
    * 参数说明：@return <p>
    * 返回：nodelist <p>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    public static nodelist getnodelist(element parent)
    {
        return parent.getchildnodes();
    }
     
    /**
    * 方法名称：getelementsbyname<p>
    * 方法功能：在父结点中查询指定名称的结点集            <p>
    * 参数说明：@param parent
    * 参数说明：@param name
    * 参数说明：@return <p>
    * 返回：element[] <p>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    public static string getelementname(element element)
    {
        return element.getnodename();
    }
     
    /**
    * 方法名称：getelementvalue<p>
    * 方法功能：获取指定element的值<p>
    * 参数说明：@param element
    * 参数说明：@return <p>
    * 返回：string <p>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    public static string getelementattr(element element,string attr)
    {
        return element.getattribute(attr);
    }
     
    /**
    * 方法名称：setelementvalue<p>
    * 方法功能：设置指定element的值            <p>
    * 参数说明：@param element
    * 参数说明：@param val <p>
    * 返回：void <p>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    public static void addelement(element parent,element child)
    {
        parent.appendchild(child);
    }
     
    /**
    * 方法名称：addelement<p>
    * 方法功能：在parent下增加字符串tagname生成的结点<p>
    * 参数说明：@param parent
    * 参数说明：@param tagname <p>
    * 返回：void <p>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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");
}

三、新建xml文件

xmlcreater.java
 
 用于创建ｘｍｌ文件 
/********************************************************************
 * 项目名称    ：rochoc   <p>
 * 包名称      ：rochoc.xml.oper <p>
 * 文件名称    ：xmlcreater   <p>
 * 编写者     ：luoc    <p>
 * 编写日期    ：2005-6-22    <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>
 * 编写者 ：luoc<p>
 * 编写日期 ：2005-6-22<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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    public void createattribute(element parent,string attrname,string attrvalue)
    {
        xmloper.setelementattr(parent,attrname,attrvalue);        
    }
     
    /**
    * 方法名称：buildxmlfile<p>
    * 方法功能：根据dom生成xml文件<p>
    * 参数说明： <p>
    * 返回：void <p>
    * 作者：luoc
    * 日期：2005-6-22
    **/
    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文件绝对路径
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。