使用W3C XML Schema

W3C XML Schema 定义语言是描述和约束XML文档内容的XML语言，W3C推荐使用W3C XML Schema。

本文介绍了如何使用W3C XML Schema，还包括了对Schema数据类型和结构的完整参考。

第一个Schema

让我们从一个描述一本书的简单文档开始：

<? xml version="1.0" encoding="UTF-8" ?>
< book  isbn ="0836217462" >
  < title >
  Being a Dog Is a Full-Time Job
  </ title >
  < author >Charles M. Schulz </ author >
  < character >
   < name >Snoopy </ name >
   < friend-of >Peppermint Patty </ friend-of >
   < since >1950-10-04 </ since >
   < qualification >
    extroverted beagle
   </ qualification >
  </ character >
  < character >
   < name >Peppermint Patty </ name >
   < since >1966-08-22 </ since >
   < qualification >bold, brash and tomboyish </ qualification >
  </ character >
</ book >

要为这份文档写一份scheme，可以从它的结构和定义我们看到的每个元素开始，我们现在从xs:schema元素开始：

<? xml version="1.0" encoding="UTF-8" ?> 
< xs:schema 
xmlns:xs ="http://www.w3.org/2001/XMLSchema" > 
.../... 
</ xs:schema > 

定义从schema 元素开始，它也包括了目标名称空间的定义和几个默认选项，我们会在下面章节中看到它们。

为了匹配book 元素标签，我们定义一个叫做book的元素。这个元素具有属性而无文字子节点，因此我们认为它是一个complexType （因为另一个数据类型simpleType 是只包括数据值而没有子节点或者属性），book元素的子节点使用sequence 元素进行定义：

 
 
  
  
  
  

  
  
   
   
   
   
 
    < 
    xs:element  
    name 
    ="book" 
    >    
   

  
  
   
   
   
   
 
    < 
    xs:complexType 
    >      
    < 
    xs:sequence 
    >       
   

  
  
   
   
   
   

     .../... 
    </ 
    xs:sequence 
    >     
   

  
  
   
   
   
   

       .../...   
    </ 
    xs:complexType 
    > 
    </ 
    xs:element 
    > 
   

 
 
  
  
  
  

sequence 定义了顺序的子元素，接下来的章节还会探讨另外两个同样的元素：choice和all。

现在，我们来定义title和author元素为简单类型——因为它们没有包含属性和非文本元素，并且可以在一个退化的元素element 内部直接描述。类型（xs:string）是被预先加了XML scheme相关的名称空间前缀，表示为预定义的XML scheme数据类型：

< xs:element  name ="title"  type ="xs:string" /> 
< xs:element  name ="author"  type ="xs:string" /> 

现在，我们必须来处理character 元素了，它是一个复杂类型，注意它的基数（cardinality ）是如何定义的：

< xs:element  name ="character"  minOccurs ="0"  maxOccurs ="unbounded" > 
< xs:complexType > 
< xs:sequence > 
.../... 
</ xs:sequence > 
</ xs:complexType > 
</ xs:element >

不像其他的scheme定义语言，W3C XML Schema  允许我们定义一个元素的精密基数（例如：可能的数目），我们可以一起指定minOccurs（最小可能）和maxOccurs （最大可能），这里maxOccurs 设置为unbounded 意思是该节点无最大数目限制，可以任意多。 

我们使用同样的方式指定所有的子节点：

< xs:element  name ="name"  type ="xs:string" /> 
< xs:element  name ="friend-of"  type ="xs:string"  minOccurs ="0"  maxOccurs ="unbounded" /> 
< xs:element  name ="since"  type ="xs:date" /> 
< xs:element  name ="qualification"  type ="xs:string" />

我们现在可以声明元素的属性了，一般在最后这样做。似乎并没有什么特别的理由这样做，但是W3C XML Schema工作组已经认为在一种复杂的类型内把一项有关的命令强加到元素列表和属性的定义更简单，并且在元素之后定义属性是更自然的。

< xs:attribute  name ="isbn"  type ="xs:string" /> 

就是这样！第一次的设计，有时也被称为“俄罗斯玩偶设计”，紧随我们示例文档的结构。

其中这样的设计的一个关键特点是定义一个上下文中的每个元素和属性，并允许多个事件的同一元素的名称，进行不同的定义。

本例的完整scheme定义如下：

