（题图：wikipedia.org）

重点：

XML语言简介

XML文档编写规范

什么是DOM解析XML

DOM解析XML的方法

DOM4J解析XML的方法

一、XML简介

XML （EXtensible Markup Language）,可扩展标记语言。

特点：

XML与操作系统、编程语言的开发平台无关；
实现不同系统之间的数据交换

作用：

数据交互
配置应用程序和网站
Ajax基石

二、XML文档结构

<!--声明-->
<?xml version="1.0" encoding="UTF-8"?>    
<!--文档元素描述信息（文档结构）-->
<books>
  <!-- 图书信息-->
  <book id="bk101">
    <author>王珊</author>
    <title>.NET高级编程</title>
    <description>包含C#框架和网络编程等</description>
  </book>
  <book id="bk102">
    <author>李明明</author>
    <title>XML基础编程</title>
    <description>包含XML基础概念和基本作用</description>
  </book>
</books>

三、XML标签

XML文档内容由一系列标签元素组成。

示例：<元素名属性名=“属性值”>元素内容</元素名>

语法：

属性值用双引号包裹
一个元素可以有多个属性
属性值中不能直接包含<、 “、& （不建议：‘、>）

四、XML编写注意事项

标签编写注意事项：

所有XML元素都必须有结束标签
XML标签对大小写敏感
XML必须正确的嵌套
同级标签以缩进对齐
元素名称可以包含字母、数字或其他的字符
元素名称不能以数字或者标点符号开始
元素名称中不能含空格

五、转义符

XML中的转义符列表：

符号	转义符	英文全称
<	\<	less than
>	\>	greater than
"	\"	quot
'	\'	apos
&	\&	ampersand

当元素中出现很多特殊字符时，可以使用 CDATA 节，如：

<description>
     <![CDATA[讲解了元素<title>以及</title>的使用]]>
</description>

六、XML命名空间

XML命名空间（XML namespace，也译作XML名称空间、XML名字空间）用于在一个XML文档中提供名字唯一的元素和属性，可以用作元素或属性名称的名称集合。它们标识来自特定的域（标准组织、公司、行业）的名称。

语法：

xmlns:namespace-prefix="namespaceURI"

prefix是前缀名称，作为命名空间的别名
xmlns是保留属性

示例：

<?xml version= "1.0" encoding="UTF-8"?>
<cameras xmlns:canon="http://www.canon.com" xmlns:nikon="http://www.nikon.com">
     <canon:camera prodID= "P663" name="Camera傻瓜相机"/>
     <nikon:camera prodID=“K29B3” name=“Camera超级35毫米相机"/>
</cameras>

属性命名空间：除非带有前缀，否则属性属于它们的元素的命名空间。

示例：

<?xml version= "1.0" encoding="UTF-8"?>
<batchCompany xmlns="http://www.FatliTalk.com" xmlns:tea="http://www.tea.org">
     <batch-list>
          <batch type= "thirdbatch">第三批次</batch>
          <batch tea:type="thirdbatch">第三批茶</batch>
          <batch>午班批次</batch>
   </batch-list>
</batchCompany>

七、XML解析器（XML验证）

7.1 解析器类型：

非验证解析器
验证解析器：DTD、Schema

DTD 是 Document Type Definition 的缩写，即文档类型定义，DTD 用来描述 XML 文档的结构。 XML Schema 可以对 XML 进行验证，和 DTD 相比，XML Schema 是使用 XML 语法编写的，更易于学习和使用。

7.2 ”形式良好“和”合法“的 XML

拥有正确语法的 XML 被称为"形式良好"的 XML。
通过 DTD 验证的XML是"合法"的 XML。

7.2.1 形式良好的 XML 文档：

”形式良好“的 XML 文档拥有正确的语法：

XML 文档必须有一个根元素
XML元素都必须有一个关闭标签
XML 标签对大小写敏感
XML 元素必须被正确的嵌套
XML 属性值必须加引号

<?xml version="1.0" encoding="ISO-8859-1"?>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>

7.2.2 验证 XML 文档：

合法的 XML 文档是"形式良好"的 XML 文档，这也符合文档类型定义（DTD）的规则：

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE note SYSTEM "Note.dtd">
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>

注：在上面的实例中，DOCTYPE 声明是对外部 DTD 文件的引用。

7.3 XML DTD：

DTD （Document Type Definition），文档类型定义。

DTD的声明语法：

<!DOCTYPE 根元素 [定义内容]>

DTD元素的定义语法：

<!ELEMENT NAME CONTENT>

