XML架构工具之Schema

前言

XML Schema 是基于XML标记语言设计的一个XML文档架构工具，它是DTD替代品，比DTD功能更强大，所以它是XML文档架构目前最佳的选择。学XMLSchema之前最好先学DTD，因为它们都是为了解决XML架构、XML数据传输检验、XML数据传输标准化的问题，DTD更为简单易学，虽然XML Schema 也不是很难，但是有了DTD作为基础就更容易学、更容易上手。

1.XML Schema是什么？

XML Schema 就是一个XML 文档的架构工具，指定和描述一个XML文档组织结构，组成部分及各个部分的属性，是DTD的替代品。

2.作用是什么？

XML Schema 目的是为了详细的描述一个XML文档，根据需要架构一个XML，定义一个XML文档中的元素（标签）、元素属性、元素的值类型、元素出现的次数、元素的出现顺序、元素的父子关系；这样在编写或传输数据时有了统一的标准，客户端和服务器之间接收数据时有了校验规则，在解析数据时有了参照规则；避免了不同的使用者使用不同的数据格式，产生解析负担。

3.有哪些功能？

（1）定义元素；
（2）定义元素的属性；
（3）定义元素的内容类型，以及内容的格式和字符数限制；
（4）定义元素是否必须出现，最少出现几次，最多出现几次；
（5）定义的出现顺序，是固定顺序还是无序的，还是说多个元素之间只能选一个；
（6）定义元素的层次关系；
在这里插入图片描述

4.怎么使用？

4.1.XSD文档组成

基础文档：作用是架构XSD文件即描述、定义XSD文档的规则文件；
元素：它是XSD文档的根元素，所有对应XML的描述和定义都在这个根元素里面；
空间名称：XSD文档中定义的元素存放空间；
文档主体：指XSD文档中元素定义、属性定义、文件格式定义等统称为主体；

案例：
文件以.XSD结尾：
在这里插入图片描述
内容如下

基础文档链接：http://www.w3.org/2001/XMLSchema，可以直接复制，这个目标群使用最为广泛的XSD架构标准文档。

4.2.XSD文档的引用

XSD文档是以<?xml version="1.0" ?> 开头的，验证了XSD是XML标记语言基础上实现的；所以XSD中引入文档的方式和XML中引入XSD文档的方式是语言的，以xmlns属性来引入外部文档，xmlns的使用格式：

默认文档引入：xmlns=“[外部文档路径]”，默认文档中的元素可以直接使用；
其它文档引入：xmlns:[前缀]=“[外部文档路径]”，和默认文档中的元素不一样的，需要加了前缀才能使用；
上面两个说明了文档中可以引入多个文档，但是默认文档只能有一个；
例子如下：

<xs:schema xmlns="http://www.baiguifu.com/learnXMLSchema"
           xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="learn.xsd"
           xmlns="learn.xsd"
           elementFormDefault="qualified">

上面列例子中http://www.baiguifu.com/learnXMLSchema 就是默认文档；http://www.w3.org/2001/XMLSchema就是其它问题，xs是这个文档密码空间的缩写，是内部元素时需要带前缀，比如<schema> 使用时需要写成<xs:schema>,这种前缀的使用方式是xsd中允许引入多个文档的基础，这样就避免了元素冲突。
上面是xsd文档中引入外部文件，下面是XML中引入XSD文件:

<root
        xmlns="learn.xsd"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="learn.xsd learn.xsd">

说明：第一个xmlns是自己需要的xsd文件；第二个是引入用来指定xml解析器解析时可以读取的文档规则标签元素schemaLocation, 它的值格式是：[文档空间名称][空格][文件地址路径]，是以成对出现的，多个文件用逗号隔开，然后重复上面的格式就行：

 xsi:schemaLocation="learn.xsd learn.xsd  learn.xsd2 learn.xsd2 learn.xsd3 learn.xsd3">

列如：

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

会创建xsd文档，会引入xsd文档到XML文档中就完成了如何使用的问题，下面我们考虑如何架构自己的xml文档了

5.编写XSD文档

5.1.架构

架构就是划分你的XML文档，把XML进行分层，每一层有几个元素，每个元素都有哪些属性，有大概想法后去写对速度是有帮助的，编写处理的xsd更为高效、更为清晰。

5.2.xsd 主体的组成

5.2.1.xsd的数据类型

5.2.1.1.数值类型

在这里插入图片描述
数值类型数据限定：enumeration-枚举来指定可选值；fractionDigits-限定最大的小数位，用户控制精度；length-自定数据的长度；maxExclusive-指定数据的最大值（小于）；maxInclusive-指定数据的最大值（小于等于）；maxLength-指定长度的最大值；minExclusive-指定最小值（大于）; minInclusive-指定最小值（小于等于）; minLength-指定最小长度; pattern-正则

5.2.1.2.字符串

在这里插入图片描述

数值类型数据限定：enumeration-枚举来指定可选值；length-自定数据的长度；maxLength-指定长度的最大值; minLength-指定最小长度; pattern-正则; whiteSpace-空白字符处理设置

5.2.1.2.日期数据类型

在这里插入图片描述

time类型的时间格式：hh:mm:ss, hh-表示小时，mm-表示分钟，ss-表示秒，如：01:01:01或23:00:00；
datetime类型时间格式：YYYY-MM-DDTmm:hh:ss。YYYY-表示年份，MM表示月份，DD表示几号，T-表示time部分的开始即就是表示分隔符；hh:mm:ss是time是一样的含义。如：2023-12-31T23:00:00
上面两个是常见的日期类型！
时间间隔的表示即相隔几年、几月、几周等等，格式：“PnYnMnDTnHnMnS”，其中：

