|
L’objet de ce nouveau tutoriel est multiple. En effet,
le sujet principal est l’utilisation d’un arbre grâce à la classe JTree, mais comme nous allons étudier son utilisation
associée à une mini base de données, nous en profiterons donc aussi pour
faire connaissance avec interbase.
Attention, pour profiter pleinement
de ce tutoriel et du fait de l'utilisation de composants base de donnée
, il faut disposer d'une version Jbuilder professionnelle ou entreprise
ainsi que d'interbase et de son driver Jdbc.
La base de données :
Cette base est relativement simple. Elle a pour objet
de fournir le support nécessaire à l’illustration d’une arborescence.
La meilleure façon pour cela est de modéliser un livre constitué de parties
, chapitres et de lignes de textes . Notre arbre en sera en quelque sorte
la table des matières.
Construction de la base de données :
Pour cela nous
allons utiliser Interbase 6.5.
Nous commençons par créer un répertoire , dans cet exemple
il s’appellera DataBase . Puis nous ouvrons IBConsole , nous nous connectons
au serveur local, puis dans le
menu Database nous choisissons Create Database . La fenêtre suivante apparaît et
nous allons y préciser l’emplacement et le fichier .gdb à créer ainsi
que la taille de la base de donnée et son alias:
Après avoir validé par OK, notre base est créée, il ne
reste plus qu’à y inscrire des utilisateurs et à y créer nos tables, et
bien sûr à les remplir de données.
Construction des tables
Pour cela, nous allons maintenant ouvrir le programme
pilote de base de donnée à partir du menu outil de JBUILDER7.
Tout d’abord, nous allons ajouter créer un URL vers notre
toute nouvelle base de donnée en sélectionnant URL base de donnée et l’option
Nouveau du menu fichier. Dans la fenêtre suivante, nous
allons associer le pilote interbase au chemin d’accès de notre base de
donnée :
Après validation, notre base de donnée est ajoutée à
la liste des URL .
Nous allons maintenant pouvoir créer les tables de notre
base de donnée avec l’option Créer une table du menu fichier.
Puis nous y mettrons quelques données grâce l’outil interactive
SQL auquel nous accédons par IBConsole…
Le programme en JAVA
Ce dernier sera très simple. En effet, si nous voulons
apprendre un point particulier, ici manipuler un JTREE, il faut savoir
se consacrer à l’essentiel.
Donc, nous afficherons , après l’avoir initialisé notre
arbre dans une fenêtre et un bouton
nous permettra de quitter l’application.
Les classes :
Ce programme utilisera 3 classes :
AppTreeTuto
la classe principale de l’application
CadreTreeTuto
le cadre qui contient notre jtree
Dm
Un module de donnée qui regroupe nos accès à la base de donnée.
Construction du projet :
Dans Jbuilder, nous créerons un nouveau projet grâce
à l’expert .
Une fois ce dernier créé, nous ajoutons une nouvelle
classe de type module de donnée :
.
Nous ouvrons maintenant notre classe Dm et nous sélectionnons
le concepteur.
A quoi sert cette classe module de données, et bien simplement
à regrouper en un seul endroit les composants base de donnée utilisés
par notre application.
Grâce au concepteur, nous allons choisir le composant
Jdatabase dans l’onglet DataExpress de la barre de composant.
Une fois ce dernier ajouté à notre classe, nous allons
lui donner les propriétés pour le lier à notre petite base de donnée d’exemple.
et tout particulièrement voici la configuration de la
propriété connexion qui se configure d’une façon très simple grâce à la puissance de JBuilder :
L’URL doit indiquer notre base de donnée Interbase JTUTO.GDB
.
Le mot de passe est ici ‘eleve’ . Si nous souhaitons
qu’il soit demandé à chaque fois que le programme sera exécuté , il faudra
cocher la case ‘Demander le mot de passe’.
Un petit test de la connexion nous permet de voir que
tout est ok.
Simultanément , Jbuilder génère le code java correspondant .
Maintenant, nous allons ajouter le ou les accès aux tables
de notre application.
Nous réaliserons cela en ajoutant à Dm des composants
QueryDataSet qui nous permettons d’accéder à nos tables grâce à SQL
Là encore, Jbuilder nous apporte l’aide de ses puissants
experts pour configurer notre composant et dans notre cas notamment la
requête SQL de la propriété query :
Nous ajouterons donc dans la classe Dm tous les accès
aux tables de notre base de données.
Passons maintenant à l’application.
Nous ajoutons au projet 2 nouvelles classes en choisissant
l’expert Application. Je passerai sur les détails car je suppose que créer
une application avec jbuilder vous est déjà connu.
Dans la classe du cadre, nous ouvrirons le concepteur
et nous ajouterons un JscrollPane et
Jtree à notre panel et le bouton pour quitter le programme.
JTREE
Bien passons maintenant au vif du sujet, l’arbre et son
utilisation .
Qu’est ce qu’un arbre ?
C’est une structure de donnée particulière qui possède
un point de départ, la racine , des branches et des feuilles.
Ce qui tient lieu de racine, de branches ou de feuilles
sont des instances de l’objet DefaultMutableTreeNode.
Rattacher ces objets entre eux constitue l’arbre. Le
nœud de départ qui n’a pas de parent est la racine, une nœud peut être
rattaché à un ou plusieurs autres nœud, les branches et enfin, un nœud
sans enfant est une feuille.
Comment construit on un arbre ?
Supposons que nous souhaitions représenter l’arborescence
suivante :
Départ
|
-Branche1
|
|
| -F1
| -F2
|
-Branche2
|
-F3
Tout d’abord, on crée
une instance de Jtree
JTree jTree1 = new JTree();
Puis , il nous faut la racine
DefaultMutableTreeNode root = new DefaultMutableTreeNode("Départ");
On construit les branches que l’on prévoie
DefaultMutableTreeNode Branche1 = new
DefaultMutableTreeNode("B1");
On ajoute nos feuille à la branche,
Branche1.Add(new DefaultMutableTreeNode("F1"))
Branche1.Add(new DefaultMutableTreeNode("F2"))
Puis notre branche à la racine
root.Add(Branche1)
Passons à la branche numéro 2
DefaultMutableTreeNode Branche2 = new
DefaultMutableTreeNode("B2");
Branche2.Add(new DefaultMutableTreeNode("F1"))
root.Add(Branche2)
A ce moment précis, nous avons liés entre eux
une serie de noeuds d’arbre constituée d’un point de départ, de branches
et de feuilles.
Il nous faut maintenant l’associer à notre objet Jtree
qui lui se chargera de mettre en œuvre les méthodes nécessaires à l’affichage , la navigation et autre aspect
graphique et intéractif.
Pour cela, il nous faut une instance d’un objet modèle
d’arbre auquel nous passerons en paramètre du constructeur notre liste
de nœud liés entre eux qui constitue notre arborescence.
model = new DefaultTreeModel(root);
sur lequel notre Jtree s’appuira ensuite.
jTree1.setModel(model);
Entre parenthèses, vous remarquerez ici que notre objet
Jtree s’appuie sur un modèle d’arbre et que nous avons ici utilisé une
instance de l’objet DefaultTreeModel . Il va sans dire que si vous avez
besoin d’un arbre qui possède un comportement particulier, vous pouvez
tout à fait vous créer votre propre modèle d’arbre et y programmer le
comportement souhaité (tout comme pour les tables et leur modèles de table
cf tutoriel
modèle de table).
Maintenant que vous avez un peu compris le principe de
la construction d’un arbre, étudions celui qui fait l’objet de ce tutoriel…
Tout à lieu dans la méthode treeLoad().
Détaillons la un peu :
Notre arbre ici doit représenter un livre composé de
parties, chacune étant elle même une suite de chapitres dans lesquels
on trouve du texte.
Chacune de ces parties constituera une branche dans notre
arborescence et ces branches seront classées hiérarchiquement dans l’ordre
Livre contient Partie
qui contient Chapitre
qui contient
Texte.
Le livre est stocké dans une table et pour pouvoir charger
notre arbre, il faut lire cette table dans le bon ordre.
C’est le rôle du QueryDataSet et de la requête SQL que
nous avons vu plus haut.
Cela correspond au code suivant :
void treeLoad()
{
DefaultMutableTreeNode root = new DefaultMutableTreeNode("livre");
DefaultMutableTreeNode chap = null;
DefaultMutableTreeNode part = null;
DefaultMutableTreeNode text =null;
DmTuto.getQdsLivre().open();
Pour remplir notre arbre, nous allons lire notre table
et surveiller les changements de chapitres et de parties
(ce que l’on appelle les ruptures de contrôle) .
Quand il n’y a pas de rupture , on remplie la branche
en cours avec le texte, quand il y a rupture , on remplie la branche du
niveau supérieur avec la branche
actuelle terminée et on commence la nouvelle branche…
Cela est réalisé dans la boucle suivante. Les variables
p et c contiennent la partie et
chapitre que l’on lit dans la table et sp et sc contiennent
les sauvegardes des valeurs précédentes des parties et chapitres. Ces
4 variables servent à déterminer quant il y a rupture (dès que c <>
sc ou p <> sp)
int
c =0;
int
p =0;
int
sc =0 ;
int
sp = 0 ;
while ( DmTuto.getQdsLivre().next())
// Tant que la derniere ligne du querydataset
n'est pas atteinte, lire la ligne suivante
{
c=
DmTuto.getQdsLivre().getInt("CHAPITRE");//
lecture du numéro de chapitre
p=
DmTuto.getQdsLivre().getInt("PARTIE");//
lecture du numéro de partie
text
= new DefaultMutableTreeNode(DmTuto.getQdsLivre().getString("TEXTE"));//
lecture du texte
if (p==sp)
{
if (c==sc)
{//
Cas normal, pas de rupture
chap.add(text);//
ajouter le texte au chapitre en cours
}else// ruture sur le chapitre
{
chap = new DefaultMutableTreeNode(new
Integer(c));// Créer u nouveau
chapitre
chap.add(text);//
y stocker le texte lu
part.add(chap);//
Ajouter ce chapitre à la partie
sc=c; //
mémoriser le nouveau chapitre
}
}else//
ruture sur la partie
{
chap = new DefaultMutableTreeNode(new
Integer(c));// créer un nouveau
chapitre
part = new DefaultMutableTreeNode(new
Integer(p));// créer une nouvelle
partie
chap.add(text);//
ajouter le texte à notre nouveau chapitre
part.add(chap);//ajouter
notre nouveau chapitre à notre nouvelle partie
root.add(part);//
et ajouter cette nouvelle partie à notre arbre (à sa racine)
sc=c;//
mémoriser le nouveau chapitre
sp=p;//
mémoriser la nouvelle partie
}
}
Enfin, une fois notre arborescence chargée, il ne reste
plus qu’à fermer la table et construire notre arbre
DmTuto.getQdsLivre().close();//
fermer la table
//
finaliser notre arbre maintenant qu'il à un contenu....
model
= new DefaultTreeModel(root);
jTree1.setModel(model);
}
Pour ce qui est du reste, je vous laisse jeter un œil
dans le programme qui reste du Jbuilder classique et aussi le soin d'ajouter
le code pour aller chercher dans les tables Partie et Chapitre les intitulés
de ces derniers afin de les afficher au bons endroits dans l'arbre….
Pour télécharger les sources et la base
de donnée de ce tutoriel : ICI
|
