解析XML文件的几种常见操作方法—DOM/SAX/DOM4j

一直想学点什么东西，有些浮躁，努力使自己静下心来看点东西，哪怕是回顾一下知识。看到了xml解析，目前我还没用到过。但多了解一下，加深点记忆和理解也无害处，权当复习吧。

　　在此只写下常见的三种XML解析方法，即DOM解析、SAX解析、DOM4J解析。

　　先上一份xml文件，关于xml文件的格式和创建方法，在此不多说了。

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <root>
 3     <class name="class1">
 4         <student>
 5             <name>张三</name>
 6             <age>20</age>
 7             <sex>男</sex>
 8         </student>
 9         <student>
10             <name>Andy</name>
11             <age>22</age>
12             <sex>female</sex>
13         </student>
14     </class>
15     <class name="class2">
16         <student>
17             <name>李四</name>
18             <age>15</age>
19             <sex>男</sex>
20         </student>
21         <student>
22             <name>bigbang</name>
23             <age>21</age>
24             <sex>女</sex>
25         </student>
26     </class>
27 </root>

 

DOM解析是一种消耗内存的解析方法，它先将整个xml文档装入内存，然后顺序读取，解析也是有些复杂，具体的操作都在注释中，不多说了。

 1 import java.io.IOException;
 2 import java.util.ArrayList;
 3 import java.util.List;
 4 
 5 import javax.xml.parsers.DocumentBuilder;
 6 import javax.xml.parsers.DocumentBuilderFactory;
 7 import javax.xml.parsers.ParserConfigurationException;
 8 
 9 import org.w3c.dom.Document;
10 import org.w3c.dom.Element;
11 import org.w3c.dom.Node;
12 import org.w3c.dom.NodeList;
13 import org.xml.sax.SAXException;
14 
15 import com.entity.Student;
16 
17 public class DOMParse {
18 
19     private Student student;
20     private List<Student> students;
21 
22     public void pasre() {
23         students = new ArrayList<Student>();
24         try {
25             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
26             DocumentBuilder builder = dbf.newDocumentBuilder();
27             // 在此没有使用InputStream作为参数，直接引用文件路径。
28             Document doc = builder.parse("src/com/parseDom/test.xml");
29             // 获取整个document元素
30             Element element = doc.getDocumentElement();
31             // 获取所有<class>子节点
32             NodeList list = element.getElementsByTagName("class"); // <class>
33             // 遍历class子节点
34             for (int i = 0; i < list.getLength(); i++) {
35                 Element el = (Element) list.item(i);
36                 // 获取<student>节点
37                 NodeList stus = el.getElementsByTagName("student"); // <student>
38                 // 遍历student子节点
39                 for (int j = 0; j < stus.getLength(); j++) {
40                     /**
41                      * 获取student下所有子节点 此处有7个节点，分别是#text<name> #text<sex>
42                      * #text<age> #text
43                      * 对应的xml实际是<student>、<name>、#name、<sex>、#sex
44                      * 、<age>、#age这七个子节点
45                      * **/
46                     NodeList lis = stus.item(j).getChildNodes();
47                     // 每个student节点输出就是一个Student对象
48                     student = new Student();
49                     for (int k = 0; k < lis.getLength(); k++) {
50                         // 当元素为节点元素时（非textValue），对比后取值
51                         if (lis.item(k).getNodeType() == Node.ELEMENT_NODE) {
52                             if ("name".equals(lis.item(k).getNodeName())) { // <name>
53                                 student.setName(lis.item(k).getFirstChild().getNodeValue());
54                             }
55                             if ("sex".equals(lis.item(k).getNodeName())) { // <sex>
56                                 student.setSex(lis.item(k).getFirstChild().getNodeValue());
57                             }
58                             if ("age".equals(lis.item(k).getNodeName())) { // <age>
59                                 student.setAge(Integer.parseInt(lis.item(k).getFirstChild().getNodeValue()));
60                             }
61                         }
62                     }
63                     students.add(student);
64                 }
65             }
66 
67         } catch (ParserConfigurationException e) {
68             e.printStackTrace();
69         } catch (SAXException e) {
70             e.printStackTrace();
71         } catch (IOException e) {
72             e.printStackTrace();
73         } finally {
74             for (Student stus : students) {
75                 System.out.println(stus.getName() + "--" + stus.getSex() + "--" + stus.getAge());
76             }
77         }
78     }
79 
80     public static void main(String[] args) {
81         DOMParse domParse = new DOMParse();
82         domParse.pasre();
83     }
84 }

 

