XML基礎介紹【二】

XML基礎介紹【二】

一、schema約束
dtd語法： <!ELEMENT 元素名稱 約束>
schema符合xml的語法，xml語句。一個xml中能夠有多個schema，多個schema使用名稱空間區分（相似於java包名）
dtd裏面有PCDATA類型，可是在schema裏面能夠支持更多的數據類型
　　好比 年齡 只能是整數，在schema能夠直接定義一個整數類型
schema語法更加複雜，schema目前不能替代dtd

二、schema的快速入門

建立一個schema文件 後綴名是 .xsd
　根節點 <schema>
在schema文件裏面
　屬性 xmlns="http://www.w3.org/2001/XMLSchema"
　　- 表示當前xml文件是一個約束文件
targetNamespace="http://www.boom.cn/2015112401"
　　- 使用schema約束文件，直接經過這個地址引入約束文件
elementFormDefault="qualified"

步驟：
（1）看xml中有多少個元素
　　<element>
（2）看簡單元素和複雜元素
　若是複雜元素
　　<complexType>
　　　<sequence>
　　　　子元素
　　　</sequence>
　　</complexType>

（3）簡單元素，寫在複雜元素的
　　<element name="person">
　　　<complexType>
　　　　　<sequence>
　　　　　　<element name="name" type="string"></element>
　　　　　　<element name="age" type="int"></element>
　　　　　</sequence>
　　　</complexType>
　　</element>

（4）在被約束文件裏面引入約束文件
<person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　xmlns="http://www.boom.cn/2015112401"
　xsi:schemaLocation="http://www.boom.cn/2015112401 1.xsd">

　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　　-- 表示xml是一個被約束文件
　xmlns="http://www.boom.cn/2015112401"
　　-- 是約束文檔裏面 targetNamespace
　xsi:schemaLocation="http://www.boom.cn/2015112401 1.xsd">
　　-- targetNamespace 空格 約束文檔的地址路徑

<sequence>：表示元素的出現的順序
<all>: 元素只能出現一次
<choice>：元素只能出現其中的一個
maxOccurs="unbounded"： 表示元素的出現的次數 unbounded:無限次數
<any></any>:表示任意元素

能夠約束屬性
　寫在複雜元素裏面
　寫在　</complexType>以前
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
<attribute name="id1" type="int" use="required"></attribute>
　　- name: 屬性名稱
　　- type：屬性類型 int stirng
　　- use：屬性是否必須出現 required

複雜的schema約束
<company xmlns = "http://www.example.org/company"
　xmlns:dept="http://www.example.org/department"
　xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
　xsi:schemaLocation="http://www.example.org/company company.xsd http://www.example.org/department department.xsd" >

<employee age="30">
　　<!-- 部門名稱 -->
　　<dept:name>100</dept:name>
想要引入部門的約束文件裏面的name，使用部門的別名 detp:元素名稱
　　<!-- 員工名稱 -->
　　<name>王曉曉</name>
</employee>

e-code

三、sax解析的原理（********）
解析xml有兩種技術 dom 和sax

根據xml的層級結構在內存中分配一個樹形結構，把xml中標籤，屬性，文本封裝成對象

sax方式：事件驅動，邊讀邊解析。在javax.xml.parsers包裏面
SAXParser
　此類的實例能夠從 SAXParserFactory.newSAXParser() 方法得到
　　　- parse(File f, DefaultHandler dh)
　　　兩個參數
　　　　a. 第一個參數：xml的路徑
　　　　b. 事件處理器

SAXParserFactory
　　實例 newInstance() 方法獲得
 畫圖分析一下sax執行過程
* 當解析到開始標籤時候，自動執行startElement方法
* 當解析到文本時候，自動執行characters方法
* 當解析到結束標籤時候，自動執行endElement方法

