XML 学习笔记 7：XSD

本文章内容转载自 W3school XSD 教程

---

1、XSD 是什么

XSD（XML Schema Definition）用来描述 XML 文档的结构，是 DTD 的替代者，功能比 DTD 更强大。

1. XML Schema 基于 XML 编写

   • 可扩展
   • 可以通过 XML 解析器来解析 Schema 文件
   • 可以通过 XML DOM 来处理 Schema
   • 可以通过 XSLT 来转换 Schema

2. XML Schema 支持数据类型

   • 可更容易地验证数据的正确性
   • 可以更容易地定义数据格式
   • 可以更容易地定义数据约束（data facets）
   • 可以更容易地在不同的数据类型间转换数据

通过 XML Schema，数据的发送方可以用一种接收方能够理解的方式来描述数据。

例如 “03-11-2004”，在某些国家被解释为 11 月 3 日，而在另一些国家被解释为 3 月 11 日。

但是一个带有数据类型的 XML 元素 2004-03-11，可以确保对数据内容的一致理解，这是因为 XML 数据类型 xs:date 要求的格式是 YYYY-MM-DD。

XML Schema 在 2001 年 5 月 2 日成为 W3C 标准。

---

2、XSD 内置数据类型

2.1、基本数据类型

2.1.1、基本字符串类型

数据类型	描述
xs:string	字符串数据类型可包含字符、换行、回车以及制表符

2.1.2、基本数值类型

数据类型	描述
xs:decimal	十进制数据，最大位数是 18 位，例如 -999.5230
xs:float	32 位单精度浮点数
xs:double	64 位双精度浮点数

2.1.3、日期时间类型

数据类型	描述
xs:date	YYYY-MM-DD
xs:time	hh:mm:ss
xs:dateTime	YYYY-MM-DDThh:mm:ss，T 表示时间部分的起始
xs:duration	持续时间数据类型用于规定时间间隔，格式：PnYnMnDTnHnMnS，n 表示年月日时分秒的数目，P 表示周期，T 表示时间部分的起始。例如 P5Y2M10DT15H 表示 5 年零 2 个月零 10天 零 15 小时
xs:gYear	hh:mm:ss
xs:gYearMonth	hh:mm:ss
xs:gMonth	hh:mm:ss
xs:gMonthDay	hh:mm:ss
xs:gDay	hh:mm:ss

2.1.4、其他基本数据类型

数据类型	描述
xs:boolean	true 或 false
xs:hexBinary	十六进制编码的二进制数据
xs:base64Binary	Base64 编码的二进制数据
xs:anyURI	转义URI
xs:QName
xs:NOTATION	从 anySimpleType 类型派生，非 XML 格式的数据

QName

<xs:simpleType name="QName" id="QName">
    <xs:annotation>
        <xs:appinfo>
            <hfp:hasFacet name="length"/>
            <hfp:hasFacet name="minLength"/>
            <hfp:hasFacet name="maxLength"/>
            <hfp:hasFacet name="pattern"/>
            <hfp:hasFacet name="enumeration"/>
            <hfp:hasFacet name="whiteSpace"/>
            <hfp:hasProperty name="ordered" value="false"/>
            <hfp:hasProperty name="bounded" value="false"/>
            <hfp:hasProperty name="cardinality" value="countably infinite"/>
            <hfp:hasProperty name="numeric" value="false"/>
        xs:appinfo>
        <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#QName"/>
    xs:annotation>

    <xs:restriction base="xs:anySimpleType">
        <xs:whiteSpace value="collapse" fixed="true" id="QName.whiteSpace"/>
    xs:restriction>
xs:simpleType>

[Definition]
QName represents XML qualified names. The value space of QName is the set of tuples {namespace name, local part}, where namespace name is an anyURI and local part is an NCName. The lexical space of QName is the set of strings that match the QName production of [Namespaces in XML].
限定名称由命名空间名称和本地部分组成，命名空间名称是任意 URI，而本地部分则是由用户定义的名称（NCName，non-colonized Name）。