<? xml version="1.0" encoding="utf-8" ?> 
< xs:schema  xmlns:xs ="http://www.w3.org/2001/XMLSchema" > 
< xs:element  name ="book" > 
< xs:complexType > 
< xs:sequence > 
< xs:element  name ="title"  type ="xs:string" /> 
< xs:element  name ="author"  type ="xs:string" /> 
< xs:element  name ="character"  minOccurs ="0"  maxOccurs ="unbounded" > 
< xs:complexType > 
< xs:sequence > 
< xs:element  name ="name"  type ="xs:string" /> 
< xs:element  name ="friend-of"  type ="xs:string"  minOccurs ="0"  
maxOccurs ="unbounded" /> 
< xs:element  name ="since"  type ="xs:date" /> 
< xs:element  name ="qualification"  type ="xs:string" /> 
</ xs:sequence > 
</ xs:complexType > 
</ xs:element > 
</ xs:sequence > 
< xs:attribute  name ="isbn"  type ="xs:string" /> 
</ xs:complexType > 
</ xs:element > 
</ xs:schema >

下面的章节探讨了如何细分模式设计，以使它们更具可读性和可维护性。

 

分层 Schema

因为以往的设计方法很简单，它会导致内嵌设计变得深奥，使之难以可读并且当文件复杂的时候难以维护。另外一个不利的地方是，XML和DTD在结构上差别很大，给人和机器在想将DTD转换到XML Scheme的时候造成了很大的麻烦，甚至在两种技术上无法使用同一个设计指导。

第二种设计基于一个所有在实例文档中可用元素的目录，包括其中的每个元素，例如子元素和属性的列表。这种作用是通过使用元素参考和必须符合范围的参考的属性定义，实现了简单设计：

<? xml version="1.0" encoding="UTF-8" ?> 
< xs:schema  xmlns:xs ="http://www.w3.org/2001/XMLSchema" > 
<!--  definition of simple type elements  --> 
< xs:element  name ="title"  type ="xs:string" /> 
< xs:element  name ="author"  type ="xs:string" /> 
< xs:element  name ="name"  type ="xs:string" /> 
< xs:element  name ="friend-of"  type ="xs:string" /> 
< xs:element  name ="since"  type ="xs:date" /> 
< xs:element  name ="qualification"  type ="xs:string" /> 
<!--  definition of attributes  --> 
< xs:attribute  name ="isbn"  type ="xs:string" /> 
<!--  definition of complex type elements  --> 
< xs:element  name ="character" > 
< xs:complexType > 
< xs:sequence > 
< xs:element  ref ="name" /> 
< xs:element  ref ="friend-of"  minOccurs ="0"  maxOccurs ="unbounded" /> 
< xs:element  ref ="since" /> 
< xs:element  ref ="qualification" /> 
<!--  the simple type elements are referenced using 
the "ref" attribute  --> 
<!--  the definition of the cardinality is done 
when the elements are referenced  --> 
</ xs:sequence > 
</ xs:complexType > 
</ xs:element > 
< xs:element  name ="book" > 
< xs:complexType > 
< xs:sequence > 
< xs:element  ref ="title" /> 
< xs:element  ref ="author" /> 
< xs:element  ref ="character"  minOccurs ="0"  maxOccurs ="unbounded" /> 
</ xs:sequence > 
< xs:attribute  ref ="isbn" /> 
</ xs:complexType > 
</ xs:element > 
</ xs:schema >

使用元素或属性的引用某种程度上好克隆一个对象相似。元素或者属性首先被定义，然后在该文档的其他地方可以通过引用机制被复制，同样对象也可以被克隆。这两个元素（或属性）那么就是同一个类的两个实例。

下面的章节我们将讲述怎样定义“types”这种类，它允许我们复用元素定义。

 

定义命名类型

我们已经看到，当我们需要他们时，我们可以定义元素和属性，首先创建并引用它们（目录）。 W3C XML Schema 给我们第3 个机制， 将确定数据类型（用于PCDATA元素的简单类型或者属性或者仅用于元素的复杂类型）使用这种类型去定义我们的属性和元素。

这是通过给simpleType 和complexType 元素命名实现的，并且在元素和属性定义之外定位它们。我们也会借此机会，以显示我们如何通过在数据类型上定义约束新建一个数据类型。

例如，要定义一个名为nameType的数据类型，其为最大32个字符的字符串，我们会这样写：

