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

骑猪看日落 2021-09-10 09:32 121阅读 0赞

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 plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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>

<!ELEMENT classes (java班,net班,php班,ios班)>
    <!ELEMENT java班 (teachers?,students?)>
    <!ELEMENT net班 (teachers?,students?)>
    <!ELEMENT php班 (teachers?,students?)>
    <!ELEMENT ios班 (teachers?,students?)>
    <!ELEMENT teachers (teacher*)>
    <!ELEMENT teacher EMPTY>
    <!ELEMENT students (student*)>
    <!ELEMENT student (name,sex,age)>
    <!ATTLIST java班 name CDATA #IMPLIED>
    <!ATTLIST net班 name CDATA #IMPLIED>
    <!ATTLIST php班 name CDATA #IMPLIED>
    <!ATTLIST ios班 name CDATA #IMPLIED>
    <!ATTLIST teacher name CDATA #IMPLIED>
    <!ATTLIST teacher sex CDATA #IMPLIED>
    <!ATTLIST teacher age CDATA #IMPLIED>
    <!ELEMENT name (#PCDATA)>
    <!ELEMENT sex (#PCDATA)>
    <!ELEMENT age (#PCDATA)>
    <!ATTLIST student id ID #IMPLIED>

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

**\[html\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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.       
18.     <net班 name="CSDNNet01班">xxx</net班>  
19.     <php班 name="CSDNPhp01班"></php班>  
20.     <ios班 name="CSDNIos01班"></ios班>  
21. </classes>  
22.   
23.

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE classes SYSTEM "bin//parsers//java.dtd">
    <classes>
    	<java班 name="CSDNJava01班">
    		<teachers>
    			<teacher name="军哥" sex="男" age="28" />
    			<teacher name="刘丽华" sex="女" age="28" />
    		</teachers>
    		<students>
    			<student id="x121">
    				<name>王亮</name>
    				<sex>女</sex>
    				<age>28</age>
    			</student>
    		</students>
    	</java班>
    	
    	<net班 name="CSDNNet01班">xxx</net班>
    	<php班 name="CSDNPhp01班"></php班>
    	<ios班 name="CSDNIos01班"></ios班>
    </classes>

3.遍历xml文件的操作

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

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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.     \}

@Test
    	public void test() throws ParserConfigurationException, SAXException, IOException{
    		//调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂
    		DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
    		//调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象
    		DocumentBuilder builder =  builderFactory.newDocumentBuilder();
    		//通过文件的方式获取Document对象
    		/*File file = new File("src//parsers//java.xml");
    		System.out.println(file+"----");
    		Document document = builder.parse(file);*/
    		//解析指定的文件
    		InputStream is= this.getClass().getClassLoader()
                                  .getResourceAsStream("parsers//java.xml");
    		Document document = builder.parse(is);
    	    
    	    //document.getDocumentElement()获取根节点的元素对象
    		Element root = document.getDocumentElement();
    		//遍历根节点下面的所有子节点
    		listNodes(root);
    	}

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

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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.     \}

/**
    	 * 遍历根据节点对象下面的所有的节点对象
    	 * @param node
    	 */
    	public void listNodes(Node node) {
    		// 节点是什么类型的节点
    		if (node.getNodeType() == Node.ELEMENT_NODE) {// 判断是否是元素节点
    			Element element = (Element) node;
    			//判断此元素节点是否有属性
    			if(element.hasAttributes()){
    				//获取属性节点的集合
    				NamedNodeMap namenm = 	element.getAttributes();//Node
    				//遍历属性节点的集合
    			    for(int k=0;k<namenm.getLength();k++){
    			    	//获取具体的某个属性节点
    			    	Attr attr = (Attr) namenm.item(k);
    			    	System.out.println("name:::"+attr.getNodeName()+" value::"
                                         +attr.getNodeValue()+"  type::"+attr.getNodeType());
    			    }
    			}
    			//获取元素节点的所有孩子节点
    			NodeList listnode = element.getChildNodes();
    			//遍历
    			for (int j = 0; j < listnode.getLength(); j++) {
    				//得到某个具体的节点对象
    				Node nd = listnode.item(j);
    				System.out.println("name::" + nd.getNodeName() + "  value:::"
    						+ nd.getNodeValue() + "  type:::" + nd.getNodeType());
    				//重新调用遍历节点的操作的方法
    				listNodes(nd);
    			}
    
    		}
    	}

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

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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. \}

/**
    	 * 根据标签的名称查找所有该名称的节点对象
    	 */
    	public void findNode(Document document) {
    		//根据标签名称获取该名称的所有节点对象
    		NodeList nodelist = document.getElementsByTagName("teacher");
    		//遍历
    		for (int i = 0; i < nodelist.getLength(); i++) {
    			//得到具体的某个节点对象
    			Node node = nodelist.item(i);
    			System.out.println(node.getNodeName());
    		}
    	}
    
    	/**
    	 * 根据属性的值 查询某个节点对象
    	 * 属性值是唯一（假设）
    	 * @param document
    	 * @param value
    	 * @return
    	 */
    	public Node findNodeByAttrValue(Document document, String value) {
    		//根据标签名称获取该名称的节点对象集合
    		NodeList nodelist = document.getElementsByTagName("teacher");
    		//遍历
    		for (int i = 0; i < nodelist.getLength(); i++) {
    			//获取某个具体的元素节点对象
    			Element node = (Element) nodelist.item(i);
    			//根据属性名称获取该节点的属性节点对象
    			Attr attr = node.getAttributeNode("name");
    			//获取属性节点的值是否给指定的节点属性值相同
    			if (attr.getNodeValue().equals(value)) {
    				//返回此节点
    				return node;
    			}
    		}
    		return null;
    	}
    
    	/**
    	 * 根据id获取某个节点对象
    	 * 
    	 * @param document
    	 * @param id
    	 * @return
    	 */
    	public Node findNodeById(Document document, String id) {
    		return document.getElementById(id);
    	}

5.删除指定的节点对象

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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.     \}