例如：P10Y2M10D，其中P无值所以前面值表示10年2个月10天。
数值类型数据限定：enumeration-枚举来指定可选值；maxExclusive-指定数据的最大值（小于）；maxInclusive-指定数据的最大值（小于等于）；minExclusive-指定最小值（大于）; minInclusive-指定最小值（小于等于）; pattern-正则；whitespace-空白字符的处理

5.2.1.4.其它数据类型

其它常用的有：boolean(布尔类型)、AnyURI（统一资源标识符）、floatl、double(浮点数)

5.2.2.简易元素定义

从这里开始，用来定义元素、属性的元素我们就称其为元元素。定义元素的关键元元素就是<element>。简易元素是指定义的元素中没属性、没有子元素，

5.2.2.1格式如下：

<xs:element name="{元素名称}" type="{数据类型}"/>

或

<xs:element name="{元素名称}">
        <xs:simpleType>
            <xs:restriction xml:base="{元素值类型}">
                {对元素值的限定}
            </xs:restriction>
        </xs:simpleType>
    </xs:element>

有两种情况信息。

例子1：

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

说明：name 定义元素的名称，type-定义元素的类型；

例子2：

<xs:element name="simpleEle01">
        <xs:simpleType>
            <xs:restriction base="xs:integer">
            </xs:restriction>
        </xs:simpleType>
    </xs:element>

说明：

<simpleType>：元元素指定当前<element>里面包含的是一个简易元素；
<restricion>: 元元素指定当前定义元素的限制内容，其中的属性base指定当前定义元素的数据类型；<restriction> 里面可以更多的限制，我们项目再讲。

5.2.2.2.`简易元素的默认或固定值`

关键属性是 default 默认值，fixed 固定值

设置默认值格式：

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

设置固定值格式：

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

例子：

<xs:element name="number1" type = "xs:integer" default="1000001"/>
    <xs:element name="number2" type="xs:integer" fixed="10000009"/>

5.2.3.属性定义

属性就是元素的一些特性，定义方式和简易元素类似，关键的元元素是<attribute>,格式如下：

<xs:attribute name="{属性名称}" type="{数据类型}"/>

属性的声明要么在混合元素内部、要么在属性组中声明定义，这两个我们会在后续章节中介绍，在这里我们给个例子：

<xs:element name="student">
        <xs:complexType>
            <!--元素中-->
            <xs:attribute name="id" type="xs:string"/>
        </xs:complexType>
    </xs:element>
    
    <xs:attributeGroup name="attList">
        <!--属性组中-->
        <xs:attribute name="name" type="xs:int"/>
    </xs:attributeGroup>

5.2.4.元素的限定

元素限定的元元素是<restriction>,用于限定元素的类型、元素内容的长度、匹配格式、最大最小值等等。在我们《xsd的数据类型》章节讲到的各种数据类值的限定就在这个元元素下面声明的。<restriction>元素中的属性base就是指定所定义元素的类型。

5.2.4.1.格式：

<xs:restriction base="{元素类型}">
        {子元素}
</xs:restriction>

5.2.4.2.对值范围限定

<restriction>通过其子元素的配合进行对定义元素数据规范,必须配合<simpleType> 配合使用，以integer为例：

<xs:restriction base="xs:integer">
                 <!--限定小值（大于等于）-->
                 <xs:minInclusive value="10"/>
                 <!--限定最大值（小于）-->
                 <xs:maxExclusive value="100"/>
             </xs:restriction>

说明：

base: 设置当前元素的类型是integer类型；
minInclusive 定义该元素在使用时的取值范围是必须大于等于设置的值；
maxExclusive 定义该元素在使用时的取值范围必须小于设置的值；

温馨提示：如果对restriction的字元素作用不明白就返回《xsd的数据类型》章节的对应数据类型小节，上面有数据类型限制的对应说明。

5.2.4.3.枚举限制

还是以integer类型为例：

<xs:restriction base="xs:integer">
                    <xs:enumeration value="1"/>
                    <xs:enumeration value="2"/>
                    <xs:enumeration value="3"/>
                    <xs:enumeration value="4"/>
                </xs:restriction>

上面的这个例子就是，元素的值只能在1,2，3, 4。

5.2.4.4.正则匹配

通过正则表达式可以限制元素内容的组成格式及长度。以string类型为例：

 <xs:restriction base="xs:string">
                    <xs:pattern value="^[a-z]$"/>
                </xs:restriction>

上面的例子意思当前的元素内容必须以小写字母组成。

温馨提示：对正则表达没有基础的朋友可以去学一下，它是一种非常高效的文本校验方式，当然缺点就是写起来很繁琐

5.2.4.5 长度限制

关键元素是length、maxLength、minLength 来限制元素值的长度，例子如下：

<xs:restriction base="xs:string">
                    <xs:length value="100"/>
                </xs:restriction>

5.2.4.5. 其它限定元素

