XML Schema

最新推荐文章于 2023-11-28 13:43:04 发布

weixin_43980049

最新推荐文章于 2023-11-28 13:43:04 发布

阅读量2k

点赞数 1

分类专栏： Java初识 XML 文章标签： XML Schema

Java初识同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

XML

2 篇文章 0 订阅

订阅专栏

一、XML Schema简介

XML Schema或XML Schema Definition(XSD)
可扩展标记语言架构:
是以可扩展标记语言（标准通用标记语言的子集）为基础的，它用于可替代文档类型定义（外语缩写：XSD）；
一份XML schema文件描述了可扩展标记语言文档的结构。

1.定义编辑
它的作用是定义一份XML文档的合法组件群，就像文档类型定义（外语缩写：DTD）的作用一样,一份XML Schema定义了：

可以出现在文档里的元素；
可以出现在文档里的属性；
哪些元素是子元素；
子元素的顺序；
子元素的数量；
一个元素应是否能包含文本，或应该是空的；
元素和属性的数据类型；
元素和属性的默认值和固定值。

2.优劣点编辑

优点:

XML Schema 比 DTD 更强大。其优势包括以下几点：
1、支持数据类型
XML Schema 最重要的能力之一就是对数据类型的支持。通过对数据类型的支持：

可更容易地描述允许的文档内容
可更容易地验证数据的正确性
可更容易地与来自数据库的数据一并工作
可更容易地定义数据约束（data facets）
可更容易地定义数据模型（或称数据格式）
可更容易地在不同的数据类型间转换数据

2、它使用 XML 语法
另一个关于 XML Schema 的重要特性是，它们由 XML 编写。由 XML 编写 XML Schema 有很多好处：

不必学习新的语言
可使用 XML 编辑器来编辑 Schema 文件
可使用 XML 解析器来解析 Schema 文件
可通过 XML DOM 来处理 Schema
可通过 XSLT 来转换 Schema

3、可保护数据通信
当数据从发送方被发送到接受方时，其要点是双方应有关于内容的相同的"期望值"。
通过 XML Schema，发送方可以用一种接受方能够明白的方式来描述数据。
一种数据，比如 “03-11-2004”，在某些国家被解释为11月3日，而在另一些国家为当作3月11日。
但是一个带有数据类型的 XML 元素，比如：2004-03-11，可确保对内容一致的理解，这是因为 XML 的数据类型 “date” 要求的格式是 “YYYY-MM-DD”。
4、可扩展性
XML Schema 是可扩展的，因为它们由 XML 编写。通过可扩展的 Schema 定义，您可以：

在其他 Schema 中重复使用您的 Schema
创建由标准类型衍生而来的您自己的数据类型
在相同的文档中引用多重的 Schema

5、可捕获到错误
即使文档的形式良好，仍然不能保证它们不会包含错误，并且这些错误可能会产生严重的后果。
请考虑下面的情况：您订购的了 5 打激光打印机，而不是 5 台。通过 XML Schema，大部分这样的错误会被您的验证软件捕获到。

劣点:

1、虽然被写入XML是一个优势,在某些方面也是一个缺点。W3C XML Schema语言特点是可能非常冗长,而DTD可以简洁且相对容易编辑。
2、W3C XML Schema没有实现大部分提供的数据元素到文档的DTD能力。
3、继承性编辑
XML Schema可能很快就会替代文档类型定义（外语缩写：DTD）在大多数的网络应用程序中被广泛使用。
针对将来的额外内容是可扩展的；
内容比文档类型定义（外语缩写：DTD）丰富，作用也更大；
是以XML语言编写而成的；
支持数据类型；
支持名称空间（外语：namespaces）。
4、标准编辑
XML Schema于2001年5月2日成为万维网联盟（外语缩写：W3C）推荐使用的标准，在万维网联盟教程中你能阅读到更多关于XML Schema标准。

二、XML Schema基本用法简介

一个XML Schema文档通常称之为模式文档（约束文档），遵循这个文档写的xml文件称之为实例文档。和XML文件一样，一个XML Schema文档也必须有一个根节点，但这个根节点的名称为Schema。编写了一个XML Schema约束文档后，通常需要把这个文件中的声明的元素绑定到一个URI地址上，在XML Schema技术中有一个专业属于来描述这个过程，即把XML Schema文档声明的元素绑定到一个名称空间上，以后XML文件姐可以通过这个URI（即名称空间）来告诉解析引擎，xml文档中编写的元素来自那里，被谁约束。

