首页 > 代码库 > Java学习之道：使用JAXP进行DOM解析（ DocumentBuilderFactory、DocumentBuilder、Document)

Java学习之道：使用JAXP进行DOM解析（ DocumentBuilderFactory、DocumentBuilder、Document)

2024-07-17 08:22:50   220人阅读

1.javax.xml.parsers 包中的DocumentBuilderFactory用于创建DOM模式的解析器对象 ， DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法 ，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回

2.调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。
3.调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象。
4.调用 DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进行可以利用DOM特性对整个XML文档进行操作了。

案例1.遍历xml文件中跟节点下面的所有子节点.

1.xml的约束文件java.dtd

[html] view plaincopyprint?
  1. <!ELEMENT classes (java班,net班,php班,ios班)>  
  2. <!ELEMENT java班 (teachers?,students?)>  
  3. <!ELEMENT net班 (teachers?,students?)>  
  4. <!ELEMENT php班 (teachers?,students?)>  
  5. <!ELEMENT ios班 (teachers?,students?)>  
  6. <!ELEMENT teachers (teacher*)>  
  7. <!ELEMENT teacher EMPTY>  
  8. <!ELEMENT students (student*)>  
  9. <!ELEMENT student (name,sex,age)>  
  10. <!ATTLIST java班 name CDATA #IMPLIED>  
  11. <!ATTLIST net班 name CDATA #IMPLIED>  
  12. <!ATTLIST php班 name CDATA #IMPLIED>  
  13. <!ATTLIST ios班 name CDATA #IMPLIED>  
  14. <!ATTLIST teacher name CDATA #IMPLIED>  
  15. <!ATTLIST teacher sex CDATA #IMPLIED>  
  16. <!ATTLIST teacher age CDATA #IMPLIED>  
  17. <!ELEMENT name (#PCDATA)>  
  18. <!ELEMENT sex (#PCDATA)>  
  19. <!ELEMENT age (#PCDATA)>  
  20. <!ATTLIST student id ID #IMPLIED>  

2.xml文件内容如下java.xml

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE classes SYSTEM "bin//parsers//java.dtd">  
  3. <classes>  
  4.     <java班 name="CSDNJava01班">  
  5.         <teachers>  
  6.             <teacher name="军哥" sex="男" age="28" />  
  7.             <teacher name="刘丽华" sex="女" age="28" />  
  8.         </teachers>  
  9.         <students>  
  10.             <student id="x121">  
  11.                 <name>王亮</name>  
  12.                 <sex>女</sex>  
  13.                 <age>28</age>  
  14.             </student>  
  15.         </students>  
  16.     </java班>  
  17.     <!-- 注释0 -->  
  18.     <net班 name="CSDNNet01班">xxx</net班>  
  19.     <php班 name="CSDNPhp01班"></php班>  
  20.     <ios班 name="CSDNIos01班"></ios班>  
  21. </classes>  
  22. <!-- 对java.xml文件进行CRUD的操作 -->  
  23. <!-- 节点  
  24.         nodeName            nodeValue        nodeType  
  25. element  标签名               null             1  
  26. Attr     属性名              属性值            2  
  27. text     #text               文本的值          3  
  28.  -->  
3.遍历xml文件的操作

//1.获取XML的根节点对象

[java] view plaincopyprint?
  1. @Test  
  2.     public void test() throws ParserConfigurationException, SAXException, IOException{  
  3.         //调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂  
  4.         DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();  
  5.         //调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象  
  6.         DocumentBuilder builder =  builderFactory.newDocumentBuilder();  
  7.         //通过文件的方式获取Document对象  
  8.         /*File file = new File("src//parsers//java.xml"); 
  9.         System.out.println(file+"----"); 
  10.         Document document = builder.parse(file);*/  
  11.         //解析指定的文件  
  12.         InputStream is= this.getClass().getClassLoader()  
  13.                               .getResourceAsStream("parsers//java.xml");  
  14.         Document document = builder.parse(is);  
  15.           
  16.         //document.getDocumentElement()获取根节点的元素对象  
  17.         Element root = document.getDocumentElement();  
  18.         //遍历根节点下面的所有子节点  
  19.         listNodes(root);  
  20.     }  


//2.遍历节点对象的方法

[java] view plaincopyprint?
  1. /** 
  2.      * 遍历根据节点对象下面的所有的节点对象 
  3.      * @param node 
  4.      */  
  5.     public void listNodes(Node node) {  
  6.         // 节点是什么类型的节点  
  7.         if (node.getNodeType() == Node.ELEMENT_NODE) {// 判断是否是元素节点  
  8.             Element element = (Element) node;  
  9.             //判断此元素节点是否有属性  
  10.             if(element.hasAttributes()){  
  11.                 //获取属性节点的集合  
  12.                 NamedNodeMap namenm =   element.getAttributes();//Node  
  13.                 //遍历属性节点的集合  
  14.                 for(int k=0;k<namenm.getLength();k++){  
  15.                     //获取具体的某个属性节点  
  16.                     Attr attr = (Attr) namenm.item(k);  
  17.                     System.out.println("name:::"+attr.getNodeName()+" value::"  
  18.                                      +attr.getNodeValue()+"  type::"+attr.getNodeType());  
  19.                 }  
  20.             }  
  21.             //获取元素节点的所有孩子节点  
  22.             NodeList listnode = element.getChildNodes();  
  23.             //遍历  
  24.             for (int j = 0; j < listnode.getLength(); j++) {  
  25.                 //得到某个具体的节点对象  
  26.                 Node nd = listnode.item(j);  
  27.                 System.out.println("name::" + nd.getNodeName() + "  value:::"  
  28.                         + nd.getNodeValue() + "  type:::" + nd.getNodeType());  
  29.                 //重新调用遍历节点的操作的方法  
  30.                 listNodes(nd);  
  31.             }  
  32.   
  33.         }  
  34.     }  

4.查询某个节点对象(简单列举一些案例)

[java] view plaincopyprint?
  1. /** 
  2.  * 根据标签的名称查找所有该名称的节点对象 
  3.  */  
  4. public void findNode(Document document) {  
  5.     //根据标签名称获取该名称的所有节点对象  
  6.     NodeList nodelist = document.getElementsByTagName("teacher");  
  7.     //遍历  
  8.     for (int i = 0; i < nodelist.getLength(); i++) {  
  9.         //得到具体的某个节点对象  
  10.         Node node = nodelist.item(i);  
  11.         System.out.println(node.getNodeName());  
  12.     }  
  13. }  
  14.   
  15. /** 
  16.  * 根据属性的值 查询某个节点对象 
  17.  * 属性值是唯一（假设） 
  18.  * @param document 
  19.  * @param value 
  20.  * @return 
  21.  */  
  22. public Node findNodeByAttrValue(Document document, String value) {  
  23.     //根据标签名称获取该名称的节点对象集合  
  24.     NodeList nodelist = document.getElementsByTagName("teacher");  
  25.     //遍历  
  26.     for (int i = 0; i < nodelist.getLength(); i++) {  
  27.         //获取某个具体的元素节点对象  
  28.         Element node = (Element) nodelist.item(i);  
  29.         //根据属性名称获取该节点的属性节点对象  
  30.         Attr attr = node.getAttributeNode("name");  
  31.         //获取属性节点的值是否给指定的节点属性值相同  
  32.         if (attr.getNodeValue().equals(value)) {  
  33.             //返回此节点  
  34.             return node;  
  35.         }  
  36.     }  
  37.     return null;  
  38. }  
  39.   
  40. /** 
  41.  * 根据id获取某个节点对象 
  42.  *  
  43.  * @param document 
  44.  * @param id 
  45.  * @return 
  46.  */  
  47. public Node findNodeById(Document document, String id) {  
  48.     return document.getElementById(id);  
  49. }  

5.删除指定的节点对象

[java] view plaincopyprint?
  1. /** 
  2.      * 删除某个节点对象 
  3.      *  
  4.      * @param document 
  5.      * @param id 
  6.      * @throws TransformerException 
  7.      */  
  8.     public void deleteNodeById(Document document, String id)  
  9.             throws TransformerException {  
  10.         //获取删除的节点对象  
  11.         Node node = document.getElementById(id);  
  12.         // 是通过父节点调用removeChild(node)把子节点给删除掉  
  13.         Node node1 = node.getParentNode().removeChild(node);  
  14.           
  15.         //创建TransformerFactory对象  
  16.         TransformerFactory transformerFactory = TransformerFactory  
  17.                 .newInstance();  
  18.         //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出  
  19.         //Transformer对象通过TransformerFactory获得  
  20.         Transformer transformer = transformerFactory.newTransformer();  
  21.         // 把Document对象又重新写入到一个XML文件中。  
  22.         transformer.transform(new DOMSource(document), new StreamResult(  
  23.                 new File("src//a.xml")));  
  24.     }  

6.更新某个节点对象

[java] view plaincopyprint?
  1. /** 
  2.  * 更新某个节点 
  3.  *  
  4.  * @param document 
  5.  * @param id 
  6.  * @throws TransformerException 
  7.  */  
  8. public void updateNodeById(Document document, String id)  
  9.         throws TransformerException {  
  10.     //根据id获取元素指定的元素节点对象  
  11.     Element node = document.getElementById(id);  
  12.     //获取元素节点的id属性节点对象  
  13.     Attr attr = node.getAttributeNode("id");  
  14.     //修改元素节点的属性值  
  15.     attr.setValue("x122");  
  16.   
  17.     //获取该节点对象的所有孩子节点对象name、age、sex节点  
  18.     NodeList nodelist = node.getChildNodes();  
  19.        //遍历  
  20.     for (int i = 0; i < nodelist.getLength(); i++) {  
  21.         //得到具体的节点对象  
  22.         Node n = nodelist.item(i);  
  23.         //判断是否是元素节点对象  
  24.         if (n.getNodeType() == Node.ELEMENT_NODE) {  
  25.             //看是否是name节点  
  26.             if (n.getNodeName().equals("name")) {  
  27.                 n.setTextContent("君君");//修改其值  
  28.             } else if (n.getNodeName().equals("age")) {//看看是否是age节点  
  29.                 n.setTextContent("80");//修改其值  
  30.             } else if (n.getNodeName().equals("sex")) {//看看是否是sex节点  
  31.                 n.setTextContent("男");//修改其值  
  32.             } else {  
  33.                 System.out.println("不做处理");  
  34.             }  
  35.         }  
  36.     }  
  37.   
  38.     //创建TransformerFactory对象  
  39.     TransformerFactory transformerFactory = TransformerFactory  
  40.             .newInstance();  
  41.     //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出  
  42.     //Transformer对象通过TransformerFactory获得  
  43.     Transformer transformer = transformerFactory.newTransformer();  
  44.     //把Document对象又重新写入到一个XML文件中。  
  45.     transformer.transform(new DOMSource(document), new StreamResult(  
  46.             new File("src//b.xml")));  
  47. }  

7.在某个节点的下方添加新的节点

[java] view plaincopyprint?
  1. /** 
  2.  * 在指定的节点下方添加新得某个节点 
  3.  *  
  4.  * @param document 
  5.  * @param id 
  6.  * @throws TransformerException 
  7.  */  
  8. public void addNodeById(Document document, String id)  
  9.         throws TransformerException {  
  10.     //获取要添加位置节点的兄弟节点对象  
  11.     Element node = document.getElementById(id);  
  12.     //获取其父节点对象  
  13.     Node parentNode = node.getParentNode();  
  14.     //创建元素节点  
  15.     Element nd = document.createElement("student");  
  16.     //设置元素节点的属性值  
  17.     nd.setAttribute("id", "x123");  
  18.     //创建name元素节点  
  19.     Node name = document.createElement("name");  
  20.     //设置name节点的文本值  
  21.     name.appendChild(document.createTextNode("陈红军"));  
  22.     //创建age元素节点  
  23.     Node age = document.createElement("age");  
  24.     //设置age节点的文本值  
  25.     age.appendChild(document.createTextNode("20"));  
  26.     //创建sex元素节点  
  27.     Node sex = document.createElement("sex");  
  28.     //设置sex节点的文本值  
  29.     sex.appendChild(document.createTextNode("男"));  
  30.     //在nd节点中添加3个子节点  
  31.     nd.appendChild(name);  
  32.     nd.appendChild(age);  
  33.     nd.appendChild(sex);  
  34.     //在父节点中添加nd节点  
  35.     parentNode.appendChild(nd);  
  36.   
  37.     //创建TransformerFactory对象  
  38.     TransformerFactory transformerFactory = TransformerFactory  
  39.             .newInstance();  
  40.     //Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出  
  41.     //Transformer对象通过TransformerFactory获得  
  42.     Transformer transformer = transformerFactory.newTransformer();  
  43.     //把Document对象又重新写入到一个XML文件中。  
  44.     transformer.transform(new DOMSource(document), new StreamResult(  
  45.             new File("src//c.xml")));  
  46. }  

通过以上方法的练习希望你对xml的DOM解析有个入门的了解.


联系
我们