Quelles sont les meilleures pratiques pour la conception de schémas XML?
En tant que développeur de logiciels amateur (je suis toujours dans les milieux universitaires), j'ai écrit quelques schémas pour les documents XML. Je rencontre régulièrement des problèmes de conception qui génèrent des documents XML très laids, car je ne suis pas tout à fait certain de la sémantique exacte de XML.
Mes hypothèses:
<property> value </property>
propriété = valeur
<property attribute="attval"> value </property>
Une propriété avec un descripteur spécial, l'attribut.
<parent>
<child> value </child>
</parent>
Le parent a une caractéristique "enfant" qui a la valeur "valeur".
<tag />
"Tag" est un drapeau ou traduit directement en texte. Je ne suis pas sûr sur celui-ci.
<parent>
<child />
</parent>
"enfant" décrit "parent". "enfant" est un drapeau ou un booléen. Je ne suis pas sûr sur celui-ci non plus.
L'ambiguïté se pose si vous voulez faire quelque chose comme représenter les coordonnées cartésiennes:
<coordinate x="0" y="1 />
<coordinate> 0,1 </coordinate>
<coordinate> <x> 0 </x> <y> 1 </y> </coordinate>
Lequel de ces est le plus correct? Je voudrais me pencher vers le troisième sur la base de ma conception actuelle de la conception de schémas XML, mais je ne le sais vraiment pas.
Quelles sont les ressources qui décrivent succinctement comment concevoir efficacement des schémas XML?
Voir le tutoriel:
Je recommande aussi:
Une recommandation générale (mais importante!) Est de ne jamais stocker plusieurs éléments logiques de données dans un seul nœud (que ce soit un nœud de texte ou un nœud d'attribut). Sinon, vous aurez besoin de votre propre logique d’analyse en plus de la logique d’analyse XML que vous obtenez normalement gratuitement à partir de votre framework.
Ainsi, dans votre exemple de coordonnées, <coordinate x="0" y="1" /> Et <coordinate> <x>0</x> <y>1</y> </coordinate> Me conviennent tous les deux.
Mais <coordinate> 0,1 </coordinate> n'est pas très bon, car il stocke deux données logiques (la coordonnée X et la coordonnée Y) dans un seul noeud XML, ce qui oblige le consommateur à analyser les données outside de leur code XML. analyseur. Et bien que diviser une chaîne par une virgule soit assez simple, il reste quelques ambiguïtés comme ce qui se passe s'il y a une virgule supplémentaire à la fin.
Je suis d'accord avec le conseil de cdragon ci-dessous pour éviter l'option n ° 2. Le choix entre # 1 et # 3 est en grande partie une question de style. J'aime utiliser des attributs pour ce que je considère être des attributs de l'entité et des éléments pour ce que je considère comme des données. Parfois, c'est difficile à classer. Néanmoins, ni sont "mal".
Et tandis que nous sommes sur le sujet de la conception de schéma, je vais ajouter mes deux centimes concernant mon niveau préféré de réutilisation (maximale) (des éléments et des types), ce qui peut également faciliter le référencement "logique" externe de ces entités dans, disons, un dictionnaire de données stocké dans une base de données.
Notez que si le schéma "Garden of Eden" offre une réutilisation maximale, il implique également le plus de travail. Au bas de cet article, j'ai fourni des liens vers les autres modèles abordés dans la série de blogs.
• L'approche du jardin d'Eden http://blogs.msdn.com/skaufman/archive/2005/05/10/416269.aspx
Utilise une approche modulaire en définissant tous les éléments de manière globale et, comme dans l’approche des stores vénitiens, toutes les définitions de types sont déclarées de manière globale. Chaque élément est défini globalement comme un enfant immédiat du nœud et son attribut de type peut être défini sur l'un des types complexes nommés.
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="TargetNamespace" xmlns:TN="TargetNamespace"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
elementFormDefault="qualified" attributeFormDefault="unqualified"/>
<xs:element name="BookInformation" type="BookInformationType"/>
<xs:complexType name="BookInformationType"/>
<xs:sequence>
<xs:element ref="Title"/>
<xs:element ref="ISBN"/>
<xs:element ref="Publisher"/>
<xs:element ref="PeopleInvolved" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="PeopleInvolvedType">
<xs:sequence>
<xs:element name="Author"/>
</xs:sequence>
</xs:complexType>
<xs:element name="Title"/>
<xs:element name="ISBN"/>
<xs:element name="Publisher"/>
<xs:element name="PeopleInvolved" type="PeopleInvolvedType"/>
</xs:schema>
L'avantage de cette approche est que les schémas sont réutilisables. Étant donné que les éléments et les types sont définis globalement, ils peuvent être réutilisés. Cette approche offre le maximum de contenu réutilisable. Les inconvénients sont que le schéma est détaillé. Ce serait une conception appropriée lorsque vous créez. bibliothèques générales dans lesquelles vous ne pouvez vous permettre aucune hypothèse sur la portée des types et des éléments de schéma et sur leur utilisation dans d'autres schémas, notamment en ce qui concerne l'extensibilité et la modularité.
Étant donné que chaque type et chaque élément ont une définition globale unique, ces particules/composants canoniques peuvent être liés individuellement aux identifiants d'une base de données. Et bien que maintenir les associations entre les particules/composants textuels XSD et la base de données puisse sembler une tâche manuelle fastidieuse, SQL Server 2005 peut en fait générer des identifiants de composants de schéma canoniques via l’instruction
CREATE XML SCHEMA COLLECTION
http://technet.Microsoft.com/en-us/library/ms179457.aspx
Inversement, pour construire un schéma à partir des particules canoniques, SQL Server 2005 fournit la
SELECT xml_schema_namespace function
http://technet.Microsoft.com/en-us/library/ms191170.aspx
ca · non · i · cal Relatives à la mathématique. (d'une équation, coordonnée, etc.) "sous la forme la plus simple ou standard" http://dictionary.reference.com/browse/canonical
D'autres modèles, plus faciles à construire, mais moins résiliables/plus "dénormalisés/redondants" incluent:
• L'approche de la poupée russe http://blogs.msdn.com/skaufman/archive/2005/04/21/410486.aspx
Le schéma comporte un seul élément global, l’élément racine. Tous les autres éléments et types sont imbriqués progressivement, lui donnant son nom, du fait que chaque type s’intègre dans celui qui le précède. Les éléments de cette conception étant déclarés localement, ils ne seront pas réutilisables via les instructions d'importation ou d'inclusion.
• L'approche de la tranche de salami http://blogs.msdn.com/skaufman/archive/2005/04/25/411809.aspx
Tous les éléments sont définis globalement mais les définitions de type sont définies localement. De cette façon, d'autres schémas peuvent réutiliser les éléments. Avec cette approche, un élément global avec son type défini localement fournit une description complète du contenu de l'élément. Cette «tranche» d'informations est déclarée individuellement, puis agrégée et peut également être reconstituée pour construire d'autres schémas.
• L'approche des aveugles vénitiens http://blogs.msdn.com/skaufman/archive/2005/04/29/413491.aspx
Similaire à l'approche de la poupée russe en ce sens qu'ils utilisent tous deux un seul élément global. L'approche Venetian Blind décrit une approche modulaire en nommant et en définissant toutes les définitions de types de manière globale (par opposition à l'approche Salami Slice qui déclare les éléments globalement et les types localement). Chaque type défini globalement décrit une "lame" individuelle et peut être réutilisé par d'autres composants. En outre, tous les éléments déclarés localement peuvent être qualifiés d'espace de nom ou non qualifiés (les lamelles peuvent être "ouvertes" ou "fermées") en fonction du paramètre d'attribut elementFormDefault situé en haut du schéma.
XML est quelque peu subjectif en termes de conception - je ne pense pas qu'il existe des directives précises sur la manière dont les éléments et les attributs doivent être disposés, mais j'ai tendance à utiliser des éléments pour représenter des "choses" et des attributs pour représenter des attributs/propriétés singuliers. d'eux.
En ce qui concerne les coordonnées, l’exemple serait parfaitement acceptable, mais j’aurais tendance à choisir <coordinate x="" y=""/> car il est un peu plus concis et rend le document un peu plus lisible si vous en avez beaucoup.
La chose la plus importante, cependant, est l’espace de noms du schéma. Assurez-vous que (a) vous en avez une et (b) que vous en avez une version afin de pouvoir changer les choses dans le futur et publier une nouvelle version. Les versions peuvent être des dates ou des chiffres, par exemple.
http://company.com/2008/12/something/somethingelse/
urn:company-com:2008-12:something:somethingelse
http://company.com/v1/something/somethingelse/
urn:company-com:v1:something:somethingelse
Je ne connais aucune bonne ressource d'apprentissage sur la façon de concevoir des modèles de document XML (les schémas ne sont qu'un moyen formel de spécifier des modèles de document).
À mon avis, un aperçu crucial de XML est que ce n’est pas un langage, mais une syntaxe. Et chaque modèle de document est une langue distincte.
Différentes cultures utiliseront chacune le XML à leur manière. Même dans les spécifications du W3C, vous pouvez sentir LISP dans les noms de XSLT séparés par des tirets et Java dans les noms camelCaseNames de XML Schema. De même, différents domaines d’application feront appel à différents idiomes XML.
Les modèles de documents narratifs tels que HTML ou DocBook ont tendance à insérer du texte imprimable dans les nœuds de texte et les métadonnées dans les noms et les attributs d'éléments.
Les modèles de document plus orientés objet tels que SVG utilisent peu ou pas les nœuds de texte et n'utilisent que des éléments et des attributs.
Mes règles empiriques personnelles pour la conception d'un modèle de document sont les suivantes:
- Si c'est le genre de soupe sans balises qui nécessite un contenu mixte , utilisez HTML et DocBook comme sources d'inspiration. Les autres règles ne sont pertinentes que par ailleurs.
- Si une valeur doit être composite ou hiérarchique, utilisez des éléments. Les données XML ne devraient pas nécessiter d'analyse supplémentaire, à l'exception des idiomes établis tels que IDREFS, qui sont de simples séquences séparées par des espaces.
- Si une valeur peut devoir apparaître plusieurs fois, utilisez des éléments.
- Si une valeur doit éventuellement être affinée ou enrichie ultérieurement, utilisez des éléments.
- Si une valeur est clairement atomique (booléen, numéro, date, identifiant, libellé simple) et peut apparaître au maximum une fois, utilisez un attribut.
Une autre façon de le dire pourrait être:
- Si c'est narratif, ce n'est pas orienté objet.
- Si c'est orienté objet, modélisez les objets en tant qu'éléments et les attributs atomiques en tant qu'attributs.
EDIT: Certaines personnes semblent aimer complètement renoncer à des attributs. Il n'y a rien mauvais avec cela, mais je n'aime pas ça, ça gonfle les documents et les rend inutiles, difficiles à lire et à écrire à la main.
J'ai été chargé d'écrire une série de schémas XML pour intégrer les systèmes de mon entreprise à nos clients. J'en ai conçu une douzaine il y a plus de 10 ans et j'ai constaté que de nombreuses fonctionnalités d'extension dans la spécification ne fonctionnaient pas bien dans la pratique. Avant de concevoir les nouveaux modèles, j'ai recherché les meilleures pratiques actuelles (et suis arrivé ici!).
Certains des conseils ci-dessus sont utiles, mais je n’ai pas aimé presque toutes les références. Le meilleur endroit avec des recommandations de conception que j'ai trouvées venait de Microsoft.
La meilleure référence est Schémas de conception de schéma XML: éviter la complexité . Ici vous trouverez ce conseil avisé:
il semble que de nombreux auteurs de schémas seraient mieux servis si comprenait et utilisait un sous-ensemble efficace des fonctionnalités fournies par [Schéma XML du W3C au lieu d'essayer de comprendre l'ensemble de . minuties de la langue.
et donner des explications détaillées sur les directives suivantes:
- Pourquoi devriez-vous utiliser les déclarations d'éléments globaux et locaux
- Pourquoi devriez-vous utiliser les déclarations d'attributs globaux et locaux
- Pourquoi devriez-vous comprendre comment les espaces de nom XML affectent le schéma XML du W3C
- Pourquoi vous devriez toujours définir elementFormDefault sur "qualifié"
- Pourquoi devriez-vous utiliser des groupes d'attributs
- Pourquoi devriez-vous utiliser des groupes de modèles
- Pourquoi devriez-vous utiliser les types simples intégrés
- Pourquoi devriez-vous utiliser des types complexes
- Pourquoi vous ne devriez pas utiliser de déclarations de notation
- Pourquoi devriez-vous utiliser les groupes de substitution avec prudence
- Pourquoi préférer key/keyref/unique à ID/IDREF pour les contraintes d’identité
- Pourquoi devriez-vous utiliser les schémas de caméléon avec précaution
- Pourquoi ne pas utiliser les valeurs par défaut ou fixes, en particulier pour les types de xs: QName
- Pourquoi devriez-vous utiliser la restriction et l'extension de types simples
- Pourquoi devriez-vous utiliser l'extension de types complexes
- Pourquoi devriez-vous utiliser la restriction des types complexes avec précaution
- Pourquoi utiliser les types abstraits avec précaution
- Utilisez des caractères génériques pour fournir des points d'extensibilité bien définis
- Ne pas utiliser la redéfinition de groupe ou de type
Mon conseil à propos de leurs conseils est que, lorsqu'ils disent "utilisez-les avec précaution" , vous devriez simplement les éviter. Mon impression est que la spécification de schéma n'a pas été écrite par les développeurs de logiciels. Ils ont essayé d’utiliser certains concepts d’orientation objet, mais ils ont tout gâché. Beaucoup de mécanismes d'extension sont inutiles ou extrêmement verbeux. Je ne comprends pas vraiment comment quelqu'un aurait pu inventer la restriction des types complexes.
Deux autres articles de Nice sur ce site sont:
- Schémas de conception de schémas: faire face au changement
- Modèles de conception de schéma XML: la dérivation de types complexes est-elle inutile?
Et un conseil omniprésent est de spécifier vos schémas avec quelque chose de différent des spécifications officielles. Relax NG recherche le langage de spécification préféré. Malheureusement, vous perdrez l’un des meilleurs atouts: la normalisation.
Lors de la conception d'un format basé sur XML, il est souvent bon de penser à ce que vous représentez. Essayez de vous moquer de certaines données XML qui correspondent à l'objectif que vous souhaitez. Une fois que vous êtes satisfait de quelque chose qui répond à vos exigences, développez le schéma pour le valider.
Lors de la conception d'un format, j'ai tendance à utiliser des éléments pour conserver le contenu des données et des attributs pour appliquer des caractéristiques aux données, telles qu'un identifiant, un nom, un type ou d'autres métadonnées sur les données contenues dans un élément.
À cet égard, une représentation XML des coordonnées pourrait être:
<coordinate type="cartesian">
<ordinate name="x">0</ordinate>
<ordinate name="y">1</ordinate>
</coordinate>
Cela s'adresse à différents systèmes de coordonnées. Si vous saviez qu'ils seraient toujours cartésiens, une meilleure implémentation pourrait être:
<coordinate>
<x>0</x>
<y>1</y>
</coordinate>
Bien entendu, ce dernier pourrait conduire à un schéma plus détaillé, car chaque type d'élément aurait besoin d'être déclaré (bien que j'espère un type complexe a été défini pour réellement faire le travail difficile pour ces éléments).
Tout comme dans la programmation, il y a souvent plusieurs façons d'atteindre les mêmes fins, mais il n'y a pas de juste ou de faux dans de nombreuses situations, simplement meilleures et pires. L'important est de rester cohérent et d'essayer d'être intuitif afin que, lorsque d'autres regardent votre schéma, ils puissent comprendre ce que vous tentiez de réaliser.
Vous devez toujours mettre à jour vos schémas et vous assurer que le XML écrit sur votre schéma l'indique en tant que tel. Si vous ne modifiez pas correctement le code XML, il sera beaucoup plus difficile de créer des additifs au schéma tout en prenant en charge le langage XML écrit dans le schéma plus ancien.
Dans nos projets Java, nous utilisons souvent JAXB pour analyser automatiquement XML et le transformer en structure d'objet. Je suppose que pour d'autres langues, vous aurez quelque chose de similaire. Un générateur approprié peut créer automatiquement la structure d'objet dans le langage de programmation choisi. Cela rend souvent le traitement du XML beaucoup plus facile, tout en conservant une représentation XML portable pour la communication entre les systèmes.
Si vous utilisez un tel mappage automatique, vous constaterez que le schéma est très contraint - <coordinate> <x> 0 </x> <y> 1 </y> </coordinate> est le chemin à suivre sauf si vous souhaitez utiliser une magie spéciale dans la traduction. Vous obtiendrez une classe Coordinate avec deux attributs x et y avec le type approprié tel que déclaré dans le schéma.
Regardez les relations des données que vous essayez de représenter est la meilleure approche que j'ai trouvée.
Je me trouve souvent aux prises avec le même problème, mais je trouve qu'en pratique, cela n'a pas vraiment d'importance, le xml n'est que des données.
Cela dit, je préfère généralement l’approche «s’il est dit quelque chose sur le nœud, c’est un attribut, sinon c’est un enfant».
Dans votre exemple, je choisirais:
<coordinate>
<x>0</x>
<y>1</y>
</coordinate>
parce que x et y sont les propriétés d’une coordonnée et ne disent rien du xml, mais de l’objet représenté.
J'ai trouvé la forme de l'attribut plus facile à gérer avec les coordonnées cartésiennes. Mes projets ont généralement besoin de plusieurs espaces de noms et le partage de la définition du type de coordonnées entre les espaces de noms devient déplaisant sous la forme de sous-élément. Dans la forme de sous-élément, vous devez soit qualifier les sous-éléments, jongler avec des espaces de noms sur l'élément de base ou racine, ou utiliser par défaut des noms d'élément non qualifiés (c'est-à-dire masquage d'espace de nom ).
Je suppose que cela dépend de la complexité ou de la simplicité de la structure.
Je ferai l'attribut x et y, sauf si x et y ont leurs propres détails
Vous pouvez regarder HTML ou toute autre forme de balisage, qui est utilisé pour définir des éléments (XAML dans le cas de WPF, MXML en cas de flash) pour comprendre pourquoi un élément est choisi comme attribut par rapport à un nœud enfant).
si x et y ne doivent pas être répétés, ils peuvent être des attributs.
Disons que les coordonnées ont plusieurs x et y, je suppose que xml n'autorise pas plusieurs attributs portant le même nom pour un nœud. Dans ce cas, vous devrez utiliser des nœuds enfants.
Il n'y a rien de mal à utiliser un élément ou un sous-élément pour chaque valeur que vous souhaitez représenter.
La principale considération est qu'il est parfois plus simple d'utiliser un attribut. Puisqu'un élément ne peut avoir qu'un seul attribut d'un même prénom, vous êtes bloqué avec une cardinalité 1: 1. Si vous représentez les données sous forme d'élément enfant, vous pouvez utiliser la cardinalité de votre choix (ou être prêt à l'étendre ultérieurement).
La réponse de Rob Wells ci-dessus est juste: cela dépend des relations que vous essayez de modéliser.
Chaque fois qu'il est clair qu'il n'y aura jamais qu'une relation 1: 1, un attribut peut être plus propre.
Ici est une excellente liste de méthodes pour concevoir une grammaire XML.
Comme indiqué ci-dessus, il s'agit d'une pratique subjective, mais ce site donne des indications utiles, telles que «utiliser ce modèle pour résoudre le problème X»… ou «les avantages et les inconvénients sont…».