限定	描述
enumeration	定义可接受值的一个列表
fractionDigits	定义所允许的最大的小数位数。必须大于等于0。
length	定义所允许的字符或者列表项目的精确数目。必须大于或等于0。
maxExclusive	定义数值的上限。所允许的值必须小于此值。
maxInclusive	定义数值的上限。所允许的值必须小于或等于此值。
maxLength	定义所允许的字符或者列表项目的最大数目。必须大于或等于0。
minExclusive	定义数值的下限。所允许的值必需大于此值。
minInclusive	定义数值的下限。所允许的值必需大于或等于此值。
minLength	定义所允许的字符或者列表项目的最小数目。必须大于或等于0。
pattern	定义可接受的字符的精确序列。
totalDigits	定义所允许的阿拉伯数字的精确位数。必须大于0。
whiteSpace	定义空白字符（换行、回车、空格以及制表符）的处理方式

5.2.5.复合元素

复合元素恰恰和简易元素相反，复合元素中必须包含元素、子元素中一个或者两个都包含。关键元元素是：<element>、<complexType>、<comlexCotent>；复合元素有4种：空元素、包含子元素、包含文本和属性、包含属性和子元素、混合元素

5.2.5.1.格式

第一种格式：全部都在<element>中定义

 <!--元素标签-->
    <xs:element name="{元素名称}">
        <!--定义元素为复合元素-->
        <xs:complexType>
            <!--定义元素类型-->
            <xs:complexContent>
                <!--限定元素-->
                <xs:restriction base="{元素类型}">
                    <!--顺序指示器-->
                    <xs:sequence>
                        <!--子元素-->
                        <xs:element name="{子元素名称}"/>
                    </xs:sequence>
                </xs:restriction>
            </xs:complexContent>
            <!--定义属性-->
            <xs:attribute name="{属性名称}" type="{属性类型}"/>
        </xs:complexType>
    </xs:element>

第二种格式

把复合类型声明提取出来，这样的好处就是提取通用部分，然后多个元素使用这个部分：

 <!--定义元素为复合元素-->
    <xs:complexType name="{复合类型名称}">
        <!--定义元素类型-->
        <xs:complexContent >
            <!--限定元素-->
            <xs:restriction base="{元素类型}">
                <!--顺序指示器-->
                <xs:sequence>
                    <!--子元素-->
                    <xs:element name="{子元素名称}"/>
                </xs:sequence>
            </xs:restriction>
        </xs:complexContent>
        <!--定义属性-->
        <xs:attribute name="{属性名称}" type="{属性类型}"/>
    </xs:complexType>

    <!--元素标签-->
    <xs:element name="{元素名称}" type="{复合类型名称}"/>

5.2.5.2.复合空元素定义

复合空元素就是只有属性，不包含文本、不包含子元素：

<xs:element name="emptyEl">
        <xs:complexType>
            <xs:attribute name="id" type="xs:string"/>
        </xs:complexType>
    </xs:element>

上面的代码中定义了一个emptyEl复合空元素，它只有一个属性id;没有指定类型所以不能包含文本，更没有声明子元素。

5.2.5.2.仅含元素

也就一个元素中只有子元素，不含属性和文本：

<xs:element name="dog">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="number" type="xs:string"/>
                <xs:element name = "name" type="xs:int"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

上面的例子中定义了一个dog元素，同时声明了两个字元素：number,name; 就没有文本和属性；

5.2.5.3.含文本和属性

不能只包含文本的，只包含文本就是简易元素，例如：

 <xs:element name="dog">
         <xs:complexType>
             <xs:simpleContent>
                <xs:restriction base="xs:string"/>
             </xs:simpleContent>
             <xs:attribute name="id" type="xs:int"/>
          </xs:complexType>
 </xs:element>

上面定义了一个名称为dog的复合元素，文本类型为string, 有一属性为id.

5.2.5.4.包含属性和子元素

只包含属性和子元素的元素，例如：

 <xs:all>
                <xs:element name="complexEl">
                    <xs:complexType>
                        <xs:all>
                            <xs:element name="A1" type="xs:int"/>
                            <xs:element name="B1" type="xs:string"/>
                        </xs:all>
                        <xs:attribute name="id" type="xs:string"/>
                    </xs:complexType>
                </xs:element>

上定义的元素只有元素和属性，不包含文本。

5.2.5.5.混合元素

属性、子元素、文本都包含的元素就称为复合元素，例如：

 <xs:element name="complexEl">
                    <xs:complexType>
                        <xs:complexContent>
                            <xs:restriction base="xs:string">
                                <xs:all>
                                    <xs:element name="A1" type="xs:int"/>
                                    <xs:element name="B1" type="xs:string"/>
                                </xs:all>
                            </xs:restriction>
                        </xs:complexContent>
                        <xs:attribute name="id" type="xs:string"/>
                    </xs:complexType>
                </xs:element>

上面这个元素包含了属性、子元素、文本，使用例子：

 <complexEl id="1000">
         ss
        <A1>1</A1>
        sss
        <B1>2</B1>
        sss
    </complexEl>

5.2.6.指示器

指示器是指用于指示控制元素的使用顺序、可出现次数、分组的管理器。

5.2.6.1.指示器分类

Order指示器：控制元素顺序，分别有all（无顺序限制）、choice（多选一，多个元素中有且只能选择一个）、sequence（固定顺序，使用时要按定义时的顺序出现）；
Occurrence 指示器：控制元素是否必须出现、可出现几次的控制器，分别有：minOccurs(最小出现次数指示器)、maxOccurs(最到出现次数指示器)；
Group指示器：控制元素和属性的分组控制器，group（元素组）、attributeGroup(属性组)

5.2.6.2.Order指示器的使用

sequence固定顺序
定义元素例子如下：

  <!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="A"/>
                <xs:element name="B"/>
                <xs:element name="C"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