< xs:simpleType  name ="nameType" > 
< xs:restriction  base ="xs:string" > 
< xs:maxLength  value ="32" /> 
</ xs:restriction > 
</ xs:simpleType > 

simpleType 元素中的name属性值为新数据类型的名称。restriction 元素表示通过应用一个约束，该数据类型源自于W3C XML Schema 名称空间（基础属性）的数据类型。例如，通过现在可能值的数字。这个maxLength 元素，即所谓的facet，说明这个约束是一个最大长度为32字符的约束条件。

另外一个功能强大的facet是pattern元素，它定义了一个必须匹配的正则表达式。例如，如果我们不关心“-”字符，我们可以定义ISBN数据类型为10个数字，因此：

< xs:simpleType  name ="isbnType" > 
< xs:restriction  base ="xs:string" > 
< xs:pattern  value ="[0-9]{10}" /> 
</ xs:restriction > 
</ xs:simpleType >

Facets，以及另外两种方式生成一个数据类型（list和union）将在下面的章节介绍。

复杂类型就像我们之前看到的那样被定义，仅仅给一个名称。

定义并且使用命名的数据类型与定义一个类兵器使用它实例化一个对象相似。一种数据类型是一个抽象的概念，可用于定义一个属性或匀速。datatype和属性以及元素的关系类似于类和对象的关系。

完整清单：

<? xml version="1.0" encoding="UTF-8" ?> 
< xs:schema  xmlns:xs ="http://www.w3.org/2001/XMLSchema" > 
<!--  definition of simple types  --> 
< xs:simpleType  name ="nameType" > 
< xs:restriction  base ="xs:string" > 
< xs:maxLength  value ="32" /> 
</ xs:restriction > 
</ xs:simpleType > 
< xs:simpleType  name ="sinceType" > 
< xs:restriction  base ="xs:date" /> 
</ xs:simpleType > 
< xs:simpleType  name ="descType" > 
< xs:restriction  base ="xs:string" /> 
</ xs:simpleType > 
< xs:simpleType  name ="isbnType" > 
< xs:restriction  base ="xs:string" > 
< xs:pattern  value ="[0-9]{10}" /> 
</ xs:restriction > 
</ xs:simpleType > 
<!--  definition of complex types  --> 
< xs:complexType  name ="characterType" > 
< xs:sequence > 
< xs:element  name ="name"  type ="nameType" /> 
< xs:element  name ="friend-of"  type ="nameType"  minOccurs ="0"  
maxOccurs ="unbounded" /> 
< xs:element  name ="since"  type ="sinceType" /> 
< xs:element  name ="qualification"  type ="descType" /> 
</ xs:sequence > 
</ xs:complexType > 
< xs:complexType  name ="bookType" > 
< xs:sequence > 
< xs:element  name ="title"  type ="nameType" /> 
< xs:element  name ="author"  type ="nameType" /> 
< xs:element  name ="character"  type ="characterType"  minOccurs ="0" /> 
<!--  the definition of the "character" element is 
using the "characterType" complex type  --> 
</ xs:sequence > 
< xs:attribute  name ="isbn"  type ="isbnType"  use ="required" /> 
</ xs:complexType > 
<!--  Reference to "bookType" to define the 
"book" element  --> 
< xs:element  name ="book"  type ="bookType" /> 
</ xs:schema > 

下面讲的是分组、排序以及衍生如何用来实现进一步的复用以及介绍scheme的结构。

 

分组，排序和派生

分组

W3C XML Schema 亦允许元素和属性的分组定义。

<!--  definition of an element group  --> 

< xs:group  name ="mainBookElements" > 
< xs:sequence > 
< xs:element  name ="title"  type ="nameType" /> 
< xs:element  name ="author"  type ="nameType" /> 
</ xs:sequence > 
</ xs:group > 

<!--  definition of an attribute group  --> 
< xs:attributeGroup  name ="bookAttributes" > 
< xs:attribute  name ="isbn"  type ="isbnType"  use ="required" /> 
< xs:attribute  name ="available"  type ="xs:string" /> 
</ xs:attributeGroup > 

这些分组可以被用于复杂类型的定义，如下：

