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

螞蟻小哥發表於2021-06-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是CDA他的一個子集，設定該屬性時只能寫英文字母、數字、句號、破折號
        下劃線、冒號，但是屬性值裡面不能有空格
　　　　  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程式碼

超詳細的程式設計師Java學習路線指南，從入門到精通不看後悔
2020-12-09
程式設計師Java
webpack從0到1超詳細超基礎學習教程
2018-05-27
Web
超詳細，手把手教你入門.NET for Linux
2018-05-07
Linux
SpringDataRedis入門到深入
2022-01-27
SpringRedis
CreateJS入門 -- 註釋詳細到爆炸（My Style）
2018-07-18
JS
Mitti不迷路！Mitti for Mac的超詳細入門指南
2020-10-19
MITMac
makefile從入門到入門
2020-10-06
scala 從入門到入門+
2019-02-16
新手入門，webpack入門詳細教程
2018-11-15
Web
深入理解正規表示式：從入門到精通
2024-04-30
快速入門NativeScript，超詳細的NativeScript學習筆記
2019-05-08
筆記
MyBatis從入門到精通(二)：MyBatis XML方式的基本用法之Select
2019-07-02
MyBatisXML
yarn詳細入門教程
2018-11-23
Yarn
深入理解二叉樹（超詳細）
2020-09-18
二叉樹
物聯網超詳細入門教程免費分享-千鋒
2019-12-18
超詳細的TCP、Sokcket和SuperSocket與TCP入門指導
2020-10-12
TCP
kafka從入門到關門
2020-10-31
Kafka
Argo CD 詳細入門教程
2024-09-05
Go
MyBatis從入門到精通(三)：MyBatis XML方式的基本用法之多表查詢
2019-07-03
MyBatisXML
MyBatis從入門到精通(四)：MyBatis XML方式的基本用法之增刪改
2019-07-04
MyBatisXML
2019新媒體運營超詳細入門教程-千鋒出品
2019-12-16
MyBatis從入門到精通(一)：MyBatis入門
2019-06-28
MyBatis
SA：從入門到入土
2024-10-30
Python從入門到精通
2024-03-09
Python
vim從入門到精通
2022-05-24
Jdbc從入門到入土
2022-05-19
JDBC
Thymeleaf從入門到精通
2020-07-24
Eclipse從入門到精通
2019-06-11
Eclipse
Shell從入門到精通
2021-01-28
Promise從入門到精通
2019-01-14
Promise
LESS從入門到精通
2019-03-17
Git 從入門到精通
2019-03-08
Git
babel從入門到跑路
2018-08-09
Babel
SAP從入門到精通
2018-06-29
Service Worker 從入門到出門
2019-07-11
Jmeter(八) - 從入門到精通 - JMeter配置元件（詳解教程）
2020-06-10
JMeter元件
Kafka從入門到放棄（三）—— 詳說消費者
2021-12-21
Kafka
Promise入門到精通(初級篇)-附程式碼詳細講解
2021-01-11
Promise