一、名称空间的概念
1、在XML Schema中，每个约束模式文档都可以被赋以一个唯一的名称空间，名称空间用一个唯一的URI（Uniform Resource Identifier），在XML文件中书写标签时，可以通过名称空间声明（xmlns），来声明当前编写的标签来自哪个Schema约束文档。如：

<itcast:书架 xmlns:itcast=“http://www.itcast.cn”>       
       <itcast:书>……</itcast:书>   
</itcast:书架>

此处使用itcast来指向声明的名称，以便后面对名称空间的引用。

2、注意：名称空间的名字语法容易让人混淆，尽管以http://开始，那个URI并不只想一个包含模式定义的文件。事实上，这个URI：http://www.itcast.cn根本没有指向任何文件，只是一个分配的名字。

二、使用名称空间引入Schema
1、为了在一个XML文档中声明它所遵循的Schema文件的具体位置，通常需要在XML文档中的根节点中使用schemaLocation属性来指定。

<itcast:书架 xmlns:itcast="http://www.itcast.cn"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   xsi:schemaLocation=“http://www.itcast.cn book.xsd">

2、schemaLocation次属性有两个值。第一个值是需要使用的名称空间。第二个值是供命名空间使用的XML Schema的位置，两者之间用空格分隔。
3、注意：在使用schemaLocation属性时，也需要指定该属性来自哪里。

三、使用默认名称空间
1、基本格式：xmlns=”URI”
2、举例：

<书架 xmlns="http://www.it315.org/xmlbook/schema"         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation=“http://www.itcast.cn book.xsd">       
 <书>       
<书名>spark核心分析</书名>       
<作者>zhaojw</作者>       
<售价>28.00元</售价>       
 </书>   
<书架>

四、使用名称空间引入多个XML Schema文档
文件清单：book.xml

<?xml version="1.0" encoding="UTF-8"?>
 <书架 xmlns="http://www.it315.org/xmlbook/schema"     xmlns:demo="http://www.it315.org/demo/schema"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:schemaLocation="http://www.it315.org/xmlbook/schema                 http://www.it315.org/xmlbook.xsd         http://www.it315.org/demo/schema http://www.it315.org/demo.xsd">   
<书>       
<书名>spark核心分析</书名>       
<作者>zhaojw</作者>       
<售价 demo:币种=”人民币”>28.00元</售价>   
</书>
</书架>

六、不使用名称空间引入XML Schema文档
文件清单：book.xml

<?xml version="1.0" encoding="UTF-8"?> <书架 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xsi:noNamespaceSchemaLocation="xmlbook.xsd">   
<书>       
<书名>spark核心分析</书名>       
<作者>zhaojw</作者>       
<售价>28.00元</售价>   
</书>
</书架>

七、在XML Schema文档中声明名称空间

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"                targetNamespace="http://www. itcast.cn"                elementFormDefault="qualified">
<xs:schema>

1、 targetNameSpace元素用于指定Schema文档中声明的元素属于那个名称空间。
2、elementFormDefault元素用于指定，该Schema文档中声明的跟元素以及所有子元素都属于targetNameSpace所指定的名称空间。
3、targetNamespace表示将当前的元素或类型或属性放到指定的空间中（有全局和局部之分，通过elementFormDefault和attributeFormDefault来指定），如果指定了targetNamespace的值，就需要通过使用xmlns定义命名空间指向该空间，如果不指定targetNamespace的值，则表示缺省，那么在使用元素或者类型或者属性时就不需要加上命名空间前缀，此时elementFormDefault和attributeFormDefault将不起作用。

elementFormDeafult和attributeFormDefault有 unqualified和qualified两个选择值，当 elementFormDefault取值qualified时，表示此时的全局元素或者属性将被定义的指定的命名空间中，在此文件中使用时需要加上命名前缀，并且全局元素的子元素将被以缺省方式放到目标命名空间，当elementFormDefault取值unqualified时，表示全局的置于命名空间中，在此文件中使用时仍需要加上命名前缀，而局部的置于无名空间中，这些特性也就决定的我们在生成xml文件实例是否需要在子元素前面加上命名前缀，当取值qualified表示在父元素和子元素上都需要加上前缀，当取值unqualified是表示不需要再子元素前面加上前缀。  
在这里我们还需要注意一点就是在局部的元素中如果我们使用form属性时，form取值qualified和unqualified，当前的限定范围就会覆盖指定的范围，例如elementFormDefault取值qualified，form取值unqualified时，那么当前的就会定义在无名空间中，即在xml实例中该子元素时，就不需要加上前缀。