< xs:complexType  name ="bookType" > 
< xs:sequence > 
< xs:group  ref ="mainBookElements" /> 
< xs:element  name ="character"  type ="characterType"  
minOccurs ="0"  maxOccurs ="unbounded" /> 
</ xs:sequence > 
< xs:attributeGroup  ref ="bookAttributes" /> 
</ xs:complexType >

这些分组不是数据类型，而是包含一组元素或属性的容器，在整体复用上提供了方便。

排序（Compositors）

到目前为止，我们已经看到了xs:sequence排序元素，它定义了有序的元素组。W3C XML Schema支持另外两种排序元素， 它们可以被混合使用以支持各种组合形式。每个排序元素都拥有minOccurs 和maxOccurs 属性，来定义它们的基数。

xs:choice表示几种可能的元素中的一个选择，或者多组元素中的一个选择。以下的组——排序可以在组内出现、复杂类型或者其他的排序，将会接受单一的name元素或者一系列的firstName、可选的middleName以及lastName：

< xs:group  name ="nameTypes" >
     < xs:choice >
       < xs:element  name ="name"  type ="xs:string" />
       < xs:sequence >
         < xs:element  name ="firstName"  type ="xs:string" />
         < xs:element  name ="middleName"  type ="xs:string"  minOccurs ="0" />
         < xs:element  name ="lastName"  type ="xs:string" />
       </ xs:sequence >
     </ xs:choice >
   </ xs:group >

xs:all 定义了一组无序的元素。下面的复杂类型定义允许其包含的元素以任意顺序排列：

< xs:complexType  name ="bookType" >
     < xs:all >
       < xs:element  name ="title"  type ="xs:string" />
       < xs:element  name ="author"  type ="xs:string" />
       < xs:element  name ="character"  type ="characterType"  minOccurs ="0"
       maxOccurs ="unbounded" />
     </ xs:all >
     < xs:attribute  name ="isbn"  type ="isbnType"  use ="required" />
</ xs:complexType >

为了避免组合变得复杂和模糊，而无法被W3C XML Schema工具所处理，一组约束被加到了xs:all：

• 在内容模型上子节点必须唯一
• 并且其子节点只能为xs:element定义或references，并且基数不能大于1

简单类型的派生

简单的数据类型都是派生于其他的数据类型，要么是被W3C XML Schema 名称空间预定义或标识的，要么是在你自己的schema定义的。

我们之前看到了简单类型使用约束派生的例子（使用xs:restriction 元素）。可以应用的不同类别的约束称为切面（facet）。除了xs:pattern（使用正则表达式语法）和xs:maxLength这两个切面看过外，许多切面允许在数据长度、值列表、最小和最大值、精确和可变等上面进行控制。

另外两个派生方法已经可用了，可以允许定义列表中分隔的空白和组合的数据类型。下面的定义使用xs:union扩展了我们的isbn类型，用了接受数据TDB和NA：

   < xs:simpleType  name ="isbnType" >
     < xs:union >
       < xs:simpleType >
         < xs:restriction  base ="xs:string" >
           < xs:pattern  value ="[0-9]{10}" />
         </ xs:restriction >
       </ xs:simpleType >
       < xs:simpleType >
         < xs:restriction  base ="xs:NMTOKEN" >
           < xs:enumeration  value ="TBD" />
           < xs:enumeration  value ="NA" />
         </ xs:restriction >
       </ xs:simpleType >
     </ xs:union >
   </ xs:simpleType >

union元素被应用到两个内嵌的简单类型上以允许两个数据类型的值数据，新类型现在将接受来自于一个枚举的两个可能值（TBD和NA）。

下面的例子，类型（isbnTypes）使用xs:list去定义一个ISBN数据的空白分隔的列表。它也是派生自一个类型(isbnTypes10)使用xs:restriction接受1到10的数据值，以空白分隔。

  < xs:simpleType  name ="isbnTypes" >
     < xs:list  itemType ="isbnType" />
   </ xs:simpleType >
   < xs:simpleType  name ="isbnTypes10" >
     < xs:restriction  base ="isbnTypes" >
       < xs:minLength  value ="1" />
       < xs:maxLength  value ="10" />
     </ xs:restriction >
   </ xs:simpleType >

 

 

内容类型

在文章的第一部分，我们检查了默认的内容类型行为，在面向数据的文档后建模，发现复杂类型的元素只是元素和属性，并且简单类型的元素是没有属性的字符数据。