<xs:simpleType name="NOTATION" id="NOTATION">
    <xs:annotation>
        <xs:appinfo>
            <hfp:hasFacet name="length"/>
            <hfp:hasFacet name="minLength"/>
            <hfp:hasFacet name="maxLength"/>
            <hfp:hasFacet name="pattern"/>
            <hfp:hasFacet name="enumeration"/>
            <hfp:hasFacet name="whiteSpace"/>
            <hfp:hasProperty name="ordered" value="false"/>
            <hfp:hasProperty name="bounded" value="false"/>
            <hfp:hasProperty name="cardinality" value="countably infinite"/>
            <hfp:hasProperty name="numeric" value="false"/>
        xs:appinfo>
        <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#NOTATION"/>
        <xs:documentation>
            NOTATION cannot be used directly in a schema;
            rather a type must be derived from it 
            by specifying at least one enumeration facet 
            whose value is the name of a NOTATION declared in the schema.
        xs:documentation>
    xs:annotation>
    
    <xs:restriction base="xs:anySimpleType">
        <xs:whiteSpace value="collapse" fixed="true" id="NOTATION.whiteSpace"/>
    xs:restriction>
xs:simpleType>

[Definition : Notations identify by name the format of unparsed entities, the format of elements which bear a notation attribute, or the application to which a processing instruction is addressed.]
NOTATION 通过名称标识 1.未解析实体的格式、2.带有符号属性的元素的格式或 3.处理指令所指向的应用程序。

[Definition: Notation declarations provide a name for the notation, for use in entity and attribute-list declarations and in attribute specifications, and an external identifier for the notation which may allow an XML processor or its client application to locate a helper application capable of processing data in the given notation.]
Schema Component Constraint: enumeration facet value required for NOTATION
It is an ·error· for NOTATION to be used directly in a schema. Only datatypes that are ·derived· from NOTATION by specifying a value for ·enumeration· can be used in a schema.

例如

<xs:notation name="gif" public="image/gif" system="view.exe"/>
<xs:notation name="jpeg" public="image/jpeg" system="view.exe"/>

<xs:element name="image">
    <xs:complexType>
        <xs:simpleContent>
            <xs:attribute name="type">
                <xs:simpleType>
                    <xs:restriction base="xs:NOTATION">
                        <xs:enumeration value="gif"/>
                        <xs:enumeration value="jpeg"/>
                    <xs:restriction>
                xs:simpleType>
            xs:attribute>
        xs:simpleContent>
    xs:complexType>
xs:element>

<image type="gif">image>

2.2、派生数据类型

2.2.1、派生字符串类型

数据类型	描述
xs:normalizedString	从 string 类型派生，同样可以包含字符，但是 XML 处理器会移除制表符、换行以及回车
xs:token	从 normalizedString类型派生，XML 处理器会移除制表符、换行、回车以及开头和结尾的空格，多个连续空格的内部序列会被缩减为一个空格
xs:language	由 RFC3066 规定的合法的语言的标识
xs:NMTOKEN	由 NMTOKEN.pattern 限制，从 token 类型派生
xs:NMTOKENS
xs:Name
xs:NCName	XML “non-colonized” Names，即由用户定义的 Name
xs:ID
xs:IDREF
xs:IDREFS
xs:ENTITIE
xs:ENTITIES

pattern 限制派生类型 NMTOKEN

<xs:simpleType name="NMTOKEN" id="NMTOKEN">
    <xs:annotation>
        <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#NMTOKEN"/>
    xs:annotation>
    
    <xs:restriction base="xs:token">
        <xs:pattern value="\c+" id="NMTOKEN.pattern">
            <xs:annotation>
                <xs:documentation source="http://www.w3.org/TR/REC-xml#NT-Nmtoken">
                    pattern matches production 7 from the XML spec
                xs:documentation>
            xs:annotation>
        xs:pattern>
    xs:restriction>