SAX解析方法如下，依然看注释说明。

 1 import java.io.IOException;
 2 import java.util.ArrayList;
 3 import java.util.List;
 4 
 5 import javax.xml.parsers.ParserConfigurationException;
 6 import javax.xml.parsers.SAXParser;
 7 import javax.xml.parsers.SAXParserFactory;
 8 
 9 import org.xml.sax.Attributes;
10 import org.xml.sax.SAXException;
11 import org.xml.sax.helpers.DefaultHandler;
12 
13 import com.entity.Student;
14 
15 public class SAXParse extends DefaultHandler{
16 
17     
18     private Student student;
19     private static List<Student> stus;
20     private String preTag=null;
21 
22     //①程序启动执行
23     @Override
24     public void startDocument() throws SAXException {
25             stus = new ArrayList<Student>();
26     }
27     
28     //② 开始遍历元素时
29     @Override
30     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
31         if("student".equals(qName)){
32             student = new Student();
33 //            student.setName(attributes.getValue(0));
34         }
35         preTag = qName;
36     }
37 
38     //④元素遍历结束
39     @Override
40     public void endElement(String uri, String localName, String qName) throws SAXException {
41         if("student".equals(qName)){
42             stus.add(student);
43             student = null;
44         }
45         preTag=null;
46     }
47 
48     //③ 遍历取值过程
49     @Override
50     public void characters(char[] ch, int start, int length) throws SAXException {
51         if(preTag!=null){
52             String content = new String(ch,start,length);
53             if("name".equals(preTag)){
54                 student.setName(content);
55             }
56             if("age".equals(preTag)){
57                 student.setAge(Integer.parseInt(content));
58             }
59             if("sex".equals(preTag)){
60                 student.setSex(content);
61             }
62         }
63     }
64 
65     public void fun(){
66         try {
67             SAXParserFactory factory =SAXParserFactory.newInstance();
68             SAXParser    parser = factory.newSAXParser();
69             SAXParse handler = new SAXParse();
70             parser.parse("src/com/parseDom/test.xml", handler);
71         } catch (ParserConfigurationException e) {
72             e.printStackTrace();
73         } catch (SAXException e) {
74             e.printStackTrace();
75         } catch (IOException e) {
76             e.printStackTrace();
77         }
78     }
79     
80     public static  List<Student> getStus(){
81         return stus;
82     }
83     
84     public static void main(String[] args) {
85         new SAXParse().fun();
86         for (Student stu : getStus()) {
87             System.out.println(stu.getName()+"--"+stu.getAge()+"--"+stu.getSex());
88         }
89     }
90 }

 

DOM4J的解析方法如下，需要注意的是它的Document类和Element类是DOM4J的jar包提供的，不要引用错了。

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 
 5 import org.dom4j.Document;
 6 import org.dom4j.DocumentException;
 7 import org.dom4j.Element;
 8 import org.dom4j.io.SAXReader;
 9 
10 import com.entity.Student;
11 
12 public class DOM4J {
13 
14     private Student student;
15     private List<Student> stus;
16     
17     @SuppressWarnings("unchecked")
18     public void parse(){
19         stus = new ArrayList<Student>();
20         try {
21             SAXReader reader = new SAXReader();
22             
23             //此处Document类和Element类均为DOM4j的jar包中的类
24             Document doc =  reader.read("src/com/parseDom/test.xml");
25             //获取根元素
26             Element root = doc.getRootElement();
27             //获取节点元素为"class"的迭代
28             Iterator<Element> classss = root.elementIterator("class");
29             while(classss.hasNext()){
30                 Element classs =classss.next();
31                 //获取节点元素为"student"的迭代
32                 Iterator<Element> students = classs.elementIterator("student");
33                 while (students.hasNext()) {
34                     //每一个student节点元素都包括一个student对象
35                     student = new Student();
36                     Element els = students.next();
37                     //根据节点元素取值
38                     student.setName(els.elementText("name"));
39                     student.setAge(Integer.parseInt(els.elementText("age")));
40                     student.setSex(els.elementText("sex"));
41                     stus.add(student);
42                 }
43             }
44         } catch (DocumentException e) {
45             e.printStackTrace();
46         } finally{
47             for (Student stu : stus) {
48                 System.out.println(stu.getName()+"++"+stu.getSex()+"++"+stu.getAge());
49             }
50         }
51     }
52     
53     
54     public static void main(String[] args) {
55         new DOM4J().parse();
56     }
57 }

最后的输出结果是：

1 张三++男++20
2 Andy++female++22
3 李四++男++15
4 bigbang++女++21

其实每个解析的方法差不多，代码量比较小，很好理解。每个方法都有自己的特点，具体使用要看使用的环境了。