W3C XML Schema 定义语言也支持定义空白内容元素，以及具有属性的简单内容（它们只包含字符串数据）。

空白内容元素使用xs:complexType结构并有意的忽略定义子元素。下列结构定义一个空白book元素并接受一个isbn属性。

< xs:element  name ="book" > 
< xs:complexType > 
< xs:attribute  name ="isbn"  type ="isbnType" /> 
</ xs:complexType > 
</ xs:element > 

简单的内容元素，例如，具有属性的字符串数据元素，可以使用xs:simpleContent从简单类型派生。上面定义的book元素因此被扩展成可以接受一个文本数据：

< xs:element  name ="book" > 
< xs:complexType > 
< xs:simpleContent > 
< xs:extension  base ="xs:string" > 
< xs:attribute  name ="isbn"  type ="isbnType" /> 
</ xs:extension > 
</ xs:simpleContent > 
</ xs:complexType > 
</ xs:element > 

注意属性定义的位置，显示扩展点是通过扩展属性完成的。这个定义将会接受下面的XML元素：

< book  isbn ="0836217462" > 
Funny book by Charles M. Schulz. 
Its title (Being a Dog Is a Full-Time Job) says it all ! 
</ book >

W3C XML Schema在 xs:complexType 元素中通过混合属性支持混合的内容。考虑下：

< xs:element  name ="book" > 
< xs:complexType  mixed ="true" > 
< xs:all > 
< xs:element  name ="title"  type ="xs:string" /> 
< xs:element  name ="author"  type ="xs:string" /> 
</ xs:all > 
< xs:attribute  name ="isbn"  type ="xs:string" /> 
</ xs:complexType > 
</ xs:element > 

将验证这样的XML文件，如下：

< book  isbn ="0836217462" > 
Funny book by  < author >Charles M. Schulz </ author >. 
Its title ( < title >Being a Dog Is a Full-Time Job </ title >) says it all ! 
</ book > 

不像DTD那样，W3C XML Schema 混合内容不修改子元素的约束，简单内容模型可以使用相同的方式表示。虽然这是较XML 1.0 DTD重要的改进，但注意字符数据值以及其相对子元素的位置，其不能应用约束。

 

约束

Unique

W3C XML Schema 提供了几种灵活的基于XPath的特性，其描述了唯一性约束和一致性引用约束。首先，一个简单的唯一性声明，使用xs:unique元素进行声明。下面的声明建立在我们的book元素的名称必须唯一的前提下：

< xs:unique  name ="charName" > 
< xs:selector  xpath ="character" /> 
< xs:field  xpath ="name" /> 
</ xs:unique > 

xs:unique 元素在schema中的位置，给出了内容节点，其中包括了约束。靠在book元素插入xs:unique，我们指定了在全文中此book名称必须唯一。

唯一性约束中定义的两个XPath 相对符合内容节点。第一个使用selector元素定义，目的是定义拥有该唯一性约束的元素——selector指向的节点必须是一个元素节点。

第二个路径，在xs:field元素中定义的，是相对于xs:selector所标识的元素，其可以是一个元素或者一个属性节点。这就是一个其值将会被检查唯一性的节点。组合值可以通过在xs:unique中添加另外的xs:field元素来实现。

Key

第二个结构，xs:key，和xs:unique类似，除了其值不能为null（注意xs:unique和xs:key都可以被引用）。要使用一个字符串名称作为一个key，我们可以通过使用xs:key替换xs:unique实现。

< xs:key  name ="charName" > 
< xs:selector  xpath ="character" /> 
< xs:field  xpath ="name" /> 
</ xs:key > 

Keyref

第三个结构，xs:keyref，允许我们的那个有一个到xs:key或xs:unique的引用。要显示它的用法，我们将介绍friend-of 元素，将会针对字符串使用。

< character > 
< name >Snoopy </ name > 
< friend-of >Peppermint Patty </ friend-of > 
< since >1950-10-04 </ since > 
< qualification > 
extroverted beagle 
</ qualification > 
</ character >

为了显示friend-of需要从同一本书参考一个字符，我们将会写，在同一个层次我们定义一个key约束，如下：

< xs:keyref  name ="charNameRef"  refer ="charName" >
   < xs:selector  xpath ="character" />
   < xs:field  xpath ="friend-of" />
</ xs:keyref >

 

