核心技术Ⅱ：XML

XML概述

XML 是一种非常有用的描述结构化信息的技术。

“Properties”类：在单个方法调用中读入这样的“属性文件”（property file）：

属性文件：用于描述程序配置；包含了一组“名/值”对：
```
fontname=Times Roman
fontsize=l2
windowsize=400 200
co1or=O 5O 100
```

但是：

属性文件采用的是一种单一的平面层次结构；所以常常会出现这种情况：
```
title.fontname=Helvetica
title.fontsize=36
body.fontname=Times Roman
body.fontsize=12
```

属性文件要求键是唯一的；所以保存序列值需要：

menu.item.l=Times Roman
menu.item.2=Helvetica
menu.item.3=Goudy Old Style

XML 和HTML 格式是古老的标准通用标记语言(Standard Generalized Markup Language, SGML) 的衍生语言。

XML 格式能够表达层次结构，并且重复的元素不会被曲解：

<configuration>
   <title>
      <font>
         <name>Helvetica</name>
         <Size>36</size>
      </font>
   </title>
   <body>
      <font>
         <name>Times Roman</name>
         <Size>12</size>
      </font>
   </body>
   <window>
      <width>400</width>
      <height>200</height>
   </window>
   <color>
      <red>O</red>
      <green>50</green>
      <blue> 100</blue>
   </color>
   <menu>
      <item>Times Roman</item>
      <item>Helvetica</item>
      <item>Goudy 01d Style</item>
   </menu>
</configuration>

XML 和HTML的区别：

XML	HTML
大小写敏感如：<H1> 和<hl> 是不同的XML 标签	不敏感
结束标签绝对不能省略	如果从上下文中可以分清哪里是段落或列表项的结尾，那么结束标签（如</p>或</li>) 就可以省略
只有单个标签而没有相对应的结束标签的元素必须以“/”结尾如：<img src="coffeecup.png"/ >
属性值必须用引号括起来如：<applet code="MyApplet.class" width="300" height="300">	引号是可有可无的如：<applet code="MyApplet.class" width=300 height=300>
所有属性必须都有属性值如：<input type="radio" name="1anguage" value="Java" checked="checked">	属性名可以没有值如：<input type="radio" name="1anguage" value="Java" checked>

XML 文档的结构

XML 文档应当以一个文档头开始：

<?xml version="l.O"?>
或
<?xml version="l.O" encoding="UTF-8"?>

文档头之后通常是文档类型定义(Docun1ent Type Definition, DTD)：

<!DOCTYPE web-app PUBLIC
   "-//Sun Microsystems, Inc.//OTD Web Application 2.2//EN" 
   "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">

XML 文档的正文包含根元素，根元素包含其他元素：

<?xml version="l.O"?>
<!DOCTYPE configuration ... >
<configuration>
   <title>
      <font>
         <name>Helvetica</name>
         <Size>36</size>
      </font>
   </title>
   ...
</configuration>

元素可以有子元素(child element )、文本或两者皆有；
在设计XML 文档结构时，应避免混合式内容(mixed content)，以简化解析过程：
```
<font>
   Helvetica
   <Size>36</size>
</font>
```
XML元素可以包含属性，但属性的灵活性要差很多；
- “属性只应该用来修改值的解释，而不是用来指定值。”
- “HTML 中，凡是不显示在网页上的都是属性。”

<font name="Helvetica" size="36 pt"/>

<font>
   <name>Helvetica</name>
   <Size unit="pt">36</size>
</font>

XML中的其他一些标记：

字符引用（character reference）：形式是“&#”十进制值；或“&#x”十六进制值；

实体引用（entity reference）：形式是“&name”；

下面这些实体引用：
   &lt; &gt; &amp; &quot; &apos;
都有预定义的含义：
   小于、大于、＆、引号、省略号等字符。

CDATA部分（CDATA Section）：用“<![CDATA[”和“]]>”来限定其界限；
- 它们是字符数据的一种特殊形式。可以使用它们来襄括那些含有“<”、“>”、“&”之类字符的字符串，而不必将它们解释为标记；
- CDATA 部分不能包含字符串“]]>”；
```
<![CDATA[< & > are my favorite delimiters]]>
```
处理指令（processing instruction）：是那些专门在处理XML 文档的应用程序中使用的指令，它们由“<?”和“?>”来限定其界限：
```
<?xml-stylesheet href="mystyle.css" type="text/css"?>

每个XML 都以一个处理指令开头：
<?xml version="l.O"?>
```
注释（comment）：用“<!-”和“-->”限定其界限：
- 注释不应该含有字符串“--”；
```

```

