Guide du développeur d applications XML - Accueildeptinfo.unice.fr/~buffa/jbuilder5/pdf/xml.pdf ·...

Guide du développeur d’applications XML

V E R S I O N 5

Borland®

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 1E0R05010102030405-9 8 7 6 5 4 3 2 1PDF

i

Chapitre 1Introduction 1-1Comment contacter le support développeur

de Borland . . . . . . . . . . . . . . . . . . . . 1-2Ressources en ligne. . . . . . . . . . . . . . . 1-2World Wide Web . . . . . . . . . . . . . . . . 1-2Groupes de discussion Borland. . . . . . . . 1-3Groupes de discussion Usenet . . . . . . . . 1-3Rapports de bogues . . . . . . . . . . . . . . 1-3

Conventions de la documentation . . . . . . . . 1-4Conventions pour le Macintosh . . . . . . . . . 1-6

Chapitre 2Utilisation des fonctionnalités XML de JBuilder 2-1

Présentation . . . . . . . . . . . . . . . . . . . . 2-1Création et validation de XML . . . . . . . . . . 2-2

Création de documents XML . . . . . . . . . 2-2Expert DTD vers XML . . . . . . . . . . . 2-2Expert XML vers DTD . . . . . . . . . . . 2-4

Visualisation de documents XML . . . . . . 2-5Visualiseur XML de JBuilder . . . . . . . 2-5

Validation de documents XML . . . . . . . . 2-7Présentation de XML . . . . . . . . . . . . . . . 2-10

Structure de publication XML Cocoon. . . . 2-10Transformation de documents XML . . . . . 2-13

Application de feuilles de style internes .2-14Application de feuilles de style externes .2-15Définition des options de suivi

de la transformation . . . . . . . . . . . 2-17Configurations XML. . . . . . . . . . . . . . . . 2-18Ressources XML . . . . . . . . . . . . . . . . . . 2-19Manipulation de XML par programme . . . . . 2-19

Création d’un gestionnaire SAX . . . . . . . 2-19Liaison de données . . . . . . . . . . . . . . . 2-21

BorlandXML. . . . . . . . . . . . . . . . . 2-22Castor . . . . . . . . . . . . . . . . . . . . 2-24

Interface avec des données métier dans des bases de données . . . . . . . . . . . 2-25

Chapitre 3Utilisation des composants de bases de données XML de JBuilder 3-1

Utilisation des composants basés sur des templates . . . . . . . . . . . . . . . . . 3-2

Définition des propriétés des beans templates . . . . . . . . . . . . . . 3-2

Utilisation du personnaliseur de composants . . . . . . . . . . . . . . . 3-2

Utilisation de l’inspecteur. . . . . . . . . . 3-9Document de requête XML . . . . . . . . . 3-9

Utilisation des composants basés sur des modèles . . . . . . . . . . . . . . . . . 3-11

XML-DBMS . . . . . . . . . . . . . . . . . . 3-11JBuilder et XML-DBMS . . . . . . . . . . . . 3-12Expert XML-DBMS . . . . . . . . . . . . . . 3-13Définition des propriétés

des composants basés sur des modèles . . 3-17Utilisation du personnaliseur

de composants . . . . . . . . . . . . . . 3-17Utilisation de l’inspecteur. . . . . . . . . 3-21

Chapitre 4Tutoriel : Validation et transformationde documents XML 4-1

Présentation . . . . . . . . . . . . . . . . . . . . . 4-1Etape 1 : Création d’un document XML

à partir d’une DTD . . . . . . . . . . . . . . . . 4-2Etape 2 : Insertion des données

dans le document XML généré . . . . . . . . . 4-3Etape 3 : Validation du document XML . . . . . 4-4Etape 4 : Association de feuilles de style

au document . . . . . . . . . . . . . . . . . . . . 4-6Etape 5 : Transformation du document

à l’aide de feuilles de style . . . . . . . . . . . . 4-8Etape 6 : Définition des options de suivi

de la transformation . . . . . . . . . . . . . . . 4-9

Table des matières

ii