这些功能基本独立于schema中的其他特性。它们从数据类型的定义中断开。唯一固定它们到schema的是它们被定义的位置，其中确定唯一性约束的范围。

 

创建可用——并且可复用的Schema

或许编写可复用的schema的第一步是文档化它们。W3C XML Schema 提供了一个XML注释（面向人的）的替代品，以及处理说明（面向机器），可能为支持工具更易于处理。

人类可读的文档可以用xs:documentation元素定义，而针对应用程序则必须包括在xs:appinfo元素内。它们都必须包含在xs:annotation元素内，并且接受可选的xml:lang以及source属性和任意的内容类型。source属性是一个URI引用，可被用来说明说明注释文档的目的或应用程序信息。

xs:annotation元素可以被添加到大多数schema结构的开始处，就如下面的例子那样。appinfo部分演示了如何自定义名称空间和schema可能允许在schema内部一个元素绑定到一个Java类。

< xs:element  name ="book" > 
< xs:annotation > 
< xs:documentation  xml:lang ="en" > 
Top level element. 
</ xs:documentation > 
< xs:documentation  xml:lang ="fr" > 
Element racine. 
</ xs:documentation > 
< xs:appinfo  source ="http://example.com/foo/" > 
< bind  xmlns ="http://example.com/bar/" > 
< class  name ="Book" /> 
</ bind > 
</ xs:appinfo > 
</ xs:annotation >

从多个文件组合Schema

对那些希望将一个schema定义在多个文档的人来说——要么切分一个大的schema，要么使用schema代码段的库——W3C XML Schema 提供两种机制来包含外部的schema。

第一种包含机制，xs:include类似于复制并粘贴包含的schema的定义。它是一个包含文件并且它不允许覆盖被包含schema的定义。它可以这样使用：

< xs:include  schemaLocation ="character.xsd" />

第二种包含机制，xs:redefine，类似于xs:include，除了它会要求你从包含的schema中重新定义声明。

< xs:redefine  schemaLocation ="character12.xsd" > 
< xs:simpleType  name ="nameType" > 
< xs:restriction  base ="xs:string" > 
< xs:maxLength  value ="40" /> 
</ xs:restriction > 
</ xs:simpleType > 
</ xs:redefine > 

注意，被重定义的声明必须放在xs:redefine元素中。

我们已经看到了很多特性，它们可以被一起使用，通过xs:include和xs:redefine去创建schema的库。我们看到了如何引用之前定义好的元素，如何通过派生定义数据类型并使用它们，如何定义并使用属性组，我们还看到元素好对象的对比、数据类型和类的对比。这里还有另外一个从面向对象设计借过来的特性，就是可以创建可复用的schema。

抽象类型

这些特性中的第一个，从面向对象设计演变而来的，是替代组。不像我们迄今看到的那些特性，一个替代组不是通过W3C XML Schema元素明确定义的，而是通过引用一个公用的元素（称为head）使用substitutionGroup。 

头元素并不包含任何特定的声明，但必须为全局的。所有的元素在一个替代组内需要有一个类型，要么和头元素同一个类型或者可以从它派生。那么，他们都可以代替头元素使用。在下面的例子中，surname元素可以在name元素被定义的任何地方使用。

< xs:element  name ="name"  type ="xs:string" /> 
< xs:element  name ="surname"  type ="xs:string"  
substitutionGroup ="name"   /> 

现在，我们也可以定义一个一般的name-elt 元素，它为一个替代组的头元素，其不应直接被使用，而应该使用其的一个派生形式。这是通过声明该元素为抽象的实现的，类似于面向对象语言中的一个抽象类。下面的例子定义了name-elt为抽象元素，它应该被在引用的地方使用name或surname替代。

< xs:element  name ="name-elt"  type ="xs:string"  abstract ="true" /> 
< xs:element  name ="name"  type ="xs:string"  
substitutionGroup ="name-elt" /> 
< xs:element  name ="surname"  type ="xs:string"  
substitutionGroup ="name-elt" />

最终类型

我们可以，或者另一个方面，希望控制数据类型上的派生。 W3C XML Schema 通过xs:complexType、xs:simpleType或者xs:element上的final属性支持这点。这个属性的值范围为：restriction, extension 以及#al，通过约束现在扩展或派生。下面的片段代码，举例说明，禁止从characterType 复杂类型的任何派生。