DTD 的目的是定义 XML 文档的结构。它使用一系列合法的元素来定义文档结构：

<!DOCTYPE note
[
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
]>

注：#PCDATA可以包含任何字符数据，但是不能在其中包含任何子元素。

7.4 XML Schema：

针对DTD的不足之处（如隐晦的语法、缺乏数据类型、封闭的内容模型以及不支持命名空间等）进行了改善。和DTD相比， XML Schema是使用XML语法编写的，更易于学习和使用。

W3C 支持一种基于 XML 的 DTD 代替者，它名为 XML Schema：

<xs:element name="note">

<xs:complexType>
<xs:sequence>
<xs:element name="to" type="xs:string"/>
<xs:element name="from" type="xs:string"/>
<xs:element name="heading" type="xs:string"/>
<xs:element name="body" type="xs:string"/>
</xs:sequence>
</xs:complexType>

</xs:element>

八、解析XML技术

在实际应用中，经常需要对XML文档进行各种操作，例如，在应用程序启动时去读取XML配置文件信息，或者把数据库中的内容读取出来转换为XML文档形式，这些时候都会用到XML文档的解析技术。

下面介绍3种常用的XML解析技术：

1. DOM（常用）：

基于XML文档树结构的解析
适用于多次访问的XML文档
特点：比较消耗资源

2. SAX：

基于事件的解析
适用于大数据量的XML文档
特点：占用资源少，内存消耗小

3. DOM4J（常用）：

非常优秀的Java XML API
性能优异、功能强大
开放源代码

8.1 DOM解析XML：

8.1.1 DOM概念：

文档对象模型（Document Object Model）
DOM把XML文档映射成一个倒挂的树（以根元素为根节点，每个节点都已对象形式存在。通过获取这些对象就能够获取存取XML文档的内容）

xml dom

常用接口介绍：

DOM解析包：org.w3c.dom（W3C推荐使用的用于DOM解析XML文档的接口），了解更多：在API文档中查看接口。

常用接口	常用方法	说明
Document：表示整个XML 文档	NodeList getElementsByTagName(String Tag)	按文档顺序返回文档中指定标记名称的所有元素集合
	Element createElement(String tagName)	创建指定标记名称的元素
Node:该文档树中的单个节点	NodeList getChildNodes()	获取该元素的所有子节点，返回节点集合
Element：XML 文档中的一个元素	String getTagName()	获取元素名称

8.1.2 访问DOM树节点（这里以“使用DOM读取手机收藏信息”为实例）：

DOM解析XML文件步骤：

创建解析器工厂对象，即DocumentBuilderFactory对象
解析器工厂对象创建解析器对象，即DocumentBuilder对象
由解析器对象对指定XML文件进行解析，构建相应的DOM树，创建Document对象
以Document对象为起点操作DOM树的节点进行增加、删除、修改、查询等操作

使用DOM读取手机收藏信息中品牌和型号，XML文档（收藏信息.xml）代码如下：

<?xml version="1.0" encoding="GB2312"?>
<PhoneInfo>
     <Brand name="华为">
          <Type name="U8650"/>    
     </Brand>                 
     <Brand name="苹果">        
          <Type name="iPhone4"/>
          <Type name="iPhone5"/>
     </Brand>
</PhoneInfo>

XML文档对应树结构： xml

根据使用 DOM 解析 XML 文档的步骤可以实现： 显示“收藏信息.xml”文件中收藏的手机品牌和型号：

/*关键代码*/
//步骤1：得到DOM解析器的工厂实例
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
//步骤2：从DOM工厂获得DOM解析器
DocumentBuilder db = dbf.newDocumentBuilder();
//步骤3：解析XML文档，得到一个Document对象，即DOM树
Document doc = db.parse("src/收藏信息.xml");
//步骤4：以Document对象为起点操作DOM树 的节点进行增加、删除、修改、查询等操作
//得到所有的Brand节点列表信息
NodeList brandList = doc.getElementsByTagName("Brand");
//循环Brand信息
for(int i = 0;i < brandList.getLength();i++){
     //获取第i个Brand元素信息
     Node brand = brandList.item(i);
     //获取第i个Brand元素的name属性的值
     Element element = (Element) brand;
     String attrValue = element.getAttribute("name");
     //获取第i个Brand元素的所有子元素的name属性值
     NodeList types = element.getChildNodes();
     for(int j = 0;j < types.getLength();j++){
          Element typeElement = (Element) types.item(j);     //Type节点
          String type = typeElement.getAttribute("name");    //获得手机型号
          System.out.println("手机："+attrValue+type);
     }
}

