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

一：什么是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>

二：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" ?>
<!--引入PI指令 注意只能放在头部  并引入style.css样式-->
<?xml-stylesheet type='text/css' href='./style.css' ?>
<School>
    <!--定义学生对象  这是一个注释-->
    <Student>
        <name>蚂蚁小哥</name>
    </Student>
</School>

<!--CSS样式-->
name {
    font: normal 500 22px "微软雅黑";
    color:#f69;
}

3：XML之CDATA节

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

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<School>
    <!--定义学生对象  这是一个注释-->
    <Student>
        <!--使用<![CDATA[xxx]]>可以把特殊字符当作文本-->
        <name><![CDATA[我是一个"文本":想不到把]]></name>
    </Student>
</School>

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

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<School>
    <!--定义学生对象  这是一个注释-->
    <Student>
        <!--这里的蚂蚁小< > 哥报错 <>干扰，我们要使用转义-->
        <!--<name>蚂蚁小<>哥</name>-->
        <name>蚂蚁小&lt;&gt;哥</name>
    </Student>
</School>
<!--常用网页转义字符   xml也可以使用-->
<!--
显示结果            描述            实体名称            实体编号
                空格            &nbsp;            &#160;
    <            小于号        &lt;            &#60;
    >            大于号        &gt;            &#62;
    &            和号            &amp;            &#38;
    "            引号            &quot;            &#34;
    '            撇号            &apos;(IE不支持)    &#39;
    ￠            分            &cent;            &#162;
    £            镑            &pound;            &#163;
    ¥            日圆            &yen;            &#165;
    §            节            &sect;            &#167;
    ©            版权            &copy;            &#169;
    ®            注册商标        &reg;            &#174;
    ×            乘号            &times;            &#215;
    ÷            除号            &divide;        &#247;
-->
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" ?>
<!--注：此时我这里面的 ELEMENT 定义元素的我后面介绍-->
<!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>

<!--下面是文件 st.dtd-->
<!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>

<!--外部引用的st.dtd文件-->
<?xml version="1.0" encoding="UTF-8" ?>
<!--这里不能写DOCTYPE，因为这个可以当作元素引用，具体规则在上面定义-->
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
内外部定义DTD文档

3：DTD元素的定义（ELEMENT）

语法：<!ELEMENT 元素名称(NAME)  元素类型(COUTENT)>
    注：ELEMENT关键字
元素名称：就是自定义的子标签名称
元素类型：
    EMPTY：该元素不能包含子元素和文本，但是可以有属性，这类元素称为自闭和标签
    ANY：该元素可以包含任意在DTD中定义的元素内容
    #PCDATA：可以包含任何字符数据，设置这个就不能包含子元素了，一般设置具体value
    混合元素类型：只包含子元素，并且这些子元素没有文本
    混合类型：包含子元素和文本数据混合体
<!-- 定义空元素EMPTY -->
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE Student[
        <!ELEMENT Student EMPTY>
        ]>
<!--约束为空元素 所以写成自闭和标签，-->
<Student/>

<!-- 定义组合元素（student，teacher）并为每个元素设置类型（#PCDATA） -->
<?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>

<!-- 设置任意元素ANY 虽然student元素内部没有再设置元素而设置ANY，那我就可以
     在编写任意子元素，前提在里面有定义 -->
<?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>
        <!--定义了一个id属性类型为ID 必须值-->
        <!ATTLIST student id ID #REQUIRED>
        <!--设置了name属性 为任意字符的字符串 必须值-->
        <!ATTLIST student name CDATA #REQUIRED >
        <!--设置address 类型为多个常规字符串 且不需要一定存在此属性-->
        <!ATTLIST student address NMTOKENS #IMPLIED>
        <!--设置srcID  该属性的值只能从id上面上取-->
        <!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>
        <!--简便写法，全部放在一起写-->
        <!--设置了name属性 为任意字符的字符串 不一定要设置此属性，但是设置必须按照指定的值-->
        <!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：基本使用