四、使用jaxp的sax方式解析xml（**會寫***）
sax方式不能實現增刪改操做，只能作查詢操做
一、打印出整個文檔
步驟：
一、建立解析器工廠
二、建立解析器
三、執行Parser()方法，第一個參數xml路徑，第二個參數是 事件處理器
　　a. 建立一個類，繼承事件處理器的類，
　　b. 重寫裏面的三個方法
四、建立一個類，繼承事件處理器的類
五、重寫裏面的三個方法

二、獲取到全部的name元素的值
定義一個成員變量 flag= false
判斷開始方法是不是name元素，若是是name元素，把flag值設置成true
若是flag值是true，在characters方法裏面打印內容
當執行到結束方法時候，把flag值設置成false

三、獲取第一個name元素的值
定義一個成員變量 idx=1
在結束方法時候，idx+1 idx++
想要打印出第一個name元素的值，
　- 在characters方法裏面判斷，
　- 判斷flag=true 而且 idx==1，在打印內容
e-code

  1 package boom.jaxpsax;
  2 
  3 import javax.swing.text.DefaultCaret;
  4 import javax.xml.parsers.ParserConfigurationException;
  5 import javax.xml.parsers.SAXParser;
  6 import javax.xml.parsers.SAXParserFactory;
  7 
  8 import org.xml.sax.Attributes;
  9 import org.xml.sax.SAXException;
 10 import org.xml.sax.helpers.DefaultHandler;
 11 
 12 public class TestSax {
 13 
 14     /**
 15      * 打印不一樣元素的a.xml文檔
 16      * @param args
 17      * @throws SAXException 
 18      * @throws ParserConfigurationException 
 19      */
 20     public static void main(String[] args) throws Exception {
 21 //        一、建立解析器工廠
 22         SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
 23 //        二、建立解析器
 24         SAXParser saxParser = saxParserFactory.newSAXParser();
 25 //        三、執行Parser()方法
 26         saxParser.parse("src/a.xml", new MyDefault3());
 27 //        四、建立一個類，繼承事件處理器的類
 28 //        五、重寫裏面的三個方法
 29 
 30     }
 31 
 32 }
 33 //建立一個類，繼承事件處理器的類
 34 //一、打印整個a.xml文檔
 35 class MyDefault1 extends DefaultHandler{
 36 //    重寫startElement、characters、endElement的三個方法
 37     @Override
 38     public void startElement(String uri, String localName, String qName,
 39             Attributes attributes) throws SAXException {
 40         System.out.print("<"+qName+">");
 41     }
 42     
 43     @Override
 44     public void characters(char[] ch, int start, int length)
 45             throws SAXException {
 46         System.out.print(new String(ch,start,length));
 47     }
 48 
 49     @Override
 50     public void endElement(String uri, String localName, String qName)
 51             throws SAXException {
 52         System.out.print("</"+qName+">");
 53     }
 54     
 55 }
 56 
 57 //二、獲取全部的name元素值
 58 class MyDefault2 extends DefaultHandler{
 59 //    定義一個成員變量
 60     boolean flag = false;
 61     @Override
 62     public void startElement(String uri, String localName, String qName,
 63             Attributes attributes) throws SAXException {
 64 //        進行判斷qName是否爲name
 65         if ("name".equals(qName)){
 66             flag = true;
 67         }
 68     }
 69 
 70     @Override
 71     public void characters(char[] ch, int start, int length)
 72             throws SAXException {
 73 //        當flag值爲true時，表示解析到name值
 74         if (flag == true){
 75             System.out.println(new String(ch,start,length));
 76         }
 77     }
 78     
 79     @Override
 80     public void endElement(String uri, String localName, String qName)
 81             throws SAXException {
 82 //        flag設置成false,表示name元素結束
 83         if ("name".equals(qName)){
 84             flag = false;
 85         }
 86     }
 87     
 88 }
 89 
 90 //三、獲取第一個的name元素值
 91 class MyDefault3 extends DefaultHandler{
 92 //    定義一個成員變量
 93     boolean flag = false;
 94     int idx =1; 
 95     @Override
 96     public void startElement(String uri, String localName, String qName,
 97             Attributes attributes) throws SAXException {
 98 //        進行判斷qName是否爲name
 99         if ("name".equals(qName)){
100             flag = true;
101         }
102     }
103 
104     @Override
105     public void characters(char[] ch, int start, int length)
106             throws SAXException {
107 //        當flag值爲true時，表示解析到name值
108 //        索引是1
109         if (flag == true && idx == 1){
110             System.out.println(new String(ch,start,length));
111         }
112     }
113     
114     @Override
115     public void endElement(String uri, String localName, String qName)
116             throws SAXException {
117 //        flag設置成false,表示name元素結束
118         if ("name".equals(qName)){
119             flag = false;
120             idx++;
121         }
122     }
123     
124 }