输出结果：手机：华为 U8650 手机：苹果 iPhone4 手机：苹果 iPhone5

8.1.3 使用 DOM 解析 XML 时主要使用以下对象（参考上面代码里的红色字）：

（1）Document 对象

Document 对象代表整个 XML 文档，所有其他的Node都以一定的顺序包含在 Document 对象之内，排列成一个树形结构，可以通过遍历这棵“树”来得到 XML 文档的所有内容。它也是对 XML 文档进行操作的起点，人们总是先通过解析XML源文件而得到一个 Document 对象，然后再来执行后续的操作。

Document 对象的主要方法如下：

getElementByTagName(String name)：返回一个 NodeList 对象，它包含了所有给定标签名称的标签
getDocumentElement()：返回一个代表这个DOM树的根节点的 Element 对象，也就是代表 XML 文档根元素的对象

（2）NodeList 对象

顾名思义，NodeList 对象是指包含了一个或者对个节点（Node）的列表，类似数组，节点列表中的节点可以通过其对应的索引数字（从 0 开始计数）进行访问。

NodeList 对象的常用方法如下：

getLength()：返回列表长度
item(index)：返回节点列表中指定索引号的节点（Node对象）

（3）Node对象

Node 对象是 DOM 结构中最基本的对象，代表了文档树中的一个抽象节点。在实际开发中，很少会用到Node对象，一般会使用如Element、Text等Node对象的子对象来操作文档。

Node对象的主要方法如下：

getChildNodes()：包含此节点的所有子节点的NodeList
getFirstChild()：如果节点存在子节点，则返回第一个子节点
getLastChile()：如果节点存在子节点，则返回最后一个子节点
getNextSibling()：返回在DOM树中这个节点的下一个兄弟节点
getPreviousSibling()：返回在DOM树中这个节点的上一个兄弟节点
getNodeName()：返回节点的名称
getNodeValue()：返回节点的值
getNodeType()：返回节点的类型

（4）Element对象

Element 对象代表 XML 文档中的一个元素（标签元素），元素可以包含属性、其他元素或文本。Element 对象继承自Node，也是Node最主要的子对象。

在标签中可以包含属性，因此Element对象中也可以存取其属性的方法：

getAttribute(String attributeName)：返回标签中给定属性名称的属性的值
getElementByTagName(String name)：返回具有给定标签名称的所有后代Element的NodeList

