9.XML文件解析

一.xml文件的引入

1.1 创建Student.java类

 1 package com.entity;
 2 /**
 3  * 1.创建学生类
 4  * @author pc
 5  *
 6  */
 7 public class Student {
 8     private int id;
 9     private String name;
10     private String course;
11     private int score;
12
13     public Student() {
14     }
15     public Student(int id, String name, String course, int score) {
16         this.id = id;
17         this.name = name;
18         this.course = course;
19         this.score = score;
20     }
21     public int getId() {
22         return id;
23     }
24     public void setId(int id) {
25         this.id = id;
26     }
27     public String getName() {
28         return name;
29     }
30     public void setName(String name) {
31         this.name = name;
32     }
33     public String getCourse() {
34         return course;
35     }
36     public void setCourse(String course) {
37         this.course = course;
38     }
39     public int getScore() {
40         return score;
41     }
42     public void setScore(int score) {
43         this.score = score;
44     }
45     @Override
46     public String toString() {
47         return "Student [course=" + course + ", id=" + id + ", name=" + name
48                 + ", score=" + score + "]";
49     }
50
51
52
53 }

Student.java

1.2 创建测试类Test.java

 1 package com.entity;
 2
 3 public class Test {
 4
 5     /**
 6      * @param args
 7      */
 8     public static void main(String[] args) {
 9       Student mengmeng=new Student(1, "许萌", "java", 98);
10       Student zhangfujun=new Student(2, "张福军", "java", 98);
11      System.out.println(mengmeng);
12      System.out.println(zhangfujun);
13     }
14
15 }

Test.java

1.3 对象映射到xml文件Student.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <students>
 3   <student id="1">
 4     <name>许萌</name>
 5     <course>java</course>
 6     <score>98</score>
 7   </student>
 8   <student id="2">
 9     <name>张福军</name>
10     <course>mysql</course>
11     <score>98</score>
12   </student>
13 </students>

Student.xml

二.DtD的创建

声明DTD:<!DOCTYPE 根元素 [定义内容]>
定义dtd元素标签节点:<!ELEMENT 标签名 元素类型>
定义dtd元素标签属性:<!ATTLIST 元素名称 属性名称 属性类型 属性默认值>
ELEMENT 定义标签节点
ATTLIST 定义标签属性
CDATA 表示属性类型是字符数据
#REQUIRED 属性值是必须的
#IMPLIED 属性值不是必须的
#FIXED 属性值是固定的
(|)给元素分组
A|B 必须选择A或B
A,B 表示A和B按照顺序出现
A* 表示A出现0到n次
A? 表示A出现0到1次
A+ 表示A出现一次或n次