View Code

五、使用dom4j解析xml
dom4j，是一個組織，針對xml解析，提供解析器 dom4j

dom4j不是javase的一部分，想要使用第一步須要怎麼作？
　導入dom4j提供jar包
　　　-- 建立一個文件夾 lib
　　　-- 複製jar包到lib下面，
　　　-- 右鍵點擊jar包，build path -- add to build path
　　　-- 看到jar包，變成奶瓶樣子，表示導入成功

獲得document
　SAXReader reader = new SAXReader();
　Document document = reader.read(url);
document的父接口是Node
　　若是在document裏面找不到想要的方法，到Node裏面去找

document裏面的方法 getRootElement() ：獲取根節點 返回的是Element

Element也是一個接口，父接口是Node
　- Element和Node裏面方法
　　　getParent()：獲取父節點
　　　addElement：添加標籤

　　　element(qname)
　　　　　表示獲取標籤下面的第一個子標籤
　　　　　qname：標籤的名稱
　　　elements(qname)
　　　　　獲取標籤下面是這個名稱的全部子標籤（一層）
　　　　　　qname：標籤名稱
　　　elements()
　　　　　獲取標籤下面的全部一層子標籤

六、使用dom4j查詢xml
* 解析是從上到下解析
* 查詢全部name元素裏面的值
一、建立解析器
二、獲得document
三、獲得根節點 getRootElement() 返回Element

四、獲得全部的p1標籤
　　* elements("p1") 返回list集合
　　* 遍歷list獲得每個p1
五、獲得name
　　* 在p1下面執行 element("name")方法 返回Element
六、獲得name裏面的值
　　* getText方法獲得值

*查詢第一個name元素的值
一、建立解析器
二、獲得document
三、獲得根節點
四、獲得第一個p1元素
　　* element("p1")方法 返回Element
五、獲得p1下面的name元素
　　* element("name")方法 返回Element
六、獲得name元素裏面的值
　　* getText方法

* 獲取第二個name元素的值
一、建立解析器
二、獲得document
三、獲得根節點
四、獲得全部的p1
　　* 返回 list集合
五、遍歷獲得第二個p1
　　* 使用list下標獲得 get方法，集合的下標從 0 開始，想要獲得第二個值，下標寫 1
六、獲得第二個p1下面的name
　　* element("name")方法 返回Element
七、獲得name的值
　　* getText方法

七、使用dom4j實現添加操做
* 在第一個p1標籤末尾添加一個元素 <sex>nv</sex>
步驟:
一、建立解析器
二、獲得document
三、獲得根節點
四、獲取到第一個p1
　　* 使用element方法
五、在p1下面添加元素
　　* 在p1上面直接使用 addElement("標籤名稱")方法 返回一個Element

六、在添加完成以後的元素下面添加文本
　　* 在sex上直接使用 setText("文本內容")方法
七、回寫xml
　　* 格式化 OutputFormat,使用 createPrettyPrint方法，表示一個漂亮的格式
　　* 使用類XMLWriter 直接new 這個類 ，傳遞兩個參數
　　　*** 第一個參數是xml文件路徑 new FileOutputStream("路徑")
　　　*** 第二個參數是格式化類的值