<!-- myschema.xml文件 -->
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <!--定义一个String类型的元素-->
    <xs:element name="student" type="xs:string"/>
</xs:schema>

<!-- myxml.xml文件 -->
<?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">
    <!--定义一个name元素为string类型-->
    <xs:element name="name" type="xs:string"/>

    <!--定义的简单类型likes 并设置enum属性供选择一个爱好-->
    <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>

    <!--d定义一个复杂类型 student-->
    <xs:complexType name="student">
        <xs:sequence>
            <!--引用我最上面定义好的name元素-->
            <xs:element ref="name"/>
            <!--定义一个likes元素并指定简单类型-->
            <xs:element name="likes" type="likes"/>
            <!--定义女朋友元素，此标签最少出现一个最多出现次数不限unbounded（不限）-->
            <xs:element name="girlfriend" type="xs:string" minOccurs="1" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
    <!--创建一个element元素student 并引用我自定义的student的复杂类型-->
    <xs:element name="student" type="student"/>
</xs:schema>
<!-- 具体的xml使用 -->
<?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">
    <!--定义两个元素-->
    <!--substitutionGroup设置替代的元素，可以看出sname元素直接引用name，所以sname可以替代name-->
    <xs:element name="name" type="xs:string"/>
    <xs:element name="sname" substitutionGroup="name"/>
    <!--定义一个元素并设置固定值fixed-->
    <xs:element name="address" type="xs:string" fixed="安徽六安"/>
    
    <!--创建一个element元素student 这里的复杂类型我直接写在元素里-->
    <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使用 -->
<?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">

    <!--定义一个基本的base组 simpleType简单类型后面会介绍，现在使用一下 -->
    <xs:group name="base">
        <!--设置元素顺序-->
        <xs:sequence>
            <!--设置name元素-->
            <xs:element name="name" type="xs:string"/>
            <!--设置age元素 并限制年龄选择 value > 0 && value < 100 -->
            <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>
            <!--设置sex元素 并设置enum值为男女-->
            <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文件里使用 -->
<?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">
    <!--建属性age-->
    <xs:attribute name="age" type="xs:integer"/>
    <!--创建一个根元素-->
    <xs:element name="School">
        <!--设置复杂类型-->
        <xs:complexType>
            <!--按照顺序-->
            <xs:sequence>
                <!--构建一个student元素并设置复杂元素-->
                <xs:element name="student" minOccurs="1" maxOccurs="unbounded">
                    <xs:complexType>
                        <!--按照顺序-->
                        <xs:sequence>
                            <!--创建UUID元素-->
                            <xs:element name="uuid" type="xs:string"/>
                        </xs:sequence>
                        <!--创建属性name   必须创建xs:sequence下面，DTD归档的顺序创建-->
                        <xs:attribute name="name" type="xs:string" use="required"/>
                        <!--引用属性age   必须创建xs:sequence下面，DTD归档的顺序创建-->
                        <xs:attribute ref="age" use="required"/>
                    </xs:complexType>
                </xs:element>
            </xs:sequence>
        </xs:complexType>
    </xs:element>
</xs:schema>
<!-- 在自己的XML中具体使用 -->
<?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>
            <!--School元素里使用属性-->
            <xs:attributeGroup ref="studentAtt"/>
        </xs:complexType>
    </xs:element>
</xs:schema>
<!-- 在xml中使用上面约束 -->
<?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>
            <!--定义元素name 并设置name长度为2~4 -->
            <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>
            <!--定义likes元素 并设置为列表类型  空格隔开-->
            <xs:element name="likes">
                <xs:simpleType>
                    <xs:list itemType="xs:string"/>
                </xs:simpleType>
            </xs:element>
            <!--定义地址address元素-->
            <xs:element name="address">
                <xs:simpleType>
                    <!--组合 意思时说要么使用AnhuiAddress 要么使用ShanghaiAddress-->
                    <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>
    <!--定义Student元素并指定复杂类型为student-->
    <xs:element name="Student" type="student"/>

</xs:schema>