Chapitre 5Tutoriel : Création d’un Gestionnaire SAX pour analyser des documents XML 5-1

Présentation . . . . . . . . . . . . . . . . . . . . 5-1Etape 1 : Utilisation

de l’expert Gestionnaire SAX . . . . . . . . . . 5-2Etape 2 : Modification de l’analyseur SAX . . . 5-4Etape 3 : Exécution du programme . . . . . . . 5-6Etape 4 : Ajout d’attributs . . . . . . . . . . . . . 5-7Code source de MySaxParser.java . . . . . . . . 5-8

Chapitre 6Tutoriel : Liaison de données DTD avec BorlandXML 6-1

Présentation . . . . . . . . . . . . . . . . . . . . 6-1Etape 1 : Génération de classes Java

à partir d’une DTD. . . . . . . . . . . . . . . . 6-2Etape 2 : Dé-marshalling des données . . . . . . 6-5Etape 3 : Ajout d’un employé . . . . . . . . . . . 6-6Etape 4 : Modification d’un employé . . . . . . 6-7Etape 5 : Exécution de l’application terminée. . 6-8

Chapitre 7Tutoriel : Liaison de données par schéma avec Castor 7-1

Présentation . . . . . . . . . . . . . . . . . . . . 7-1Etape 1 : Génération de classes Java

à partir d’un schéma . . . . . . . . . . . . . . . 7-2Etape 2 : Dé-marshalling des données . . . . . . 7-5Etape 3 : Ajout d’un employé . . . . . . . . . . . 7-6Etape 4 : Modification des données

du nouvel employé . . . . . . . . . . . . . . . 7-7Etape 5 : Exécution de l’application terminée. . 7-8

Chapitre 8Tutoriel : Transfert de données avec les composants base de données XML basés sur des modèles 8-1

Introduction . . . . . . . . . . . . . . . . . . . . 8-2Création des fichiers script SQL

et d’affectation . . . . . . . . . . . . . . . . . . 8-4

Entrée d’informations concernant la connexion JDBC. . . . . . . . . . . . . . . 8-4

Test de la connexion . . . . . . . . . . . . . 8-5Spécification des noms de fichiers . . . . . . . 8-6

Création des tables de base de données . . . . . 8-7Utilisation de l’exemple d’application test . . . . 8-8

Utilisation du personnaliseur de XMLDBMSTable . . . . . . . . . . . . . . 8-9

Sélection d’une connexion JDBC . . . . . . 8-9Transfert de données d’un document XML

vers la table de base de données . . . . 8-10Transfert de données d’une table de base de

données vers un document XML. . . . 8-11Utilisation du personnaliseur

de XMLDBMSQuery . . . . . . . . . . . . 8-15Sélection d’une connexion JDBC . . . . . 8-16Transfert de données

avec une instruction SQL . . . . . . . . 8-16Fichiers d’affectation du composant

XMLDBMSQuery . . . . . . . . . . . . 8-17

Chapitre 9Tutoriel : Transfert de données avec les composants base de données XML basés sur des templates 9-1

Introduction . . . . . . . . . . . . . . . . . . . . . 9-2Utilisation de l’exemple d’application test . . . . 9-2

Utilisation du personnaliseur de XTable . . . 9-3Entrée d’informations concernant

la connexion JDBC . . . . . . . . . . . . . 9-3Transfert de données de la table de base

de données vers un document XML . . . 9-4Utilisation du personnaliseur de XQuery. . . 9-7

Sélection d’une connexion JDBC . . . . . . 9-7Transfert de données

avec une instruction SQL . . . . . . . . . 9-8

Index I-1

I n t r o d u c t i o n 1-1

C h a p i t r e

1Chapitre1Introduction

Le support XMLest une fonctionnalité

de JBuilder Professionnelet 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.

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 tutorielssont 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”

1-2 G u i d e d u d é v e l o p p e u r d ’ a p p l i c a t i o n s X M L

C o m m e n t c o n t a c t e r l e s u p p o r t d é v e l o p p e u r d e B o r l a n d

Comment contacter le support développeur de BorlandBorland 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

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.

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.


