XML从入门到深入（超详细）

亦凉 2024-03-27 18:56 14阅读 0赞

### **一：什么是XML** ###

> 　　XML (eXtensible Markup Language)指可扩展标记语言，标准通用标记语言的子集，简称XML。是一种用于标记电子文件使其具有结构性的标记语言。
> 
> 　　XML可以标记数据、定义数据类型，可以允许用户对自己标记语言进行自定义，是对人和机器都比较友好的数据承载方式；XML其前身是SGML（标准通用标记语言）。

传统的系统已经远远不足以来表达复杂的信息，简单的语言根本无法表达出一些细微的差别，需要更完整的语言来表达网络世界里日益丰富复杂的信息内涵

XML - 可扩展标记语言便由此诞生，它不像HTML追求美观的效果，而不重视实际交流应用现象，所以**XML语言的出现核心是用来展示及数据的交互**，它的出现把网络表达的语言集合推进了一大步，XML传递信息，**具有跨平台的特性（如：WebService）**它作为数据交互和网络计算基础，尤其是在电子商务应用上的出色表现，现在已经没人怀疑它给信息社会带来的革命性影响（随着2021的到来JSON也是一个不错的选择）

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <Students>
        <Student>
            <name>蚂蚁小哥</name>
            <address>安徽六安</address>
        </Student>
        <Student>
            <name>欧阳康康</name>
            <address>安徽六安</address>
        </Student>
    </Students>

#### 1：编写XML注意事项 ####

①：XML 中的每个元素都是成对出现的，有开始和结束，自闭和标签除外，但是都得有 '/'结束标志
        如：<student>xxxxx</student>    自闭和：<student name='xxx' />
    ②：每个XML文档都有且只有一个根元素（Root Element）
    ③：XML标签对大小写敏感
    ④：XML必须正确嵌套
    ⑤：同级标签以所缩进对齐
    ⑥：元素名称可以包含字母，数字，但不能以数字开头
    ⑦：元素名称中不能含有空格 或者 ' : '号
    ⑧：如出现特殊字符需要转义 如：<,>,",',&....

#### 2：使用XML的优缺点 ####

优点：
    ①：XML是使用信息自描述的新语言（没有约束的情况下）
    ②：信息共享（自定义数据格式，而且很容易使用工具读写）
    ③：数据传递（支持各种通道传递数据，如WebService就使用XML传输数据）
    ④：数据重用、分离数据和显示、文档包含语义、方便阅读有面向对象的树形结构
    
    缺点：
    ①：数据量大是传输效果不好，因为XML定义了和数据无关的标签

#### 3：XML基本语法 ####

第一行必须是XML的声明<?xml  ?> 
        version：xml的版本，必须设定，当前只有'1.0'版本
        encoding：当前xml里面的数据格式，默认UTF-8
        standalone：标记是否是一个独立的xml，默认yes
            如果设置 no 表示这个XML不是独立的而是依赖于外部的DTD约束文件（后面说）
    
    <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <Students>
        <Student>
            <name>蚂蚁小哥</name>
            <address>安徽六安</address>
        </Student>
    </Students>

![38c781c594d5475c89cf70125a973974.png][]

### **二：XML专用标记** ###

XML其实是有专用的标记，也可以理解是XML的基本语法，但是这些语法你在看HTML语法时也看到过，因它们都属于一个大家族，只是应用的方向不一样而导致的差异有部分不一样

#### 1：XML注释 ####

**语法：**

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <School>
        
        <Student id="st01" name="张三" age="23"/>
    </School>①：注释里的内容不要出现 --②：不要把注释写在元素中间 如<Student  ></Student> ③：注释不可嵌套

#### 2：XML处理PI指令 ####

其实XML里的PI指令大家可以理解为XML设置样式的，但是考虑到XML是用于存储数据的载体，所以这个指令用的也不多

**语法：<?目标 指令?>**

如引入CSS样式：<?xml-stylesheet type='css类型' href='引入css样式地址'>

CSS类型可以设置 type='text/css' type='text/xsl'

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    
    <?xml-stylesheet type='text/css' href='./style.css' ?>
    <School>
        
        <Student>
            <name>蚂蚁小哥</name>
        </Student>
    </School>
    
    
    name {
        font: normal 500 22px "微软雅黑";
        color:#f69;
    }

#### 3：XML之CDATA节 ####

用于把整段文本解析为纯字符串数据而不是标记的情况，其实包含在CDATA节中的特殊字符<、>、&都会当作字符展示

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <School>
        
        <Student>
            
            <name><![CDATA[我是一个"文本":想不到把]]></name>
        </Student>
    </School>