八、使用dom4j實如今特定位置添加元素
* 在第一個p1下面的age標籤以前添加 <school>ahszu.edu.cn</schlool>
步驟:
一、建立解析器
二、獲得document
三、獲得根節點
四、獲取到第一個p1
五、獲取p1下面的全部的元素
　　** elements()方法 返回 list集合

　　** 使用list裏面的方法，在特定位置添加元素
　　　　  ** 首先建立元素 在元素下面建立文本
　　　　　　- 使用DocumentHelper類方法createElement建立標籤
　　　　　　- 把文本添加到標籤下面 使用 setText("文本內容")方法

　　 ** list集合裏面的 add(int index, E element)
　　　　* - 第一個參數是 位置 下標，從0開始
　　　　* - 第二個參數是 要添加的元素
六、回寫xml

封裝的總結：
** 能夠對獲得document的操做和 回寫xml的操做，封裝成方法
** 也能夠把傳遞的文件路徑，封裝成一個常量
*** 好處：能夠提升開發速度，能夠提交代碼可維護性
　　- 好比想要修改文件路徑（名稱），這個時候只須要修改常量的值就能夠了，其餘代碼不須要作任何改變

九、使用dom4j實現修改節點的操做
* 修改第一個p1下面的age元素的值 <age>30</age>
步驟：
一、獲得document
二、獲得根節點，而後再獲得第一個p1元素
三、獲得第一個p1下面的age
　　element("")方法
四、修改值是 300
　　* * 使用setText("文本內容")方法
五、回寫xml

十、使用dom4j實現刪除節點的操做
* 刪除第一個p1下面的<school></school>元素
步驟：
一、獲得document
二、獲得根節點
三、獲得第一個p標籤
四、獲得第一個p下面的school元素

五、刪除（使用p1刪除school）
　　* 獲得school的父節點
　　　　- 第一種直接獲得p
　　　　- 使用方法 getParent方法獲得
　　* 刪除操做
　　　　- 在p上面執行remove方法刪除節點
六、回寫xml

十一、使用dom4j獲取屬性的操做
* 獲取第一個name裏面的屬性id1的值
步驟：
一、獲得document
二、獲得根節點
三、獲得第一個p元素
五、獲得p標籤下層級的name
六、獲得name裏面的屬性值
　　- name.attributeValue("id1");
　　- 在name上面執行這個方法，裏面的參數是屬性名稱

e-code【a.xml】

e-code【封裝工具類:Dom4jUtils】

 1 package boom.utils;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 import java.io.OutputStreamWriter;
 6 
 7 import org.dom4j.Document;
 8 import org.dom4j.DocumentException;
 9 import org.dom4j.io.OutputFormat;
10 import org.dom4j.io.SAXReader;
11 import org.dom4j.io.XMLWriter;
12 
13 public class Dom4jUtils {
14     public static final String PATH="src/a.xml";
15     // 返回document
16     public static  Document getDocument(String path){
17         try {
18         // 建立解析器
19         SAXReader reader = new SAXReader();
20         // 獲得document
21             Document document = reader.read(path);
22             return document;
23         } catch (Exception e) {
24             e.printStackTrace();
25         }
26         return null;
27     }
28     
29     // 回寫xml的方法
30     public static void xmlWriter(String path,Document document){
31         try {
32             OutputFormat format = OutputFormat.createPrettyPrint();
33             XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(path), format);
34             xmlWriter.write(document);
35             xmlWriter.close();
36         } catch (Exception e) {
37             e.printStackTrace();
38         }
39     }
40 }

View Code