C o m m e n t c o n t a c t e r l e s u p p o r t d é v e l o p p e u r d e B o r l a n d

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 :

• 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

Remarque 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é.


C o n v e n t i o n s d e l a d o c u m e n t a t i o n

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 documentationLa 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

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.


C o n v e n t i o n s d e l a d o c u m e n t a t i o n

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.

< > 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.

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.

Tableau 1.1 Polices et symboles (suite)

Police Signification


C o n v e n t i o n s p o u r l e M a c i n t o s h

Conventions pour le MacintoshJBuilder 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.

U t i l i s a t i o n d e s f o n c t i o n n a l i t é s X M L d e J B u i l d e r 2-1

C h a p i t r e

2Chapitre2Utilisation des fonctionnalités

XML de JBuilder

PrésentationCes fonctionnalités

font partiede JBuilder Professionnelet 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ésfont partie

de JBuilder Entreprise.

• Manipulation de documents XML par programme

• Interface avec des données métier dans des bases de données

Voir aussi 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/


C r é a t i o n e t v a l i d a t i o n d e X M L

Création et validation de XMLLa création

et la validationsont des fonctionnalités


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 XMLL’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 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



Figure 2.2 XML créé par l’expert

Expert XML vers DTDL’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.



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 JBuilderDans 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 Vue XML avec la feuille de style par défaut

Remarque Vous pouvez développer et réduire la vue arborescente en cliquant sur les symboles plus (+) et moins (–).



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 Document 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.



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.



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


P r é s e n t a t i o n d e X M L

Présentation de XMLLa présentation

est une fonctionnalitéde JBuilder Professionnelet 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.



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.



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.



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



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 internesPour 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

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.



Application de feuilles de style externesVous 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.



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.



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 transformationVous 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.


C o n f i g u r a t i o n s X M L

Configurations XMLFonctionnalité


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 :

• Génération• Modèles• Eléments• Sélections


R e s s o u r c e s X M L

Ressources XMLD’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 programmeLa manipulationpar 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


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.


M a n i p u l a t i o n d e X M L p a r p r o g r a m m e

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 documentdébut élément : pagedébut élément : titrecaractères : Exemple basé sur des événementsfin élément : titredébut élément : contenucaractères : Bonjour à tous !fin élément : contenufin élément : pagefin 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.



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


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.

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

BorlandXMLBorlandXML 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.



• 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”.



CastorCastor 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.


I n t e r f a c e a v e c d e s d o n n é e s m é t i e r d a n s d e s b a s e s d e d o n n é e s

3 Remplissez les champs obligatoires, tels que le nom du paquet, et spécifiez vos options.


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éesL’interfaçage avec

des données métierest 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.


I n t e r f a c e a v e c d e s d o n n é e s m é t i e r d a n s d e s b a s e s d e d o n n é e s

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 XML-DBMS à l’adresse http://www.rpbourret.com/xmldbms/

U t i l i s a t i o n d e s c o m p o s a n t s d e b a s e s d e d o n n é e s X M L d e J B u i l d e r 3-1

C h a p i t r e

3Chapitre3Utilisation des composants

de bases de données XMLde JBuilder


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


U t i l i s a t i o n d e s c o m p o s a n t s b a s é s s u r d e s t e m p l a t e s

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 templatesLes 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 composantsChaque 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.



Voici le personnaliseur de XTable :

Connexion JDBCDans 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.



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

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.



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.



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.

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.



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ètresSi 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 :

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.

emp_no emp_name

1 Tom

2 Dick



• 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 HTMLPour 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) :



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’inspecteurVous 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 XMLUne 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’">

<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"/> </Query>


U t i l i s a t i o n d e s c o m p o s a n t s b a s é s s u r d e s m o d è l e s

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èlesDans 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.



Les éléments principaux du langage d’affectation incluent :

ClassMapClassMap 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.

PropertyMapPropertyMap affecte des éléments uniquement PCDATA et des attributs de valeur simple à des colonnes spécifiques dans une table de base de données.

RelatedClassMapRelatedClassMap 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 OptionsOutre 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 :