<!-- 引用到自己编写的xml里使用 -->
<?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>
            <!--定义一个name元素-->
            <xs:element name="name" type="xs:string"/>
        </xs:sequence>
        <!--属性定义-->
        <xs:attribute name="uuid" type="xs:string" use="optional"/>
    </xs:complexType>
    <!--定义一个Student元素 并为复杂类型-->
    <xs:element name="Student" type="student"/>
</xs:schema>
<!-- 具体在xml中使用 -->
<?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>
            <!--设置元素中的文本内容必须为decimal类型-->
            <xs:extension base="xs:decimal">
                <!--定义了两个属性 为name 和 address-->
                <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>

    <!--定义一个Student元素 并为复杂类型-->
    <xs:element name="Student" type="student"/>
</xs:schema>
<!-- 在xml文件中使用上面约束 -->
<?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">

    <!--定义一个Student的元素-->
    <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中使用 -->
<?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">

    <!--定义一个Student的元素-->
    <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中使用 -->
<?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>
        <!--学生实例 可以出现多个学生   属性ID为id类型-->
        <student id="st001">
            <!--名称限制2~4字符-->
            <name>蚂蚁小哥</name>
            <!--性别枚举 男|女-->
            <sex>男</sex>
            <!--年龄限制integer 20~50 -->
            <age>25</age>
            <!--家庭住址-->
            <address value="安徽六安"/>
            <!--爱好 使用list-->
            <hobbys>爬山 竞走 排球 篮球</hobbys>
            <!--成绩 保留一位小数点-->
            <grades>97.5</grades>
        </student>
    </Students>
    <Teachers>
        <teacher id="te001">
            <name>张老师</name>
            <sex>女</sex>
            <age>35</age>
            <address value="安徽合肥"/>
            <!--工资  最高不能超过6位数，小数点保留2位-->
            <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>
            <!--定义name元素 并设置简单类型字符串长度为2~4-->
            <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>
            <!--定义sex元素 并且设置置简单类型enum枚举为男|女-->
            <xs:element name="sex">
                <xs:simpleType>
                    <xs:restriction base="xs:string">
                        <xs:enumeration value="男"/>
                        <xs:enumeration value="女"/>
                    </xs:restriction>
                </xs:simpleType>
            </xs:element>
            <!--设置age元素 并设置简单类型数值范围为20~50-->
            <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>
            <!--设置address元素 并里面是value属性-->
            <xs:element name="address">
                <xs:complexType>
                    <xs:attribute name="value" type="xs:string"/>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:group>

    <!--定义复杂类型students-->
    <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>
                    <!--设置属性id 为ID类型-->
                    <xs:attribute name="id" type="xs:ID" use="required"/>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>

    <!--定义复杂类型teachers-->
    <xs:complexType name="teachers">
        <xs:sequence>
            <xs:element name="teacher">
                <xs:complexType>
                    <xs:sequence>
                        <xs:group ref="baseElement"/>
                        <!--设置工资元素  并且最高不超过6位，小数点为2位-->
                        <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>
                        <!--设置jobType工作类型元素  并且是个复杂类型 出现次数不限-->
                        <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>
                    <!--设置属性id 为ID类型-->
                    <xs:attribute name="id" type="xs:ID" use="required"/>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>

    <!--定义复杂类型school-->
    <xs:complexType name="school">
        <!--定义顺序 Students -> Teacher -> Message 按照顺序-->
        <xs:sequence>
            <!--定义一个Students元素 引用students复杂类型-->
            <xs:element name="Students" type="students"/>
            <!--定义一个Teachers元素 引用teachers复杂类型-->
            <xs:element name="Teachers" type="teachers"/>
            <!--定义Message元素并设置2个属性msg和address-->
            <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>

    <!--创建元素School并指定为school类型-->
    <xs:element name="School" type="school"/>
</xs:schema>
具体练习的Schema代码

 .

posted @ 2021-06-24 14:43  蚂蚁小哥  阅读(1885)  评论(2)  编辑  收藏  举报