解析XML文档

xml解析器：读入一个文件，确认这个文件具有正确的格式（验证xml文档），然后将其分解成各种元素，使得程序员能够访问这些元素；

Java 库提供了两种XML 韶析器：
1. “树型解析器”：将读入的XML 文档转换成树结构。
  如：文档对象校型（Document Object Model, DOM）解析器；
2. “流机制解析器”：在读入XML 文档时生成相应的事件。
  如：XML 简单API（Simple API for XML, SAX）解析器；
何时使用“流机制解析器”：
1. 如果需要处理很长的文档，若生成树结构将会消耗大量内存；
2. 或者如果只对某些元素感兴趣，而不关心它们的上下文；

树型解析器

DOM 韶析器的接门已经被W3C 标准化了。org.w3c.dom 包中包含了这些接口类型的定义，比如： Document 和Element 等。不同的提供者，比如Apache 组织和IBM, 都编写了实现这些接口的DOM 解析器。

Java XML 处理 API (Java API for XML Processing, JAXP) 库使得我们实际上可以以插件形式使用这些韶析器中的任意一个。

JDK 中也包含了从Apache 解析器导出的DOM 解析器；

读人XML文档：

首先需要“DocumentBuilder”对象（从“DocumentBuilderFactory”中得到）：

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

从不同的源中读入文档：

// 从文件：
File f = ...
Document doc = builder.parse(f);

// 从一个URL：
URL u = ...
Document doc= builder.parse(u);

// 从指定的输入流：
InputStream in = ...
Document doc= builder.parse(in);

果使用输入流作为源，那么对于那些以该文档的位置为相对路径而被引用的文档，解析器将无法定位。

“Document”对象是XML 文档的树型结构在内存中的表示方式，它由实现了“Node”接口及其各种子接口的类的对象构成：

解析文档内容：

调用“getDocumentElement”方法，获取文档根元素：
调用“getTagName”方法可以返同元素的标签名；
```
Element root = doc.getDocumentElement();
String rootName = root.getTagName();
```

调用“getChildNode”方法，获取元素的子元素（可能是子元素、文本、注释或其他节点）：

返回一个类型为“Nodelist”的集合；

“item”方法将得到指定索引俏的项；

“getLength”方法则提供了项的总数；

// 枚举所有子元素
// 得到的子元素会包含：元素之间的“\n”等空白字符
Nodelist children = root.getChildNodes();
for (int i = O; i < children.getlength(); i++)
{
   Node child= children.item(i);
   ...
}

// 枚举所有子元素
// 并忽略元素之间的“\n”等空白字符
Nodelist children = root.getChildNodes();
for (int i = O; i < children.getlength(); i++)
{
   Node child= children.item(i);
   if (chi1d instanceof Element)
   {
      Element childElement = (Element) child;
      ...
   }
}

利用DTD，解析器会忽略空白字符；

获取节点文本：

使用“getFirstChild”方法而不用再遍历另一个Nodelist；
使用“getData”方法获取存储在Text节点中的字符串；

for (inti = O; i < children.getlength(); i++)
{  
   Node child = chi1dren.item(i);
   if (child instanceof Element)
   {
      Element childElement = (Element) chi1d;
      Text textNode = (Text) childElement.getFirstChild();
      String text = textNode.getData().trim();
      if (childElement.getTagName().equals("name"))
         name = text;
      else if (childElement.getTagName().equals("size"))
         size = Integer.parseInt(text);
   }
}

也可以用“getlastChild”方法得到最后一项子元素；

用“getNextSibling”得到下一个兄弟节点；

// 另一种遍历子节点集的方法
for (Node childNode = element.getFirstChild();
    childNode != null;
    childNode = childNode.getNextSibling())
{
    ...
}

获取元素属性：
1. 调用“getAttributes”方法，枚举节点的属性：
  返回一个“NamedNodeMap”对象，其中包含了描述屈性的“Node”对象。可以和“Nodelist”一样的方式遍历；
2. 调用“getNodeName”和“getNodeValue”方法可以得到属性名和属性值；
```
NamedNodeMap attributes = element.getAttributes();
for (int i = O; i < attributes.getlength(); i++)
{
   Node attribute = attributes.item(i);
   String name = attribute.getNodeName();
   String value= attribute.getNodeValue();
   ...
}
```
- 如果知道属性名，则可以直接获取相应的属性值：
  String unit = element.getAttribute("unit");