< xs:complexType  name ="characterType"  final ="#all" > 
< xs:sequence > 
< xs:element  name ="name"  type ="nameType" /> 
< xs:element  name ="since"  type ="sinceType" /> 
< xs:element  name ="qualification"  type ="descType" /> 
</ xs:sequence > 
</ xs:complexType > 

除final外，一个更细粒度的机制是控制简单类型的派生，作用在每个切面（facet）上。这里，这个属性叫做fixed，当它的值设为true的时候，切面（facet）不能进行修改（但其他的切换仍可被增加和修改）。下面的例子防止类型nameType被重定义：

< xs:simpleType  name ="nameType" > 
< xs:restriction  base ="xs:string" > 
< xs:maxLength  value ="32"  fixed ="true" /> 
</ xs:restriction > 
</ xs:simpleType >  

 

名称空间

在W3C XML Schema里的Namespaces 支持是灵活而简单的。它不但允许在实例文档（不像DTD）中使用任何前缀，而且允许你打开Schemas从已知或未知命名空间接受未知的元素和属性。

每个W3C XML Schema文档都通过targetNamespace 属性，绑定到一个特定的名称空间，或者缺少名称空间是因为缺少这样一个属性。每个我们想要定义的命名空间至少需要一个Schema文档（元素和属性没有名称空间也可以被定义）。

截至目前，我们忽略了targetNamespace这个属性，意思就是我们并没有使用名称空间。 要涉足命名空间，先让我们假设我们的例子属于一个简单的名称空间：

< book  isbn ="0836217462"  xmlns ="http://example.org/ns/books/" > 
.../... 
</ book > 

 

侵入性最小的方式，就是改写我们的schema，增加一些属性到xs:schema元素：

< xs:schema  targetNamespace ="http://example.org/ns/books/"  
xmlns:xs ="http://www.w3.org/2001/XMLSchema"  
xmlns:bk ="http://example.org/ns/books/"  
elementFormDefault ="qualified"  
attributeFormDefault ="unqualified" > 
.../... 
</ xs:schema >

名称空间的声明扮演着一个很重要的角色。首先（xmlns:xs=http://www.w3.org/2001/XMLSchema）说明下，我们不但选择使用前缀去标识元素以遵守W3C XML Schema的约定，而且我们在目前为止的所有例子中为W3C XML Schema预定义的数据类型都加上了xs前缀。要知道我们可以选择任何其他前缀代替xs。我们甚至可以在这个例子中使用http://www.w3.org/2001/XMLSchema 为我们默认的名称空间，我们本不会为W3C XML Schema元素或者数据类型增加前缀的。

既然我们工作于http://example.org/ns/books/名称空间，我们就用它定义（使用bk做前缀）。这意味着我们现在将要对引用加前缀使之成为“对象”（数据类型、元素、属性，……）属于bk：名称空间。再者，我们本可以选择任何的前缀来标识这个名称空间，或者甚至使用我们默认的名称空间（注意xs:unique, xs:key 以及xs:keyref中使用的 XPath表达式不使用默认名称空间）。

targetNamespace  属性允许你定义独立于名称空间的声明，它的名称空间在本schema中描述。如果你需要引用这个名称空间的对象，这是个很常见的例子，除了targetNamespace之外你还需要提供一个名称空间声明。

最后的两个属性（elementFormDefault 和attributeFormDefault）是在一个单一的schema中，W3C XML Schema提供的控制设施，无论属性和元素被默认为是否合法的（在一个名称空间内）。合法和非法之间的区别可以通过指定默认值显示，正如上面所述，而且当定义元素和属性时，加入一个form属性，其值为qualified或unqualified。 

但必须注意的是只有本地元素和属性可被指定为unqualified。所有全局定义的元素和属性必须总是合法（qualified）。

从外部名称空间导入定义

W3C XML Schema不像XSLT和XPath，在一些属性值中使用名称空间前缀来标识数据类型、元素、属性的名称空间。举例来说，我们已经在示例中通篇使用了这个特性来标识W3C XML Schema 的预定义数据类型。这种机制可以被扩展以从任何其他的名称空间导入定义并在我们的schema中进行复用。

通过三步流程可实现从其他名称空间复用定义。为了声明xml:lang这样的属性，即使对于XML 1.0名称空间这个过程也需要这样完成。首先，必须像往常一样定义名称空间。