attributeFormDefault与elementFormDefault类似。
一、定义元素

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

二、定义属性

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

三、简单类型simpleType，对属性或者元素的约束，简单类型中不能包含属性或者元素，只是简单的文本

     <xs:simpleType name="">
<xs:restriction base=""> //表示约束，base 表示基于哪一种类型(xs:int/xs:string.........),在<xs:restriction>元
               </xs:restriction>//素下表示对长度、大小、枚举等限制
       </xs:simpleType> 

 例如： <xs:simpleType name="type">
<xs:restriction base="xs:string">
                   <xs:length value="2"/>
</xs:restriction> 
   </xs:simpleType> //表示type为长度为2的字符串

在simpleType中除了除了restriction之外还可以取list、union

    <xs:simpleType>
<xs:list itemType="xs:int"/>//指定该类是int类型的列表，在xml实例中取值通过空格隔开
</xs:simpleType>       

  xs:simpleType>
<xs:union memberTypes="xs:int xs:string" > //表示该类型是int和string的联合体
</xs:union>
</xs:simpleType>

四、复合类型complexType，也是对属性或者元素的约定，complexType包含元素或者属性或者二者都包含。

 <xs:complexType name="">
 <xs:sequence>//表示序列，该序列下面的元素必须按照给定的顺序出现，通过属性maxOccurs="" minOccurs=""
 <xs:element name=" " type=" "/> //指定总体出现的最大次数和最小次数，默认值为1

 <xs:element name=" " type=" "/>      maxOccurs="unbounded"表示无上限

 </xs:sequence>
 <xs:attribute name="" type=""/>//指定属性
 </xs:complexType>

除了使用sequence之外还可以使用all 、group 、choice
xs:all…</xs:all>表示其下面的元素整体按照任意的顺序出现，可出现一次或者零次
xs:group…</xs:group>表示按照组的形式出现
xs:choce…</xs:choice>表示每次选择其下的一个元素，maxOccurs="" minOccurs="",选择的最大、最小次数
另外complexType 下面还可以使用simpleContent和complexContent，其中simpleContent表示该复合类型没有元素，包含文本，还可以包含属性。

 <xs:complexType name="">
                     <xs:simpleContent>
         <xs:extension base="xs:int">//在这里还可以使用restriction   
                            <xs:attribute name="name" type="xs:string"/> 
       </xs:extension>
           </xs:simpleContent>
  </xs:complexType>//表示包含属性name和文本为int类型的符合类型

五、group和attributeGroup

  group表示对元素进行分组，attributeGroup表示对属性进行分组，在其它地方可以通过ref属性对其进行

六、unique 表示在一定的范围内对属性或者元素的唯一性进行限定

 例如：<xs:element name="books">
                  <xs:complexType>
                     <xs:sequence>
                         <xs:element name="bookName" type="xs:string" maxOccurs="unbounded"/>            
                    </xs:sequence>        
                 </xs:complexType>
                <xs:unique name="bookUnique">
                    <xs:selector xpath="bookName"></xs:selector>//表示指定范围
                    <xs:field xpath="."></xs:field>//表示当前元素本身在指定的范围内唯一
               </xs:unique>
           </xs:element>

  <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="book"/>  //指定范围
        <xs:field xpath="id"/>//指定id属性在指定的范围内唯一
    </xs:unique>
</xs:element>