xml中使用元素的例子如下：

<root
        xmlns="learn.xsd"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="learn.xsd learn.xsd ">
    <A></A>
    <B></B>
    <C></C>
</root>

root的子元素A,B,C在使用时必须按顺序出现，不能是CBA、BAC、CAB等，只能是ABC顺序。

choice 选择指示器
定义元素例子：

<xs:element name="root">
     <xs:complexType>
         <xs:choice>
             <xs:element name="A"/>
             <xs:element name="B"/>
             <xs:element name="C"/>
         </xs:choice>
     </xs:complexType>
 </xs:element>

xml中的使用：

     <root
      xmlns="learn.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="learn.xsd learn.xsd ">
   <A></A>
 </root>

使用时子元素A、B、C中只能选一个，不能一个或两个同时出现。

all 无序指示器
无序指示器例子：

<xs:element name="root">
        <xs:complexType>
            <xs:all>
                <xs:element name="A"/>
                <xs:element name="B"/>
                <xs:element name="C"/>
            </xs:all>
        </xs:complexType>
    </xs:element>

XML中使用例子：

<root
       xmlns="learn.xsd"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="learn.xsd learn.xsd ">
   <A></A>
   <C></C>
   <B></B>
</root>

在使用子元素A,B,C他们的顺序是不要求的，可以然后顺序出现。

5.2.6.3.Occurrence次数指示器

主要两个属性就是minOccurs、maxOccurs，如果两个值大于1即元素出现的次数可能大于1的时候，必须配合顺序指示器sequence和choice使用，不能和无序指示器all配合使用，例子如下：

<!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="m1" type="xs:string" minOccurs="1" maxOccurs="10"/>
                <xs:element name="m2" type="xs:string" minOccurs="1" maxOccurs="10"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

xml的中的使用例子：

<root
        xmlns="learn.xsd"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="learn.xsd learn.xsd ">
    <m1></m1>
    <m1></m1>
    <m2></m2>
</root>

出现顺序必须是m2在m1之后，在m2之前可以有多个m1。

5.2.6.4.group 分组器

元素分组器：用于给元素分组，这样的好处就是可以统一定义元素，多出使用，关键元元素。
属性分组器：用于给属性分组，好处和元素分组的作用是语言的，统一定义多出使用，关键元元素。
使用例子如下：

<xs:element name="root">
        <xs:complexType>
            <xs:all>
                <xs:element name="person">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:group ref="student"/>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:all>
        </xs:complexType>
    </xs:element>

    <xs:group name="student">
        <xs:sequence>
            <xs:element name="a1">
                <xs:complexType>
                    <xs:attributeGroup ref="studentAtt"/>
                </xs:complexType>
            </xs:element>
            <xs:element name="a2">
                <xs:complexType>
                    <xs:attributeGroup ref="studentAtt"/>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:group>

    <xs:attributeGroup name="studentAtt">
        <xs:attribute name="att" type="xs:string"/>
        <xs:attribute name="att1" type="xs:int"/>
    </xs:attributeGroup>

上面元素组是student，属性组是studentAtt.

5.3.进阶知识

5.3.1.自定义类型

自定义类型的关键元元素是<complex>

 <!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">
        <xs:complexType>
            <xs:all>
                <!--使用自定义类型-->
                <xs:element name="p1" type="person"/>
            </xs:all>
        </xs:complexType>
    </xs:element>

    <!--定义复合类型-->
    <xs:complexType name="person">
        <xs:complexContent>
            <xs:restriction base="xs:int">
                <xs:attribute name="name" type="xs:string"/>
            </xs:restriction>
        </xs:complexContent>
    </xs:complexType>

person自己定义的类型，p1就是该类型的元素。

5.3.1.元素继承和拓展

复合元素继承是指继承已定义的复合元素，拓展是指继承复合元素的基础上定义自己的属性和元素：

 <!--定义复合类型-->
    <xs:complexType name="student">
        <xs:attribute name="id" type="xs:int"/>
    </xs:complexType>

    <!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">
        <xs:complexType>
            <xs:all>
                <!--直接继承，不做拓展-->
                <xs:element name="student01" type="student"/>
                <xs:element name="student02">
                    <xs:complexType>
                        <xs:complexContent>
                            <!--继承-->
                            <xs:extension base="student">
                                <!--拓展-->
                                <xs:attribute name="mobile" type="xs:string"/>
                            </xs:extension>
                        </xs:complexContent>
                    </xs:complexType>
                </xs:element>
            </xs:all>
        </xs:complexType>
    </xs:element>

上面student是自己定义的复合类型，sudent01元素只做了继承，student02元素，不仅做了继承还进行了拓展，这种方式的好处就可以提出通用部分，统一维护。

5.3.2.<any> 元素

元元素，是一个占位元素，任何元素都可以占用这些位置，当然这些元素都必须在Xml Schema文档中定义过；同时只能在次数指顺序指示器sequence和choice配合使用，例子如下：

 <!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="B3">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="b1"/>
                            <xs:any minOccurs="1" maxOccurs="3"/>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

    <xs:element name="b2" type="xs:string"/>
    <xs:element name="b3" type="xs:string"/>

xml中使用时：


<root
        xmlns="learn.xsd"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="learn.xsd learn.xsd ">
   <B3>
      <b1></b1>
      <b2></b2>
      <b3></b3>
   </B3>
</root>