流机制解析器

对于大多数应用， DOM 都运行得很好。但是，如果

文档很大，并且处理算法又非常简单，
可以在运行时解析节点，而不必看到完整的树形结构，

那么DOM 可能就会显得效率低下。在这种情况下，我们应该使用流机制解析器（streaming parser）：

（解析某些节点，而非整个树）

SAX 解析器
- 使用事件回调（eventcallback）
StAX 解析器；
- Java SE 6 中添加；
- 提供了遍历解析事件的迭代器；

使用“SAX”解析器

实际上， DOM 解析器是在SAX 解析器的基础上构建的，它在接收到解析器事件时构建DOM 树。
HTML不必是合法的XML，但 XHTML 是一种HTML方言，且是良构的XML。

使用SAX 解析器时，需要一个处理器来为各种解析器事件定义事件动作。“ContentHandler”接口定义了若干个在解析文档时解析器会调用的回调方法，下面是最重要的几个：

“startDocument”和“endDocument”分别在文档开始和结束时各调用一次。
“startElement”和“endElement”在每当遇到起始或终止标签时凋用。
“characters”在每当遇到字符数据时调用。

代码：

得到SAX 解析器：

SAXParserFactory factory= SAXParserFactory.newInstance();
factory.setNamespaceAware(true);   // 设置打开命名空间处理特性（默认是关闭的）
factory.setFeature("http://apache.org/xml/features/nonvalidating/1oad-external-dtd", false);   // 设置不需要验证DTD文件
SAXParser parser = factory.newSAXParser();

处理文档：
```
parser.parse(source, handler);
```
其中：
1. source 可以是一个文件、一个URL 字符串或者是一个输人流；
2. handler 属于“DefaultHandler”的一个子类；
  “DefaultHandler”类为以下四个接口定义了空的方法：
  1. “ContentHandler”
  2. “DTDHandler”
  3. “EntityResolver”
  4. “ErrorHandler”

示例：

package sax;

import java.io.*；
import java.net.*;
import javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;

public class SAXTest {
	public static void main(String[] args) throws Exception {
		String url;
		if (args.1ength = O) {
			url = "http://www.w3c.org";
			System.out.println("Using" + url);
		} else url = args[0] ;
		
		InputStream in = new URL(url).openStream();

		DefaultHandler handler = new DefaultHandler()
		{
			public void startflement(String namespaceURI, String lname, String qname, Attributes attrs) {
				if (lname.equa1s("a") && attrs != null) {
					for (int i = 0; i < attrs.getlength(); i++) {
						String aname = attrs.getlocalName(i);
						if (aname.equals ("href")) 
							System.out.println(attrs.getValue(i)) ;
					}
				}
			}
		};
		
		SAXParserFactory factory = SAXParserFactory.newInstance();
		factory.setNamespaceAware(true);
		factory.setFeature("http://apache.org/xml/features/nonvalidating/1oad-external-dtd", false);
		SAXParser saxParser = factory.newSAXParser();
		saxParser.parse(in, handler);
	}
}

使用“StAX”解析器

StAX 解析器是一种“拉解析器(pull parser)”，与安装事件处理器不同，只需使用下面这样的基本循环来迭代所有的事件：

InputStream in = url.openStream();
XMLInputFactory factory = XMLInputFactory.newInstance();
factory.setProperty(XMLinputFactory.IS_NAMESPACE_AWARE, false);   // 设置关闭命名空间处理特性（默认是打开的）
XMLStreamReader parser= factory.createXMLStreamReader(in);
whi1e(parser.hasNext())
{
   int event = parser.next();
   Call parser methods to obtain event details
}

获取当前元素的units 属性：

String units= parser.getAttributeValue(null, "units");

示例：

package stax;

import java.io.*;
import java.net.*;
import javax.xml.stream.*;

puhlic class StAX.Test {
	pub1ic static void main(String[] args) throws Exception {
		String urlString;
		if (args.1ength == 0) {
			urlString = "http://www.w3c.org"；
			System.out.println("Using" + urlString);
		} 
		e1se urlString = args[0];
		
		URL url = new URL(urlString);
		InputStream in = url.openStream();
		
		XMLInputFactory factory =XMLInputFactory.newlnstance();
		XMLStreamReader parser = factory.createXMLStreamReader(in);
		while (parser.hasNext()) {
			int event = parser.next();
			if (event= XMLStreamConstants.START_ELEMENT) {
				if (parser.getlocalName().equals("a")) {
					String href = parser.getAttributeValue(null, "href");
					if (href != null)
						System.out.println(href);
				}
			}
		}
	}
}