• 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



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.



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 :





Nom d’utilisateur Si nécessaire, entrez le nom de l’utilisateur de la source de données.





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 :

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 request (req_name, parameter*)><!ELEMENT parameter (para_name, type, value)><!ELEMENT req_name (#PCDATA)><!ELEMENT para_name (#PCDATA)><!ELEMENT type (#PCDATA)><!ELEMENT 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>

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.



<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));



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 composantsPour 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.



Voici le personnaliseur de XMLDBMSTable:

Connexion JDBCDans 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 :




Nom d’utilisateur Si nécessaire, entrez le nom de l’utilisateur de la source de données.






Après avoir réussi une connexion, cliquez sur l’onglet Transfert.

TransfertDans 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.



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.



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 Spécifiez le nom du Fichier XML de sortie.2 Spécifiez le nom du Fichier d’affectation.3 Entrez votre instruction SQL dans le champ SQL.4 Choisissez Transférer.

Regardez le résultat du transfert en choisissant Voir DOM.

Utilisation de l’inspecteurVous 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”.

T u t o r i e l : V a l i d a t i o n e t t r a n s f o r m a t i o n d e d o c u m e n t s X M L 4-1

C h a p i t r e

4Chapitre4Tutoriel : Validation

et transformationde documents XML

PrésentationCe tutoriel utilise

des fonctionnalitésde JBuilder Professionnelet 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.


E t a p e 1 : C r é a t i o n d ’ u n d o c u m e n t X M L à p a r t i r d ’ u n e D T D

• 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 DTDUn 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">


E t a p e 2 : I n s e r t i o n d e s d o n n é e s d a n s l e d o c u m e n t X M L 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>


E t a p e 3 : V a l i d a t i o n d u d o c u m e n t X M L

<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>


Etape 3 : Validation du document XMLDans 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.


E t a p e 3 : V a l i d a t i o n d u d o c u m e n t X M L

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


E t a p e 4 : A s s o c i a t i o n d e f e u i l l e s d e s t y l e a u d o c u m e n t

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 documentLa 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 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.


E t a p e 4 : A s s o c i a t i o n d e f e u i l l e s d e s t y l e a u d o c u m e n t

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.


E t a p e 5 : T r a n s f o r m a t i o n d u d o c u m e n t à l ’ a i d e d e f e u i l l e s d e s t y l e

Etape 5 : Transformation du document à l’aide de feuilles de styleMaintenant 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 :


E t a p e 6 : D é f i n i t i o n d e s o p t i o n s d e s u i v i d e l a t r a n s f o r m a t i o n

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 transformationIl 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.


E t a p e 6 : D é f i n i t i o n d e s o p t i o n s d e s u i v i d e l a t r a n s f o r m a t i o n

• 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.

T u t o r i e l : C r é a t i o n d ’ u n G e s t i o n n a i r e S A X p o u r a n a l y s e r d e s d o c u m e n t s X M L 5-1

C h a p i t r e

5Chapitre5Tutoriel : Création d’un

Gestionnaire SAX pour analyserdes documents XML


des fonctionnalitésde 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.


E t a p e 1 : U t i l i s a t i o n d e l ’ e x p e r t G e s t i o n n a i r e S A X


• 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 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 SAXL’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.


E t a p e 1 : U t i l i s a t i o n d e l ’ e x p e r t G e s t i o n n a i r e S A X

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.


E t a p e 2 : M o d i f i c a t i o n d e l ’ a n a l y s e u r S A X

Etape 2 : Modification de l’analyseur SAXL’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.


E t a p e 2 : M o d i f i c a t i o n d e l ’ a n a l y s e u r S A X

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; //indentpublic 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);}


E t a p e 3 : E x é c u t i o n d u p r o g r a m m e

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).


Etape 3 : Exécution du programmeAvant 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.


E t a p e 4 : A j o u t d ’ a t t r i b u t s

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’attributsEnsuite, 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);


C o d e s o u r c e d e M y S a x P a r s e r . j a v a

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.javapackage com.borland.samples.xml.saxparser;