7、 key元素用于对元素或者属性的唯一性进行限定
key的用法与unique的用法相同
另外还有一个refkey元素，它与key元素一起使用

 <xs:keyref refer="sortKey" name="sortKeyRef">  //refer表示引用一个key元素
    <xs:selector xpath="book"></xs:selector>//表示限定的范围
    <xs:field xpath="type"></xs:field>//表示type的值必须是sortKey中的一员
    </xs:keyref>
	<xs:element name="学生名册" type="students"/>
    <xs:complexType name="students">
    <xs:sequence minOccurs="1" maxOccurs="unbounded">
    <xs:element ref="student"/>
    </xs:sequence>
    </xs:complexType>
    <xs:element name="student" type="s"/>
    <xs:complexType name="s">
    <xs:sequence minOccurs="1" maxOccurs="1">
    <xs:element ref="name"/>
    <xs:element ref="gender"/>
    <xs:element ref="age"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:int" use="required"/>
    </xs:complexType>
    <xs:element name="name" type="xs:string"/>
    <xs:element name="gender">
    <xs:simpleType>
    <xs:restriction base="xs:string">
    <xs:enumeration value="男"/>
    <xs:enumeration value="女"/>
    </xs:restriction>
    </xs:simpleType>
    </xs:element>
    <xs:element name="age">
    <xs:simpleType>
    <xs:restriction base="xs:int">
    <xs:minExclusive value="0"/>
    <xs:maxInclusive value="150"/>
    </xs:restriction>
    </xs:simpleType>
    </xs:element>

三、XML Schema应用实例

最简单的Schema文档
如何写一个最简单的XML Schema文档呢？
首先，我们写出一个最简单的XML文档。

hello.xml
-------------------
<?xml version="1.0"?> 
<greeting>Hello World!!</greeting>
<!--一个根元素：greeting；且这个元素不含属性，无子元素，内容是字符串。-->


hello.xsd
－－－－－－－－－－
<?xml version="1.0"?> 
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="greeting" type="xsd:string"/>
</xsd:schema>

XML Schema文档后缀名是.xsd，完全符合XML语法，根元素是schema，命名空间xmlns:xsd="http://www.w3.org/2001/XMLSchema，用元素定义实例文档中的元素，如greeting。

含子元素的Schema文档
假设实例文档是如下的：

customer.xml

<customer>
<name>teiki</name>
<address>No.237, Road Waitan, Shanghai</address>
</customer>

则可以写出以下的XML Schema文档：
customer.xsd

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="customer">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:string"/>
<xsd:element name="address" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

实例文档customer.xml中，<customer>元素含有两个子元素，所以我们在Schema文档中采用ComplexType来定义该元素。sequence表示子元素依次出现的顺序。

含子元素和孙元素的Schema文档
这次我们给出一个更加复杂一些的文档：
customer.xml

    <customer>
    <name>Teiki</name>
    <address>
    <!-- address追加一个地址子元素 -->
    <prefecture>Zhejiang</prefecture>
    <city>Hangzhou</city>
    <street>Xilu Road, No.121, 7F</street>
    </address>
    </customer>

为此，我们需要一个更加复杂一点的Schema文档：
address.xsd

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="customer">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:string"/>
<!-- 追加子元素address-->
<xsd:element name="address">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="prefecture" type="xsd:string"/>
<xsd:element name="city" type="xsd:string" />
<xsd:element name="street" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

不过，我们还可以采用ref元素来重新编写这个Schema文档：
address2.xsd

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="customer">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="name" type="xsd:string"/>
<xsd:element ref="address"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="address">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="prefecture" type="xsd:string"/>
<xsd:element name="city" type="xsd:string" />
<xsd:element name="street" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

使用ref元素可以直接将其指向另一个模块，使文档更加具有可读性。

定义相同子元素的数量
先看这个简单的订购数据实例文档：
order.xml

<order>
<orderItem>Accounting Book</orderItem>
<orderItem>Taxation Book</orderItem>
</order>

假设元素，即每次的订购书目不能超过10种，那该怎么写这个Schema文档呢？这里要用到的maxOccurs属性。
order.xsd

 <?xml version="1.0"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:element name="order">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="orderItem"   type="xsd:string"  maxOccurs="10" />
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    </xsd:schema>

第7行中的maxOccurs属性为10，代表orderItem元素可以最大有10个。如果，不设定元素个数，则可以用maxOccurs="unbounded"来定义。
类似，如果要定义最小值，可以使用minOccurs，比如下面这句：
<xsd:element name=“orderItem” type=“xsd:string” minOccurs=“5” maxOccurs=“10”/>
这两个属性缺省值都是1。

定义可选项的子元素
假如上面的订书数据中，可以用书名或者书号任意一种订购，则实例文档可能如下：
order2.xml

     <order>
        <orderItem>
        <!--书名订购-->
        <name>Accounting Book</name>
        </orderItem>
        <orderItem>
        <!--书号订购-->
        <id>7-5058-3496-7</id>
        </orderItem>
     </order>