操作DOM树的节点进行增加、删除、修改、查询等操作，演示示例：

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class ParseXMLDemo {
    private Document document=null;
    public static void main(String[] args) {
        ParseXMLDemo pd=new ParseXMLDemo();
        pd.getDocument();
        pd.showInfo();
//        pd.add();
//        pd.update();
//        pd.savaXML("new.xml");
//        pd.delete();
    }

    public void getDocument(){
        DocumentBuilderFactory  factory=DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder builder=factory.newDocumentBuilder();
            document=builder.parse("收藏信息.xml");
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //获取手机品牌和属性
    public void showInfo(){
        NodeList brands=document.getElementsByTagName("Brand");
        for(int i=0;i<brands.getLength();i++){
            Node node=brands.item(i);
            Element eleBrand=(Element)node;
            System.out.println(eleBrand.getAttribute("name"));

            NodeList types=eleBrand.getChildNodes();
            for(int j=0;j<types.getLength();j++){
                Node typeNode=types.item(j);
                if(typeNode.getNodeType()==Node.ELEMENT_NODE){
                    Element eleType=(Element)typeNode;
                    System.out.println(eleType.getAttribute("name"));
                }
            }
        }
    }

     /*保存XML文件
    步骤：

    *      获得TransformerFactory对象
    *      创建Transformer对象
    *      创建DOMSource对象
    * 
        *      包含XML信息

    *      设置输出属性
    * 
        *      编码格式

    *      创建StreamResult对象
    * 
        *      包含保存文件的信息

    *      将XML保存到指定文件中

     */
    public void savaXML(String path){
        TransformerFactory factory=TransformerFactory.newInstance();
        factory.setAttribute("indent-number", "4");
        try {
            Transformer transformer=factory.newTransformer();
            transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312");
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
          //StreamResult result=new StreamResult(new FileOutputStream(path));
            StreamResult result=new StreamResult(new OutputStreamWriter(new FileOutputStream(path), "gb2312"));
            DOMSource source=new DOMSource(document);
            transformer.transform(source, result);
        } catch (TransformerConfigurationException e) {
            e.printStackTrace();
        } catch (TransformerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

     /*添加DOM节点
演示示例：给手机收藏信息XML中添加新的手机信息:

    * 添加新的Brand：三星
    * 给Brand节点添加新的子标签Type：Note4
    * 将Brand添加到DOM树中

     */
    public void add(){
        Element element=document.createElement("Brand");
        element.setAttribute("name", "三星");
        Element ele1=document.createElement("Type");
        ele1.setAttribute("name", "Note4");
        element.appendChild(ele1);
        document.getElementsByTagName("PhoneInfo").item(0).appendChild(element);
        this.savaXML("new.xml");
    }

     /*修改DOM节点：
     给所有的Brand标签添加id属性

    * 获取Brand标签
    * 调用setAttribute()方法添加属性

     */
    public void update(){
        NodeList brands=document.getElementsByTagName("Brand");
        for(int i=0;i<brands.getLength();i++){
            Node brand=brands.item(i);
            Element eleBrand=(Element)brand;
            eleBrand.setAttribute("id", i+"");
        }
        this.savaXML("new.xml");
    }

    /*删除DOM节点：
     删除Brand值为“华为”的标签

    * getElementsByTagName ()方法获取Brand标签列表
    * 获得Brand值为“华为”的标签对象
    * 通过getParentNode ()方法获得父节点对象
    * 调用父节点的removeChild()方法删除节点

     */
    public void delete(){
        NodeList brands=document.getElementsByTagName("Brand");
        for(int i=0;i<brands.getLength();i++){
            Node brand=brands.item(i);
            Element eleBrand=(Element)brand;
            if(eleBrand.getAttribute("name").equals("华为")){
                eleBrand.getParentNode().removeChild(eleBrand);
            }
        }
        this.savaXML("new.xml");
    }
}

8.2 DOM4J 解析 XML：

DOM4J是目前使用非常广泛的解析XML的一种技术，与DOM相比，使用灵活。操作简单，要点在于灵活理解几个重要接口的用法。

重点：

了解DOM4J相关接口
使用DOM4J读取、添加、修改、删除XML数据

概述：

DOM4J是一个易用、开源的库（Java XML API），用于XML、XPath和XSLT。它应用于Java平台，采用了Java集合框架并完全支持DOM、SAX和JAXP。
DOM4J使用简单。只需要了解基本的XML-DOM模型，就能使用。DOM4J最大的特色是使用大量的接口。

DOM4J 的主要接口都在 org.dom4j 这个包里定义：

Attribute：定义 XML 属性

Branch：为能够包含子节点的节点，如XML元素（Element）和文档（Document）定义了一个公共的行为。
CDATA：定义了 XML CDATA 区域
CharacterData：是一个标识接口，标识基于字符的节点，如 CDATA、Comment、和 Text
Comment：定义了 XML 注释的行为
Document：定义了 XML 文档
DocumentType：定义 XML DOCTYPE 声明
Element：定义 XML 元素
ElementHandle：定义了 Element 对象的处理器
ElementPath：被 ElementHandle 使用，用于取得当前正在处理的路径层次信息
Entity：定义 XML entity
Node：为所有的 dom4j 中 XML 节点定义了多态行为
NodeFilter：定义了在 dom4j 节点中产生的一个滤镜或谓词的行为（predicate）
ProcessingInstruction：定义 XML 处理指令
Text：定义 XML 文本节点
Visitor：用于实现 Visitor 模式
XPath：在分析一个字符串后会提供一个 XPath表达式

使用 DOM4J 解析“收藏信息.xml”，进行增加、删除、修改、查询等操作 Java代码示例：（需先导入 dom4j 的 jar 包）

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

public class Dom4j {

    public static Document doc;

    public static void main(String[] args) {
        loadDocument();
//        showPhoneInfo();
//        saveXML("src/新收藏.xml");
//        addNewPhoneInfo();
//        updatePhoneInfo();
        deleteItem();
        showPhoneInfo();
    }

    public static void loadDocument(){
        try{
            SAXReader saxReader = new SAXReader();
            doc = saxReader.read(new File("src/收藏信息.xml"));
        }catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

    public static void updatePhoneInfo(){
        // 获取XML的根节点
        Element root = doc.getRootElement();
        int id = 0;
        for (Iterator itBrand = root.elementIterator(); itBrand.hasNext();) {
            Element brand = (Element) itBrand.next();
            id++;
            brand.addAttribute("id", id + "");
        }
        saveXML("src/收藏信息.xml");
    }

    public static void deleteItem(){
        // 获取XML的根节点
        Element root = doc.getRootElement();
        int id = 0;
        for (Iterator itBrand = root.elementIterator(); itBrand.hasNext();) {
            Element brand = (Element) itBrand.next();
            if (brand.attributeValue("name").equals("华为")) {
                brand.getParent().remove(brand);
            }
        }
//        saveXML("src/收藏信息.xml");           
    }

    public static void showPhoneInfo() {
        // 获取XML的根节点
        Element root = doc.getRootElement();
        // 遍历所有的Brand标签
        for (Iterator itBrand = root.elementIterator(); itBrand.hasNext();) {
            Element brand = (Element) itBrand.next();
            // 输出标签的name属性
            System.out.println("品牌：" + brand.attributeValue("name"));
            // 遍历Type标签
            for (Iterator itType = brand.elementIterator(); itType.hasNext();) {
                Element type = (Element) itType.next();
                // 输出标签的name属性
                System.out.println("\t型号：" + type.attributeValue("name"));
            }
        }
    }

    public static void saveXML(String path){
        try {
            OutputFormat format = OutputFormat.createPrettyPrint();
            format.setEncoding("GBK"); // 指定XML编码
            XMLWriter writer;
            writer = new XMLWriter(new FileWriter(path), format);
            writer.write(doc);
            writer.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void addNewPhoneInfo(){
        // 获取XML的根节点
        Element root = doc.getRootElement();
        // 创建Brand标签
        Element el = root.addElement("Brand");
        // 给Brand标签设置属性
        el.addAttribute("name", "三星");
        // 创建Type标签
        Element typeEl = el.addElement("Type");
        // 给Type标签设置属性
        typeEl.addAttribute("name", "Note4");
        saveXML("src/收藏信息.xml");
    }
}

使用 DOM4J 解析 XML 的关键操作（使用 DOM4J 对 XML 文件数据的查询、添加、修改和删除功能）总结如下：

Document对象相关

读取 XML 文件，获得 document 对象

SAXReader reader = new SAXReader();
Document document = reader.read(new File("input.xml"));

节点相关

（1）获得文档的根元素

Element rootElement = document.getRootElement();

（2）获得某个节点的单个节点

Element memberElement = root.element("menber");     //"member"是节点名

（3）取得节点的文字

String text = memberElement.getText();

也可以：

String text = root.elementText("name");     //取得根元素下的name子节点的文字

（4）取得某节点下名为 "member" 的所有子节点并进行遍历

List nodes = rootElement.elements("member");
     for(Iterator it = nodes.iterator(); it.hasNext();){
          Element element  = (Element) it.next();
          //……
}

（5）对某节点下的所有子节点进行遍历

for(Iterator  it = root.elementIterator(); it.hasNext();){
    Element element = (Element) it.next();
    //……
}

（6）在某个节点下添加子节点

Element ageElement = newMemberElement.addElement("age");

（7）设置节点文字

ageElement.setText("18");

（8）删除某节点

parentElement.remove(childElement);

（9）添加一个 CDATA 节点

Element contentElement = infoElement.addElement("content");
    contentElement.addCDATA(diary.getContent());
    contentElement.fetText();               //特别说明：获取节点的 CDATA 值与获取节点的值是同一个方法
    contentElement.clearContent();      //清除节点中的内容，CDATA 亦可

属性相关

（1）获取某节点下的某属性

Element root = document.getRootElement();
Attribute attribute = root.atttibute("size");     //属性名 name

（2）取得属性的文字

String text = attribute.getText();

也可以：

//取得根节点下name子节点的属性 firstName 的值
String text2 = root.element("name").attributeValue("firstName");

（3）遍历某节点的所有属性

Element root = document.getRootElement();
     for(Iterator it = root.attributeInterator();it.hasNext();){
          Attribute attribute = (Attribute) it.next();
          String text = attribute.getText();
          System.out.println(text);
}

（4）设置某节点的属性和文字

newMemberElement.addAttribute("name","sitinspring");

（5）设置属性的文字

Attribute attribute = root.attribute("name");
attribute.setText("sitinspring");

（6）删除某属性

Attribute attribute = root.attribute("size");     //属性名 name
root.remove(attribute);

将文档写入 XML 文件

（1）文档中全为英文，不设置编码格式，直接写入

XMLWriter writer = newXMLWriter(new FileWriter("output.xml"));
writer.write(document);
writer.close();

（2）文档中含有中文，设置编码格式再写入

OutputFormat format = OutputFormat.createPrettyPrint();
     format.setEncoding("GBK");     //指定 XML 编码
     XMLWriter writer = newXMLWriter(new FileWriter("output.xml"),format);
     writer.write(document);
     writer.close();

——END

Qingquan-Li / blog

Java高级特性_5 XML #6