在XML Schema中定义B3元素时，子元素只定义了b1以及定义了<any> 占位元素，占位元素最多可以占3个位置。在xml中使用就可以使用在其它地方定义的元素b2,b3去使用<any>提前所占的位置。当然b2、b3虽然不需要再b1内部定义倒是必须在其它地方定义元素。

5.3.3.<anyAttribute>元素

<anyAttribute>是属性占位元素，可以使用xsd文件中未定义的属性, 可以任意添加，使用例子如下：

 <!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">

        <xs:complexType>
            <xs:sequence>
               <xs:element name="c">
                   <xs:complexType>
                      <xs:complexContent>
                          <xs:restriction base="xs:string">
                              <xs:attribute name="id" type="xs:string"/>
                              <xs:anyAttribute/>
                          </xs:restriction>
                      </xs:complexContent>
                   </xs:complexType>
               </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

xml中的使用例子如下：

<root
        xmlns="learn.xsd"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="learn.xsd learn.xsd ">
    <c id="100" age="100" b="100"/>
</root>

补充:
在这里插入图片描述

5.3.4.元素的引用

定义和使用位置独立分开，通过引用的创建关系,关键属性是ref

<!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">
        <xs:complexType>
            <xs:all>
                <xs:element ref="A1"/>
            </xs:all>
        </xs:complexType>
    </xs:element>

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

5.3.6.元素替换

顾名思义，用一个元素去替换另外一个元素，也就是两个元素同时出现时只有其中一个有效，配合元素的引用ref使用。

 <!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">
        <xs:complexType>
            <xs:all>
                <!--使用自定义类型-->
                <xs:element  ref="A1"/>
            </xs:all>
        </xs:complexType>
    </xs:element>

    <!--定义复合类型-->
    <xs:element name="A1" type="xs:int"/>
    <xs:element name="B2" type="xs:int" substitutionGroup="A1"/>

注意：去替换的元素和可替换元素的类型必须一样

5.3.7.注释元素

<annotation> 素是一个顶层元素，规定 schema 的注释。子元素<documentation>中编写对用户的描述，<appinfo>中写引用程序所需要的描述信息。


    <!--声明根元素,根元素肯定是复合元素-->
    <xs:element name="root">
        <xs:annotation>
            <xs:documentation>根元素</xs:documentation>
            <xs:appinfo>redis</xs:appinfo>
        </xs:annotation>
        <xs:complexType>
            <xs:all>
                <!--使用自定义类型-->
                <xs:element  ref="A1"/>
            </xs:all>
        </xs:complexType>
    </xs:element>

    <!--定义复合类型-->
    <xs:element name="A1" type="xs:string"/>
    <xs:element name="B2" type="xs:string" substitutionGroup="A1"/>

使用例子：
在这里插入图片描述

总结

学海无涯苦作舟,XML使用篇见! 同时欢迎大家指出不足之处!

XML Schema的基本语法_xmlschematree.getelementsbyname("enumeration");-CSDN博客

XSDL（XML Schema定义语言）由元素、属性、命名空间和XML文档种的其他节点构成的。

一、XSD中的元素

XSD文档至少要包含：schema根元素和XML模式命名空间的定义、元素定义。

1、schema根元素语法如下：

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

…

</xsd:schema>

在XSD中必须定义一个且只能定义一个schema根元素。根元素中包括模式的约束、XML模式命名空间的定义，其他命名空间的定义、版本信息、语言信息和其他一些属性。

2、元素

语法如下：

<xsd:element name=”user” type=”xsd:string” />

XSD中的元素是利用element标识符来声明的。其中name属性是元素的名字，type属性是元素值的类型，在这里可以是XML Schema中内置的数据类型或其他类型。

例子：

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

<xsd:element name=”user” type=”xsd:string” />

</xsd:schema>

以上文档对应的有效XML文档如下：

<?xml version=”1.0”?>

<user>string</user>

在元素的定义中还有2个属性：minOccurs和maxOccurs。其中minOccurs定义了该元素在父元素中出现的最少次数（默认为1，值为大于等于0的整数），maxOccurs定义了该元素在父元素中出现的最多次数（默认为1，值为大于等于0的整数）。在maxOccurs中可以把值设置为unbounded，表示对元素出现的最多次数没有限制。

例子：

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

<xsd:element name=”user” type=”xsd:string” minOccurs=”0” maxOccurs=”unbounded” />

</xsd:schema>

表示为元素user的类型为string，出现的次数最少为0（也就是可选），最多不限制。

3、引用元素和替代

语法如下：

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

<xsd:element name=”user” type=”xsd:string” />

<xsd:element name=”name”>

<xsd:complexType>

<xsd:sequence>

<xsd:element ref=”user” />

</xsd:sequence>

</xsd:complexType>

</xsd:element>

</xsd:schema>

引用是利用element标记符的ref属性实现的。主要适用于避免在文档中多次定义同一个元素，应当将经常使用的元素定义为根元素的子元素，以便在文档的任何地方引用它。

在这里还可以为某个定义的元素起一个别名，方法如下：

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

<xsd:element name=”yonghu” type=”xsd:string” substitutionGroup=”user” />

<xsd:element name=”user” type=”xsd:string” />

<xsd:element name=”name”>

<xsd:complexType>

<xsd:sequence>

<xsd:element ref=”user” />

</xsd:sequence>

</xsd:complexType>

</xsd:element>

</xsd:schema>

以上文档对应的有效XML文档如下：

<?xml version=”1.0”?>

<name>