xs:simpleType>

数据类型	pattern

[4]    NameStartChar  ::=  ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
[4a]   NameChar  ::=  NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
[5]    Name  ::=  NameStartChar (NameChar)*
[6]    Names  ::=  Name (#x20 Name)*
[7]    Nmtoken  ::=  (NameChar)+
[8]    Nmtokens  ::=  Nmtoken (#x20 Nmtoken)*

pattern 限制派生类型 NCName

<xs:simpleType name="NCName" id="NCName">
    <xs:annotation>
        <xs:documentation source="http://www.w3.org/TR/xmlschema-2/#NCName"/>
    xs:annotation>

    <xs:restriction base="xs:Name">
        <xs:pattern value="[\i-[:]][\c-[:]]*" id="NCName.pattern">
            <xs:annotation>
                <xs:documentation source="http://www.w3.org/TR/REC-xml-names/#NT-NCName">
                    pattern matches production 4 from the Namespaces in XML spec
                xs:documentation>
            xs:annotation>
        xs:pattern>
    xs:restriction>
xs:simpleType>

2.2.2、派生数值类型

数据类型	描述
xs:integer	整数，用于规定无小数部分的数值
xs:nonPositiveInteger	非正整数（0 和负整数）
xs:negativeInteger	负整数
xs:long	有正负的 64 位整数
xs:int	有正负的 32 位整数
xs:short	有正负的 16 位整数
xs:byte	有正负的 8 位整数
xs:nonNegativeInteger	非负整数（0 和正整数）
xs:positiveInteger	正整数
xs:unsignedLong	无正负的 64 位整数
xs:unsignedInt	无正负的 32 位整数
xs:unsignedShort	无正负的 16 位整数
xs:unsignedByte	无正负的 8 位整数

3、用户派生类型

3.1、扩展派生类型 - extension 元素

类型扩展即 extension 元素，定义对简单类型 simpleType 或复合类型 simpleContent、complexContent 的扩展，也就是为类型添加新的元素或属性。

<extension
id=ID
base=QName
any attributes
>
    (annotation?,
        ((group|all|choice|sequence)?,
            ((attribute|attributeGroup)*,anyAttribute?)))
extension>

使用扩展定义一个复合类型 Chinese_customer，它从复合类型 customer 派生，拥有新的子元素 country ：

<xs:complexType name="customer">
    <xs:sequence>
        <xs:element name="name" type="xs:string"/>
    xs:sequence>
xs:complexType>

<xs:complexType name="Chinese_customer">
    <xs:complexContent>
        <xs:extension base="customer">
            <xs:sequence>
                <xs:element name="country" type="xs:string"/>
            xs:sequence>
        xs:extension>
    xs:complexContent>
xs:complexType>

---

3.2、限制派生类型 - restriction 元素

类型限制即 restriction 元素，定义对简单类型 simpleType 或复合类型 simpleContent、complexContent 的约束，并不会为类型添加新的元素或属性。

<restriction
id=ID
base=QName
any attributes
>
    
    (annotation?,
        (simpleType?,
            (minExclusive|minInclusive|maxExclusive|maxInclusive|
             totalDigits|fractionDigits|
             length|minLength|maxLength|
             enumeration|whiteSpace|pattern)*))

    
    (annotation?,
        (simpleType?,
            (minExclusive |minInclusive|maxExclusive|maxInclusive|
             totalDigits|fractionDigits|
             length|minLength|maxLength|
             enumeration|whiteSpace|pattern)*)?, 
                ((attribute|attributeGroup)*,anyAttribute?))

    
    (annotation?,
        (group|all|choice|sequence)?,
            ((attribute|attributeGroup)*,anyAttribute?))
restriction>

例如使用约束定义一个复合类型 Chinese_customer，它从复合类型 customer 派生，子元素 country 的固定值是 “China”：

<xs:complexType name="customer">
    <xs:sequence>
        <xs:element name="name" type="xs:string"/>
        <xs:element name="country" type="xs:string"/>
    xs:sequence>
xs:complexType>

<xs:complexType name="Chinese_customer">
    <xs:complexContent>
        <xs:restriction base="customer">
            <xs:sequence>
                <xs:element name="name" type="xs:string"/>
                <xs:element name="country" type="xs:string" fixed="China"/>
            xs:sequence>
        xs:restriction>
    xs:complexContent>
xs:complexType>

---

3.3、简单类型的扩展和限制 - simpleContent 元素

simpleContent 元素是对简单类型 simpleType 元素的扩展或限制，简单类型扩展后会变成复合类型。

<simpleContent
id=ID
any attributes
>
    (annotation?,(restriction|extension))
simpleContent>

例如对简单类型 integer 进行扩展后获得一个复合类型 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>

---

3.4、复合类型的扩展和限制 - complexContent 元素

complexContent 元素定义对复合类型 complexType 元素的扩展或限制。

<complexContent
id=ID
mixed=true|false
any attributes
>
    (annotation?,(restriction|extension))
complexContent>

示例参见小节 3.2 类型限制。

3.5、集合派生类型

---

4、XSD 简单类型 - simpleType 元素

simpleType 元素定义一个简单类型，规定与

1. 仅包含文本内容的元素，参见小节 4.1 简单元素
2. 或 属性 的值有关的信息，参见小节 4.2 属性
3. 以及对它们的 约束，参见小节 4.3 限定

<simpleType id=ID name=NCName anyAttribute>
    (annotation?,(restriction|list|union))
simpleType>

例如声明 age 元素是一个带有约束（restriction）的简单类型（age 元素的值不能小于 0 或大于 100）：

<xs:element name="age">
    <xs:simpleType>
        <xs:restriction base="xs:integer">
            <xs:minInclusive value="0"/>
            <xs:maxInclusive value="100"/>
        xs:restriction>
    xs:simpleType>
xs:element>

---

4.1、简单元素 - element 元素

简单元素指那些仅包含文本内容的元素，它不包含任何其他的元素或属性。

不过，“仅包含文本内容” 这个限定却很容易造成误解。文本内容有很多种类型，它可以是 XML Schema 定义类型中的一种（布尔、字符串、数值等），它也可以是自定义的定制类型。

可以向数据类型添加限定（facets），以此来限制它的内容，或者可以要求数据匹配某种特定的模式（facets 中的 pattern）。

<xs:element name="元素名称" type="数据类型" default="默认值" fixed="固定值"/>

例如声明两个简单元素 name 和 age：

<xs:element name="name" type="xs:string"/>
<xs:element name="age" type="xs:integer"/>

<name>Smithname>
<age>28age>

---

4.2、属性 - attribute 元素

attribute 元素定义一个属性。

<attribute
default=string
fixed=string
form=qualified|unqualified
id=ID
name=NCName
ref=QName
type=QName
use=optional|prohibited|required
any attributes
>
    (annotation?,(simpleType?))
attribute>

---

• use 属性
  可选。规定如何使用该属性。默认值是 optional 可选的。可以设置为下列值：
  1. optional - 属性是可选的
  2. prohibited - 属性不能使用
  3. required - 属性是必需的

---

• form 属性
  可选。规定属性的格式。默认值是 包含该属性的元素 的 attributeFormDefault 属性的值。可以设置为下列值：
  1. qualified - 指示必须通过命名空间前缀和该属性的本地名称（即无冒号名称，NCName）来限定此属性
  2. unqualified - 指示此属性无须通过命名空间前缀限定，且无须匹配此属性的本地名称 （无须匹配本地名称不太理解是什么意思？）

---

• default 和 fixed 属性不能同时出现
• ref 和 name、form、type 等属性不能同时出现
• ref 属性和 simpleType 子元素不能同时出现
• type 属性和 simpleType 子元素不能同时出现

---

例如声明一个 country 属性，限定属性值是大写字母 A 到 Z 中的两个字母：

<xs:attribute name="country">
    <xs:simpleType>
        <xs:restriction base="xs:string">
            <xs:pattern value="[A-Z][A-Z]"/>
        xs:restriction>
    xs:simpleType>
xs:attribute>

---

4.3、限定 - facets 元素组

本部分内容翻译自 W3C Recommendation

Restrictions are used to define acceptable values for XML elements or attributes. Restrictions on XML elements are called facets.

限定（restriction）用于为 XML 元素或者属性定义可接受的值。对 XML 元素的限定被称为 facet （/ˈfæsɪt/，方面）。

在 XMLSchema.xsd 文件中对 facets 元素组的定义如下：

<xs:group name="facets">
    <xs:choice>
        <xs:element ref="xs:minExclusive"/>
        <xs:element ref="xs:minInclusive"/>
        <xs:element ref="xs:maxExclusive"/>
        <xs:element ref="xs:maxInclusive"/>
        
        <xs:element ref="xs:totalDigits"/>
        <xs:element ref="xs:fractionDigits"/>
        
        <xs:element ref="xs:length"/>
        <xs:element ref="xs:minLength"/>
        <xs:element ref="xs:maxLength"/>
        
        <xs:element ref="xs:enumeration"/>
        <xs:element ref="xs:whiteSpace"/>
        <xs:element ref="xs:pattern"/>
    xs:choice>
xs:group>

限定	描述
minExclusive	定义数值或者日期的下限。所允许的值必需大于此值。等同于左开区间。
minInclusive	定义数值或者日期的下限。所允许的值必需大于或等于此值。等同于左闭区间。
maxExclusive	定义数值或者日期的上限。所允许的值必须小于此值。等同于右开区间。
maxInclusive	定义数值或者日期的上限。所允许的值必须小于或等于此值。等同于右闭区间。
totalDigits	定义所允许的十进制数的精确位数。必须大于0。
fractionDigits	定义所允许的十进制数的最大的小数位数。必须大于或等于0。
length	定义所允许的字符或者列表项的精确数目。必须大于或等于0。
minLength	定义所允许的字符或者列表项的最小数目。必须大于或等于0。
maxLength	定义所允许的字符或者列表项的最大数目。必须大于或等于0。
enumeration	定义可接受值的一个枚举列表。
whiteSpace	定义空白字符（换行、回车、空格以及制表符）的处理方式。
pattern	定义可接受的字符的正则表达式。

4.3.1、左开区间 - minExclusive 元素

<minExclusive
  fixed = boolean : false
  id = ID
  value = anySimpleType
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
minExclusive>

[Definition]
minExclusive is the exclusive lower bound of the value space for a datatype with the ordered property. The value of minExclusive must be in the value space of the base type or be equal to {value} in {base type definition}.
minExclusive 是具有有序属性的数据类型的值空间的左开区间。minExclusive 的值必须在基本类型的值空间中。

[Example]
The following is the definition of a user-derived datatype which limits values to integers greater than or equal to 100, using minExclusive.
如下示例定义了一个从 integer 类型派生的简单类型 more-than-ninety-nine，通过 minExclusive 限定了大于或等于 100 的整数值。

<simpleType name="more-than-ninety-nine">
    <restriction base="integer">
        <minExclusive value="99"/>
    restriction>
simpleType>

minInclusive、maxExclusive、maxInclusive 元素的定义方式和 minExclusive 元素类似。

注：

• 同时定义 minInclusive 和 minExclusive 是不合法的
• 同时定义 maxInclusive 和 maxExclusive 是不合法的
• minExclusive >= maxInclusive、minExclusive > maxExclusive 是不合法的
• minInclusive >= maxExclusive、minInclusive > maxInclusive 是不合法的

---

4.3.2、总位数 - totalDigits 元素

<totalDigits
  fixed = boolean : false
  id = ID
  value = positiveInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
totalDigits>

[Definition:] totalDigits controls the maximum number of values in the ·value space· of datatypes ·derived· from decimal, by restricting it to numbers that are expressible as i × 10^-n where i and n are integers such that |i| < 10^totalDigits and 0 <= n <= totalDigits. The value of totalDigits ·must· be a positiveInteger.

totalDigits 通过表示形式 i×10^n 的数字来限制从十进制派生的数据类型的值空间中的最大值，i 和 n 是整数，因此 |i|<10^totalDigets 和 0<=n<=totalDigits。totalDigits 的值必须是正整数。

4.3.3、小数位数 - fractionDigits 元素

<fractionDigits
  fixed = boolean : false
  id = ID
  value = nonNegativeInteger
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
fractionDigits>

[Definition]
fractionDigits controls the size of the minimum difference between values in the value space of datatypes derived from decimal, by restricting the value space to numbers that are expressible as i × 10^-n where i and n are integers and 0 <= n <= fractionDigits. The value of fractionDigits must be a nonNegativeInteger.

[Example]
The following is the definition of a user-derived datatype which could be used to represent the magnitude of a person’s body temperature on the Celsius scale. This definition would appear in a schema authored by an “end-user” and shows how to define a datatype by specifying facet values which constrain the range of the base type.
如下示例定义一个从 decimal 派生的简单类型 celsiusBodyTemp，表示人的摄氏度体温，totalDigits 的值是 4，小数点也算位数？

<simpleType name='celsiusBodyTemp'>
    <restriction base='decimal'>
        <totalDigits value='4'/>
        <fractionDigits value='1'/>
        <minInclusive value='36.4'/>
        <maxInclusive value='40.5'/>
    restriction>
simpleType>

---

4.3.4、最小长度 -

4.3.5、枚举值 -

---

4.3.6、空白字符处理 - whiteSpace 元素

<whiteSpace
  fixed = boolean : false
  id = ID
  value = (collapse | preserve | replace)
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
whiteSpace>

• preserve：XML 处理器不会对空白字符做任何处理
  No normalization is done, the value is not changed (this is the behavior required by [XML 1.0 (Second Edition)] for element content).

• replace：XML 处理器会使用空格替换所有空白字符（制表符、换行以及回车）
  All occurrences of #x9 (tab), #xA (line feed) and #xD (carriage return) are replaced with #x20 (space).

• collapse：XML 处理器会使用空格替换所有空白字符（制表符、换行以及回车），多个连续空格会被缩减为一个空格，开头和结尾的空格会被移除
  After the processing implied by replace, contiguous sequences of #x20’s are collapsed to a single #x20, and leading and trailing #x20’s are removed.

---

4.3.7、匹配模式 - pattern 元素

<pattern
  id = ID
  value = string
  {any attributes with non-schema namespace . . .}>
  Content: (annotation?)
pattern>

[Definition]
pattern is a constraint on the value space of a datatype which is achieved by constraining the lexical space to literals which match a specific pattern. The value of pattern must be a regular expression.

pattern 元素是对数据类型的值空间的约束，通过将词汇空间约束为与特定模式匹配的字面量来实现。pattern 的值必须是正则表达式。

[Example]
The following is the definition of a user-derived datatype which is a better representation of postal codes in the United States, by limiting strings to those which are matched by a specific regular expression.

如下示例定义了一个从 string 类型派生的简单类型 better-us-zipcode，用来表示美国的邮政编码，并通过正则表达式限制了字符串的取值范围。

<simpleType name='better-us-zipcode'>
    <restriction base='string'>
        <pattern value='[0-9]{5}(-[0-9]{4})?'/>
    restriction>
simpleType>

---

5、XSD 复合类型 - complexType 元素

complexType 元素定义复合类型。复合类型的元素是 包含其他元素 或 属性 的 XML 元素。

<complexType
id=ID 
name=NCName 
abstract=true|false 
mixed=true|false
block=(#all|list of (extension|restriction))
final=(#all|list of (extension|restriction))
any attributes
>
    (annotation?,
    (simpleContent|complexContent|((group|all| choice|sequence)?,
    ((attribute|attributeGroup)*,anyAttribute?))))
complexType>

• mixed
  可选。规定是否允许字符数据出现在该复杂类型的子元素之间。默认值为 false。
  如果子元素是 simpleContent 元素，则不允许 mixed 属性。
  如果子元素是 complexContent 元素，则 mixed 属性可以被 complexContent 元素的 mixed 属性重写。

• abstract
  可选。规定在实例文档中是否可以直接使用该复合类型，类似 Java 中的 abstract 关键字。如果值为 true，则元素不能直接使用该复合类型，而是必须使用从该复合类型派生的复合类型。默认值为 false。

• final
  可选。防止从该 complexType 元素指定的类型派生出新的类型，类似 Java 中的 final 关键字。该值可以包含：

  1. #all - 防止所有派生（扩展和限制）
  2. extension - 防止通过扩展派生
  3. restriction - 防止通过限制派生

---

复合类型指示器

Occurrence 指示器

minOccurs 属性

minOccurs 指示器规定某个元素能够出现的最小次数。

maxOccurs 属性

maxOccurs 指示器规定某个元素能够出现的最大次数，如果某个元素的出现次数不受限制，使用 maxOccurs="unbounded"。

例如规定 class 元素可以有多个 student 子元素而只能有 1-2 个 teacher 子元素：

<xs:element name="class">
    <xs:complexType>
        <xs:sequence>
            <xs:element name="student" type="xs:string"
                        maxOccurs="unbounded"/>
            <xs:element name="teacher" type="xs:string"
                        minOccurs="1" maxOccurs="2"/>
        xs:sequence>
    xs:complexType>
xs:element>

---

Order 指示器

all 元素

all 元素规定子元素能够以任意顺序出现，每个子元素可以出现零次或一次。

<all
id=ID
minOccurs=0|1
maxOccurs=1
any attributes
>
    (annotation?,element*)
all>

例如规定 person 元素中 firstname 和 lastname 子元素能够以任意顺序出现零次或一次：

<xs:element name="person">
    <xs:complexType>
        <xs:all minOccurs="0">
            <xs:element name="firstname" type="xs:string"/>
            <xs:element name="lastname" type="xs:string"/>
        xs:all>
    xs:complexType>
xs:element>

choice 元素

choice 元素规定仅允许 声明的元素之一出现。

<choice
id=ID
minOccurs=nonNegativeInteger
maxOccurs=nonNegativeInteger|unbounded
any attributes
>
    (annotation?,(element|group|choice|sequence|any)*)
choice>

sequence 元素

sequence 元素规定 声明的元素以指定的顺序出现，每个子元素可以出现 0 次到任意次数。

<sequence
id=ID
maxOccurs=nonNegativeInteger|unbounded
minOccurs=nonNegativeInteger
any attributes
>
    (annotation?,(element|group|choice|sequence|any)*)
sequence>

示例参见小节 3.2 类型限制。

---

Group 指示器

元素组 - group 元素

group 元素用于对元素声明进行组合，这样这些声明就能够以组合的形式合并到复合类型中。

<group
id=ID
name=NCName
ref=QName
maxOccurs=nonNegativeInteger|unbounded
minOccurs=nonNegativeInteger
any attributes
>
    (annotation?,(all|choice|sequence)?)
group>

例如声明一个元素组 customergroup，元素组中声明 sequence 元素，规定 age 和 birthday 元素必须依次出现，然后声明一个复合类型 customerinfo 并引用 customergroup 元素组：

<xs:group name="customergroup">
    <xs:sequence>
        <xs:element name="age" type="xs:integer"/>
        <xs:element name="birthday" type="xs:date"/>
    xs:sequence>
xs:group>

<xs:complexType name="customerinfo">
    <xs:sequence>
        <xs:element name="name" type="xs:string"/>
        <xs:element name="country" type="xs:string"/>
        <xs:group ref="customergroup"/>
  xs:sequence>
xs:complexType>

<xs:element name="customer" type="customerinfo"/>

属性组 - attributeGroup 元素

attributeGroup 元素用于对属性声明进行组合，这样这些声明就能够以组合的形式合并到复合类型中。

<attributeGroup
id=ID
name=NCName
ref=QName
any attributes
>
    (annotation?),((attribute|attributeGroup)*,anyAttribute?))
attributeGroup>

例如声明一个属性组 customerAttrs，然后在复合类型 customer 中引用：

<xs:attributeGroup name="customerAttrs">
    <xs:attribute name="name" type="string"/>
    <xs:attribute name="age" type="integer"/>
xs:attributeGroup>

<xs:complexType name="customer">
    <xs:attributeGroup ref="customerAttrs"/>
xs:complexType>

---

复合元素 - element 元素

复合元素指包含其他元素或属性的 XML 元素。

<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>

---

任何元素 - any 元素

any 元素使来自指定命名空间的任何元素可以显示在包含 sequence 或 choice 元素中。

该元素使创作者可以通过未被 schema 规定的元素来扩展 XML 文档。

<any
id=ID
maxOccurs=nonNegativeInteger|unbounded
minOccurs=nonNegativeInteger
namespace=namespace
processContents=lax|skip|strict
any attributes
>
    (annotation?)
any>

• namespace
  可选。规定包含可以使用的元素的命名空间。如果没有指定命名空间，则默认值是 ##any。如果指定命名空间，则取值必须是以下之一：

  1. ##any - 来自任何命名空间的元素都可以出现
  2. ##other - 来自该元素的父元素的目标命名空间之外的任何命名空间的元素都可以出现
  3. ##local - 未由命名空间限定的元素可以出现
  4. ##targetNamespace - 来自包含该元素的父元素的目标命名空间的元素可以出现
  5. {URI references of namespaces, ##targetNamespace, ##local} 的列表 - 来自通过空格分隔的命名空间列表的元素可以出现。 该列表可以包含以下内容： 命名空间 ##targetNamespace 和 ##local 的 URI 引用。

• processContents
  可选。一个指示符，指示应用程序或 XML 处理器应如何根据由该 any 元素指定的元素处理 XML 文档的验证。 如果没有指定 processContents 属性，则默认为 strict。如果指定了 processContents，则取值必须是以下之一：

  1. strict - XML 处理器必须获得所需命名空间的架构，并且必须验证来自这些命名空间的所有元素
  2. lax - 与 strict 相同；但是，即使不能获取该架构，也不会发生任何错误
  3. skip - XML 处理器不尝试验证来自指定命名空间的所有元素

---

任何属性 - anyAttribute 元素

anyAttribute 元素使创作者可以通过未被 schema 规定的属性来扩展 XML 文档。

---

注释 - annotation 元素

annotation 元素是一个顶层元素，规定 schema 的注释。

<annotation
id=ID
any attributes
>
    (appinfo|documentation)*
annotation>

可以包含 appinfo 元素（由应用程序使用的信息）和 documentation 元素（由用户读取或使用的注释或文本）。

appInfo 元素规定 annotation 元素中应用程序要使用的信息。该元素必须位于 annotation 中。

注释：应用程序使用在 appinfo 元素内提供的信息处理指令。

<appInfo
source=anyURL
>
Any well-formed XML content
appInfo>

source 可选。一个 URI 引用，规定应用程序信息的来源。

documentation 元素在 schema 中输入文本注释。该元素必须位于 annotation 元素内。

source 可选。规定应用程序信息的来源。
xml:lang 可选。规定内容中使用的语言。

<xs:annotation>
    <xs:appInfo>
        W3School Note
    xs:appInfo>
    <xs:documentation xml:lang="en">
        This Schema defines a W3School note!
    xs:documentation>
xs:annotation>