Schema详解
XML Schema 简介
XSD 为什么使用XML Schema 是基于 XML 的 DTD 替代者。XML Schema 可描述 XML 文档的结构。XML Schema 语言也可做为 XSD（XML Schema Definition）来引用。
在继续学习以前，您须要对下面的知识有基本的了解：HTML / XHTMLXML 以及 XML 命名空间对 DTD 的基本了解
XML Schema 的做用是定义 XML 文档的合法构建模块，相似 DTD。XML Schema:定义可出如今文档中的元素定义可出如今文档中的属性定义哪一个元素是子元素定义子元素的次序定义子元素的数目定义元素是否为空，或者是否可包含文本定义元素和属性的数据类型定义元素和属性的默认值以及固定值
XML Schema 是 DTD 的继任者咱们认为 XML Schema 很快会在大部分网络应用程序中取代 DTD。理由以下：XML Schema 可针对将来的需求进行扩展XML Schema 更完善，功能更强大XML Schema 基于 XML 编写XML Schema 支持数据类型XML Schema 支持命名空间
为何要使用 XML Schema？
XML Schema 支持数据类型XML Schema 最重要的能力之一就是对数据类型的支持。经过对数据类型的支持：可更容易地描述容许的文档内容可更容易地验证数据的正确性可更容易地与来自数据库的数据一并工做可更容易地定义数据约束（data facets）可更容易地定义数据模型（或称数据格式）可更容易地在不一样的数据类型间转换数据
注：数据约束，或称 facets，是 XML Schema 原型中的一个术语，中文可译为“面”，用来约束数据类型的允许值。
XML Schema 使用 XML 语法由 XML 编写 XML Schema 有不少好处：没必要学习新的语言可以使用 XML 编辑器来编辑 Schema 文件可以使用 XML 解析器来解析 Schema 文件可经过 XML DOM 来处理 Schema可经过 XSLT 来转换 Schema
XML Schema 可保护数据通讯当数据从发送方被发送到接受方时，其要点是双方应有关于内容的相同的“指望值”。经过 XML Schema，发送方能够用一种接受方可以明白的方式来描述数据。一种数据，好比 "03-11-2004"，在某些国家被解释为11月3日，而在另外一些国家为看成3月11日。可是一个带有数据类型的 XML 元素，好比：<date type="date">2004-03-11</date>，可确保对内容一致的理解，这是由于 XML 的数据类型 "date" 要求的格式是 "YYYY-MM-DD"。
XML Schema 可扩展XML Schema 是可扩展的，由于它们由 XML 编写。经过可扩展的 Schema 定义，您能够：在其余 Schema 中重复使用您的 Schema建立由标准类型衍生而来的您本身的数据类型在相同的文档中引用多重的 Schema
形式良好是不够的咱们把符合 XML 语法的文档称为形式良好的 XML 文档，好比：它必须以 XML 声明开头它必须拥有惟一的根元素开始标签必须与结束标签相匹配元素对大小写敏感全部的元素都必须关闭全部的元素都必须正确地嵌套必须对特殊字符使用实体即便文档的形式良好，仍然不能保证它们不会包含错误，而且这些错误可能会产生严重的后果。请考虑下面的状况：您订购的了 5 打激光打印机，而不是 5 台。经过 XML Schema，大部分这样的错误会被您的验证软件捕获到。
如何使用 XSD？
XML 文档可对 DTD 或 XML Schema 进行引用。一个简单的 XML 文档：请看这个名为 "note.xml" 的 XML 文档：<?xml version="1.0"?><note><to>George</to><from>John</from><heading>Reminder</heading><body>Don't forget the meeting!</body></note>
DTD 文件下面这个例子是名为 "note.dtd" 的 DTD 文件，它对上面那个 XML 文档的元素进行了定义：<!ELEMENT note (to, from, heading, body)><!ELEMENT to (#PCDATA)><!ELEMENT from (#PCDATA)><!ELEMENT heading (#PCDATA)><!ELEMENT body (#PCDATA)>
第 1 行定义 note 元素有四个子元素："to, from, heading, body"。第 2-5 行定义了 to, from, heading, body 元素的类型是 "#PCDATA"。XML Schema下面这个例子是一个名为 "note.xsd" 的 XML Schema 文件，它定义了上面那个 XML 文档的元素：<?xml version="1.0"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"targetNamespace="http://www.w3school.com.cn"xmlns="http://www.w3school.com.cn"elementFormDefault="qualified"><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></xs:schema>
note 元素是一个复合类型，由于它包含其余的子元素。其余元素 (to, from, heading, body) 是简易类型，由于它们没有包含其余元素。对 DTD 的引用此文件包含对 DTD 的引用：<?xml version="1.0"?><!DOCTYPE note SYSTEM "http://www.w3school.com.cn/dtd/note.dtd"><note><to>George</to><from>John</from><heading>Reminder</heading><body>Don't forget the meeting!</body></note>
对 XML Schema 的引用此文件包含对 XML Schema 的引用：<?xml version="1.0"?><notexmlns="http://www.w3school.com.cn"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.w3school.com.cn note.xsd"><to>George</to><from>John</from><heading>Reminder</heading><body>Don't forget the meeting!</body></note>
XSD - <schema> 元素
<schema> 元素是每个 XML Schema 的根元素：<?xml version="1.0"?><xs:schema>......</xs:schema>
<schema> 元素可包含属性。一个 schema 声明每每看上去相似这样：<?xml version="1.0"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"targetNamespace="http://www.w3school.com.cn"xmlns="http://www.w3school.com.cn"elementFormDefault="qualified">......</xs:schema>
代码解释：xmlns:xs="http://www.w3.org/2001/XMLSchema"
显示 schema 中用到的元素和数据类型来自命名空间 "http://www.w3.org/2001/XMLSchema"。同时它还规定了来自命名空间 "http://www.w3.org/2001/XMLSchema" 的元素和数据类型应该使用前缀 xs：targetNamespace="http://www.w3school.com.cn"
声明（只是声明，并不能说明当前schema默认使用该命名空间）被此 schema 定义的元素 (note, to, from, heading, body) 属于命名空间： "http://www.w3school.com.cn"。xmlns="http://www.w3school.com.cn"
指出默认使用的命名空间。与targetNamespace相同，说明默认使用当前命名空间 。elementFormDefault="qualified"
指出任何 XML 实例文档所使用的且在此 schema 中声明过的元素必须被命名空间限定。<?xml version="1.0" encoding="UTF-8"?><sp:note xmlns:sp="http://www.w3school.com.cn" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.w3school.com.cn note.xsd"><!--note.xsd使用elementFormDefault="unqualified"--> <to>George</to> <from>John</from> <heading>Reminder</heading> <body>Don't forget the meeting!</body></sp:note>
<?xml version="1.0" encoding="UTF-8"?><sp:note xmlns:sp="http://www.w3school.com.cn" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.w3school.com.cn note.xsd"><!--note.xsd使用elementFormDefault="qualified"--> <sp:to>George</sp:to> <sp:from>John</sp:from> <sp:heading>Reminder</sp:heading> <sp:body>Don't forget the meeting!</sp:body></sp:note>
命名空间 http://www.w3.org/2001/XMLSchema声明的元素最终由 http://www.w3.org/2001/XMLSchema.dtd校验
此 XML 文档含有对 XML Schema 的引用：<?xml version="1.0"?><note xmlns="http://www.w3school.com.cn"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.w3school.com.cn note.xsd"><to>George</to><from>John</from><heading>Reminder</heading><body>Don't forget the meeting!</body></note>
xmlns="http://www.w3school.com.cn"规定了默认命名空间的声明。此声明会告知 schema 验证器，在此 XML 文档中使用的全部元素都属于 "http://www.w3school.com.cn" 这个命名空间。
一旦您拥有了可用的 XML Schema 实例命名空间：xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"您就可使用 schemaLocation 属性了。该属性将具备目标命名空间的 XSD文档与实例文档相关联。此属性有两个值： "http://www.w3school.com.cn note.xsd "第一个值是须要使用的命名空间。第二个值是供命名空间使用的 XML schema 的位置：xsi:schemaLocation="http://www.w3school.com.cn note.xsd"提供多个指定命名空间的XSD文档的位置信息
xsi:schemaLocation= "http://contoso.com/People http://contoso.com/schemas/people.xsd http://contoso.com/schemas/Vehicles http://contoso.com/schemas/vehicles.xsd http://contoso.com/schemas/People http://contoso.com/schemas/people.xsd"
XSD 简易元素
XML Schema 可定义 XML 文件的元素。简易元素指那些只包含文本的元素。它不会包含任何其余的元素或属性。不过，“仅包含文本”这个限定却很容易形成误解。文本有不少类型。它能够是 XML Schema 定义中包括的类型中的一种（布尔、字符串、数据等等），或者它也能够是您自行定义的定制类型。您也可向数据类型添加限定（即 facets），以此来限制它的内容，或者您能够要求数据匹配某种特定的模式。定义简易元素<xs:element name="xxx" type="yyy"/>此处 xxx 指元素的名称，yyy 指元素的数据类型。XML Schema 拥有不少内建的数据类型。最经常使用的类型是：xs:string xs:decimal xs:integer xs:boolean xs:date xs:time例子： 这是一些 XML 元素：<lastname>Smith</lastname><age>28</age><dateborn>1980-03-27</dateborn>
这是相应的简易元素定义：<xs:element name="lastname" type="xs:string"/><xs:element name="age" type="xs:integer"/><xs:element name="dateborn" type="xs:date"/>
简易元素的默认值和固定值简易元素可拥有指定的默认值或固定值。当没有其余的值被规定时，默认值就会自动分配给元素。在下面的例子中，缺省值是 "red"：<xs:element name="color" type="xs:string" default="red"/>固定值一样会自动分配给元素，而且您没法规定另一个值。在下面的例子中，固定值是 "red"：<xs:element name="color" type="xs:string" fixed="red"/>
XSD 属性
什么是属性？简易元素没法拥有属性。假如某个元素拥有属性，它就会被看成某种复合类型。可是属性自己老是做为简易类型被声明的。如何声明属性？定义属性的语法是：<xs:attribute name="xxx" type="yyy"/>在此处，xxx 指属性名称，yyy 则规定属性的数据类型。XML Schema 拥有不少内建的数据类型。最经常使用的类型是： xs:string xs:decimal xs:integer xs:boolean xs:date xs:time实例这是带有属性的 XML 元素：<lastname lang="EN">Smith</lastname>这是对应的属性定义：<xs:attribute name="lang" type="xs:string"/>
属性的默认值和固定值属性可拥有指定的默认值或固定值。当没有其余的值被规定时，默认值就会自动分配给元素。在下面的例子中，缺省值是 "EN"：<xs:attribute name="lang" type="xs:string" default="EN"/>固定值一样会自动分配给元素，而且您没法规定另外的值。在下面的例子中，固定值是 "EN"：<xs:attribute name="lang" type="xs:string" fixed="EN"/>可选的和必需的属性在缺省的状况下，属性是可选的。如需规定属性为必选，请使用 "use" 属性：<xs:attribute name="lang" type="xs:string" use="required"/>对内容的限定当 XML 元素或属性拥有被定义的数据类型时，就会向元素或属性的内容添加限定。假如 XML 元素的类型是 "xs:date"，而其包含的内容是相似 "Hello World" 的字符串，元素将不会（经过）验证。
经过 XML schema，您也可向您的 XML 元素及属性添加本身的限定。这些限定被称为 facet（可译为限定面）。
XSD 限定 / Facets
限定（restriction）用于为 XML 元素或者属性定义可接受的值。对 XML 元素的限定被称为 facet。对值的限定下面的例子定义了带有一个限定且名为 "age" 的元素。age 的值不能低于 0 或者高于 120：<xs:element name="age"><xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="0"/> <xs:maxInclusive value="120"/> </xs:restriction></xs:simpleType></xs:element>
对一组值的限定如需把 XML 元素的内容限制为一组可接受的值，咱们要使用枚举约束（enumeration constraint）。下面的例子定义了带有一个限定的名为 "car" 的元素。可接受的值只有：Audi, Golf, BMW：<xs:element name="car"><xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction></xs:simpleType></xs:element>
上面的例子也能够被写为：<xs:element name="car" type="carType"/><xs:simpleType name="carType"> <xs:restriction base="xs:string"> <xs:enumeration value="Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction></xs:simpleType>
注释：在这种状况下，类型 "carType" 可被其余元素使用，由于它不是 "car" 元素的组成部分。对一系列值的限定如需把 XML 元素的内容限制定义为一系列可以使用的数字或字母，咱们要使用模式约束（pattern constraint）。下面的例子定义了带有一个限定的名为 "letter" 的元素。可接受的值只有小写字母 a - z 其中的一个：<xs:element name="letter"><xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-z]"/> </xs:restriction></xs:simpleType></xs:element>
下一个例子定义了带有一个限定的名为 "initials" 的元素。可接受的值是大写字母 A - Z 其中的三个：<xs:element name="initials"><xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[A-Z][A-Z][A-Z]"/> </xs:restriction></xs:simpleType></xs:element>
下一个例子也定义了带有一个限定的名为 "initials" 的元素。可接受的值是大写或小写字母 a - z 其中的三个：<xs:element name="initials"><xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-zA-Z][a-zA-Z][a-zA-Z]"/> </xs:restriction></xs:simpleType></xs:element>
下一个例子定义了带有一个限定的名为 "choice 的元素。可接受的值是字母 x, y 或 z 中的一个：<xs:element name="choice"><xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[xyz]"/> </xs:restriction></xs:simpleType></xs:element>
下一个例子定义了带有一个限定的名为 "prodid" 的元素。可接受的值是五个阿拉伯数字的一个序列，且每一个数字的范围是 0-9：<xs:element name="prodid"><xs:simpleType> <xs:restriction base="xs:integer"> <xs:pattern value="[0-9][0-9][0-9][0-9][0-9]"/> </xs:restriction></xs:simpleType></xs:element>
对一系列值的其余限定下面的例子定义了带有一个限定的名为 "letter" 的元素。可接受的值是 a - z 中零个或多个字母：<xs:element name="letter"><xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="([a-z])*"/> </xs:restriction></xs:simpleType></xs:element>
下面的例子定义了带有一个限定的名为 "letter" 的元素。可接受的值是一对或多对字母，每对字母由一个小写字母后跟一个大写字母组成。举个例子，"sToP"将会经过这种模式的验证，可是 "Stop"、"STOP" 或者 "stop" 没法经过验证：<xs:element name="letter"><xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="([a-z][A-Z])+"/> </xs:restriction></xs:simpleType></xs:element>
下面的例子定义了带有一个限定的名为 "gender" 的元素。可接受的值是 male 或者 female：<xs:element name="gender"><xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="male|female"/> </xs:restriction></xs:simpleType></xs:element>
下面的例子定义了带有一个限定的名为 "password" 的元素。可接受的值是由 8 个字符组成的一行字符，这些字符必须是大写或小写字母 a - z 亦或数字 0 - 9：<xs:element name="password"><xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-zA-Z0-9]{8}"/> </xs:restriction></xs:simpleType></xs:element>
对空白字符的限定如需规定对空白字符（whitespace characters）的处理方式，咱们须要使用 whiteSpace 限定。下面的例子定义了带有一个限定的名为 "address" 的元素。这个 whiteSpace 限定被设置为 "preserve"，这意味着 XML 处理器不会移除任何空白字符：<xs:element name="address"><xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="preserve"/> </xs:restriction></xs:simpleType></xs:element>
这个例子也定义了带有一个限定的名为 "address" 的元素。这个 whiteSpace 限定被设置为 "replace"，这意味着 XML 处理器将移除全部空白字符（换行、回车、空格以及制表符）：<xs:element name="address"><xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="replace"/> </xs:restriction></xs:simpleType></xs:element>
这个例子也定义了带有一个限定的名为 "address" 的元素。这个 whiteSpace 限定被设置为 "collapse"，这意味着 XML 处理器将移除全部空白字符（换行、回车、空格以及制表符会被替换为空格，开头和结尾的空格会被移除，而多个连续的空格会被缩减为一个单一的空格）：<xs:element name="address"><xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="collapse"/> </xs:restriction></xs:simpleType></xs:element>
对长度的限定如需限制元素中值的长度，咱们须要使用 length、maxLength 以及 minLength 限定。本例定义了带有一个限定且名为 "password" 的元素。其值必须精确到 8 个字符：<xs:element name="password"><xs:simpleType> <xs:restriction base="xs:string"> <xs:length value="8"/> </xs:restriction></xs:simpleType></xs:element>
这个例子也定义了带有一个限定的名为 "password" 的元素。其值最小为 5 个字符，最大为 8 个字符：<xs:element name="password"><xs:simpleType> <xs:restriction base="xs:string"> <xs:minLength value="5"/> <xs:maxLength value="8"/> </xs:restriction></xs:simpleType></xs:element>
数据类型的限定
限定 描述 enumeration 定义可接受值的一个列表 fractionDigits 定义所容许的最大的小数位数。必须大于等于0。 length 定义所容许的字符或者列表项目的精确数目。必须大于或等于0。 maxExclusive 定义数值的上限。所容许的值必须小于此值。 maxInclusive 定义数值的上限。所容许的值必须小于或等于此值。 maxLength 定义所容许的字符或者列表项目的最大数目。必须大于或等于0。 minExclusive 定义数值的下限。所容许的值必需大于此值。 minInclusive 定义数值的下限。所容许的值必需大于或等于此值。 minLength 定义所容许的字符或者列表项目的最小数目。必须大于或等于0。 pattern 定义可接受的字符的精确序列。 totalDigits 定义所容许的阿拉伯数字的精确位数。必须大于0。 whiteSpace 定义空白字符（换行、回车、空格以及制表符）的处理方式。
XSD 复合元素
什么是复合元素？复合元素指包含其余元素及/或属性的 XML 元素。有四种类型的复合元素：空元素包含其余元素的元素仅包含文本的元素包含元素和文本的元素注释：上述元素都可包含属性！
复合元素的例子复合元素，"product"，是空的：<product pid="1345"/>复合元素，"employee"，仅包含其余元素：<employee><firstname>John</firstname><lastname>Smith</lastname></employee>
复合元素，"food"，仅包含文本：<food type="dessert">Ice cream</food>复合元素，"description"，包含元素和文本：<description>It happened on <date lang="norwegian">03.03.99</date> ....</description>
如何定义复合元素？请看这个复合 XML 元素，"employee"，仅包含其余元素：<employee><firstname>John</firstname><lastname>Smith</lastname></employee>
在 XML Schema 中，咱们有两种方式来定义复合元素：1. 经过命名此元素，可直接对"employee"元素进行声明 ，就像这样：<xs:element name="employee"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType></xs:element>
假如您使用上面所描述的方法，那么仅有 "employee" 可以使用所规定的复合类型。请注意其子元素，"firstname" 以及 "lastname"，被包围在指示器 <sequence>中。这意味着子元素必须以它们被声明的次序出现。2. "employee" 元素可使用 type 属性，这个属性的做用是引用要使用的复合类型的名称 ：<xs:element name="employee" type="personinfo"/><xs:complexType name="personinfo"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence></xs:complexType>
若是您使用了上面所描述的方法，那么若干元素都可以使用相同的复合类型，好比这样：<xs:element name="employee" type="personinfo"/><xs:element name="student" type="personinfo"/><xs:element name="member" type="personinfo"/><xs:complexType name="personinfo"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence></xs:complexType>
您也能够在已有的复合元素之上以某个复合元素为基础，而后添加一些元素，就像这样：<xs:element name="employee" type="fullpersoninfo"/><xs:complexType name="personinfo"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence></xs:complexType><xs:complexType name="fullpersoninfo"> <xs:complexContent> <xs:extension base="personinfo"> <xs:sequence> <xs:element name="address" type="xs:string"/> <xs:element name="city" type="xs:string"/> <xs:element name="country" type="xs:string"/> </xs:sequence> </xs:extension> </xs:complexContent></xs:complexType>
XSD 复合空元素
空的复合元素不能包含内容，只能含有属性。复合空元素：一个空的 XML 元素：<product prodid="1345" />上面的 "product" 元素根本没有内容。为了定义无内容的类型，咱们就必须声明一个在其内容中只能包含元素的类型，可是实际上咱们并不会声明任何元素，好比这样：<xs:element name="product"> <xs:complexType> <xs:complexContent> <xs:restriction base="xs:integer"> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:restriction> </xs:complexContent> </xs:complexType></xs:element>
在上面的例子中，咱们定义了一个带有复合内容的复合类型。complexContent 元素给出的信号是，咱们打算限定或者拓展某个复合类型的内容模型，而 integer 限定则声明了一个属性但不会引入任何的元素内容。
不过，也能够更加紧凑地声明此 "product" 元素：<xs:element name="product"> <xs:complexType> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:complexType></xs:element>
或者您能够为一个 complexType 元素起一个名字，而后为 "product" 元素设置一个 type 属性并引用这个 complexType 名称（经过使用此方法，若干个元素都可引用相同的复合类型）：<xs:element name="product" type="prodtype"/><xs:complexType name="prodtype"> <xs:attribute name="prodid" type="xs:positiveInteger"/></xs:complexType>
XSD 复合类型 - 仅含元素
“仅含元素”的复合类型元素是只能包含其余元素的元素 。复合类型仅包含元素XML 元素，"person"，仅包含其余的元素：<person><firstname>John</firstname><lastname>Smith</lastname></person>
您可在 schema 中这样定义 "person" 元素：<xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType></xs:element>
请留意这个 <xs:sequence>。它意味着被定义的元素必须按上面的次序出如今 "person" 元素中。或者您能够为 complexType 元素设定一个名称，并让 "person" 元素的 type 属性来引用此名称（如使用此方法，若干元素都可引用相同的复合类型）：<xs:element name="person" type="persontype"/><xs:complexType name="persontype"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence></xs:complexType>
XSD 仅含文本复合元素
此类型仅包含简易的内容（文本和属性），所以咱们要向此内容添加 simpleContent 元素。当使用简易内容时，咱们就必须在 simpleContent 元素内定义扩展或限定，就像这样：<xs:element name="某个名称"> <xs:complexType> <xs:simpleContent> <xs:extension base="basetype"> .... .... </xs:extension> </xs:simpleContent> </xs:complexType></xs:element>
或者：<xs:element name="某个名称"> <xs:complexType> <xs:simpleContent> <xs:restriction base="basetype"> .... .... </xs:restriction> </xs:simpleContent> </xs:complexType></xs:element>
提示： 请使用 extension 或 restriction 元素来扩展或限制元素的基本简易类型。这里有一个 XML 元素的例子，"shoesize"，其中仅包含文本：<shoesize country="france">35</shoesize>下面这个例子声明了一个复合类型，其内容被定义为整数值，而且 "shoesize" 元素含有名为 "country" 的属性：<xs:element name="shoesize"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:integer"> <xs:attribute name="country" type="xs:string" /> </xs:extension> </xs:simpleContent> </xs:complexType></xs:element>
咱们也可为 complexType 元素设定一个名称，并让 "shoesize" 元素的 type 属性来引用此名称（经过使用此方法，若干元素都可引用相同的复合类型）：<xs:element name="shoesize" type="shoetype"/><xs:complexType name="shoetype"> <xs:simpleContent> <xs:extension base="xs:integer"> <xs:attribute name="country" type="xs:string" /> </xs:extension> </xs:simpleContent></xs:complexType>
XSD 带有混合内容的复合类型
混合的复合类型可包含属性、元素以及文本。带有混合内容的复合类型XML 元素，"letter"，含有文本以及其余元素：<letter>Dear Mr.<name>John Smith</name>.Your order <orderid>1032</orderid>will be shipped on <shipdate>2001-07-13</shipdate>.</letter>
下面这个 schema 声明了这个 "letter" 元素：<xs:element name="letter"> <xs:complexType mixed="true"> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveInteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence> </xs:complexType></xs:element>
注释：为了使字符数据能够出如今 "letter" 的子元素之间，mixed 属性必须被设置为 "true"。<xs:sequence> 标签 (name、orderid 以及 shipdate ) 意味着被定义的元素必须依次出如今 "letter" 元素内部。咱们也能够为 complexType 元素起一个名字，并让 "letter" 元素的 type 属性引用 complexType 的这个名称（经过这个方法，若干元素都可引用同一个复合类型）：<xs:element name="letter" type="lettertype"/><xs:complexType name="lettertype" mixed="true"> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveInteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence></xs:complexType>
XSD 复合类型指示器
经过指示器，咱们能够控制在文档中使用元素的方式。有七种指示器：Order 指示器：AllChoiceSequenceOccurrence 指示器：maxOccursminOccursGroup 指示器：Group nameattributeGroup nameOrder 指示器Order 指示器用于定义元素的顺序。All 指示器<all> 指示器规定子元素能够按照任意顺序出现，且每一个子元素必须只出现一次：<xs:element name="person"> <xs:complexType> <xs:all> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:all> </xs:complexType></xs:element>
注释：当使用 <all> 指示器时，你能够把 <minOccurs> 设置为 0 或者 1，而只能把 <maxOccurs> 指示器设置为 1（稍后将讲解 <minOccurs> 以及 <maxOccurs>）。Choice 指示器<choice> 指示器规定可出现某个子元素或者可出现另一个子元素（非此即彼）：<xs:element name="person"> <xs:complexType> <xs:choice> <xs:element name="employee" type="employee"/> <xs:element name="member" type="member"/> </xs:choice> </xs:complexType></xs:element>
提示：如需设置子元素出现任意次数，可将 <maxOccurs> （稍后会讲解）设置为 unbounded（无限次）。Sequence 指示器<sequence> 规定子元素必须按照特定的顺序出现：<xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType></xs:element>
Occurrence 指示器Occurrence 指示器用于定义某个元素出现的频率。注释：对于全部的 "Order" 和 "Group" 指示器（any、all、choice、sequence、group name 以及 group reference），其中的 maxOccurs 以及 minOccurs 的默认值均为 1。maxOccurs 指示器<maxOccurs> 指示器可规定某个元素可出现的最大次数：<xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="full_name" type="xs:string"/> <xs:element name="child_name" type="xs:string" maxOccurs="10"/> </xs:sequence> </xs:complexType></xs:element>
上面的例子代表，子元素 "child_name" 可在 "person" 元素中最少出现一次（其中 minOccurs 的默认值是 1），最多出现 10 次。minOccurs 指示器<minOccurs> 指示器可规定某个元素可以出现的最小次数：<xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="full_name" type="xs:string"/> <xs:element name="child_name" type="xs:string" maxOccurs="10" minOccurs="0"/> </xs:sequence> </xs:complexType></xs:element>
上面的例子代表，子元素 "child_name" 可在 "person" 元素中出现最少 0 次，最多出现 10 次。提示：如需使某个元素的出现次数不受限制，请使用 maxOccurs="unbounded" 这个声明：一个实际的例子：名为 "Myfamily.xml" 的 XML 文件：<?xml version="1.0" encoding="ISO-8859-1"?><persons xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="family.xsd"><person><full_name>Tony Smith</full_name><child_name>Cecilie</child_name></person><person><full_name>David Smith</full_name><child_name>Jogn</child_name><child_name>mike</child_name><child_name>kyle</child_name><child_name>mary</child_name></person><person><full_name>Michael Smith</full_name></person></persons>
上面这个 XML 文件含有一个名为 "persons" 的根元素。在这个根元素内部，咱们定义了三个 "person" 元素。每一个 "person" 元素必须含有一个 "full_name" 元素，同时它能够包含多至 5 个 "child_name" 元素。这是schema文件"family.xsd"：<?xml version="1.0" encoding="ISO-8859-1"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"elementFormDefault="qualified"><xs:element name="persons"> <xs:complexType> <xs:sequence> <xs:element name="person" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="full_name" type="xs:string"/> <xs:element name="child_name" type="xs:string" minOccurs="0" maxOccurs="5"/> </xs:sequence> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType></xs:element></xs:schema>
Group 指示器Group 指示器用于定义相关的数批元素。元素组元素组经过 group 声明进行定义：<xs:group name="组名称"> ...</xs:group>
您必须在 group 声明内部定义一个 all、choice 或者 sequence 元素。下面这个例子定义了名为 "persongroup" 的 group，它定义了必须按照精确的顺序出现的一组元素：<xs:group name="persongroup"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> <xs:element name="birthday" type="xs:date"/> </xs:sequence></xs:group>
在您把 group 定义完毕之后，就能够在另外一个定义中引用它了：<xs:group name="persongroup"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> <xs:element name="birthday" type="xs:date"/> </xs:sequence></xs:group>
<xs:element name="person" type="personinfo"/><xs:complexType name="personinfo"> <xs:sequence> <xs:group ref="persongroup"/> <xs:element name="country" type="xs:string"/> </xs:sequence></xs:complexType>属性组属性组经过 attributeGroup 声明来进行定义：<xs:attributeGroup name="组名称"> ...</xs:attributeGroup>
下面这个例子定义了名为 "personattrgroup" 的一个属性组：<xs:attributeGroup name="personattrgroup"> <xs:attribute name="firstname" type="xs:string"/> <xs:attribute name="lastname" type="xs:string"/> <xs:attribute name="birthday" type="xs:date"/></xs:attributeGroup>
在您已定义完毕属性组以后，就能够在另外一个定义中引用它了，就像这样：<xs:attributeGroup name="personattrgroup"> <xs:attribute name="firstname" type="xs:string"/> <xs:attribute name="lastname" type="xs:string"/> <xs:attribute name="birthday" type="xs:date"/></xs:attributeGroup><xs:element name="person"> <xs:complexType> <xs:attributeGroup ref="personattrgroup"/> </xs:complexType></xs:element>
XSD <any> 元素
<any> 元素使咱们有能力经过未被 schema 规定的元素来拓展 XML 文档！下面这个例子是从名为 "family.xsd" 的 XML schema 中引用的片断。它展现了一个针对 "person" 元素的声明。经过使用 <any> 元素，咱们能够经过任何元素（在 <lastname> 以后）扩展 "person" 的内容：<xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> <xs:any minOccurs="0"/> </xs:sequence> </xs:complexType></xs:element>
如今，咱们但愿使用 "children" 元素来扩展 "person" 元素。这此种状况下咱们就能够这么作，即便以上这个 schema 的没有声明任何 "children" 元素。请看这个 schema 文件，名为 "children.xsd"：<?xml version="1.0" encoding="ISO-8859-1"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"targetNamespace="http://www.w3school.com.cn"xmlns="http://www.w3school.com.cn"elementFormDefault="qualified"><xs:element name="children"> <xs:complexType> <xs:sequence> <xs:element name="childname" type="xs:string" maxOccurs="unbounded"/> </xs:sequence> </xs:complexType></xs:element></xs:schema>
下面这个 XML 文件（名为 "Myfamily.xml"），使用了来自两个不一样的 schema 中的成分，"family.xsd" 和 "children.xsd"：<?xml version="1.0" encoding="ISO-8859-1"?><persons xmlns="http://www.microsoft.com"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:SchemaLocation="http://www.microsoft.com family.xsdhttp://www.w3school.com.cn children.xsd"><person><firstname>David</firstname><lastname>Smith</lastname><children> <childname>mike</childname></children></person><person><firstname>Tony</firstname><lastname>Smith</lastname></person></persons>
上面这个 XML 文件是有效的，这是因为 schema "family.xsd" 容许咱们经过在 "lastname" 元素后的可选元素来扩展 "person" 元素。<any> 和 <anyAttribute> 都可用于制做可扩展的文档！它们使文档有能力包含未在主 XML schema 中声明过的附加元素。
XSD <anyAttribute> 元素
<anyAttribute> 元素使咱们有能力经过未被 schema 规定的属性来扩展 XML 文档！下面的例子是来自名为 "family.xsd" 的 XML schema 的一个片断。它为咱们展现了针对 "person" 元素的一个声明。经过使用 <anyAttribute> 元素，咱们就能够向 "person" 元素添加任意数量的属性：<xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> <xs:anyAttribute/> </xs:complexType></xs:element>
如今，咱们但愿经过 "gender" 属性来扩展 "person" 元素。在这种状况下咱们就能够这样作，即便这个 schema 的做者从未声明过任何 "gender" 属性。请看这个 schema 文件，名为 "attribute.xsd"：<?xml version="1.0" encoding="ISO-8859-1"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"targetNamespace="http://www.w3school.com.cn"xmlns="http://www.w3school.com.cn"elementFormDefault="qualified"><xs:attribute name="gender"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="male|female"/> </xs:restriction> </xs:simpleType></xs:attribute></xs:schema>
下面这个 XML（名为 "Myfamily.xml"），使用了来自不一样 schema 的成分，"family.xsd" 和 "attribute.xsd"：<?xml version="1.0" encoding="ISO-8859-1"?><persons xmlns="http://www.microsoft.com"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:SchemaLocation="http://www.microsoft.com family.xsdhttp://www.w3school.com.cn attribute.xsd"><person gender="female"><firstname>Jane</firstname><lastname>Smith</lastname></person><person gender="male"><firstname>David</firstname><lastname>Smith</lastname></person></persons>
上面这个 XML 文件是有效的，这是由于 schema "family.xsd" 容许咱们向 "person" 元素添加属性。<any> 和 <anyAttribute> 都可用于制做可扩展的文档！它们使文档有能力包含未在主 XML schema 中声明过的附加元素。
XSD 元素替换（Element Substitution）
经过 XML Schema，一个元素可对另外一个元素进行替换。元素替换让咱们举例说明：咱们的用户来自英国和挪威。咱们但愿有能力让用户选择在 XML 文档中使用挪威语的元素名称仍是英语的元素名称。为了解决这个问题，咱们能够在 XML schema 中定义一个 substitutionGroup。首先，咱们声明主元素，而后咱们会声明次元素，这些次元素可声明它们可以替换主元素。<xs:element name="name" type="xs:string"/><xs:element name="navn" substitutionGroup="name"/>
在上面的例子中，"name" 元素是主元素，而 "navn" 元素可替代 "name" 元素。请看一个 XML schema 的片断：<xs:element name="name" type="xs:string"/><xs:element name="navn" substitutionGroup="name"/><xs:complexType name="custinfo"> <xs:sequence> <xs:element ref="name"/> </xs:sequence></xs:complexType><xs:element name="customer" type="custinfo"/><xs:element name="kunde" substitutionGroup="customer"/>
有效的 XML 文档相似这样（根据上面的 schema）：<customer> <name>John Smith</name></customer>
或相似这样：<kunde> <navn>John Smith</navn></kunde>
阻止元素替换为防止其余的元素替换某个指定的元素，请使用 block 属性：<xs:element name="name" type="xs:string" block="substitution"/>请看某个 XML schema 的片断：<xs:element name="name" type="xs:string" block="substitution"/><xs:element name="navn" substitutionGroup="name"/><xs:complexType name="custinfo"> <xs:sequence> <xs:element ref="name"/> </xs:sequence></xs:complexType><xs:element name="customer" type="custinfo" block="substitution"/><xs:element name="kunde" substitutionGroup="customer"/>
合法的 XML 文档应该相似这样（根据上面的 schema）：<customer> <name>John Smith</name></customer>
可是下面的文档再也不合法：<kunde> <navn>John Smith</navn></kunde>
使用 substitutionGroup可替换元素的类型必须和主元素相同，或者从主元素衍生而来。假如可替换元素的类型与主元素的类型相同，那么您就没必要规定可替换元素的类型了。请注意， substitutionGroup 中的全部元素（主元素和可替换元素）必须被声明为全局元素，不然就没法工做！什么是全局元素（Global Elements）？全局元素指 "schema" 元素的直接子元素！本地元素（Local elements）指嵌套在其余元素中的元素。
一个 XSD 实例
本节会为您演示如何编写一个 XML Schema。您还将学习到编写 schema 的不一样方法。XML 文档让咱们看看这个名为 "shiporder.xml" 的 XML 文档：<?xml version="1.0" encoding="ISO-8859-1"?><shiporder orderid="889923"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="shiporder.xsd"> <orderperson>George Bush</orderperson> <shipto> <name>John Adams</name> <address>Oxford Street</address> <city>London</city> <country>UK</country> </shipto> <item> <title>Empire Burlesque</title> <note>Special Edition</note> <quantity>1</quantity> <price>10.90</price> </item> <item> <title>Hide your heart</title> <quantity>1</quantity> <price>9.90</price> </item></shiporder>
上面的XML文档包括根元素 "shiporder"，其中包含必须名为 "orderid" 的属性。"shiporder" 元素包含三个不一样的子元素："orderperson"、"shipto" 以及 "item"。"item" 元素出现了两次，它含有一个 "title"、一个可选 "note" 元素、一个 "quantity" 以及一个 "price" 元素。上面这一行 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"，告知XML解析器根据某个 schema 来验证此文档。 这一行：xsi:noNamespaceSchemaLocation="shiporder.xsd" 规定了 schema 的位置（在这里，它与 "shiporder.xml" 处于相同的文件夹）。建立一个 XML Schema如今，咱们须要为上面这个 XML 文档建立一个 schema。咱们能够经过打开一个新的文件来开始，并把这个文件命名为 "shiporder.xsd"。要建立schema，咱们仅仅须要简单地遵循 XML 文档中的结构，定义咱们所发现的每一个元素。首先咱们开始定义一个标准的 XML 声明：<?xml version="1.0" encoding="ISO-8859-1" ?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">......</xs:schema>
在上面的 schema 中，咱们使用了标准的命名空间 (xs)，与此命名空间相关联的 URI 是 Schema 的语言定义（Schema language definition），其标准值是 http://www.w3.org/2001/XMLSchema。接下来，咱们须要定义 "shiporder" 元素。此元素拥有一个属性，其中包含其余的元素，所以咱们将它认定为复合类型。"shiporder" 元素的子元素被 xs:sequence 元素包围，定义了子元素的次序：<xs:element name="shiporder"> <xs:complexType> <xs:sequence> ... ... </xs:sequence> ... </xs:complexType></xs:element>
而后咱们须要把 "orderperson" 元素定义为简易类型（这是由于它不包含任何属性或者其余的元素）。类型 (xs:string) 的前缀是由命名空间的前缀规定的，此命名空间与指示预约义的 schema 数据类型的 XML schema 相关联：<xs:element name="orderperson" type="xs:string"/>接下来，我须要把两个元素定义为复合类型："shipto" 和 "item"。咱们从定义 "shipto" 元素开始：<xs:element name="shipto"> <xs:complexType> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="address" type="xs:string"/> <xs:element name="city" type="xs:string"/> <xs:element name="country" type="xs:string"/> </xs:sequence> </xs:complexType></xs:element>
经过 schema，咱们可以使用 maxOccurs 和 minOccurs 属性来定义某个元素可能出现的次数。maxOccurs 定义某元素出现次数的最大值，而 minOccurs 则定义某元素出现次数的最小值。maxOccurs 和 minOccurs 的默认值都是 1！如今，咱们能够定义 "item" 元素了。这个元素可在 "shiporder" 元素内部出现屡次。这是经过把 "item" 元素的 maxOccurs 属性的值设定为 "unbounded" 来实现的，这样 "item" 元素就可出现创做者所但愿的任意屡次。请注意，"note" 元素是可选元素。咱们已经把此元素的 minOccurs 属性设定为 0 了：<xs:element name="item" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="title" type="xs:string"/> <xs:element name="note" type="xs:string" minOccurs="0"/> <xs:element name="quantity" type="xs:positiveInteger"/> <xs:element name="price" type="xs:decimal"/> </xs:sequence> </xs:complexType></xs:element>
如今，咱们能够声明 "shiporder" 元素的属性了。因为这是一个必选属性，咱们规定 use="required"。注释： 此属性的声明必须被置于最后 ：<xs:attribute name="orderid" type="xs:string" use="required"/>这是这个名为 "shiporder.xsd" 的 schema 文件的文档清单：<?xml version="1.0" encoding="ISO-8859-1" ?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:element name="shiporder"> <xs:complexType> <xs:sequence> <xs:element name="orderperson" type="xs:string"/> <xs:element name="shipto"> <xs:complexType> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="address" type="xs:string"/> <xs:element name="city" type="xs:string"/> <xs:element name="country" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> <xs:element name="item" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="title" type="xs:string"/> <xs:element name="note" type="xs:string" minOccurs="0"/> <xs:element name="quantity" type="xs:positiveInteger"/> <xs:element name="price" type="xs:decimal"/> </xs:sequence> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="orderid" type="xs:string" use="required"/> </xs:complexType></xs:element></xs:schema>
分割 Schema前面的设计方法很是容易，但当文档很复杂时却难以阅读和维护。接下来介绍的设计方法基于首先对全部元素和属性的定义，而后再使用 ref 属性来引用它们。这是用新方法设计的 schema 文件：<?xml version="1.0" encoding="ISO-8859-1" ?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><!-- 简易元素的定义 --><xs:element name="orderperson" type="xs:string"/><xs:element name="name" type="xs:string"/><xs:element name="address" type="xs:string"/><xs:element name="city" type="xs:string"/><xs:element name="country" type="xs:string"/><xs:element name="title" type="xs:string"/><xs:element name="note" type="xs:string"/><xs:element name="quantity" type="xs:positiveInteger"/><xs:element name="price" type="xs:decimal"/><!-- 属性的定义 --><xs:attribute name="orderid" type="xs:string"/><!-- 复合元素的定义 --><xs:element name="shipto"> <xs:complexType> <xs:sequence> <xs:element ref="name"/> <xs:element ref="address"/> <xs:element ref="city"/> <xs:element ref="country"/> </xs:sequence> </xs:complexType></xs:element><xs:element name="item"> <xs:complexType> <xs:sequence> <xs:element ref="title"/> <xs:element ref="note" minOccurs="0"/> <xs:element ref="quantity"/> <xs:element ref="price"/> </xs:sequence> </xs:complexType></xs:element><xs:element name="shiporder"> <xs:complexType> <xs:sequence> <xs:element ref="orderperson"/> <xs:element ref="shipto"/> <xs:element ref="item" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute ref="orderid" use="required"/> </xs:complexType></xs:element></xs:schema>
使用指定的类型（Named Types）第三种设计方法定义了类或者类型，这样使咱们有能力重复使用元素的定义。具体的方式是：首先对简易元素和复合元素进行命名，而后经过元素的 type 属性来指向它们。这是利用第三种方法设计的 schema 文件 ("shiporder.xsd")：<?xml version="1.0" encoding="ISO-8859-1" ?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:simpleType name="stringtype"> <xs:restriction base="xs:string"/></xs:simpleType><xs:simpleType name="inttype"> <xs:restriction base="xs:positiveInteger"/></xs:simpleType><xs:simpleType name="dectype"> <xs:restriction base="xs:decimal"/></xs:simpleType><xs:simpleType name="orderidtype"> <xs:restriction base="xs:string"> <xs:pattern value="[0-9]{6}"/> </xs:restriction></xs:simpleType><xs:complexType name="shiptotype"> <xs:sequence> <xs:element name="name" type="stringtype"/> <xs:element name="address" type="stringtype"/> <xs:element name="city" type="stringtype"/> <xs:element name="country" type="stringtype"/> </xs:sequence></xs:complexType><xs:complexType name="itemtype"> <xs:sequence> <xs:element name="title" type="stringtype"/> <xs:element name="note" type="stringtype" minOccurs="0"/> <xs:element name="quantity" type="inttype"/> <xs:element name="price" type="dectype"/> </xs:sequence></xs:complexType><xs:complexType name="shipordertype"> <xs:sequence> <xs:element name="orderperson" type="stringtype"/> <xs:element name="shipto" type="shiptotype"/> <xs:element name="item" maxOccurs="unbounded" type="itemtype"/> </xs:sequence> <xs:attribute name="orderid" type="orderidtype" use="required"/></xs:complexType><xs:element name="shiporder" type="shipordertype"/></xs:schema>
restriction 元素显示出数据类型源自于 W3C XML Schema 命名空间的数据类型。所以，下面的片断也就意味着元素或属性的值必须是字符串类型的值：<xs:restriction base="xs:string">restriction 元素常被用于向元素施加限制。请看下面这些来自以上 schema 的片断：<xs:simpleType name="orderidtype"> <xs:restriction base="xs:string"> <xs:pattern value="[0-9]{6}"/> </xs:restriction></xs:simpleType>
这段代码指示出，元素或属性的值必须为字符串，而且必须是连续的六个字符，同时这些字符必须是 0-9 的数字。
XSD 字符串数据类型
字符串数据类型用于可包含字符串的值。字符串数据类型（String Data Type）字符串数据类型可包含字符、换行、回车以及制表符。下面是一个关于某个 scheme 中字符串声明的例子：<xs:element name="customer" type="xs:string"/>文档中的元素看上去应该相似这样：<customer>John Smith</customer>或者相似这样：<customer> John Smith </customer>注释：若是您使用字符串数据类型，XML 处理器就不会更改其中的值。规格化字符串数据类型（NormalizedString Data Type）规格化字符串数据类型源自于字符串数据类型。规格化字符串数据类型一样可包含字符，可是 XML 处理器会移除折行，回车以及制表符。下面是一个关于在某个 schema 中规格化字符串数据类型的例子：<xs:element name="customer" type="xs:normalizedString"/>文档中的元素看上去应该相似这样：<customer>John Smith</customer>或者相似这样：<customer> John Smith </customer>注释：在上面的例子中，XML 处理器会使用空格替换全部的制表符。Token 数据类型（Token Data Type）Token 数据类型一样源自于字符串数据类型。Token 数据类型一样可包含字符，可是 XML 处理器会移除换行符、回车、制表符、开头和结尾的空格以及（连续的）空格。下面是在 schema 中一个有关 token 声明的例子：<xs:element name="customer" type="xs:token"/>文档中的元素看上去应该相似这样：<customer>John Smith</customer>或者相似这样：<customer> John Smith </customer>注释：在上面这个例子中，XML 解析器会移除制表符。字符串数据类型请注意，全部如下的数据类型均衍生于字符串数据类型（除了字符串数据类型自己）！
名称 描述 ENTITIES ENTITY 实体类型 ID 在 XML 中提交 ID 属性的字符串 (仅与 schema 属性一同使用) IDREF 在 XML 中提交 IDREF 属性的字符串(仅与 schema 属性一同使用) IDREFS language 包含合法的语言 id 的字符串 Name 包含合法 XML 名称的字符串 NCName NMTOKEN 在 XML 中提交 NMTOKEN 属性的字符串 (仅与 schema 属性一同使用) NMTOKENS normalizedString 不包含换行符、回车或制表符的字符串 QName string 字符串 token 不包含换行符、回车或制表符、开头或结尾空格或者多个连续空格的字符串 对字符串数据类型的限定（Restriction）可与字符串数据类型一同使用的限定：enumerationlengthmaxLengthminLengthpattern (NMTOKENS、IDREFS 以及 ENTITIES 没法使用此约束)whiteSpace
XSD 日期及时间数据类型（Date and Time Data Types）
日期及时间数据类型用于包含日期和时间的值。日期数据类型（Date Data Type）日期数据类型用于定义日期。日期使用此格式进行定义："YYYY-MM-DD"，其中：YYYY 表示年份MM 表示月份DD 表示天数注释：全部的成分都是必需的！下面是一个有关 schema 中日期声明的例子：<xs:element name="start" type="xs:date"/>文档中的元素看上去应该相似这样：<start>2002-09-24</start>时区如需规定一个时区，您也能够经过在日期后加一个 "Z" 的方式，使用世界调整时间（UTC time）来输入一个日期 - 好比这样：<start>2002-09-24Z</start>或者也能够经过在日期后添加一个正的或负时间的方法，来规定以世界调整时间为准的偏移量 - 好比这样：<start>2002-09-24-06:00</start>或者：<start>2002-09-24+06:00</start>时间数据类型（Time Data Type）时间数据类型用于定义时间。时间使用下面的格式来定义："hh:mm:ss"，其中hh 表示小时mm 表示分钟ss 表示秒注释：全部的成分都是必需的！下面是一个有关 schema 中时间声明的例子：<xs:element name="start" type="xs:time"/>文档中的元素看上去应该相似这样：<start>09:00:00</start>或者相似这样：<start>09:30:10.5</start>时区如需规定一个时区，您也能够经过在时间后加一个 "Z" 的方式，使用世界调整时间（UTC time）来输入一个时间 - 好比这样：<start>09:30:10Z</start>或者也能够经过在时间后添加一个正的或负时间的方法，来规定以世界调整时间为准的偏移量 - 好比这样：<start>09:30:10-06:00</start>或者：<start>09:30:10+06:00</start>日期时间数据类型（DateTime Data Type）日期时间数据类型用于定义日期和时间。日期时间使用下面的格式进行定义："YYYY-MM-DDThh:mm:ss"，其中：YYYY 表示年份MM 表示月份DD 表示日T 表示必需的时间部分的起始hh 表示小时mm 表示分钟ss 表示秒注释：全部的成分都是必需的！下面是一个有关 schema 中日期时间声明的例子：<xs:element name="startdate" type="xs:dateTime"/>文档中的元素看上去应该相似这样：<startdate>2002-05-30T09:00:00</startdate>或者相似这样：<startdate>2002-05-30T09:30:10.5</startdate>时区如需规定一个时区，您也能够经过在日期时间后加一个 "Z" 的方式，使用世界调整时间（UTC time）来输入一个日期时间 - 好比这样：<startdate>2002-05-30T09:30:10Z</startdate>或者也能够经过在时间后添加一个正的或负时间的方法，来规定以世界调整时间为准的偏移量 - 好比这样：<startdate>2002-05-30T09:30:10-06:00</startdate>或者：<startdate>2002-05-30T09:30:10+06:00</startdate>持续时间数据类型（Duration Data Type）持续时间数据类型用于规定时间间隔。时间间隔使用下面的格式来规定："PnYnMnDTnHnMnS"，其中：P 表示周期(必需)nY 表示年数nM 表示月数nD 表示天数T 表示时间部分的起始 （若是您打算规定小时、分钟和秒，则此选项为必需）nH 表示小时数nM 表示分钟数nS 表示秒数下面是一个有关 schema 中持续时间声明的例子：<xs:element name="period" type="xs:duration"/>文档中的元素看上去应该相似这样：<period>P5Y</period>上面的例子表示一个 5 年的周期。或者相似这样：<period>P5Y2M10D</period>上面的例子表示一个 5 年、2 个月及 10 天的周期。或者相似这样：<period>P5Y2M10DT15H</period>上面的例子表示一个 5 年、2 个月、10 天及 15 小时的周期。或者相似这样：<period>PT15H</period>上面的例子表示一个 15 小时的周期。负的持续时间如需规定一个负的持续时间，请在 P 以前输入减号：<period>-P10D</period>上面的例子表示一个负 10 天的周期。日期和时间数据类型
名称 描述 date 定义一个日期值 dateTime 定义一个日期和时间值 duration 定义一个时间间隔 gDay 定义日期的一个部分 - 天 (DD) gMonth 定义日期的一个部分 - 月 (MM) gMonthDay 定义日期的一个部分 - 月和天 (MM-DD) gYear 定义日期的一个部分 - 年 (YYYY) gYearMonth 定义日期的一个部分 - 年和月 (YYYY-MM) time 定义一个时间值 对日期数据类型的限定（Restriction）可与日期数据类型一同使用的限定：enumerationmaxExclusivemaxInclusiveminExclusiveminInclusivepatternwhiteSpace
XSD 数值数据类型（Numeric Data Types）
十进制数据类型用于规定一个数值。下面是一个关于某个 scheme 中十进制数声明的例子。<xs:element name="prize" type="xs:decimal"/>文档中的元素看上去应该相似这样：<prize>999.50</prize>或者相似这样：<prize>+999.5450</prize>或者相似这样：<prize>-999.5230</prize>或者相似这样：<prize>0</prize>或者相似这样：<prize>14</prize>注释：您可规定的十进制数字的最大位数是 18 位。整数数据类型整数数据类型用于规定无小数成分的数值。下面是一个关于某个 scheme 中整数声明的例子。<xs:element name="prize" type="xs:integer"/>文档中的元素看上去应该相似这样：<prize>999</prize>或者相似这样：<prize>+999</prize>或者相似这样：<prize>-999</prize>或者相似这样：<prize>0</prize>数值数据类型请注意，下面全部的数据类型均源自于十进制数据类型（除 decimal 自己之外）！
名字 秒数 byte 有正负的 8 位整数，表示整型数，大小介于-128和127之间 decimal 十进制数 int 有正负的 32 位整数，表示整型数，大小介于-2147483648和 2147483647之间 integer 整数值 long 有正负的 64 位整数，表示整型数，大小介于-9223372036854775808和9223372036854775807之间 negativeInteger 仅包含负值的整数 ( .., -2, -1.) nonNegativeInteger 仅包含非负值的整数 (0, 1, 2, ..) nonPositiveInteger 仅包含非正值的整数 (.., -2, -1, 0) positiveInteger 仅包含正值的整数 (1, 2, ..) short 有正负的 16 位整数，表示整型数，大小介于-32768和32767之间 unsignedLong 无正负的 64 位整数 unsignedInt 无正负的 32 位整数 unsignedShort 无正负的 16 位整数 unsignedByte 无正负的 8 位整数 对数值数据类型的限定（Restriction）可与数值数据类型一同使用的限定：enumerationfractionDigitsmaxExclusivemaxInclusiveminExclusiveminInclusivepatterntotalDigitswhiteSpace
XSD 杂项数据类型（Miscellaneous Data Types）
其余杂项数据类型包括逻辑、base64Binary、十六进制、浮点、双精度、anyURI、anyURI 以及 NOTATION。逻辑数据类型（Boolean Data Type）逻辑数据性用于规定 true 或 false 值。下面是一个关于某个 scheme 中逻辑声明的例子：<xs:attribute name="disabled" type="xs:boolean"/>文档中的元素看上去应该相似这样：<prize disabled="true">999</prize>注释：合法的布尔值是 true、false、1（表示 true） 以及 0（表示 false）。二进制数据类型（Binary Data Types）二进制数据类型用于表达二进制形式的数据。咱们可以使用两种二进制数据类型：base64Binary (Base64 编码的二进制数据)hexBinary (十六进制编码的二进制数据)下面是一个关于某个 scheme 中 hexBinary 声明的例子：<xs:element name="blobsrc" type="xs:hexBinary"/>AnyURI 数据类型（AnyURI Data Type）anyURI 数据类型用于规定 URI。下面是一个关于某个 scheme 中 anyURI 声明的例子：<xs:attribute name="src" type="xs:anyURI"/>文档中的元素看上去应该相似这样：<pic src="http://www.w3school.com.cn/images/smiley.gif" />注释：假如某个 URI 含有空格，请用 %20 替换它们。杂项数据类型（Miscellaneous Data Types）
名称 描述 anyURI base64Binary boolean double float hexBinary NOTATION QName
XML Schema list 元素
list 元素定义单个 simpleType 定义的集合。该属性把简单类型定义为指定数据类型的值的一个列表。下面的例子展现了为一列整数的简单类型：<?xml version="1.0"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"><xs:element name="intvalues" type="valuelist"><xs:simpleType name="valuelist"> <xs:list itemType="xs:integer"/></xs:simpleType></xs:schema>
文档中的 "intvalues" 元素相似这样（注意这个列表有五个列表项）：<intvalues>100 34 56 -23 1567</intvalues>注释：空格被做为列表项的分隔符。
XML Schema union 元素
union 元素定义多个 simpleType 定义的集合。从一个特定简单数据类型的集合中选择定义一个简单类型元素.
本例是一个合并了两个简单类型的简单类型：<xs:element name="jeans_size"> <xs:simpleType> <xs:union memberTypes="sizebyno sizebystring" /> </xs:simpleType></xs:element><xs:simpleType name="sizebyno"> <xs:restriction base="xs:positiveInteger"> <xs:maxInclusive value="42"/> </xs:restriction></xs:simpleType><xs:simpleType name="sizebystring"> <xs:restriction base="xs:string"> <xs:enumeration value="small"/> <xs:enumeration value="medium"/> <xs:enumeration value="large"/> </xs:restriction></xs:simpleType>
XML Schema unique 元素
定义和用法
unique 元素指定属性或元素值（或者属性或元素值的组合）在指定范围内必须是惟一的。 该值必须惟一或为零。
unique 元素必须按顺序包含下列元素：
selector 元素
selector 元素包含 XPath 表达式，指定一个元素集，在其中由 field 元素指定的值必须惟一。
必须有一个且只有一个 selector 元素。
field 元素
每个 field 元素均包含一个 XPath 表达式，指定对于由 selector 元素指定的元素集而言必须惟一的值（属性或元素值）。
若是有多个 field 元素，则 field 元素的组合必须是惟一的。 在此状况下，单个 field 元素的值对于选定元素不必定是惟一的，但全部字段的组合必须是惟一的。
必须有一个或多个 field 元素
<?xml version="1.0" encoding="UTF-8"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified" targetNamespace="http://www.test.com" xmlns:tn="http://www.test.com"><xs:element name="books"> <xs:complexType> <xs:sequence> <xs:element name="book" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="title" type="xs:string"/> <xs:element name="price" type="xs:decimal"/> </xs:sequence> <xs:attribute name="id" type="xs:integer"/> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> <xs:unique name="bookUnique"> <xs:selector xpath="tn:book"/> <xs:field xpath="@id"/> </xs:unique></xs:element></xs:schema> <?xml version="1.0" encoding="UTF-8"?><tn:books xsi:schemaLocation="http://www.test.com t.xsd" xmlns:tn="http://www.test.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><tn:book id="1"> <tn:title>a</tn:title> <tn:price>10</tn:price></tn:book><tn:book id="2"> <tn:title>a</tn:title> <tn:price>10</tn:price></tn:book><tn:book id="1"> <tn:title>a</tn:title> <tn:price>10</tn:price></tn:book>/tn:books>
XML Schema unique 元素
定义和用法
unique 元素指定属性或元素值（或者属性或元素值的组合）在指定范围内必须是惟一的。 该值必须惟一或为零。
unique 元素必须按顺序包含下列元素：
selector 元素
selector 元素包含 XPath 表达式，指定一个元素集，在其中由 field 元素指定的值必须惟一。
必须有一个且只有一个 selector 元素。
field 元素
每个 field 元素均包含一个 XPath 表达式，指定对于由 selector 元素指定的元素集而言必须惟一的值（属性或元素值）。
若是有多个 field 元素，则 field 元素的组合必须是惟一的。 在此状况下，单个 field 元素的值对于选定元素不必定是惟一的，但全部字段的组合必须是惟一的。
必须有一个或多个 field 元素
<?xml version="1.0" encoding="UTF-8"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified" targetNamespace="http://www.test.com" xmlns:tn="http://www.test.com"><xs:element name="books"> <xs:complexType> <xs:sequence> <xs:element name="book" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="title" type="xs:string"/> <xs:element name="price" type="xs:decimal"/> </xs:sequence> <xs:attribute name="id" type="xs:integer"/> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> <xs:unique name="bookUnique"> <xs:selector xpath="tn:book"/> <xs:field xpath="@id"/> </xs:unique></xs:element></xs:schema> <?xml version="1.0" encoding="UTF-8"?><tn:books xsi:schemaLocation="http://www.test.com t.xsd" xmlns:tn="http://www.test.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><tn:book id="1"> <tn:title>a</tn:title> <tn:price>10</tn:price></tn:book><tn:book id="2"> <tn:title>a</tn:title> <tn:price>10</tn:price></tn:book><tn:book id="1"> <tn:title>a</tn:title> <tn:price>10</tn:price></tn:book>/tn:books>
问题
<?xml version="1.0" encoding="UTF-8"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified" targetNamespace="http://www.test.com" xmlns="http://www.test.com"> <xs:attribute name="fk" type="xs:integer"/> <xs:element name="book"> <xs:complexType> <xs:sequence> <xs:element name="title" type="xs:string"/> </xs:sequence> <xs:attribute name="id" type="xs:integer"/> <xs:attribute ref="fk"/> </xs:complexType> </xs:element></xs:schema>
<?xml version="1.0" encoding="UTF-8"?><book xmlns="http://www.test.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.test.com test.xsd" id="1" fk="fk"> <title/></book>
相关文章
- 1. Solr5之Schema详解
- 2. MaxCompute Information Schema功能详解
- 3. SQL SERVER 中的Schema详解
- 4. oracle schema 白话文详解
- 5. XML技术-Schema约束-Dom4j-Xpath详解
- 6. 详解xml约束中schema约束
- 7. pt-online-schema-change 过程详解
- 8. 初学schema---schema命名空间理解
- 9. Solr系列三：solr索引详解（Schema介绍、字段定义详解、Schema API 介绍）
- 10. schema与catalog的理解
- 更多相关文章...
- • 免费ARP详解 - TCP/IP教程
- • *.hbm.xml映射文件详解 - Hibernate教程
- • Flink 数据传输及反压详解
- • 为了进字节跳动，我精选了29道Java经典算法题，带详细讲解
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Duang!超快Wi-Fi来袭
- 2. 机器学习-补充03 神经网络之**函数(Activation Function)
- 3. git上开源maven项目部署 多module maven项目（多module maven+redis+tomcat+mysql）后台部署流程学习记录
- 4. ecliple-tomcat部署maven项目方式之一
- 5. eclipse新导入的项目经常可以看到“XX cannot be resolved to a type”的报错信息
- 6. Spark RDD的依赖于DAG的工作原理
- 7. VMware安装CentOS-8教程详解
- 8. YDOOK：Java 项目 Spring 项目导入基本四大 jar 包 导入依赖，怎样在 IDEA 的项目结构中导入 jar 包 导入依赖
- 9. 简单方法使得putty（windows10上）可以免密登录树莓派
- 10. idea怎么用本地maven
欢迎关注本站公众号,获取更多信息
相关文章