使用“XPath”

XPath 语言使得访问树节点变得很容易，而不必遍历DOM树。

如，对于以下XML文档：

<configuration>
   ...
   <database>
      <username>dbuser</username>
      <password>secret</password>
      ...
   </database>
</configuration>

可以通过对XPath 表达式“/configuration/database/username”求值，来得到database中的username的值。

XPath表达式

XPath 可以描述XML 文档中的个节点集：

/gridbag/row
描述了根元素gridbag 的子元素中所有的row 元素

可以用“[]”操作符来选择特定元素：

/gridbag/row[l]
表示的是第一行（索引号从1 开始）

使用“@”操作符可以得到属性值：

/gridbag/row(1)/ce11[1]/@anchor
描述了作为根元索gridbag 的子元素的那些row 元素中的所有单元格的anchor 属性节点

XPath 有很多有用的函数：
- 参见http://www.w3c.org/TR/xpath的规范；
- 或者http://www.zvon.org/xxl/XPatbTutorial/General/exampleshtml上的在线指南；
```
count(/gridbag/row)
返回gridbag 根元素的row 子元素的数量
```

使用XPath

Java SE 5.0 增加了一个API 来计算XPath 表达式：

首先需要从“XPathFactory”创建一个“XPath”对象：

XPathFactory xpfactory = XPathFactory.newlnstance();
path = xpfactory.newXPath();

然后，调用“evaluate”方法来计算XPath 表达式：
- （可以用同一个XPath 对象来计算多个表达式）
1. 如果返回一个字符串，不用指定“resultType”（“XPathConstants”常量）：
  String username = path.evaluate("/configuration/database/username", doc);
2. 如果结果是一组节点，则使用“XPathConstants.NODESIT”：
  NodeList nodes = (NodeList) path.evaluate("/gridbag/row", doc, XPathConstants.NODESIT);
3. 如果结果只有一个节点，则以“XPathConstants.NODE”代替：
  Node node = (Node) path.evaluate("/gridbag/row[l)", doc, XPathConstants.NODE);
4. 如果结果是一个数字，则使用“XPathConstants.NUMBER”：
  int count = ((Number) path.eva1uate("count(/gridbag/row)", doc, XPathConstants.NUMBER)).intVa1ue();
- 不必从文档的根节点开始搜索，可以从任意一个节点或节点列表开始。
  如果有前一次计算得到的节点，那么就可以调用：
  result = path.evaluate(expression, node);

使用命名空间

关于

命名空间(namespace) 机制，用于元素名和属性名，可以避免名字冲突：

名字空间是由统一资源标识符(Uniform Resource Identifier, URI ) 来标识的：

http://www.w3.org/2001/XMLSchema
uuid:lc759aed-b748-47Sc-ab68-10679700c4f2
urn:com:books-r-us

HTTP 的URL 格式是最常见的标识符。

URL 只用作标识符字符串，而不是一个文件的定位符。
如下，表示了不同的Namespace，但在Web服务器中对应于同一个文档：
```
http://www.horstmann.com/corejava
http://www.horstmann.com/corejava/index.html
```
在命名空间的URL 所表示的位性上不需要有任何文档，XML 解析器不会尝试去该处查找任何东西。

Namespace机制：（xml中用“xmlns”标识Namespace）

嵌套的Namespace：

<element xmlns="namespaceURil">
   <child xmlns="namespaceURI2">
      grandchildren
   </child>
   more children
</element>

第一个子元素和孙元索都是第二个命名空间的一部分

前缀表示Namespace：

<xsd:schema xm1ns:xsd="http://www.w3.org/2001/XMLSchema">
   <xsd:element name="gridbag" type="GridBagType"/>
   ...
</xsd:schema>

前缀“xsd”标识“http://www.w3.org/2001/XMLSchema”中的元素，如“xsd:schema”

有子元素继承了它们父元素的命名空间，而不带显式前缀的属性并不是命名空间的一部分：

<configuration xmlns="http://www.horstmann.com/corejava"
   xmlns:si="http://www.bipm.fr/enus/3_SI/si.html">
   <size value="210" si:unit="mm"/>
   ...
