Guide du développeur d`applications XML - Fichier

Guide du développeur
d’applications XML
Borland ®
VERSION 5
JBuilder
™
Consultez le fichier DEPLOY.TXT situé dans le répertoire redist de JBuilder pour avoir la liste complète des fichiers
que vous pouvez distribuer en accord avec votre contrat de licence JBuilder.
Les applications mentionnées dans ce manuel sont brevetées par Borland Software Corporation ou en attente de
brevet. Ce document ne donne aucun droit sur ces brevets.
COPYRIGHT © 1997, 2001 Borland Software Corporation. Tous droits réservés. Tous les produits Borland sont des
marques commerciales ou des marques déposées de Borland Software Corporation aux Etats-Unis et dans les
autres pays. Les autres noms de produits sont des marques commerciales ou des marques déposées de leurs
fabricants respectifs.
Pour connaître les conditions et limites des fournisseurs tiers, lisez les Remarques version sur votre CD JBuilder.
JB5XML 1E0R0501
0102030405-9 8 7 6 5 4 3 2 1
PDF
Table des matières
Chapitre 1
Chapitre 3
Introduction
Comment contacter le support développeur
de Borland . . . . . . . . . . . . . . . . . .
Ressources en ligne. . . . . . . . . . . . .
World Wide Web . . . . . . . . . . . . . .
Groupes de discussion Borland. . . . . .
Groupes de discussion Usenet . . . . . .
Rapports de bogues . . . . . . . . . . . .
Conventions de la documentation . . . . . .
Conventions pour le Macintosh . . . . . . .
1-1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Utilisation des composants
de bases de données XML
de JBuilder
1-2
1-2
1-2
1-3
1-3
1-3
1-4
1-6
Chapitre 2
Utilisation des fonctionnalités XML
de JBuilder
3-1
Utilisation des composants basés
sur des templates . . . . . . . . . . . . . .
Définition des propriétés
des beans templates . . . . . . . . . . .
Utilisation du personnaliseur
de composants . . . . . . . . . . . .
Utilisation de l’inspecteur. . . . . . .
Document de requête XML . . . . . .
Utilisation des composants basés
sur des modèles . . . . . . . . . . . . . . .
XML-DBMS . . . . . . . . . . . . . . . .
JBuilder et XML-DBMS . . . . . . . . . .
Expert XML-DBMS . . . . . . . . . . . .
Définition des propriétés
des composants basés sur des modèles
Utilisation du personnaliseur
de composants . . . . . . . . . . . .
Utilisation de l’inspecteur. . . . . . .
2-1
Présentation . . . . . . . . . . . . . . . . . . . . 2-1
Création et validation de XML . . . . . . . . . . 2-2
Création de documents XML . . . . . . . . . 2-2
Expert DTD vers XML . . . . . . . . . . . 2-2
Expert XML vers DTD . . . . . . . . . . . 2-4
Visualisation de documents XML . . . . . . 2-5
Visualiseur XML de JBuilder . . . . . . . 2-5
Validation de documents XML . . . . . . . . 2-7
Présentation de XML . . . . . . . . . . . . . . . 2-10
Structure de publication XML Cocoon . . . . 2-10
Transformation de documents XML . . . . . 2-13
Application de feuilles de style internes . 2-14
Application de feuilles de style externes . 2-15
Définition des options de suivi
de la transformation . . . . . . . . . . . 2-17
Configurations XML. . . . . . . . . . . . . . . . 2-18
Ressources XML . . . . . . . . . . . . . . . . . . 2-19
Manipulation de XML par programme . . . . . 2-19
Création d’un gestionnaire SAX . . . . . . . 2-19
Liaison de données . . . . . . . . . . . . . . . 2-21
BorlandXML. . . . . . . . . . . . . . . . . 2-22
Castor . . . . . . . . . . . . . . . . . . . . 2-24
Interface avec des données métier
dans des bases de données . . . . . . . . . . . 2-25
. . . 3-2
. . . 3-2
. . . 3-2
. . . 3-9
. . . 3-9
.
.
.
.
.
.
.
.
3-11
3-11
3-12
3-13
. . 3-17
. . 3-17
. . 3-21
Chapitre 4
Tutoriel : Validation et transformation
de documents XML
4-1
Présentation . . . . . . . . . . . . . . . . .
Etape 1 : Création d’un document XML
à partir d’une DTD . . . . . . . . . . . .
Etape 2 : Insertion des données
dans le document XML généré . . . . .
Etape 3 : Validation du document XML .
Etape 4 : Association de feuilles de style
au document . . . . . . . . . . . . . . . .
Etape 5 : Transformation du document
à l’aide de feuilles de style . . . . . . . .
Etape 6 : Définition des options de suivi
de la transformation . . . . . . . . . . .
i
. . . . 4-1
. . . . 4-2
. . . . 4-3
. . . . 4-4
. . . . 4-6
. . . . 4-8
. . . . 4-9
Chapitre 5
Entrée d’informations concernant
la connexion JDBC. . . . . . . . . . . . . . . 8-4
Test de la connexion . . . . . . . . . . . . . 8-5
Spécification des noms de fichiers . . . . . . . 8-6
Création des tables de base de données . . . . . 8-7
Utilisation de l’exemple d’application test . . . . 8-8
Utilisation du personnaliseur
de XMLDBMSTable . . . . . . . . . . . . . . 8-9
Sélection d’une connexion JDBC . . . . . . 8-9
Transfert de données d’un document XML
vers la table de base de données . . . . 8-10
Transfert de données d’une table de base de
données vers un document XML. . . . 8-11
Utilisation du personnaliseur
de XMLDBMSQuery . . . . . . . . . . . . 8-15
Sélection d’une connexion JDBC . . . . . 8-16
Transfert de données
avec une instruction SQL . . . . . . . . 8-16
Fichiers d’affectation du composant
XMLDBMSQuery . . . . . . . . . . . . 8-17
Tutoriel : Création
d’un Gestionnaire SAX pour analyser
des documents XML
5-1
Présentation . . . . . . . . . . . . . . . . .
Etape 1 : Utilisation
de l’expert Gestionnaire SAX . . . . . . .
Etape 2 : Modification de l’analyseur SAX
Etape 3 : Exécution du programme . . . .
Etape 4 : Ajout d’attributs . . . . . . . . . .
Code source de MySaxParser.java . . . . .
. . . 5-1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5-2
5-4
5-6
5-7
5-8
Chapitre 6
Tutoriel : Liaison de données DTD
avec BorlandXML
Présentation . . . . . . . . . . . . . . . . . . .
Etape 1 : Génération de classes Java
à partir d’une DTD . . . . . . . . . . . . . . .
Etape 2 : Dé-marshalling des données . . . . .
Etape 3 : Ajout d’un employé. . . . . . . . . .
Etape 4 : Modification d’un employé . . . . .
Etape 5 : Exécution de l’application terminée.
6-1
. 6-1
.
.
.
.
.
6-2
6-5
6-6
6-7
6-8
Chapitre 9
Tutoriel : Transfert de données
avec les composants base de données
XML basés sur des templates
9-1
Chapitre 7
Tutoriel : Liaison de données
par schéma avec Castor
Présentation . . . . . . . . . . . . . . . . . . .
Etape 1 : Génération de classes Java
à partir d’un schéma . . . . . . . . . . . . . .
Etape 2 : Dé-marshalling des données . . . . .
Etape 3 : Ajout d’un employé. . . . . . . . . .
Etape 4 : Modification des données
du nouvel employé . . . . . . . . . . . . . .
Etape 5 : Exécution de l’application terminée.
Introduction . . . . . . . . . . . . . . . . . . . .
Utilisation de l’exemple d’application test . . .
Utilisation du personnaliseur de XTable . .
Entrée d’informations concernant
la connexion JDBC . . . . . . . . . . . .
Transfert de données de la table de base
de données vers un document XML . .
Utilisation du personnaliseur de XQuery. .
Sélection d’une connexion JDBC . . . . .
Transfert de données
avec une instruction SQL . . . . . . . .
7-1
. 7-1
. 7-2
. 7-5
. 7-6
. 7-7
. 7-8
Chapitre 8
Index
Tutoriel : Transfert de données
avec les composants base de données
XML basés sur des modèles
8-1
Introduction . . . . . . . . . . . . . . . . . . . . 8-2
Création des fichiers script SQL
et d’affectation . . . . . . . . . . . . . . . . . . 8-4
ii
. 9-2
. 9-2
. 9-3
. 9-3
. 9-4
. 9-7
. 9-7
. 9-8
I-1
Chapitre
1
Introduction
Chapitre1
Le support XML
est une fonctionnalité
de JBuilder Professionnel
et de JBuilder Entreprise.
Le Guide du développeur d’applications XML explique comment utiliser les
fonctionnalités XML de JBuilder ; il se compose des chapitres suivants :
• Chapitre 2, “Utilisation des fonctionnalités XML de JBuilder”
Explique comment utiliser les fonctionnalités XML de JBuilder pour
créer, valider et présenter des documents XML.
C’est une fonctionnalité
de JBuilder Entreprise.
C’est une fonctionnalité
de JBuilder Entreprise.
Il contient aussi “Manipulation de XML par programme”, page 2-19,
qui explique comment créer un analyseur SAX et manipuler des
données XML par programme à l’aide de plusieurs solutions de liaison
des données.
• Chapitre 3, “Utilisation des composants de bases de données XML
de JBuilder”
Explique comment utiliser les composants bean modèle et template de
XML pour créer des requêtes sur une base de données et comment
transférer des données entre des documents XML et des bases de
données.
• Tutoriels
• Chapitre 4, “Tutoriel : Validation et transformation
de documents XML”
Ces tutoriels
sont disponibles
dans JBuilder Entreprise.
• Chapitre 5, “Tutoriel : Création d’un Gestionnaire SAX pour
analyser des documents XML”
• Chapitre 6, “Tutoriel : Liaison de données DTD avec BorlandXML”
• Chapitre 7, “Tutoriel : Liaison de données par schéma avec Castor”
• Chapitre 8, “Tutoriel : Transfert de données avec les composants
base de données XML basés sur des modèles”
• Chapitre 9, “Tutoriel : Transfert de données avec les composants
base de données XML basés sur des templates”
Introduction
1-1
Comment contacter le support développeur de Borland
Comment contacter le support développeur de Borland
Borland offre aux développeurs diverses options de support. Elles
comprennent des services gratuits sur Internet, où vous pouvez consulter
notre importante base d’informations et entrer en contact avec d’autres
utilisateurs de produits Borland. En outre, vous pouvez choisir parmi
plusieurs catégories de support, allant de l’installation des produits
Borland au support tarifé de niveau consultant, en passant par une
assistance complète.
Pour obtenir des informations sur les services Borland de support aux
développeurs, veuillez consulter notre site Web, à l’adresse
http://www.borland.fr/Support/.
Quand vous contacterez le support, préparez des informations complètes
sur votre environnement, la version du produit que vous utilisez et une
description détaillée du problème.
Pour avoir de l’aide sur les outils tiers, ou leur documentation, contactez
votre fournisseur.
Ressources en ligne
Vous pouvez obtenir des informations depuis les sources ci-après :
World Wide Web http://www.borland.fr/
FTP
ftp.borland.com
Documents techniques accessibles par anonymous ftp.
Listserv
Pour vous abonner aux bulletins électroniques, utilisez
le formulaire en ligne :
http://www.borland.com/contact/listserv.html
ou, pour l’international,
http://www.borland.com/contact/intlist.html
TECHFAX
1-800-822-4269 (Amérique du Nord)
Documents techniques accessibles par télécopie.
World Wide Web
Consultez régulièrement www.borland.fr/jbuilder. L’équipe produit de
JBuilder y place notes techniques, analyses des produits concurrents,
réponses aux questions fréquemment posées, exemples d’applications,
mises à jour du logiciel et informations sur les produits existants ou
nouveaux.
1-2
Guide du développeur d’applications XML
Comment contacter le support développeur de Borland
Vous pouvez vous connecter en particulier aux URL suivantes :
• http://www.borland.fr/Produits/jbuilder/ (mises à jour du logiciel et
autres fichiers)
• http://community.borland.com/ (contient notre magazine
d’informations web pour les développeurs)
Groupes de discussion Borland
Vous pouvez vous inscrire à JBuilder et participer à de nombreux groupes
de discussion dédiés à JBuilder.
Vous trouverez des groupes de discussion, animés par les utilisateurs,
pour JBuilder et d’autres produits Borland, à l’adresse
http://www.borland.fr/Newsgroups/
Groupes de discussion Usenet
Les groupes Usenet suivants sont dédiées à Java et concernent la
programmation :
•
•
•
•
•
•
•
•
•
•
Remarque
news:comp.lang.java.advocacy
news:comp.lang.java.announce
news:comp.lang.java.beans
news:comp.lang.java.databases
news:comp.lang.java.gui
news:comp.lang.java.help
news:comp.lang.java.machine
news:comp.lang.java.programmer
news:comp.lang.java.security
news:comp.lang.java.softwaretools
Ces groupes de discussion sont maintenus par les utilisateurs et ne sont
pas des sites Borland officiels.
Rapports de bogues
Si vous pensez avoir trouvé un bogue dans le logiciel, merci de le signaler
dans la page du support développeur de JBuilder, à l’adresse
http://www.borland.fr/Support/jbuilder/. Sur ce site, vous pouvez
également demander une fonctionnalité ou consulter la liste des bogues
déjà signalés.
Quand vous signalez un bogue, indiquez toutes les étapes nécessaires à la
reproduction de ce bogue, ainsi que tout paramètre spécial de votre
environnement et les autres programmes utilisés avec JBuilder. Précisez
bien le comportement attendu et ce qui s’est réellement passé.
Introduction
1-3
Conventions de la documentation
Si vous avez des commentaires (compliments, suggestions ou questions)
concernant la documentation de JBuilder, vous pouvez envoyer un e-mail
à [email protected]. Uniquement pour la documentation. Les
questions de support doivent être adressées au support développeur.
JBuilder est fait par des développeurs pour des développeurs. Nous
apprécions vraiment vos remarques, car elles nous aident à améliorer
notre produit.
Conventions de la documentation
La documentation Borland sur JBuilder utilise les polices et les symboles
décrits dans le tableau ci-dessous pour signaler du texte particulier.
Tableau 1.1 Polices et symboles
1-4
Police
Signification
Police à
espacement fixe
La police à espacement fixe représente :
• du texte tel qu’il apparaît à l’écran
• du texte que vous devez taper, comme “Entrez Hello World dans
le champ Titre de l’expert Application.”
• des noms de fichiers
• des noms de chemins
• des noms de répertoires ou de dossiers
• des commandes, comme SET PATH, CLASSPATH
• du code Java
• des types de données Java, comme boolean, int et long.
• des identificateurs Java, comme des noms de variables, classes,
interfaces, composants, propriétés, méthodes et événements
• des noms de paquets
• des noms d’argument
• des noms de champs
• des mots clés Java, comme void et static
Gras
Le gras est utilisé pour désigner les outils java, bmj (Borland Make
for Java), bcj (Borland Compiler for Java) et les options du
compilateur. Par exemple : javac, bmj, -classpath.
Italiques
L’italique est utilisé pour les termes nouveaux, les titres des
manuels et, parfois, pour la mise en valeur.
Touches
Cette police indique une touche de votre clavier. Par exemple,
“Appuyez sur Echap pour quitter un menu.”
[]
Les crochets droits dans le texte ou dans la syntaxe entourent les
éléments facultatifs. Ne tapez pas ces crochets.
Guide du développeur d’applications XML
Conventions de la documentation
Tableau 1.1 Polices et symboles (suite)
Police
Signification
<>
Les crochets angulaires dans le texte ou dans la syntaxe indiquent
une chaîne variable ; entrez la chaîne appropriée à votre code. Ne
tapez pas ces crochets. Les crochets angulaires sont également
utilisés pour les balises HTML.
...
Dans les exemples de code, les points de suspension indiquent du
code manquant. Sur un bouton, les points de suspension indiquent
que ce bouton ouvre un dialogue de sélection.
JBuilder est disponible sur plusieurs plates-formes. Reportez-vous au
tableau ci-dessous pour une description des conventions et répertoires
associés aux diverses plates-formes dans la documentation.
Tableau 1.2 Conventions et répertoires associés aux plates-formes
Elément
Signification
Chemins
Les chemins d’accès mentionnés dans la documentation sont
indiqués par une barre oblique (/).
Pour la plate-forme Windows, utilisez une barre oblique
inverse (\).
Répertoire de base
L’emplacement du répertoire de base dépend de la
plate-forme.
• Pour UNIX et Linux, le répertoire de base peut varier. Par
exemple, ce peut être /user/[username] ou /home/[username]
• Pour Windows 95/98, le répertoire de base est C:\Windows
• Pour Windows NT, le répertoire de base est C:\Winnt\
Profiles\[username]
• Pour Windows 2000, le répertoire de base est C:\Documents
and Settings\[username]
Répertoire
.jbuilder5
Le répertoire .jbuilder5, où sont stockés les paramètres de
fonctionnement de JBuilder, est placé dans le répertoire de
base.
Répertoire jbproject
Le répertoire jbproject, qui contient les fichiers projet, classe
et source, est placé dans le répertoire de base. JBuilder
enregistre les fichiers dans ce chemin par défaut.
Captures d’écran
Les captures d’écran reflètent l’apparence Metal de JBuilder
sur diverses plates-formes.
Introduction
1-5
Conventions pour le Macintosh
Conventions pour le Macintosh
JBuilder a été conçu pour supporter le Macintosh OS X si étroitement qu’il
prend l’apparence d’une application native. La plate-forme Macintosh a
des conventions d’apparence et de style qui diffèrent de celles de
JBuilder ; quand cela se produit, JBuilder prend l’apparence du Mac. Cela
veut dire qu’il y a quelques différences entre la façon dont JBuilder se
présente sur le Mac et ce qui est décrit dans la documentation. Par
exemple, la documentation utilise le mot “répertoire” alors que sur le Mac,
on dit “dossier”. Pour plus d’informations sur les chemins, la terminologie
et les conventions de l’interface utilisateur de Macintosh OS X, consultez
la documentation livrée avec votre OS X.
1-6
Guide du développeur d’applications XML
Chapitre
2
Utilisation des fonctionnalités
XML de JBuilder
Chapitre2
Présentation
Ces fonctionnalités
font partie
de JBuilder Professionnel
et de JBuilder Entreprise.
JBuilder offre plusieurs fonctionnalités et intègre divers outils pour
assurer le support du langage XML (Extensible Markup Language). XML
est un moyen de structurer les informations indépendant des
plates-formes. Comme XML sépare le contenu d’un document de sa
structure, il peut être utile lors de l’échange de données. Par exemple, il
peut servir à transférer des données entre des bases de données et des
programmes Java. Comme contenu et structure sont séparés, des feuilles
de style peuvent être appliquées pour afficher le même contenu dans
différent formats comme PDF (Portable Document Format), HTML pour
l’affichage dans un navigateur Web, etc.
Quand il travaille avec XML, JBuilder répartit les fonctionnalités dans
plusieurs couches :
• Création et validation de documents XML
• Présentation de documents XML
Ces fonctionnalités
font partie
de JBuilder Entreprise.
Voir aussi
• Manipulation de documents XML par programme
• Interface avec des données métier dans des bases de données
W3C (Consortium World Wide Web) à l’adresse http://www.w3.org/
Les XML Cover Pages à l’adresse http://www.oasis-open.org/cover/
sgml-xml.html (ou http://xml.coverpages.org/)
XML.org à l’adresse http://xml.org/
xmlinfo à l’adresse http://www.xmlinfo.com/
Utilisation des fonctionnalités XML de JBuilder
2-1
Création et validation de XML
Création et validation de XML
La création
et la validation
sont des fonctionnalités
de JBuilder Professionnel
et de JBuilder Entreprise.
JBuilder fournit un ensemble de fonctionnalités qui servent à créer,
modifier, visualiser et valider des documents XML sans jamais quitter
l’environnement de développement. Vous pouvez utiliser des experts
pour créer rapidement des documents XML, le visualiseur pour les voir
dans une vue arborescente réductible et l’éditeur de JBuilder pour
modifier le texte (cet éditeur met en évidence la syntaxe XML), rechercher
les erreurs et, finalement, valider les documents.
Pour trouver un tutoriel sur la création et la validation de documents
XML, consultez le Chapitre 4, “Tutoriel : Validation et transformation
de documents XML”.
Création de documents XML
JBuilder fournit des experts permettant de créer plusieurs documents
XML dans l’EDI :
• Expert DTD vers XML
• Expert XML vers DTD
Ces experts sont disponibles à partir du menu contextuel (clic droit) du
volet projet et de la page XML de la galerie d’objets (Fichier|Nouveau).
Astuce
Vous pouvez créer aussi des documents XML vides de la façon suivante ;
l’éditeur reconnaîtra le type de fichier et fournira la mise en évidence de la
syntaxe :
1 Choisissez Fichier|Ouvrir un fichier.
2 Dans le champ Nom de fichier, entrez un nom de fichier et une
extension, telle que .dtd, .xml, .xsl et .xsd.
3 Entrez le texte dans le fichier.
4 Enregistrez le fichier.
5 Ajoutez le fichier au projet avec le bouton Ajouter au projet.
Expert DTD vers XML
L’expert DTD vers XML permet de créer rapidement un document XML à
partir d’une DTD existante. Il crée un template XML à partir de la DTD
avec des paramètres fictifs pcdata représentant le contenu que vous
remplacez par le vôtre.
Pour utiliser l’expert DTD vers XML,
1 Cliquez avec le bouton droit sur le fichier DTD dans le volet projet et
choisissez Générer XML. Le nom du fichier DTD est automatiquement
mis dans le champ Fichier DTD d’entrée de l’expert.
2-2
Guide du développeur d’applications XML
Création et validation de XML
2 Sélectionnez l’élément racine dans la liste déroulante Elément racine.
3 Dans le champ Fichier XML de sortie, acceptez le nom de fichier par
défaut ou cliquez sur le bouton points de suspension pour entrer le
nom de fichier du document XML.
4 Facultatif : Entrez les identificateurs de la déclaration DOCTYPE.
• Public : entrez l’URI de la bibliothèque standard spécifiée.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 Final//EN">
• Système : entrez le nom du fichier DTD. Cela génère la déclaration
DOCTYPE. Par exemple :
<!DOCTYPE root SYSTEM "Employees.dtd">
5 Cliquez sur OK pour fermer l’expert. Le document XML s’ajoute au
projet et figure dans le volet projet.
L’expert gère aussi des attributs et convertit les définitions ATTLIST de la
DTD en attributs dans le document XML.
Figure 2.1
DTD avec des définitions ATTLIST
Utilisation des fonctionnalités XML de JBuilder
2-3
Création et validation de XML
Figure 2.2
XML créé par l’expert
Expert XML vers DTD
L’expert XML vers DTD permet de créer rapidement une DTD à partir
d’un document XML existant.
Pour utiliser l’expert XML vers DTD,
1 Pour ouvrir l’expert XML vers DTD, cliquez avec le bouton droit sur le
fichier XML dans le volet projet et choisissez Générer DTD. Le nom du
fichier XML est automatiquement mis dans le champ Fichier XML
d’entrée de l’expert.
2 Dans le champ Fichier DTD de sortie, acceptez le nom de fichier par
défaut ou cliquez sur le bouton points de suspension pour entrer un
nom de fichier XML différent.
3 Cliquez sur OK pour fermer l’expert. La DTD s’ajoute au projet et
figure dans le volet projet.
2-4
Guide du développeur d’applications XML
Création et validation de XML
Important
Si le document XML contient des attributs, l’expert XML vers DTD génère
dans la DTD les définitions ATTLIST correspondantes. Voir “Expert DTD
vers XML”, page 2-2, qui donne des exemples d’attributs.
Visualisation de documents XML
JBuilder fournit un visualiseur XML qui permet de voir vos documents
XML sans avoir à quitter l’environnement de développement. Le
document XML affiché peut utiliser une feuille de style définie par
l’utilisateur, une feuille de style JBuilder par défaut ou aucune feuille de
style. Le visualiseur XML de JBuilder, qui prend JavaScript en charge,
affiche la feuille de style JBuilder par défaut sus une forme arborescente
réductible.
Visualiseur XML de JBuilder
Dans JBuilder, vous pouvez voir un document XML en l’ouvrant et en
sélectionnant l’onglet Vue du volet contenu. Si cet onglet est indisponible,
il faut l’activer sur la page XML de la boîte de dialogue Options de l’EDI
(Outils|Options de l’EDI).
Si aucune feuille de style CSS n’est disponible, JBuilder applique une
feuille de style XSLT par défaut pour afficher le document dans une vue
arborescente réductible. Remarquez que l’onglet Vue ignore les feuilles de
style XSL. Pour savoir comment appliquer des feuilles de style, consultez
“Transformation de documents XML”, page 2-13.
Figure 2.3
Remarque
Vue XML avec la feuille de style par défaut
Vous pouvez développer et réduire la vue arborescente en cliquant sur les
symboles plus (+) et moins (–).
Utilisation des fonctionnalités XML de JBuilder
2-5
Création et validation de XML
Quand l’option Appliquer la feuille de style par défaut est désactivée,
vous pouvez voir votre document XML sans aucun style. Vous pouvez la
désactiver dans la page XML de la boîte de dialogue Options de l’EDI.
Figure 2.4
Vue XML sans feuille de style
Si votre fichier XML contient une feuille de style en cascade (CSS), le
visualiseur XML de JBuilder affiche le document en utilisant cette feuille
de style.
Par exemple, pour afficher le document XML suivant directement avec
une feuille de style plutôt qu’en le transformant, vous pouvez créer un
fichier CSS comme le montre l’illustration et y faire référence dans le
document XML de la façon suivante :
<?xml-stylesheet type="text/css" href="cd_catalog.css"?>
Figure 2.5
2-6
Document XML
Guide du développeur d’applications XML
Création et validation de XML
Figure 2.6
Source de la feuille de style en cascade
L’image suivante montre le résultat obtenu :
Figure 2.7
Document XML avec application d’une feuille de style en cascade
Validation de documents XML
Dans XML, il y a deux types de validation : construction correcte et
validité grammaticale. Pour qu’un document ait une construction
correcte, sa structure physique et sa syntaxe doivent respecter les règles
XML. Par exemple, tous les documents XML doivent avoir un élément
racine. De même, si le document a une DTD interne, toutes les entités
doivent être déclarées. Si un document a une construction correcte, les
DTD externes ne sont pas contrôlées.
Par contre, un document XML valide est un document dont la
construction est correcte mais qui respecte aussi les règles plus strictes
spécifiées dans la DTD (Document Type Definition) ou dans le schéma. La
DTD décrit une structure de document, spécifie quels types d’éléments
sont autorisés et définit les propriétés de chaque élément.
Utilisation des fonctionnalités XML de JBuilder
2-7
Création et validation de XML
JBuilder intègre l’analyseur Xerces pour fournir une analyse XML de
validation des documents XML. Pour avoir des informations sur Xerces,
consultez la documentation Xerces et les exemples disponibles dans le
répertoire extras de l’installation complète de JBuilder ou visitez le site
Web d’Apache à l’adresse http://xml.apache.org/.
Quand vous affichez un document XML ouvert dans JBuilder, le volet
structure affiche la structure du document. Si ce dernier n’a pas une
correction correcte, le volet structure montre un dossier Erreurs qui
contient des messages d’erreurs. Servez-vous de ces messages pour
corriger les erreurs d’une structure de document. Dans le volet structure,
cliquez sur un message d’erreur pour le mettre en évidence dans le code
source et double-cliquez pour envoyer la focalisation du curseur vers
l’éditeur.
Figure 2.8
Dossier Erreurs dans le volet structure
JBuilder peut valider aussi la grammaire XML de votre document selon
les définitions de la DTD. Le document XML étant affiché dans le volet
contenu, cliquez avec le bouton droit sur le fichier XML dans le volet
projet et choisissez Valider. Si le document est valide, une boîte de
dialogue le signale. Si le document contient des erreurs, les résultats sont
mis dans une page Trace de validation XML du volet message. Cliquez
sur un message d’erreur pour mettre en évidence l’erreur dans le code
source. Double-cliquez sur un message pour envoyer la focalisation du
curseur vers le code source.
Le volet message affiche deux types de messages d’erreurs : correctement
construit et valide. S’il n’y a pas de DTD, le document est déclaré invalide
et un message le signale dans le volet message. Une fois les erreurs
corrigées, faites une nouvelle validation du document pour le vérifier.
2-8
Guide du développeur d’applications XML
Création et validation de XML
Figure 2.9
Erreurs de validation XML en utilisant une DTD
JBuilder prend aussi en charge la validation des fichiers schéma (XSD).
Comme avec les DTD, cliquez avec le bouton droit sur le fichier schéma
dans le volet projet et choisissez Valider. Les erreurs sont visibles dans le
volet structure et/ou le volet message. Si un fichier schéma n’est pas
disponible, un message le signale dans le volet message. Si le schéma est
valide, une boîte de dialogue le précise.
Figure 2.10 Erreurs de validation XML en utilisant un schéma
Utilisation des fonctionnalités XML de JBuilder
2-9
Présentation de XML
Présentation de XML
La présentation
est une fonctionnalité
de JBuilder Professionnel
et de JBuilder Entreprise.
JBuilder fournit des outils destinés aux tâches de présentation des
documents XML :
• Cocoon comme couche présentation
• Validation de documents XML
• Transformation de documents XML
Structure de publication XML Cocoon
Cocoon, qui fait partie du projet XML Apache, est intégré dans JBuilder.
C’est une structure de publication Java basée sur des servlets, destinée à
XML, qui autorise la séparation du contenu, du style et de la logique, et
qui utilise une transformation XSL pour les fusionner. Cocoon peut
utiliser aussi des feuilles logiques, pages XSP (Extensible Server Pages),
pour intégrer un contenu dynamique à la logique de programme écrite en
Java. Le modèle Cocoon décompose le contenu Web en :
• Création XML : les fichiers XML sont créés par des propriétaires de
contenu qui ont besoin de comprendre les DTD mais pas de connaître
le traitement.
• Traitement XML : le fichier XML est traité selon les feuilles logiques. La
logique est séparée du contenu.
• Rendu XSL : l’affichage du document XML utilise une feuille de style et
un formatage tenant compte du type de ressource (PDF, HTML, WML,
XHTML, etc).
Quand vous exécutez l’expert Application Web Cocoon, Cocoon est
configuré pour utiliser la version fournie avec JBuilder. Utilisez l’expert
Application Web Cocoon sur la page XML de la galerie d’objets (Fichier|
Nouveau|XML) pour configurer Cocoon après avoir démarré un
nouveau projet :
1 Créez un projet en utilisant l’expert Projet de JBuilder (Fichier|
Nouveau projet).
2 Choisissez Fichier|Nouveau et choisissez l’onglet XML de la galerie
d’objets.
3 Double-cliquez sur l’icône Application Web Cocoon pour ouvrir
l’expert Application Web Cocoon.
4 Acceptez la base Cocoon par défaut.
5 Acceptez l’option Générer WAR si vous voulez créer un fichier WAR.
6 Cliquez sur OK pour fermer l’expert et générer les fichiers Cocoon.
2-10
Guide du développeur d’applications XML
Présentation de XML
7 Sélectionnez le fichier du projet dans le volet projet, cliquez avec le
bouton droit, et choisissez Construire le projet pour générer le fichier
WAR.
8 Dans le volet projet, développez le nœud cocoon pour voir les fichiers
Cocoon générés par l’expert :
•
•
•
•
•
•
cocoon.war - fichier archive Web
web.xml - descripteur de déploiement d’application Web
cocoon.properties - fichier de propriétés
cocoon.xml - fichier de configuration
index.xml - exemple de fichier xml
index.xsl - exemple de feuille de style
Vous pourrez ultérieurement apporter des modifications dans la
plupart de ces fichiers directement dans l’éditeur sans exécuter l’expert
une nouvelle fois.
9 Ajoutez au projet vos fichiers XML et XSL existants à l’aide du bouton
Ajouter au projet situé sur la barre d’outils du volet projet.
Pour avoir plus d’informations sur web.xml et sur l’éditeur du descripteur
de déploiement, consultez les rubriques “Descripteurs de déploiement”
dans “Utilisation des WebApp et des fichiers WAR” et “Déploiement de
votre application Web” dans le Guide du développeur d’applications Web.
Ouvrez un fichier exemple Cocoon, index.xml, et remarquez qu’il utilise
index.xsl comme feuille de style.
Utilisation des fonctionnalités XML de JBuilder
2-11
Présentation de XML
Figure 2.11 Code source XML de index.xml
Figure 2.12 Code source de la feuille de style index.xsl
Pour exécuter Cocoon, cliquez avec le bouton droit sur le nœud cocoon
dans le volet projet et choisissez Exécution Cocoon dans le menu
déroulant. Cocoon lance le moteur de servlet actuellement configuré et
s’insère dans l’environnement des servlets, en utilisant les informations
des fichiers web.xml et de cocoon.properties générés par l’expert Application
Web Cocoon. Vous pouvez modifier cocoon.properties pour ajouter des
bibliothèques XSP (Extensible Server Pages) et des ressources
individuelles à chaque feuille logique.
Maintenant, choisissez l’onglet Vue Web pour voir l’exemple Cocoon sur
lequel la feuille de style a été appliquée.
2-12
Guide du développeur d’applications XML
Présentation de XML
Figure 2.13 Vue Web de index.xml
Pour voir le code source de la vue Web, choisissez l’onglet Source Vue
Web.
Figure 2.14 Source de la vue Web de index.xml
Pour avoir des informations sur l’utilisation de Cocoon, consultez la
documentation Cocoon et les exemples dans le répertoire cocoon de votre
installation JBuilder ou visitez le site Web d’Apache à l’adresse
http://xml.apache.org/cocoon/index.html.
Transformation de documents XML
La conversion d’un document XML en un autre type de document est
appelée transformation XML. Pour la transformation des documents
XML, JBuilder incorpore Xalan comme processeur de feuilles de style et
utilise des feuilles de style écrites en XSLT (Extensible Style Language
Transformations). Une feuille de style XSL contient des instructions pour
Utilisation des fonctionnalités XML de JBuilder
2-13
Présentation de XML
la transformation des documents XML d’un type en un autre (XML,
HTML, PFD, WML ou autre).
Pour avoir des informations sur Xalan, consultez la documentation Xalan
et les exemples disponibles dans le répertoire extras de l’installation
complète de JBuilder ou visitez le site Web d’Apache à l’adresse
http://xml.apache.org/.
Application de feuilles de style internes
Pour appliquer une feuille de style à un document XML, choisissez
l’onglet Vue de la transformation dans le volet contenu. Si le document
contient une instruction de traitement XSLT et une seule feuille de style,
cette dernière est appliquée au document XML. Si une vue arborescente
est affichée à la place, appuyez sur le bouton Feuille de style par défaut
dans la barre d’outils de la vue de transformation pour désactiver la vue
arborescente. Le document transformé, mis dans un tampon temporaire,
est affiché sur l’onglet Vue de la transformation du volet contenu, avec la
feuille de style qui lui est appliquée. Un onglet Source de la vue de
transformation vous permet de voir le code source de cette
transformation.
Pour appliquer une autre feuille de style interne figurant dans
l’instruction des feuilles de style du document, choisissez-la dans la liste
déroulante des feuilles de style dans la barre d’outils de la vue de la
transformation.
Figure 2.15 Barre d’outils de la vue de la transformation
Tableau 2.1 Boutons de la barre d’outils de la vue de la transformation
2-14
Bouton
Description
Feuille de style
par défaut
Applique la feuille de style par défaut de JBuilder, qui est
une vue arborescente réductible.
Rafraîchir
Rafraîchit la vue.
Définir les options
de suivi
Ouvre la boîte de dialogue Définir les options de suivi de la
transformation qui permet de suivre le traitement de
l’application.
Ajouter des feuilles
de style
Ouvre la boîte de dialogue Configurer les feuilles de styles
du nœud dans laquelle vous pouvez associer des feuilles de
style à un document.
Guide du développeur d’applications XML
Présentation de XML
Application de feuilles de style externes
Vous pouvez également appliquer à un document des feuilles de style
externes. Commencez par les associer au document XML. Il y a plusieurs
façons d’ajouter et de retirer des feuilles de style externes associées à un
document :
• Cliquez avec le bouton droit sur le document XML dans le volet projet
et choisissez Propriétés.
• Cliquez sur le bouton Ajouter des feuilles de style dans la barre d’outils
de la vue de la transformation.
Ensuite, utilisez les boutons Ajouter et Retirer pour ajouter et retirer les
feuilles de style sélectionnées. Une fois les feuilles de style associées au
document, elles figurent avec les feuilles de style internes sur la barre
d’outils de la vue de la transformation, dans la liste déroulante des feuilles
de style.
Ensuite, choisissez l’onglet Vue de la transformation et sélectionnez une
feuille de style externe dans la liste déroulante pour l’appliquer. Si le
document est affiché dans une vue arborescente, désactivez-la en cliquant
sur le bouton Feuille de style par défaut de la barre d’outils, dans la vue de
la transformation.
Utilisation des fonctionnalités XML de JBuilder
2-15
Présentation de XML
Figure 2.16 Vue de la transformation avec une feuille de style externe appliquée
Si aucune feuille de style n’est disponible, un message le signale dans la
vue de la transformation indiquant qu’aucune feuille de style n’est
associée au document.
Figure 2.17 Vue de la transformation sans feuille de style
Pour afficher le résultat de la transformation dans une vue arborescente en
utilisant le feuille de style par défaut de JBuilder, cliquez sur le bouton
Feuille de style par défaut dans la barre d’outils de la vue de la
transformation. Cela est utile si la sortie d’une transformation est un autre
document XML sans feuille de style.
2-16
Guide du développeur d’applications XML
Présentation de XML
Figure 2.18 Vue de la transformation avec la vue arborescente de la feuille de style par défaut
Définition des options de suivi de la transformation
Vous pouvez définir les options de suivi de la transformation de façon à ce
que, lorsqu’une transformation a lieu, vous puissiez voir un suivi du
traitement de l’application. Ces options incluent Génération, Modèles,
Eléments et Sélections. Pour activer le suivi, choisissez Outils|Options de
l’EDI, choisissez l’onglet XML et cochez les options de suivi souhaitées.
Vous pouvez définir aussi ces options en cliquant sur le bouton Définir les
options de suivi dans la barre d’outils de la vue de la transformation. Le
suivi se trouve dans le volet message. Cliquez sur un suivi met en
évidence le code source correspondant. Double-cliquer sur un suivi
envoie la focalisation sur le code source dans l’éditeur pour que vous
puissiez commencer à le modifier.
Utilisation des fonctionnalités XML de JBuilder
2-17
Configurations XML
Configurations XML
Fonctionnalité
de JBuilder Professionnel
et de JBuilder Entreprise.
Vous pouvez définir des configurations XML dans la boîte de dialogue
Options de l’EDI. Choisissez Outils|Options de l’EDI et cliquez sur
l’onglet XML pour définir les options suivantes :
• Options générales
• Activer la vue du navigateur : active le visualiseur XML de JBuilder.
Quand cette option est activée, un onglet Vue est disponible dans le
volet contenu.
• Appliquer la feuille de style par défaut : La feuille de style par défaut
de JBuilder affiche un document XML dans une vue arborescente.
• Définir les options de suivi de la transformation : définit les options de
suivi de la transformation pour que, lorsqu’une transformation se
produit, vous puissiez suivre l’ordre dans lequel les divers éléments
des feuilles de style ont été appliqués. Les options de suivi
comprennent :
•
•
•
•
2-18
Génération
Modèles
Eléments
Sélections
Guide du développeur d’applications XML
Ressources XML
Ressources XML
D’autres ressources XML sont incluses dans le répertoire extras de
l’installation complète de JBuilder : Xerces, Xalan, Castor et Borland XML.
Vous y trouvez aussi la documentation, Javadoc et des exemples.
Manipulation de XML par programme
La manipulation
par programme
est une fonctionnalité
de JBuilder Entreprise.
En général, XML est manipulé par programme soit par des analyseurs soit
par une solution de liaison de données plus spécifique. JBuilder prend les
deux approches en charge et fournit des outils correspondants :
• Un expert SAX et des définitions de bibliothèques pour DOM et JAXP.
• BorlandXML pour la génération de sources Java à partir d’une DTD
• Castor pour la génération de sources Java à partir d’un schéma
Vous pouvez ajouter à votre projet des bibliothèques prédéfinies fournies
avec JBuilder : JDOM, JAXP, Xerces, BorlandXML, Castor, parmi d’autres.
Vous pouvez les ajouter à votre projet dans la boîte de dialogue Propriétés
du projet. Choisissez Projet|Propriétés du projet et sélectionnez la page
Chemins. Choisissez l’onglet Bibliothèques nécessaires et ajouter les
bibliothèques. Une fois les bibliothèques ajoutées, l’audit de code de
JBuilder y accède et peut afficher dans l’éditeur des fenêtres déroulantes
contextuelles qui montrent les méthodes et les membres de données, les
classes, les paramètres attendus par la méthode codée, ainsi qu’un examen
détaillé du code source.
Création d’un gestionnaire SAX
C’est une fonctionnalité
de JBuilder Entreprise.
SAX, acronyme de Simple API pour XML, est une interface standard pour
l’analyse XML basée sur les événements. Il y a deux types d’API XML : les
API basées sur des arborescences et les API basées sur des événements.
Avec une API basée sur des arborescences, qui compile un document
XML en une structure arborescente interne, une application peut naviguer
dans l’arborescence. Cette API basée sur des arborescences est
actuellement en cours de normalisation en tant que DOM (Document
Object Model).
SAX, API basée sur des événements, signale directement des événements
d’analyse à l’application au moyen de callbacks. L’application implémente
des gestionnaires pour traiter les différents événements, pour obtenir une
gestion semblable à celle des événements dans une interface utilisateur
graphique.
Utilisation des fonctionnalités XML de JBuilder
2-19
Manipulation de XML par programme
Par exemple, une API basée sur des événements étudie ce document :
<?xml version="1.0"?>
<page>
<titre>Exemple basé sur des événements</titre>
<contenu>Bonjour à tous !</contenu>
</page>
et le décompose en ces événements :
début document
début élément : page
début élément : titre
caractères : Exemple basé sur des événements
fin élément : titre
début élément : contenu
caractères : Bonjour à tous !
fin élément : contenu
fin élément : page
fin document
JBuilder facilite l’utilisation de SAX pour manipuler votre XML par
programme. L’expert Gestionnaire SAX crée un template
d’implémentation de l’analyseur SAX qui n’inclut que les méthodes à
implémenter pour analyser votre XML.
Pour utiliser l’expert Gestionnaire SAX,
1 Choisissez Fichier|Nouveau pour ouvrir la galerie d’objets, cliquez sur
l’onglet XML et double-cliquez sur l’icône de l’expert Gestionnaire SAX
pour ouvrir ce dernier.
2 Spécifiez le nom de la classe et les noms de paquets ou acceptez les
noms par défaut.
2-20
Guide du développeur d’applications XML
Manipulation de XML par programme
3 Sélectionnez les interfaces et les méthodes à redéfinir et cliquez sur
Suivant.
4 Sélectionnez les options de l’Analyseur SAX que vous voulez et cliquez
sur Terminer.
L’expert génère une classe qui implémente un analyseur SAX. Pour
achever l’implémentation, vous devez ensuite remplir les corps des
méthodes avec le code.
5 Configurez la page Exécution des Propriétés du projet en sélectionnant
la classe principale à exécuter et en spécifiant le fichier XML à analyser
dans le champ Paramètres de l’application.
Pour avoir plus d’informations sur SAX, visitez le site
http://www.megginson.com/SAX/index.html.
Pour obtenir un tutoriel sur l’expert Gestionnaire SAX, consultez le
Chapitre 5, “Tutoriel : Création d’un Gestionnaire SAX pour analyser des
documents XML”.
Liaison de données
C’est une fonctionnalité
de JBuilder Entreprise.
La liaison de données permet d’accéder à des données et de les manipuler,
puis de renvoyer les données modifiées à la base de données ou de les
afficher avec un document XML. Le document XML peut servir de
mécanisme de transfert entre la base de données et l’application. Ce
transfert se fait en liant un objet Java à un document XML. La liaison de
données est implémentée en générant des classes Java pour représenter les
contraintes contenues dans une grammaire, par exemple dans une DTD
Utilisation des fonctionnalités XML de JBuilder
2-21
Manipulation de XML par programme
ou dans un schéma XML. Vous pouvez ensuite utiliser ces classes pour
créer ou lire des documents XML conformes à la grammaire et valider des
documents XML par rapport à la grammaire au fur et à mesure de leur
modification.
JBuilder offre plusieurs solutions de liaison de données : BorlandXML et
Castor Open Source. BorlandXML utilise des fichiers DTD, alors que
Castor génère des classes Java à partir de fichiers schéma (.xsd).
Voir aussi
Les spécifications de liaison de données XML à l’adresse
http://www.oasis-open.org/cover/xmlDataBinding.html
BorlandXML
BorlandXML fournit un mécanisme de liaison de données qui masque les
détails de XML, réduit la complexité du code et facilite la maintenance.
BorlandXML est un générateur de classes programmable basé sur des
templates et utilisé pour générer des classes JavaBean à partir d’une DTD
(Document Type Definition). Il vous suffit ensuite d’utiliser la convention
de programmation JavaBean simple pour manipuler des données XML
sans avoir à vous préoccuper des détails XML.
Pour générer des classes Java, BorlandXML utilise des DTD dans un
traitement en deux étapes. Dans la première étape, BorlandXML génère
un fichier de modèles de classes à partir d’une DTD. C’est un fichier XML
qui porte l’extension .bom. Il décrit une structure de haut niveau des
classes cibles et fournit un moyen de personnaliser ces classes. Dans la
deuxième étape, BorlandXML génère des classes Java à partir du fichier
.bom (fichier XML de modèles de classes).
BorlandXML prend en charge plusieurs fonctionnalités :
• Manipulation JavaBean : manipule un bean pour construire un
document XML ou accéder à des données dans le document.
• Marshalling et dé-marshalling : conversion entre Java et XML.
• Marshalling : écrit un document XML à partir d’objets JavaBean Java vers XML.
• Dé-marshalling : lit un document XML dans des objets JavaBean XML vers Java.
• Validation de documents : valide des objets JavaBean avant d’effectuer
un marshalling vers XML ou après le dé-marshalling d’un document
XML en objets JavaBean.
• Personnalisation de PCDATA : permet de personnaliser PCDATA pour
prendre en charge différents types de données primitifs, tels que les
types Integer et Long, et pour prendre en charge des noms de
propriétés personnalisées.
2-22
Guide du développeur d’applications XML
Manipulation de XML par programme
• Noms de variables : permet l’ajout d’un préfixe et d’un suffixe
personnalisés aux noms de variables générées pour des éléments et des
attributs.
Pour générer des classes Java à partir d’une DTD à l’aide de l’expert
Liaison de données,
1 Cliquez avec le bouton droit sur le fichier DTD dans le volet projet et
choisissez Générer Java pour ouvrir l’expert Liaison de données. De
cette façon, le champ Fichier DTD de l’expert est automatiquement
rempli avec le nom du fichier. L’expert Liaison de données est
également disponible sur l’onglet XML de la galerie d’objets (Fichier|
Nouveau).
2 Comme Type de liaison de données, sélectionnez BorlandXML, qui est
basé uniquement sur des DTD, puis cliquez sur Suivant.
3 Remplissez les champs obligatoires, tels que le nom et l’emplacement
de la DTD utilisée, l’élément racine et le nom du paquet.
4 Entrez un identificateur PUBLIC ou SYSTEM à insérer dans la
déclaration DOCTYPE.
5 Cliquez sur Terminer.
6 Dans le volet projet, développez le nœud du paquet généré pour voir
les fichiers .java générés par l’expert.
Pour obtenir un tutoriel sur la liaison de données avec BorlandXML,
consultez le Chapitre 6, “Tutoriel : Liaison de données DTD avec
BorlandXML”.
Utilisation des fonctionnalités XML de JBuilder
2-23
Manipulation de XML par programme
Castor
Castor est une structure de liaison de données XML qui met en
correspondance (affecte) une instance de schéma XML avec un modèle
d’objet qui représente les données. Ce modèle d’objet inclut un ensemble
de classes et de types ainsi que des descripteurs utilisés pour obtenir des
informations sur une classe et ses champs.
Castor utilise une structure de marshalling qui inclut un ensemble de
ClassDescriptors et de FieldDescriptors pour décrire comment faire le
marshalling et le dé-marshalling d’un Objet à partir de XML.
Pour les personnes qui connaissent mal les termes “marshalling” et
“dé-marshalling”, il s’agit simplement de l’action de conversion d’un flux
(séquence d’octets) de données vers ou à partir d’un Objet. Le
“marshalling” est la conversion d’un Objet en flux, et le “dé-marshalling”
d’un flux en Objet.
Pour créer des classes Java, Castor utilise un schéma au lieu de DTD. Les
schémas (XSD), plus robustes et souples, présentent plusieurs avantages
par rapport aux DTD. Les schémas sont des documents XML, alors que les
DTD contiennent une syntaxe non XML. Les schémas acceptent aussi des
espacenoms (namespace), qui sont obligatoires pour éviter les conflits de
noms et offrent plus de types de données et une plus grande prise en
charge de l’héritage.
Pour générer des classes Java à partir d’un schéma XML, utilisez l’expert
Liaison de données de la façon suivante :
1 Cliquez avec le bouton droit sur le fichier schéma (XSD) dans le volet
projet et choisissez Générer Java pour ouvrir l’expert Liaison de
données. De cette façon, le champ Fichier schéma XML de l’expert est
automatiquement rempli avec le nom du fichier. L’expert Liaison de
données est également disponible sur l’onglet XML de la galerie
d’objets (Fichier|Nouveau).
2 Comme Type de liaison de données, sélectionnez Castor qui prend les
schémas XML en charge, puis cliquez sur Suivant.
2-24
Guide du développeur d’applications XML
Interface avec des données métier dans des bases de données
3 Remplissez les champs obligatoires, tels que le nom du paquet, et
spécifiez vos options.
4 Cliquez sur Terminer.
5 Dans le volet projet, développez le nœud du paquet généré pour voir
les fichiers .java générés par l’expert.
Remarque
Par défaut, la fonction de marshalling de Castor écrit des documents XML
sans indentation, puisque cette dernière augmente la taille des documents
XML générés. Pour activer l’indentation, modifiez le fichier des propriétés
de Castor comme suit : org.exolab.castor.indent=true. Ce fichier contient
aussi d’autres propriétés qu’il peut être utile de modifier. Le fichier
castor.properties est automatiquement créé par l’expert Liaison de
données dans le répertoire source du projet.
Pour obtenir un tutoriel sur la liaison de données avec Castor, consultez le
Chapitre 7, “Tutoriel : Liaison de données par schéma avec Castor”.
Le répertoire extras de l’installation complète de JBuilder contient des
exemples et la documentation Castor ; vous pouvez également visiter le
site Web Castor à l’adresse http://castor.exolab.org.
Interface avec des données métier dans des bases de données
L’interfaçage avec
des données métier
est une fonctionnalité
de JBuilder Entreprise.
La prise en charge de bases de données XML dans JBuilder se décompose
en deux catégories - basée sur des modèles et basée sur des templates. La
solution basée sur des modèles utilise un document d’affectation qui
détermine comment les données sont transférées entre une structure XML
et les métadonnées de la base de données. Les composants basés sur des
modèles, XMLDBMSTable et XMLDBMSQuery, sont implémentés en utilisant
XML-DBMS, middleware XML Open Source fourni avec JBuilder.
Utilisation des fonctionnalités XML de JBuilder
2-25
Interface avec des données métier dans des bases de données
La solution basée sur des templates utilise un template, ou ensemble de
règles. Les composants basés sur des templates, XTable et XQuery, sont très
souples et il n’y a pas de relation prédéfinie entre le document XML et
l’ensemble de métadonnées que vous interrogez dans la base de données.
Pour plus d’informations sur les composants de bases de données XML,
voir Chapitre 3, “Utilisation des composants de bases de données XML
de JBuilder”.
Voir aussi
2-26
XML-DBMS à l’adresse http://www.rpbourret.com/xmldbms/
Guide du développeur d’applications XML
Chapitre
3
Utilisation des composants
de bases de données XML
de JBuilder
Chapitre3
C’est une fonctionnalité
de JBuilder Entreprise.
Un ensemble de composants, proposé sur la page XML de la palette de
composants, assure la prise en charge de bases de données XML par
JBuilder. Le code d’exécution des beans fait partie d’une bibliothèque
transmissible située dans Xbeans.jar.
La bibliothèque XBeans se compose de deux types de composants de
bases de données XML
• Composants basés sur des templates
• Composants basés sur des modèles
Pour utiliser des composants basés sur des templates, vous fournissez une
instruction SQL et le composant génère un document XML approprié.
Cette instruction SQL sert de template remplacé dans le document XML
en tant que résultat de l’application du template. La solution basée sur des
templates est très souple car il n’y a pas de relation prédéfinie entre le
document XML et l’ensemble de métadonnées que vous interrogez dans la
base de données. Bien que les composants basés sur des templates
permettent une grande souplesse dans l’extraction de données d’une base
et leur intégration dans le document XML, le format de ce dernier reste
relativement simple et élémentaire. En outre, les composants basés sur des
templates peuvent générer des documents HTML basés sur des feuilles de
style par défaut ou sur une feuille de style personnalisée fournie par
l’utilisateur.
Les composants basés sur des modèles utilisent un document d’affectation
qui détermine la méthode de transfert les données entre une structure
XML et les métadonnées d’une base de données. En raison de la
Utilisation des composants de bases de données XML de JBuilder
3-1
Utilisation des composants basés sur des templates
correspondance entre un élément du document XML et une table ou une
colonne particulière d’une base de données, des documents XML
profondément imbriqués peuvent être transférés vers et depuis un
ensemble de tables de base de données. Les composants basés sur des
modèles sont implémentés en utilisant XML-DBMS, middleware XML
Open Source fourni avec JBuilder.
Utilisation des composants basés sur des templates
Les deux composants basés sur des templates, XTable et XQuery, sont le
premier et le deuxième composants de la palette de composants de
JBuilder.
Pour obtenir un tutoriel sur l’utilisation des composants XML basés sur
des templates, consultez le Chapitre 9, “Tutoriel : Transfert de données
avec les composants base de données XML basés sur des templates”.
Pour commencer à utiliser ces composants, sélectionnez-en un sur la page
XML de la palette des composants et mettez-le dans le Concepteur
d’interface utilisateur ou dans le volet structure pour l’ajouter à votre
application.
Définition des propriétés des beans templates
Il y a trois façons de définir les propriétés des deux composants basés sur
des templates :
• Utilisation du personnaliseur de composants
• Utilisation de l’inspecteur
• Avec un document de requête XML
Utilisation du personnaliseur de composants
Chaque composant de base de données XML dispose de son propre
personnaliseur. L’utilisation d’un personnaliseur de composants est la
façon la plus facile de définir les propriétés du composant. Vous pouvez
même tester votre connexion JDBC, effectuer le transfert pour voir le
document généré et afficher le DOM (Document Object Model).
Pour afficher un personnaliseur de composants, cliquez avec le bouton
droit sur le composant dans le volet structure et choisissez Personnaliser
dans le menu déroulant.
3-2
Guide du développeur d’applications XML
Utilisation des composants basés sur des templates
Voici le personnaliseur de XTable :
Connexion JDBC
Dans la page Connexion JDBC, vous pouvez spécifier la connexion JDBC
vers la base de données contenant les données à utiliser pour créer un
document XML. Elle contient les champs suivants :
Pilote
Dans la liste déroulante, spécifiez le pilote JDBC à
utiliser. Les pilotes affichés en noir sont ceux que
vous avez installés. Les pilotes affichés en rouge
ne sont pas disponibles sur votre système.
URL
Spécifiez l’URL de la source de données
contenant les informations à utiliser pour créer un
document XML. Quand vous cliquez dans le
champ, il affiche le masque que vous devez
utiliser pour spécifier l’URL en fonction du pilote
JDBC choisi.
Nom d’utilisateur
Si nécessaire, entrez le nom d’utilisateur de la
source de données.
Mot de passe
Si nécessaire, entrez le mot de passe d’accès à la
source de données.
Propriétés avancées
Ajoutez toutes les propriétés avancées dont vous
avez besoin. Un clic sur le bouton points de
suspension affiche la boîte de dialogue Propriétés
avancées permettant d’ajouter des propriétés.
Utilisation des composants de bases de données XML de JBuilder
3-3
Utilisation des composants basés sur des templates
Si vous avez déjà défini une ou plusieurs connexions JBuilder vers des
sources de données, cliquez sur le bouton Choisir une connexion existante
et sélectionnez la connexion voulue. La plupart des Propriétés de la
connexion sont automatiquement remplies.
Pour tester la validité de votre connexion JDBC, cliquez sur le bouton
Tester la connexion. Le personnaliseur signale si la connexion a réussi ou
non.
Après avoir réussi une connexion, cliquez sur l’onglet Transfert.
Transfert
3-4
Fichier requête
Document de requête XML. L’utilisation d’un
document de requête XML est facultative. Si vous
utilisez un document de requête XML, vous n’avez
aucun autre champ à remplir dans le personnaliseur,
sauf le nom du Fichier de sortie et facultativement le
nom du Fichier XSL, puisque le document de
requête spécifie vos propriétés. Pour avoir plus
d’informations sur la création et l’utilisation d’un
document de requête XML, consultez “Document de
requête XML”, page 3-9.
Fichier de sortie
Spécifiez le nom du fichier XML ou HTML à
générer.
Guide du développeur d’applications XML
Utilisation des composants basés sur des templates
Fichier XSL
Spécifiez le nom du fichier feuille de style XSL à
utiliser pour transformer le fichier de sortie, s’il y en
a un. Si aucun fichier n’est spécifié, une feuille de
style par défaut est générée et mise dans le même
répertoire que le fichier de sortie. Le fichier XSL
généré porte le nom JBuilderDefault.xsl. Pour créer
une présentation plus personnalisée, le fichier XSL
peut être copié, puis modifié. Si vous souhaitez
modifier le fichier XSL, vérifiez que la propriété du
nom du Fichier XSL pointe vers le fichier modifié.
Remarquez que JBuilder ne remplace pas une feuille
de style par défaut existante.
Format de colonne
Spécifiez sous quelle forme faire apparaître les
colonnes de la source de données dans le fichier
XML généré, éléments ou attributs.
Format de sortie
Spécifiez si le fichier généré doit avoir le format
XML ou HTML.
Noms d’élément
Spécifiez le nom de l’élément Document et un autre
pour l’élément Ligne.
Ignorer les valeurs
nulles
Pour que les valeurs nulles soient ignorées dans
votre sortie XML, cochez cette case. Si cette case à
cocher reste vide, “null” sera utilisé en tant
qu’espace réservé.
Nom de table
Spécifiez le nom de la table contenant les données
qui vous intéressent.
Clés
Spécifiez la ou les clés qui identifient la ou les lignes
de la table à insérer dans le document XML généré.
Pour ajouter une clé, cliquez sur le bouton Ajouter.
Dans l’éditeur de la propriété tableau de type chaîne
qui apparaît, cliquez sur le bouton Ajouter pour
ajouter un élément au tableau. Modifiez le nom de
l’élément ajouté dans une colonne du tableau.
Continuez à ajouter dans l’éditeur toutes les clés
dont vous avez besoin. Si vous spécifiez un nom de
table sans préciser de clé, toutes les lignes de la table
seront renvoyées.
Utilisation des composants de bases de données XML de JBuilder
3-5
Utilisation des composants basés sur des templates
DefaultParams
Dans le cas d’une requête paramétrée, ce champ
permet de spécifier un paramètre par défaut. Si vous
précisez une valeur dans le champ Clé, vous devez
spécifier un paramètre par défaut pour la ou les
colonnes constituant une clé. Pour ajouter un
paramètre par défaut à votre requête, cliquez sur le
bouton Ajouter. Dans la boîte de dialogue
Paramètres par défaut qui apparaît, cliquez sur le
bouton Ajouter pour ajouter un paramètre par
défaut. Dans la ligne vide ajoutée, spécifiez le nom
du paramètre en tant que Nom du paramètre et la
valeur du paramètre en tant que Valeur du
paramètre. Par exemple, si la clé est EMP_NO,
spécifiez EMP_NO en tant que Nom du paramètre et
spécifiez la valeur à trouver dans la colonne
EMP_NO. Pensez à placer les valeurs du type chaîne
entre apostrophes. Pour plus d’informations sur
l’ajout de paramètres par défaut, voir “Spécification
des paramètres”, page 3-7.
Le personnaliseur de XQuery a un aspect très semblable. Comme XTable, il a
une page Connexion JDBC :
Remplissez cette page comme vous le feriez pour XTable et testez la
connexion.
3-6
Guide du développeur d’applications XML
Utilisation des composants basés sur des templates
La page Transfert du personnaliseur de XQuery diffère de celle de XTable
par le champ SQL qui remplace les champs Nom de table et Clés :
Dans le champ SQL, vous pouvez spécifier n’importe quelle instruction
SQL. Si votre instruction SQL est une requête paramétrée, vous devez
spécifier un paramètre par défaut pour chaque variable paramétrée.
Spécification des paramètres
Si votre requête est paramétrée, vous devez spécifier une valeur de
paramètre par défaut avant de générer le fichier XML ou HTML. A
l’exécution, vous pouvez remplacer la valeur du paramètre par défaut par
une autre valeur. Si aucun paramètre n’est fourni à l’exécution, le
paramètre par défaut est utilisé.
L’exemple de requête ci-dessous montre comment utiliser les paramètres
et les paramètres par défaut :
Select emp_name from employee where emp_no = :emp_no
Disons que la table Employee contient les entrées suivantes :
emp_no
emp_name
1
Tom
2
Dick
Il y a deux façons de fournir le paramètre :emp_no. Vous pouvez utiliser un
paramètre par défaut et/ou un paramètre fourni à l’exécution. Voici les
possibilités
• Aucun paramètre d’aucune sorte n’est spécifié. Résultat : la requête
renvoie une erreur.
Utilisation des composants de bases de données XML de JBuilder
3-7
Utilisation des composants basés sur des templates
• defaultParams a la valeur :emp_no = 1 et aucun paramètre d’exécution
n’est spécifié. Résultat : la requête renvoie Tom.
• defaultParams a la valeur :emp_no = 1 et un paramètre d’exécution a la
valeur :emp_no = 2. Résultat : la requête renvoie Dick.
En d’autres termes, si aucun paramètre n’est spécifié, le paramètre par
défaut est utilisé. Si un paramètre est spécifié à l’exécution, il est utilisé à la
place du paramètre par défaut, dont la valeur est ignorée. Les noms des
paramètres distinguent les minuscules des majuscules.
Transfert vers XML ou HTML
Pour voir les résultats de vos définitions de propriétés, cliquez sur le
bouton Transférer. Si vous décidez de créer un fichier XML, vous pouvez
cliquer sur le bouton Voir DOM (Document Object Model) :
3-8
Guide du développeur d’applications XML
Utilisation des composants basés sur des templates
Si vous avez choisi de générer un fichier HTML, un clic sur Voir HTML
affiche le document HTML résultant :
Utilisation de l’inspecteur
Vous pouvez définir également ces propriétés dans l’Inspecteur du
concepteur. Pour ouvrir l’Inspecteur,
• Sélectionnez l’onglet Conception dans le volet contenu. L’inspecteur est
affiché à droite du concepteur.
• Cliquez sur le champ à droite d’une propriété et entrez les informations
appropriées.
Document de requête XML
Une autre façon de définir la connexion et les options de transfert consiste
à utiliser un document de requête XML. Pour créer un document de
requête XML et le spécifier en tant que valeur du champ Fichier requête,
utilisez le personnaliseur de composants ou l’Inspecteur. Voici un
exemple de document de requête pour un XTable :
<Query>
<Options
OutputType=XML"
ColumnFormat="AsElements"
IgnoreNulls="True"
DocumentElement="MyDoc"
RowElement="YourRow">
<Connection
Url="jdbc:odbc:foodb"
Driver="sun.jdbc.odbc.JdbcOdbcDriver"
User="me"
Password="ok">
<Params>
<Param Name=":Part" Default="’ab-c’">
Utilisation des composants de bases de données XML de JBuilder
3-9
Utilisation des composants basés sur des templates
<Param Name=":Number" Default="2">
</Params>
<table name="LINES">
<Key Name="Number">
<Key Name="Part">
</table>
</Query>
La requête ci-dessus doit renvoyer le document XML suivant :
<MyDoc>
<YourRow>
<col1>des données</col1>
<col2>des données</col2>
<Number>2</Number>
<Part>ab-c</Part>
</YourRow>
<YourRow>
<col1>d’autres données</col1>
<col2>d’autres données</col2>
<Number>2</Number>
<Part>ab-c</Part>
</YourRow>
</MyDoc>
Remarque
Si le format des colonnes du document de requête a la valeur
“AsAttributes”, alors col1, col2, Number et Part seraient des attributs de
YourRow.
Voici un exemple de document de requête pour un XQuery :
<Query>
<Options
OutputType="XML"
ColumnFormat="AsElements"
IgnoreNulls="True"
DocumentElement="MyDoc"
RowElement="YourRow">
<Connection
Url="jdbc:odbc:foodb"
Driver="sun.jdbc.odbc.JdbcOdbcDriver"
User="me"
Password="ok">
<Params>
<Param Name=":Part" Default="’ab-c’">
<Param Name=":Number" Default="2">
</Params>
<Sql Value="SELECT * FROM LINES where Number >= :Number AND Number <= :Number"/
>
<!--L’exemple ci-dessus doit utiliser une section CDATA ou un échappement avec
des références aux entités lt/gt-->
</Query>
3-10
Guide du développeur d’applications XML
Utilisation des composants basés sur des modèles
Pour obtenir un tutoriel sur l’utilisation des composants XTable et XQuery,
consultez le Chapitre 9, “Tutoriel : Transfert de données avec les
composants base de données XML basés sur des templates”.
Utilisation des composants basés sur des modèles
Dans les composants basés sur des modèles, JBuilder utilise XML-DBMS.
XML-DBMS, middleware de transfert de données entre des documents
XML et des bases de données relationnelles, affecte des objets à la base de
données en utilisant une affectation d’objets relationnels. XML-DBMS est
redistribué avec JBuilder et se trouve dans le répertoire XML du CD
JBuilder. Vous pouvez trouver la documentation XML-DBMS dans le
répertoire jbuilder5\extras\xmldbms\docs.
Pour effectuer réellement le transfert de données XML-DBMS, JBuilder
fournit deux beans : XMLDBMSTable et XMLDBMSQuery, qui sont les troisième et
quatrième beans sur la palette de composants au-dessus du concepteur de
JBuilder. XMLDBMSTable utilise une table spécifiée et des clés en tant que
critère de sélection du transfert, alors que XMLDBMSQuery se sert des résultats
d’une requête SQL.
Pour obtenir un tutoriel sur l’utilisation des composants XML basés sur
des modèles, consultez le Chapitre 8, “Tutoriel : Transfert de données
avec les composants base de données XML basés sur des modèles”.
Pour mettre un bean dans votre application, choisissez l’onglet
Conception et cliquez sur l’onglet XML de la palette de composants.
Choisissez un bean et mettez-le dans le concepteur.
XML-DBMS
La solution XML-DBMS se compose de :
• Une base de données relationnelle avec un pilote JDBC
• Un document XML servant à l’entrée et à la sortie des données
• Un document d’affectation XML qui définit l’affectation entre la base
de données et le document XML
• Une bibliothèque contenant un ensemble de méthodes API pour
transférer des données entre la base et le document XML
Au cœur de XML-DBMS se trouve le document d’affectation spécifié dans
XML. Il est défini par un langage d’affectation et est documenté dans la
distribution de XML-DBMS. Pour avoir plus d’informations, consultez la
documentation et les sources XML-DBMS.
Utilisation des composants de bases de données XML de JBuilder
3-11
Utilisation des composants basés sur des modèles
Les éléments principaux du langage d’affectation incluent :
ClassMap
ClassMap est la racine de l’affectation. Un ClassMap affecte une table de
base de données à des éléments XML qui contiennent d’autres éléments
(modèles de contenu d’éléments). En outre, un ClassMap imbrique
PropertyMaps et RelatedClassMap.
PropertyMap
PropertyMap affecte des éléments uniquement PCDATA et des attributs
de valeur simple à des colonnes spécifiques dans une table de base de
données.
RelatedClassMap
RelatedClassMap affecte des relations entre classes. Cela se fait par
référence à un autre ElementType (par exemple, ClassMap) déclaré
quelque part ailleurs et par spécification de la base de la relation.
L’affectation spécifie la clé primaire et la clé étrangère utilisées dans la
relation, et indique laquelle des deux tables contient la clé primaire.
Remarquez que l’identificateur CandidateKey sert à représenter une clé
primaire.
En outre, la génération de clé est prise en charge. Dans certains scénarios,
les clés sont des données métier réelles telles que NoClient ou NoEmp.
Dans d’autres, il faut créer des clés juste pour les besoins de la liaison.
Cela est possible en intégrant un attribut généré à la définition de la clé
respective.
Si nécessaire, un orderColumn facultatif avec génération automatique de
clé est également pris en charge par l’affectation.
MiscMaps et Options
Outre les affectations ci-dessus, il y en a quelques autres pour gérer les
valeurs nulles, ignorer un élément racine sans données en correspondance
dans la base de données mais servant uniquement d’élément de
regroupement, et les formats de date et d’heure.
JBuilder et XML-DBMS
JBuilder assure la prise en charge XML-DBMS suivante :
•
•
•
•
3-12
Expert XML-DBMS
XModelBean : classe de base pour XMLDBMSTable et XMLDBMSQuery
XMLDBMSTable : transfert des données sur la base d’une table et d’une clé
XMLDBMSQuery : transfert des données sur la base d’un ensemble de
résultats défini par une requête SQL
Guide du développeur d’applications XML
Utilisation des composants basés sur des modèles
Expert XML-DBMS
L’expert XML-DBMS de JBuilder fait partie de la solution basée sur des
modèles et sur l’affectation qui utilise l’API Map_Factory_DTD dans
XML-DBMS. A partir d’une DTD donnée, l’expert génère un document
template d’affectation et un fichier script SQL pour créer les métadonnées.
Dans tous les cas, sauf les plus simples, le document d’affectation ne sert
que de point de départ à la création de l’affectation nécessaire. Le script
SQL, ensemble d’instructions Create Table, doit être également modifié
puisque XML-DBMS ne régénère pas les scripts SQL à partir du document
d’affectation modifié.
Actuellement, XML-DBMS ne prend pas en charge la création d’un fichier
d’affectation à partir d’un schéma de base de données. Si vous commencez
par une base de données existante, vous devez créer manuellement le
fichier d’affectation. Si vous avez le document XML, vous pouvez l’ouvrir
et cliquez dessus avec le bouton droit pour générer la DTD. Ensuite, vous
pouvez utiliser la DTD générée pour générer le fichier d’affectation et le
modifier pour qu’il corresponde au schéma de la base de données.
Pour utiliser l’expert XML-DBMS,
1 Sélectionnez Fichier|Nouveau, puis cliquez sur l’onglet XML de la
galerie d’objets.
2 Double-cliquez sur l’icône XML-DBMS.
Utilisation des composants de bases de données XML de JBuilder
3-13
Utilisation des composants basés sur des modèles
Dans la première page, vous pouvez spécifier la connexion JDBC vers
la base de données contenant les données à utiliser pour créer un
document XML. Elle contient les champs suivants :
Pilote
Dans la liste déroulante, spécifiez le pilote
JDBC à utiliser. Les pilotes affichés en noir sont
ceux que vous avez installés. Les pilotes
affichés en rouge ne sont pas disponibles sur
votre système.
URL
Spécifiez l’URL de la source de données
contenant les informations à utiliser pour créer
un document XML. Quand vous cliquez dans
le champ, il affiche le masque que vous devez
utiliser pour spécifier l’URL en fonction du
pilote JDBC choisi.
Nom d’utilisateur
Si nécessaire, entrez le nom de l’utilisateur de
la source de données.
Mot de passe
Si nécessaire, entrez le mot de passe d’accès à
la source de données.
Propriétés avancées
Ajoutez toutes les propriétés avancées dont
vous avez besoin. Un clic sur le bouton points
de suspension affiche la boîte de dialogue
Propriétés avancées permettant d’ajouter des
propriétés.
Si vous avez déjà défini une ou plusieurs connexions JBuilder vers des
sources de données, cliquez sur le bouton Choisir une connexion
existante et sélectionnez la connexion voulue. La plupart des Propriétés
de la connexion sont automatiquement remplies.
Pour tester la validité de votre connexion JDBC, cliquez sur le bouton
Tester la connexion. Le personnaliseur signale si la connexion a réussi
ou non.
3-14
Guide du développeur d’applications XML
Utilisation des composants basés sur des modèles
3 Après avoir obtenu la connexion, cliquez sur Suivant.
Cette page permet de spécifier la DTD que vous utilisez pour générer le
fichier d’affectation et le script SQL de création de la table de base de
données. Remplissez les champs suivants :
Fichier DTD
Spécifiez un fichier DTD existant.
Répertoire de sortie
Acceptez le nom par défaut ou modifiez-le
comme bon vous semble.
Fichier d’affectation
Spécifiez le nom du fichier d’affectation à
générer.
Fichier script SQL
Spécifiez le nom du fichier script SQL à générer.
4 Cliquez sur OK pour fermer l’expert. L’expert génère les fichiers
d’affectation et SQL, puis les ajoute à votre projet.
Supposons, par exemple, que vous ayez une DTD appelée request.dtd :
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
<!ELEMENT
request (req_name, parameter*)>
parameter (para_name, type, value)>
req_name (#PCDATA)>
para_name (#PCDATA)>
type (#PCDATA)>
value (#PCDATA)>
L’expert XML-DBMS générera le fichier request.map suivant :
<?xml version=’1.0’ ?>
<!DOCTYPE XMLToDBMS SYSTEM "xmldbms.dtd" >
<XMLToDBMS Version="1.0">
<Options>
</Options>
<Maps>
<ClassMap>
Utilisation des composants de bases de données XML de JBuilder
3-15
Utilisation des composants basés sur des modèles
<ElementType Name="request"/>
<ToRootTable>
<Table Name="request"/>
<CandidateKey Generate="Yes">
<Column Name="requestPK"/>
</CandidateKey>
</ToRootTable>
<PropertyMap>
<ElementType Name="req_name"/>
<ToColumn>
<Column Name="req_name"/>
</ToColumn>
</PropertyMap>
<RelatedClass KeyInParentTable="Candidate">
<ElementType Name="parameter"/>
<CandidateKey Generate="Yes">
<Column Name="requestPK"/>
</CandidateKey>
<ForeignKey>
<Column Name="requestFK"/>
</ForeignKey>
</RelatedClass>
</ClassMap>
<ClassMap>
<ElementType Name="parameter"/>
<ToClassTable>
<Table Name="parameter"/>
</ToClassTable>
<PropertyMap>
<ElementType Name="para_name"/>
<ToColumn>
<Column Name="para_name"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="type"/>
<ToColumn>
<Column Name="type"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="value"/>
<ToColumn>
<Column Name="value"/>
</ToColumn>
</PropertyMap>
</ClassMap>
</Maps>
</XMLToDBMS>
L’expert XML-DBMS générera le fichier request.map suivant :
CREATE TABLE "request" ("req_name" VARCHAR(255), "requestPK" INTEGER);
CREATE TABLE "parameter" ("para_name" VARCHAR(255), "type" VARCHAR(255),
"requestFK" INTEGER, "value" VARCHAR(255));
3-16
Guide du développeur d’applications XML
Utilisation des composants basés sur des modèles
CREATE TABLE XMLDBMSKey (HighKey Integer);
INSERT INTO XMLDBMSKey VALUES (0);
Une fois les fichiers d’affectation et script SQL obtenus, vous pouvez les
modifier comme bon vous semble. Par exemple, bien qu’un nom
d’élément puisse être “HireDate”, vous savez que le nom réel de la
colonne est “Date_Hired”. Vous pouvez faire cette modification
directement sur le fichier d’affectation. Généralement, le fichier script SQL
est simplement un point de départ à la création du type de table voulu ;
vous avez donc souvent besoin de le modifier.
Lorsque vous êtes satisfait de votre fichier script SQL, exécutez-le pour
créer les tables de la base de données. Un moyen simple consiste à copier
les instructions SQL dans le Pilote de base de données, puis à cliquer sur le
bouton Exécuter. Pour avoir plus d’informations sur le Pilote de base de
données, consultez le “Guide du développeur d’applications bases de
données : Pilote de base de données”. Pour avoir des informations
spécifiques sur l’exécution d’instructions SQL, consultez la rubrique
“Exécution d’instructions SQL” dans le chapitre consacré à
l’administration des bases de données du Guide du développeur
d’applications bases de données.
Définition des propriétés des composants basés sur des
modèles
Une fois que vous avez le fichier XML, le fichier d’affectation et les tables
de la base de données, vous êtes prêt à utiliser des beans modèles pour
transférer des données entre le fichier XML et la table, dans les deux sens.
Il y a deux façons de définir les propriétés d’un bean modèle :
• Utilisation du personnaliseur de composants
• Utilisation de l’inspecteur
Utilisation du personnaliseur de composants
Pour afficher le personnaliseur d’un composant, cliquez avec le bouton
droit sur le composant dans le volet structure et choisissez Personnaliser
dans le menu contextuel.
Utilisation des composants de bases de données XML de JBuilder
3-17
Utilisation des composants basés sur des modèles
Voici le personnaliseur de XMLDBMSTable:
Connexion JDBC
Dans la page Connexion JDBC, vous pouvez spécifier la connexion JDBC
vers la base de données contenant les données à utiliser pour créer un
document XML. Elle contient les champs suivants :
Pilote
Dans la liste déroulante, spécifiez le pilote JDBC à
utiliser. Les pilotes affichés en noir sont ceux que
vous avez installés. Les pilotes affichés en rouge ne
sont pas disponibles sur votre système.
URL
Spécifiez l’URL de la source de données contenant
les informations à utiliser pour créer un document
XML. Quand vous cliquez dans le champ, il affiche
le masque que vous devez utiliser pour spécifier
l’URL en fonction du pilote JDBC choisi.
Nom d’utilisateur
Si nécessaire, entrez le nom de l’utilisateur de la
source de données.
Mot de passe
Si nécessaire, entrez le mot de passe d’accès à la
source de données.
Propriétés avancées
Ajoutez toutes les propriétés avancées dont vous
avez besoin. Un clic sur le bouton points de
suspension affiche la boîte de dialogue Propriétés
avancées permettant d’ajouter des propriétés.
Si vous avez déjà défini une ou plusieurs connexions JBuilder vers des
sources de données, cliquez sur le bouton Choisir une connexion existante
et sélectionnez la connexion voulue. La plupart des Propriétés de la
connexion sont automatiquement remplies.
3-18
Guide du développeur d’applications XML
Utilisation des composants basés sur des modèles
Pour tester la validité de votre connexion JDBC, cliquez sur le bouton
Tester la connexion. Le personnaliseur signale si la connexion a réussi ou
non.
Après avoir réussi une connexion, cliquez sur l’onglet Transfert.
Transfert
Dans la deuxième page de l’expert, spécifiez si vous transférez des
données depuis un document XML vers la base de données ou l’inverse, et
remplissez les informations obligatoires pour que le transfert soit possible.
Pour transférer des données depuis un fichier XML vers la base de
données, suivez ces étapes :
1 Modifiez le fichier XML pour qu’il contienne les valeurs à transférer
vers la table de la base de données.
2 Sur la page Transfert du personnaliseur de XMLDBMSTable, mettez dans le
champ Fichier XML d’entrée le nom du fichier XML qui contient les
informations à transférer vers la base de données.
3 Spécifiez dans le champ Fichier d’affectation celui que vous avez créé.
Les deux champs restants sont désactivés pour ce type de transfert.
4 Cliquez sur le bouton Transférer.
Pour voir le résultat du transfert, utilisez Outils|Pilote de base de données
pour ouvrir la table et voir son contenu.
Pour transférer des données depuis la base de données vers le fichier
XML, suivez ces étapes :
1 Cliquez sur le bouton radio DB vers XML.
2 Mettez dans le champ Fichier XML de sortie le nom du fichier XML qui
va recevoir les données transférées depuis la base de données.
Utilisation des composants de bases de données XML de JBuilder
3-19
Utilisation des composants basés sur des modèles
3 Spécifiez dans le champ Fichier d’affectation celui que vous avez créé.
4 Spécifiez dans le champ Nom de table le nom de la table d’où
proviennent les données transférées.
5 Spécifiez la ou les valeurs de la clé primaire pour identifier le ou les
enregistrements à transférer. Par exemple, si EMP_NO est la clé
primaire et si vous voulez transférer les données de l’employé numéro
5, donnez à Key Value la valeur 5. Pour déterminer la clé, regardez
votre fichier d’affectation. Vous la voyez en tant que “CandidateKey”
sous le nœud <RootTable> de la table donnée.
6 Choisissez Transférer.
Pour voir le résultat du transfert, choisissez Voir DOM pour voir la
structure du fichier XML après le transfert.
3-20
Guide du développeur d’applications XML
Utilisation des composants basés sur des modèles
La page Transfert d’un XMLDBMSQuery est différente :
Avec un XMLDBMSQuery, vous pouvez spécifier une requête SQL pour
transférer des données depuis la base de données vers le document XML.
Pour transférer des données depuis la base de données vers le fichier
XML :
1
2
3
4
Spécifiez le nom du Fichier XML de sortie.
Spécifiez le nom du Fichier d’affectation.
Entrez votre instruction SQL dans le champ SQL.
Choisissez Transférer.
Regardez le résultat du transfert en choisissant Voir DOM.
Utilisation de l’inspecteur
Vous pouvez également définir les propriétés des beans basés sur des
modèles avec l’Inspecteur du concepteur. Pour ouvrir l’Inspecteur,
1 Sélectionnez l’onglet Conception dans le volet contenu. L’inspecteur est
affiché à droite du concepteur.
2 Cliquez sur le champ à droite d’une propriété et entrez les informations
appropriées.
Pour obtenir un tutoriel illustrant l’utilisation des composants XMLDBMSTable
et XMLDBMSQuery, consultez le Chapitre 8, “Tutoriel : Transfert de données
avec les composants base de données XML basés sur des modèles”.
Utilisation des composants de bases de données XML de JBuilder
3-21
3-22
Guide du développeur d’applications XML
Chapitre
4
Tutoriel : Validation
et transformation
de documents XML
Chapitre4
Présentation
Ce tutoriel utilise
des fonctionnalités
de JBuilder Professionnel
et de JBuilder Entreprise.
Il vous montre, étape après étape, comment utiliser les fonctionnalités
XML de JBuilder pour créer un document XML à partir d’une DTD, ainsi
que pour valider et transformer des documents XML. Le répertoire
samples/tutorials/XML/presentation/ de JBuilder contient des exemples. Une
DTD et des feuilles de style (XSL) sont fournies en tant qu’exemples.
Ce tutoriel suppose que vous avez déjà travaillé avec JBuilder et XML. Si
vous n’avez jamais utilisé JBuilder, consultez “L’environnement de
JBuilder” dans Construction d’applications.
Des exemples spécifiques vous montrent comment réaliser les tâches
suivantes :
• Créer un document XML à partir d’une DTD existante.
• Modifier le document XML généré à l’aide des véritables données - ID
employé, nom, adresse professionnelle, etc.
• Valider le document XML par comparaison avec la DTD.
• Utiliser l’EDI de JBuilder pour rechercher une erreur dans le document
XML.
• Associer des feuilles de style au document.
• Transformer le document XML par application de plusieurs feuilles de
style.
Tutoriel : Validation et transformation de documents XML
4-1
Etape 1 : Création d’un document XML à partir d’une DTD
• Définir des options de suivi de la transformation.
• Afficher le document XML à l’aide du visualiseur XML et de la vue
arborescente de la feuille de style par défaut de JBuilder.
Pour plus d’informations sur les fonctionnalités XML de JBuilder, voir les
chapitres 2 et 3.
Etape 1 : Création d’un document XML à partir d’une DTD
Un expert JBuilder permet de créer rapidement un document XML à
partir d’une DTD existante. Commencez par créer un document XML à
partir de l’exemple Employees.dtd.
1 Ouvrez presentation.jpx dans le répertoire samples de JBuilder : samples/
Tutorials/XML/presentation/.
Remarque
Si vous avez installé JBuilder en tant que ’racine’ (root), mais l’exécutez
sous votre compte utilisateur normal, vous devez copier le répertoire
entier des exemples dans un répertoire où vous avez tous les droits de
lecture/écriture pour les exécuter.
2 Pour ouvrir l’expert DTD vers XML, dans le volet projet, cliquez avec le
bouton droit sur Employees.dtd, puis choisissez Générer XML.
Sélectionner le fichier DTD remplit automatiquement le champ Fichier
DTD d’entrée dans l’expert. Il est également possible d’ouvrir l’expert à
partir de la galerie d’objets (Fichier|Nouveau|XML).
3 Cliquez sur la flèche déroulante en regard du champ Elément racine
pour afficher la liste d’éléments, puis choisissez XmlEmployees. Veillez à
NE PAS choisir XmlEmployee.
4 Appuyez sur les points de suspension en regard du champ Fichier XML
de sortie et, dans le champ Nom de fichier, remplacez le nom par
défaut du fichier XML par MyEmployees.xml. Choisissez OK pour fermer
la boîte de dialogue.
5 Dans le champ Système, entrez le nom du fichier DTD : Employees.dtd.
Cela génère la déclaration DOCTYPE, qui indique au document XML
qu’une DTD est en cours d’utilisation :
<!DOCTYPE XmlEmployees SYSTEM "Employees.dtd">
4-2
Guide du développeur d’applications XML
Etape 2 : Insertion des données dans le document XML généré
L’expert DTD vers XML doit ressembler à ceci :
6 Cliquez sur OK pour fermer l’expert.
7 Enregistrez le projet.
JBuilder génère à partir de la DTD un document XML qu’il appelle
MyEmployees.xml. Le document XML s’ouvre dans l’éditeur et s’ajoute au
projet. JBuilder utilise des paramètres fictifs pcdata entre les balises XML,
par exemple, <EmpNo>pcdata</EmpNo>. Vous remarquerez également que
Employees.dtd, que vous avez entré dans l’expert DTD vers XML, dans le
champ de l’identificateur SYSTEM, est présent dans la déclaration
DOCTYPE.
Ensuite, il vous faut modifier le document XML et remplacer les
paramètres fictifs pcdata par les véritables données.
Etape 2 : Insertion des données dans le document XML généré
Nous allons maintenant entrer les véritables données pour chaque
élément.
1 Créez un deuxième enregistrement employé. Pour cela, copiez les
balises <XmlEmployee> </XmlEmployee> et tout ce qu’elles contiennent.
Collez la copie sous cet enregistrement. Sélectionnez chacun des
paramètres fictifs pcdata et entrez les données de la manière suivante :
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE XmlEmployees SYSTEM "Employees.dtd">
<XmlEmployees>
<XmlEmployee>
<EmpNo>2</EmpNo>
<FirstName>Robert</FirstName>
<LastName>Nelson</LastName>
Tutoriel : Validation et transformation de documents XML
4-3
Etape 3 : Validation du document XML
<PhoneExt>250</PhoneExt>
<HireDate>1988-12-28</HireDate>
<DeptNo>600</DeptNo>
<JobCode>VP</JobCode>
<JobGrade>2</JobGrade>
<JobCountry>USA</JobCountry>
<Salary>105900.000000</Salary>
<FullName>Nelson, Robert</FullName>
</XmlEmployee>
<XmlEmployee>
<EmpNo>4</EmpNo>
<FirstName>Bruce</FirstName>
<LastName>Young</LastName>
<PhoneExt>233</PhoneExt>
<HireDate>1988-12-28</HireDate>
<DeptNo>621</DeptNo>
<JobCode>CEO</JobCode>
<JobGrade>2</JobGrade>
<JobCountry>Eng</JobCountry>
<Salary>97500.000000</Salary>
<FullName>Young, Bruce</FullName>
</XmlEmployee>
</XmlEmployees>
2 Enregistrez le projet.
Etape 3 : Validation du document XML
Dans XML, il y a deux types de validation : construction correcte et
validité grammaticale. Pour qu’un document ait une construction
correcte, sa structure physique et sa syntaxe doivent respecter les règles
XML. Par exemple, tous les documents XML doivent avoir un élément
racine. Si un document a une construction correcte, les DTD externes ne
sont pas contrôlées.
Par contre, un document XML valide est un document dont la
construction est correcte mais qui respecte aussi les règles plus strictes
spécifiées dans la DTD (Document Type Definition). La DTD décrit la
structure d’un document, spécifie quels types d’éléments sont autorisés et
définit les propriétés de chaque élément.
JBuilder assure les deux types de validation. Si un document n’a pas une
construction correcte, les erreurs s’affichent dans un dossier Erreurs du
volet structure. S’il comporte des erreurs de grammaire, ces dernières
s’affichent dans le volet message.
Ce document a une construction correcte car le dossier Erreurs n’apparaît
pas dans le volet structure. Pour introduire une erreur, supprimez
l’élément racine du document. Tous les documents XML doivent avoir un
élément racine.
4-4
Guide du développeur d’applications XML
Etape 3 : Validation du document XML
Introduisez volontairement une erreur dans ce document, bien que sa
construction soit correcte, pour voir comment JBuilder affiche les erreurs.
1 Dans l’éditeur, sélectionnez l’élément racine, <XmlEmployees> et
coupez-le. Comme un document correctement construit doit comporter
un élément racine, votre opération devrait entraîner l’affichage d’une
erreur. Remarquez qu’un dossier Erreurs s’affiche dans le volet
structure. Ouvrez le dossier Erreurs et sélectionnez l’erreur pour la
mettre en évidence dans le code. Double-cliquez sur l’erreur pour
amener la focalisation dans l’éditeur, sur la ligne de code qui la
contient. La ligne de code indiquée par le message d’erreur n’est pas
forcément à l’origine de l’erreur. Dans cet exemple, l’erreur, illegal
character at end of document, se produit parce que la balise de début de
l’élément racine est absente.
2 Réintroduisez l’élément racine ou collez-le dans l’éditeur. Remarquez
la disparition du dossier Erreurs. Le document a de nouveau une
construction correcte.
Ensuite, vérifiez que le document a une syntaxe grammaticale correcte
selon la DTD.
1 Dans le volet projet, cliquez avec le bouton droit sur MyEmployees.xml,
puis choisissez Valider. Un message s’affiche dans une boîte de
dialogue Succès, pour indiquer que le document est valide.
2 Pour introduire une erreur de validation, sélectionnez la déclaration
DOCTYPE et coupez-la :
<!DOCTYPE XmlEmployees SYSTEM "Employees.dtd">
3 Revalidez le document. La page Trace de validation XML qui s’affiche
dans le volet message contient un nœud ERREUR.
4 Développez ce nœud ERREUR dans le volet message pour afficher
l’erreur :
MYEMPLOYEES.XML est incorrect
ERREUR
Il n’y a aucun DTD ou Schéma présent dans ce document
5 Réintroduisez ou collez la déclaration DOCTYPE dans le document.
6 Pour introduire une autre erreur, remplacez le N majuscule par un n
minuscule dans <FirstName> pour obtenir <Firstname>.
7 Cliquez avec le bouton droit de la souris sur le fichier XML et choisissez
Valider. Remarquez les messages d’erreur :
MYEMPLOYEES.XML est incorrect
ERREUR
Element type "Firstname" must be declared.
FATAL_ERROR
Tutoriel : Validation et transformation de documents XML
4-5
Etape 4 : Association de feuilles de style au document
The element type "Firstname" must be terminated by the matching
end-tag "</Firstname>".
Il y a deux erreurs ici : l’élément Firstname n’est pas déclaré dans la DTD
et ne comporte pas de balise de fermeture.
8 Remplacez <Firstname> par <FirstName>.
9 Cliquez avec le bouton droit de la souris sur le fichier XML et choisissez
Valider. Votre document est de nouveau correct.
Etape 4 : Association de feuilles de style au document
La conversion d’un document XML en un autre type de document est
appelée transformation XML. La feuille de style par défaut de JBuilder est
écrite en XSLT (Extensible Style Language Transformations) et affiche les
documents dans une vue arborescente sous l’onglet Vue du volet contenu.
Vous pouvez aussi ajouter une feuille de style personnalisée.
Regardons MyEmployees.xml tel qu’il apparaît avec la feuille de style par
défaut de JBuilder, puis sans feuille de style.
1 MyEmployees.xml étant ouvert dans l’éditeur, choisissez l’onglet Vue pour
afficher le document avec la feuille de style par défaut, dont
l’application donne une vue arborescente réductible. Cliquez sur les
symboles plus (+) et moins (–) pour développer et réduire
l’arborescence.
Remarque
4-6
Si l’onglet Vue n’est pas disponible dans le volet contenu, activez le
visualiseur XML de JBuilder dans la boîte de dialogue Options de
l’EDI. Choisissez Outils|Options de l’EDI et, sur la page XML de la
boîte de dialogue, activez l’option Activer la vue du navigateur.
Remarquez que l’option Appliquer la feuille de style par défaut est
activée par défaut. Cliquez sur OK pour fermer la boîte de dialogue.
Guide du développeur d’applications XML
Etape 4 : Association de feuilles de style au document
Regardons maintenant le document XML sans feuille de style :
2 Désactivez l’option Appliquer la feuille de style par défaut sur la page
XML de la boîte de dialogue Options de l’EDI (Outils|Options de
l’EDI).
3 Cliquez sur OK pour fermer la boîte de dialogue. Remarquez que le
document s’affiche maintenant sans aucun style, sur une ligne
continue.
Remarque
Il peut être utile de basculer entre la source et l’affichage du document.
4 Réactivez l’option feuille de style pour qu’elle soit de nouveau
disponible.
Pour appliquer une feuille de style personnalisée dans JBuilder,
associez-la au document. Vous pourriez aussi inclure une instruction de
traitement XSLT dans votre document et dans les feuilles de style.
Ensuite, associez les feuilles de style à votre document de la manière
suivante :
1 Choisissez l’onglet Vue de la transformation. Remarquez le message
indiquant qu’aucune feuille de style n’est associée au document.
2 Sur la barre d’outils de la Vue de la transformation, cliquez sur le
bouton Ajouter des feuilles de style pour ouvrir la boîte de dialogue
Configurer les feuilles de styles du nœud.
3 Choisissez le bouton Ajouter, puis ouvrez le répertoire xsls contenant
les feuilles de style. Sélectionnez EmployeesListView.xsl. Cliquez à
nouveau sur Ajouter pour ajouter la deuxième feuille de style,
EmployeesTableView.xsl. Les feuilles de style XSL sont désormais
associées au document. Cliquez sur OK pour fermer la boîte de
dialogue.
Remarque
Vous pouvez également ajouter des feuilles de style dans la boîte de
dialogue Propriétés. Cliquez avec le bouton droit sur le document XML
dans le volet projet et choisissez Propriétés.
Tutoriel : Validation et transformation de documents XML
4-7
Etape 5 : Transformation du document à l’aide de feuilles de style
Etape 5 : Transformation du document à l’aide de feuilles de style
Maintenant que les feuilles de style sont liées au document XML, vous
pouvez transformer le document en utilisant différentes feuilles de style.
Les feuilles de style que vous avez associées sont proposées dans une liste
déroulante, sur la barre d’outils Vue de la transformation.
Remarquez que MyEmployees.xml s’affiche sous forme de la vue
arborescente par défaut. La vue de la transformation utilise cette feuille de
style par défaut si le document ne dispose pas d’autres feuilles de style.
Désactivez cette vue, puis appliquez une feuille de style.
1 Pour désactiver la vue arborescente, cliquez sur le bouton Feuille de
style par défaut, qui était activé.
2 Dans la liste déroulante des feuilles de style, choisissez
EmployeesListView.xsl. La vue de la transformation applique la feuille de
style sélectionnée pour afficher le document sous forme de liste.
L’onglet Source de la vue de la transformation affiche le code source du
document transformé. Votre document XML doit se présenter ainsi :
4-8
Guide du développeur d’applications XML
Etape 6 : Définition des options de suivi de la transformation
3 Choisissez EmployeesTableView.xsl dans la liste déroulante pour
appliquer la deuxième feuille de style. Le document est transformé en
tableau dans la vue de la transformation.
Etape 6 : Définition des options de suivi de la transformation
Il est possible de définir les options de suivi de la transformation de
manière à suivre les modifications apportées par application de la feuille
de style en cas de transformation. Ces options incluent Génération,
Modèles, Eléments et Sélections. Le suivi se trouve dans le volet message.
Cliquez sur un suivi met en évidence le code source correspondant.
Double-cliquer sur un suivi envoie la focalisation sur le code source dans
l’éditeur pour que vous puissiez commencer à le modifier.
Pour définir les options de suivi,
1 Cliquez sur le bouton Définir les options de suivi de la barre d’outils
Vue de la transformation ou choisissez Outils|Options de l’EDI et
cliquez sur l’onglet XML.
2 Sélectionnez toutes les options de suivi, puis choisissez OK.
Ensuite, appliquez la feuille de style EmployeesListView.xsl à
MyEmployees.xml et remarquez la transformation qui s’opère dans le volet
message.
1 Dans la liste déroulante des feuilles de style, choisissez
EmployeesListView.xsl. Remarquez que la transformation entraîne
l’affichage du volet message et de quatre nœuds : génération, modèles,
éléments, sélections.
Tutoriel : Validation et transformation de documents XML
4-9
Etape 6 : Définition des options de suivi de la transformation
• création : donne des informations sur chacun des événements
survenus dans la génération de l’arborescence, tels que le document
et l’élément de début, les caractères, etc.
• modèles : montre un événement à chaque appel d’un modèle.
• éléments : montre les événements se produisant à l’exécution de
chaque nœud de la feuille de style.
• sélections : présente des informations après chaque événement de
sélection.
2 Développez chaque nœud pour afficher le déroulement de la
transformation du document.
4-10
Guide du développeur d’applications XML
Chapitre
5
Tutoriel : Création d’un
Gestionnaire SAX pour analyser
des documents XML
Chapitre5
Présentation
Ce tutoriel utilise
des fonctionnalités
de JBuilder Entreprise.
Il vous montre, étape après étape, comment utiliser l’expert Gestionnaire
SAX de JBuilder pour créer un analyseur SAX à utiliser avec vos
documents XML. Le répertoire samples/Tutorials/XML/saxparser/ de
JBuilder contient des exemples l’illustrant. Ce tutoriel utilise un exemple
de document XML contenant des données telles que le numéro d’un
employé, son prénom, son nom de famille et son nom complet.
SAX, acronyme de Simple API pour XML, est une interface standard pour
l’analyse XML basée sur les événements. Il y a deux types d’API XML : les
API basées sur des arborescences et les API basées sur des événements.
SAX, API basée sur des événements, signale directement des événements
d’analyse à l’application au moyen de callbacks. L’application implémente
des gestionnaires pour traiter les différents événements, pour obtenir une
gestion semblable à celle des événements dans une interface utilisateur
graphique.
JBuilder facilite l’utilisation de SAX pour manipuler votre XML par
programme. L’expert Gestionnaire SAX crée un template
d’implémentation de l’analyseur SAX qui n’inclut que les méthodes à
implémenter pour analyser votre XML.
Tutoriel : Création d’un Gestionnaire SAX pour analyser des documents XML
5-1
Etape 1 : Utilisation de l’expert Gestionnaire SAX
Des exemples spécifiques vous montrent comment réaliser les tâches
suivantes :
• Créer un analyseur SAX avec l’expert Gestionnaire SAX.
• Modifier le code de l’analyseur SAX pour personnaliser l’analyse.
• Exécuter le programme et afficher les résultats de l’analyse.
• Ajouter des attributs au document XML, ajouter du code pour gérer les
attributs et ré-analyser le document.
Pour voir le code source intégral de l’analyseur SAX pour le tutoriel,
consultez “Code source de MySaxParser.java”, page 5-8.
Ce tutoriel suppose que vous avez déjà travaillé avec JBuilder et XML. Si
vous n’avez jamais utilisé JBuilder, consultez “L’environnement de
JBuilder” dans Construction d’applications avec JBuilder.
Pour plus d’informations sur les fonctionnalités XML de JBuilder, voir les
chapitres 2 et 3.
Pour avoir plus d’informations sur SAX (Simple API for XML), visitez le
site http://www.megginson.com/SAX/index.html.
Pour avoir plus d’informations sur Xerces, consultez la documentation
Xerces et les exemples disponibles dans le répertoire extras de
l’installation complète de JBuilder ou visitez le site Web d’Apache à
l’adresse http://xml.apache.org/.
Etape 1 : Utilisation de l’expert Gestionnaire SAX
L’expert Gestionnaire SAX de JBuilder vous aide à créer un analyseur SAX
qui utilisera le moteur d’analyse Xerces pour personnaliser l’analyse de
vos documents XML.
Pour créer l’analyseur SAX avec l’expert Gestionnaire SAX,
1 Ouvrez le fichier projet, SAXParser.jpx, qui se trouve dans le répertoire
JBuilder, dans samples/Tutorials/XML/saxparser/.
Important
Si vous avez installé JBuilder en tant que ’racine’ (root), mais l’exécutez
sous votre compte utilisateur normal, vous devez copier le répertoire
entier des exemples dans un répertoire où vous avez tous les droits de
lecture/écriture pour les exécuter.
2 Ouvrez Employees.xml et examinez les données dans le document XML.
Remarquez qu’il y a trois employés et qu’à chacun est associé un
enregistrement contenant des données telles que son numéro, son
prénom, son nom de famille et son nom complet.
3 Choisissez Fichier|Nouveau ou cliquez sur le bouton Nouveau dans la
barre d’outils principale pour ouvrir la galerie d’objets.
5-2
Guide du développeur d’applications XML
Etape 1 : Utilisation de l’expert Gestionnaire SAX
4 Choisissez l’onglet XML, puis double-cliquez sur l’icône Gestionnaire
SAX pour ouvrir l’expert.
5 Apportez les modifications suivantes aux noms de la classe et du
paquet :
• Nom de classe : MySaxParser
• Nom du paquet : com.borland.samples.xml.saxparser
6 Cochez ContentHandler en tant qu’interface à remplacer et développer le
nœud ContentHandler. Cochez ces cinq options pour créer des méthodes
les concernant : characters, endDocument, endElement, startDocument et
startElement. L’étape 1 doit ressembler à ceci :
7 Choisissez Suivant pour passer à l’étape 2, qui fait la liste des options
de l’analyseur. Pour ce tutoriel, nous ne sélectionnerons aucune de ces
options.
8 Cliquez sur Terminer pour fermer l’expert.
L’expert génère un fichier d’analyse, MySaxParser.java, l’ajoute au projet et
l’ouvre dans l’éditeur. Prenons le temps de regarder ce fichier. L’expert a
généré des méthodes vides, qu’il vous faut remplir.
Astuce
Pour parcourir les classes importées présentes dans le fichier, ouvrez le
dossier Imports dans le volet structure et double-cliquez sur un paquet
pour ouvrir la boîte de dialogue Chercher le symbole d’importation et
naviguez jusqu’à la classe à étudier.
Tutoriel : Création d’un Gestionnaire SAX pour analyser des documents XML
5-3
Etape 2 : Modification de l’analyseur SAX
Etape 2 : Modification de l’analyseur SAX
L’expert génère des méthodes vides à implémenter. Remarquez que la
structure de MySaxParser.java est visible dans le volet structure à gauche de
l’éditeur et que le dossier A faire contient cinq méthodes à implémenter :
characters(), endDocument(), endElement(), startDocument() et startElement().
Regardons le bloc try de la méthode main() généré par l’expert :
try {
XMLReader parser = XMLReaderFactory.createXMLReader(
"org.apache.xerces.parsers.SAXParser");
MySaxParser MySaxParserInstance = new MySaxParser();
parser.setContentHandler(MySaxParserInstance);
parser.parse(uri);
}
Ce bloc instancie un analyseur, puis lui demande d’analyser le fichier
XML spécifié dans le champ Paramètres de l’application de la page
Exécuter des Propriétés du projet (Projet|Propriétés du projet).
Commencez par ajouter des instructions print aux méthodes
startDocument() et endDocument() pour demander l’affichage à l’écran des
messages de début et de fin d’analyse.
Astuce
Pour envoyer le curseur sur une méthode dans l’éditeur, double-cliquez
sur cette méthode dans le volet structure ou dans le dossier A faire.
1 Ajoutez une instruction print à la méthode startDocument() :
System.out.println("PARSING begins...");
2 Ajoutez une instruction print à la méthode endDocument() :
System.out.println("...PARSING ends");
3 Supprimez de chaque méthode les instructions throw, qui ne sont pas
nécessaires.
5-4
Guide du développeur d’applications XML
Etape 2 : Modification de l’analyseur SAX
4 Créez une variable pour indenter le résultat de l’analyse et déclarez-la
juste avant la méthode characters() :
private int idx = 0; //indent
public void characters(char[] ch, int start, int length) throws SAXException
{
5 Créez une constante INDENT ayant la valeur 4 juste avant la méthode
main().
private static int INDENT = 4;
public static void main(String[] argv) {
6 Créez une méthode getIndent() à la fin de la classe MySaxParser, après la
méthode startElement(). Cette méthode assure l’indentation du résultat
de l’analyse, qui sera ainsi plus facile à lire.
private String getIndent() {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < idx; i++)
sb.append(" ");
return sb.toString();
}
7 Ajoutez à chacune des méthodes les éléments de code indiqués en gras
pour demander l’indentation du résultat :
public void characters(char[] ch, int start, int length) throws SAXException
{
//instancie s, indente la sortie, imprime les valeurs des caractères
//dans l’élément
String s = new String(ch, start, length);
if (ch[0] == ’\n’)
return;
System.out.println(getIndent()+ " Value: " + s);
}
public void endDocument() throws SAXException {
idx -= INDENT;
System.out.println(getIndent() + "end document");
System.out.println("...PARSING ends");
}
public void endElement(String uri, String localName,
String qName) throws SAXException {
System.out.println(getIndent() + "end element");
idx -= INDENT;
}
public void startDocument() throws SAXException {
idx += INDENT;
System.out.println("PARSING begins...");
System.out.println(getIndent() + "start document: ");
}
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
idx += INDENT;
System.out.println(’\n’ + getIndent() + "start element: " + localName);
}
Tutoriel : Création d’un Gestionnaire SAX pour analyser des documents XML
5-5
Etape 3 : Exécution du programme
Astuce
Pour en savoir plus sur les classes, les interfaces, les événements, les
méthodes, les propriétés, les paquets et les identificateurs, utilisez, dans
l’éditeur, Chercher un symbole. Placez le curseur sur un de ces noms,
cliquez avec le bouton droit de la souris, puis choisissez Chercher un
symbole. Pour qu’une classe soit automatiquement trouvée, elle doit
figurer sur le chemin d’importation. Les résultats sont affichés dans le
volet contenu de l’AppBrowser. Vous pouvez également rechercher les
classes dans l’éditeur à partir du menu Chercher (Chercher|Parcourir
les classes).
8 Enregistrez le projet.
Etape 3 : Exécution du programme
Avant d’exécuter le programme, spécifiez le document XML en tant que
paramètre d’exécution, pour que l’analyseur sache quel fichier analyser.
1 Choisissez Projet|Propriétés du projet pour ouvrir la boîte de dialogue
Propriétés du projet.
2 Choisissez l’onglet Application dans la page Exécuter.
3 Dans le champ Paramètres de l’application, entrez le chemin d’accès au
document XML. Par exemple,
file:///E:\JBuilder5\samples\Tutorials\XML\saxparser\Employees.xml
4 Choisissez OK pour fermer la page Exécuter.
5-6
Guide du développeur d’applications XML
Etape 4 : Ajout d’attributs
5 Dans le volet projet, cliquez avec le bouton droit sur MySaxParser.java et
choisissez Exécuter.
Le volet message s’ouvre et affiche le résultat de l’analyse :
Etape 4 : Ajout d’attributs
Ensuite, ajoutez des attributs au document XML. Vous devez ajouter dans
l’analyseur des éléments de code lui permettant de gérer les attributs.
1 Ouvrez Employees.xml et ajoutez un attribut au premier élément EmpNo :
<EmpNo att1="a" att2 ="b">2</EmpNo>
2 Ajoutez des attributs au premier élément FirstName :
<FirstName z="z1" d ="d1" k="k1">Robert</FirstName>
3 Ajoutez la variable attList immédiatement au-dessus de la méthode
main() :
public class MySaxParser extends DefaultHandler {
private static int INDENT = 4;
private static String attList = "" ;
public static void main(String[] argv) {
4 Ajoutez le code suivant à la méthode startElement() pour gérer
l’attribut :
public void startElement(String uri, String localName, String qName,
Attributes
attributes) throws SAXException {
idx += INDENT;
System.out.println(’\n’+getIndent() + "start element: " + localName);
if (attributes.getLength()> 0) {
idx += INDENT;
for (int i = 0; i < attributes.getLength(); i++){
attList = attList + attributes.getLocalName(i) + " = " +
attributes.getValue(i);
Tutoriel : Création d’un Gestionnaire SAX pour analyser des documents XML
5-7
Code source de MySaxParser.java
if (i < (attributes.getLength() - 1))
attList = attList + ",";
}
idx -= INDENT;
}
}
5 Ajoutez le code suivant à la méthode endElement() :
public void endElement(String uri, String localName,
String qName) throws SAXException {
if (!attList.equals(""))
System.out.println(getIndent() + " Attributes: " + attList);
attList = "";
System.out.println(getIndent() + "end element");
idx -= INDENT;
}
6 Enregistrez le projet et ré-exécutez le programme.
Remarquez que le résultat de l’analyse inclut maintenant les attributs.
Code source de MySaxParser.java
package com.borland.samples.xml.saxparser;
import
import
import
import
java.io.IOException;
org.xml.sax.*;
org.xml.sax.helpers.*;
org.apache.xerces.parsers.SAXParser;
public class MySaxParser extends DefaultHandler {
private static int INDENT = 4;
private static String attList = "";
public static void main(String[] argv) {
if (argv.length != 1) {
System.out.println("Usage: java MySaxParser [URI]");
System.exit(0);
5-8
Guide du développeur d’applications XML
Code source de MySaxParser.java
}
String uri = argv[0];
try {
XMLReader parser = XMLReaderFactory.createXMLReader("
org.apache.xerces.parsers.SAXParser");
MySaxParser MySaxParserInstance = new MySaxParser();
parser.setContentHandler(MySaxParserInstance);
parser.parse(uri);
}
catch(IOException ioe) {
ioe.printStackTrace();
}
catch(SAXException saxe) {
saxe.printStackTrace();
}
}
private int idx = 0;
public void characters(char[] ch, int start, int length) throws SAXException {
/**@todo: Implémenter cette méthode characters*/
String s = new String(ch, start, length);
if (ch[0] == ’\n’)
return;
System.out.println(getIndent() + " Value: " + s);
}
public void endDocument() throws SAXException {
/**@todo: Implémenter cette méthode endDocument*/
idx -= INDENT;
System.out.println(getIndent() + "end document");
System.out.println("...PARSING ends");
}
public void endElement(String uri, String localName,
String qName) throws SAXException {
/**@todo: Implémenter cette méthode endElement*/
if (!attList.equals(""))
System.out.println(getIndent() + " Attributes: " + attList);
attList = "";
System.out.println(getIndent() + "end document");
idx -= INDENT;
}
public void startDocument() throws SAXException {
/**@todo: Implémenter cette méthode startDocument*/
idx += INDENT;
System.out.println("PARSING begins...");
System.out.println(getIndent() + "start document: ");
}
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
/**@todo: Implémenter cette méthode startElement*/
idx += INDENT;
System.out.println(’\n’ + getIndent() + "start element: " + localName);
if (attributes.getLength() > 0) {
Tutoriel : Création d’un Gestionnaire SAX pour analyser des documents XML
5-9
Code source de MySaxParser.java
idx += INDENT;
for (int i = 0; i < attributes.getLength(); i++) {
attList = attList + attributes.getLocalName(i) + " = " +
attributes.getValue(i);
if (i < (attributes.getLength() - 1))
attList = attList + ", ";
}
idx-= INDENT;
}
}
private String getIndent() {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < idx; i++)
sb.append(" ");
return sb.toString();
}
}
5-10
Guide du développeur d’applications XML
Chapitre
6
Tutoriel : Liaison de données
DTD avec BorlandXML
Chapitre6
Présentation
Ce tutoriel utilise des
fonctionnalités
de JBuilder Entreprise.
Il montre, étape par étape, comment utiliser les fonctionnalités JBuilder de
liaison de données XML à l’aide de DTD et de BorlandXML. Vous
trouverez des exemples dans le répertoire samples de JBuilder : samples/
Tutorials/XML/presentation/. Ce tutoriel prend comme exemple une base de
données d’employés contenant des champs où seront entrées des
informations telles qu’un numéro d’employé, un prénom, un nom de
famille, etc. L’exemple est illustré par un document XML et une DTD,
ainsi qu’une application test permettant de manipuler les données.
Ce tutoriel suppose que vous avez déjà travaillé avec JBuilder et XML. Si
vous n’avez jamais utilisé JBuilder, consultez “L’environnement de
JBuilder” dans Construction d’applications avec JBuilder.
La liaison de données permet d’accéder à des données et de les manipuler,
puis de renvoyer les données modifiées à la base de données ou de les
afficher avec un document XML. Le document XML peut servir de
mécanisme de transfert entre la base de données et l’application. Ce
transfert se fait en liant un objet Java à un document XML. La liaison de
données est implémentée en générant des classes Java pour représenter les
contraintes contenues dans une grammaire, par exemple dans une DTD
ou dans un schéma XML. Vous pouvez ensuite utiliser ces classes pour
créer ou lire des documents XML conformes à la grammaire et valider des
documents XML par rapport à la grammaire au fur et à mesure de leur
modification.
Tutoriel : Liaison de données DTD avec BorlandXML
6-1
Etape 1 : Génération de classes Java à partir d’une DTD
Des exemples spécifiques vous montrent comment réaliser les tâches
suivantes :
• Générer des classes Java à partir d’une DTD à l’aide de BorlandXML.
• Dé-marshaller les données provenant d’objets XML et les convertir en
objets Java.
• Editer les données en ajoutant un employé et en modifiant le nom d’un
employé existant.
• Marshaller à nouveau les objets Java dans le document XML.
Pour plus d’informations sur les fonctionnalités XML de JBuilder, voir les
chapitres 2 et 3.
Etape 1 : Génération de classes Java à partir d’une DTD
Lorsque vous utilisez vos données, la première étape consiste à générer
des classes Java à partir de votre DTD existante, à l’aide de l’expert Liaison
de données. Lorsque vous choisissez BorlandXML comme type de liaison
de données, l’expert Liaison de données examine la DTD et crée une classe
Java par élément de la DTD.
Pour générer des classes Java à partir d’une DTD à l’aide de l’expert
Liaison de données,
1 Ouvrez le fichier projet, BorlandXML.jpx, qui se trouve dans le répertoire
JBuilder, dans samples/Tutorials/XML/databinding/fromDTD/.
Important
Si vous avez installé JBuilder en tant que ’racine’ (root), mais l’exécutez
sous votre compte utilisateur normal, vous devez copier le répertoire
entier des exemples dans un répertoire où vous avez tous les droits de
lecture/écriture pour les exécuter.
2 Ouvrez Employees.xml et examinez les données dans le document XML.
Remarquez qu’il y a trois employés : Robert Nelson, Bruce Young et
Kim Lambert. A chacun correspond un enregistrement contenant des
données telles que le numéro de l’employé, son prénom, son nom de
famille et son nom complet. Ce sont les données que vous allez
manipuler.
Remarque
Vous pouvez également afficher le document XML dans le visualiseur
XML. Activez le navigateur sur la page XML de la boîte de dialogue
Options de l’EDI (Outils|Options de l’EDI). Ensuite, sur le volet
contenu, choisissez l’onglet Vue pour afficher le document sous forme
de la vue arborescente par défaut.
3 Ouvrez Employees.dtd et remarquez les éléments que contient le
document XML : XmlEmployee, EmpNo, FirstName, etc. L’expert Liaison de
données génère une classe Java pour chacun de ces éléments.
6-2
Guide du développeur d’applications XML
Etape 1 : Génération de classes Java à partir d’une DTD
4 Cliquez avec le bouton droit sur Employees.dtd et choisissez Générer java
pour ouvrir l’expert Liaison de données. Remarquez la sélection de
BorlandXML comme type de liaison. BorlandXML génère des classes
Java à partir de DTD.
Remarque
L’expert Liaison de données est également disponible sur la page XML
de la galerie d’objets (Fichier|Nouveau).
5 Cliquez sur Suivant pour passer à l’étape 2.
6 Remplissez les champs suivants lors de l’étape 2 de l’expert :
• Fichier DTD : /<jbuilder>/samples/Tutorials/XML/databinding/fromDTD/
Employees.dtd. Ce champ est automatiquement rempli car vous avez
sélectionné le fichier DTD sur le volet projet avant d’ouvrir l’expert.
• Elément racine : sélectionnez XmlEmployees dans la liste déroulante.
Veillez à sélectionner XmlEmployees et non l’élément au singulier,
XmlEmployee.
• Nom du paquet : remplacez le nom du paquet par
com.borland.samples.xml.databinding.borlandxml
• Identificateur système : Employees.dtd.
L’expert Liaison de données se présente ainsi :
7 Cliquez sur Terminer.
8 Développez le nœud du paquet source automatique,
com.borland.samples.xml.databinding.borlandxml, dans le volet projet,
pour voir les fichiers .java générés par l’expert. Remarquez qu’à chaque
élément de la DTD est attribuée une classe différente. Le nœud inclut
également l’application test, DB_BorlandXML.java, qui fait partie de
Tutoriel : Liaison de données DTD avec BorlandXML
6-3
Etape 1 : Génération de classes Java à partir d’une DTD
l’exemple fourni. Nous allons utiliser cette application pour manipuler
les données.
9 Enregistrez le projet.
Avant de poursuivre, prenons le temps d’examiner certaines des classes
générées.
1 Ouvrez EmpNo.java et examinez le code. Remarquez la présence d’un
constructeur pour la création d’un objet EmpNo à partir de l’élément
EmpNo, ainsi que de méthodes de dé-marshalling de l’élément EmpNo en
objet EmpNo et d’obtention du nom de balise de l’élément.
2 Ouvrez XmlEmployee.java. L’élément XmlEmployee du document XML
contient tous les enregistrements de l’individu, tels que son numéro
d’employé (EmpNo), son prénom (FirstName) et son nom (LastName). Dans
cette classe, un constructeur permet de créer un objet XmlEmployee à
partir de l’élément XmlEmployee, des déclarations définissent les éléments
et des méthodes obtiennent et définissent les éléments contenus dans
XmlEmployee. En outre, les méthodes unmarshal() (lecture) et marshal()
(écriture) traduisent l’objet XML en objet Java pour la lecture puis
l’objet Java en objet XML après manipulation de l’objet dans
l’application Java.
3 Ouvrez XmlEmployees.java. XmlEmployees est l’élément racine du
document XML. Il contient tous les autres éléments XML. La classe
XmlEmployees contient des méthodes d’obtention et de définition de
l’élément XmlEmployee, ainsi que des méthodes d’ajout et de suppression
d’employés, de définition et d’obtention d’ID PUBLIC et SYSTEM et de
marshalling ou dé-marshalling des données.
Astuce
6-4
Pour naviguer dans les classes, les interfaces, les événements, les
méthodes, les propriétés, les paquets et les identificateurs, utilisez, dans
l’éditeur, Chercher un symbole. Placez le curseur sur un de ces noms,
cliquez avec le bouton droit de la souris, puis choisissez Chercher un
symbole. Pour qu’une classe soit automatiquement trouvée, elle doit
figurer sur le chemin d’importation. Les résultats sont affichés dans le
Guide du développeur d’applications XML
Etape 2 : Dé-marshalling des données
volet contenu de l’AppBrowser. Vous pouvez également rechercher les
classes dans l’éditeur à partir du menu Chercher (Chercher|Parcourir les
classes).
Etape 2 : Dé-marshalling des données
Après avoir créé les objets Java correspondant aux objets XML, regardez
l’application test, DB_BorlandXML.java. Cette application transmet les
données entre le document XML et les objets Java - elle effectue un
dé-marshalling (lecture) et un marshalling (écriture) de données.
1 Dans le volet projet, double-cliquez sur DB_BorlandXML.java pour
l’ouvrir. Remarquez qu’une variable de classe, db_BorlandXML, dans la
méthode main() de l’application, appelle différentes méthodes, dont
trois ont été mises en commentaire.
public class DB_BorlandXML {
public DB_BorlandXML() {
}
public static void main(String[] args) {
db_BorlandXML = new DB_BorlandXML();
db_BorlandXML.readEmployees();
//
db_BorlandXML.addEmployee();
//
db_BorlandXML.modifyEmployee();
//
db_BorlandXML.readEmployees();
}
....
}
Ensuite, exécutez l’application sans modifier le code et lisez les
employés à partir du document XML pour les convertir en objets Java.
Puis, pour manipuler les données, changez le code, ajoutez et modifiez
des employés. La première étape consiste à lire les employés à partir du
document XML.
2 Pour exécuter l’application, cliquez avec le bouton droit de la souris sur
DB_BorlandXML.java et choisissez Exécuter. Lors de son exécution,
l’application lit les informations relatives aux employés, et affiche sur le
volet message le nombre d’employés et les noms complets du premier
et du dernier :
== unmarshalling "Employees.xml" ==
Total Number of Employees read = 3
First Employee’s Full Name is Nelson, Robert
Last Employee’s Full Name is Lambert, Kim
Tutoriel : Liaison de données DTD avec BorlandXML
6-5
Etape 3 : Ajout d’un employé
Etape 3 : Ajout d’un employé
Ensuite, ajoutez un employé et effectuez un marshalling des données vers
le document XML. Pour obtenir ce résultat, vous devez enlever les
marques de commentaire (//) commençant la ligne d’appel à la méthode
addEmployee() : db_BorlandXML.addEmployee(); Vous allez également ajouter
un autre appel à la méthode readEmployees() pour lire les nouvelles
données dans le volet message. Lorsque vous exécuterez le programme, la
méthode addEmployee() ajoutera un nouvel employé, Charlie Chaplin.
1 Supprimez les commentaires de db_BorlandXML.addEmployee.
2 Ajoutez un appel à readEmployees() immédiatement sous la ligne dont
vous avez ôté les marques de commentaire. Votre code doit ressembler
à ceci :
public static void main(String[] args) {
db_BorlandXML = new DB_BorlandXML();
db_BorlandXML.readEmployees();
db_BorlandXML.addEmployee();
db_BorlandXML.readEmployees();
// db_BorlandXML.modifyEmployee();
// db_BorlandXML.readEmployees();
}
3 Exécutez à nouveau le programme. Notez le résultat dans le volet
message et l’ajout de Charlie en tant que quatrième employé.
== unmarshalling "Employees.xml" ==
Total Number of Employees read = 3
First Employee’s Full Name is Nelson,
Last Employee’s Full Name is Lambert,
== unmarshalling "Employees.xml" ==
Total Number of Employees read = 4
First Employee’s Full Name is Nelson,
Last Employee’s Full Name is Chaplin,
Robert
Kim
Robert
Charlie
4 Basculez vers Employees.xml et remarquez que Charlie Chaplin a été
ajouté en tant que quatrième employé.
6-6
Guide du développeur d’applications XML
Etape 4 : Modification d’un employé
Etape 4 : Modification d’un employé
Nous allons maintenant modifie le nom de Charlie Chaplin. Pour obtenir
ce résultat, réinsérez des marques de commentaire sur les lignes
addEmployee() et readEmployees() et supprimez celles des lignes
modifyEmployee() et readEmployees().
1 Mettez ces deux lignes en commentaire dans DB_BorlandXML.java :
// db_BorlandXML.addEmployee();
// db_BorlandXML.readEmployees();
2 Supprimez les commentaires de ces deux lignes :
db_BorlandXML.modifyEmployee();
db_BorlandXML.readEmployees();
Votre code doit ressembler à ceci :
public static void main(String[] args) {
db_BorlandXML = new DB_BorlandXML();
db_BorlandXML.readEmployees();
// db_BorlandXML.addEmployee();
// db_BorlandXML.readEmployees();
db_BorlandXML.modifyEmployee();
db_BorlandXML.readEmployees();
}
Maintenant que vous avez supprimé les marques de commentaire de la
ligne modifyEmployee(), lors de la prochaine exécution du programme, le
nom Charlie Chaplin sera remplacé par les informations de la méthode
modifyEmployee().
1 Cliquez avec le bouton droit sur DB_BorlandXML.java dans le volet projet,
puis choisissez Exécuter pour exécuter l’application. Notez le résultat
dans le volet message et le remplacement de Charlie par Andy Scott.
== unmarshalling "Employees.xml" ==
Total Number of Employees read = 4
First Employee’s Full Name is Nelson, Robert
Last Employee’s Full Name is Chaplin, Charlie
== unmarshalling "Employees.xml" ==
Total Number of Employees read = 4
First Employee’s Full Name is Nelson, Robert
Last Employee’s Full Name is Scott, Andy
2 Revenez à Employees.xml et remarquez que le marshalling/
dé-marshalling des données d’Andy Scott les a transférées d’objets Java
vers les objets XML, puis les a ré-écrites dans le document XML.
Maintenant, Andy Scott a remplacé Charlie Chaplin.
Tutoriel : Liaison de données DTD avec BorlandXML
6-7
Etape 5 : Exécution de l’application terminée
Etape 5 : Exécution de l’application terminée
Après avoir vu le rôle que cette application pouvait jouer, supprimez les
nouvelles données du document XML et les commentaires du
programme, ajoutez une instruction print pour lire le nouvel employé,
puis exécutez le programme.
1 Supprimez les données de l’employé Andy Scott du document XML, en
veillant à ne pas supprimer d’autres données ou balises XML.
<XmlEmployee>
<EmpNo>9000</EmpNo>
<FirstName>Andy</FirstName>
<LastName>Scott</LastName>
<PhoneExt>1993</PhoneExt>
<HireDate>2/2/2001</HireDate>
<DeptNo>600</DeptNo>
<JobCode>VP</JobCode>
<JobGrade>3</JobGrade>
<JobCountry>USA</JobCountry>
<Salary>145000.00</Salary>
<FullName>Scott, Andy</FullName>
</XmlEmployee>
Maintenant, le document XML ne contient que les enregistrements des
trois employés d’origine.
2 Revenez à DB_BorlandXML.java et supprimez les commentaires de tous les
appels de variables de classes à des méthodes. Votre code doit
ressembler à ceci :
public static void main(String[] args) {
db_BorlandXML = new DB_BorlandXML();
db_BorlandXML.readEmployees();
db_BorlandXML.addEmployee();
db_BorlandXML.readEmployees();
db_BorlandXML.modifyEmployee();
db_BorlandXML.readEmployees();
}
3 Enregistrez le projet.
4 Exécutez le programme pour sortir les données et obtenir le résultat
suivant dans le volet message :
== unmarshalling "Employees.xml" ==
Total Number of Employees read = 3
First Employee’s Full Name is Nelson,
Last Employee’s Full Name is Lambert,
== unmarshalling "Employees.xml" ==
Total Number of Employees read = 4
First Employee’s Full Name is Nelson,
Last Employee’s Full Name is Chaplin,
== unmarshalling "Employees.xml" ==
6-8
Guide du développeur d’applications XML
Robert
Kim
Robert
Charlie
Etape 5 : Exécution de l’application terminée
Total Number of Employees read = 4
First Employee’s Full Name is Nelson, Robert
Last Employee’s Full Name is Scott, Andy
5 Basculez vers Employees.xml pour vérifier que les données ont été
réintégrées par marshalling dans le document XML. Remarquez que les
informations relatives à Andy Scott ont été ajoutées puis modifiées.
Lors de la seconde lecture des employés, le nouvel employé est pris en
compte.
Félicitations. Vous avez terminé le tutoriel. Vous avez utilisé une
application Java et des classes Java générées par l’expert Liaison de
données à partir d’une DTD pour lire, ajouter et modifier dans un
document XML des données relatives à des employés.
Tutoriel : Liaison de données DTD avec BorlandXML
6-9
6-10
Guide du développeur d’applications XML
Chapitre
7
Tutoriel : Liaison de données
par schéma avec Castor
Chapitre7
Présentation
Ce tutoriel utilise
des fonctionnalités
de JBuilder Entreprise.
Il montre, étape par étape, comment utiliser les fonctionnalités JBuilder de
liaison de données XML à l’aide de schémas et de Castor. Vous trouverez
des exemples dans le répertoire samples de JBuilder : samples/Tutorials/XML/
databinding/fromSchema. Ce tutoriel prend comme exemple une base de
données d’employés, dans laquelle se trouvent des champs destinés à
accueillir des informations telles que le numéro de l’employé, son prénom,
son nom, etc. Il illustre l’utilisation d’un document XML et d’un fichier
schéma et contient une application test permettant de manipuler les
données.
Ce tutoriel suppose que vous avez déjà travaillé avec JBuilder et XML. Si
vous n’avez jamais utilisé JBuilder, consultez “L’environnement de
JBuilder” dans Construction d’applications avec JBuilder.
La liaison de données permet d’accéder à des données et de les manipuler,
puis de renvoyer les données modifiées à la base de données ou de les
afficher avec un document XML. Le document XML peut servir de
mécanisme de transfert entre la base de données et l’application. Ce
transfert se fait en liant un objet Java à un document XML. La liaison de
données est implémentée en générant des classes Java pour représenter les
contraintes contenues dans une grammaire, par exemple dans une DTD
ou dans un schéma XML. Vous pouvez ensuite utiliser ces classes pour
créer ou lire des documents XML conformes à la grammaire et valider des
documents XML par rapport à la grammaire au fur et à mesure de leur
modification.
Tutoriel : Liaison de données par schéma avec Castor
7-1
Etape 1 : Génération de classes Java à partir d’un schéma
Des exemples spécifiques vous montrent comment réaliser les tâches
suivantes :
• Générer des classes Java à partir d’un schéma à l’aide de Castor et de
l’expert Liaison de données.
• Dé-marshaller les données provenant d’objets XML et les convertir en
objets Java.
• Editer les données en ajoutant un employé et en modifiant un employé
existant.
• Marshaller à nouveau les objets Java dans le document XML.
Pour plus d’informations sur les fonctionnalités XML de JBuilder, voir les
chapitres 2 et 3.
Pour plus d’informations sur Castor, consultez la documentation Castor
que vous trouverez dans le répertoire extras de JBuilder si vous avez
choisi une installation complète ou sur le site Web de Castor à l’adresse
www.castor.org.
Etape 1 : Génération de classes Java à partir d’un schéma
Quand vous utilisez vos données, la première étape consiste à générer des
classes Java à partir de votre schéma existant. Lorsque vous avez choisi
Castor comme type de liaison de données, l’expert Liaison de données
examine le fichier schéma sélectionné et l’utilise comme base pour la
création de classes Java.
Pour générer des classes Java à partir d’un schéma à l’aide de l’expert
Liaison de données,
1 Ouvrez le fichier projet, castor.jpx, qui se trouve dans le répertoire
JBuilder, dans samples/Tutorials/XML/databinding/fromSchema.
Important
Si vous avez installé JBuilder en tant que ’racine’ (root), mais l’exécutez
sous votre compte utilisateur normal, vous devez copier le répertoire
entier des exemples dans un répertoire où vous avez tous les droits de
lecture/écriture pour les exécuter.
2 Ouvrez Employees.xml et examinez les données dans le document XML.
Remarquez qu’il y a trois employés : Robert Nelson, Bruce Young et
Kim Lambert. A chacun correspond un enregistrement contenant des
données telles que le numéro de l’employé, son prénom, son nom de
famille et son nom complet. Ce sont les données que vous allez
manipuler.
Remarque
7-2
Vous pouvez également afficher le document XML dans le visualiseur
XML. Activez le navigateur sur la page XML de la boîte de dialogue
Options de l’EDI (Outils|Options de l’EDI). Ensuite, sur le volet
Guide du développeur d’applications XML
Etape 1 : Génération de classes Java à partir d’un schéma
contenu, choisissez l’onglet Vue pour afficher le document sous forme
de la vue arborescente par défaut.
3 Ouvrez Employees.xsd et examinez ce fichier. L’expert Liaison de
données génère des classes Java selon le fichier schéma (XSD).
4 Sur le volet projet, cliquez avec le bouton droit sur Employees.xsd et
choisissez Générer Java pour ouvrir l’expert Liaison de données. A
l’ouverture de l’expert, le champ XSD contient automatiquement le
nom du fichier.
5 Acceptez Castor comme type de Liaison de données, puis cliquez sur
Suivant pour passer à l’étape 2.
Castor utilise le schéma (XSD) pour créer des classes Java. Les schémas,
plus robustes et souples, présentent plusieurs avantages par rapport
aux DTD. Les schémas sont des documents XML, alors que les DTD
contiennent une syntaxe non XML. Les schémas acceptent aussi des
espacenoms (namespace), qui sont obligatoires pour éviter les conflits
de noms et offrent plus de types de données et une plus grande prise en
charge de l’héritage.
6 Remplissez les champs de la manière suivante :
• Schéma XML : acceptez le chemin d’accès au fichier schéma - /
<jbuilder>/samples/Tutorials/XML/databinding/fromSchema/
Employees.xsd. Ce champ a déjà été rempli pour vous.
• Paquet : remplacez le nom du paquet par
com.borland.samples.xml.databinding.borlandxml
• Acceptez les options par défaut.
L’étape 2 de l’expert doit ressembler à ceci :
7 Cliquez sur Terminer.
Tutoriel : Liaison de données par schéma avec Castor
7-3
Etape 1 : Génération de classes Java à partir d’un schéma
8 Dans le volet projet, développez le nœud du paquet source
automatique, com.borland.samples.xml.databinding.castor, pour voir les
fichiers .java générés par l’expert. Le nœud inclut également
l’application test, DB_Castor.java, qui fait partie de l’exemple fourni.
Nous allons utiliser cette application pour manipuler les données.
9 Enregistrez le projet.
Avant de passer à l’étape suivante, examinons quelques-unes des classes
Java générées par l’expert. Pour effectuer la liaison de données, Castor
affecte une instance de schéma XML à un modèle d’objet approprié. Ce
modèle d’objet inclut un ensemble de classes et de types représentant les
données. L’utilisation de descripteurs permet d’obtenir des informations
sur une classe et ses champs. Dans la plupart des cas, la structure de
marshalling utilise un ensemble de ClassDescriptors et de FieldDescriptors
pour décrire comment effectuer le marshalling et le dé-marshalling d’un
Objet à partir du document XML.
Nous pouvons commencer par observer qu’il y a plusieurs types de
fichiers Java :
1 XmlEmployee.java : pour le marshalling et le dé-marshalling de données
entre le document XML et les objets Java.
2 XmlEmployeeDescriptor.java : pour l’obtention d’espaces de noms, d’une
identité, d’une classe Java, etc.
3 XmlEmployees.java : pour l’obtention et la définition de l’élément
XmlEmployee, ainsi que pour le marshalling et dé-marshalling de données
entre le document XML et les objets Java.
4 XmlEmployeesDescriptor.java : pour l’obtention d’espaces de noms, d’une
identité, d’une classe Java, etc.
5 XmlEmployeeType.java : pour la définition du type de données de chaque
objet.
6 XmlEmployeeTypeDescriptor.java : pour l’initialisation des descripteurs
d’éléments. Diverses méthodes permettent d’obtenir le nom du fichier
XML, la classe Java et l’espace de noms.
7-4
Guide du développeur d’applications XML
Etape 2 : Dé-marshalling des données
Astuce
Voir aussi
Pour naviguer dans les classes, les interfaces, les événements, les
méthodes, les propriétés, les paquets et les identificateurs, utilisez, dans
l’éditeur, Chercher un symbole. Placez le curseur sur un de ces noms,
cliquez avec le bouton droit de la souris, puis choisissez Chercher un
symbole. Pour qu’une classe soit automatiquement trouvée, elle doit
figurer sur le chemin d’importation. Les résultats sont affichés dans le
volet contenu de l’AppBrowser. Vous pouvez également rechercher les
classes dans l’éditeur à partir du menu Chercher (Chercher|Parcourir les
classes).
Castor API dans le répertoire extras de JBuilder si vous avez opté pour
une installation complète ou sur le site Web Castor à l’adresse
http://www.castor.org/javadoc/overview-summary.html
Etape 2 : Dé-marshalling des données
Après avoir créé les objets Java correspondant aux objets XML, regardez
l’application test, DB_Castor.java. Cette application transmet les données
entre le document XML et les objets Java - elle effectue un dé-marshalling
(lecture) et un marshalling (écriture) des données.
Dans le volet projet, double-cliquez sur DB_Castor.java pour l’ouvrir.
Remarquez que plusieurs méthodes sont à votre disposition pour la
manipulation de données. D’abord, l’application effectue un
dé-marshalling (lecture) des données à partir du document XML et affiche
sur l’écran le nombre d’employés ainsi que les noms du premier et du
dernier employés. Ensuite, un employé est ajouté puis modifié. Enfin, un
marshalling des données est effectué vers le document XML.
try {
String fileName = "Employees.xml";
System.out.println("== unmarshalling \"" + fileName + "\" ==");
//Faire un dé-marshalling du fichier XML
XmlEmployees xmlEmployees = XmlEmployees.unmarshal(new
FileReader(fileName));
System.out.println("Total Number of XmlEmployees read = " +
xmlEmployees.getXmlEmployeeCount());
System.out.println("First XmlEmployee’s Full Name is"+
xmlEmployees.getXmlEmployee(0).getFullName());
System.out.println("Last XmlEmployee’s Full Name is
"+xmlEmployees.getXmlEmployee
(xmlEmployees.getXmlEmployeeCount()-1).getFullName());
// Ajouter un XmlEmployee
xmlEmployees.addXmlEmployee(getXmlEmployee("8000","400",
"Charlie","Castor","3/3/2001","VP","USA","2","1993","155000.00"));
//Modifier le dernier XmlEmployee
xmlEmployees.setXmlEmployee(getXmlEmployee("8000","600","Peter","Castor",
"3/3/2001","VP","USA","3","2096","125000.00"),
xmlEmployees.getXmlEmployeeCount()-1);
Tutoriel : Liaison de données par schéma avec Castor
7-5
Etape 3 : Ajout d’un employé
// Faire un marshalling des données vers le même fichier XML
xmlEmployees.marshal(new java.io.FileWriter(fileName));
}
Astuce
Pour parcourir les classes importées présentes dans le fichier, ouvrez le
dossier Imports dans le volet structure et double-cliquez sur un paquet
pour ouvrir la boîte de dialogue Chercher le symbole d’importation et
naviguez jusqu’à la classe à étudier.
Vous pourriez exécuter l’application, ajouter puis, tout de suite après,
modifier un employé ; cependant, nous allons décomposer cette opération
en plusieurs étapes pour voir ce qui se produit.
Etape 3 : Ajout d’un employé
Commençons par modifier l’application de manière à ne traiter que l’ajout
d’un employé. Pour ce faire, il faut mettre en commentaire la méthode
demandant la modification d’un employé, setXmlEmployee(), dans
DB_Castor.java. Nous modifierons l’employé à l’étape suivante.
1 Transformez en commentaire la méthode setXmlEmployee() et
l’instruction print qui suit. Si ces lignes ne sont considérées que comme
des commentaires, l’application effectue un dé-marshalling des
données, les envoie à l’écran, ajoute un employé, puis effectue un
marshalling des nouvelles données vers le document XML, sans
modifier le nouvel employé.
// Modifier le dernier XmlEmployee
//xmlEmployees.setXmlEmployee(getXmlEmployee("8000","600","Peter","Castor",
"3/3/2001","VP"//,"USA","3","2096","125000.00"),
xmlEmployees.getXmlEmployeeCount()-1);
2 Ajoutons une ligne print après la méthode addXmlEmployee(), pour que le
nom du nouvel employé s’affiche à l’écran après son ajout.
// Ajouter un XmlEmployee
xmlEmployees.addXmlEmployee(getXmlEmployee("8000","400","Charlie","Castor",
"3/3/2001","VP","USA","2","1993","155000.00"));
System.out.println("New XmlEmployee’s Full Name is "+
xmlEmployees.getXmlEmployee(
xmlEmployees.getXmlEmployeeCount()-1).getFullName());
3 Pour exécuter l’application, cliquez avec le bouton droit sur
DB_Castor.java et choisissez Exécuter. Lors de son exécution,
l’application lit les informations relatives à l’employé et affiche ce qui
suit sur le volet message :
== unmarshalling "Employees.xml" ==
Total Number of XmlEmployees read = 3
First XmlEmployee’s Full Name is Nelson, Robert
Last XmlEmployee’s Full Name is Lambert, Kim
New XmlEmployee’s Full Name is Castor, Charlie
7-6
Guide du développeur d’applications XML
Etape 4 : Modification des données du nouvel employé
4 Basculez vers Employees.xml pour vérifier que le marshalling des
nouvelles données vers le document XML a bien été effectué et
remarquez que Charlie Castor a été ajouté en tant que nouvel employé.
Remarque
Par défaut, la fonction de marshalling de Castor écrit des documents XML
sans indentation, puisque cette dernière augmente la taille des documents
XML générés. Pour activer l’indentation, modifiez le fichier des propriétés
de Castor comme suit : org.exolab.castor.indent=true. Ce fichier contient
aussi d’autres propriétés qu’il peut être utile de modifier. Le fichier
castor.properties est automatiquement créé par l’expert Liaison de
données dans le répertoire source du projet.
Etape 4 : Modification des données du nouvel employé
Ensuite, utilisons la méthode setXmlEmployee() pour modifier
l’enregistrement de l’employé Charlie Castor et ré-exécutons le
programme pour mettre à jour cet enregistrement dans le document XML.
1 Revenez dans DB_Castor.java et mettez en commentaire la méthode
addEmployee() et l’instruction print qui la suit :
// Ajouter un XmlEmployee
//
xmlEmployees.addXmlEmployee(getXmlEmployee("8000","400","Charlie","Castor",
"3/3/2001","VP","USA","2","1993","155000.00"));
//
//System.out.println("New XmlEmployee’s Full Name is " +
xmlEmployees.getXmlEmployee(xmlEmployees.getXmlEmployeeCount()//
1).getFullName());
2 Supprimez les marques de commentaire de la méthode setXmlEmployee()
et ajoutez l’instruction print :
// Modifier le dernier XmlEmployee
xmlEmployees.setXmlEmployee(getXmlEmployee("8000","600",
"Peter","Castor","3/3/2001","VP","USA","3","2096","125000.00"),
xmlEmployees.getXmlEmployeeCount()-1);
System.out.println("New XmlEmployee’s Modified Full Name is "+
xmlEmployees.
getXmlEmployee(xmlEmployees.getXmlEmployeeCount()-1).getFullName());
3 Pour exécuter l’application, cliquez avec le bouton droit sur
DB_Castor.java et choisissez Exécuter. Lors de son exécution,
l’application lit les informations relatives aux employés, puis affiche
dans le volet message le nombre d’employés, les noms complets du
premier et du dernier, en plus de l’employé modifié :
== unmarshalling "Employees.xml" ==
Total Number of XmlEmployees read = 4
First XmlEmployee’s Full Name is Nelson, Robert
Last XmlEmployee’s Full Name is Castor, Charlie
New XmlEmployee’s Modified Full Name is Castor, Peter
Tutoriel : Liaison de données par schéma avec Castor
7-7
Etape 5 : Exécution de l’application terminée
Etape 5 : Exécution de l’application terminée
Après avoir vu le rôle que cette application pouvait jouer, supprimez les
marques de commentaire, ajoutez une instruction print pour lire le nouvel
employé, supprimez les nouvelles données du document XML puis
exécutez l’application dans sa totalité.
1 Supprimez les marques de commentaire de la méthode addXmlEmployee()
et ajoutez l’instruction print suivante. Votre code doit ressembler à
ceci :
// Ajouter un XmlEmployee
xmlEmployees.addXmlEmployee(getXmlEmployee("8000","400","Charlie","Castor",
"3/3/2001","VP","USA","2","1993","155000.00"));
System.out.println("New XmlEmployee’s Full Name is " +
xmlEmployees.getXmlEmployee(xmlEmployees.getXmlEmployeeCount()
-1).getFullName());
//Modifier le dernier XmlEmployee
xmlEmployees.setXmlEmployee(getXmlEmployee("8000","600","Peter","Castor",
"3/3/2001","VP",
"USA","3","2096","125000.00"),
xmlEmployees.getXmlEmployeeCount()-1);
System.out.println("New XmlEmployee’s Modified Full Name is " +
xmlEmployees.getXmlEmployee(xmlEmployees.getXmlEmployeeCount()
-1).getFullName());
// Faire un marshalling des données vers le même fichier XML
xmlEmployees.marshal(new java.io.FileWriter(fileName));
2 Ajoutez une autre instruction print à la suite de l’instruction print de la
méthode setXmlEmployee() et avant la méthode marshal() pour effectuer
une relecture des données après intégration et modification des
nouvelles données. Votre code doit ressembler à ceci :
// Modifier le dernier XmlEmployee
xmlEmployees.setXmlEmployee(getXmlEmployee("8000","600","Peter","Castor",
"3/3/2001","VP","USA","3","2096","125000.00")
,xmlEmployees.getXmlEmployeeCount()-1);
System.out.println("New XmlEmployee’s Modified Full Name is
"+xmlEmployees.getXmlEmployee(xmlEmployees.getXmlEmployeeCount()
-1).getFullName());
//relecture des employés
System.out.println("Total Number of XmlEmployees read =
"+xmlEmployees.getXmlEmployeeCount());
// Faire un marshalling des données vers le même fichier XML
xmlEmployees.marshal(new java.io.FileWriter(fileName));
3 Supprimez les données de l’employé Peter Castor du document XML,
en veillant à ne pas supprimer d’autres données ou balises XML.
4 Enregistrez le projet.
7-8
Guide du développeur d’applications XML
Etape 5 : Exécution de l’application terminée
5 Ré-exécutez le programme pour sortir les données et obtenir le résultat
suivant sur le volet message :
== unmarshalling "Employees.xml" ==
Total Number of XmlEmployees read = 3
First XmlEmployee’s Full Name is Nelson, Robert
Last XmlEmployee’s Full Name is Lambert, Kim
New XmlEmployee’s Full Name is Castor, Charlie
New XmlEmployee’s Modified Full Name is Castor, Peter
Total Number of XmlEmployees read = 4
6 Basculez vers Employees.xml pour vérifier que les données ont été
réintégrées par marshalling dans le document XML. Remarquez que
Charlie Castor a été ajouté puis modifié. Lors de la seconde lecture des
employés, le nouvel employé est pris en compte.
Félicitations. Vous avez terminé le tutoriel. Vous avez utilisé une
application Java et des classes Java générées par l’expert Liaison de
données à partir d’un fichier schéma pour lire, ajouter et modifier dans un
document XML des données relatives à des employés.
Tutoriel : Liaison de données par schéma avec Castor
7-9
7-10
Guide du développeur d’applications XML
Chapitre
8
Tutoriel : Transfert de données
avec les composants
base de données XML
basés sur des modèles
Chapitre8
C’est une fonctionnalité
de JBuilder Entreprise.
Ce tutoriel explique comment utiliser les composants JBuilder de bases de
données XML basés sur des modèles pour transférer des données d’un
document XML vers une base de données et inversement. Il présente
également l’utilisation de l’expert XML-DBMS pour créer le fichier
d’affectation obligatoire utilisé lors du transfert des données et la création
d’un fichier script SQL permettant de créer la base de données.
Ce tutoriel suppose que vous avez déjà travaillé avec JBuilder et XML. Si
vous n’avez jamais utilisé JBuilder, consultez “L’environnement de
JBuilder” dans Construction d’applications avec JBuilder.
Les composants basés sur des modèles utilisent un document d’affectation
qui détermine la méthode de transfert les données entre une structure
XML et les métadonnées d’une base de données. En raison de la
correspondance entre un élément du document XML et une table ou une
colonne particulière d’une base de données, des documents XML
profondément imbriqués peuvent être transférés vers et depuis un
ensemble de tables de base de données. Les composants basés sur des
modèles sont implémentés en utilisant XML-DBMS, middleware XML
Open Source fourni avec JBuilder.
Tu torie l : Tra nsfert de do nn ée s a v ec l es c o m po s an ts b as e d e d on né es XML b asé s s u r d es mo dè les
8-1
Introduction
Au cours de ce tutoriel, vous allez apprendre à :
• Créer un fichier d’affectation qui met en correspondance les éléments
d’un fichier DTD avec les colonnes d’une table de base de données.
• Créer un fichier script SQL qui crée les métadonnées de la table de base
de données.
• Utiliser le composant XDBMSTable pour extraire des données d’un
document XML et les transmettre à la table de base de données.
• Utiliser le même composant XDBMSTable pour transférer des données de
la table de base de données vers un document XML.
• Utiliser le composant XDBMSQuery pour transférer des données de la table
de base de données vers un document XML.
• Utiliser les personnaliseurs de XDBMSTable et de XDBMSQuery pour définir
des propriétés et afficher les résultats de leurs paramètres sur le
transfert de données.
Pour plus d’informations sur les fonctionnalités XML de JBuilder, voir les
chapitres 2 et 3.
Introduction
Ce tutoriel crée une table de base de données XmlEmployee contenant des
informations fondamentales sur les employés, comme un numéro unique,
le nom, le salaire, la date d’embauche, la qualification, etc.. Avant de créer
la table, il faut disposer d’une DTD qui définit les métadonnées de la table
de base de données permettant le transfert des données. Vous pouvez en
créer une manuellement ou, si vous disposez d’un document XML de
structure correcte, utiliser ce dernier pour créer la DTD à l’aide de l’expert
XML vers DTD.
Dans JBuilder, ouvrez le projet \jbuilder5\samples\Tutorials\XML\database\
XMLDBMSBeans\XMLDBMSBeans.jpx qui contient le fichier DTD dont vous avez
besoin, Employees.dtd. Il ressemble à ceci :
<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT XmlEmployee (EmpNo, FirstName, LastName, PhoneExt, HireDate, DeptNo,
JobCode, JobGrade, JobCountry, Salary, FullName)>
<!ELEMENT DeptNo (#PCDATA)>
<!ELEMENT EmpNo (#PCDATA)>
<!ELEMENT FirstName (#PCDATA)>
<!ELEMENT FullName (#PCDATA)>
<!ELEMENT HireDate (#PCDATA)>
<!ELEMENT JobCode (#PCDATA)>
<!ELEMENT JobCountry (#PCDATA)>
<!ELEMENT JobGrade (#PCDATA)>
<!ELEMENT LastName (#PCDATA)>
<!ELEMENT PhoneExt (#PCDATA)>
<!ELEMENT Salary (#PCDATA)>
<!ELEMENT XmlEmployees (XmlEmployee+)>
8-2
Guide du développeur d’applications XML
Introduction
L’exemple de projet contient aussi un fichier Employees.xml. Si ce fichier
n’existait pas dans le projet, vous pourriez le créer à l’aide de l’expert DTD
vers XML en spécifiant Employees.dtd comme DTD d’entrée. Il faudrait
ensuite modifier la structure XML obtenue et ajouter les données. Par la
suite, vous utiliserez Employees.xml pour remplir la table de base de
données et modifier ses données. Dans l’exemple de projet, Employees.xml
contient les données de trois employés. Il ressemble à ceci :
<?xml version="1.0"?>
<!DOCTYPE XmlEmployees SYSTEM "Employees.dtd">
<XmlEmployees>
<XmlEmployee>
<EmpNo>2</EmpNo>
<FirstName>Robert</FirstName>
<LastName>Nelson</LastName>
<PhoneExt>250</PhoneExt>
<HireDate>1988-12-28</HireDate>
<DeptNo>600</DeptNo>
<JobCode>VP</JobCode>
<JobGrade>2</JobGrade>
<JobCountry>USA</JobCountry>
<Salary>105900.000000</Salary>
<FullName>Nelson, Robert</FullName>
</XmlEmployee>
<XmlEmployee>
<EmpNo>4</EmpNo>
<FirstName>Bruce</FirstName>
<LastName>Young</LastName>
<PhoneExt>233</PhoneExt>
<HireDate>1988-12-28</HireDate>
<DeptNo>621</DeptNo>
<JobCode>Eng</JobCode>
<JobGrade>2</JobGrade>
<JobCountry>USA</JobCountry>
<Salary>97500.000000</Salary>
<FullName>Young, Bruce</FullName>
</XmlEmployee>
<XmlEmployee>
<EmpNo>5</EmpNo>
<FirstName>Kim</FirstName>
<LastName>Lambert</LastName>
<PhoneExt>22</PhoneExt>
<HireDate>1989-02-06</HireDate>
<DeptNo>130</DeptNo>
<JobCode>Eng</JobCode>
<JobGrade>2</JobGrade>
<JobCountry>USA</JobCountry>
<Salary>102750.000000</Salary>
<FullName>Lambert, Kim</FullName>
</XmlEmployee>
</XmlEmployees>
Tu torie l : Tra nsfert de do nn ée s a v ec l es c o m po s an ts b as e d e d on né es XML b asé s s u r d es mo dè les
8-3
Création des fichiers script SQL et d’affectation
Création des fichiers script SQL et d’affectation
Vous avez déjà la structure de la table de base de données telle qu’elle a
été définie par la DTD et un document XML contenant les données à
stocker dans la table. Mais vous n’avez pas encore de table de base de
données réelle ; vous devez donc la créer. Il vous faut aussi un fichier
d’affectation qui décrit comment transférer correctement les données des
éléments XML vers les bonnes colonnes de la nouvelle base de données.
L’expert XML-DMBS de JBuilder peut générer le fichier script SQL à
exécuter pour créer la table en même temps que le fichier d’affectation
nécessaire au transfert des données.
Pour ouvrir l’expert XML-DBMS, choisissez Fichier|Nouveau, cliquez sur
l’onglet XML, puis double-cliquez sur l’icône XML-DBMS.
Entrée d’informations concernant la connexion JDBC
Ce tutoriel utilise la base de données JDataStore employee.jds, qui se trouve
dans le répertoire
\jbuilder5\samples\JDataStore\datastores. Si vous avez déjà utilisé des
exemples JDataStore, vous avez déjà sur votre système une connexion
JDBC vers ce datastore. Si c’est le cas, cliquez sur le bouton Choisir une
connexion existante et sélectionnez cette dernière. Vous voyez que les
Paramètres de la connexion sont déjà remplis. Sinon, vous devez entrer les
informations vous-même. Suivez ces étapes :
1 Dans la liste déroulante, sélectionnez
com.borland.datastore.jdbc.DataStoreDriver comme pilote. JDataStore
doit être installé sur votre système. Pour obtenir des informations sur
l’utilisation de JDataStore, consultez le Guide du développeur JDataStore,
“Notions fondamentales JDataStore”.
8-4
Guide du développeur d’applications XML
Création des fichiers script SQL et d’affectation
2 Spécifiez l’URL du datastore que vous utilisez, employee.jds. Lorsque
vous sélectionnez DataStoreDriver comme pilote, un masque vous
guide dans la saisie de l’URL correcte. Supposons que JBuilder est
installé sur le disque C: de votre système. L’URL donnant accès au
datastore employee.jds du répertoire samples est :
jdbc:borland:dslocal:C:\jbuilder5\samples\JDataStore\datastores\employee.jds
3 Comme Nom d’utilisateur, entrez Sample.
4 Comme Mot de passe, entrez une valeur quelconque ou laissez le
champ vide. (employee.jds ne nécessite aucun mot de passe).
5 Ignorez le champ Propriétés avancées.
Test de la connexion
Pour tester la validité de votre connexion JDBC, cliquez sur le bouton
Tester la connexion. Un message Succès ou Echec apparaît sur le volet
près du bouton :
Après avoir réussi la connexion, vous pouvez passer à la page suivante de
l’expert. Choisissez Suivant.
Tu torie l : Tra nsfert de do nn ée s a v ec l es c o m po s an ts b as e d e d on né es XML b asé s s u r d es mo dè les
8-5
Création des fichiers script SQL et d’affectation
Spécification des noms de fichiers
Sur la deuxième page de l’expert XML-DBMS, spécifiez le fichier DTD
utilisé pour créer le fichier d’affectation, ainsi que les noms que les fichiers
script SQL et d’affectation générés doivent porter.
Suivez ces étapes :
1 Utilisez le bouton Fichier DTD d’entrée ... pour atteindre et sélectionner
le fichier Employees.dtd du projet XMLDBMSBeans.jpx.
2 Acceptez le Nom du fichier d’affectation proposé par JBuilder,
Employees.map.
3 Acceptez le Fichier SQL de sortie proposé par JBuilder, Employees.sql.
4 Activez la case à cocher Créer une table XMLDBMSKey par défaut.
5 Choisissez Terminer.
L’expert XML-DBMS génère les fichiers Employees.map et Employees.sql. Ils
apparaissent dans votre projet. Double-cliquez sur Employees.map pour voir
comment les éléments XML seront affectés aux colonnes de la table de
base de données à créer. Si vous vouliez changer le nom des colonnes dans
la table de base de données qui va être créée, vous pourriez modifier les
noms des colonnes dans le fichier d’affectation. Dans ce cas, il faudrait
apporter les mêmes modifications aux noms des colonnes dans le fichier
script SQL. Ne faites aucune modification dans le cadre de ce tutoriel.
Mais il vous arrivera souvent d’avoir à modifier les fichiers script SQL et
d’affectation créés par l’expert pour répondre à vos besoins.
8-6
Guide du développeur d’applications XML
Création des tables de base de données
Création des tables de base de données
Double-cliquez sur Employees.sql dans le volet projet pour voir les
instructions SQL générées par l’expert XML-DBMS. Vous remarquerez
qu’il ne contient pas une, mais trois instructions CREATE TABLE. La
première crée une table XmlEmployee qui contient les métadonnées
spécifiées par la DTD, avec une colonne “XmlEmployeesFK”
supplémentaire (FK signifiant clé étrangère). La deuxième instruction
CREATE TABLE crée une table XmlEmployees qui ne contient qu’une
colonne appelée “XmlEmployeesPK” (PK signifiant clé primaire). La
troisième crée une table XMLDBMSKey. Pour représenter la structure du fichier
DTD d’entrée, XML-DBMS utilise ces trois tables.
Pour exécuter ces instructions SQL, vous pouvez utiliser le pilote de base
de données de JBuilder :
1 Sélectionnez tout le texte du fichier Employees.sql et choisissez Edition|
Copier pour le mettre dans le presse-papiers.
2 Choisissez Outils|Pilote de base de données pour ouvrir le Pilote de
base de données.
3 Double-cliquez sur l’URL de base de données que vous avez spécifié
dans l’expert XML-DBMS.
4 Cliquez sur l’onglet Saisie SQL.
Tu torie l : Tra nsfert de do nn ée s a v ec l es c o m po s an ts b as e d e d on né es XML b asé s s u r d es mo dè les
8-7
Utilisation de l’exemple d’application test
5 Dans la zone Instruction SQL, collez les instructions SQL copiées :
6 Cliquez sur Exécuter.
Le Pilote de base de données crée les trois tables dans le datastore
employee.jds.
7 Fermez le Pilote de base de données.
Utilisation de l’exemple d’application test
Généralement, un développeur utilise des composants JBuilder de base de
données XML pour développer une application présentant une interface
graphique destinée aux utilisateurs. Ce n’est pas l’objet de ce tutoriel.
Nous allons utiliser à la place XMLDBMS_Test.java, exemple d’application
constitué tout simplement d’une classe Java contenant des composants de
base de données XML basés sur des modèles et définissant les propriétés
de ces composants. Ce tutoriel montre comment utiliser les
personnaliseurs de composants pour définir des propriétés et comment
afficher les résultats d’un transfert de données. Lorsque vous êtes certain
qu’un transfert fonctionne correctement, vous pouvez continuer à bâtir en
toute confiance l’application à interface utilisateur graphique qui
l’entoure.
Dans le projet XMLDBMSBeans ouvert, double-cliquez sur le paquet
com.borland.samples.DBMS pour afficher son contenu. Vous y trouverez un
fichier, XMLDBMS_Test.java. Double-cliquez dessus pour l’ouvrir dans
l’éditeur.
Examinez le code source et vous verrez qu’il contient les deux
composants, XMLDBMSTable et XMLDBMSQuery. Au cours de la création de votre
8-8
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
propre application test, il vous suffit de suivre les étapes ci-dessous pour
ajouter ces composants à votre application :
Affichez la classe de l’application dans l’éditeur.
Cliquez sur l’onglet Conception.
Cliquez sur l’onglet XML de la palette des composants.
Sélectionnez le composant XMLDBMSTable et placez-le sur le Concepteur
d’interface utilisateur.
5 Sélectionnez le composant XMLDBMSQuery et placez-le sur le Concepteur
d’interface utilisateur.
1
2
3
4
Utilisation du personnaliseur de XMLDBMSTable
Pour commencer à utiliser le composant XMLDBMSTable,
1 Cliquez sur l’onglet Conception lorsque l’exemple d’application est
ouvert dans l’éditeur. Dans le volet structure, un dossier Autre contient
les deux composants basés sur des modèles.
2 Cliquez avec le bouton droit sur XMLDBMSTable dans le volet structure et
choisissez la commande Personnaliseur. Le personnaliseur de
XMLDBMSTable apparaît :
Sélection d’une connexion JDBC
L’exemple d’application définit déjà toutes les propriétés dans son code
source. Si vous étiez en train de créer votre propre application, vous
devriez remplir vous-même tous les champs du personnaliseur. Imaginez
que les champs sont vides et poursuivez le tutoriel pour les remplir.
Comme lors de la première étape de l’expert XML-DBMS, vous devez
sélectionner la connexion JDBC. Comme vous disposez déjà d’une
connexion, cliquez simplement sur le bouton Choisir une connexion
existante et sélectionnez la connexion que vous avez établie vers le
datastore employee.jds.
Tu torie l : Tra nsfert de do nn ée s a v ec l es c o m po s an ts b as e d e d on né es XML b asé s s u r d es mo dè les
8-9
Utilisation de l’exemple d’application test
Dès que la connexion est sélectionnée, le personnaliseur se sert de ses
données pour remplir les autres champs. Pour vérifier la validité de votre
connexion, cliquez sur le bouton Tester la connexion.
Transfert de données d’un document XML vers la table de base de
données
Cliquez sur l’onglet Transfert pour afficher la page suivante du
personnaliseur :
Fournissez les informations de transfert requises :
1 Si elle n’est pas sélectionnée, cliquez sur l’option XML vers DB située
au centre de la page. Vous préparez le transfert des données du
document Employees.xml vers la table XmlEmployee.
2 Utilisez le bouton Fichier XML d’entrée ... pour atteindre et sélectionner
le fichier Employees.xml dans le projet. Vous devez toujours spécifier le
nom complet et, si vous utilisez le bouton points de suspension, le nom
du fichier inclura toujours le chemin d’accès complet.
3 Utilisez le bouton Fichier d’affectation ... pour atteindre et sélectionner
le fichier Employees.map dans le projet.
Ce sont les seuls champs obligatoires pour le transfert. Les autres champs
sont désactivés. Comme l’exemple d’application XMLDBMSBeans_Test.java
définit des valeurs de propriétés pour ces champs dans son code source,
ils contiennent déjà des valeurs. Ils ne sont pas utilisés pour le transfert de
8-10
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
données depuis le document XML vers la table de base de données
XmlEmployees.xml. Le personnaliseur doit ressembler à ceci :
Pour transférer les données du document XmlEmployees.xml vers la table de
base de données XmlEmployees.xml que vous avez créée, choisissez
Transférer.
Le transfert des données s’effectue.
Transfert de données d’une table de base de données vers un
document XML
Avant de pouvoir transférer des données d’un document XML vers la
table de base de données, il faut modifier le fichier Employees.map.
L’élément “XmlEmployee” doit se comporter en tant que racine. En
conséquence, Employees.map doit demander à XML-DBMS d’ignorer la
racine présente, l’élément “XmlEmployees” (au pluriel), et d’utiliser à la
place l’élément “XmlEmployee” (au singulier). Suivez ces étapes :
1 Double-cliquez sur Employees.map dans le volet projet pour l’ouvrir dans
l’éditeur.
2 Modifiez le fichier pour qu’il ressemble à ce qui suit. Le texte en gras
correspond au code que vous ajoutez :
<?xml version=’1.0’ ?>
<!DOCTYPE XMLToDBMS SYSTEM "xmldbms.dtd" >
<XMLToDBMS Version="1.0">
<Options>
</Options>
<Maps>
<IgnoreRoot>
<ElementType Name="XmlEmployees"/>
<PseudoRoot>
<ElementType Name="XmlEmployee"/>
<CandidateKey Generate="No">
<Column Name="EmpNo"/>
T ut or i el : T r a ns f e r t d e do nné es av e c l e s c o m p os a nt s b as e de d on née s X M L b asé s s u r de s m od èl e s
8-11
Utilisation de l’exemple d’application test
</CandidateKey>
</PseudoRoot>
</IgnoreRoot>
<ClassMap>
<ElementType Name="XmlEmployee"/>
<ToClassTable>
<Table Name="XMLEmployee"/>
</ToClassTable>
<PropertyMap>
<ElementType Name="FullName"/>
<ToColumn>
<Column Name="FullName"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="JobGrade"/>
<ToColumn>
<Column Name="JobGrade"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="Salary"/>
<ToColumn>
<Column Name="Salary"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="JobCode"/>
<ToColumn>
<Column Name="JobCode"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="PhoneExt"/>
<ToColumn>
<Column Name="PhoneExt"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="JobCountry"/>
<ToColumn>
<Column Name="JobCountry"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="LastName"/>
<ToColumn>
<Column Name="LastName"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="FirstName"/>
<ToColumn>
8-12
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
<Column Name="FirstName"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="HireDate"/>
<ToColumn>
<Column Name="HireDate"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="EmpNo"/>
<ToColumn>
<Column Name="EmpNo"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="DeptNo"/>
<ToColumn>
<Column Name="DeptNo"/>
</ToColumn>
</PropertyMap>
</ClassMap>
</Maps>
</XMLToDBMS>
Pour obtenir le résultat ci-dessus, vous devez également enlever ce bloc
de code :
<ClassMap>
<ElementType Name="XmlEmployees"/>
<ToRootTable>
<Table Name="XmlEmployees"/>
<CandidateKey Generate="Yes">
<Column Name="XmlEmployeesPK"/>
</CandidateKey>
</ToRootTable>
<RelatedClass KeyInParentTable="Candidate">
<ElementType Name="XmlEmployee"/>
<CandidateKey Generate="Yes">
<Column Name="XmlEmployeesPK"/>
</CandidateKey>
<ForeignKey>
<Column Name="XmlEmployeesFK"/>
</ForeignKey>
</RelatedClass>
</ClassMap>
3 Enregistrez le projet.
T ut or i el : T r a ns f e r t d e do nné es av e c l e s c o m p os a nt s b as e de d on née s X M L b asé s s u r de s m od èl e s
8-13
Utilisation de l’exemple d’application test
Jusqu’ici, vous n’avez aucune preuve qu’un transfert de données ait eu
lieu, si ce n’est qu’aucune erreur n’a été déclarée (bien que vous puissiez
voir les données à l’aide du Pilote de base de données). Mais si des
données existent maintenant réellement dans la table XmlEmployee, vous
devriez pouvoir les transférer vers un document XML. Pour cela, vous
pouvez utiliser la page Transfert du personnaliseur de XMLDBMSTable.
Pour transférer des données de la table XmlEmployee vers le document XML
appelé Employees_out.xml,
1 Sélectionnez l’option DB vers XML. Les champs du personnaliseur
changent légèrement.
2 Remplacez le nom du Fichier XML de sortie, Employees.xml, par
Employees_out.xml.
3 Conservez le nom du Fichier d’affectation, Employees.map (fichier que
vous avez modifié), y compris le nom de son chemin.
4 Comme Nom de table, spécifiez XmlEmployee.
5 Cliquez sur le bouton Valeurs clés ... pour afficher l’Editeur de clés et
spécifier une valeur clé égale à 2 :
1 Dans l’Editeur de clés, cliquez sur le bouton Ajouter.
2 Sélectionnez l’élément ajouté, remplacez sa valeur par 2, puis
appuyez sur Entrée.
3 Cliquez sur OK pour fermer l’Editeur de clés.
La valeur que vous avez entrée est celle de la colonne “EmpNo”
correspondant à l’employé à transférer de la table de base de données
vers le document Employees_out.xml. La colonne “EmpNo” est la clé
primaire de XmlEmployee. Pour voir les enregistrements de plusieurs
employés, utilisez le champ Valeurs clés et son éditeur de propriétés
pour spécifier plusieurs numéros d’employés.
Pour transférer des données de la table XmlEmployee vers le document
Employees_out.xml, choisissez Voir DOM.
8-14
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
Le transfert a lieu. Vous pouvez voir le résultat de votre demande de
transfert :
Choisissez OK.
Utilisation du personnaliseur de XMLDBMSQuery
Vous pouvez également utiliser le composant XMLDBMSQuery pour extraire
des données d’une table de base de données avec une instruction SQL.
Pour commencer à utiliser le composant XMLDBMSQuery,
1 Cliquez sur l’onglet Conception lorsque l’exemple d’application est
ouvert dans l’éditeur.
2 Cliquez avec le bouton droit sur XMLDBMSQuery dans le volet structure et
choisissez la commande Personnaliseur.
T ut or i el : T r a ns f e r t d e do nné es av e c l e s c o m p os a nt s b as e de d on née s X M L b asé s s u r de s m od èl e s
8-15
Utilisation de l’exemple d’application test
Le personnaliseur de XMLDBMSQuery apparaît :
Sélection d’une connexion JDBC
Comme vous l’avez déjà fait dans le cas du composant XMLDBMSTable,
cliquez sur le bouton Choisir une connexion existante et spécifiez la
connexion à employee.jds que vous avez déjà établie.
Transfert de données avec une instruction SQL
Cliquez sur Transfert pour aller à la page suivante :
Fournissez les informations de transfert requises :
1 Utilisez le bouton Fichier XML de sortie ... pour atteindre et
sélectionner le fichier Employees_out.xml que vous avez créé
précédemment. Vous devez toujours spécifier le nom complet et, si
vous utilisez le bouton points de suspension, le nom du fichier inclura
toujours le chemin d’accès complet.
2 Utilisez le bouton Fichier d’affectation ... pour atteindre et sélectionner
le fichier EmployeesQuery.map dans le projet.
8-16
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
3 Entrez l’instruction SQL suivante dans le champ SQL :
Select * from "XmlEmployee"
N’oubliez pas de mettre le nom de la table entre guillemets doubles.
Cette instruction extrait toutes les lignes de la table XmlEmployee vers le
document Employees_out.xml. Bien évidemment, vous pouvez également
utiliser n’importe quelle instruction SQL correcte pour interroger la
table XmlEmployee. Par exemple,
Select * from "XmlEmployee" where "JobCode" = ’VP’
4 Pour voir le résultat, choisissez Voir DOM. Voici le résultat de la
première requête :
Fichiers d’affectation du composant XMLDBMSQuery
Vous avez sans doute remarqué que le composant XMLDBMSQuery a utilisé un
fichier d’affectation, EmployeesQuery.map, différent de celui utilisé par le
composant XMLDMSTable. Voici à quoi ressemble le fichier EmployeesQuery.map,
les différences avec Employees.map étant signalées en gras :
<?xml version=’1.0’ ?>
<!DOCTYPE XMLToDBMS SYSTEM "xmldbms.dtd" >
<XMLToDBMS Version="1.0">
<Options>
</Options>
<Maps>
<IgnoreRoot>
T ut or i el : T r a ns f e r t d e do nné es av e c l e s c o m p os a nt s b as e de d on née s X M L b asé s s u r de s m od èl e s
8-17
Utilisation de l’exemple d’application test
<ElementType Name="XmlEmployees"/>
<PseudoRoot>
<ElementType Name="XmlEmployee"/>
<CandidateKey Generate="No">
<Column Name="EmpNo"/>
</CandidateKey>
</PseudoRoot>
</IgnoreRoot>
<ClassMap>
<ElementType Name="XmlEmployee"/>
<ToClassTable>
<Table Name="Result Set"/>
</ToClassTable>
<PropertyMap>
<ElementType Name="FullName"/>
<ToColumn>
<Column Name="FullName"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="JobGrade"/>
<ToColumn>
<Column Name="JobGrade"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="Salary"/>
<ToColumn>
<Column Name="Salary"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="JobCode"/>
<ToColumn>
<Column Name="JobCode"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="PhoneExt"/>
<ToColumn>
<Column Name="PhoneExt"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="JobCountry"/>
<ToColumn>
<Column Name="JobCountry"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="LastName"/>
<ToColumn>
<Column Name="LastName"/>
8-18
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="FirstName"/>
<ToColumn>
<Column Name="FirstName"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="HireDate"/>
<ToColumn>
<Column Name="HireDate"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="EmpNo"/>
<ToColumn>
<Column Name="EmpNo"/>
</ToColumn>
</PropertyMap>
<PropertyMap>
<ElementType Name="DeptNo"/>
<ToColumn>
<Column Name="DeptNo"/>
</ToColumn>
</PropertyMap>
</ClassMap>
</Maps>
</XMLToDBMS>
Quand vous utilisez le composant XMLDBMSQuery pour interroger la table de
base de données XmlEmployee, l’élément “XmlEmployee” doit se comporter
en tant que racine. En conséquence, le fichier d’affectation doit demander
à XML-DBMS d’ignorer la racine présente, l’élément “XmlEmployees” (au
pluriel), et d’utiliser à la place l’élément “XmlEmployee” (au singulier). Si
le fichier EmployeesQuery.map n’existait pas alors que c’est le cas ici, il vous
faudrait apporter vous-même les modifications nécessaires au fichier
d’affectation. Vous devriez ajouter le bloc de code commençant par
<IgnoreRoot> et se terminant par </IgnoreRoot>. Il serait également
nécessaire de donner le nom “Result Set” à la table de sortie. Pour
terminer, vous devriez retirer ce bloc de code :
<ClassMap>
<ElementType Name="XmlEmployees"/>
<ToRootTable>
<Table Name="XmlEmployees"/>
<CandidateKey Generate="Yes">
<Column Name="XmlEmployeesPK"/>
</CandidateKey>
</ToRootTable>
<RelatedClass KeyInParentTable="Candidate">
<ElementType Name="XmlEmployee"/>
<CandidateKey Generate="Yes">
T ut or i el : T r a ns f e r t d e do nné es av e c l e s c o m p os a nt s b as e de d on née s X M L b asé s s u r de s m od èl e s
8-19
Utilisation de l’exemple d’application test
<Column Name="XmlEmployeesPK"/>
</CandidateKey>
<ForeignKey>
<Column Name="XmlEmployeesFK"/>
</ForeignKey>
</RelatedClass>
</ClassMap>
8-20
Guide du développeur d’applications XML
Chapitre
9
Tutoriel : Transfert de données
avec les composants
base de données XML
basés sur des templates
Chapitre9
C’est une fonctionnalité
de JBuilder Entreprise.
Ce tutoriel explique comment utiliser les composants JBuilder de bases de
données XML basés sur des templates pour extraire des données d’une
base et les placer dans un fichier XML.
Ce tutoriel suppose que vous avez déjà travaillé avec JBuilder et XML. Si
vous n’avez jamais utilisé JBuilder, consultez “L’environnement de
JBuilder” dans Construction d’applications avec JBuilder.
Avec les composants basés sur des templates, vous formulez une requête
et le composant génère un document XML approprié. Cette requête sert
de template remplacé dans le document XML en tant que résultat
d’application du template. La solution basée sur des templates est très
souple et il n’y a pas de relation prédéfinie entre le document XML et
l’ensemble de métadonnées que vous interrogez dans la base de données.
Le format du document XML obtenu est relativement simple et
élémentaire. Vous pouvez donner au document XML obtenu la
présentation de votre choix à l’aide de feuilles de style, par défaut ou
personnalisées.
Ce tutoriel montre comment effectuer les tâches suivantes :
• Extraire des données d’une table d’une base et les placer dans un
document XML avec le composant XTable.
T u to r i el : T r an s fe r t d e d on né es a ve c les comp osa nts ba se de do nnée s XML ba sés s ur d es te m p l at es
9-1
Introduction
• Extraire des données d’une table d’une base et les placer dans un
document XML en utilisant une instruction SQL, avec le composant
XQuery.
• Utiliser les personnaliseurs de XTable et de XQuery pour définir des
propriétés et afficher les résultats de ces définitions de propriétés sur le
transfert de données.
Pour plus d’informations sur les fonctionnalités XML de JBuilder, voir les
chapitres 2 et 3.
Introduction
Ce tutoriel utilise la table de base de données XmlEmployee, créée au
Chapitre 8, “Tutoriel : Transfert de données avec les composants
base de données XML basés sur des modèles”. Si vous n’avez pas encore
étudié ce tutoriel, nous vous conseillons de le faire maintenant. Utilisez au
moins l’expert XML-DBMS pour créer l’affectation et les fichiers script
SQL décrits dans ce tutoriel, puis exécutez les instructions SQL pour créer
la table XmlEmployee. Le Chapitre 8, “Tutoriel : Transfert de données avec
les composants base de données XML basés sur des modèles”, explique
comment faire.
Dans JBuilder, ouvrez l’exemple de projet \jbuilder5\samples\Tutorials\
XML\database\XBeans.jpx.
Utilisation de l’exemple d’application test
Généralement, un développeur utilise des composants JBuilder de base de
données XML pour développer une application présentant une interface
graphique destinée aux utilisateurs. Ce n’est pas l’objet de ce tutoriel.
Nous allons utiliser à la place XBeans_Test.java, exemple d’application
constitué tout simplement d’une classe Java contenant des composants de
base de données XML basés sur des templates et définissant les propriétés
de ces composants. Ce tutoriel montre comment utiliser les
personnaliseurs de composants pour définir des propriétés et comment
afficher les résultats d’un transfert de données. Lorsque vous êtes certain
qu’un transfert fonctionne correctement, vous pouvez continuer à bâtir en
toute confiance l’application à interface utilisateur graphique qui
l’entoure.
Dans le projet XBeans, double-cliquez sur le paquet com.borland.samples\
xml.XBean pour avoir accès à l’exemple d’application XBeans_Test.java.
Double-cliquez sur cet exemple pour l’afficher dans l’éditeur de code.
Examinez le code source et vous verrez qu’il contient des deux
composants, xTable et xQuery. Au cours de la création de votre propre
9-2
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
application test, il vous suffit de suivre les étapes ci-dessous pour ajouter
ces composants à votre application :
1 Affichez la classe de l’application dans l’éditeur.
2 Cliquez sur l’onglet Conception.
3 Cliquez sur l’onglet XML de la palette des composants.
4 Sélectionnez le composant XTable et placez-le sur le Concepteur
d’interface utilisateur.
5 Sélectionnez le composant XQuery et placez-le sur le Concepteur
d’interface utilisateur.
Utilisation du personnaliseur de XTable
Pour commencer à utiliser le composant XTable,
1 Cliquez sur l’onglet Conception lorsque l’exemple d’application est
ouvert dans l’éditeur. Dans le volet structure, un dossier Autre contient
les deux composants basés sur des modèles.
2 Cliquez avec le bouton droit sur xTable dans le volet structure et
choisissez la commande Personnaliseur. Le personnaliseur de xTable
apparaît :
Entrée d’informations concernant la connexion JDBC
Ce tutoriel utilise la base de données JDataStore employee.jds, qui se trouve
dans le répertoire
\jbuilder5\samples\JDataStore\datastores. Si vous avez déjà utilisé des
exemples JDataStore, vous avez déjà sur votre système une connexion
JDBC vers ce datastore. Si c’est le cas, cliquez sur le bouton Choisir une
T u to r i el : T r an s fe r t d e d on né es a ve c les comp osa nts ba se de do nnée s XML ba sés s ur d es te m p l at es
9-3
Utilisation de l’exemple d’application test
connexion existante et sélectionnez cette dernière. Vous voyez que les
Paramètres de la connexion sont déjà remplis. Sinon, vous devez entrer les
informations vous-même. Suivez ces étapes :
1 Dans la liste déroulante, sélectionnez
com.borland.datastore.jdbc.DataStoreDriver comme pilote. JDataStore
doit être installé sur votre système. Pour obtenir des informations sur
l’utilisation de JDataStore, consultez le Guide du développeur JDataStore :
“Notions fondamentales JDataStore”.
2 Spécifiez l’URL du datastore que vous utilisez, employee.jds. Lorsque
vous sélectionnez DataStoreDriver comme pilote, un masque vous
guide dans la saisie de l’URL correcte. Supposons que JBuilder est
installé sur le disque C: de votre système. L’URL donnant accès au
datastore employee.jds du répertoire samples est :
jdbc:borland:dslocal:C:\jbuilder5\samples\JDataStore\datastores\employee.jds
3 Comme Nom d’utilisateur, entrez Sample.
4 Entrez n’importe quelle valeur de Mot de passe. (employee.jds n’en
nécessite aucun).
5 Ignorez le champ Propriétés avancées.
Pour tester la validité de votre connexion JDBC, cliquez sur le bouton
Tester la connexion. Un message Succès ou Echec apparaît sur le volet
près du bouton :
Transfert de données de la table de base de données vers un
document XML
Cliquez sur l’onglet Transfert pour afficher la page suivante du
personnaliseur :
9-4
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
Fournissez les informations de transfert requises :
1 Laissez vide le champ Fichier requête, car vous n’utiliserez aucun
fichier requête dans le cadre de ce tutoriel. Pour plus d’informations
sur les fichiers requête, consultez “Document de requête XML” dans
Construction d’applications avec JBuilder.
2 Spécifiez le nom du document vers lequel transférer les données.
Fournissez toujours un nom complet.
3 Ignorez le champ Fichier XSL. Ce tutoriel utilise la feuille de style par
défaut du composant.
4 Comme Format de colonne, sélectionnez En tant qu’éléments.
5 Comme Format de sortie, sélectionnez HTML.
6 Pour Noms d’élément, spécifiez XmlEmployees comme Document et
XmlEmployee comme Ligne.
7 Laissez l’option Ignorer les valeurs nulles désactivée.
8 Comme Nom de table, choisissez "XmlEmployee".
9 Cliquez sur le bouton Clés pour afficher l’Editeur de clés et spécifier
une valeur clé de “EmpNo” :
1 Dans l’Editeur de clés, cliquez sur le bouton Ajouter.
2 Sélectionnez l’élément ajouté, remplacez sa valeur par “EmpNo”,
puis appuyez sur Entrée. Veillez à mettre la valeur entre guillemets.
3 Cliquez sur OK pour fermer l’Editeur de clés.
10 Cliquez sur le bouton DefaultParams ...pour afficher les paramètres par
défaut et, en particulier, donner la valeur ‘2’ au paramètre “EmpNo” :
1 Dans l’Editeur de Paramètres par défaut, cliquez sur le bouton
Ajouter.
2 Sélectionnez l’élément ajouté, remplacez le Nom du paramètre par
“EmpNo” et la Valeur du paramètre par ‘2’, puis appuyez sur
Entrée. Veillez à respecter les guillemets et les apostrophes.
3 Cliquez sur OK pour fermer l’Editeur de Paramètres par défaut.
Vous voilà prêt à transférer les données. Si vous avez sélectionné le
Format de sortie HTML, choisissez Transférer, puis cliquez sur Voir (ou
choisissez directement Voir pour voir à quoi le transfert ressemblera). Vos
T u to r i el : T r an s fe r t d e d on né es a ve c les comp osa nts ba se de do nnée s XML ba sés s ur d es te m p l at es
9-5
Utilisation de l’exemple d’application test
résultats, qui utilisent la feuille de style HTML par défaut, ont l’aspect
suivant :
Choisissez OK.
Maintenant, cochez plutôt l’option Format de sortie XML. Lorsque vous le
faites, le bouton Voir DOM remplace le bouton Voir. Remarquez que le
Fichier de sortie que vous avez spécifié a maintenant une extension .xml.
Cliquez sur Voir DOM pour afficher l’arborescence XML par défaut :
Choisissez OK.
9-6
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
Utilisation du personnaliseur de XQuery
Vous pouvez également utiliser le composant XQuery pour extraire des
données d’une table de base de données avec une instruction SQL.
Pour commencer à utiliser le composant XQuery de l’exemple d’application,
1 Cliquez sur l’onglet Conception lorsque l’exemple d’application est
ouvert dans l’éditeur.
2 Cliquez avec le bouton droit sur xQuery dans le volet structure et
choisissez la commande Personnaliseur.
Le personnaliseur de xQuery apparaît :
Sélection d’une connexion JDBC
Comme vous l’avez déjà fait avec le composant XTable, cliquez sur le
bouton Choisir une connexion existante et spécifiez la connexion à
employee.jds que vous avez déjà établie.
T u to r i el : T r an s fe r t d e d on né es a ve c les comp osa nts ba se de do nnée s XML ba sés s ur d es te m p l at es
9-7
Utilisation de l’exemple d’application test
Transfert de données avec une instruction SQL
Cliquez sur Transfert pour aller à la page suivante :
Fournissez les informations de transfert requises :
1 Laissez vide le champ Fichier requête, car vous n’utiliserez aucun
fichier requête dans le cadre de ce tutoriel. Pour plus d’informations
sur les fichiers requête, consultez “Document de requête XML” dans
Construction d’applications avec JBuilder.
2 Spécifiez le nom du document vers lequel transférer les données.
Fournissez toujours un nom complet.
3 Ignorez le champ Fichier XSL. Ce tutoriel utilise la feuille de style par
défaut du composant.
4 Comme Format de colonne, sélectionnez En tant qu’éléments.
5 Comme Format de sortie, sélectionnez HTML.
6 Pour Noms d’élément, spécifiez XmlEmployees comme Document et
XmlEmployee comme Ligne.
7 Laissez l’option Ignorer les valeurs nulles désactivée.
8 Entrez dans le champ SQL l’instruction suivante à utiliser pour
interroger la base de données :
select * from "XmlEmployee"
9 Ignorez le champ DefaultParams.
9-8
Guide du développeur d’applications XML
Utilisation de l’exemple d’application test
Choisissez Voir pour afficher les résultats en utilisant la feuille de style
HTML par défaut:
Choisissez OK.
Maintenant, cochez plutôt l’option Format de sortie XML. Lorsque vous le
faites, le bouton Voir DOM remplace le bouton Voir. Remarquez que le
Fichier de sortie que vous avez spécifié a maintenant une extension .xml.
Cliquez sur Voir DOM pour afficher l’arborescence XML par défaut :
Choisissez OK.
T u to r i el : T r an s fe r t d e d on né es a ve c les comp osa nts ba se de do nnée s XML ba sés s ur d es te m p l at es
9-9
Utilisation de l’exemple d’application test
Ensuite, essayez une requête paramétrée en tant qu’instruction SQL :
1 Entrez cette instruction dans le champ SQL :
select * from "XmlEmployee" where "EmpNo" = :"EmpNo"
2 Dans l’Editeur de Paramètres par défaut, ajoutez “EmpNo” comme
Nom de paramètre et ‘5’ comme Valeur de paramètre :
3 Cliquez sur OK pour fermer l’Editeur de Paramètres par défaut.
Ensuite, choisissez Voir DOM pour un format de sortie XML ou Voir pour
un format de sortie HTML. Vous obtenez comme résultat le seul employé
portant le numéro 5.
9-10
Guide du développeur d’applications XML
Index
A
activation du visualiseur XML 2-18
affectation d’objets relationnels 3-11
application à des documents XML 2-13
feuilles de style en cascade (CSS) 2-5
fichiers schéma (.xsd) 2-21
fonctionnalités XML dans JBuilder 2-1
B
G
beans XML basés sur des templates
définition des propriétés 3-2
bibliothèques
XML 2-19
Borland
contacter 1-2
Borland Online 1-2
BorlandXML (liaison de données) 2-21, 2-22
génération de classes Java
BorlandXML 2-22
Castor 2-24
Gestionnaire SAX (expert) 2-19
groupes de discussion 1-3
Borland 1-3
C
Java (classes)
génération à partir de DTD 2-21
génération à partir de schémas 2-21, 2-24
génération avec l’expert Liaison de
données 2-22
JDBC (connexions)
création 3-3
JDBC (pilotes)
spécification 3-3
Castor (liaison de données) 2-21
Castor (structure de liaison de données XML) 2-24
Cocoon (structure de publication XML) 2-10
composants XML basés sur des modèles 3-1, 3-11
définition des propriétés 3-17
définition des propriétés avec l’inspecteur 3-21
entrée des informations de transfert 3-19
personnaliseurs 3-17
composants XML basés sur des templates 3-1, 3-2
définition des propriétés avec l’inspecteur 3-9
définition des propriétés avec un document de
requête 3-9
contacter Borland 1-2
groupes de discussion 1-3
World Wide Web 1-2
conventions de la documentation 1-4
conventions des plates-formes 1-5
D
document d’affectation 3-11
document de requête
XML 3-9
Document de requête XML 3-9
documents XML
création à partir de DTD 2-2
DTD
création à partir de documents XML 2-2, 2-4
DTD vers XML (expert) 2-2
F
feuille de style par défaut 2-18
feuilles de style
J
L
liaison de données 2-21
Liaison de données (expert) 2-22, 2-24
M
marshalling et dé-marshalling
conversion entre Java et XML 2-22
P
personnaliseurs
XML (composants de bases de données) 3-2
polices
conventions de la documentation 1-4
R
ressources en ligne 1-2
S
SAX (gestionnaires)
création 2-19
SAX (Simple API for XML) 2-19
Simple API for XML (SAX) 2-19
Index
I-1
suivi
activation 2-13
Suivi de la transformation (options)
définition 2-18
support aux développeurs 1-2
support technique 1-2
T
transformation de documents XML 2-13
tutoriels
Création d’un Gestionnaire SAX pour analyser
des documents XML 5-1
Liaison de données DTD avec BorlandXML 6-1
Liaison de données par schéma avec Castor 7-1
Transfert de données avec les composants de
bases de données XML basés sur des
modèles 8-1
Transfert de données avec les composants de
bases de données XML basés sur des
templates 9-1
Validation et transformation de documents
XML 4-1
U
Usenet, groupes de discussion 1-3
V
validation de documents XML 2-7
validation de DTD 2-7
Vue de la transformation (barre d’outils) 2-13
W
World Wide Web Consortium 2-1
X
Xalan (processeur de feuille de style) 2-13
et Xerces 2-13
XBeans (bibliothèque) 3-1
Xerces (analyseur) 2-7
et Xalan 2-13
XML
présentation 2-10
transformation 2-10
XML (bibliothèques) 2-19
XML (composants basés sur des modèles) 2-25
XML (composants basés sur des templates) 2-25
XML (composants de bases de données) 3-1
XML (création) 2-2
XML (document d’affectation) 3-11
XML (documents de requête) 3-4
I-2
Guide du développeur d’applications XML
XML (documents)
application de feuilles de style 2-13
manipulation par programme 2-19
transformation 2-13
validation 2-7
visualisation 2-5
XML (grammaire)
validation
XML (messages d’erreur) 2-7
XML (liaison de données) 2-21
XML (options)
définition 2-18
XML (prise en charge de bases de données) 2-25
XML (publication) 2-10
XML (suivi)
activation 2-13
XML (validation) 2-2
XML (visualiseur)
activation 2-5, 2-18
XML défini 2-1
XML vers DTD (expert) 2-2, 2-4
XML, construction correcte 2-7
XML-DBMS 2-25, 3-11
emplacement 3-11
langage d’affectation 3-11
support dans JBuilder 3-12
XML-DBMS (expert) 3-13
XMLDBMSQuery (composant) 2-25, 3-11
entrée des informations de transfert 3-19
XMLDBMSQuery (personnaliseur) 3-17
création d’une connexion JDBC 3-18
XMLDBMSTable (composant) 2-25, 3-11
XMLDBMSTable (personnaliseur) 3-17
création d’une connexion JDBC 3-18
entrée des informations de transfert 3-19
XQuery (composant) 2-25
XQuery (personnaliseur)
création d’une connexion JDBC 3-3
entrée des informations de transfert 3-4
requête paramétrée 3-7
transfert vers HTML 3-8
transfert vers XML 3-8
XSLT (Extensible Stylesheet Language
Transformations) 2-13
XSLT (feuille de style par défaut) 2-5
XTable (composant) 2-25
XTable (personnaliseur)
création d’une connexion JDBC 3-3
entrée des informations de transfert 3-4
transfert vers HTML 3-8
transfert vers XML 3-8
utilisation de paramètres 3-7