e-code【dom4j.java】

  1 package boom.dom4j;
  2 
  3 import java.util.List;
  4 
  5 import org.dom4j.Document;
  6 import org.dom4j.DocumentHelper;
  7 import org.dom4j.Element;
  8 
  9 import boom.utils.Dom4jUtils;
 10 
 11 public class Dom4j {
 12 
 13     /**
 14      * dom4j常規操做
 15      * @param args
 16      * @throws Exception 
 17      */
 18     public static void main(String[] args) throws Exception{
 19         /**
 20          * 主函數調用方法
 21          */
 22 //        selectName();
 23 //        selectSingle();
 24 //        selectSecond();
 25 //        addSex();
 26 //        addAgeBefore();
 27 //        modifyAge();
 28 //        delSch();
 29         getValue();
 30         
 31     }
 32     /**
 33      *一、查詢a.xml中全部name的值
 34      * @throws Exception
 35      */
 36     public static void selectName() throws Exception{
 37         /*// 1. 建立解析器
 38         SAXReader reader = new SAXReader();
 39         // 2. 獲得document
 40         Document document = reader.read("src/a.xml");*/
 41         
 42         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
 43         // 3. 獲得根節點
 44         Element root = document.getRootElement();
 45         // 4. 獲得全部的p1 
 46         List<Element> list = root.elements("p");
 47         // 5. 遍歷list[加強for循環]
 48         for (Element element : list) {// element是每個p元素
 49             // 獲得p1下面的name元素
 50             Element name = element.element("name");
 51             // 6. 獲得name裏面的值
 52             String s = name.getText();
 53             System.out.println(s);
 54         }
 55         
 56     }
 57     /**
 58      *     
 59      *二、查詢第一個name元素的值
 60      * @throws Exception
 61      */
 62     public static void selectSingle() throws Exception{
 63         /*// 1. 建立解析器
 64         SAXReader reader = new SAXReader();
 65         // 2. 獲得document
 66         Document document = reader.read("src/a.xml");*/
 67         
 68         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
 69         // 3. 獲得根節點
 70         Element root = document.getRootElement();    
 71         // 4. 獲得第一個p標籤
 72         Element p = root.element("p");
 73         // 5. 獲得p1下面的name元素
 74         Element name = p.element("name");
 75         // 6. 獲得name元素裏面的值
 76         String s= name.getText();
 77         System.out.println(s);
 78     }
 79     /**
 80      *獲取第二個name元素的值
 81      * @throws Exception
 82      */
 83 
 84     public static void selectSecond() throws Exception{
 85         /*// 1. 建立解析器
 86         SAXReader reader = new SAXReader();
 87         // 2. 獲得document
 88         Document document = reader.read("src/a.xml");*/
 89         
 90         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
 91         // 3. 獲得根節點
 92         Element root = document.getRootElement();
 93          // 4. 獲得全部的p標籤
 94         List<Element> list = root.elements("p");
 95         // 5. 獲得第二個p標籤 list集合下標從0開始
 96         Element p = list.get(1);
 97         // 6. 獲得第二個p標籤下的name
 98         Element name = p.element("name");
 99         // 7. 獲得name元素裏面的值
100         String s = name.getText();
101         System.out.println(s);
102         
103     }
104     /**
105      * 四、在第一個p標籤末尾添加一個元素 <sex>nv</sex>
106      * @throws Exception
107      */
108     public static void addSex() throws Exception{
109         /*// 1. 建立解析器
110         SAXReader reader = new SAXReader();
111         // 2. 獲得document
112         Document document = reader.read("src/a.xml");*/
113         
114         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
115         // 3. 獲得根節點
116         Element root = document.getRootElement();
117         // 4. 獲得第一個p標籤
118         Element p = root.element("p");
119         // 5. 在p標籤下直接添加新的標籤元素sex
120         Element sex = p.addElement("sex");
121         // 6. 直接在sex新建立的元素下添加元素值
122         sex.addText("男");
123         
124         /*// 7. 回寫xml
125         OutputFormat format = OutputFormat.createPrettyPrint(); //createPrettyPrint能夠有縮進的效果
126         // OutputFormat format =OutputFormat.createCompactFormat();//createCompactFormat壓縮格式[一行顯示]
127         XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/a.xml"),format);
128         xmlWriter.write(document);// 返回document
129         xmlWriter.close();// 關閉流*/
130         
131         Dom4jUtils.xmlWriter(Dom4jUtils.PATH, document);
132     }
133     /**
134      * 五、使用dom4j實如今特定位置添加元素 
135      * // 在第一個p下面的age標籤以前添加 <school>ahszu.edu.cn</schlool>
136      * @throws Exception
137      */
138     public static void addAgeBefore() throws Exception{
139         /*// 1. 建立解析器
140         SAXReader reader = new SAXReader();
141         // 2. 獲得document
142         Document document = reader.read("src/a.xml");*/
143         
144         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
145         // 3. 獲得根節點
146         Element root = document.getRootElement();
147         // 4. 獲得第一個p標籤
148         Element p = root.element("p");
149         // 5. 獲得p標籤下的全部元素
150         List<Element> list = p.elements();
151         // 6. 建立一個新標籤
152         Element school = DocumentHelper.createElement("school");
153         // 7. 在school下面建立文本
154         school.setText("安徽宿州學院");
155         // 8. 在特定的位置添加
156         list.add(1, school);
157         
158         /*// 9. 回寫xml
159         OutputFormat format =OutputFormat.createPrettyPrint(); // createPrettyPrint 能夠有縮進的效果
160 //        OutputFormat format =OutputFormat.createCompactFormat();// createCompactFormat壓縮格式[一行顯示]
161         XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/a.xml"), format);
162         xmlWriter.write(document);// 返回document
163         xmlWriter.close();// 關閉流*/
164         Dom4jUtils.xmlWriter(Dom4jUtils.PATH, document);
165     }
166     /**
167      * 六、使用dom4j實現修改節點的操做
168      * 修改第一個p下面的age元素的值 <age>30</age>
169      * @throws Exception
170      */
171     public static void modifyAge() throws Exception{
172         // 獲得document
173         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
174         // 獲得根節點
175         Element root =  document.getRootElement();
176         // 獲得第一個p標籤
177         Element p = root.element("p");
178         // 獲得p標籤下的age標籤
179         Element age = p.element("age");
180         // 修改age值爲30
181         age.setText("300");
182         // 回寫xml文檔
183         Dom4jUtils.xmlWriter(Dom4jUtils.PATH, document);
184     }
185     /**
186      * 七、使用dom4j實現刪除節點的操做
187      * 刪除第一個p1下面的<school></school>元素
188      * @throws Exception
189      */
190     public static void delSch() throws Exception{
191         // 獲得document
192         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
193         // 獲得根節點
194         Element root = document.getRootElement();
195         // 獲得第一個p元素
196         Element p = root.element("p");
197         // 獲得p標籤的school元素
198         Element school = p.element("school");
199         // 刪除school(經過父節點進行刪除)[school.getParent(); // 獲取school父節點]
200         p.remove(school); // 已獲得元素，直接在p標籤上執行remove方法
201         // 回寫xml文件
202         Dom4jUtils.xmlWriter(Dom4jUtils.PATH, document);
203     }
204     /**
205      * 八、使用dom4j獲取屬性的操做
206      * 獲取第一個name裏面的屬性id的值
207      * @throws Exception
208      */
209     public static void getValue() throws Exception{
210         // 獲得document
211         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
212         // 獲得根節點
213         Element root = document.getRootElement();
214         // 獲得第一個p元素[若是獲取p標籤下面的name，繼續層級獲取元素。]
215         Element p = root.element("p");
216         // 獲得p標籤下層級的name
217         Element name = p.element("name");
218         // 獲得name的屬性值
219         String stringId = name.attributeValue("id");
220         System.out.println("stringId="+stringId);
221     }
222 
223 }

