关闭

XML Schema/XSD

标签: xmlJavaScriptXML SchemaXSD
351人阅读 评论(0) 收藏 举报
分类:

                                                                      XML Schema

XML Schema 是基于 XMLDTD替代者。

XML Schema 可描述 XML文档的结构。

XML Schema 语言也可作为 XSDXML Schema Definition)来引用。

XML Schema:

      定义可出现在文档中的元素

      定义可出现在文档中的属性

      定义哪个元素是子元素

      定义子元素的次序

      定义子元素的数目

      定义元素是否为空,或者是否可包含文本

      定义元素和属性的数据类型

      定义元素和属性的默认值以及固定值

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">....</note>

1、简易的类型

(1)、XSD元素

   简易元素指那些仅包含文本的元素。它不会包含任何其他的元素或属性。

定义简易元素的语法:

        <xs:element name="xxx" type="yyy"/>

   此处 xxx 指元素的名称,yyy指元素的数据类型

   最常用的类型是:

   •xs:string  •xs:decimal  •xs:integer  •xs:boolean  •xs:date  •xs:time

简易元素的默认值和固定值

   <xs:element name="color" type="xs:string" default="red"/>//默认值
   <xs:element name="color" type="xs:string" fixed="red"/>//固定值

2)、XSD属性

    简易元素无法拥有属性。假如某个元素拥有属性,它就会被当作某种复合类型。但是属性本身总是作为简易类型被声明的。

定义属性的语法是:

           <xs:attribute name="xxx" type="yyy"/>

    在此处,xxx 指属性名称,yyy则规定属性的数据类型

    这是带有属性的 XML 元素:

         <lastname lang="EN">Smith</lastname>

    这是对应的属性定义:

         <xs:attribute name="lang" type="xs:string"/>

属性的默认值和固定值

<xs:attribute name="lang" type="xs:string" default="EN"/>
<xs:attribute name="lang" type="xs:string" fixed="EN"/>

可选的和必需的属性

在缺省的情况下,属性是可选的。如需规定属性为必选,请使用 "use" 属性:

      <xs:attribute name="lang" type="xs:string" use="required"/>

(3)XSD限定

  限定(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 元素的内容限制为一组可接受的值,我们要使用枚举约束(enumerationconstraint)。

下面的例子定义了带有一个限定的名为 "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 元素的内容限制定义为一系列可使用的数字或字母,我们要使用模式约束(patternconstraint)。

下面的例子定义了带有一个限定的名为 "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>  

对长度的限定

如需限制元素中值的长度,我们需要使用 lengthmaxLength以及 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

定义空白字符(换行、回车、空格以及制表符)的处理方式。

2、复杂的类型

(1)XSD元素

    复合元素指包含其他元素及/或属性的XML 元素,有四种类型的复合元素:空元素、包含其他元素的元素、仅包含文本的元素、包含元素和文本的元素。

请看这个复合 XML 元素,"employee",仅包含其他元素:

<employee>
  <firstname>John</firstname>
  <lastname>Smith</lastname>
</employee>

A、通过命名此元素,可直接对"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>

B"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="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>

(2)XSD 复合空元素

空的复合元素不能包含内容,只能含有属性。<product prodid="1345" />

<xs:element name="product">
  <xs:complexType>
    <xs:attribute name="prodid" type="xs:positiveInteger"/>
  </xs:complexType>
</xs:element>

(3)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>

(4)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>

(5)、混合内容

混合的复合类型可包含属性、元素以及文本。

带有混合内容的复合类型

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>标签 (nameorderid以及 shipdate )意味着被定义的元素必须依次出现在 "letter"元素内部。

(6)XSD 复合类型指示器

通过指示器,我们可以控制在文档中使用元素的方式。

有七种指示器:

Order 指示器:AllChoiceSequence

Occurrence 指示器:、maxOccursminOccurs

Group 指示器:Group nameattributeGroup name

Order 指示器

     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" 指示器(anyallchoicesequencegroup 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"这个声明

Group 指示器

   Group 指示器用于定义相关的数批元素。

元素组

元素组通过 group 声明进行定义:

<xs:group name="组名称">

  ...

</xs:group>

您必须在 group 声明内部定义一个allchoice或者 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>

(7)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.xsd
http://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" 元素。

(8)XSD <anyAttribute>

<anyAttribute> 元素使我们有能力通过未被 schema规定的属性来扩展 XML文档!

(9)XSD 元素替换

   通过 XML Schema,一个元素可对另一个元素进行替换。

为了解决这个问题,我们可以在 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"/>


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:564197次
    • 积分:7988
    • 等级:
    • 排名:第2558名
    • 原创:283篇
    • 转载:29篇
    • 译文:0篇
    • 评论:175条
    文章分类
    最新评论