立即登录 马上注册
首页 › 开发帮助文档 › 编程语言 › java 如何使用org.w3c.dom操作XML文件

赞

评论

收藏

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

编程语言 编程语言 发布于：2021-11-11 14:35 | 阅读数：468 | 评论：0

这篇文章主要介绍了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文件绝对路径
}
以上为个人经验，希望能给大家一个参考，也希望大家多多支持CodeAE代码之家。
原文链接：https://blog.csdn.net/sky_ground/article/details/51697754

关注下面的标签，发现更多相似文章
免责声明：

1. 本站所有资源来自网络搜集或用户上传，仅作为参考不担保其准确性！

2. 本站内容仅供学习和交流使用，版权归原作者所有！© 查看更多

3. 如有内容侵害到您，请联系我们尽快删除，邮箱：kf@codeae.com

分享到： QQ好友和群QQ好友和群 QQ空间QQ空间

举报

返回列表
相关帖子
avatar
3426 经验
3424 文档
OPNE在线字典
  • 手机版| 免责声明|
2021-2024  版权所有：CodeAE代码之家   
粤ICP备2023096576号-2