View Code

十二、使用dom4j支持xpath的操做
* 能夠直接獲取到某個元素

* 第一種形式
　　/AAA/DDD/BBB： 表示一層一層的，AAA下面 DDD下面的BBB
* 第二種形式
　　//BBB： 表示和這個名稱相同，表示只要名稱是BBB，都獲得
* 第三種形式
　　/*: 全部元素
* 第四種形式
　　**　BBB[1]：　表示第一個BBB元素
　　**   BBB[last()]：表示最後一個BBB元素
* 第五種形式
　　** //BBB[@id]： 表示只要BBB元素上面有id屬性，都獲得
* 第六種形式
　　** //BBB[@id='b1'] 表示元素名稱是BBB,在BBB上面有id屬性，而且id的屬性值是b1

1三、使用dom4j支持xpath具體操做
默認的狀況下，dom4j不支持xpath，若是想要在dom4j裏面使用xpath
* 第一步須要，引入支持xpath的jar包，使用 jaxen-1.1-beta-6.jar
　　** 須要把jar包導入到項目中

* 在dom4j裏面提供了兩個方法，用來支持xpath
　　** selectNodes("xpath表達式")
　　　　- 獲取多個節點
　　** selectSingleNode("xpath表達式")
　　　　- 獲取一個節點

使用xpath實現：查詢xml中全部name元素的值
* 全部name元素的xpath表示： //name
* 使用selectNodes("//name");
* 代碼和步驟：
一、獲得document
二、直接使用selectNodes("//name")方法獲得全部的name元素

//獲得document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//使用selectNodes("//name")方法獲得全部的name元素
List<Node> list = document.selectNodes("//name");
//遍歷list集合
for (Node node : list) {
　　//node是每個name元素
　　//獲得name元素裏面的值　　
　　String s = node.getText();
　　System.out.println(s);
}
使用xpath實現：獲取第一個p1下面的name的值
* //p1[@id1='aaaa']/name
* 使用到 selectSingleNode("//p1[@id1='aaaa']/name")
* 步驟和代碼
一、獲得document
二、直接使用selectSingleNode方法實現
　　- xpath ： //p[@id1='aaaa']/name

//獲得document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//直接使用selectSingleNode方法實現
Node name1 = document.selectSingleNode("//p[@id='aaaa']/name"); //name的元素
//獲得name裏面的值
String s1 = name1.getText();
System.out.println(s1);
e-code【a.xml 和封裝工具類:Dom4jUtils】上例子同樣
e-code【dom4jXPath.java】

 1 package boom.dom4j;
 2 
 3 
 4 import java.util.List;
 5 
 6 import org.dom4j.Document;
 7 import org.dom4j.Element;
 8 import org.dom4j.Node;
 9 
10 import boom.utils.Dom4jUtils;
11 
12 public class Dom4jXpath {
13 
14     /**
15      * @param args
16      * @throws Exception 
17      */
18     public static void main(String[] args) throws Exception {
19         test1();
20 //        test2();
21     }
22     /**
23      * 二、查詢xml中全部第一個name元素的值
24      * @throws Exception
25      */
26     public static void test2() throws Exception{
27         // 獲得document
28         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
29         // 獲得第一個name元素[selectSingleNode方法實現]
30         Node name = document.selectSingleNode("//p[@id='frist']/name");
31         String string =name.getText();
32         System.out.println(string);
33     }
34     /**
35      * 一、查詢xml中全部name元素的值
36      * @throws Exception
37      */
38     public static void test1() throws Exception{
39         // 獲得document
40         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
41         // 獲得全部name元素[selectNodes("xpath表達式")]
42         List<Node> list = document.selectNodes("//name");
43         // 遍歷集合 以前for循環實現
44         for (Node node : list) {
45             // node是每個name元素
46             String getName =node.getText(); // 獲得name元素值
47             System.out.println(getName);
48         }
49     }
50 
51 }

View Code