XML從入門到深入（超詳細）

2021 年 6 月 24 日
筆記

一：什麼是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="//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="//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="//www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="myschema.xml">
   我是學生
</student>

xmlns:xs="//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="//www.w3.org/2001/XMLSchema"
               targetNamespace="//www.6666.com/schoolSchemal">
    </xs:schema>
定義約束：
    ①：所有的標籤和屬性都是由schema文件來約束定義
    ②：所有的schema文件都需要有個命名空間（id）,具體名稱為namespace
    ③：namespace的值由targetNamespace指定，它就是一個url（正常都是不存在此鏈接的，只是個類似id標識）
    ④：引入官方Schema約束需要用到xmlns屬性 如 xmlns="xxxxx"
        我們可以為每個xmlns加上前綴，這樣我們每次使用加上前綴標識 如 xmlns:xs='xxxxx'


    <School xmlns="//www.6666.com/schoolSchemal"
            xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
            xsi:schemalLocation="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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="//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代碼