那么问题来的，如果我不使用CDATA节包裹的话在文本区域输入<，>等就会和关键字符冲突，我们需要使用转义

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <School>
        
        <Student>
            
            
            <name>蚂蚁小<>哥</name>
        </Student>
    </School>
    
    
    
    XML中转义字符的使用

### **三：核心DTD语法约束** ###

#### 1：什么是DTD，为什么使用DTD ####

DTD是文档类型定义（Document Type Definiyion），它是用来描述XML文档结构，一个DTD文档会包含如下内容：

元素（ELEMENT）:的定义规则，描述元素之间的关系规则
    属性（ATTLIST）：的定义规则，可以定义具体的标签内部属性
    
    为什么使用DTD:
        ①：DTD文档与XML文档实例关系如类与对象关系
        ②：有了DTD，每个XML文件可以携带一个自身格式描述
        ③：有了DTD，不同组织的人可以使用一个通用DTD来交换数据
        ④：应用程序可以使用一个标准的DTD校验从外部世界接受来的XML是否是一个有效标准XML
        ⑤：可以使用DTD校验自己的XML数据

#### 2：DTD定义文档规则（DOCTYPE） ####

DTD文档的声明及引用有三种：
        内部DTD文档：
            <!DOCTYPE  根元素[定义元素属性等等内容]>
        外部DTD文档：
            <!DOCTYPE 根元素  SYSTEM 'DTD文件路径'>
        内外部DTD文档结合：
            <!DOCTYPE 根元素  SYSTEM 'DTD文件路径'[定义元素属性等等内容]>

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    
    <!DOCTYPE Student[
            <!ELEMENT Student (name)>
            <!ELEMENT name (#PCDATA)>
            ]>
    <Student>
        <name>蚂蚁小哥</name>
    </Student>
    
    内部定义DTD文档

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE Student SYSTEM './st.dtd'>
    <Student>
        <name>蚂蚁小哥</name>
    </Student>
    
    
    <!DOCTYPE Student[
            <!ELEMENT Student (name)>
            <!ELEMENT name (#PCDATA)>
            ]>
    
    外部定义DTD文档

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE Student SYSTEM './st.dtd'[
            <!ELEMENT Student (name,age,sex)>
            <!ELEMENT sex (#PCDATA)>
            ]>
    <Student>
        <name>蚂蚁小哥</name>
        <age>23</age>
        <sex>男</sex>
    </Student>
    
    
    <?xml version="1.0" encoding="UTF-8" ?>
    
    <!ELEMENT name (#PCDATA)>
    <!ELEMENT age (#PCDATA)>
    
    内外部定义DTD文档

#### 3：DTD元素的定义（ELEMENT） ####

语法：<!ELEMENT 元素名称(NAME)  元素类型(COUTENT)>
        注：ELEMENT关键字
    元素名称：就是自定义的子标签名称
    元素类型：
        EMPTY：该元素不能包含子元素和文本，但是可以有属性，这类元素称为自闭和标签
        ANY：该元素可以包含任意在DTD中定义的元素内容
        #PCDATA：可以包含任何字符数据，设置这个就不能包含子元素了，一般设置具体value
        混合元素类型：只包含子元素，并且这些子元素没有文本
        混合类型：包含子元素和文本数据混合体

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE Student[
            <!ELEMENT Student EMPTY>
            ]>
    
    <Student/>
    
    
    <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE School[
            <!ELEMENT School (student,teacher)>
            <!ELEMENT student (#PCDATA)>
            <!ELEMENT teacher (#PCDATA)>
            ]>
    <School>
        <student>我是学生</student>
        <teacher>我是老师</teacher>
    </School>
    
    
    <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE School[
            <!ELEMENT School (student)>
            <!ELEMENT student ANY>
            <!ELEMENT name (#PCDATA)>
            <!ELEMENT address (#PCDATA)>
            ]>
    <School>
        <student>
            <name>蚂蚁小哥</name>
            <address>安徽六安</address>
        </student>
    </School>
    
    
    <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE School[
            <!ELEMENT School (student*,teacher?)>
            <!ELEMENT student (#PCDATA)>
            <!ELEMENT teacher (#PCDATA)>
            ]>
    <School>
        <student>我是学生A</student>
        <student>我是学生B</student>
    </School>
    
    DTD元素定义具体代码

通配符：
        ()      用来元素分组如：(a|b|c),(d,e),f         分三组
        |       在列表中选一个如(a|b)只能选一个          表示a|b必须出现并二选一
        +       该对象至少出现一次或多次如(a+)           该元素可以出现多次
        *       该对象允许出现0次到多次如(a*)            该元素可以不出现或出现多次
        ?       表示可出现一次或者不出现(a?)             a可以出现，或者不出现
        ,       常用按照顺序出现(a,b,c)                 表示依次a,b,c

#### 4：DTD属性的定义（ATTLIST） ####

语法：<!ATTLIST 元素名称 属性名称 类型 属性特点>
    元素名称：我们自定义的元素名称
    属性类型：我们为元素上添加自定义属性
    类型：
        CDATA：
            任意字符（理解为任意字符的字符串）
        ID：
            以字母开头唯一值字符串，
        IDREF/IDREFS：
            可以指向文档中其它地方声明的ID类型值（设置此值是可以在文档上存在的）
            使用IDREFS时可以使用空格隔开
        NMTOKEN/NMTOKENS：
            NMTOKEN是CDATA的一个子集，设置该属性时只能写英文字母、数字、句号、破折号
            下划线、冒号，但是属性值里面不能有空格      NMTOKENS：它是复数，如果设置多个值由空格隔开   Enumerated:     事先定义好一些值，属性的值必须在所列出的值范围内
    属性特点：
        #REQUIRED
            表示必须设置此属性
        #IMPLIED
            表示此属性可写可不写
        #FIXED value
            表示元素实例中该属性的值必须是指定的固定值
        #Default value
            为属性提供一个默认值

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE School[
            <!ELEMENT School (student*)>
            <!ELEMENT student EMPTY>
            
            <!ATTLIST student id ID #REQUIRED>
            
            <!ATTLIST student name CDATA #REQUIRED >
            
            <!ATTLIST student address NMTOKENS #IMPLIED>
            
            <!ATTLIST student srcID IDREFS #IMPLIED>
            ]>
    <School>
        <student id="st001" name="蚂蚁小哥"/>
        <student id="st002" name="欧阳;*)*^%$:小小" address="安徽_六安 安徽_合肥"/>
        <student id="st003" name="许龄月" srcID="st001 st002"/>
    </School>
    
    
    <?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE School[
            <!ELEMENT School (student*)>
            <!ELEMENT student EMPTY>
            
            
            <!ATTLIST student
                    id ID #REQUIRED
                    name CDATA #FIXED '我们名字都一样'
                    address CDATA '默认都是安徽'
                    sex (男|女) #REQUIRED
                    >
            ]>
    <School>
        <student id="st001" sex="男" name="我们名字都一样"/>
        <student id="st002" sex="女"/>
        <student id="st003" sex="男" name="我们名字都一样"/>
    </School>
    
    DTD的属性定义具体代码

#### 5：DTD实体定义（ENTITY） ####

实体分类：
        普通内部实体，普通外部实体，内部参数实体，外部参数实体
    
    语法：
        普通内部实体定义：<!ENTITY 实体名 "实体值">
        普通外部实体引入：<!ENTITY 实体名 SYSTEM "URI/URL">
        内部参数实体定义：<!ENTITY % 实体名 "实体值">
        外部参数实体引入：<!ENTITY % 实体名 SYSTEM "URI/URL">
    
    示例定义：
        <!ENTITY name "蚂蚁小哥">
        <!ENTITY address "安徽六安">
    示例XML里使用：
        <name>&name;</name>
    
    使用范围：定义实体分为内部实体（定义在当前xml文件）和外部实体（定义在外部dtd文件里）

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <!DOCTYPE Student[
            <!ELEMENT Student (name,address)>
            <!ELEMENT name (#PCDATA)>
            <!ELEMENT address (#PCDATA)>
    
            <!ENTITY name "蚂蚁小哥">
            <!ENTITY address "安徽六安">
            ]>
    <Student>
        <name>&name;</name>
        <address>&address;</address>
    </Student>
    
    DTD实体定义代码

#### 6：使用命名空间（Namespace） ####

避免元素名冲突，使用URL作为XML的Namespaces（这样也有约束和提示好处）

语法：**xmlns:\[prefix\]="URL"**  元素和属性都可以应用命名空间

XML的元素名是不固定的，当两个不同类型的文档使用同样的名称描述两个不同类型的元素的时候就会出现命名冲突

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <h:table xmlns:h="http://www.w3.org/1999/xhtml">
        <h:tr>
            <h:td>名称A</h:td>
            <h:td>名称B</h:td>
        </h:tr>
    </h:table>

### **四：核心Schema语法约束** ###

#### 1：什么是XML Schema ####

XML Schema描述了XML文档的结构。可以用一个指定的XML Schema来验证某个XML文档，以检查该XML文档是否符合其要求。XML Schema file的后缀名是“.XSD”；其核心和DTD一样，XML Schema本身的底层约束就是用DTD写的

DTD的局限性：
        ①：DTD不遵循XML的语法（编写DTD用的一种语法，编写XML还是用一种语法，对比不清晰）
        ②：DTD数据类型有限（元素里面定义类型就#PCDATA）
        ③：DTD不可扩展
        ④：DTD不支持命名空间（命名冲突）
    Schema的新特性：
        ①：Schema基于XML语法
        ②：Schema可以用能处理XML文档的工具处理，如Altova工具
        ③：Schema大大扩充了数据类型，可以自定义数据类型
        ④：Schema支持元素的继承-Object-Oriented
        ⑤：Schema支持属性组

**　　总结：XML Schema其作用和DTD一样，都是验证我们编写的XML文档是否具有有效性，只不过它提供了比DTD更强大的功能和更细粒度的数据类型，另外还可以在Schema中自定义数据类型，此外我们要注意Schema也是一个XML文件，而不是DTD，但是Schema自身约束由DTD约束**

#### 2：基本使用 ####

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
        
        <xs:element name="student" type="xs:string"/>
    </xs:schema>
    
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="myschema.xml">
       我是学生
    </student>
    
    xmlns:xs="http://www.w3.org/2001/XMLSchema"：用于构造约束schema元素和类型该怎么写
    xsi:noNamespaceSchemaLocation="myschema.xml"：用来告知当前的schema来自哪个文件
    xs:是我们加入的命名空间前缀，如果不加，后面使用都不用xs:xxx来编写，xs是自定义名字
    
    学习Schema的基本路线
        schema
        element
        attribute
        group
        attributeGroup
        simpleType
        simpleContent
        complexType
    补充：
        choice
        list
        union
        unique
        sequence
        restrction

#### 3：Schema元素**（重要！！）** ####

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
                   targetNamespace="http://www.6666.com/schoolSchemal">
        </xs:schema>
    定义约束：
        ①：所有的标签和属性都是由schema文件来约束定义
        ②：所有的schema文件都需要有个命名空间（id）,具体名称为namespace
        ③：namespace的值由targetNamespace指定，它就是一个url（正常都是不存在此链接的，只是个类似id标识）
        ④：引入官方Schema约束需要用到xmlns属性 如 xmlns="xxxxx"
            我们可以为每个xmlns加上前缀，这样我们每次使用加上前缀标识 如 xmlns:xs='xxxxx'
    
    
        <School xmlns="http://www.6666.com/schoolSchemal"
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:schemalLocation="http://www.6666.com/schoolSchemal myschema.xsd">
        </School>
    使用约束：
        ①：引入我们定义约束的xsd文件，如在上个文件上定义的targetNamespace唯一标识
        ②：如果这个targetNamespace不是一个有效的约束地址我们就需要设置schemalLocation属性
        ③：schemalLocation的定义是由W3C官方指定的，所以我们先要引入官方Schemal约束
        ④：然后通过引入的约束起个前缀，通过前缀调用，因为2个约束不起前缀会冲突
        ⑤：schemalLocation设置需要使用命名空间（我们设置的namespace）加上文件的具体约束文件路径
    
    属性：
        xmlns：
            引用w3c官方的schema的约束，这里定义了各式各样的schema元素标签
        targetNamespace：
            定义当前编写的约束文件的互联网访问地址，如果地址不存在那也没事，只是一个标识
        schemalLocation：
            具体的约束文件路径，如果命名空间约束链接不存在，那么在命名空间链接后面加上本地约束路径
    
    
    补充：如果就是要导入一个本地的自定义schema约束不要命名空间的话 
    属性：noNamespaceSchemaLocation 不使用命名空间，选用本地约束文件
        <?xml version="1.0" encoding="UTF-8" ?>
        <School xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:noNamespaceSchemaLocation="myschema.xml">
        </School>

#### 4：element标签元素 ####

**　　**它的主要作用就是用来声明一个元素的，就像DTD语法中的 **<!ELEMENT xxx (\#PCDATA)>**

**语法：<xs:element name="元素名称" type="元素类型">**

element常用属性：
        name：自己设置元素时必须指定元素名称，如果是ref引用则不需要
        type：设置元素类型，可以为普通类型、简单类型、复杂类型
        ref：引用外部定义好的element元素并通过name来引用
        minOccurs：设置该元素最少出现几次
        maxOccurs：设置unbounded则不限次数，还有就是自定义出现次数
        substiutionGroup：设置当前元素替代哪个其它元素，前提自己不能设置类型，引用别人类型
        fixed：设置具体固定值不可改变，必须使用此值
        default：默认值

补充type基本类型：
        duration：表示持续时间                  string：字符串
        dateTime：代表特定时间                  boolean：真假值
        time：代表特定时间，但是是每天重复的       decimal：代表特定精度数字
        haxBinary：代表16进制数                 float：单精度32位浮点数
        anyURI：代表一个URI，用来指定文件定位     double：双精度64位浮点数
        NOTATION：设置该属性时只能写英文字母、数字、句号、破折号、下划线、冒号，但是属性值里面不能有空格

########本案例使用element的name、type、ref、minOccurs、maxOccurs
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
        
        <xs:element name="name" type="xs:string"/>
    
        
        <xs:simpleType name="likes">
            <xs:restriction base="xs:string">
                <xs:enumeration value="爬山"/>
                <xs:enumeration value="骑行"/>
                <xs:enumeration value="打球"/>
                <xs:enumeration value="跑步"/>
            </xs:restriction>
        </xs:simpleType>
    
        
        <xs:complexType name="student">
            <xs:sequence>
                
                <xs:element ref="name"/>
                
                <xs:element name="likes" type="likes"/>
                
                <xs:element name="girlfriend" type="xs:string" minOccurs="1" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:complexType>
        
        <xs:element name="student" type="student"/>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="myschema.xml">
        <name>张三</name>
        <likes>爬山</likes>
        <girlfriend>许龄月</girlfriend>
        <girlfriend>杨幂</girlfriend>
    </student>
    
    
    ########本案例使用element的substitutionGroup、fixed、default
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
        
        
        <xs:element name="name" type="xs:string"/>
        <xs:element name="sname" substitutionGroup="name"/>
        
        <xs:element name="address" type="xs:string" fixed="安徽六安"/>
        
        
        <xs:element name="student">
            <xs:complexType>
                <xs:sequence>
                    <xs:element ref="name"/>
                    <xs:element ref="address"/>
                    
                    <xs:element name="school" default="安徽大学" maxOccurs="unbounded" minOccurs="0"/>
                </xs:sequence>
            </xs:complexType>
        </xs:element>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="myschema.xml">
        <sname>张三</sname>
        <address>安徽六安</address>
    </student>
    
    element元素使用的基本示例

#### 5：group组元素 ####

group作用就是把声明好的元素组合到一起，以便能够被放到一起，比如现在有student和teacher两个根元素，里面还要特有的子元素，我可以把这2组元素分组，直接引用

语法：
        定义：<xs:group name='组名称'>属于当前组的元素</xs:group>
        使用：<xs:group ref='引用的组名称'/>
    
    属性：
        name：定义group组的名称
        ref：引用指定的group

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    
        
        <xs:group name="base">
            
            <xs:sequence>
                
                <xs:element name="name" type="xs:string"/>
                
                <xs:element name="age">
                    <xs:simpleType>
                        <xs:restriction base="xs:integer">
                            <xs:minExclusive value="0"/>
                            <xs:maxExclusive value="100"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                
                <xs:element name="sex">
                    <xs:simpleType>
                        <xs:restriction base="xs:string">
                            <xs:enumeration value="男"/>
                            <xs:enumeration value="女"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
            </xs:sequence>
        </xs:group>
    
        
        <xs:group name="student">
            <xs:sequence>
                
                <xs:group ref="base"/>
                
                <xs:element name="grades" type="xs:float"/>
            </xs:sequence>
        </xs:group>
        
        <xs:group name="teacher">
            <xs:sequence>
                <xs:group ref="base"/>
                
                <xs:element name="salary" type="xs:double"/>
            </xs:sequence>
        </xs:group>
    
        <xs:element name="School">
            <xs:complexType>
                <xs:sequence>
                    
                    <xs:element name="student">
                        <xs:complexType>
                            <xs:sequence>
                                <xs:group ref="student"/>
                            </xs:sequence>
                        </xs:complexType>
                    </xs:element>
                    
                    <xs:element name="teacher">
                        <xs:complexType>
                            <xs:sequence>
                                <xs:group ref="teacher"/>
                            </xs:sequence>
                        </xs:complexType>
                    </xs:element>
                </xs:sequence>
            </xs:complexType>
        </xs:element>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <School xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="myschema.xml">
        <student>
            <name>王晓伟</name>
            <age>23</age>
            <sex>男</sex>
            <grades>66.9</grades>
        </student>
        <teacher>
            <name>张老师</name>
            <age>33</age>
            <sex>男</sex>
            <salary>6500.0</salary>
        </teacher>
    </School>
    
    group组元素使用示例

#### 6：attribute属性元素 ####

有些情况下我们并不想在元素上创建子元素，这时候我们把要存放的值当属性存放在属性里也是可以的

语法：
        定义：<xs:attribute  name='属性名称' type='属性类型'/>
        使用：<xs:attribute ref='引用的属性名称' use='属性模式'>
    常用属性：
        name：定义属性名称
        type：定义属性的类型
        ref：引用定义好的属性
        use：设置属性模式
            required：此属性必须出现
            optional：此属性可出现可不出现
            prohibited：此属性不可出现（自己定义的却不可以使用）

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
        
        <xs:attribute name="age" type="xs:integer"/>
        
        <xs:element name="School">
            
            <xs:complexType>
                
                <xs:sequence>
                    
                    <xs:element name="student" minOccurs="1" maxOccurs="unbounded">
                        <xs:complexType>
                            
                            <xs:sequence>
                                
                                <xs:element name="uuid" type="xs:string"/>
                            </xs:sequence>
                            
                            <xs:attribute name="name" type="xs:string" use="required"/>
                            
                            <xs:attribute ref="age" use="required"/>
                        </xs:complexType>
                    </xs:element>
                </xs:sequence>
            </xs:complexType>
        </xs:element>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <School xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="myschema.xml">
        <student name="张三" age="33">
            <uuid>h4jd8flr-4h38flsp-meofk5p3-smif64tr</uuid>
        </student>
        <student name="李四" age="34">
            <uuid>h4jd8flr-4h38flsp-meofk5p3-smif64tr</uuid>
        </student>
    </School>
    
    attribute属性元素具体使用示例

#### 7：attributeGroup属性组元素 ####

attributeGroup与attribute差不多，只是一个单独存在，而现在介绍的是以组的形式存在的，我们引用一个组代表引用了几个一组的属性

语法：
        定义：<xs:attributeGroup  name='属性名称'>定义一组属性</xs:attributeGroup>
        使用：<xs:attributeGroup  ref='引用的属性名称' />
    常用属性：
        name：定义属性名称
        ref：引用定义好的属性

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    
        
        <xs:attributeGroup name="studentAtt">
            <xs:attribute name="name" type="xs:string" use="required"/>
            <xs:attribute name="age" type="xs:integer" use="required"/>
            <xs:attribute name="address" type="xs:string" use="optional"/>
        </xs:attributeGroup>
    
        <xs:element name="School">
            <xs:complexType>
                
                <xs:attributeGroup ref="studentAtt"/>
            </xs:complexType>
        </xs:element>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <School xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="myschema.xml" name="安徽学院" age="66" address="安徽"/>
    
    attributeGroup属性组元素具体使用示例

#### 8：simpleType简单类型元素 ####

simpleType是用来定义简单类型的，比如string、integer这些基本类型上加以简答的升级成为简单类型，比如在string上升级成一个字符串枚举类型，简单类型决定了元素和属性的约束和相关信息

语法：
        <simpleType name='简单类型名称'>编写简单类型规则</simpleType>
    
    属性：
        name：简单类型名称（只有定义在全局时才有name）
    
    具体内容：
    restriction（限制）
        属性：
            base：设置基本类型
        元素：
            maxExclusive：设置数值型的最大值（不包含最大值）
            minExclusive：设置数值型的最小值（不包含最小值）
            maxInclusive：设置数值型的最大值
            minInclusive：设置数值型的最小值
            maxLength：设置字符串型的最大长度
            minLength：设置字符串型的最小长度
            fractionDigits：设置小数点位数（在decimal类型下使用）
            totalDigits：设置小数总位数的最大长度（在decimal类型下使用）
            enumeration：设置枚举数值，和base类型保持一致
    list（列表）
        属性：
            itemType：设置列表的类型
    union（组合）

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    
        
        <xs:simpleType name="AnhuiAddress">
            <xs:restriction base="xs:string">
                <xs:enumeration value="安徽六安"/>
                <xs:enumeration value="安徽合肥"/>
                <xs:enumeration value="安徽安庆"/>
            </xs:restriction>
        </xs:simpleType>
        
        <xs:simpleType name="ShanghaiAddress">
            <xs:restriction base="xs:string">
                <xs:enumeration value="上海浦东新区"/>
                <xs:enumeration value="上海静安区"/>
                <xs:enumeration value="上海普陀区"/>
            </xs:restriction>
        </xs:simpleType>
    
        <xs:complexType name="student">
            
            <xs:sequence>
                
                <xs:element name="name">
                    <xs:simpleType>
                        <xs:restriction base="xs:string">
                            <xs:maxLength value="4"/>
                            <xs:minLength value="2"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                
                <xs:element name="likes">
                    <xs:simpleType>
                        <xs:list itemType="xs:string"/>
                    </xs:simpleType>
                </xs:element>
                
                <xs:element name="address">
                    <xs:simpleType>
                        
                        <xs:union>
                            <xs:simpleType>
                                <xs:list itemType="AnhuiAddress"/>
                            </xs:simpleType>
                            <xs:simpleType>
                                <xs:list itemType="ShanghaiAddress"/>
                            </xs:simpleType>
                        </xs:union>
                    </xs:simpleType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
        
        <xs:element name="Student" type="student"/>
    
    </xs:schema>
    
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <Student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="myschema.xml">
        <name>蚂蚁小哥</name>
        <likes>骑行 爬山</likes>
        <address>上海静安区 上海浦东新区</address>
    </Student>
    
    simpleType简单类型使用示例

#### 9：complexType复杂类型属性 ####

其实就是定义一个复合的类型，里面可以嵌套子元素，也可包含元素等等，它决定了一组元素和属性值的约束和相关信息

语法：
        定义：<complexType name='类型名称'></xs:complexType>
        引用：在type上直接引用类型名称
    属性：
        name：类型名称

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
        
        <xs:complexType name="student">
            
            <xs:sequence>
                
                <xs:element name="name" type="xs:string"/>
            </xs:sequence>
            
            <xs:attribute name="uuid" type="xs:string" use="optional"/>
        </xs:complexType>
        
        <xs:element name="Student" type="student"/>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <Student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="myschema.xml">
        <name>蚂蚁小哥</name>
    </Student>
    
    complexType复杂类型的使用示例

**注：SimpleType类型元素没有子元素，也没有属性；如果想定义子元素和属性就必须使用复杂类型ComplexType**

#### 10：simpleContent简单内容元素 ####

simpleContent这个元素是对复杂类型的一个简单的限制，限制当前复杂类型下面是否可以在包含子元素了和子属性了，一旦设置了simpleContent的话就意味在复杂类型下不能有子元素了，但是设置对应的simpleContent子元素是可以设置属性值的

语法：
        <xs:simpleContent>里面设置约束内容</xs:simpleContent>
    
    子元素：
        extension（扩大）：设置此元素后可以设置属性，但是不能设置子元素
            base：当前元素中文本的类型
        restriction（限制）：设置此元素后就代表此元素只能设置文本，无子元素和子属性
            base：限制的类型

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
        
        <xs:complexType name="student">
            
            <xs:simpleContent>
                
                <xs:extension base="xs:decimal">
                    
                    <xs:attribute name="name" type="xs:string" use="required"/>
                    <xs:attribute name="address">
                        <xs:simpleType>
                            <xs:restriction base="xs:string">
                                <xs:enumeration value="安徽六安"/>
                                <xs:enumeration value="安徽合肥"/>
                            </xs:restriction>
                        </xs:simpleType>
                    </xs:attribute>
                </xs:extension>
            </xs:simpleContent>
        </xs:complexType>
    
        
        <xs:complexType name="defaultType">
            
            <xs:simpleContent>
                <xs:restriction base="xs:string">
                    <xs:enumeration value="安徽六安"/>
                    <xs:enumeration value="安徽合肥"/>
                </xs:restriction>
            </xs:simpleContent>
        </xs:complexType>
    
        
        <xs:element name="Student" type="student"/>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <Student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="myschema.xml" name="蚂蚁小哥">
        12.6
    </Student>
    
    simpleContent简单限制的基本使用示例

**注：SimpleContent用于ComplexType元素上，用于限定该ComplexType的内容类型，表示该ComplexType没有子元素，但是可以在里卖弄的extension元素里设置属性，如果没属性和没子元素，那么当前的类型和SimpleType一样**

#### 11：choice元素（补充） ####

这个元素的主要功能是运行唯一一个元素从一个组中被选择

语法：
        <xs:complexType name='复杂类型名称'>
            <xs:choice minOccurs='最少出现元素' maxOccurs='最大出现元素'>里面定义元素</xs:choice>
        </xs:complexType>
    属性：
        minOccurs：当前在里面定义的全部元素至少使用设置的值
        maxOccurs：当前在里面定义的全部元素最多使用设置的值
            unbounded：可取值无限，可全部使用，
            数值：定义上限使用几个
    
    假设：minOccurs="1" maxOccurs="4"
        最少要在内部选择使用一个元素，并且使用不要超过4个

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    
        
        <xs:element name="Student">
            
            <xs:complexType>
                
                <xs:choice minOccurs="1" maxOccurs="3">
                    <xs:element name="name" type="xs:string"/>
                    <xs:element name="age" type="xs:integer"/>
                    <xs:element name="sex" type="xs:string"/>
                    <xs:element name="address" type="xs:string"/>
                </xs:choice>
            </xs:complexType>
        </xs:element>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <Student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="myschema.xml" >
        <name>张三</name>
        <address>安徽六安</address>
        <age>22</age>
    </Student>
    
    choice元素的基本使用示例

#### 12：sequence元素（补充） ####

此元素是用于给一个元素一个特定的序列（顺序），在写complexType复杂类型时我们会经常定义

语法：
        <xs:complexType name='复杂类型名称'>
            <xs:sequence minOccurs='最少出现元素' maxOccurs='最大出现元素'>里面定义元素</xs:sequence>
        </xs:complexType>
    属性：
        minOccurs：当前内部定义的全部元素为一组，如果值为2就代表必须顺序使用至少2遍
        maxOccurs：如果值为4就代表必须顺序使用不超过4遍
            unbounded：可取值无限，可全部使用，
            数值：定义上限使用几个
    
    假设：minOccurs="1" maxOccurs="4"
        最少要在内部实现2遍元素，并且使用不要超过4遍（必须顺序使用）

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    
        
        <xs:element name="Student">
            
            <xs:complexType>
                <xs:sequence minOccurs="1" maxOccurs="2">
                    <xs:element name="name" type="xs:string"/>
                    <xs:element name="age" type="xs:integer"/>
                </xs:sequence>
            </xs:complexType>
        </xs:element>
    </xs:schema>
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <Student xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="myschema.xml">
        <name>张三</name>
        <age>22</age>
        <name>张三</name>
        <age>22</age>
    </Student>
    
    sequence元素具体使用示例

#### 13：小试牛刀练习一下吧（总结上面内容） ####

对照下面的XML来写出一个Schema

<?xml version="1.0" encoding="UTF-8" ?>
    <School xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="myschema.xml">
        
        <Students>
            
            <student id="st001">
                
                <name>蚂蚁小哥</name>
                
                <sex>男</sex>
                
                <age>25</age>
                
                <address value="安徽六安"/>
                
                <hobbys>爬山 竞走 排球 篮球</hobbys>
                
                <grades>97.5</grades>
            </student>
        </Students>
        <Teachers>
            <teacher id="te001">
                <name>张老师</name>
                <sex>女</sex>
                <age>35</age>
                <address value="安徽合肥"/>
                
                <salary>6050.55</salary>
                
                <jobType>
                    <job>英语老师</job>
                </jobType>
                <jobType>
                    <job>数学老师</job>
                </jobType>
            </teacher>
        </Teachers>
        
        <Message msg="安徽电子信息学院" address="安徽蚌埠"/>
    </School>

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    
        
        <xs:group name="baseElement">
            <xs:sequence>
                
                <xs:element name="name">
                    <xs:simpleType>
                        <xs:restriction base="xs:string">
                            <xs:minLength value="2"/>
                            <xs:maxLength value="4"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                
                <xs:element name="sex">
                    <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:integer">
                            <xs:maxInclusive value="50"/>
                            <xs:minInclusive value="20"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                
                <xs:element name="address">
                    <xs:complexType>
                        <xs:attribute name="value" type="xs:string"/>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:group>
    
        
        <xs:complexType name="students">
            <xs:sequence>
                <xs:element name="student">
                    <xs:complexType>
                        
                        <xs:sequence>
                            
                            <xs:group ref="baseElement"/>
                            
                            <xs:element name="hobbys">
                                <xs:simpleType>
                                    <xs:list itemType="xs:string"/>
                                </xs:simpleType>
                            </xs:element>
                            
                            <xs:element name="grades">
                                <xs:simpleType>
                                    <xs:restriction base="xs:decimal">
                                        <xs:fractionDigits value="1"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:element>
                        </xs:sequence>
                        
                        <xs:attribute name="id" type="xs:ID" use="required"/>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    
        
        <xs:complexType name="teachers">
            <xs:sequence>
                <xs:element name="teacher">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:group ref="baseElement"/>
                            
                            <xs:element name="salary">
                                <xs:simpleType>
                                    <xs:restriction base="xs:decimal">
                                        <xs:totalDigits value="6"/>
                                        <xs:fractionDigits value="2"/>
                                    </xs:restriction>
                                </xs:simpleType>
                            </xs:element>
                            
                            <xs:element name="jobType" minOccurs="1" maxOccurs="unbounded">
                                <xs:complexType>
                                    <xs:sequence>
                                        <xs:element name="job" type="xs:string"/>
                                    </xs:sequence>
                                </xs:complexType>
                            </xs:element>
                        </xs:sequence>
                        
                        <xs:attribute name="id" type="xs:ID" use="required"/>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    
        
        <xs:complexType name="school">
            
            <xs:sequence>
                
                <xs:element name="Students" type="students"/>
                
                <xs:element name="Teachers" type="teachers"/>
                
                <xs:element name="Message">
                    <xs:complexType>
                        <xs:attribute name="msg" type="xs:string" use="required"/>
                        <xs:attribute name="address" type="xs:string" use="optional"/>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    
        
        <xs:element name="School" type="school"/>
    </xs:schema>
    
    具体练习的Schema代码

[38c781c594d5475c89cf70125a973974.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/1fa6361a5912468f83c1780d7c16d127.png