这时书写Schema文档还需要使用choice元素。
order2.xsd

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="order">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="orderItem" maxOccurs="10" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="orderItem">
<xsd:complexType>
<xsd:choice>
<xsd:element name="name" type="xsd:string"/>
<xsd:element name="id" type="xsd:string"/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>

稍微更复杂的可选项子元素
再稍微修改一下订书数据的实例文档：
order3.xml

<order>
<orderItem>
<name>Accounting Book</name>
<quantity>2</quantity>
</orderItem>
<orderItem>
<id>7-5058-3496-7</id>
</orderItem>
</order>

这里假定值为1时，缺省。
如何修改Schema文档呢？
order3.xsd

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="order">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="orderItem" maxOccurs="10"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="orderItem">
<xsd:complexType>
<xsd:sequence>
<xsd:choice>
<xsd:element name="name" type="xsd:string"/>
<xsd:element name="id" type="xsd:string"/>
</xsd:choice>
<xsd:element name="quantity" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

19行中的quantity最少出现值为0，也就是可以有，也可以没有。
当然，也可以直接在元素中，包含quantity,然后定义它的minOccurs。

内置简单类型
图省略
自定义简单类型
如果内置简单类型的44种还不能满足要求，怎么办呢？下面学习自定义简单类型。(XML的扩展性充分体现在这里)
例如这个实例文档：
order4.xml

<order>
<orderItem>
<id>7-5058-3496-7</id>
<quantity>5</quantity>
</orderItem>
</order>

ID是一个标准的ISBN编码，我们怎么定义这个ISBN编码呢？

<xsd:simpleType name="idType">
<xsd:restriction base="xsd:string">
<xsd:pattern value="/d{1}-/d{4}-/d{4}-/d{1}"/>
</xsd:restriction>
</xsd:simpleType>

idType是一个自定义的简单类型。
我们对它做了限制：
<xsd:restriction base=“xsd:string”>代表它是基于一个字符串类型。再用pattern元素来描述该字符串的形式。
value="/d{1}-/d{4}-/d{4}-/d{1}"这是一个正则表达式，关于正则表达式，以后再介绍。嘻嘻！
利用这个自定义的简单类型，我们可以重新写Schema文档：
order4.xsd

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="order">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="orderItem" maxOccurs="10"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="orderItem">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="id" type="idType"/>
<xsd:element name="quantity" type="xsd:integer"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:simpleType name="idType">
<xsd:restriction base="xsd:string">
<xsd:pattern value="/d{1}-/d{4}-/d{4}-/d{1}"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>

假如我们事先确定好ID只有3个，即只有3个ISBN是可选的，那怎么办？我们可以用enumeration元素来进行列举。

<xsd:simpleType name="idType">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="7-5058-3496-7"/>
<xsd:enumeration value="7-5005-6450-3"/>
<xsd:enumeration value="7-3020-6069-7"/>
</xsd:restriction>
</xsd:simpleType>

再来看订购量quantity的值，如果我们设定其值必须在1－10之间，该怎么办呢？可以这些自定义一个简单类型。

<xsd:simpleType name="quantityType">
<xsd:restriction base="xsd:integer">
<xsd:minInclusive value="1"/>
<xsd:maxInclusive value="10"/>
</xsd:restriction>
</xsd:simpleType>

其中，minInclusive,maxInclusive分别代表该类型的取值范围。
所以最终修改后的Schema文档如下：
order4-1.xsd

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="order">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="orderItem" maxOccurs="10"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="orderItem">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="id" type="idType"/>
<xsd:element name="quantity" type="quantityType"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:simpleType name="idType">
<xsd:restriction base="xsd:string">
<xsd:enumeration value="7-5058-3496-7"/>
<xsd:enumeration value="7-5005-6450-3"/>
<xsd:enumeration value="7-3020-6069-7"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="quantityType">
<xsd:restriction base="xsd:integer">
<xsd:minInclusive value="1"/>
<xsd:maxInclusive value="10"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>

定义属性
最后，我们再来讲讲元素的属性如何在Schema文档中定义。
比如上面的order.xml实例文档中：

<order>
  <orderItem id="7-5058-3496-7" />
</order>

