java xml解析之dom解析

java语言本身支持DOM，可以直接查找属性与子节点，过程大致如下：

1、通过工厂类创建对象，可以通过该对象创建文本对象

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

2.通过工厂类的对象（dbf ）创建文档对象，该对象可以映射操作xml文件

DocumentBuilder docum = dbf.newDocumentBuilder();
Document doc = docum.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("MyXML/Student.xml"));

3.获取文档中的所有节点，实现后面的对属性、值得获取

NodeList nodelist = doc.getElementsByTagName("student");//这里的“student”为要获取节点的名称,返回的是节点的集合

4.遍历每个节点，获取节点的属性和节点的子节点，实现对应的操作。

例子：

先定义个一个xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<students>
	<student score="23">
		<name>"张三"</name>
		<id>1003</id>
		<sex>女</sex>
	</student>
	
	<student score="24">
		<name>"李四"</name>
		<id>1004</id>
		<sex>男</sex>
	</student>
	
	<student id="1005">
		<name>"张五"</name>
		<score>25</score>
		<sex>男</sex>
	</student>

</students>

再定义一个Students类

public class Students {
	private int id;
	private int socre;
	private String name;
	private String sex;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getSocre() {
		return socre;
	}
	public void setSocre(int socre) {
		this.socre = socre;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Students [id=" + id + ", socre=" + socre + ", name=" + name + ", sex=" + sex + "]";
	}	
}

最后进行XML解析

import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
//dom解析 
public class DomParse {
	public static void main(String[] args) throws Exception {
		//使用工厂类创建对象
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		//使用工厂类的对象创建文档对象，该对象映射操作xml文件
		DocumentBuilder docum = dbf.newDocumentBuilder();	
		Document doc = docum.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("MyXML/Student.xml"));
		//获取文档中所有的student节点,返回的是节点的集合
		NodeList nodelist = doc.getElementsByTagName("student");
		//定义List集合以便存储Srudents对象
		List<Students>list = new ArrayList<Students>();
		for(int i=0;i<nodelist.getLength();i++) {
			//新建Student对象以便存储XML文件信息
			Students stu = new Students();
			//使用item()遍历每个节点
			Node it = nodelist.item(i);
			//获取节点的属性，返回的是属性的集合
			NamedNodeMap att = it.getAttributes();
			//遍历每一个属性，如果与Student的属性相对应，则在stu中存入对应属性的值
			for(int j = 0;j<att.getLength();j++) {
				Node property = att.item(j);
				//getNodeName()获取属性的名称
				if("id".equals(property.getNodeName())) {
					//getTextContent()获取属性对应的名字
					stu.setId(Integer.parseInt(property.getTextContent()));
				}
				if("sex".equals(property.getNodeName())) {
					stu.setSex(property.getTextContent());
				}
				if("score".equals(property.getNodeName())) {
					stu.setSocre(Integer.parseInt(property.getTextContent()));
				}
				if("name".equals(property.getNodeName())) {
					stu.setName((property.getTextContent()));
				}				
			}
			//获取节点的子节点，返回子节点的集合。
			NodeList childNodes = it.getChildNodes();
			//遍历子节点，如果与该节点名称与Student的属性相对应，则在stu中存入对应的值
			for(int k=0;k<childNodes.getLength();k++) {
				Node item = childNodes.item(k);
				if("id".equals(item.getNodeName())) {
					stu.setId(Integer.parseInt(item.getTextContent()));
				}
				if("sex".equals(item.getNodeName())) {
					stu.setSex(item.getTextContent());
				}
				if("score".equals(item.getNodeName())) {
					stu.setSocre(Integer.parseInt(item.getTextContent()));
				}
				if("name".equals(item.getNodeName())) {
					stu.setName((item.getTextContent()));
				}
			}
			//向集合中添加该对象
			list.add(stu);
		}
		//遍历集合输出测试
		for(Students s:list) {
			System.out.println(s);
		}
	}	
}

运行结果

总结：

优点: ①易于使用

②丰富的API集合，可用于轻松地导航

③整棵树加载到内存，允许对XML文档进行随机访问

缺点:①整个XML文档必须一次解析完

②将整棵树加载到内存成本较高

③一般的DOM节点对于必须为所有节点创建对象的对象类型绑定不太理想

最适合于:需要修改XML文档的应用程序或XSLT应用程序(不可用于只读XML的应用程序)

java xml解析之dom解析

猜你喜欢