精华内容
下载资源
问答
  • 实现功能:写一个c函数,取文本a.txt(a1.txt)中XML值,并存入表A中。a.txt中数据存入A表中有2条数据,a1.txt中数据存入A表中有201条数据。 环境: 操作系统:AIX 数据库: DB2 编程语言:c语言 A表结构: Id:自动增长...
  • <?php $i = 0; while ($i++ < 2) { echo "Outer<br />\n"; while (1) { echo "Middle<br />... echo "这里不会被输出,因为continue 3已直接跳出本次循环开始下一次循环"; }
  • 开发环境为VC,基于对话框,用msxml组件解析XML文档,运用递归循环的方法实现树结构,支持中文,可以运行的一个实例。
  • import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput; import java.util.Scanner; public class Sys_1 { public static void main(String[] args){ Scanner rea=new Scanner(System.in); System.out....
  • * <p>Title: Xml树 * * <p>Description: * * <p>Copyright: Copyright (c) 2004 * * <p>Company: * * @author xulinjian * @version 2.0 */ public class XmlNode implements Serializable { private ...
  • cock:0 ~ 20 hen:0 ~ 34 chick:0 ~ 100
  • XML 模式:了解结构

    千次阅读 2007-03-26 22:01:00
    XML 模式:了解结构了解如何使用 XML 模式结构声明、扩展和限制 XML结构。 本系列中的其他文章:XML 模式:了解命名空间XML 模式:了解数据类型 语法定义语言的结构和语义、实施约束以及确保实例(实际数据)的...

    XML 模式:了解结构

    了解如何使用 XML 模式结构声明、扩展和限制 XML 的结构。

    本系列中的其他文章:
    XML 模式:了解命名空间
    XML 模式:了解数据类型

     

    语法定义语言的结构和语义、实施约束以及确保实例(实际数据)的有效性。正如英语(或任何其他语言)具有关联的语法来定义有关特殊句子的撰写规则,或者在给定英语句子的情况下,利用语法来检查该句的有效性一样,XML 实例文档的语法也定义相应的规则以确保该文档的结构和内容的有效性。

    W3C XML 模式定义 (WXS) 采用 XML 语言表示 W3C XML 模式 (WXS) 的抽象数据模型。通过定义模式的抽象数据模型,W3C 模式并不知道用于表示该模型的语言。XML 表示形式是 WXS 指定的正式表示形式,但您可以根据所需的任何方式表示抽象数据模型并将它用于验证。例如,您可以使用任何符合抽象数据模型的数据结构直接创建内存中的模式。这将促使开发 W3C 模式验证程序的供应商提供一个可用于直接创建内存中模式的 API。

    验证 XML 实例文档的语法有多种。某些语法很快便过时,而其他语法(如 DTD,它是 W3C XML 1.0 REC 的一部分)则已经通过了时间的考验。在现有语法中,XML 模式在 XML 开发人员中应用最广,这是因为:

    1. 它使用 XML 语言来定义模式。
    2. 它具有 44 个以上的内置数据类型,可以对其中的每一个数据类型进行进一步地优化,以对 XML 中的字符数据进行细粒度验证。
    3. 可以使用 minOccurs 和 maxOccurs 属性以细粒度方式定义元素的基数。
    4. 它通过 extension、restriction、import、include 和 redefine 结构支持模块化和可重用性。
    5. 它支持标识约束,以确保 XML 文档中的值在指定集中的唯一性。
    6. 它具有抽象数据模型,因此它的表示形式并不限于 XML。

    以下是一个有关如何根据外部指定的模式来验证 XML 实例的示例:

    import java.io.FileInputStream;
    import oracle.xml.parser.v2.XMLError;
    import oracle.xml.parser.schema.XML Schema;
    import oracle.xml.parser.schema.XSDBuilder;
    import oracle.xml.schemavalidator.XSDValidator;
    ...
    //加载 XML 模式
    XSDBuilder schemaBuilder = new XSDBuilder();
    XML Schema schema = schemaBuilder.build(new FileInputStream("myschema.xsd"), null);
    
    //将加载的 XML 模式设置为 XSDValidator
    XSDValidator validator = new XSDValidator();
    validator.setSchema(schema);
    
    //针对提供的 XML 模式验证 XML 实例。
    validator.validate(new FileInputStream("data.xml"));
    
    //检查错误
    XMLError error = validator.getError();
    if (error.getNumMessages() > 0) {
    System.out.println("XML-instance is invalid.");
    error.flushErrors();
    }
    else {
    System.out.println("XML-instance is valid.");
    }
    
    当然,XML 模式也有限制:
    1. 它不支持基于规则的验证。一个基于规则的验证示例为:如果属性“score”的值大于 80,则 XML 实例中必须存在元素“distinction”,否则元素不存在。
    2. 唯一粒子属性 (UPA) 约束过分严格地定义了用于所有类型的 XML 文档的语法。(有关更多信息,请参阅“UPA 约束”。)

    在我的前几篇文章中,我介绍了命名空间的概念(在您深入研究 XML 模式之前必须了解它)、XML 模式中支持的数据类型以及用于进一步限制和使用这些数据类型的 simpleType 结构。

    在本文中,我将介绍用于声明、扩展和限制 XML 结构的模式。您还将学习由 XML 模式提供的模型组、粒子以及其他约束。

    Oracle XML 开发人员工具包 (XDK) 包含一个符合 W3C 标准的 XML 模式处理器以及多个实用工具,如利用 API 通过编程来创建并限制模式数据类型、分析和验证 XML 模式结构本身以及遍历 XML 模式的抽象数据模型的实用工具。请检查 oracle.xml.parser.schema 和 oracle.xml.schemavalidator 程序包。

    内容和模型

    元素内容

    在 XML 文档中,元素内容是指包含在它的 <头> 和 </尾> 标记之间的内容。元素只能有四种类型的内容:TextOnly(纯文本)、ElementOnly(纯元素)、Mixed(混合)和 Empty(空)。在元素上声明的属性并视为是元素内容的一部分。它们只是其声明所在的元素的一部分,他们组成了 XML 的结构。

    TextOnly

    如果元素在其 <头> 和 </尾> 标记之间只有字符数据(或简单称为文本数据),即如果元素没有子元素,则该元素的内容被视为是 TextOnly(纯文本)。例如:

    <TextOnly>some character data</TextOnly>
    
    ElementOnly

     

    如果元素在其 <opening> 和 </closing> 标记之间只有子元素(可以选择性地由空格、制表符、换行符、回车符分隔),则该元素的内容被视为是 TextOnly(纯元素)。这些空格被称作是可忽略的空格,并通常用于对 XML 进行缩进。因此,以下内容:

    没有空格的 ElementOnly 内容

    <ElementOnly><child1 .../><child2 .../></ElementOnly>
    
    等价于:

     

    空格的 ElementOnly 内容

    <ElementOnly>
    <child1 .../>
    <child2 .../>
    </ElementOnly>
    
    混合

     

    如果元素的字符数据与子元素分散在 <头> 和 </尾巴> 标记之间,则该元素的内容被视为是 Mixed(混合)。(换言之,它的内容同时包含字符数据和子元素。)混合内容后,前面所说的可忽略空格将不再是可忽略的。因此,以下内容:

    <Mixed><child1.../>some character data<child1.../></Mixed>
    
    不同于:
    <Mixed>
    <child1 .../>
    some character data
    <child1 .../>
    </Mixed>
    

     

    如果元素在 <头> 和 </尾> 标记之间绝对没有任何内容(甚至是空格),则该元素的内容被视为是 Empty(空)。例如:

    <Empty></Empty>
    
    另一种便于使用,并且格式清晰的元素(具有空内容)表示方法是使用单个 Empty 标记,如下所示:
    <Empty />
    
    内容模型

     

    在 XML 语法中,您可以声明元素的内容模型,以指定相应 XML 实例文档中的元素内容类型。因此,内容模型是元素内容的定义。

    下图演示了如何在 XML 模式中声明内容模型。沿着图中从 <schema> 开始的路径深入探讨,以了解如何声明四种元素内容(包含和不包含属性声明)的内容模型。让我们简单介绍一下每个元素内容。

    图 1
    图 1:在 XML 模式中声明内容模型

     

    TextOnly

    在以上图示中,沿路径找到 simpleType-1 以使用 TextOnly 内容模型声明元素:

    <xsd:element name="TextOnly">
    <xsd:simpleType>
    <xsd:restriction base="xsd:string" />
    </xsd:simpleType>  
    </xsd:element>
    
    或等价于
    
    <xsd:element name="TextOnly" type="xsd:string" />
    
    以上模式使用 TextOnly 内容模型声明了一个名为“TextOnly”(可以为任何名称)的元素,其内容 必须 是相应 XML 实例中的整数。如果元素的内容模型为 TextOnly,则它始终有一个关联的 simpleType,用于指示该元素的数据类型。例如,在本示例中,元素 TextOnly 的数据类型为 string请参阅上一部分中此模式的相应 XML 实例。

     

    正如前面指出的,属性并不是元素内容;因此,另一个具有 TextOnly 内容并具有属性的 XML 实例的示例为:

    <TextOnly att="val">some character data</TextOnly>
    
    现在,沿着图 1 中的路径找到 simpleContent-3 ,以使用 TextOnly 内容模型和属性声明一个元素:
    <xsd:element name="TextOnly">
    <xsd:complexType>
    <xsd:simpleContent>
    <xsd:extension base="xsd:string">
    <xsd:attribute name="att" type="xsd:string" use="required" />
    </xsd:extension>
    </xsd:simpleContent>
    </xsd:complexType>
    </xsd:element>
    
    以上模式使用 TextOnly 内容模型声明一个名为“TextOnly”的元素,其内容必须为字符串并且在相应的 XML 实例中必须有一个名为“attr”的属性。

     

    ElementOnly

    沿着图 1 中的路径直到找到 sequence-5、choice-6 之一或 all-7,以使用 ElementOnly 内容模型声明一个元素:

    <xsd:element name="ElementOnly">
    <xsd:complexType>
    <xsd:sequence> <!-- could have used choice or all instead —>
    <xsd:element name="child1" type="xsd:string" />
    <xsd:element name="child2" type="xsd:string" />
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    以上模式使用 ElementOnly 内容模型声明一个名为“ElementOnly”的元素。元素“ElementOnly”在相应的 XML 实例文档中必须具有子元素“child1”和“child2”。请参阅上一部分中此模式的相应 XML 实例。

     

    另一个包含 ElementOnly 元素内容和属性的 XML 实例如下所示:

    <ElementOnly att="val">
    <child1 .../>
    <child2 .../>
    </ElementOnly>
    
    要使用 ElementOnly 内容模型和属性声明一个元素,图 1 中的路径与声明 ElementOnly 内容模型的路径相同。然后,按如下所示在 complexType 中声明属性:
    <xsd:element name="ElementOnly">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="child1" type="xsd:string" />
    <xsd:element name="child2" type="xsd:string" />
    </xsd:sequence>
    <xsd:attribute name="att" type="xsd:string" use="required" />
    </xsd:complexType>
    </xsd:element>
    
    以上模式的相应 XML 实例如下
    <Mixed att="val">
    <child1 .../>
    some character data
    <child1 .../>
    </Mixed>
    
    混合型

     

    没着图 1 中的路径找到 sequence-5、choice-6 之一或 all-7,以使用 Mixed 内容模型(它与声明 ElementOnly 内容模型相同)声明元素,但这次将 complexType 的 mixed 属性设置为 true,如下所示:

    <xsd:element name="Mixed">
    <xsd:complexType mixed="true">
    <xsd:sequence>
    <xsd:element name="child1" type="xsd:string" />
    <xsd:element name="child2" type="xsd:string" />
    </xsd:sequence>
    <xsd:attribute name="att" type="xsd:string" use="required" />
    </xsd:complexType>
    </xsd:element>
    
    Empty

     

    沿着此路径直到找到 complexType-2 以使用 Empty 声明一个具有或没有属性的元素:

    <xsd:element name="EmptyContentModels">
    <xsd:complexType>
    <xsd:sequence>
    
    <xsd:element name="Empty1">
    <xsd:complexType />
    </xsd:element>
    
    <xsd:element name="Empty2">
    <xsd:complexType>
    <xsd:attribute name="att" type="xsd:string" use="required" />
    </xsd:complexType>
    </xsd:element>
    
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    以上模式的相应 XML 实例如下
    <EmptyContentModels>
    <Empty1 />
    <Empty2 att="val" />
    </EmptyContentModels>
    
    模型组

     

    如果将元素的内容模型声明为 ElementOnly或混合型(意味着该元素具有子元素),则可以使用模型组更详细地指定子元素的顺序出现位置。模型组由粒子组成;粒子可以是元素声明或其他模型组。模型组本身有一个基数,可以使用 minOccurs 和 maxOccurs 属性对其进行优化。这些特征使模型组非常强大。

    XML 模式支持的三个模型组分别为:

    • Sequence - (a , b)* - 在 sequence 模型组中声明的子元素必须以模式中定义的同样顺序出现在相应的 XML 实例中。Sequence 模型组的基数范围从 0 到无限大。通过递归方式,sequence 模型组还可以进一步包含 Sequencechoice 模型组。
    • Choice - (a | b)* - 表示在 choice 模型组中声明的子元素集中,必须有一个元素出现在相应的 XML 实例中。Choice 模型组的基数范围从 0 到无限大。通过递归方式, choice 模型组可以进一步包含 SequenceChoice 模型组。
    • all - {a , b}?- 表示在 all 模型组中声明的整个子元素集必须出现在相应的 XML 实例中,但与 sequence 模型组不同的是,顺序并不重要。因此,子元素可以任何顺序出现。all 模型组的基数只能为 0 或 1。all 模型组只能包含元素声明而不能包含任何其他模型组。

    这些模型组既可以内联方式声明,也可以全局声明(一个包含名称并可重用的 <schema> 结构的直接子项)方式声明。必须在 <group> 结构中声明全局模型组,您可以以后按其名称引用它。但与内联模型组不同的是,不能在全局声明的模型组上声明 minOccurs/maxOccurs 属性。如果需要,可以在引用全局声明的模型组时使用 minOccurs/maxOccurs 属性。例如:

    <xsd:group name="globalDecl">
    <xsd:sequence>
    <xsd:element name="child1" type="xsd:string" />
    <xsd:element name="child2" type="xsd:string" />
    </xsd:sequence>
    </xsd:group>
    
    随后,可以在需要时使用 group 结构以及 minOccurs/maxOccurs 属性引用全局声明的模型组:
    <xsd:group ref="globalDecl" maxOccurs="unbounded">
    
    为更好地了解模型组,以下提供了一个复杂示例:
    ((a | b)* , c+)?
    
    <xsd:element name="complexModelGroup">
    <xsd:complexType>
    
    <xsd:sequence minOccurs="0" maxOccurs="1">
    <xsd:choice minOccurs="0" maxOccurs="unbounded">
    <xsd:element name="a" type="xsd:string" />
    <xsd:element name="b" type="xsd:string" />
    </xsd:choice>
    <xsd:element name="c" type="xsd:string" minOccurs="1" maxOccurs="unbounded">
    </xsd:sequence>
    
    </xsd:complexType>
    </xsd:element>
    
    complexType 叙述

     

    您现在拥有足够的信息来编写一个简单的 XML 文档模式。但 XML 模式中的许多高级概念仍有待介绍。

    complexType 是 XML 模式中其他强大的结构之一。您除了可以声明所有四个包含或不包含属性的内容模型以外,还可以通过继承已经声明的 complexType 以派生出新的 complexType。因此,派生的 complexType 既可以将更多声明添加到由基础 complexType 继承而来的声明(使用 extension),也可以限制基础 complexType 中的声明(使用 restriction

    可以使用 simpleContentcomplexContent 扩展或限制 complexType。具有 simpleContent 的 complexType 声明一个包含或不包含属性的 TextOnly 内容模型。具有 complexContent 的 complexType 可用于声明其它三个包含或不包含属性的内容模型(ElementOnly、Mixed 或 Empty)。

    扩展 complexType

    simpleContent

    图 2
    图 2:只能通过扩展具有 simpleContent 的 complexType 才能添加属性。

     

    具有 simpleContent 的 complexType 可以扩展 simpleType 具有 simpleContent 的 complexType。如图 2 中所示,在派生的 complexType 中,允许您执行的唯一操作是添加属性。例如:

    <?xml version="1.0"?>
    <xsd:schema targetNamespace="http://inheritance-ext-res"
    xmlns:tns="http://inheritance-ext-res"
    xmlns:xsd="http://www.w3.org/2001/XML Schema"
    elementFormDefault="qualified">
    attributeFormDefault="unqualified">
        
    <xsd:complexType name="DerivedType1">
    <xsd:simpleContent>
    <xsd:extension base="xsd:string">
    <xsd:attribute name="att1" type="xsd:string" use="required" />
    </xsd:extension>
    </xsd:simpleContent>
    </xsd:complexType>
    
    <xsd:complexType name="DerivedType2">
    <xsd:simpleContent>
    <xsd:extension base="tns:DerivedType1">
    <xsd:attribute name="att2" type="xsd:string" use="required" />
    </xsd:extension>
    </xsd:simpleContent>
    </xsd:complexType>
    
    <xsd:element name="SCExtension">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="Derived1" type="tns:DerivedType1" />
    <xsd:element name="Derived2" type="tns:DerivedType2" />
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    </xsd:schema>
    
    在以上模式中:

     

     

    1. DerivedType1 基于内置的 simpleType string 扩展,并添加了一个属性 attr1
    2. DerivedType2 继承基础 DerivedType1(它是一个具有 simpleContent 的 complexType)中的属性 attr1,并添加一个属性 attr2

     

    对应于以上模式的 XML 实例如下:

    <SCExtension xmlns="http://inheritance-ext-res"
    xmlns:xsi="http://www.w3.org/2001/XML Schema-instance"
    xsi:schemaLocation="http://inheritance-ext-res CTSCExt.xsd">
    
    <Derived1 att1="val">abc</Derived1>
    <Derived2 att1="val" att2="val">def</Derived2>
      
    </SCExtension>
    
    complexContent

     

    图 3
    图 3:具有 complexContent 的 complexType 可用于扩展模型组以及添加属性。

     

    具有 complexContent 的 complexType 可以扩展 complexType 具有 complexContent 的 complexType。如图 3 所示,在派生的 complexType 中,允许您添加属性以及扩展模型组。例如:

    <?xml version="1.0"?>
    <xsd:schema targetNamespace="http://inheritance-ext-res"
    xmlns:tns="http://inheritance-ext-res"
    xmlns:xsd="http://www.w3.org/2001/XML Schema"
    elementFormDefault="qualified">
    attributeFormDefault="unqualified">
    
    <!— (child1)+ —>
    <xsd:complexType name="BaseType">
    <xsd:sequence maxOccurs="unbounded">
    <xsd:element name="child1" type="xsd:string" />
    </xsd:sequence>
    <xsd:attribute name="att1" type="xsd:string" use="required" />
    </xsd:complexType>
    
    <!— ((child1)+ , (child2 | child3)) —>
    <xsd:complexType name="DerivedType">
    <xsd:complexContent>
    <xsd:extension base="tns:BaseType">
    <xsd:choice>
    <xsd:element name="child2" type="xsd:string" />
    <xsd:element name="child3" type="xsd:string" />
    </xsd:choice>
    <xsd:attribute name="att2" type="xsd:string" use="required" />
    </xsd:extension>
    </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:element name="CCExtension">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="Base" type="tns:BaseType" />
    <xsd:element name="Derived" type="tns:DerivedType" />
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    </xsd:schema>
    
    在以上模式中:

     

     

    1. DerivedType 继承基础 complexType 中的 sequence 模型组,并添加一个 choice 模型组,从而生成派生的 complexType 的最终内容模型- ((child1)+ , (child2 | child3))。
    2. DerivedType 继承 BaseType 中的属性 attr1,并添加属性 attr2

    对应于以上模式的 XML 实例如下:

    <CCExtension xmlns="http://inheritance-ext-res"
    xmlns:xsi="http://www.w3.org/2001/XML Schema-instance"
    xsi:schemaLocation="http://inheritance-ext-res CTCCExt.xsd">
    
    <Base att1="val">
    <child1>This is base</child1>
    <child1>This is base</child1>
    </Base>
      
    <Derived att1="val" att2="val">
    <child1>This is inherited from base</child1>
    <child1>This is inherited from base</child1>
    <child1>This is inherited from base</child1>
    <child3>This is added in the derived</child3>
    </Derived>
    
    </CCExtension>
    
    限制 complexType

     

    simpleContent

    图 4
    图 4:具有 simpleContent 的 complexType 可用于限制数据类型和属性。

     

    具有 simpleContent 的 complexType 只能限制具有 simpleContent 的 complexType。如图 4 中所示,在派生的 complexType 中,可以限制基类的 simpleType,以及限制基类中的属性的类型和使用(可选、强制等)。例如:

    <?xml version="1.0"?>
    <xsd:schema targetNamespace="http://inheritance-ext-res"
    xmlns:tns="http://inheritance-ext-res"
    xmlns:xsd="http://www.w3.org/2001/XML Schema"
    elementFormDefault="qualified">
    attributeFormDefault="unqualified">
        
    <xsd:complexType name="BaseType">
    <xsd:simpleContent>
    <xsd:extension base="xsd:string">
    <xsd:attribute name="att1" type="xsd:string" use="optional" />
    <xsd:attribute name="att2" type="xsd:integer" use="optional" />
    </xsd:extension>
    </xsd:simpleContent>
    </xsd:complexType>
    
    <xsd:complexType name="DerivedType">
    <xsd:simpleContent>
    <xsd:restriction base="tns:BaseType">
    <xsd:maxLength value="35" />
    <xsd:attribute name="att1" use="prohibited" />
    
    <xsd:attribute name="att2" use="required">
    <xsd:simpleType>
    <xsd:restriction base="xsd:integer">
    <xsd:totalDigits value="2" />
    </xsd:restriction>
    </xsd:simpleType>
    </xsd:attribute>
    
    </xsd:restriction>
    </xsd:simpleContent>
    </xsd:complexType>
    
    <xsd:element name="SCRestriction">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="Base" type="tns:BaseType" />
    <xsd:element name="Derived" type="tns:DerivedType" />
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    </xsd:schema>
    
    在以上模式中:

     

     

    1. 您将基类的 simpleType 内容(字符串类型)限制为派生的 simpleType 中一个长度为 35 的字符串。
    2. 您禁止从基类中继承属性 att1。
    3. 您将属性 att2 的类型限制为一个 2 位整数,并使其从可选变为强制。

     

    对应于以上模式的 XML 实例如下:

    <SCRestriction xmlns="http://inheritance-ext-res"
    xmlns:xsi="http://www.w3.org/2001/XML Schema-instance"
    xsi:schemaLocation="http://inheritance-ext-res CTSCRes.xsd">
    
    <Base att1="val">This is base type</Base>
    <Derived att2="12">This is restricted in the derived</Derived>
      
    </SCRestriction>
    
    complexContent

     

    图 5
    图 5:具有 complexContent 的 complexType 可用于限制模型组和属性。

     

    具有 complexContent 的 complexType 可以限制 complexType 具有 complexContent 的 complexType。如图 5 中所示,在派生的 complexType 中,您必须重复基类中的整个内容模型并在需要时按照要求对其进行限制。可以按照限制 simpleContent 的同一方法来限制属性。例如:

    <?xml version="1.0"?>
    <xsd:schema targetNamespace="http://inheritance-ext-res"
    xmlns:tns="http://inheritance-ext-res"
    xmlns:xsd="http://www.w3.org/2001/XML Schema"
    elementFormDefault="qualified">
    attributeFormDefault="unqualified">
    
    <xsd:complexType name="BaseType">
    <xsd:sequence>
    <xsd:element name="child1" type="xsd:string" maxOccurs="unbounded" />
    <xsd:element name="child2" type="xsd:string"/>
    </xsd:sequence>
    <xsd:attribute name="att1" type="xsd:string" use="optional" />
    </xsd:complexType>
    
    <xsd:complexType name="DerivedType">
    <xsd:complexContent>
    <xsd:restriction base="tns:BaseType">
    <xsd:sequence>
    <xsd:element name="child1" type="xsd:string" maxOccurs="4" />
    
    <xsd:element name="child2">
    <xsd:simpleType>
    <xsd:restriction base="xsd:string">
    <xsd:maxLength value="35" />
    </xsd:restriction>
    </xsd:simpleType>
    </xsd:element>
    
    </xsd:sequence>
    <xsd:attribute name="att1" type="xsd:string" use="prohibited" />
    </xsd:restriction>
    </xsd:complexContent>
    </xsd:complexType>
    
    <xsd:element name="CCRestriction">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="Base" type="tns:BaseType" />
    <xsd:element name="Derived" type="tns:DerivedType" />
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    </xsd:schema>
    
    在以上模式中:

     

     

    1. 您将 DerivedType(从 BaseType 继承)中的 child1 的基数从无限大限制为 4。
    2. 您将 DerivedType(从 BaseType 继承)中的 child2 的类型限制为一个长度为 35 的字符串。
    3. 您禁止从 BaseType 继承属性 att1。

     

    对应于以上模式的 XML 实例如下:

    <CCRestriction xmlns="http://inheritance-ext-res"
    xmlns:xsi="http://www.w3.org/2001/XML Schema-instance"
    xsi:schemaLocation="http://inheritance-ext-res CTCCRes.xsd">
    
    <Base att1="val">
    <child1>This is base type</child1>
    <child2>This is base type</child2>
    </Base>
      
    <Derived>
    <child1>This is restricted in the derived</child1>
    <child2>This is restricted in the derived</child2>
    </Derived>
      
    </CCRestriction>
    
    组装模式

     

    导入、包含和 可变式效果

    许多 Java 项目都涉及多个不同的类和程序包,而不只是一个大的 Java 文件,这是因为模块化可以方便代码的重用、读取和维护。随后,必须将必需的导入语句加入到类中,然后才能使用它们。同样,在 XML 模式中,您必须在各种不同命名空间中管理不同的模式,并需要将必需的导入语句加入到模式中,然后才能使用它们。

    可以使用 <import/> 和 <include/> 模式结构组装 XML 模式,当然,以下应是该模式中位于其他任何声明之前的第一个语句:

    <schema>
    <import namespace="foo" schemaLocation="bar.xsd" />
    <include schemaLocation="baz.xsd" />
      ...
    </schema>
    
    当导入的模式具有 targetNamespace 时,将使用 <import />,而当包含的模式未声明 targetNamespace 时,将使用 <include />。

     

    下面,我们将介绍一个示例,该示例涉及两个模式 A 和 B,且 A 引用 B 中声明的项目。

    情况 I
    如果两个模式都有 targetNamespace,且模式 A 的 targetNamespace (tnsA) 不同于模式 B 的 targetNamespace (tnsB),则 A 必须导入 B。

    <import namespace="tnsB" schemaLocation="B.xsd">
    
    但 A 导入 B 时和 A 包含 B 时不指定命名空间是一个错误。

     

    情况 II
    如果两个模式都包含 targetNamespace,且模式 A 的 targetNamespace (tnsAB) 与模式 B 的 targetNamespace (tnsAB) 相同,则 A 必须包含 B。

    <include schemaLocation="B.xsd">
    
    A 导入 B 是错误的。

     

    情况 III
    如果模式 A 和 B 都没有 targetNamespace。这种情况下,A 必须包含 B。

    <include schemaLocation="B.xsd" />
    
    情况 IV
    如果模式 A 没有 targetNamespace,而模式 B 包含 targetNamespace (tnsB),则 A 必须导入 B。
    <import namespace="tnsB" schemaLocation="B.xsd" />
    
    A 包含 B 是错误的,这是因为 B 包含一个 targetNamespace。

     

    情况 V
    如果模式 A 包含 targetNamespace (tnsA),而模式 B 不包含 targetNamespace,情况又将如何?A 应包含 B。但如果我认为在本例中,A 应导入 B,情况将如何?实际上,在这种情况下,A 可以导入或包含 B,且这两个操作都是合法的,但效果并不相同。

    如果 A 包含 B,则所包含的来自 B 的所有项目将获取 A 的命名空间。这样的包含被称作 可变式 包含。

    如果您不希望发生这样的可变式效果,则必须在不指定命名空间情况下完成导入。没有 namespace 属性的导入允许对不包含目标命名空间的组件进行非限定性引用。

    <import schemaLocation="B.xsd">
    
    多次导入或包含一个模式不会产生错误,这是因为模式处理器可以检测这种情况并不再加载已加载的模式。因此,A.xsd 导入 B.xsd 和 C.xsd 并不产生错误;B.xsd 和 C.xsd 各自单独导入 A.xsd。循环引用不会产生错误,但强烈建议您不要使用它。

     

    顺便说明的是,一个类似 <import /> 的简单导入也是合法的。该方法只允许对不包含目标命名空间的外部组件进行非限定性引用,而不提供任何有关其所在位置的信息提示。模式处理器将利用某种机制提示出错或查找未知项目,因模式处理器而异。但使用 <include /> 是非法的。

    经验法则:

     

    1. <include/> - 它的作用与在包含模式中以内联方式定义被包含的模式相当。
    2. <import/> -如果被导入的模式与导入模式的 targetNamespace 不同则始终使用 <import/>。

     

    重新定义模式

    您可能并不总想用其原始格式组装模式。例如,您可能需要修改从模式中导入的组件。在此类情况下,当我们需要重定义声明而不更改其名称时,我们使用重定义组件完成这一过程,要重定义的模式必须满足以下限制条件:(a) 与 重定义模式文档具有相同的 targetNamespace,(b) 根本没有 targetNamespace,这种情况下,被重定义模式文档将转变为重定义模式文档的 targetNamespace。

    例如:

     

    actual.xsd
    <?xml version="1.0"?>
    <xsd:schema targetNamespace="http://inheritance-ext-res"
    xmlns:tns="http://inheritance-ext-res"
    xmlns:xsd="http://www.w3.org/2001/XML Schema"
    elementFormDefault="qualified">
    attributeFormDefault="unqualified">
    
    <xsd:complexType name="BaseType">
    <xsd:sequence>
    <xsd:element name="child1" type="xsd:string" />
    </xsd:sequence>
    <xsd:attribute name="att1" type="xsd:string" use="required" />
    </xsd:complexType>
    
    <xsd:complexType name="DerivedType">
    <xsd:complexContent>
    <xsd:extension base="tns:BaseType">
    <xsd:choice>
    <xsd:element name="child2" type="xsd:string" />
    <xsd:element name="child3" type="xsd:string" />
    </xsd:choice>
    <xsd:attribute name="att2" type="xsd:string" use="required" />
    </xsd:extension>
    </xsd:complexContent>
    </xsd:complexType>
    
    </xsd:schema>
    
    redefine.xsd
    <?xml version="1.0"?>
    <xsd:schema targetNamespace="http://inheritance-ext-res"
    xmlns:tns="http://inheritance-ext-res"
    xmlns:xsd="http://www.w3.org/2001/XML Schema"
    elementFormDefault="qualified">
    attributeFormDefault="unqualified">
                
    <xsd:redefine schemaLocation="actual.xsd">
    <xsd:complexType name="DerivedType">
    <xsd:complexContent>
    <xsd:extension base="tns:DerivedType">
    <xsd:sequence>
    <xsd:element name="child4" type="xsd:string" />
    </xsd:sequence>
    </xsd:extension>
    </xsd:complexContent>
    </xsd:complexType>
    </xsd:redefine>
    
    <xsd:element name="Redefine">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="Base" type="tns:BaseType" />
    <xsd:element name="Derived" type="tns:DerivedType" />
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    </xsd:schema>
    
    在以上模式中:

     

     

    1. 您在未更改其名称的情况下,通过向内容模型中添加一个或多个元素重新定义了名称为 DerivedType 的 complexType。
    2. 不在重定义模式中重新定义基类,它将按原样继承。

     

    注意,重定义类型时,类型名称并不更改。所以,重定义的类型将其自身用作基类。

    在以上示例中,我们重新定义了一个名为 DerivedType 的 complexType 而未更改其名称。重定义 DerivedType 时,对“DerivedType”的任何引用(例如,base="tns:DerivedType")都被认为是引用实际的 DerivedType。重定义类型后,对 DerivedType 的任何引用都被认为是引用重定义后的类型。

    对应于以上重新定义的模式的 XML 实例如下:

    <Redefine xmlns="http://inheritance-ext-res"
    xmlns:xsi="http://www.w3.org/2001/XML Schema-instance"
    xsi:schemaLocation="http://inheritance-ext-res redefine.xsd">
    
    <Base att1="val">
    <child1>This is base type</child1>
    </Base>
      
    <Derived att1="val" att2="val">
    <child1>This is inherited from the base as is</child1>
    <child2>This is added in the derived</child2>
    <child4>This is added when redefining</child4>
    </Derived>
    
    </Redefine>
    
    约束

     

    身份约束

    使用 XML 模式,您可以对元素和属性的内容实施唯一性约束,这可以保证指定元素或属性的值在实例文档中是唯一的。实施唯一性时,必须要有一个其值需要进行唯一性检查的项目,例如,ISBN 号。确定项目后,必须确定一个集合(例如,图书集),以在其中对这些选定的项目的值进行唯一性检查。

    XML 模式为实施唯一性约束提供了两个结构: uniquekeyUnique 确保当指定值不为空时,它们必须在定义的集合中是唯一的;key 确保指定值始终不为空,并在定义的集合中是唯一的。

    还有一个结构 — keyref,它指向某个已定义的键。Keyref 确保 keyref 指向的键集中存在 keyref 中指定项目的值。

    这三个结构的全都具有相同的语法(它们全都使用选择器和域),但含义不同。选择器用于定义集合,以在其中实施在其中实施唯一性,(多个域用于定义一个组合项目)用于定义项目,以对其值进行唯一性检查。选择器的值均为 XPath 表达式。XPath 表达式不支持缺省命名空间,因此必须通过显式使用绑定到相应命名空间(如果命名空间中存在元素/属性)的前缀以使 XPath 表达式支持命名空间。例如:

    <?xml version="1.0"?>
    <xsd:schema targetNamespace="http://identity-constraint"
    xmlns:tns="http://identity-constraint"
    xmlns:xsd="http://www.w3.org/2001/XML Schema"
    elementFormDefault="qualified">
    attributeFormDefault="unqualified">
    
    
    <xsd:complexType name="BookType">
    <xsd:sequence>
    <xsd:element name="title" type="xsd:string" />
    <xsd:element name="half-isbn" type="xsd:string" />
    <xsd:element name="other-half-isbn" type="xsd:float" />
    </xsd:sequence>
    </xsd:complexType>
    
    <xsd:element name="Books">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="Book" type="tns:BookType" maxOccurs="unbounded" />
    </xsd:sequence>
    </xsd:complexType>
    
    <xsd:key name="isbn">
    <xsd:selector xpath=".//tns:Book" />
    <xsd:field xpath="tns:half-isbn" />
    <xsd:field xpath="tns:other-half-isbn" />
    </xsd:key>
    
    </xsd:element>
    
    </xsd:schema>
    
    在以上模式中,我们声明了一个名为“isbn”的键,它表示由“field 指定的组合值不得为空,并在由 selector 指定的图书集中是唯一的”。

     

    唯一粒子属性 (UPA) 约束

    UPA 约束确保按以下方式指定每个元素的内容模型:在验证 XML 实例时,不存在模糊性,且可以明确确定正确的元素声明以进行验证。例如,以下模式违反了 UPA 约束:

    <xsd:element name="upa">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="a" minOccurs="0"/>
    <xsd:element name="b" minOccurs="0"/>
    <xsd:element name="a" minOccurs="0"/>
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    这是因为在以上模式的相应 XML 实例中:
    <upa>
    <a/>
    </upa>
    
    不能确定 XML 实例中的元素“a”对应于模式中的哪个元素声明 - 是位于“b”的元素声明之前“a”的元素声明,还是位于“b”的元素声明之后的“a”的元素声明。该限制使您只能编写上面的 XML 实例类型的 XMLSchema。在本示例中,如果您只将元素“b”的 minOccurs 设置为任何大于 0 的值,则不会违反 UPA。

     

    因此,以下是一个有效模式:

    <xsd:element name="upa">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="a" minOccurs="0"/>
    <xsd:element name="b" minOccurs="1"/>
    <xsd:element name="a" minOccurs="0"/>
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>
    
    这是因为在以上模式的相应 XML 实例中:
    <upa>
    <a/>
    <b/>
    </upa>
    
    显而易见的是,XML 实例中的元素“a”实际上是“a”的元素声明(它位于该模式中“b”的元素声明之前)实例。

     

    结论

    现在,您已经完成了本系列,您应了解以下内容:

     

    1. XML 和 XML 模式中的命名空间概念
    2. XML 模式中支持的标量数据类型以及如何使用 simpleType 进一步限制它们
    3. 元素内容、内容模型、模型组、粒子、扩展和限制 complexType、组装模式、标识约束和 UPA(用于定义和约束 XML 的结构)。

     

    至此,您应已经较好地掌握了 XML 模式。

    展开全文
  • 本笔记计划总结XMLDocument方式读取XML文件并与readXML 方式进行对比 功能需求: ...用提供的路线循环对比树结构中的路线节点,找到后再用提供的站台信息循环对比树结构中该路线节点下的站台子节点 能够
      
    

    本笔记计划总结XMLDocument方式读取XML文件并与readXML 方式进行对比

    功能需求:

    提供路线表,包含路线及路线内站台信息。提供实际得到的路线及站台号信息,核对该站台号是否在该路线中(以路线表为标准)

    需求分析:

    先用XmlDocument读取路线信息,建立树结构。用提供的路线循环对比树结构中的路线节点,找到后再用提供的站台信息循环对比树结构中该路线节点下的站台子节点

    能够找到判定为合法站台号,找不到判定为非法站台号

    具体实现:

    路线表信息

    <?xml version="1.0" encoding="UTF-8" ?>
    <AAAAAA>
     <Header File_Name="ROUTE" File_Version="004" File_Format="05" />
      <Routes>  
       <Route ID="1" Route_Name="XXXX" Route_Code="XXXXXXXX">     
         <Route_Fare Fare1="FF" Fare2="FF" />
         <Stops>
          <Stop ID="1" Stop_Name="XXXXX" Stop_Code="XXXXXX" />
          <Stop ID="2" Stop_Name="XXXXX" Stop_Code="XXXXXX" />
            <!--...    可增加,结构同上 -->
          </Stops>
       </Route>
       <Route ID="2" Route_Name="XXXX" Route_Code="XXXXXXXX">
        <Route_Fare Fare1="FF" Fare2="FF" />
        <Stops>
         <Stop ID="1" Stop_Name="XXXXX" Stop_Code="XXXXXX" />
          <!--...    可增加,结构同上 -->
         </Stops>
       </Route>
        <!--...     可增加,结构同上-->
      </Routes>
    </AAAAAA>

    读路线表建立树结构

                XmlDocument readXml = new XmlDocument();
                readXml.Load(routeFilePath + @"\Route.xml");

    读取路线节点信息
                routeNodeList = readXml.SelectSingleNode("/AAAAAA/Routes").ChildNodes;

    循环对比路线节点

                foreach (XmlNode routeNode in routeNodeList)
                {
                    XmlElement routeElement = (XmlElement)routeNode;
                    if (routeElement.GetAttribute("Route_Code") == routeCode)
                    {
                    }
                }

    找到路线后循环对比站台号

                        XmlNodeList stopNodeList = routeElement.SelectSingleNode("Stops").ChildNodes;
                        foreach (XmlNode stopNode in stopNodeList)
                        {
                            XmlElement stopElement = (XmlElement)stopNode;
                           
                            if (stopElement.GetAttribute("Stop_Code").Substring(2,4) == rfidNo.Substring(2,4))
                            {
                                return true;
                            }
                        }

    需求搞定。

    用到的知识点:

    XmlDocument 声明并初始化

    XmlDocument readXml = new XmlDocument();

    读取数据readXml.Load(routeFilePath + @"\Route.xml");

    查找节点并存储在XmlNodeList类型的routeNodeList中

    routeNodeList = readXml.SelectSingleNode("/AAAAAA/Routes").ChildNodes;

    用到SelectSingleNode方法,选择匹配 "/AAAAAA/Routes") 表达式的第一个 XmlNode

    XmlNode.ChildNodes方法得到子节点列

    XmlElement routeElement = (XmlElement)routeNode;将节点转换为元素类型

    routeElement.GetAttribute("Route_Code")得到Route中属性Route_Code的值

     

    完整代码

    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Xml;

     

    namespace BuActionExplain
    {
        public class CheckRoute
        {
            public XmlNodeList routeNodeList;
           
            public  CheckRoute(string routeFilePath)
            {
                XmlDocument readXml = new XmlDocument();
                readXml.Load(routeFilePath + @"\Route.xml");
                routeNodeList = readXml.SelectSingleNode("/AAAAAA/Routes").ChildNodes;
            }

            public bool SelectRFID(XmlNodeList routeNodeList,string routeCode, string rfidNo)
            {
               
                foreach (XmlNode routeNode in routeNodeList)
                {
                    XmlElement routeElement = (XmlElement)routeNode;
                    if (routeElement.GetAttribute("Route_Code") == routeCode)
                    {
                        XmlNodeList stopNodeList = routeElement.SelectSingleNode("Stops").ChildNodes;
                        foreach (XmlNode stopNode in stopNodeList)
                        {
                            XmlElement stopElement = (XmlElement)stopNode;
                           
                            if (stopElement.GetAttribute("Stop_Code").Substring(2,4) == rfidNo.Substring(2,4))
                            {
                                return true;
                            }
                        }
                    }
                }
                return false;
            }

        }
    }

     

    开始时不知道还有XmlDocument这个东西,想用DataSet中的ReadXml方法,上网查找后发现XmlDocument方法最简洁有效。

    应为如果用DataSet中的ReadXml方法,将会读出6个表,而路线表和站台号表还要建立关联什么的,很复杂。

    综上,XmlDocument这个东西很好用

     

    最近又学到了类似的东东还有:

    XMLTextReader------提供以快速、单向、无缓冲的方式存取XML数据。(单向意味着你只能从前往后读取XML文件,而不能逆向读取)

    XMLValidatingReader------与XMLTextReader类一起使用,提供验证DTD、XDR和XSD架构的能力。

    XMLDocument------遵循W3C文档对象模型规范的一级和二级标准,实现XML数据随机的、有缓存的存取。一级水平包含了DOM的最基本的部分,而二级水平增加多种改进,包括增加了对名称空间和级连状图表(css)的支持。

    XMLTextWriter------生成遵循 W3C XML 1.0 规范的XML文件。

    信息来自于:

    http://www.cnblogs.com/goody9807/archive/2006/10/24/534888.html

    文章说XMLTextReader对资源要求更小,没仔细研究,先记下来。

    展开全文
  • 转换的PHP代码如下 header("Content-type:text/xml;charset=utf-8"); function getRootPath(){ $biasNum = substr_count($_SERVER['PHP_SELF'], '/'); //用'/'分割当前路径字符串,并计算分割后的字符串数量 $...
    转换的PHP代码如下
    
    	header("Content-type:text/xml;charset=utf-8");
    	function getRootPath(){
    		$biasNum = substr_count($_SERVER['PHP_SELF'], '/'); //用'/'分割当前路径字符串,并计算分割后的字符串数量
    		$relativePath = './'; //初始化变量$relativePath为'./'
    		for ($i = 0; $i < ($biasNum - 1); $i ++) { //循环添加'../'
        		$relativePath .= '../';
    		}
    		return $relativePath;
    	}
    	
    	function display_children($pid,$level,$root,$temDom){
    			$targetRoot=$temDom->getElementsByTagName('root')->item(0);
       			foreach ($root->childNodes as $sons){
       				$sonID=str_replace('n', '', $sons->nodeName);
       				$sonPid=$sons->getElementsByTagName('pid')->item(0)->nodeValue;
       				$sonName=$sons->getElementsByTagName('name')->item(0)->nodeValue;
       				$sonExplain=$sons->getElementsByTagName('explain')->item(0)->nodeValue;
       				if($sonPid==$pid){
    	   				//echo str_repeat('+', $level).$sonName.' and '.$sonID.'<br/>';
    	   				if($level==1){
    	   					$level1=$temDom->createElement('level1');
    	   					$level1->setAttribute('aid', $sonID);
    	   					$level1->setAttribute('name', $sonName);
    	   					$level1->setAttribute('explain', $sonExplain);
    	   					$targetRoot->appendChild($level1);
    	   					//$level1->getAttribute('');
    	   				
    	   				}else{
    	   					$parsentLevel=$temDom->getElementsByTagName('level'.($level-1));
    	   					foreach ($parsentLevel as $levels){
    	   						if($levels->getAttribute('aid')==$sonPid){
    	   							$sonLevel=$temDom->createElement('level'.$level);
    	   							$sonLevel->setAttribute('aid', $sonID);
    			   					$sonLevel->setAttribute('name', $sonName);
    			   					$sonLevel->setAttribute('explain', $sonExplain);
    	   							$levels->appendChild($sonLevel);
    	   						}
    	   					}
    	   					
    	   				}
    	   				display_children($sonID,$level+1,$root,$temDom);
       				}
       			}
    	}
    
     	 	$dom=new DOMDocument('1.0','utf-8');
       		$dom->load(getRootPath().'mydata/area/index/main.xml');
       		$root=$dom->getElementsByTagName('root')->item(0);
       		$temDom=new DOMDocument('1.0','utf-8');
       		$root1=$temDom->createElement('root');
       		$temDom->appendChild($root1);
       		//$tartRoot=$temDom->getElementsByTagName('root')->item(0);
       		display_children(0, 1, $root,&$temDom);
       		echo $temDom->saveXML();
       		
       	

    转换后的树形结构如下


    <?xml version="1.0" encoding="utf-8"?>
    <root><level1 aid="42" name="新加坡" explain="花园国度"/><level1 aid="41" name="俄罗斯" explain="北极熊"/><level1 aid="40" name="韩国" explain="高丽棒子"/><level1 aid="39" name="日本" explain="小日本"/><level1 aid="38" name="美国" explain="霸权主义国家"/><level1 aid="37" name="中国" explain="伟大的国家"><level2 aid="66" name="河南省" explain=""><level3 aid="80" name="开封" explain="少林所在地"/><level3 aid="79" name="洛阳" explain="历史名城"/><level3 aid="78" name="郑州市" explain="河南的省会"><level4 aid="81" name="测试区" explain=""/></level3></level2><level2 aid="55" name="贵州省" explain=""/><level2 aid="54" name="海南省" explain=""/><level2 aid="53" name="西藏自治区" explain=""/><level2 aid="52" name="内蒙古自治区" explain=""/><level2 aid="51" name="宁夏回族自治区" explain=""/><level2 aid="50" name="甘肃省" explain=""/><level2 aid="49" name="云南省" explain=""/><level2 aid="48" name="广西壮族自治区" explain=""/><level2 aid="47" name="广东省" explain=""/><level2 aid="46" name="陕西省" explain=""/><level2 aid="45" name="山西省" explain=""/><level2 aid="44" name="湖南省" explain=""/><level2 aid="43" name="湖北省" explain=""><level3 aid="70" name="枣阳市" explain=""/><level3 aid="61" name="孝感市" explain=""/><level3 aid="60" name="十堰市" explain=""/><level3 aid="59" name="荆州市" explain=""/><level3 aid="58" name="鄂州市" explain=""/><level3 aid="57" name="襄阳市" explain=""><level4 aid="68" name="襄城区" explain=""/><level4 aid="67" name="谷城县" explain=""/></level3><level3 aid="56" name="武汉市" explain=""><level4 aid="86" name="徐东区" explain="我去过"/><level4 aid="85" name="蔡甸区" explain=""/><level4 aid="84" name="江汉区" explain=""/><level4 aid="83" name="江岸区" explain=""/><level4 aid="82" name="青山区" explain=""/><level4 aid="69" name="洪山区" explain=""/><level4 aid="63" name="江汉区" explain=""/></level3></level2></level1></root>
    

    XML平行结构如下

    <?xml version="1.0" encoding="utf-8"?>
    <root><n86><name><![CDATA[徐东区]]></name><pid><![CDATA[56]]></pid><explain><![CDATA[我去过]]></explain></n86><n85><name><![CDATA[蔡甸区]]></name><pid><![CDATA[56]]></pid><explain><![CDATA[]]></explain></n85><n84><name><![CDATA[江汉区]]></name><pid><![CDATA[56]]></pid><explain><![CDATA[]]></explain></n84><n83><name><![CDATA[江岸区]]></name><pid><![CDATA[56]]></pid><explain><![CDATA[]]></explain></n83><n82><name><![CDATA[青山区]]></name><pid><![CDATA[56]]></pid><explain><![CDATA[]]></explain></n82><n81><name><![CDATA[测试区]]></name><pid><![CDATA[78]]></pid><explain><![CDATA[]]></explain></n81><n80><name><![CDATA[开封]]></name><pid><![CDATA[66]]></pid><explain><![CDATA[少林所在地]]></explain></n80><n79><name><![CDATA[洛阳]]></name><pid><![CDATA[66]]></pid><explain><![CDATA[历史名城]]></explain></n79><n78><name><![CDATA[郑州市]]></name><pid><![CDATA[66]]></pid><explain><![CDATA[河南的省会]]></explain></n78><n70><name><![CDATA[枣阳市]]></name><pid><![CDATA[43]]></pid><explain><![CDATA[]]></explain></n70><n69><name><![CDATA[洪山区]]></name><pid><![CDATA[56]]></pid><explain><![CDATA[]]></explain></n69><n68><name><![CDATA[襄城区]]></name><pid><![CDATA[57]]></pid><explain><![CDATA[]]></explain></n68><n67><name><![CDATA[谷城县]]></name><pid><![CDATA[57]]></pid><explain><![CDATA[]]></explain></n67><n66><name><![CDATA[河南省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n66><n63><name><![CDATA[江汉区]]></name><pid><![CDATA[56]]></pid><explain><![CDATA[]]></explain></n63><n61><name><![CDATA[孝感市]]></name><pid><![CDATA[43]]></pid><explain><![CDATA[]]></explain></n61><n60><name><![CDATA[十堰市]]></name><pid><![CDATA[43]]></pid><explain><![CDATA[]]></explain></n60><n59><name><![CDATA[荆州市]]></name><pid><![CDATA[43]]></pid><explain><![CDATA[]]></explain></n59><n58><name><![CDATA[鄂州市]]></name><pid><![CDATA[43]]></pid><explain><![CDATA[]]></explain></n58><n57><name><![CDATA[襄阳市]]></name><pid><![CDATA[43]]></pid><explain><![CDATA[]]></explain></n57><n56><name><![CDATA[武汉市]]></name><pid><![CDATA[43]]></pid><explain><![CDATA[]]></explain></n56><n55><name><![CDATA[贵州省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n55><n54><name><![CDATA[海南省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n54><n53><name><![CDATA[西藏自治区]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n53><n52><name><![CDATA[内蒙古自治区]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n52><n51><name><![CDATA[宁夏回族自治区]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n51><n50><name><![CDATA[甘肃省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n50><n49><name><![CDATA[云南省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n49><n48><name><![CDATA[广西壮族自治区]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n48><n47><name><![CDATA[广东省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n47><n46><name><![CDATA[陕西省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n46><n45><name><![CDATA[山西省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n45><n44><name><![CDATA[湖南省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n44><n43><name><![CDATA[湖北省]]></name><pid><![CDATA[37]]></pid><explain><![CDATA[]]></explain></n43><n42><name><![CDATA[新加坡]]></name><pid><![CDATA[0]]></pid><explain><![CDATA[花园国度]]></explain></n42><n41><name><![CDATA[俄罗斯]]></name><pid><![CDATA[0]]></pid><explain><![CDATA[北极熊]]></explain></n41><n40><name><![CDATA[韩国]]></name><pid><![CDATA[0]]></pid><explain><![CDATA[高丽棒子]]></explain></n40><n39><name><![CDATA[日本]]></name><pid><![CDATA[0]]></pid><explain><![CDATA[小日本]]></explain></n39><n38><name><![CDATA[美国]]></name><pid><![CDATA[0]]></pid><explain><![CDATA[霸权主义国家]]></explain></n38><n37><name><![CDATA[中国]]></name><pid><![CDATA[0]]></pid><explain><![CDATA[伟大的国家]]></explain></n37></root>
    


    优点支持无限极分类,但是访问接口时返回XML树形结构,更利于程序读取!






    展开全文
  • 初遇XML+XSLT结构

    千次阅读 2011-02-25 14:36:00
    XML和XSL简介1.1 XMLXML是可扩展标记语言(EXtensible Markup Language)的缩写,它被设计用来传输和存储数据,并于1998年2月成为W3C的推荐标准。图1-1 XML代码示例上面是一小段XML代码,与HTML最大的区别在于,...

     

     

    XMLXSL简介

    1.1 XML

    XML是可扩展标记语言(EXtensible Markup Language)的缩写,它被设计用来传输和存储数据,并于19982月成为W3C的推荐标准。

    qqe688aae59bbee69caae591bde5908d2

    1-1 XML代码示例

    上面是一小段XML代码,与HTML最大的区别在于,XML被设计为传输和存储数据,其焦点是数据的内容,并且XML的标签是自定义的;而HTML被设计用来显示数据,其焦点是数据的外观。XML是与描述、传输信息相关的,而HTML是与显示信息相关的(资料来源于W3School)。

    1.2 XSL

    XSL是扩展样式表语言(EXtensible Stylesheet Language)的缩写,是一种用于以可读格式呈现 XML 数据的语言。XSL包含XSLTXpathXSL-FO三个部分:XSLT用于转换XML文档,Xpath用于选取XML元素和属性,XSL-FO用于格式化XML文档。

    本文只涉及到XSL里的XSLTXpathXSLT199911月被确立为W3C标准,用于将XML文档转换为HTML、文本或者XML三种类型的文档(本文仅涉及到转换为HTML文档的情况),而XpathXSLT的主要元素之一。XSL-FO就一边寂寞去吧。

    XML+XSLT结构的实现

    XML+XSLT结构输出页面可以理解为,使用XML存储数据,使用XSLT编写页面结构,感觉上像把HTML拆开了。XML文档在组织数据的同时,通过语句调用XSLT页面。在XSLT页面中,HTML语句编写基础结构,Xpath选取XML相应的数据节点,然后通过XSLT语句将这两者结合起来。

    e69caae591bde5908d 

    更为专业的描述是这样的:在转换的过程中,XSLTXpath来定义源文档中与一个或多个预先确定的模板相匹配的部分。当找到了一个匹配时,XSLT就将源文档中的匹配部分转换成结果文档;而源文档中不与任何一个模板匹配的部分最终在结果中保持不变。(摘自developerWorks) 

    2.1 结构示例

    这里使用DNF的一个专题举个例子。此专题的访问地址是:http://dnf.qq.com/act/a20090710wcg/

    这是一个赶工的专题,页面代码没太多的参考性,只是拿出来做个示例,并且由于专题比较简单,XSLT文档只用到了部分XSLT语句,属于简单应用。首页使用的是HTML,因为XML不在默认首页文件格式之列,因此只有二级页采用了XML+XSLT结构。对于其中“代表队介绍”这个二级页面:

    XML文档:http://dnf.qq.com/act/a20090710wcg/players.xml

    XSLT文档:http://dnf.qq.com/act/a20090710wcg/xslt/player.xslhttp://dnf.qq.com/act/a20090710wcg/xslt/commens.xsl

    XMLXSLT是树状结构的,在浏览器中可以看到。XSLT文档中,以”<xsl:”开头的就是XSLT语句,”select”属性里的内容则是Xpath表达式(Xpath表达式不只存在于select属性里),可以看到里面也包含了许多HTML代码。XMLXSLT代码是强制要求闭合。

    其中player.xml文档调用了player.xsl文档,XML文档不做解释了。简述一下XSLT的文档结构含义。

    文档第一排是一条XML声明语句;第二行stylesheet语句声明XSLT版本和命名空间,所有的其他XSLT语句都必须包含在此语句内;第三行是import语句,调用具有公共模块的文档commens.xslcommens.xsl文档包括顶部白色banner条,页面header块,导航,脚部声明四个模块);第四行是output语句,表明将XML文档转换为HTML文件并输出;然后通过template语句建立根模块。紧接着的就是HTML代码了,<body>标签后是一个call-template语句,调用顶部白色banner条。HTML代码就不再解释了。接着的XSLT代码是两个call-template语句,调用HTML页面header块和导航模块。跟着是两个for-each语句循环相同的结构,并通过Xpath选取XML数据,一个循环用于生成“个人赛”资料,另一个用于生成“团队赛”资料,中间有很多value-of语句,用于调用XML相应节点的值。接着是call-template语句,调用脚部声明模块,最后是页面的一些标签闭合。

    XML+XSLT结构的优势

    3.1 数据交换

    XML本身是用于网络上数据交换的语言,我可以调用互联网里的其他XML文件(当然,要经过作者同意),通过编写XSLT或者其他语言脚本(如ActionScriptJavaScript等),变成自己作品上的内容。

    XML 是独立于软件和硬件的信息传输工具,它的简单使其易于在任何应用程序中读写数据。我们在使用XSLT转换XMLHTML的同时,此XML文档还可以被其他各种脚本或开发语言调用。

    3.2 代码大小

    XSLT有个很大的优点是模块化,如同JavaScript里的function一样,需要时调用,同时也可以传递参数。这样,网站各个页面所具有的相同部分(比如导航,版权声明等,甚至可以是HTML里的<head>标签)就可以单独提出来,封装在一个模块内,每个页面的这个部分就可以替换为一条调用对应模块的代码。

    XSLT同时拥有循环语句,可以对代码里相同的结构进行循环(比如litr等),同时遍历应用这个结构的XML数据,避免了因拥有相同结构的数据而重复编写代码。

    XSLT文档可以相互调用,延长了文档的使用寿命,你可以调用以前写过的XSLT来使用里面的模块,不用再次编写,你甚至可以调用别人写过并发布在互联网上的文档(只要作者同意),这样在一定程度上节约了精力和成本。

    XML+XSLT结构大大减少了代码大小,并且随着XML数据量和页面数量的增加而越发明显。当然,数据量大过头对XML不是什么好事。

    3.3 代码维护

    利用XSLT的模块功能,对于页面相同部分的修改变得很简单,不用像以前一样打开N个文件批量替换,我们只需要对XSLT文件的模块代码进行修改。虽然也可以利用JavaScript编写各个页面的相同部分,然后调用,但代码的可读性远远比不上XSLT的模块来得直接。

    利用XSLT的循环代码,修改数据的结构不再变得痛苦。想象当你要把一个庞大的table结构的数据变成li结构时,批量替换已无法满足要求。如果使用XSLT文档,并利用循环代码,你只需要修改一个循环的公共结构就OK了。

    3.4 节约访问资源

    对于现在腾讯的游戏官网,比如首页的各种新闻列表,是使用JavaScript调用的,即服务器接到请求后,再开始从数据库里查找新闻,然后返回。

    我们其实可以换一种方式,即后台事先根据页面需要生成XML文档,并保持每隔一个固定时间更新一次XML文档,然后使用XSLT输出页面,这样就在一定程度上节省了页面下载时间。

    同时,由于后台直接生成XML文档,不再因为N个新闻列表而向服务器发送N个请求,减少了页面的请求数。

    使用XML+XSLT结构的可能性

    4.1 浏览器支持

    几乎所有主要的浏览器均支持 XML + XSLT结构的页面。Firefox1.0.2开始支持XMLXSLTNetscape8.0开始支持XMLXSLTOpera9.0开始支持XMLXSLTIE6.0开始支持XMLXSLTXpath(资料来源于W3School)。

    当然还有SafariChrome,貌似这两个浏览器是支持的(至少我安装的这两个浏览器没发现啥问题)。

    4.2 编写难度

    相对于HTML的编写,XML+XSLT的过程要复杂一些。毕竟要先写好XMLHTMLCSSJavaScript文档,然后再在HTML文档的基础上编写XSLT文档,多个页面还需要根据文档进行模块提取,以便各文档调用。

    从整个过程来看,确实复杂一些,但这个复杂也是“先苦后甜”的写照。完成XSLT文档后,可以节省很多资源,也对以后的维护有很大的好处。

    4.3 后台开发

    需要程序员将数据库里的数据按页面需要导出为相应的XML文件,或者直接使用XML存储数据(但比如新闻之类的信息数量很庞大,使用XML直接存储数据会降低效率)。各种开发语言都能将数据库中的数据输出为XML文档,相信难度不大。

    4.4 竞争

    XSLT当然不是唯一能转换XML文档的方式,其他语言脚本也可以实现与XSLT相同的功能。但是,其他语言脚本的使用远不及XSLT来的直接。XSLT可以直接使用HTML元素,并且可以使用Xpath很直观的选取XML文档节点。而且在XML+XSLT结构中,XML文档的调用很方便,只需在XML文档里写一条xml-stylesheet调用语句。

    4.5 SEO

    这可能是XML+XSLT结构最郁闷的地方了,网上貌似还没有使用此结构替换HTML对于SEO影响的定论。但各种迹象表明,使用XML+XSLT结构会在一定程度上对SEO造成不良的影响。

    4.6 适用性偏向

    由于XML本身是作为描述和传输信息的文档,注定了XML+XSLT结构更适合于信息展示类的页面,比如新闻,相册等,所以游戏官网很适合使用此结构来完成。而功能性较多的页面就不适合使用此结构,比如注册,发布系统等。

    暴雪公司的所有游戏官网均采用XML+XSLT结构。

    星际争霸2http://www.starcraft2.com/

    魔兽世界:http://www.worldofwarcraft.com/

    暗黑破坏神3http://www.blizzard.com/diablo3/

    综上所述

    XML+XSLT结构目前并不流行,虽然XML已广泛应用,但XSL由于各种原因并未能普及。对于腾讯的游戏官网建设,由于首页的各类信息调用涉及到很多产品或系统的接口,而广告和新闻也是还是使用JavaScript调用的方式生成,XML+XSLT结构的全面应用在短期来看是不大可能的,目前也只有用于纯静态的图片视频展示,资料站等。XML+XSLT结构的普及任重而道远。

    才疏学浅,个人愚见,仅供亵玩。

     

    以下为自己调试的代码

    XMLTest.xml 页面

     

    <?xml version="1.0" encoding="gb2312" ?>

    <?xml-stylesheet type="text/xsl" href="XsLTTest.xslt"?>

    <languages>

      <languages_charset>gb2312</languages_charset>

      <Reset>重填</Reset>

      <Submit>提交</Submit>

      <Password>密码</Password>

      <ID>用户名</ID>

    </languages>

    XsLTTest.xslt 页面

     

    <?xml version="1.0" encoding="utf-8"?>

    <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

        xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"

    >

      <xsl:output method="html" encoding="gb2312" omit-xml-declaration="yes" indent="yes" standalone="yes"/>

      <xsl:template match="/">

     

        <html>

          <META http-equiv="Content-Type" content="text/html;">

            <xsl:attribute name="charset">

              <xsl:value-of select="languages/languages_charset"/>

            </xsl:attribute>

          </META>

          <body>

            <table cellspacing="2" cellpadding="2" border="0">

              <tr>

                <td>

                  <xsl:value-of select="languages/ID" />

                </td>

                <td>

                  <input type="text"/>

                </td>

              </tr>

              <tr>

                <td>

                  <xsl:value-of select="languages/Password" />

                </td>

                <td>

                  <input type="text"/>

                </td>

              </tr>

              <tr>

                <td>

                  <input type="submit" >

                    <xsl:attribute name="value">

                      <xsl:value-of select="languages/Submit" />

                    </xsl:attribute>

                  </input>

                </td>

                <td>

                  <input type="reset" >

                    <xsl:attribute name="value">

                      <xsl:value-of select="languages/Reset" />

                    </xsl:attribute>

                  </input>

                </td>

              </tr>

            </table>

          </body>

        </html>

     

      </xsl:template>

    </xsl:stylesheet>

     

     

    最后用浏览器直接查看XMLTest.xml 就可以看到效果了

     

     

     

    展开全文
  • 关于Python使用xml.etree.ElementTree解析 项目是用于解析xml一个子标签,提取数据,用于创建数据 解析结构类似于这样现在提取的是table_info里面的数据。 table_info数据结构如下 最外层table_info 里面又嵌套了一...
  • 网上有很多Dom4j 解析xml的java代码,但是都忒简单了啊! 关键是大多都是知道xml嵌套了几层的情况下,但是大多数时候都没有那么简单啊! 先贴一个简单的方法,附上解析用的简单xml<?xml version="1.0" encoding=...
  • XML Code  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 3...
  • UI基础-XML、JSON 数据结构解析

    千次阅读 2015-12-02 22:52:41
    数据获取方则按照格式获取数据 iOS开发常见的解析:XML解析、JSON解析XML数据结构XML基本概念XML:Extensible Markup language(可扩展标记语言),主流数 据格式之一,可以用来存储和传输数据。XML数据格式的功能数据交换...
  • xml

    千次阅读 2012-08-01 07:03:02
    XML---可扩展标记语言 第一部分:XML语言介绍 什么是 XML? · XML 指可扩展标记语言(EXtensible Markup Language) · XML 是一种标记语言,很类似 HTML · XML 的设计宗旨是传输数据,而非显示数据 ·...
  • 文件连接2、DocumentSource选项:指定XML文件路径3、EnumerationType选项:NodeText4、OuterXPathStringSourceType选项:直接输入5、OuterXPathString选项:MonthList/Month(XML元素结构
  • XML基础

    千次阅读 2017-03-19 15:32:10
    标准、简洁、结构严谨、可扩展性高的XML应运而生。在推出之初,XML提供通用数据交换、改变Web发布、改变分布式计算的功能。如今,XML不仅对软件开发的各个方面都产生了巨大影响,而且在各行各业都得到了充分应用。...
  • 因此这里介绍一种开源项目JDOM来解析和生成xml,它基于树型结构,利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性(方法重载、集合...
  • Qt 之 XML

    万次阅读 2016-10-13 13:53:41
    简述XML 指可扩展标记语言(eXtensible Markup Language),是一种用于记录多种数据类型的标记语言。使用 XML 可以将各类型的文档定义为容易读取的格式,便于用户读取。而且,在应用程序中使用 XML,可以轻松实现...
  • 首先import xml.etree.cElementTree as et来看XML格式<?xml version="1.0" encoding="UTF-8"?> <File xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="FileFormat.xsd"> ...
  • win10 uwp 读写XML

    千次阅读 2017-05-02 08:59:43
    UWP 对 读写 XML做了一些修改,但和...XML 其实是 树结构,可以表达复杂的结构,所以在定制要求高的、或其他方面如json 做不到的结构,那么一般就使用XML,如果XML的数据结构都做不到,那么基本上也难找到其他的结构
  • 现有两个结构一样,但部分节点内容不同的XML文件,需要根据一个XML的ID节点,覆盖另一个XML节点内容.XML结构如下 3b226203-f535-4bdd-bedf-0e42503d613d.usx 118.0850858401120900,24.4822235205172980,-...
  • XML

    千次阅读 2016-05-09 21:13:20
    XML DOM(XML Document Object Model)定义了访问和操作 XML 文档的标准方法,XML DOM 把 XML 文档作为树结构来查看。 所有元素可以通过 DOM 树来访问。可以修改或删除它们的内容,并创建新的元素。元素,它们...
  • xslt 转换XML TO XML

    千次阅读 2011-01-12 14:24:00
    xslt 转换XML TO XML

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 109,880
精华内容 43,952
关键字:

xml循环结构