对此，我们在Schema文档中采用一个attribute来定义：
order.xsd

<xsd:element name="orderItem">
<xsd:complexType>
<xsd:sequence>　　←空元素
</xsd:sequence>　 
<!--定义该元素属性-->
<xsd:attribute name="id" type="xsd:string"/>
</xsd:complexType>
</xsd:element>

那么，实例文档中该属性值是必须的还是可有可无的呢？我们可以这样限制：
<xsd:attribute name=“id” type=“idType” use=“required”/>
这里我们讲id属性类型作为一种自定义数据类型idType。
而且，用attribute元素的use属性来定义是否是必须的属性。
required是必须值，optional是可选值，prohibited是无属性值。
那么对于属性的缺省值，我们怎么定义呢？
比如：

<order>
  <orderItem id="4-8443-1780-6" quantity="3"/>
</order>

我们还可以用attribute元素的另一个属性default来定义：
<xsd:attribute name=“quantity” type=“xsd:integer” default=“1”/>
所以，我们可以重新写出一个Schema文档：
order2.xsd

<xsd:element name="orderItem">
<xsd:complexType>
<xsd:sequence></xsd:sequence>
<xsd:attribute name="id" type="idType" use="required"/>
<xsd:attribute name="quantity" type="xsd:integer" default="1"/>
</xsd:complexType>
</xsd:element>

上面的属性我们定义我们还可以采用属性组的办法来重新改写Schema文档。
order3.xsd

<xsd:element name="orderItem">
<xsd:complexType>
<xsd:sequence></xsd:sequence>
<xsd:attributeGroup ref="orderItemAttributes"/>
</xsd:complexType>
</xsd:element>
<xsd:attributeGroup name="orderItemAttributes">
<xsd:attribute name="id" type="idType" use="required"/>
<xsd:attribute name="quantity" type="xsd:integer" default="1"/>
</xsd:attributeGroup>

这个属性组就不详细解释了，不过，大家一看就清楚了吧。
最后，我们写一个完整的订书order.xml的Schema文档。

<?xml version="1.0"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:element name="order">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="orderItem" maxOccurs="10"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="orderItem">
<xsd:complexType>
<xsd:sequence></xsd:sequence>
<xsd:attributeGroup ref="orderItemAttributes"/>
</xsd:complexType>
</xsd:element>
<xsd:attributeGroup name="orderItemAttributes">
<xsd:attribute name="id" type="idType" use="required"/>
<xsd:attribute name="quantity" type="xsd:integer" default="1"/>
</xsd:attributeGroup>
<xsd:simpleType name="idType">
<xsd:restriction base="xsd:string">
<xsd:pattern value="/d{1}-/d{4}-/d{4}-/d{1}"/>
</xsd:restriction>
</xsd:simpleType>
</xsd:schema>

其他xml中引用xsd

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<Envlope xmlns="gmip" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="gmip_appraise_rep.xsd">

Xsd中对应为：

<?xml version="1.0"?>
<xsd:schema targetNamespace="gmip" xmlns:xsd="http://www.w3.org/2001/XMLSchema"  elementFormDefault="qualified" attributeFormDefault="qualified">

ElementFormDefault=”qualified” 意思是要求element使用的namespace是targetNamespace，它的作用是对元素起"限定与非限定"使用,意思是在文档范例中要求采用命名空间前缀。

参考资料：
1.XML Schema 教程https://www.runoob.com/schema/schema-tutorial.html
2.XML Schema 简介http://www.w3school.com.cn/schema/schema_intro.asp

原文 : https://baike.sogou.com/v144525228.htm?fromTitle=XML+Schema
原文：https://blog.csdn.net/key/article/details/265200
原文：https://blog.csdn.net/zhaojw_420/article/details/53391507
原文：https://blog.csdn.net/u013516966/article/details/43151491

weixin_43980049

关注

1
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
XML Schema

一、XML Schema简介XML Schema或XML Schema Definition(XSD)可扩展标记语言架构:是以可扩展标记语言（标准通用标记语言的子集）为基础的，它用于可替代文档类型定义（外语缩写：XSD）；一份XML schema文件描述了可扩展标记语言文档的结构。1.定义编辑它的作用是定义一份XML文档的合法组件群，就像文档类型定义（外语缩写：DTD）的作用一样,一份...
复制链接

扫一扫

专栏目录