< xs:schema  targetNamespace ="http://example.org/ns/books/"  
xmlns:xml ="http://www.w3.org/XML/1998/namespace"  
xmlns:bk ="http://example.org/ns/books/"  
xmlns:xs ="http://www.w3.org/2001/XMLSchema"  
elementFormDefault ="qualified"  
attributeFormDefault ="qualified" > 
.../... 
</ xs:schema > 

下一步，W3C XML Schema 需要知道符合该名称空间的schema所在位置。可以通过xs:import来实现。

< xs:import  namespace ="http://www.w3.org/XML/1998/namespace"  
schemaLocation ="myxml.xsd" /> 

W3C XML Schema现在知道它应该从myxml.xsd尝试寻找任何属于该XML名称空间的引用。我们现在就可以使用外部定义了。

< xs:element  name ="title" > 
< xs:complexType > 
< xs:simpleContent > 
< xs:extension  base ="xs:string" > 
< xs:attribute  ref ="xml:lang" /> 
</ xs:extension > 
</ xs:simpleContent > 
</ xs:complexType > 
</ xs:element > 

你可能感觉奇怪，为什么我们选择从XML名称空间引用xml:lang属性，而不是创建一个xml:lang，我们这样做是因为，引用一个属性（或元素）和引用一个数据类型在关系到名称空间时存在重大区别。

• 引用一个元素或属性导入了全部内容包括名称和名称空间。
• 引用一个数据类型仅仅导入其定义，而为你正定义的元素和属性命名，以及使用目标名称空间（如果你的属性或元素为unqualified的话则没有名称空间）的事都要留给你自己去做。

包含未知的元素

要完成这个关于名称空间的部分，我们需要知道我们的schema如何对未知元素开发，沮洳在介绍中约定的那样。这个特性是通过xs:any 和xs:anyAttribute来完成的，它允许分别的包含元素或属性。

举例来说，如果我们希望扩展我们的描述类型为任意的XHTML标签，我们可以这样声明：

< xs:complexType  name ="descType"  mixed ="true" > 
< xs:sequence > 
< xs:any  namespace ="http://www.w3.org/1999/xhtml"  
processContents ="skip"  minOccurs ="0"  
maxOccurs ="unbounded" /> 
</ xs:sequence > 
</ xs:complexType > 

xs:anyAttribute 给予了属性相同的功能。

descType 类型现在和内容混合了，并且接受一个任意数字或 http://www.w3.org/1999/xhtml 名称空间中的任何元素。 processContents 属性设为了skip表示告知W3C XML Schema 处理器不进行校验那些本该尝试校验的元素。其他可能的值为， strict 要求校验这些元素，或者lax要求需要时才进行校验。 namespace 属性接受一个空格分隔的URI列表，并且特殊的值 ##local（非合格元素）和##targetNamespace（目标名称空间） 可以包含在该列表中，##other（除了目标以外的其他名称空间）和##any （任何名称空间）则可以替代这个URI列表。除了这些提到的值以外不需要任何其他值。

 

W3C XML Schema和实例文档

我们目前已经涵盖了几乎所有的W3C XML Schema的特性，但我们仍需要看一看一些在你的实际工作中可以使用的扩展。为了区别这些另外的特性，一个单独的名称空间 http://www.w3.org/2001/XMLSchema-instance，通常使用前缀xsi。

xsi:noNamespaceSchemaLocation 和xsi:schemaLocation属性允许你将文档绑定到它的W3C XML Schema上面。连接并不是强制的，并且在合法性校验时亦会给出其他的建议，但是这确实有助于W3C XML Schema工具定位一个schema所在位置。

依赖于使用名称空间，连接可能是：

< book  isbn ="0836217462"
xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation ="file:library.xsd" >

或者，类似下面这样（注意具有URL的名称空间的语法以及schema中的URL，在相同的属性中使用空格分隔）：

< book  isbn ="0836217462"  
xmlns ="http://example.org/ns/books/"  
xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"  
xsi:schemaLocation = 
"http://example.org/ns/books/ file:library.xsd" > 

其他关于xsi 属性的用法是提供如何将一个元素对应到一个schema的信息。这些属性为xsi:type，它允许你定义元素的简单或复杂类型；以及xsi:nil，允许将nil（null）值赋给一个元素（前提是必须在schema中使用nillable=true属性）。在你的W3C XML Schema中你不需要声明这些属性就可以使用它们。