Visualisation d'une hiérarchie de classes java

Version 1.16
Dernière modification : 8 Janvier 2008

Ne pas imprimer cette page,  celle-ci pouvant être mise à jour par la suite. Le numéro de version figure en dessous du titre.

Objectif du TP

Construire un outil permettant de visualiser sous forme de graphes les relations d'héritage associées à un ensemble de classes spécifiées. La phase d'extraction des données se fera en utilisant l'introspection java. La phase de visualisation se fera en utilisant dot et grappa, des outils de visualisation de graphes développés à AT&T. 

Qualité

La première partie de ce TP est exploratoire : le code fourni n'est pas censé être réutilisé. Ne pas hésiter à faire des copier-coller lorsque nécessaire. Contrairement aux tps suivants aucune norme particulière de qualité n'est exigée. Ce TP a été mis au point pour des versions de java inférieure à 1.5 et n'utilise donc pas les extensions récentes du langages concernant la généricité. En fonction de la version du compilateur utilisé on adaptera les questions ci-dessous. Avec la version 1.4 de java on demande d'indiquer systématiquement pour les signatures des méthodes le type précis des paramètres et du résultat en utilisant les conventions suivantes :

· T?  si T est peut être null

· T!  si T n'est jamais null

· C<T> pour les collections 

o par exemple Set/*<Personne!>?*/ pour null ou un ensemble Personne (ne contentant pas la valeur nulle)

o ou bien Map/*<String!,Node!>!*/

---

Déroulement de la séance