<user>string</user>

</name>

或者：

<?xml version=”1.0”?>

<name>

<yonghu>string</yonghu>

</name>

主要是利用element标识符中的属性substitutionGroup实现的。

4、设置默认值和固定值

语法如下：

<xsd:element name=”city” type=”xsd:string” default=”xian” />

<xsd:element name=”country” type=”xsd:string” fixed=”china” />

通过default属性的设置，可以在XML文档中没有对city元素定义时赋予默认值。而使用fixed属性，可以给元素country设定一个固定的值china，并且不允许改变！

5、利用组合器控制结构

sequence组合器，定义了一列元素必须按照模式中指定的顺序显示（如果是可选的，也可以不显示）。语法如下：

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

<xsd:element name=”name”>

<xsd:complexType>

<xsd:sequence>

<xsd:element name=”first” type=”xsd:string” />

<xsd:element name=”middle” type=”xsd:string” />

<xsd:element name=”last” type=”xsd:string” />

</xsd:sequence>

</xsd:complexType>

</xsd:element>

</xsd:schema>

all组合器，允许所定义的元素可以按照任意顺序显示，all元素的子元素在默认情况下是必须的，而且每次最多显示一次。语法如下：

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

<xsd:element name=”name”>

<xsd:complexType>

<xsd:all minOccurs=”0”>

<xsd:element name=”first” type=”xsd:string” />

<xsd:element name=”middle” type=”xsd:string” />

<xsd:element name=”last” type=”xsd:string” />

</xsd:all>

</xsd:complexType>

</xsd:element>

</xsd:schema>

choice组合器，允许指定多组声明中的一个，用于互斥情况。语法如下：

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

<xsd:element name=”name”>

<xsd:complexType>

<xsd:choice>

<xsd:element name=”first” type=”xsd:string” />

<xsd:element name=”middle” type=”xsd:string” />

<xsd:element name=”last” type=”xsd:string” />

</xsd:choice>

</xsd:complexType>

</xsd:element>

</xsd:schema>

二、定义属性

在XML Schema文档中可以按照定义元素的方法定义属性，但受限制的程度较高。它们只能是简单类型，只能包含文本，且没有子属性。可以应用在attribute元素定义中的属性如下：

default 初始默认值

fixed 不能修改和覆盖的属性固定值

name 属性的名称

ref 对前一个属性定义的引用

type 该属性的XSD类型或者简单类型

use 如何使用属性

form 确定attributeFormDefault的本地值

id 模式文档中属性唯一的ID

Default、fixed、name、ref和type属性与在element标记中定义的对应属性相同，但type只能是简单类型。Use属性的值可以是：optional（属性不是必须的，此为默认属性）、prohibited或者required（属性是强制的）。

1、创建属性

语法如下：

<xsd:attribute name=”age” type=”xsd:integer” />

该语句定义了一个名为age的属性，它的值必须是一个整数。把它添加到模式中时，它必须时schema元素、complexType元素或者attributeGroup元素的子元素。

例子：

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

<xsd:element name=”name”>

<xsd:complexType>

<xsd:sequence>

<xsd:element name=”first” type=”xsd:string” />

</xsd:sequence>

<xsd:attribute name=”age” type=”xsd:integer” use=”optional” />

</xsd:complexType>

</xsd:element>

</xsd:schema>

以上文档对应有效的XML文档如下：

<?xml version=”1.0”?>

<first>string</first>

</name>

如上所示，要把属性附加在元素上，属性应该在complexType定义中的组合器之后定义或引用。

三、XML Schema数据类型
XML Schema提供了一组丰富的内置数据类型，用于定义元素中允许的类型。下面将介绍一些完全符合C#标准的通用类型。

1、基本数据类型
基本数据类型是在XML Schema中使用的每种数据类型的最基本构成块。可以根据这些类型构造自定义的类型。这些类型包括：

boolean 可以是1（true）或者0（false）。

dateTime 表示时间的部分可选，格式：CCYY-MM-DDThh:mm:ss

例如：2005-3-18T14:48:12

decimal 表示任意精度的十进制数字。

string 字符数据。

int 表示从-2,147,483,648到2,147,483,648之间一个整数。

nonNegativeInteger 表示大于或者等于0的一个整数。

nonPositiveInteger 表示小于或者等于0的一个整数。

short 表示从-32768到32767之间的一个整数。

例如：

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

<xsd:element name=”ContactDetails”>

<xsd:complexType>

<xsd:sequence>

<xsd:element ref=”name” />

<xsd:element name=”rate” type=”xsd:decimal” />

</xsd:sequence>

<xsd:attribute name=”lastUpdated” type=”xsd:dateTime” />

</xsd:complexType>

</xsd:element>
<xsd:element name=”name”>

<xsd:complexType>

<xsd:sequence>

<xsd:element name=”first” type=”xsd:string” />

<xsd:element name=”middle” type=”xsd:string” />

<xsd:element name=”last” type=”xsd:string” />

</xsd:sequence>

<xsd:attribute name=”local” type=”xsd:boolean” />

</xsd:complexType>

</xsd:element>

</xsd:schema>

以上文档对应有效的XML文档如下：

<?xml version=”1.0”?>

<first>santld</first>

</name>

</ContactDetails>
2、简单类型

虽然从内置数据类型中得到了许多的功能，但是在许多情况下，只有数据类型来限制数据的值是远远不够的。这里在学习简单类型之前，先看看关于约束。

约束方面