案例：创建school.xml文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE 学校[
 3 <!ELEMENT 学校 (班级+)>
 4 <!ELEMENT 班级 (名称?,教师+)>
 5 <!ELEMENT 名称 (#PCDATA)>
 6 <!ELEMENT 教师 (#PCDATA)>
 7 ]>
 8 <学校>
 9   <班级>
10      <名称>淘宝31</名称>
11      <教师>徐娟</教师>
12      <教师>Holly</教师>
13   </班级>
14 </学校>

school.xml

三.DOM解析xml文件

3.1 案例使用DOM读取xml文件

3.1.1 在项目根目录下创建book.xml

1 <?xml version="1.0" encoding="UTF-8"?>
2 <books>
3     <book id="bk1001">
4         <title>三国演义</title>
5         <author>罗贯中</author>
6         <price>30元</price>
7     </book>
8 </books>

book.xml

3.1.2 在com.dom包下下创建DomTest.java

 1 package com.dom;
 2
 3 import java.io.IOException;
 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.Node;
11 import org.w3c.dom.NodeList;
12 import org.xml.sax.SAXException;
13
14 /**
15  * 1.使用dom读取xml文件=解析xml文件
16  * @author pc
17  *
18  */
19 public class DomTest {
20     public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
21         //1.得到DOM解析器工厂实例
22         DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
23         //2.从DOM解析器工厂获取DOM解析器
24         DocumentBuilder db=dbf.newDocumentBuilder();
25         //3.读取book.xml文件,转换DOM树(book.xml文件必须放在项目根目录下)
26         Document doc=db.parse("book.xml");
27         //4.从DOM树中获取所有根节点列表
28         NodeList allbooks=doc.getChildNodes();
29         //5.获取图书节点books
30         Node booksNode=allbooks.item(0);
31         //6.获取的books图书节点下的所有子节点列表book
32         NodeList books=booksNode.getChildNodes();
33         //7.循环遍历子节点列表信息
34         for (int i = 0; i < books.getLength(); i++) {
35             //7.1获取第i个book节点元素
36             Node book =books.item(i);
37             //7.2获取book节点下的所有元素节点
38             NodeList items=book.getChildNodes();
39             //7.3循环遍历book节点下的所有元素节点
40             for (int j = 0; j < items.getLength(); j++) {
41                 //7.3.1 获取book节点下的某个元素节点
42                 Node node=items.item(j);
43                 //7.3.2 获取元素节点的名称
44                 String nodeName=node.getNodeName();
45                 //7.3.3 获取元素节点的内容
46                 String nodeConent=node.getTextContent();
47                 //7.3.4判断节点名称获取对应的节点内容
48                 if(nodeName.equals("title")){
49                     System.out.println("书名:"+nodeConent);
50                 }else if(nodeName.equals("author")){
51                     System.out.println("作者:"+nodeConent);
52                 }else if(nodeName.equals("price")){
53                     System.out.println("价格:"+nodeConent);
54                 }
55
56             }
57
58         }
59
60
61     }
62
63 }

DomTest.java

3.2 案例使用DOM对xml文件增删改查

3.2.1 在项目根目录下创建student.xml

 1 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 <students>
 3     <student id="1">
 4         <name>许萌</name>
 5         <course>java</course>
 6         <score>98</score>
 7     </student>
 8     <student id="2">
 9         <name>张福军</name>
10         <course>mysql</course>
11         <score>98</score>
12     </student>
13 </students>

Student.xml

3.2.2 在com.dom包下下创建DomTest2.java

  1 package com.dom;
  2
  3 import java.io.FileOutputStream;
  4 import java.io.IOException;
  5
  6 import javax.print.Doc;
  7 import javax.xml.parsers.DocumentBuilder;
  8 import javax.xml.parsers.DocumentBuilderFactory;
  9 import javax.xml.parsers.ParserConfigurationException;
 10 import javax.xml.transform.OutputKeys;
 11 import javax.xml.transform.Transformer;
 12 import javax.xml.transform.TransformerConfigurationException;
 13 import javax.xml.transform.TransformerException;
 14 import javax.xml.transform.TransformerFactory;
 15 import javax.xml.transform.dom.DOMSource;
 16 import javax.xml.transform.stream.StreamResult;
 17
 18 import org.w3c.dom.Document;
 19 import org.w3c.dom.Element;
 20 import org.w3c.dom.Node;
 21 import org.w3c.dom.NodeList;
 22 import org.xml.sax.SAXException;
 23
 24 /**
 25  * dom4j对xml文件全套增删改查
 26  *
 27  * @author pc
 28  *
 29  */
 30 public class DomTest2 {
 31     public static void main(String[] args) throws ParserConfigurationException,
 32             SAXException, IOException, TransformerException {
 33         //add();
 34         update();
 35         delete();
 36         select();
 37
 38     }
 39
 40     private static void select() throws ParserConfigurationException,
 41             SAXException, IOException {
 42         // 1.创建dom解析器工厂
 43         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 44         // 2.从dom工厂获取DOM解析器
 45         DocumentBuilder db = dbf.newDocumentBuilder();
 46         // 3.读取student.xml文件,转换为DOM数,该文在必须在项目根目录
 47         Document doc = db.parse("Student.xml");
 48         // 4.从DOM中获取所有根节点列表students
 49         NodeList studentsList = doc.getChildNodes();
 50         // 5.获取第一个根节点studens
 51         Node studentsNode = studentsList.item(0);
 52         // 6.从第一个根节点下获取所有的student子节点列表
 53         NodeList studentList = studentsNode.getChildNodes();
 54         // 7.循环遍历student子节点
 55         for (int i = 0; i < studentList.getLength(); i++) {
 56             // 7.1 获取某个student节点
 57             Node student = studentList.item(i);
 58             // 7.2 获取student节点下所有元素节点列表(name,course,score)
 59             NodeList items = student.getChildNodes();
 60             // 7.3 循环student节点下的所有元素节点
 61             for (int j = 0; j < items.getLength(); j++) {
 62                 // 7.3.1 获取某个元素节点(name,course,score)
 63                 Node node = items.item(j);
 64                 // 7.3.2 获取某个元素节点名称
 65                 String nodeName = node.getNodeName();
 66                 // 7.3.3 获取某个元素节点的内容
 67                 String nodeContent = node.getTextContent();
 68                 // 7.3.4 判断根据元素节点名称获取对应元素节点内容
 69                 if (nodeName.equals("name")) {
 70                     System.out.println("姓名:" + nodeContent);
 71                 } else if (nodeName.equals("course")) {
 72                     System.out.println("课程:" + nodeContent);
 73                 } else if (nodeName.equals("score")) {
 74                     System.out.println("成绩:" + nodeContent);
 75                 }
 76             }
 77
 78         }
 79
 80     }
 81
 82     private static void add() throws ParserConfigurationException,
 83             SAXException, IOException, TransformerException {
 84         // 1.创建dom解析器工厂
 85         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 86         // 2.从dom工厂获取DOM解析器
 87         DocumentBuilder db = dbf.newDocumentBuilder();
 88         // 3.读取student.xml文件,转换为DOM数,该文在必须在项目根目录
 89         Document doc = db.parse("Student.xml");
 90         // 4.创建Student节点
 91         Element studentElement = doc.createElement("student");
 92         // 5.为Student节点设置属性
 93         studentElement.setAttribute("id", "3");
 94         // 6.创建name元素节点
 95         Element nameElement = doc.createElement("name");
 96         // 7.为name元素节点添加内容
 97         nameElement.setTextContent("陈金锋");
 98         // 8.将name元素节点放入Student节点
 99         studentElement.appendChild(nameElement);
100         // 9.创建course元素节点
101         Element courseElement=doc.createElement("course");
102         // 10.为course元素节点添加内容
103         courseElement.setTextContent("JSP");
104         // 11.将course元素节点添加到Student节点内
105         studentElement.appendChild(courseElement);
106         // 12.创建score元素节点
107         Element scoreElement=doc.createElement("score");
108         // 13.为score元素节点添加内容
109         scoreElement.setTextContent("90");
110         // 14.将score元素节点添加到Student节点内
111         studentElement.appendChild(scoreElement);
112         // 15.获取Students根节点(根据节点名获取整个节点)
113         Element studentsElement=(Element) doc.getElementsByTagName("students").item(0);
114         // 16.将student节点放入Students根节点中
115         studentsElement.appendChild(studentElement);
116         // 17.创建添加节点工厂对象
117         TransformerFactory transformerFactory=TransformerFactory.newInstance();
118         // 18.根据添加节点工厂对象创建添加节点对象
119         Transformer transformer=transformerFactory.newTransformer();
120         // 19.将整个节点放入内存
121         DOMSource domSource=new DOMSource(doc);
122         // 20.设置编码类型
123         transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
124         // 21.创建输出流对象,并执行写入路径
125         StreamResult result=new StreamResult(new FileOutputStream("Student.xml"));
126         // 22.添加节点对象将内存中dom写入文件
127         transformer.transform(domSource, result);
128         System.out.println("添加成功!!");
129     }
130
131     private static void update() throws ParserConfigurationException, SAXException, IOException, TransformerException {
132         //1.获取dom解析器工厂对象
133         DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
134         //2.从DOM解析器工厂获取dom解析器
135         DocumentBuilder db=dbf.newDocumentBuilder();
136         //3.读取Student.xml,生成DOM树
137         Document doc=db.parse("Student.xml");
138         //4.找到修改的节点所在集合
139         NodeList studentList=doc.getElementsByTagName("student");
140         //5.循环遍历修改节点所在集合
141         for (int i = 0; i < studentList.getLength(); i++) {
142             //5.1.获取某个student节点
143             Element studentElement=(Element) studentList.item(i);
144             //5.2 获取Student节点的id属性值
145             String studentId=studentElement.getAttribute("id");
146             //5.3判断Student节点的id值是否是要修改的id为3的节点
147             if(studentId.equals("3")){
148                 //5.3.1 获取修改的Student节点下的Score元素节点
149                Element scoreElement=(Element) studentElement
150                .getElementsByTagName("score").item(0);
151                 //5.3.2  修改score节点文本内容
152                scoreElement.setTextContent("60");
153                System.out.println("update is success!");
154             }
155         }
156         //6.创建添加节点工厂对象
157         TransformerFactory transformerFactory=TransformerFactory.newInstance();
158         //7.根据添加节点工厂对象创建添加节点对象
159         Transformer transformer=transformerFactory.newTransformer();
160         //8.将dom放入内存中
161         DOMSource domSource=new DOMSource(doc);
162         //9.设置编码类型
163         transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
164         //10.创建输出流并指定写入路径
165         StreamResult result=new StreamResult(new FileOutputStream("Student.xml"));
166         //11.根据添加节点对象将内存中dom树,写入xml文件
167         transformer.transform(domSource, result);
168     }
169
170     private static void delete() throws ParserConfigurationException, SAXException, IOException, TransformerException {
171         //1.创建dom解析器工厂
172         DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
173         //2.根据dom解析器工厂创建dom解析器
174         DocumentBuilder db=dbf.newDocumentBuilder();
175         //3.读取xml文件,并生成dom树
176         Document doc=db.parse("Student.xml");
177         //4.找到所有的student节点集合
178         NodeList studentList=doc.getElementsByTagName("student");
179         //5.循环找出要删除的student节点
180         for (int i = 0; i < studentList.getLength(); i++) {
181             //5.1 获取某个student节点
182             Element studentElement=(Element) studentList.item(i);
183             //5.2 获取某个student节点的id属性
184             String studentid=studentElement.getAttribute("id");
185             //5.3 判断id属性值是否是我们要找的id值
186             if(studentid.equals("3")){
187                 //5.3.1 删除student的id为某个值的整个student节点
188                 studentElement.getParentNode()
189                 .removeChild(studentElement);
190                 System.out.println("delete is success!!");
191             }
192
193         }
194         //6.创建添加节点工厂对象
195         TransformerFactory transformerFactory=TransformerFactory.newInstance();
196         //7.根据添加节点工厂对象创建添加节点对象
197         Transformer transformer=transformerFactory.newTransformer();
198         //8.将dom放入内存中
199         DOMSource domSource=new DOMSource(doc);
200         //9.设置编码类型
201         transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
202         //10.创建输出流并指定写入路径
203         StreamResult result=new StreamResult(new FileOutputStream("Student.xml"));
204         //11.根据添加节点对象将内存中dom树,写入xml文件
205         transformer.transform(domSource, result);
206
207     }
208
209 }

DomTest2.java

四.使用DOM4j操作xml文件

4.1.2 在com.dom4j包下下创建DOM4jParse.java

 1 package com.dom4j;
 2
 3 import java.io.File;
 4 import java.util.HashMap;
 5 import java.util.Iterator;
 6
 7 import org.dom4j.Document;
 8 import org.dom4j.DocumentException;
 9 import org.dom4j.Element;
10 import org.dom4j.io.SAXReader;
11
12 /**
13  * 使用DOM4j解析xml文件
14  * @author Holly老师
15  *
16  */
17 public class DOM4jParse {
18     public static void main(String[] args) throws DocumentException {
19         //1.创建HashMap集合,存放解析后的内容
20         HashMap<String, String> hashMap=new HashMap<String, String>();
21         //2.获取xml文件所在的路径(System.getProperty("user.dir")=项目真实路径)
22         String xmlPath=System.getProperty("user.dir")+"\\Student.xml";
23         /*3.解析xml文件内容到map集合
24         *(参数分为输入参数和输出参数,)
25         *输入参数可以是任意类型,
26         *输出参数只能是引用类型
27         */
28         dom4jParseXml(xmlPath,hashMap);
29         //4.循环遍历map集合打印内容
30         for (int i = 0; i < hashMap.size(); i+=3) {
31             int j=i/3; //第一个student节点
32             System.out.print(hashMap.get("name"+j)+"\t");
33             System.out.print(hashMap.get("course"+j)+"\t");
34             System.out.println(hashMap.get("score"+j)+"\t");
35         }
36
37     }
38    /**
39     *
40     * @param xmlPath xml文件路径
41     * @param hashMap
42  * @throws DocumentException
43     */
44     private static void dom4jParseXml(String xmlPath,
45             HashMap<String, String> hashMap) throws DocumentException {
46         //1.创建读取xml文件的对象(xml输入流对象)
47         SAXReader saxReader=new SAXReader();
48         //2.创建文件流指定读取路径
49         File file=new File(xmlPath);
50         //3.在指定路径中读取xml文件并转换为dom树
51         Document document =saxReader.read(file);
52         //4.获取xml文档的根节点
53         Element root=document.getRootElement();
54         //5.定义用于记录学生编号的变量
55         int num=-1;
56         //6.获取根元素students下的所有的student放入迭代器集合
57         Iterator studentList=root.elementIterator();
58         //7.循环student标签集合
59         while(studentList.hasNext()){
60             //获取某个student节点标签
61             Element studentElement=(Element) studentList.next();
62             num++;
63             //获取student标签下的所有元素节点的集合
64             Iterator studentContentList=studentElement.elementIterator();
65             //循环获取student标签下元素节点内容
66             while(studentContentList.hasNext()){
67                 //获取student标签下的某个元素节点
68                 Element studentContent=(Element) studentContentList.next();
69                 //循环将读取到的元素节点内容放入hashmap中(getName()获取标签名,getText()标签文本内容)
70                 hashMap.put(studentContent.getName()+num, studentContent.getText());
71             }
72         }
73
74     }
75
76 }

DOM4jParse.java