· (1) Sur Windows faire le nécessaire pour que java fonctionne correctement (l'exécution est basée sur la version Windows de dot).

o repérer où le jdk est installé, peut être C:\Logiciel\j2sdk1.4.1

o après avoir ouvert une fenêtre (noire) de commande, définir le chemin d'accès au exécutable pour éviter qu'il y ai des conflits entre les différentes installation de java et les incompatibilité: ne mettre que le jdk1.4 soit    set PATH=C:\j2sdk1.4.1\bin sans espaces (adapter éventuellement le nom du répertoire selon l'emplacement du jdk).

o pour tester votre installation taper java -version qui devrait vous afficher la version 1.4.1 sans doute (ou 1.5 ?). Taper également javac qui devrait afficher un message de la forme "usage ..." (cette dernière précaution est nécessaire car selon les installations l'interpréteur peut être disponible mais pas le compilateur)

· (2) Créer quelque part un répertoire PRI (de préférence dans Z:\, soit Z:\PRI)

· (3) Télécharger la dernière version de l'archive CLASSVIEWx.x.zip que vous trouverez dans le répertoire ARCHIVES.

· (4) Décompacter dans le répertoire PRI, cette archive.  Cette opération crée un répertoire CLASSVIEW dans lequel vous allez travailler.

· (5) Observer le contenu du répertoire CLASSVIEW en vous basant sur les informations ci-dessous. 

bin

• dot.exe  : algorithme de placement pour un graphe. Développé par AT&T. Cet algorithme prend en entrée un graphe dont les noeuds et les arcs ne sont pas positionnés et produit un graphe affichable en associant à chaque élément des coordonnées. 
• neato.exe : idem mais implémentant un "Spring Layout", c'est à dire un algorithme de placement différent.

src

• les sources de différentes classes. Le contenu de ce répertoire devra être complété en créant de nouvelles classes ou en modifiant certaines classes incomplétes.

classes

• les classes compilées à partir des sources contenues dans src (utiliser systématiquement l'option -d classes lors de la compilation).

lib

• grappa1_2.jar : bibliothèque grappa pour l'affichage de graphe. Développé par AT&T. A mettre dans le classpath, par exemple via l'option -classpath de la commande javac et java (voir les exemples fourni ci-dessus lors de la compilation et exécution de la commande ListFiles).

· Le répertoire src contient un certain nombre de classes java complètes ou à compléter ainsi que certaines classes déjà compilées. Le répertoire bin contient le binaire de l'algorithme de placement de graphe dot. 

o se placer dans le répertoire racine de CLASSVIEW. Toutes les commandes seront exécutées à partir de ce répertoire. Si ce n'est pas le cas l'exécutable dot ne pourra pas s'exécuter.

o pour tester dot.exe, taper la ligne suivante. Elle ne doit afficher aucune erreur et ne rien faire (cet exécutable implémente un algorithme de placement. Lorsque aucun fichier n'est fourni sur la ligne de commande, le graphe est lu à partir du clavier) . Taper Ctrl-C pour interrompre ce programme.

§ bin\dot.exe

o on utilisera par la suite des commandes de la forme suivante. Par exemple pour compiler la classe fr.imag.classview.app.ListFiles 

§ javac -classpath classes;lib\grappa1_2.jar -d classes -sourcepath src   src/fr/imag/classview/app/ListFiles.java.
Aucune erreur de compilation ne devrait s'afficher.

o par exemple pour l'exécuter

§ java -classpath classes;lib\grappa1_2.jar fr.imag.classview.app.ListFiles
La liste des repertoires contenus dans le répertoire courant devrait s'afficher.

· suivre les instructions dans ce fichier pour réaliser le TPs

---

Questions 

(Q1) Parcours d'une hiérarchie de fichier

• Compiler et essayer la classe fr.imag.classview.app.ListFiles se trouvant dans le répertoire src.
• Lire cette classe pour la comprendre.
• Remplacer les XXX en indiquant les types précis dans les signatures de méthodes. Ces types seront inférés à partir de la lecture du code (commenter le code est une stratégie efficace de "lecture active"). 
• CR:
• Donner les signatures avec types précis de addFiles et de allFiles. Justifier la réponse.

(Q2) Visualisation d'un graphe simple

• Lire la classe fr.imag.classview.app.SimpleGraph.
• Compiler la classe et l'essayer. Une fenêtre contenant un graphe formé de trois noeuds et 3 arcs devrait apparaître.
• Lire cette classe et la modifier en ajoutant des nœuds, des attributs, etc. De nombreuses propriétés graphiques peuvent être utilisées, permettant ainsi de paramétrer l'affichage des graphes. Ces propriétés seront utilisées pour répondre aux questions suivantes. La documentation de dotty contient un résumé des principales propriétés à la page 11, 12 et 13. Prendre le temps de lire la liste des attributs et tester la fonctionalité des attributs les plus importants. On veillera notamment à répondre aux questions suivantes. Il existe trois types d'attributs, ceux associés aux noeuds, aux arcs et au graphe.
• CR: 
• Quel attribut permet-il de changer l'orientation du graphe (horizontal vs. vertical) ? (Tester ces deux possibilités).
• A quoi correspond l'attribut "tip" sur les noeuds ? Attention: cet attribut n'est pas décrit dans la documentation qui n'est pas tout à fait à jour. Tester avec un valeur correspondant à une chaîne hml "<HTML>un <B><I>mot</I></B><BR>autre ligne" ?
• A quoi correspondent les attributs nodesep et ranksep ?
• Comment définir la couleur de fond d'un noeud ? Comment changer sa forme ?
• Comment définir la taille d'un nœud ? Cette solution est elle compatible avec l'attribut label ?
• Comment tracer des arcs en pointillé ?
• Comment déterminer l'orientation des arcs, ou plus précisemment les cotés sur lesquels apparaissent des "flêches" ?

(Q3) Visualisation d'une hiérarchie de fichiers

• Compléter la classe fr.imag.classview.app.FileGraph pour afficher un graphe à partir d'une structure de répertoire. On utilisera pour cela les connaissances acquises sur le parcours de la structure de répertoire et la construction d'un graphe.
• Modifier cette classe pour prendre que le nom du répertoire à explorer soit donné en paramètre sur la ligne de commande.
• Modifier la classe pour que la couleur de chaque noeud correspond à son type, sachant que l'on s'intéresse à la visualisation de projet typique en java (c'est à dire contenant des fichiers .java, .class, .html, .jar, etc.).
• Ajouter un paramètre ("-compact") à la ligne de commande pour sélectionner les deux modes d'affichage ci-dessous 
• affichage normal: afficher les noms des fichiers à l'intérieur des boites (on affichera le graphe de manière horizontale pour un rendu plus compact).  
• affichage compact: utiliser l'attribut tip pour afficher le nom du fichier uniquement lorsque le curseur passe sur un noeud. Cette technique permet d'afficher des répertoires beaucoup plus volumineux.
• CR:
• pourquoi l'affichage horizontal donne de meilleurs résultats lorsque le nom est affiché ?
• fournir une copie d'écran pour deux modes d'affichages et fournir la légende des couleurs.
• indiquer quelles utilisations pourrait être faites d'un tel affichage et quels patrons graphiques pourraient être reconnaissables.

(Q4) Parcours d'une hiérarchie de classes

• Compiler et essayer la classe fr.imag.classview.app.ListSuperclasses.
• Lire cette classe pour la comprendre.
• Tester ce programme en utilisant éventuellement d'autres classes comme point de départ.
• CR:
• combien les classes javax.swing.JTree et javax.swing.event.TreeModelListener ont elles respectivement de superclasses ? 
• la valeur retournées sont elles compatibles avec l'information fournies dans la documentation javadoc? expliquer brièvement.

(Q5) Visualisation d'une hiérarchie de classes

• Compléter la classe fr.imag.classview.app.ClassGraph. Il s'agit d'un parcours d'une hiérarchie de classes et de la création d'un graphe. Il est nécessaire de conserver une table associative pour marquer les classes déjà visitées car bien entendu une classe doit apparaître une et une seule fois dans le graphe. Utiliser l'interface java.util.Map et une implémentation adaptée pour réalisée la table associative. Modifier cette classe pour que la liste des classes de départ soit fournies en paramètre sur la ligne de commande.
• Afficher le graphe partant des classes javax.swing.JTree, javax.swing.JTable, javax.swing.JButton. Vérifier la validité du graphe obtenu en consultant la documentation javadoc associée à ces classes. Pour que le graphe soit lisible on utilisera l'orientation conventionnelle du haut vers le bas (super classes en haut et sous classes en bas). (Remarque: Dot ne gère que deux orientations et il est donc nécessaire d'utiliser un artifice pour obtenir le résultat voulu. Il faudra pour cela créer des arcs dans le sens inverse (de la super-classe à la sous-classe) et utiliser un style graphique permettant d'afficher les flèches non pas du coté de destination de l'arc mais du coté origine. Consulter la documentation de dot pour les attributs disponibles)
• CR: 
• Donner une image d'écran

(Q6) Visualisation des super classes et des interfaces

• Modifier la classe précédente pour ajouter dans le même graphe les interfaces et non pas uniquement les super-classes. Il ne s'agit donc pas d'une hiérarchie mais d'un graphe acyclique. 
• Choisir trois couleurs différentes pour représenter (1) les classes concrètes, (2) classes abstraites et les interfaces
• Pour se rapprocher de la notation UML on représentera les relations de réalisation (implémentation en java) entre classes et interfaces en pointillé alors que les relation de spécialisation (extends en java) seront représenté en trait plein.
• Utiliser l'attribut "tip" pour indiquer le nom de classe, le nombre d'attributs hérités, le nombre d'attributs déclaré dans la classe, le nombre de méthodes hérités et le nombre de méthodes dérivées.
• CR: 
• Afficher le graphe partant des classes javax.swing.JTree, javax.swing.JTable, javax.swing.JButton. Vérifier la validité du graphe obtenu (notamment les couleurs) en consultant la documentation javadoc associée à ces classes (attention différents bugs sont possibles).
• Donner une image d'écran et spécifier la légende.

(Q7) Interprétation de la hiérarchie de classes correspondant aux collections

• Utiliser la classe précédente pour afficher le graphe correspondant à certaines classes du paquetage collection. A savoir: java.util.ArrayList, java.util.LinkedList, java.util.Stack, java.util.HashSet, java.util.HashMap, java.util.Hashtable, java.util.BitSet, java.util.TreeSet, java.util.LinkedHashSet, java.util.LinkedHashMap. 
• CR: 
• Donner une ou plusieurs images d'écran (voir ci-dessous).
• Commenter le graphe obtenu en expliquant sa structure, la position de chaque classe dans le graphe, et éventuellement les anomalies ou points singulier. Quelles conventions de nommage semblent elles avoir été respectées? Y-a-t il des exceptions? Si oui pourquoi? Pour répondre à cette question on utilisera la documentation javadoc associée lorsque nécessaire. On pourra également produire plusieurs sous-graphes représentatifs pour faciliter le commentaire. Cette partie constitue une partie importante du compte rendu à fournir.

(Q8) Visualisation de métriques

• Modifier la classe précédente pour prendre en compte deux modes d'affichage sélectionnables via la ligne de commande
• affichage normal. (par défaut). Le nom des classes est affiché dans les boites.
• affichage de métrique. Utiliser la hauteur et la largeur pour représenter respectivement le nombre de méthodes déclarées dans la classe et le nombre d'attributs. Remarque: dans ce cas il est également nécessaire de fournir en paramètre des coefficients pour calculer la taille des noeuds. Sachant que la taille est exprimée en pouce le coefficient doit être très inférieur à 1. Il est également possible de jouer sur les paramètres nodesep et ranksep pour obtenir un meilleur rendu.
• CR: 
• En se basant sur des classes du paquetages javax.swing donner une image d'écran significative et commenter très brièvement le diagramme obtenu.
• Pourquoi est il plus pertinent de n'afficher que les méthodes directement déclarées dans la classes plutôt que les méthodes héritées? 

(Q8) Parcours des fichiers correspondant à des classes

• L'inconvénient du programme ci-dessus est qu'il faut explicitement indiquer toutes les classes à partir desquelles le parcours doit débuter. Il n'y a hélas pas, dans la bibliothèque java concernant l'introspection, de méthodes pour obtenir toutes les classes d'un package. Il est donc nécessaire de créer cette fonction en se basant sur le fait que la représentation des paquetages à partir du système de fichiers est standardisé. C'est l'objectif de la classe fr.imag.classview.ListClassFiles. Compléter dans cette classe les méthodes allSelectedFiles et allClassFiles en s'inspirant de la classe ListFiles (ne pas hésiter à faire des copier-coller si nécessaire. Ce premier TP correspond à de la programmation exploratoire). Utiliser la notion de filtre (voir la documentation javadoc de java.io.FileFilter). Compléter ensuite la méthode allClassNames et la tester.
• En utilisant ce  programme pour explorer différents répertoires de votre choix, déterminer la convention de nommage permettant de représenter des classes anonymes ou internes  (à une classe donnée). On observera pour cela le nom des classes se trouvant dans les répertoires. Modifier le programme décrit ci-dessus pour éliminer ces classes sachant que celles-ci sont accessibles à partir des classes via introspection.
• CR: 
• A quoi correspond d'un point de vue mathématique la classe FileFilter? Plus généralement, quel mécanisme serait utilisé dans un langage fonctionnel (e.g. Lisp ou Caml)?
• Quelle sont les conventions de nommage pour les classes anonymes (celles qui n'ont pas de nom, par exemple celle utilisée comme filtre dans l'exemple)? pour les classes internes (celles qui sont nommées mais définies à l'intérieur d'une autre classe, comme par exemple java.util.Map.Entry)?
• Si l'on considère les exemples ci-dessus et l'utilisation par exemple de différentes classes internes dans javax.swing.JTree (cf javadoc), indiquer quelles sont les utilisations habituelles des classes anonymes, des classes internes et des classes normalles (dans quels cas choisir  telle ou telle solution).
• Quelles méthodes de java.lang.Class permet d'obtenir les classes internes? 

(Q9) Visualisation des relations d'héritages pour une liste de paquetage donné

• Créer une nouvelle classe fr.imag.classview.InheritancePackageGraph permettant d'afficher les relations d'héritages liant les classes et les interfaces contenues dans une liste de paquetages donnée en paramètre (On fera un copier-coller si nécessaire).
• Tester cette fonctionnalité en utilisant par exemple le paquetage java.lang.util (pour cela il faudra au préalable décompresser le contenu de ce paquetage puisque dans cette version seule les paquetages représentés sous forme de répertoire sont supportés. Cette contrainte est levée dans la question 10).
• Utiliser un attribut graphique permettant d'indiquer pour chaque classe ou interface si elle appartient aux paquetages donnés ou non (c.a.d. si elle  est externe aux paquetages de départ ou non).
• CR:
• Fournir une image d'écran pour java.lang.util. Commenter brièvement.

(Q10) Support pour les fichiers .zip et .jar (s'il vous reste du temps)

• Modifier le programme pour permettre de fournir en paramètre soit le nom d'un répertoire, soit le nom d'un fichier zip ou d'un fichier jar. Pour cela utiliser les paquetages java.util.zip  et java.util.jar.

(Q11) Paramétrage interactif (s'il vous reste du temps)

• Pour rendre le paramétrage du programme interactif, utiliser la classe java.swing.JFileChooser pour permettre à l'utilisateur de choisir le répertoire contenant les paquetages à analyser. Se référer à l'exemple fourni dans la page javadoc de java.swing.JFileChooser pour utiliser cette classe. Dans un premier temps la liste des paquetages restera fournie via la ligne de commande.
• Permettre de sélectionner graphiquement parmi la liste des paquetages à afficher en utilisant la classe JList (voir la documentation correspondante). Après avoir sélectionné le répertoire (ou l'archive) contenant les classes, la liste des paquetages possibles sera affiché dans la JList
• CR:
• Fournir des images d'écran

(Q12) Affichage des classes dans le classpath  (s'il vous reste du temps)

• Modifier le programme pour éliminer la sélection du répertoire ou de l'archive et permettre à l'utilisateur de sélectionner les paquetages à afficher parmi l'ensemble des paquetages accessibles dans le classpath. Utiliser la classe java.lang.System pour accéder  la propriété "java.class.path".
• CR:
• Fournir des images d'écran