enumeration 用空格分开的一组指定的数值。它把数据类型约束为指定的值。

fractionDigit 指定小数点后的最大位数。

length 长度单位。

minExclusive 下限值，所有的值都必须大于该值。

maxExclusive 上限值，所有的值都应该小于该值。

minLength 长度单位的最小个数。

maxLength 长度单位的最大数。

minInclusive 最小值，所有的值都应该大于或者等于该值。

maxInclusive 最大值，所有的值都应该小于或者等于该值。

pattern 数据类型的值必须匹配的指定模式，pattern值必须是一个正则表达式。

totalDigits 指定小数最大位数的值。

whiteSpace 其值为：preserve（值中的空格不能改变），replace（所有的制表

符、换行符和回车符都用空格代替），collapse（执行replace，删

除相邻的、结尾处和开头处的空格）。
要应用上述的约束，就要利用元素restriction。这个元素中有2个属性：id属性是模式文档中restriction元素的唯一标识符，base属性设置为一个内置的XSD数据类型或者现有的简单类型定义，他是一种被限制的类型。

例如：

<xsd:restriction base=”xsd:string”>

<xsd:minLength value=”4” />

<xsd:maxLength value=”10” />

</xsd:restriction>

如上，将字符串最小长度限定为4个字符，将最大长度限定为10个字符。

<xsd:restriction base=”xsd:int”>

<xsd:minInclusive value=”1” />

<xsd:maxInclusive value=”100” />

</xsd:restriction>

如上，将一个整数的取值范围设置为1到100之间。

<xsd:restriction base=”xsd:string”>

<xsd:enumeration value=”FistValue” />

<xsd:enumeration value=”SecondValue” />

<xsd:enumeration value=”ThirdValue” />

</xsd:restriction>
如上，字符串只能为枚举出的三种值。