</configuration>

1、元素“configuration”和“size”是URI 为“http://www.horstmann.com/corejava”的命名空间的一部分；
2、属性“si:unit”是URI 为“http://www.bipm.fr/enus/3_ SI/si.html”的命名空间的一部分。
3、属性“value”不是任何命名空间的一部分

使用

默认悄况下，Java XML 库的DOM 解析器并非“命名空间感知的”。

调用“DocumentBuilderFactory”类的“setNamespaceAware”方法，打开命名空间处理特性：

factory.setNamespaceAware(true);

这样，该工厂产生的所有生成器便都支持命名空间了。每个节点有三个属性：

带有前缀的限定名（qualified），由“getNodeName”和“getTagName”等方法返回。
命名空间URI，由“getNamespaceURI”方法返回。
不带前缀和命名空间的本地名（localname），由“getlocalName”方法返回。

如果对命名空间的感知特性被关闭，“getLocalName”和“getNamespaceURI”方法将返回“null”；

如：

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

会报告如下信息：

限定名 = “xsd:schema”；
命名空间URI = “http://www.w3.org/2001/XMLSchema”；
本地名 = “schema”；

验证XML文档

XML 解析器的一个很大的好处就是它能自动校验某个文档是否具有正确的结构。

指定文档结构，可以提供一个文档类型定义（ DTD ）或一个XML Schema 定义。

DTD 或schema 包含了用于解释文档应如何构成的规则，这些规则指定了每个元素的合法子元素和属性。
XML Schema 可以表达更加复杂的验证条件（比如size 元素必须包含一个整数）。XML Schema 自身使用的就是XML。

文档类型定义

引入DTD的方式

提供DTD 的方式有多种：

文档类型必须匹配根元素的名字，如以下的configuration。

纳入到XML 文档中：

<?xml version="l.O"?>
<!OOCTYPE configuration [
   <!ELEMENT configuration . . . >
   more rules
   . . .
]>
<configuration>
. . .
</configuration>

指定一个包含DTD 的URL：
- 如果使用的是DTD 的相对URL（比如“config.dtd”），那么要给解析器一个“File”或“URL”对象，而不是“InputStream”。
```
<!DOCTYPE configuration SYSTEM "config.dtd">
或
<!DOCTYPE configuration SYSTEM "http://myserve.com/config.dtd"〉
```
- 如果XML 处理器知道如何定位带有公共标识符的DTD，那么就不需要URL了：
  <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web App1ication 2.2//EN" "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd”>