import java.io.IOException;import org.xml.sax.*;import org.xml.sax.helpers.*;import 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);



} 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) {



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(); }}

T u t o r i e l : L i a i s o n d e d o n n é e s D T D a v e c B o r l a n d X M L 6-1

C h a p i t r e

6Chapitre6Tutoriel : Liaison de données

DTD avec BorlandXML

PrésentationCe tutoriel utilise des

fonctionnalitésde 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.


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.


E t a p e 1 : G é n é r a t i o n d e c l a s s e s J a v a à p a r t i r d ’ u n e D T D


• 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.


Etape 1 : Génération de classes Java à partir d’une DTDLorsque 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/.


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.



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 :


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



l’exemple fourni. Nous allons utiliser cette application pour manipuler les données.


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 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


E t a p e 2 : D é - m a r s h a l l i n g d e s d o n n é e s

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éesAprè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 = 3First Employee’s Full Name is Nelson, RobertLast Employee’s Full Name is Lambert, Kim


E t a p e 3 : A j o u t d ’ u n e m p l o y é

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.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 = 3First Employee’s Full Name is Nelson, RobertLast Employee’s Full Name is Lambert, Kim== unmarshalling "Employees.xml" ==Total Number of Employees read = 4First Employee’s Full Name is Nelson, RobertLast Employee’s Full Name is Chaplin, Charlie

4 Basculez vers Employees.xml et remarquez que Charlie Chaplin a été ajouté en tant que quatrième employé.


E t a p e 4 : M o d i f i c a t i o n d ’ u n e m p l o y é

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 :



// 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 = 4First Employee’s Full Name is Nelson, RobertLast Employee’s Full Name is Chaplin, Charlie== unmarshalling "Employees.xml" ==Total Number of Employees read = 4First Employee’s Full Name is Nelson, RobertLast 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.


E t a p e 5 : E x é c u t i o n d e l ’ a p p l i c a t i o n t e r m i n é e

Etape 5 : Exécution de l’application terminéeAprè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 :


db_BorlandXML = new DB_BorlandXML(); db_BorlandXML.readEmployees(); db_BorlandXML.addEmployee(); db_BorlandXML.readEmployees(); db_BorlandXML.modifyEmployee(); db_BorlandXML.readEmployees(); }


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 = 3First Employee’s Full Name is Nelson, RobertLast Employee’s Full Name is Lambert, Kim== unmarshalling "Employees.xml" ==Total Number of Employees read = 4First Employee’s Full Name is Nelson, RobertLast Employee’s Full Name is Chaplin, Charlie== unmarshalling "Employees.xml" ==



Total Number of Employees read = 4First Employee’s Full Name is Nelson, RobertLast 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.

T u t o r i e l : L i a i s o n d e d o n n é e s p a r s c h é m a a v e c C a s t o r 7-1

C h a p i t r e

7Chapitre7Tutoriel : Liaison de données

par schéma avec Castor


des fonctionnalitésde 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.


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.


E t a p e 1 : G é n é r a t i o n d e c l a s s e s J a v a à p a r t i r d ’ u n s c h é m a


• 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 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émaQuand 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.


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.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 :




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.


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.


E t a p e 2 : D é - m a r s h a l l i n g d e s d o n n é e s

Astuce 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).

Voir aussi 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éesAprè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);


E t a p e 3 : A j o u t d ’ u n e m p l o y é

// 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 XmlEmployeexmlEmployees.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 = 3First XmlEmployee’s Full Name is Nelson, RobertLast XmlEmployee’s Full Name is Lambert, KimNew XmlEmployee’s Full Name is Castor, Charlie


E t a p e 4 : M o d i f i c a t i o n d e s d o n n é e s d u n o u v e l e m p l o y é

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 = 4First XmlEmployee’s Full Name is Nelson, RobertLast XmlEmployee’s Full Name is Castor, CharlieNew XmlEmployee’s Modified Full Name is Castor, Peter



