Le typage orienté objet pour les données XML

Le typage orienté objet pour les données XML
XML schema Le typage orienté objet pour les données XML

Plan Schema ? Les applications Classer les éléments
Types simples prédéfinis Les types simples Création de nouveaux types Création de types complexes Groupes d'éléments et d'attributs Les espaces de noms

Nous apprendrons à valider un doc xml
<?xml version="1.0"?> <note xmlns=" xmlns:xsi=" xsi:schemaLocation=" note.xsd"> <to> dupont</to> <from>bob</from> <heading> XMLSchema</heading> <body> Pas mal ! </body> </note>

Vérification

Edition

JAXB Découvrir l'API JAXB.

Types simples prédéfinis Les types simples Création de nouveaux types Création de types complexes Les espaces de noms

introductions Les applications de XML Schéma
la validation : recevoir un document conforme avant de le stocker validation structurelle validation des données la documentation : documente le vocabulaire XML de façon concise. l'édition structurée : guide de saisie JAXB

XML schéma XML schéma formalise
les contraintes de types (feuilles du document) les structures des instances XML (les branches de l'arbre) On distinguera les types simples qui ne concernent que les feuilles de l'arbre. Ils servent à la construction de composants plus complexes (approche modulaire) les types complexes qui forment la définition même de la structure de l'arbre

Plan Schema ? Les applications Classer les éléments Modèle de contenu

Classer les éléments Modèle de contenu
le modèle de contenu d'un élément décrit la structure de ses enfants et les nœuds textuels autorisés. On distingue contenu vide contenu simple contenu mixte contenu complexe les commentaires, attributs et instructions de traitement sont ignorés.

Classer les éléments : le contenu vide
Modèle de contenu le contenu vide un élément à un modèle de contenu vide quand il n'a ni nœud textuel enfant sous élément avec ou sans attribut. exemple Un élément n'ayant que des attributs, un commentaire et des instructions de traitement sera considéré comme "a contenu vide".

Classer les éléments : le contenu simple :
Modèle de contenu le contenu simple : il n'y a qu'un nœud textuel. Les attributs sont toujours de type simple (le contenu est textuel) exemple <title lang="en"> Being a Dog Is a Full-Time Job </title> <name> Charles M Schulz </name> <born> </born>

Classer les éléments Modèle de contenu
Un modèle de contenu simple est de type simple si il n'a aucun attribut et de type complexe si il en a. exemple <title lang="en"> Being a Dog Is a Full-Time Job </title> <name> Charles M Schulz </name> <born> </born>

Classer les éléments : le contenu mixte
Modèle de contenu le contenu mixte un élément à un modèle de contenu mixte quand il contient à la fois des sous-éléments et des nœuds textuels enfants.

Classer les éléments : le contenu complexe
Modèle de contenu le contenu complexe un élément à un modèle de contenu complexe quand ses seuls enfants sont des nœuds éléments il n'y a pas de nœud textuel exemple <character id="Lucy"> <name> Lucy </name> <born> </born> <qualification> bossy, crabby and selfish </qualification> </character>

Types simples prédéfinis
La recommandation XML Schema fournit des types de données prédéfinis La recommandation distingue les données écrites dans une instance de document, dit espace lexical, de leurs valeurs logiques obtenues en mémoire après considération de leurs types, on parle d'espace de valeurs. Chaque type de données a son propre espace lexical et son espace de valeurs. une valeur peut avoir plusieurs représentations lexicales. E1 Les formes lexicales seront égales si le type est xs:float mais pas si c'est le type xs:string.

traitement sur les types de données
traitement en deux étapes la normalisation : consiste à remplacer toutes les occurrences des caractères tabulations (#x9), nouvelle ligne (#xA), retour chariot (#xD) et espace blanc (#x20) entre l'espace normalisé et l'espace lexical par des blancs. Le compactage Retire tous les blancs d'entête et de queue, et toute série contiguë de blanc par 1 seul blanc.

Les types de chaînes de caractères
xs:string la normalisation des blancs n'est pas faite. la forme lexicale <title lang="en"> Being a Dog Is a Full-Time Job </title> La forme logique (conserve toutes ses tab, blancs et CR) Being a Dog Is a Full-Time Job

Les types de chaînes de caractères
xs:normalizedString la normalisation des blancs est faite sans compactage. la forme lexicale <title lang="en"> Being a Dog Is a Full-Time Job </title> La forme logique Being a Dog Is a Full-Time Job

Les types compactés On supprime les blancs de têtes et de queue et séries d'espace blancs unités lexicale format binaire URI nom qualifié notation

Les unités lexicales xs:token version compactée de xs:normalizedString
la forme lexicale <title lang="en"> Being a Dog Is a Full-Time Job </title> La forme logique Being a Dog Is a Full-Time Job

Les unités lexicales xs:NMTOKEN série de caractères sans blanc
Snoopy bold,brash (pas de virgule)

Les unités lexicales xs:Name
idem que NMTOKEN et commence par un caractère Snoopy bold,brash (pas de virgule) xs:NCName pas de : _ :10-00 xs:ID xs:NCNAME unique

Les noms qualifiés xs:QName
ensemble de tuples (nom de l'espace de noms,partie locale) la déclaration <xs:attribute name="lang" type="xs:language"/> attribue à l'attribut lang le type lexicale xs:language qui est un xs:QName dont la valeur logique est le tuple : {" "language"} parce qu'une déclaration a associé l'URI " au préfixe xs:. Sans celle-là, la déclaration de l'attribut type aurait été considérée comme invalide.

Les URIs xs:anyURI Cas de chaîne de caractère dont l'espace lexical est différent de l'espace des valeurs. <a href=" Word/Français </a>

Les notations xs:NOTATION
Equivalent au concept de notation de XML1.0, utilisé au travers un type personnalisé dérivé

Les Types numériques xs:décimal xs:integer
xs:nonPositiveInteger (0) xs:negativeInteger xs:nonNegativeInteger (0) xs:positiveInteger xs:long xs:int xs:sort xs:byte xs:float xs:double xs:boolean

Les types date et heures
xs:datetime xs:date xs:gYear

Les types listes Des listes d'items délimitées par des séparateurs.
listes prédéfinies xs:NMTOKENS xs:IDREFS XS:ENTITIES

Création d'un schéma <xs:schema xmlns:xs=" </xs:schema>

Les types Il existe deux types d'éléments type simple
contenu simple sans attribut type complexe Les autres !

Les types simples <name> Charles M Schulz </name>
<xs:element name="name" type="xs:string"/> <born> </born> <xs:element name="born" type="xs:date"/> <isbn> </isbn> <xs:element name="isbn" type="xs:integer"/>

Types simples prédéfinis Les types simples Création de nouveaux types simples dérivation Création de types complexes Les espaces de noms

Création de nouveaux types
Dérivation action de définir un type en partant de la définition d'un ou de plusieurs types. les types simples peuvent être dérivés par restriction (ajout de nouvelles contraintes) liste union (union de l'espace lexicaux des types membres) Les types complexes sont dérivés par restriction extension

Création de nouveaux types
un type simple est une contrainte posée sur la valeur terminale d'un élément ou d'un attribut. C'est une caractéristique que l'on peut partagée entre + documents. Un type complexe représente la définition d'un modèle de contenu, souvent spécifique à une classe de document. Les méthodes de dérivation entre type simple et complexe seront différentes.

Dérivation par listes Dérivation
action de définir un type en partant de la définition d'un ou de plusieurs types. les types simples peuvent être dérivés par restriction (ajout de nouvelles contraintes) liste union (union de l'espace lexicaux des types membres)

Création de types simples : restriction
Dérivation par restriction Les nouveaux types sont créés par restriction en ajoutant de nouvelles contraintes. C'est la méthode utilisée par W3C pour de nombreux types prédéfinis Les restrictions peuvent êtres définis suivants plusieurs axes ou facettes

Restriction <xs:simpleType name="myInteger">
<xs:restriction base="xs:integer"> <xs:minInclusive value="-2"/> <xs:maxExclusive value="5"/> </xs:restriction> </xs:simpleType> xs:minInclusive est une facette du type xs:integer. Elle précise les valeurs minimales.

Les facettes elles peuvent êtres classées en trois catégories
xs:whiteSpace (type xs:string xs:normalizedString) xs:pattern qui ne s'applique qu'à l'espace lexical les autres qui s'appliquent à l'espace des valeurs La disponibilités des facettes et leurs effets dépendent des types auxquels elles sont appliquées.

Facettes : cas des chaînes de caractères compactées
Les types concernés : xs:ENTITY, xs:ID; xs:IDREF, xs:language, xs:Name, xs:NCName; xs:NMTOKEN, xs:token, xs:anyURI, xs:base64Binary, xs:hexBinary, xs:NOTATION, xs:QName xs:enumeration xs:length xs:maxlength xs:minlength xs:pattern

Chaînes xs:enumeration
Permet de spécifier la liste des valeurs autorisées <xs:simpleType name="schemaRecommendations"> <xs:restriction base="xs:anyURI"> <xs:enumeration value=" <xs:enumeration value=" <xs:enumeration value=" </xs:restriction> </xs:simpleType>

Chaînes xs:length Permet de spécifier une longeur mesurée en nombre de caractères <xs:simpleType name="standardNotations"> <xs:restriction base="xs:NOTATION"> <xs:length value="8"/> </xs:restriction> </xs:simpleType>

Chaînes xs:maxlength, minlength
Permet de définir la longueur maximum (minimum) mesurée en nombre de caractères <xs:simpleType name="longName"> <xs:restriction base="xs:NCName"> <xs:minLength value="6"/> </xs:restriction> </xs:simpleType>

Chaînes xs:pattern définit un motif auquel doit correspondre la chaîne de caractères <xs:simpleType name="CapitalizedNameWS"> <xs:restriction base="xs:token"> <xs:pattern value="([A-Z]([a-z]*) ?)+"/> </xs:restriction> </xs:simpleType>

Flottants xs:enumeration
<xs:simpleType name="enumeration"> <xs:restriction base="xs:float"> <xs:enumeration value="-INF"/> <xs:enumeration value=" "/> <xs:enumeration value="3e3"/> </xs:restriction> </xs:simpleType> <enumeration> 3e3 </enumeration> <enumeration> </enumeration> ont des valeurs lexicales différentes mais représentent la même valeur logique.

Flottants : maxExclusive
<xs:simpleType name="maxExclusive"> <xs:restriction base="xs:float"> <xs:maxExclusive value="10"/> </xs:restriction> </xs:simpleType>

Flottant : MaxInclusive
<xs:simpleType name="thousands"> <xs:restriction base="xs:double"> <xs:maxInclusive value="1e3"/> </xs:restriction> </xs:simpleType>

Flottant : minExclusive
<xs:simpleType name="strictlyPositive"> <xs:restriction base="xs:double"> <xs:minExclusive value="0"/> </xs:restriction> </xs:simpleType>

Flottant : minInclusive
<xs:simpleType name="positive"> <xs:restriction base="xs:double"> <xs:minInclusive value="0"/> </xs:restriction> </xs:simpleType>

Flottant : pattern <xs:simpleType name="noLeading0">
<xs:restriction base="xs:float"> <xs:pattern value="[^0].*"/> </xs:restriction> </xs:simpleType> La facette xs:pattern agit directement sur l'espace lexical du type de données. la facette interdit les zéro en entête.

Cas des types entiers S'applique à
xs:byte, xs:int, xs:integer, xs:long, xs:negativeInteger, xs:nonNegativeInteger, xs:nonPositiveInteger, xs:positiveInteger, xs:short, xs:unsignedByte, xs:unsignedInt, xs:unsignedLong, xs:unsignedShort

Entier : xs:totalDigits
<xs:simpleType name="totalDigits"> <xs:restriction base="xs:integer"> <xs:totalDigits value="5"/> </xs:restriction> </xs:simpleType> Cette facette n'autorise que les entiers ayant au max 5 chiffres

entier : xs:fractionDigits
<xs:simpleType name="fractionDigits"> <xs:restriction base="xs:decimal"> <xs:fractionDigits value="2"/> </xs:restriction> </xs:simpleType> Cette facette spécifie le nombre de chiffres après la virgule.

Restrictions multiples et attribut
Cas général : Facette plus restrictive, <xs:simpleType name="minInclusive"> <xs:restriction base="xs:float"> <xs:minInclusive value="10"/> </xs:restriction> </xs:simpleType> on ne doit pas étendre l'espace des valeurs du type de base. <xs:simpleType name="minInclusive2"> <xs:restriction base="minInclusive"> <xs:minInclusive value="0"/> facette xs:lenght ne peut être redefinie Seule la facette xs:lenght

Facette faisant l'intersection de deux espaces lexicaux <xs:simpleType name="nonScientific"> <xs:restriction base="xs:float"> <xs:pattern value="[^eE]*"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="noScientificNoLeading0"> <xs:restriction base="nonScientific"> <xs:pattern value="[^0].*"/>

Facette appliquée avant l'espace lexical <xs:simpleType name="greetings"> <xs:restriction base="xs:string"> <xs:whiteSpace value="replace"/> <xs:enumeration value="hi"/> <xs:enumeration value="hello"/> <xs:enumeration value="how do you do?"/> </xs:restriction> </xs:simpleType> Permet que d'étendre l'ensemble des instances acceptées. <xs:simpleType name="restricted-greetings"> <xs:restriction base="greetings"> <xs:whiteSpace value="collapse"/>

Facette fixée l'attribut fixed sert à bloquer les modifications de la facette. C'est la méthode utilisée pour créer les types prédéfinis de la recommandation XML schéma. <xs:simpleType name="integer" id="integer"> <xs:restriction base="xs:decimal"> <xs:fractionDigits value="0" fixed="true"/> </xs:restriction> </xs:simpleType> ne s'applique pas à xs:enumeration et xs:pattern

Dérivations par listes
La dérivation par listes est un mécanisme permettant d'obtenir un type liste à partir d'un type atomique. Les types prédéfinis IDREFS, ENTITIES et NMTOKENS sont obtenus en utilisant cette méthodes. il existe deux types d'écriture référencée par la définition embarquée dans la définition pas de listes de listes

Dérivation par listes Référencée par la définition, la référence au type de base se fait par l'attribut itemType <xs:simpleType name="integerList"> <xs:list itemType="xs:integer"/> </xs:simpleType> Embarquement un élément xs:simpleType <xs:simpleType name="myIntegerList"> <xs:list> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:maxInclusive value="100"/> </xs:restriction> </xs:list> sert pour des attribut ou éléments dont le contenu sera une série de nombre entiers plus petits à 100 séparés par un blanc :

Espace de valeurs Les types listes disposent de leur propre espace de valeurs qui peut être contraint en utilisant les facettes xs:length, xs:maxLength, xs:minLength, xs:enumeration et xs:whiteSpace L'application se fait en deux temps définition de la liste restriction par contrainte

Espace de valeurs Exemple : <xs:simpleType name="myStringList">
<xs:list itemType="xs:string"/> </xs:simpleType> <xs:simpleType name="myRestrictedStringList"> <xs:restriction base="myStringList"> <xs:maxLength value="10"/> </xs:restriction> Création de la liste Contrôle du nombre

Dérivation par l'union permet de définir des types de données en fusionnant les espaces lexicaux de plusieurs autres types. deux méthodes utilisent l'élément xs:union référencement d'un type de base embarquement une définition propre

Dérivation par l'union <xs:simpleType name="integerOrData">
<xs:union memberTypes="xs:integer xs:date"/> </xs:simpleType> <xs:simpleType name="myIntegerUnion"> <xs:union> <xs:simpleType> <xs:restriction base="xs:integer"/> <xs:restriction base="xs:NMTOKEN"> <xs:enumeration value="undefined"/> </xs:restriction> </xs:union>

Types simples prédéfinis Les types simples Création de nouveaux types Création de types complexes Contenus simples Contenus complexes Contenus mixtes Contenus vides Les espaces de noms Dérivation par extension Dérivation par restriction

Création de types complexes
Contenus simples Un élément a un modèle de contenu simple quand il n'a qu'un noeud textuel (et aucun sous élément). Contenus complexes contenus mixtes Contenus vides complexType : simpleContent

Création : Contenus simples
Un modèle de contenu simple est de type simple si il n'a aucun attribut et de type complexe si il en a un. Création des types complexes à contenus simples = des éléments avec des attributs et un contenu purement textuel très proche des extensions de type simple complexType : simpleContent

Contenus simples exemple :
<xs:element name="title"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute ref="lang"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> L'élément de nom title est complexe son contenu est de type simple c'est une extension du type prédéfini xs:string obtenue en ajoutant l'attribut lang à sa définition exemple : <title lang="en"> Being a Dog Is a Full-Time Job </title> complexType : simpleContent

Types simples prédéfinis Les types simples Création de nouveaux types Création de types complexes Contenus simples Contenus complexes Contenus mixtes Contenus vides Les espaces de noms Dérivation par extension Dérivation par restriction complexType : simpleContent

Dérivation des modèles de contenu simples
Dérivation du contenu simple à partir du type de base Dérivation par extension : ajoute uniquement des nouveaux attributs Dérivation par restriction : forme plus puissante, elle restreint le type du contenu textuel et des attributs du modèle de base et permet d'exclure les attributs du modèle de base inutiles dans la forme dérivées.

Définition d'un type <xs:complexType name="tokenWithLang">
<xs:simpleContent> <xs:extension base="xs:token"> <xs:attribute ref="lang"/> // ajout d'un attribut </xs:extension> </xs:simpleContent> </xs:complexType> <xs:element name="title" type="tokenWithLang"/> // ref au type complexType : simpleContent

Dérivation par extension
<xs:element name="title"> <xs:complexType> <xs:simpleContent> <xs:extension base="tokenWithLang"> <xs:attribute name="note" type="xs:token"/> // ajout d'un attribut </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> Méthode de dérivation identique à celle vue précédemment complexType : simpleContent

Dérivation par restriction
Définition d'un type : <xs:complexType name="tokenWithLangAndNote"> <xs:simpleContent> <xs:extension base="xs:token"> <xs:attribute name="lang" type="xs:language"/> <xs:attribute name="note" type="xs:token"/> </xs:extension> </xs:simpleContent> </xs:complexType> complexType : simpleContent

Méthode similaire à la dérivation par restriction des types simples (sauf qu'elle touche à la fois le contenu textuel et les attributs) Les facettes portant sur le contenu textuel sont suivies des règles de restriction portant sur les attributs le type des attributs peut être changé les attributs peuvent être proscrits

Restriction de la longueur <xs:element name="title"> <xs:complexType> <xs:simpleContent> <xs:restriction base="tokenWithLangAndNote"> <xs:maxLength value="255"/> </xs:restriction> </xs:simpleContent> </xs:complexType> </xs:element> complexType : simpleContent

Proscription d'un attribut <xs:element name="title"> <xs:complexType> <xs:simpleContent> <xs:restriction base="tokenWithLangAndNote"> <xs:maxLength value="255"/> <xs:attribute name="lang" type="xs:language"/> <xs:attribute name="note" use="prohibited"/> </xs:restriction> </xs:simpleContent> </xs:complexType> </xs:element> complexType : simpleContent

Restreindre le type de l'attribut lang <xs:element name="title"> <xs:complexType> <xs:simpleContent> <xs:restriction base="tokenWithLangAndNote"> <xs:maxLength value="255"/> <xs:attribute name="lang"> <xs:simpleType> <xs:restriction base="xs:language"> <xs:enumeration value="en"/> <xs:enumeration value="es"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:simpleContent> </xs:complexType> </xs:element> Restriction des langues directement sur l'attribut : lang complexType : simpleContent

Création de types complexes
Contenus simples Contenus complexes un élément a un contenu complexe quand ses seuls enfants sont des nœuds éléments Contenus mixtes Contenus vides

Création : Contenus complexes
Un connecteur est un conteneur qui permet de manipuler un groupe d'éléments comme un tout et en définit l'ordre relatif xs:sequence xs:choice xs:all Les connecteur peuvent être imbriqués on dispose d'indicateurs d'occurrences minOccurs et maxOccurs pour indiquer le nombre d'occurrences autorisées du groupe dans les instances du document. complexType

Connecteurs : comment exprimer ?
<first-name> </first-name> <last-name> </last-name> <first-name> </first-name> <middle-name> </middle-name> <last-name> </last-name> <name> Snoopy </name>

Connecteurs : sequence
<xs:element name="author"> <xs:complexType> <xs:sequence> <xs:choice> <xs:element ref="name"/> <xs:element ref="first-name"/> <xs:element ref="middle-name" minOccurs="0"/> <xs:element ref="last-name"/> </xs:sequence> </xs:choice> <xs:attribute ref="id"/> </xs:complexType> </xs:element> <first-name> </first-name> <middle-name> </middle-name> <last-name> </last-name> ou <name> Snoopy </name>

Groupes d'éléments et d'attributs
Les groupes sont des ensembles étiquetés permettant de manipuler des éléments ou des attributs en bloc. Ces groupes sont réutilisables à différents endroits d'un schéma. Etapes à suivre : Définition (nommée et globale) du groupe d'éléments Utilisation du groupe comme particule à l'intérieur de connecteurs via l'élément xs:group et l'attribut ref

Définition : groupe d'éléments
<xs:group name="name"> <xs:choice> <xs:element ref="name"/> <xs:sequence> <xs:element ref="first-name"/> <xs:element ref="middle-name" minOccurs="0"/> <xs:element ref="last-name"/> </xs:sequence> </xs:choice> </xs:group> complexType

Définition : groupe d'attributs
<xs:attributeGroup name="bookAttributes"> <xs:attribute name="id" type="xs:ID"/> <xs:attribute name="available" type="xs:boolean"/> </xs:attributeGroup> complexType

Utilisation : groupe d'éléments et d'attributs
<xs:element name="author"> <xs:complexType> <xs:sequence> <xs:group ref="name"/> <xs:element ref="born"/> <xs:element ref="dead" minOccurs="0"/> </xs:sequence> <xs:attribute ref="id"/> </xs:complexType> <xs:attributeGroup ref="bookAttributes"/> </xs:element> complexType

Contenus complexes xs:all
Un connecteur est un conteneur qui permet de manipuler un groupe d'éléments comme un tout et en définit l'ordre relatif xs:sequence xs:choice xs:all Les connecteur peuvent être imbriqués on dispose d'indicateurs d'occurrences minOccurs et maxOccurs pour indiquer le nombre d'occurrences autorisées du groupe dans les instances du document. complexType

Limitations des modèles de contenu non ordonnés
Les modèles de contenu non ordonnés sont ceux qui n'imposent aucun ordre d'apparition à leurs sous-éléments. Son utilisation fait l'objet de nombreuses limitations pour assurer des contenu déterministes. xs:all n'a qu'un rôle de connecteur ne peut être utilisé comme particule une seule occurrence est autorisée seul xs:element est autorisé dans xs:all avec comme contrainte d'occurrence 0 ou 1. Des méthodes de contournement sont possibles.

Types simples prédéfinis Les types simples Création de nouveaux types Création de types complexes Contenus simples Contenus complexes Contenus mixtes Contenus vides Les espaces de noms Dérivation par extension Dérivation par restriction complexType

Dérivation des modèles de contenu complexe
Dérivation par extension ajout de nouvelles particules. Un contenu conforme au type de base ne le sera pas forcément par rapport au type complexe étendu. Dérivation par restriction s'applique à la totalité des instances de ce type et les structures restreintes sont obligatoirement conformes à celle du type complexe de base pas de retour en arrière

Dérivation par extension cette méthode est similaire à celle utilisée pour le type complexes à contenu simple. La dérivation se fait en ajoutant de nouveaux éléments et attributs par rapport au type de base. Cela revient à créer une séquence (au moyen du connecteur xs:sequence) composée du modèle de base suivi du nouveau. 29

Exemple : Extension ajout d'un élément
<xs:complexType name="basePerson"> <xs:sequence> <xs:element ref="name"/> <xs:element ref="born"/> </xs:sequence> <xs:attribute ref="id"/> </xs:complexType> <xs:element name="author"> <xs:complexType> <xs:complexContent> <xs:extension base="basePerson"> <xs:sequence> <xs:element ref="dead" minOccurs="0"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> 29 ajout d'un élément

Dérivation par Restriction cette dérivation est une diminution du nombre d'instances conformes au modèle de base. la dérivation s'effectue en redéfinissant la totalité du modèle de contenu qui doit être une restriction logique du modèle de base.

"Qualification" supprimé
restriction <xs:complexType name="person"> <xs:sequence> <xs:element ref="name"/> <xs:element ref="born"/> <xs:element ref="dead" minOccurs="0"/> <xs:element ref="qualification" minOccurs="0"/> </xs:sequence> <xs:attribute ref="id"/> </xs:complexType> <xs:element name="author"> <xs:complexType> <xs:complexContent> <xs:restriction base="person"> <xs:sequence> <xs:element ref="name"/> <xs:element ref="born"/> <xs:element ref="dead" minOccurs="0"/> </xs:sequence> </xs:restriction> </xs:complexContent> </xs:complexType> </xs:element> "Qualification" supprimé

Types simples prédéfinis Les types simples Création de nouveaux types Création de types complexes Contenus simples Contenus complexes Contenus mixtes Contenus vides Les espaces de noms complexType

Contenus mixtes Un élément a un modèle de contenu mixte quand il contient à la fois des sous-éléments et des nœuds textuels enfants. ajout de l'attribut mixed de l'élément xs:complexType 39

contenu mixte <xs:complexType name="markedText" mixed="true">
<xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="em" type="xs:token"/> <xs:element ref="a"/> </xs:choice> <xs:attribute ref="lang"/> </xs:complexType> <xs:element name="title" type="markedText"/> <title lang="en"> Being a <a href=" Dog </a> Is a <em> Full-Time </em> Job </title>

Dérivation des modèles de contenu mixtes
extension à partir d'autres types complexes à contenu complexe restriction même méthode que celle des contenu complexes. Chaque particule doit être une dérivation explicite de sa particule correspondante dans le modèle de base.

Contenus vides ne disposent que des attributs.

Déclaration des espaces de noms
<library xmlns=" <book id="b " available="yes"> <isbn> .../... </book> </library> <xs:schema targetNamespace=" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:lib=" xmlns:xs=" </xs:schema> attributs de l'élément schéma définitions des préfixes

Elément : "qualified" Un élément ou un attribut est dit "qualified" s'il appartient à un espace de noms et "unqualified" s'il appartient à aucun espace de noms. la distinction entre un élément qualifié ou non qualifié est faite sur l'attribut des éléments ou des attributs "form". <xs:element name="book" form="qualified"/> <xs:attribute name="isbn" form="qualified"/> <xs:element name="character" form="unqualified"/> La valeur par défaut des attributs form sont définis par : elementFormDefault= attributeFormDefault= de l'élément xs:schema, par défaut la valeur est "unqualified".

Définition des espaces de noms
<xs:schema targetNamespace=" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:lib=" xmlns:xs=" .../... </xs:schema> On associe xs à l'espace de noms W3C XMLSchema

<xs:schema targetNamespace=" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:lib=" xmlns:xs=" .../... </xs:schema> On associe lib à l'espace de noms W3C XMLSchema : c'est l'espace de noms dans notre instance de document. Cette déclaration est utile pour résoudre les références des composants du schéma (datatype, elements, … pour les expressions Xpath) ex : <xs:element name="person"> <xs:element ref="lib:person">

<xs:schema targetNamespace=" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:lib=" xmlns:xs=" .../... </xs:schema> Indique quel espace de noms ce schema décrit. On utilise l'attribut targetNamespace

Différentes écritures
<?xml version="1.0"?> <xs:schema targetNamespace=" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:lib=" xmlns:xs=" <xs:element name="library"> <xs:complexType> <xs:sequence> <xs:element name="book" type="lib:bookType"/> </xs:sequence> </xs:complexType> </xs:element> <xs:complexType name="bookType"> pas de confusion possible lors de la définition car définit des éléments appartenant au targetN lib : utilisé pour les cross ref ref : W3C

Autre écriture <?xml version="1.0"?>
<schema targetNamespace=" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns=" xmlns:lib=" <element name="library"> <complexType> <sequence> <element name="book" type="lib:bookType"/> </sequence> </complexType> </element> <element name="person"> pas de ns car W3C est le NS par défaut

Autre écriture <xs:schema targetNamespace=" elementFormDefault="qualified" attributeFormDefault="unqualified" xmlns:xs=" xmlns=" <xs:element name="library"> <xs:complexType> <xs:sequence> <xs:element name="book" type="bookType"/> </xs:sequence> </xs:complexType> </xs:element> <xs:complexType name="bookType"> pas de lib car Library est le NS par défaut

OEF JAXB

<complexType abstract = boolean : false block = (#all | List of (extension | restriction)) final = (#all | List of (extension | restriction)) id = ID mixed = boolean : false name = NCName {any attributes with non-schema namespace . . .}> Content: (annotation?, (simpleContent | complexContent | ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)))) </complexType>

Le typage orienté objet pour les données XML

Présentations similaires

Présentation au sujet: "Le typage orienté objet pour les données XML"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Le typage orienté objet pour les données XML

Présentations similaires

Présentation au sujet: "Le typage orienté objet pour les données XML"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back