/**
    	 * 删除某个节点对象
    	 * 
    	 * @param document
    	 * @param id
    	 * @throws TransformerException
    	 */
    	public void deleteNodeById(Document document, String id)
    			throws TransformerException {
    		//获取删除的节点对象
    		Node node = document.getElementById(id);
    		// 是通过父节点调用removeChild(node)把子节点给删除掉
    		Node node1 = node.getParentNode().removeChild(node);
    		
    		//创建TransformerFactory对象
    		TransformerFactory transformerFactory = TransformerFactory
    				.newInstance();
    		//Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出
    		//Transformer对象通过TransformerFactory获得
    		Transformer transformer = transformerFactory.newTransformer();
    		// 把Document对象又重新写入到一个XML文件中。
    		transformer.transform(new DOMSource(document), new StreamResult(
    				new File("src//a.xml")));
    	}

6.更新某个节点对象

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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. \}

/**
    	 * 更新某个节点
    	 * 
    	 * @param document
    	 * @param id
    	 * @throws TransformerException
    	 */
    	public void updateNodeById(Document document, String id)
    			throws TransformerException {
    		//根据id获取元素指定的元素节点对象
    		Element node = document.getElementById(id);
    		//获取元素节点的id属性节点对象
    		Attr attr = node.getAttributeNode("id");
    		//修改元素节点的属性值
    		attr.setValue("x122");
    
    		//获取该节点对象的所有孩子节点对象name、age、sex节点
    		NodeList nodelist = node.getChildNodes();
            //遍历
    		for (int i = 0; i < nodelist.getLength(); i++) {
    			//得到具体的节点对象
    			Node n = nodelist.item(i);
    			//判断是否是元素节点对象
    			if (n.getNodeType() == Node.ELEMENT_NODE) {
    				//看是否是name节点
    				if (n.getNodeName().equals("name")) {
    					n.setTextContent("君君");//修改其值
    				} else if (n.getNodeName().equals("age")) {//看看是否是age节点
    					n.setTextContent("80");//修改其值
    				} else if (n.getNodeName().equals("sex")) {//看看是否是sex节点
    					n.setTextContent("男");//修改其值
    				} else {
    					System.out.println("不做处理");
    				}
    			}
    		}
    
    		//创建TransformerFactory对象
    		TransformerFactory transformerFactory = TransformerFactory
    				.newInstance();
    		//Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出
    		//Transformer对象通过TransformerFactory获得
    		Transformer transformer = transformerFactory.newTransformer();
    		//把Document对象又重新写入到一个XML文件中。
    		transformer.transform(new DOMSource(document), new StreamResult(
    				new File("src//b.xml")));
    	}

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

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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. \}

/**
    	 * 在指定的节点下方添加新得某个节点
    	 * 
    	 * @param document
    	 * @param id
    	 * @throws TransformerException
    	 */
    	public void addNodeById(Document document, String id)
    			throws TransformerException {
    		//获取要添加位置节点的兄弟节点对象
    		Element node = document.getElementById(id);
    		//获取其父节点对象
    		Node parentNode = node.getParentNode();
    		//创建元素节点
    		Element nd = document.createElement("student");
    		//设置元素节点的属性值
    		nd.setAttribute("id", "x123");
    		//创建name元素节点
    		Node name = document.createElement("name");
    		//设置name节点的文本值
    		name.appendChild(document.createTextNode("陈红军"));
    		//创建age元素节点
    		Node age = document.createElement("age");
    		//设置age节点的文本值
    		age.appendChild(document.createTextNode("20"));
    		//创建sex元素节点
    		Node sex = document.createElement("sex");
    		//设置sex节点的文本值
    		sex.appendChild(document.createTextNode("男"));
    		//在nd节点中添加3个子节点
    		nd.appendChild(name);
    		nd.appendChild(age);
    		nd.appendChild(sex);
    		//在父节点中添加nd节点
    		parentNode.appendChild(nd);
    
    		//创建TransformerFactory对象
    		TransformerFactory transformerFactory = TransformerFactory
    				.newInstance();
    		//Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出
    		//Transformer对象通过TransformerFactory获得
    		Transformer transformer = transformerFactory.newTransformer();
    		//把Document对象又重新写入到一个XML文件中。
    		transformer.transform(new DOMSource(document), new StreamResult(
    				new File("src//c.xml")));
    	}

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

[view plain]: http://blog.csdn.net/redarmy_chen/article/details/12912065#