- 如果使用DOM解析器，且要支持“PUBLIC”标识符，则需调用“DocumentBuilder”类的“setEntityResolver”方法来安装“EntityResolver”接口的某个实现类的一个对象。
- （该接口只有一个方法：“resolveEntity”）
- 典型实现的代码框架：
  class MyEntityResolver implements EntityResolver { public InputSource resolveEntity(String publicID, String systemID) { if (publicID.equals(a known ID)) return new InputSource(DTD data); else return null; // use default behavior } }

元素规则

ELEMENT规则用于指定某个元素可以拥有什么样的子元素：（可以指定一个正则表达式）

如：

menu 元素包含0 或多个item 元素：
```
<!ELEMENT menu (item)*〉
```

font 是用一个name 和size 来描述的，它们都包含文本：

<!ELEMENT font (name, size)>
<!ELEMENT name (#PCDATA) >
<!ELEMENT size (#PCDATA) >

当一个元素可以包含文本时，那么就只有两种合法的情况：
1. 只包含文本：
  <!ELEMENT name (#PCDATA) >
2. 包含任意顺序的文本和标签的组合：
  <!ELEMENT para (#PCDATA|em|strong|code)*>
- 指定其他任何类型的包含＃ PCDATA 的规则都是不合法的：
  <!ELEMENT captionedlmage (image, #PCDATA) >

属性规则

描述合法的元素属性的规则，其通用语法为：

〈!ATTLIST element attribute type default>

示例：

<!ATILIST font style (plainlboldlital|bold-italic) "plain">
font 元素的style 属性：它有4 个合法的属性值，默认值是plain 。

<!ATILIST size unit CDATA #IMPLIED>
size 元素的unit 属性可以包含任意的字符数据序列

使用DTD

通知文档生成工厂打开验证特性：
```
factory.setVa1idating(true);
```
设置生成器忽略文本节点中的空白字符：
```
factory.setlgnoringElementContentWhitespace(true);
```

（验证的最大好处是可以忽略元索内容中的空白字符）
当解析器报告错误时｀应用程序希屯对该错误执行某些操作：
只要使用验证，就应该安装一个错误处理器，这需要提供一个实现了“ErrorHandler”接口的对象。这个接口有三个方法：
```
void warning(SAXParseException exception)
void error(SAXParseException exception)
void fatalError(SAXParseExcepti on exception)
```
可以通过“DocumentBuilder”类的“setErrorHandler”方法来安装错误处理器：
```
bui1der.setErrorHandler(handler);
```

XML Schema

XML Schema规则

【XML Schema比DTD复杂得多，需要另外了解】

前缀“xsd:”（或“xs:”）来表示XSLSchema 定义的命名空间。

如果要在文档中引用Schema 文件，需要在根元素中添加属性：

<?xml version="l.0"?>
<configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi: noNamespaceSchemalocation="config.xsd">
...
</configuration>

即：Schema 文件config.xsd 会被用来验证该文档。

Schema 为每个元素都定义了类型：
类型可以是简单类型，即有格式限制的字符串，或者是复杂类型。

一些简单类型巳经被内建到了XML Schema 内：
```
xsd:string
xsd:int
xsd:boo1ean
```

可以定义自己的简单类型：

如下，面是一个枚举类型：
<Xsd:simpleType name= "StyleType">
   <xsd:restriction base="xsd:string">
      <xsd:enumeration value="PLAIN" />
      <xsd:enumeration value="BOLD" />
      <xsd:enumeration value="ITALIC" />
      <xsd:enumeration val ue="BOLD_ITALIC" />
   </xsd:restriction>
</xsd:simpleType>

当定义元素时，要指定它的类型，以约束了元素的内容：

<xsd:e1ement name="name" type="xsd:string"/>
<xsd:element name="size" type="xsd:int"/>
<Xsd:element name="style" type="StyleType"/>

可以把类型组合成复杂类型：

<xsd:complexType name="FontType">
   <xsd:sequence>
      <xsd:element ref="name"/>
      <xsd:element ref="size"/>
      <xsd:element ref="style"/>
   </xsd:sequence>
</xsd:complexType>

其中，“ref”属性来引用在Schema 中位千别处的定义，等同于嵌套定义：
<Xsd:complexType name="FontType">
   <xsd:sequence>
      <xsd:element name="name" type="xsd:string"/>
      <xsd:e1ement name="size" type="xsd:int"/>
      <xsd:element name="style" type="StyleType">
         <xsd:simpleType>
            <xsd:restriction base="xsd:string">
               <xsd:enumeration value="PLAIN" />
               <xsd:enumeration value="BOLD" />
               <xsd:enumeration value="ITALIC" />
               <xsd:enumeration value="BOLD_ITALIC" />
            </xsd:restriction>
         </xsd:simpleType>
      </xsd:e1ement>
   </xsd:sequence>
</xsd:complexType>

“xsd:sequence”结构和DTD 中的“连接符号”等价，而“xsd:choice”结构和“|”操作符等价：

<xsd:comp1exType name="contactinfo ">
   <xsd:choice>
      <xsd:element ref="email"/>
      <xsd:element ref="phone"/>
   </xsd:choice>
</xsd:comp1exType>

和 DTD 中的类型“email|phone”类型是等价的。

如果要允许重复元素，可以使用“minoccurs”和“maxoccurs”属性：

<xsd:element name="item" type=" ... " minoccurs="O" maxoccurs="unbounded">

与DTD 类型“item*”等价

如果要指定属性，可以把“xsd:attribute”元素添加到complexType 定义中去：

<xsd:element name="size">
   <xsd:complexType>
      ...
      <xsd:attribute name="unit" type="xsd:string" use="optional" default="cm"/>
   </xsd:complexType>
</xsd:element>

与下面的DTD 语句等价：
<!ATTLIST size unit CDATA #IMPLIED "cm">

可以把Schema 的元素和类型定义封装在“xsd:schema”元索中：

<xsd:schema xmlns :xsd="http://www.w3.org/2001/XMLSchema">
   ...
</xsd: schema>

使用XML Schema

解析带有Schema 的XML 文件和解析带有DTD 的文件相似，但有3 点差别：

必须打开对命名空间的支待：
（即使在XML 文件里你可能不会用到它）
```
factory.setNamespaceAware(true);
```

必须通过如下的“魔咒”来准备好处理Schema 的工厂：

final String JAXP_SCHEMA_LANGUAGE = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";
final String W3C_XML_SCHEMA = "http://www.w3.org/2001/XMLSchema";
factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);

解析器不会丢弃元素中的空白字符；
（有一种变通方法）【？？？】

生成XML文档

使用DOM

用文档的内容构建一棵DOM 树，然后再写出该树的所有内容。

构建：不带命名空间的XML

获取文档生成器工厂：

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
builder = factory.newDocumentBuilder();

得到空文档：
```
Document doc= builder.newDocument();
```

构建文档元素：

使用“Document”类的“createElement”方法；

Element rootElement = doc.createElement(rootName);
Element childElement = doc.createElement(childName);

构建文本节点：
使用“Document”类的“createTextNode”方法；
```
Text textNode = doc.createlextNode(textContents);
```
设置元素属性：
调用“Element”类的“setAttribute”方法；
```
rootElement.setAttribute(name, va1ue);
```

给文档添加根元素，给父结点添加子节点：

doc.appendChild(root Element);
rootElement.appendChild(child Element);
childElement.appendChild(textNode);

构建：带命名空间的XML

如果要使用命名空间．那么创建文档的过程就会稍微有些差异：

获取文档生成器工厂：（设置命名空间感知）

调用“DocumentBuilderFactory”对象的“setNamespaceAware”方法；

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
builder = factory.newDocumentBuilder();

构建文档元素：（设置元素的命名空间）

使用“Document”类的“createElementNS”而不是“createElement”；

String namespace = "http://www.w3.org/2000/svg";
Element rootElement = doc.createElementNS(namespace, "svg");

如果节点具有带命名空间前缀的限定名，那么所有必需的带有xmlns 前缀的属性都会被自动创建。

// 例如，如果需要在HTML 中包含SVG, 那么就可以像下面这样构建元素：
Element svgElement = doc.createElement(namespace, "svg:svg");

// 当该元素被写入XML 文件时，它会转变为：
// <svg:svg xmlns:svg="http://www.w3.org/2000/svg">

设置元素属性：（设置属性的命名空间）
使用“Element”类的“setAttributeNS”方法：
```
rootElement.setAttributeNS(namespace, qualifiedName, va1ue);
```

写出文档

把DOM 树写出到输出流中并非一件易事：

XSLT

最容易的方式是：“可扩展的样式表语言转换”（Extensible Stylesheet Language Transformations, XSLT）API。【更多信息参见：#XSL_转换】

// construct the do-nothing transformation
Transformer t = TransformerFactory.newlnstance().newTransformer();

// set output properties to get a DOCTYPE node
t.setOutputProperty(OutputKeys.DOCTYPUYSTEM, systemIdentifier);
t.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, publicIdentifier);

// set indentation
t.setOutputProperty(OutputKeys.INDENT, "yes");
t.setOutputProperty(OutputKeys.METHOD, "xml");
t.setOutputProperty("{http://xml.apache.org/xs1t}indent-amount", "2");

// apply the do-nothing transformation and send the output to a file
t.transform(new DOMSource(doc), new StreamResult(new FileOutputStream(file)));

以上：

把“不做任何操作”的转换应用于文档，并且捕获它的输出；
为了将DOCTYPE 节点纳入输出，我们还需要将SYSTEM 和PUBLIC 标识符设置为输出属性；

LSSerializer

另一种方式是使用“LSSerializer”接口：

获取“LSSerializer”实例：

DOMImplementation impl = doc.getImplementation();
DOMImplementationLS implLS = (DOMImplementationLS) impl.getFeature("LS", "3.0");
LSSerializer ser = implLS.createLSSerializer();

// 如果需要空格和换行，设置标志：
ser.getDomConfig().setParameter("format-pretty-print", true);

输出DOM：

输出到字符串：
```
String str = ser.writeToString(doc);
```

输出到文件：（需要一个“LSOutput”）

LSOutput out = implLS.createLSOutput();
out.setEncoding("UTF-8");
out.setByteStream(Fi1es.newOutputStream(path));
ser.write(doc, out);

使用StAX 写出XML文档

StAX API 使我们可以直接将XML 树写出：

从某个“OutputStream”中构建一个“XMLStreamWriter”：

XMLOutputfactory factory = XMLOutputfactory.newInstance();
XMLStreamWriter writer = factory.createXMLStreamWriter(out);

写入内容：

XML 文件开始

writer.writeStartDocument();

元素开始

writer.writeStartElement(name);

属性

writer.writeAttribute(name, value);

字符或子元素

writer.writeCharacters(text);

writer.writeStartElement(name);

 . . .
 
writer.writeEndElement();

元素结尾

writer.writeEndElement();

无子节点元素（如“<img .../>”）

writer.writeEmptyElement(name);

XML文件结尾

writer.writeEndDocument();

与使用DOM/XSLT 的方式一样，不必担心属性值和字符数据中的转义字符。
仍旧有可能会产生非良构的XML（例如具有多个根节点的文档）。
StAX 没有任何对产生缩进输出的支持。

示例

XSL 转换

XSL 转换( XSLT ) 机制可以指定将XML 文档转换为其他格式的规则，通常用于：

将某种机器可读的XML 格式转译为另一种机器可读的XML 格式
将XML 转译为适千人类阅读的表示格式

使用XSL需要提供“XSLT样式表”，它描述了XML 文档向某种其他格式转换的规则。

XSLT 处理器将读入XML文档和XSLT样式表，产生所要的输出：

XSLT处理器以检查根元素开始其处理过程：

每当一个节点匹配某个模板时，就会应用该模板（如果匹配多个模板，就会使用最佳匹配的那个）。如果没有匹配的模板，处理器会执行默认操作。
对于文本节点，默认操作是把它的内容囊括到输出中去。对于元素，默认操作是不产生任何输出，但会继续处理其子节点。

使用

在Java平台下产生XML的转换极其简单，只需为每个样式表设置一个转换器工厂，然后得到一个转换器对象，并告诉它把一个源转换成结果：

File styleSheet = new File(filename); 
StreamSource styleSource = new StreamSource(styleSheet); 
Transformer t = TransformerFactory.newInstance().newTransformer(styleSource); 
t.transform(source，result);

“transform”方法的参数是“Source”和“Result”接口的实现类的对象。

“Source”接口有4个实现类：
1. DOMSource
2. SAXSource
3. StAXSource
4. StreamSource
- 可以从一个文件、流、阅读器或URL中构建StreamSource对象，或者从DOM树节点中构建DOMSource对象。
- 将非XML的遗留数据转换成XML：
  t.transform(new SAXSource(newEmployeeReader(), new InputSource(new FilelnputStream(filename))), result);
- 大多数XSLT应用程序都已经有了XML格式的输入数据，只需要在一个StreamSource对象上调用transform方法即可：
  t.transform(newStrearnSource(file), result);
“Result”接口有3个实现类：
1. DOMResult
2. SAXResult
3. StreamResult
- 转换结果存储：
  1. 存储到DOM树中：
    使用“DocumentBuilder”产生一个新的文档节点，并将其包装到“DOMResult”中；
    Document doc= builder.newDocument(); t.transform(source, new DOMResult(doc));
  2. 保存到文件中：
    使用“StreamResult”；
    t.transform(source, new StreamResult(file));

XML	HTML
大小写敏感如：<H1> 和<hl> 是不同的XML 标签	不敏感
结束标签绝对不能省略	如果从上下文中可以分清哪里是段落或列表项的结尾，那么结束标签（如</p>或</li>) 就可以省略
只有单个标签而没有相对应的结束标签的元素必须以“/”结尾如：<img src="coffeecup.png"/ >
属性值必须用引号括起来如：<applet code="MyApplet.class" width="300" height="300">	引号是可有可无的如：<applet code="MyApplet.class" width=300 height=300>
所有属性必须都有属性值如：<input type="radio" name="1anguage" value="Java" checked="checked">	属性名可以没有值如：<input type="radio" name="1anguage" value="Java" checked>

核心技术Ⅱ：XML

XML概述

XML 文档的结构

解析XML文档

树型解析器

相关方法

流机制解析器

使用“SAX”解析器

相关方法

使用“StAX”解析器

相关方法

使用“XPath”

XPath表达式

使用XPath

相关方法

使用命名空间

关于

使用

相关方法

验证XML文档

文档类型定义

引入DTD的方式

元素规则

属性规则

使用DTD

相关方法

XML Schema

XML Schema规则

使用XML Schema

生成XML文档

使用DOM

构建：不带命名空间的XML

构建：带命名空间的XML

写出文档

XSLT

LSSerializer

相关方法

使用StAX 写出XML文档

相关方法

示例

XSL 转换

使用

相关方法

导航菜单

搜索