简单类型
简单类型是对一个节点的可能值进一步限制的自定义数据类型。创建简单类型需要利用simpleType元素，其定义如下：
<simpleType id=”ID” name=”NCName” final=”(#all|(list|union|restriction))” />

id属性应唯一的标明文档内的simpleType元素，name不能使用冒号字符。simpleType不能包含元素，也不能有属性，根据在simpleType中定义的规则，它基本上是一个值，或者是一个值的集合。

例如：

<xsd:simpleType name=”personsName”>

<xsd:restriction base=”xsd:string”>

<xsd:minLength value=”4” />

<xsd:maxLength value=”8” />

</xsd:restriction>

</xsd:simpleType>

<xsd:element name=”first” type=”personsName” />

以上文档对应有效的XML文档如下：

<first>Santld</first>

以下就是无效的XML文档：

<first>SS</first> 或者 <first>Santld wang</first>

再举个例子：

<xsd:simpleType name=”personsTitle”>

<xsd:restriction base=”xsd:string”>

<xsd:enumeration value=”Mr.” />

<xsd:enumeration value=”Mrs.” />

<xsd:enumeration value=”Miss.” />

</xsd:restriction>

</xsd:simpleType>

<xsd:element name=”title” type=”personsTitle” />

上面定义的类型personsTitle是一个字符串类型，但它的值只能是Mr.、Mrs.或者Miss.其中的一个。

复杂类型

复杂类型的定义必须使用complexType元素，在这里可以包含属性和元素。在复杂类型的使用中，主要是complexType和simpleType配合使用。格式如下：

<xsd:complexType name=”name” />

例如：

<xsd:element name="name" type="FullName" />

<xsd:complexType name="FullName">
<xsd:sequence>

<xsd:element name="first" type="PersonsFirstname" minOccurs="0" maxOccurs="1"

default="John" />

<xsd:element name="middle" type="xsd:string" minOccurs="0"

maxOccurs="unbounded" nillable="true" />

<xsd:element name="last" type="xsd:string" minOccurs="1" maxOccurs="1"

default="Doe" />

</xsd:sequence>

<xsd:attribute name="title" type="PersonsTitle" default="Mr." />

</xsd:complexType>

<xsd:simpleType name="PersonsFirstname">

<xsd:restriction base="xsd:string">

<xsd:minLength value="4" />

<xsd:maxLength value="10" />

</xsd:restriction>

</xsd:simpleType>

<xsd:simpleType name="PersonsTitle">

<xsd:restriction base="xsd:string">

<xsd:enumeration value="Mr." />

<xsd:enumeration value="Mrs." />

<xsd:enumeration value="Miss." />

</xsd:restriction>

</xsd:simpleType>

如上就实现了一个复杂类型，该例子实现了一个复杂类型FullName，其中包含了两个简单类型PersonsFirstname和PersonsTitle。

分组和属性

在为定义XML文档而创建的一些更为复杂的定义中，会有一些元素集、属性集的组合，这是我们就使用了分组的概念。分组定义中使用的是group元素。

例如：

<xsd:group name=”CityChoice”>

<xsd:choice>

<xsd:element name=” Beijing ” type=”xsd:string” />

<xsd:element name=” Shanghai ” type=”xsd:string” />

<xsd:element name=”Xian” type=”xsd:string” />

</xsd:choice>

</xsd:group>

<xsd:element name=”City”>

<xsd”group ref=”CityChoice” minOccurs=”1” maxOccurs=”1” />

</xsd:element>

对属性的分组，应该使用attributeGroup元素，例如：

<xsd:attributeGroup name=”contactAttribs”>

<xsd:attribute name=”city” type=”xsd:string” />

<xsd:attribute name=”country” type=”xsd:string” />

<xsd:attribute name=”age” type=”xsd:string” />

</xsd:attributeGroup>

<xsd:element name=”contact”>

<xsd:complexType>

<xsd:attributeGroup ref=”contactAttribs” />

</xsd:complexType>

</xsd:element>

以上文档对应有效的XML文档如下：

内容模型

内容模型可以对在XML文档内使用的元素、属性和类型进行限制，确定用户可以在XML实例的哪些等级添加自己的元素和属性。

any

当在XML中声明元素时any是默认的内容模型，该模型可以包含文本、元素和空格。如果允许添加元素的内容，且无需屋里修改模式文件，就可以使用该模型。

例如：

<xsd:xchema xmlns:xsd=”http://www.w3.org/2001/XMLSchema”>

<xsd:element name=”name”>

<xsd:complexType>

<xsd:sequence>

<xsd:element name=”first” type=”xsd:string” />

<xsd:element name=”middle” type=”OtherNames” />

<xsd:element name=”last” type=”xsd:string” />

</xsd:sequence>

</xsd:complexType>

</xsd:element>

<xsd:complexType name=”OtherNames”>

<xsd:sequence>

<xsd:any namespace=”##any” processContents=”lax” minOccurs=”0”

maxOccurs=”unbounded” />

</xsd:sequence>

</xsd:complexType>

</xsd:schema>

例子中的xsd:any元素说明该类型允许添加内容。namespace属性允许的值为：

##any（元素可以来自任何命名空间）

##other（元素可以来自除了该元素的父元素所在的目标命名空间之外的命名空间）

##local（元素不受命名空间的限制）

##targetNamespace（元素来自父元素的目标命名空间）

processContents属性说明对这里所创建的元素进行验证时所执行的操作，取值有如下3种：

strict（标明XML处理器必须获得和那些命名空间相关联的模式，并验证元素和属性）

lax（与strict相似，只是如果处理器找不到模式文档，也不会出现错误）

skip（不利用模式文档验证XML文档）

上述模式的一个有效实例如下：

<?xml version=”1.0”?>

<name>

<first>santld</first>

</middle>

</name>

empty

empty元素禁止把文本或者元素作为一个声明为空的元素的子元素，如果要保证该元素不包括子元素、文本甚至空格，就可以使用它。在XSD中时利用xsd:anyType类型来限定它的，这样就意味元素只能包含属性，例如：
<xsd:schema xmlns:xsd=”http://www.w3.org/2001/XMLSchema”>

<xsd:element name=”contact”>

<xsd:complexType>

<xsd:complexContent>

<xsd:restriction base=”xsd:anyType”>

<xsd:attribute name=”age” type=”xsd:integer” />

</xsd:restriction>

</xsd:complexContent>

</xsd:complexType>

</xsd:element>

</xsd:schema>

以上就是一个复杂类型，只允许有一个age属性。在例子里complexContent元素可以表示complexType的内容要进行扩充或者限制，在这里，我们对其内容进行限制，因此使用了restriction元素，如果扩成则使用exension元素。

element（前边已经了解过了）

mixed

最后一个内容模型就是mixed，它包含文本、内容和属性。在complexType元素上把mixed属性的值设为true，就一个声明一个mixed内容模型了。例如：

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

<xsd:element name=”contact”>

<xsd:complexType mixed=”true”>

<xsd:sequence>

<xsd:element name=”first” type=”xsd:string” />

</xsd:sequence>

<xsd:complexType>

</xsd:element>

</xsd:schema>

上述模式的一个有效实例如下：

<?xml version=”1.0”?>

<contact>My first name is<first>Santld</first>.</contact>

在例子中contact元素就包含了文本和元素first。

posted @ 2025-02-05 15:12 CharyGao 阅读(501) 评论(0) 收藏举报

刷新页面返回顶部

硅基文明

代码改变不了世界，但是改变世界需要代码。

XML架构工具之Schema

前言

1.XML Schema是什么？

2.作用是什么？

3.有哪些功能？

4.怎么使用？

4.1.XSD文档组成

4.2.XSD文档的引用

5.编写XSD文档

5.1.架构

5.2.xsd 主体的组成

5.2.1.xsd的数据类型

5.2.1.1.数值类型

5.2.1.2.字符串

5.2.1.2.日期数据类型

5.2.1.4.其它数据类型

5.2.2.简易元素定义

5.2.2.1格式如下：

5.2.2.2.简易元素的默认或固定值

5.2.3.属性定义

5.2.4.元素的限定

5.2.4.1.格式：

5.2.4.2.对值范围限定

5.2.4.3.枚举限制

5.2.4.4.正则匹配

5.2.4.5 长度限制

5.2.4.5. 其它限定元素

5.2.5.复合元素

5.2.5.1.格式

5.2.5.2.复合空元素定义

5.2.5.2.仅含元素

5.2.5.3.含文本和属性

5.2.5.4.包含属性和子元素

5.2.5.5.混合元素

5.2.6.指示器

5.2.6.1.指示器分类

5.2.6.2.Order指示器的使用

5.2.6.3.Occurrence次数指示器

5.2.6.4.group 分组器

5.3.进阶知识

5.3.1.自定义类型

5.3.1.元素继承和拓展

5.3.2.<any> 元素

5.3.3.<anyAttribute>元素

5.3.4.元素的引用

5.3.6.元素替换

5.3.7.注释元素

总结

5.2.2.2.`简易元素的默认或固定值`