Etape 5 : Exécution de l’application terminéeAprè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 XmlEmployeexmlEmployees.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 XmlEmployeexmlEmployees.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 XMLxmlEmployees.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 XmlEmployeexmlEmployees.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ésSystem.out.println("Total Number of XmlEmployees read = "+xmlEmployees.getXmlEmployeeCount());// Faire un marshalling des données vers le même fichier XMLxmlEmployees.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.




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 = 3First XmlEmployee’s Full Name is Nelson, RobertLast XmlEmployee’s Full Name is Lambert, KimNew XmlEmployee’s Full Name is Castor, CharlieNew XmlEmployee’s Modified Full Name is Castor, PeterTotal 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.

Tutor ie l : T rans fer t de données avec les composan ts base de données XML basés sur des modè l es 8-1

C h a p i t r e

8Chapitre8Tutoriel : Transfert de données

avec les composantsbase de données XML

basés sur des modèlesC’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.


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.


I n t r o d u c t i o n

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.


IntroductionCe 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+)>



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>


C r é a t i o n d e s f i c h i e r s s c r i p t S Q L e t d ’ a f f e c t a t i o n

Création des fichiers script SQL et d’affectationVous 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”.



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 connexionPour 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.



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.


C r é a t i o n d e s t a b l e s d e b a s e d e d o n n é e s

Création des tables de base de donnéesDouble-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.


U t i l i s a t i o n d e l ’ e x e m p l e d ’ a p p l i c a t i o n t e s t

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 testGé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



propre 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 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.

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 JDBCL’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.



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éesCliquez 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

Tutor ie l : T rans fe r t de données avec les composants base de données XML basés sur des modè l es 8-11


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 XMLAvant 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 :


<XMLToDBMS Version="1.0"> <Options> </Options> <Maps> <IgnoreRoot> <ElementType Name="XmlEmployees"/> <PseudoRoot> <ElementType Name="XmlEmployee"/> <CandidateKey Generate="No"> <Column Name="EmpNo"/>



</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>



<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>




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.



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.



Le personnaliseur de XMLDBMSQuery apparaît :

Sélection d’une connexion JDBCComme 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 SQLCliquez sur Transfert pour aller à la page suivante :


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.



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 XMLDBMSQueryVous 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 :


<XMLToDBMS Version="1.0"> <Options> </Options> <Maps> <IgnoreRoot>



</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">

Tuto r ie l : T rans fe r t de données avec les composants base de données XML basés sur des templa tes 9-1

C h a p i t r e

9Chapitre9Tutoriel : Transfert de données

avec les composantsbase de données XML

basés sur des templatesC’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.


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.



• 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.


IntroductionCe 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 testGé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



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 JDBCCe 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”.

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 XMLCliquez sur l’onglet Transfert pour afficher la page suivante du personnaliseur :




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



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.



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 JDBCComme 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.



Transfert de données avec une instruction SQLCliquez sur Transfert pour aller à la page suivante :


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.



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.



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.

I n d e x I-1

Aactivation du visualiseur XML 2-18affectation d’objets relationnels 3-11

Bbeans XML basés sur des templates

définition des propriétés 3-2bibliothèques

XML 2-19Borland

contacter 1-2Borland Online 1-2BorlandXML (liaison de données) 2-21, 2-22

CCastor (liaison de données) 2-21Castor (structure de liaison de données XML) 2-24Cocoon (structure de publication XML) 2-10composants XML basés sur des modèles 3-1, 3-11

définition des propriétés 3-17définition des propriétés avec l’inspecteur 3-21entrée des informations de transfert 3-19personnaliseurs 3-17

composants XML basés sur des templates 3-1, 3-2définition des propriétés avec l’inspecteur 3-9définition des propriétés avec un document de

requête 3-9contacter Borland 1-2

groupes de discussion 1-3World Wide Web 1-2

conventions de la documentation 1-4conventions des plates-formes 1-5

Ddocument d’affectation 3-11document de requête

XML 3-9Document de requête XML 3-9documents XML

création à partir de DTD 2-2DTD

création à partir de documents XML 2-2, 2-4DTD vers XML (expert) 2-2

Ffeuille de style par défaut 2-18feuilles de style

application à des documents XML 2-13feuilles de style en cascade (CSS) 2-5fichiers schéma (.xsd) 2-21fonctionnalités XML dans JBuilder 2-1

Ggénération de classes Java

BorlandXML 2-22Castor 2-24

Gestionnaire SAX (expert) 2-19groupes de discussion 1-3

Borland 1-3

JJava (classes)

génération à partir de DTD 2-21génération à partir de schémas 2-21, 2-24génération avec l’expert Liaison de

données 2-22JDBC (connexions)

création 3-3JDBC (pilotes)

spécification 3-3

Lliaison de données 2-21Liaison de données (expert) 2-22, 2-24

Mmarshalling et dé-marshalling

conversion entre Java et XML 2-22

Ppersonnaliseurs

XML (composants de bases de données) 3-2polices

conventions de la documentation 1-4

Rressources en ligne 1-2

SSAX (gestionnaires)

création 2-19SAX (Simple API for XML) 2-19Simple API for XML (SAX) 2-19

Index

I-2 G u i d e d u d é v e l o p p e u r d ’ a p p l i c a t i o n s X M L

suiviactivation 2-13

Suivi de la transformation (options)définition 2-18

support aux développeurs 1-2support technique 1-2

Ttransformation de documents XML 2-13tutoriels

Création d’un Gestionnaire SAX pour analyser des documents XML 5-1

Liaison de données DTD avec BorlandXML 6-1Liaison de données par schéma avec Castor 7-1Transfert 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

UUsenet, groupes de discussion 1-3

Vvalidation de documents XML 2-7validation de DTD 2-7Vue de la transformation (barre d’outils) 2-13

WWorld Wide Web Consortium 2-1

XXalan (processeur de feuille de style) 2-13

et Xerces 2-13XBeans (bibliothèque) 3-1Xerces (analyseur) 2-7

et Xalan 2-13XML

présentation 2-10transformation 2-10

XML (bibliothèques) 2-19XML (composants basés sur des modèles) 2-25XML (composants basés sur des templates) 2-25XML (composants de bases de données) 3-1XML (création) 2-2XML (document d’affectation) 3-11XML (documents de requête) 3-4

XML (documents)application de feuilles de style 2-13manipulation par programme 2-19transformation 2-13validation 2-7visualisation 2-5

XML (grammaire)validation

XML (messages d’erreur) 2-7XML (liaison de données) 2-21XML (options)

définition 2-18XML (prise en charge de bases de données) 2-25XML (publication) 2-10XML (suivi)

activation 2-13XML (validation) 2-2XML (visualiseur)

activation 2-5, 2-18XML défini 2-1XML vers DTD (expert) 2-2, 2-4XML, construction correcte 2-7XML-DBMS 2-25, 3-11

emplacement 3-11langage d’affectation 3-11support dans JBuilder 3-12

XML-DBMS (expert) 3-13XMLDBMSQuery (composant) 2-25, 3-11

entrée des informations de transfert 3-19XMLDBMSQuery (personnaliseur) 3-17

création d’une connexion JDBC 3-18XMLDBMSTable (composant) 2-25, 3-11XMLDBMSTable (personnaliseur) 3-17

création d’une connexion JDBC 3-18entrée des informations de transfert 3-19

XQuery (composant) 2-25XQuery (personnaliseur)

création d’une connexion JDBC 3-3entrée des informations de transfert 3-4requête paramétrée 3-7transfert vers HTML 3-8transfert vers XML 3-8

XSLT (Extensible Stylesheet Language Transformations) 2-13

XSLT (feuille de style par défaut) 2-5XTable (composant) 2-25XTable (personnaliseur)

création d’une connexion JDBC 3-3entrée des informations de transfert 3-4transfert vers HTML 3-8transfert vers XML 3-8utilisation de paramètres 3-7

Guide du développeur d applications XML - Accueildeptinfo.unice.fr/~buffa/jbuilder5/pdf/xml.pdf ·...

Documents

Transcript of Guide du développeur d applications XML - Accueildeptinfo.unice.fr/~buffa/jbuilder5/pdf/xml.pdf ·...