I. INTRODUCTION▲
I-A. Objectif▲
L'objectif de cet article est de présenter l'outil UMLGraph.
UMLGraph est un programme Doclet pour Javadoc permettant de générer des diagrammes UML (diagrammes de classes ou de diagrammes de séquences) à partir du code Java et plus particulièrement des annotations ajoutées au code. L'article présentera uniquement la génération des diagrammes de classes.
UMLGraph s'appuie sur Graphviz pour la génération de diagrammes de classes. GraphViz permet de manipuler des graphes définis par le langage DOT et permet surtout de créer des fichiers d'images à partir de ces graphes. Ainsi, UMLGraph crée des fichiers .dot qui sont traités par GraphViz.
UMLGraph est utilisable de plusieurs manières : en ligne de commande ou depuis la tâche Ant ou le plugin Maven qui génèrent la Javadoc. Il existe également un plugin Maven (Dotuml) pour UMLGraph (http://maven-plugins.sourceforge.net/maven-dotuml-plugin/) et un plugin (Light UML) Eclipse (http://sourceforge.net/projects/lightuml/) ; mais les projets ne semblent plus actifs. La dernière release pour Dotuml date de 2007 pour Maven 1.1 et la dernière release pour Light UMl date de 2006.
UMLGraph a été principalement développé par Diomidis D. Spinellis.
I-B. Connaissances prérequises▲
Aucune connaissance particulière n'est nécessaire pour la compréhension de cet article.
Il faut juste quelques connaissances de base en Java, UML, Javadoc, Ant et Maven.
I-C. Versions des logiciels▲
Pour la réalisation de cet article les versions des outils sont :
- Java Development Kit : 6 Update 18 ;
- Eclipse : developpement Java 3.5 Galileo SR1 ;
- Ant : 1.7.1 ;
- Maven : 2.2.1 ;
- UMLGraph : 5.2 ;
- GraphViz : 2.26.3.
I-D. Autres ressources sur developpez.com▲
II. UTILISATION▲
II-A. Prérequis▲
Pour fonctionner correctement, UMLGraph nécessite Javadoc et GraphViz installés sur l'ordinateur.
Javadoc fait partie du JDK de Sun. La variable d'environnement "JAVA_HOME" doit contenir le dossier d'installation de la JDK.
Le dossier "bin" de l'installation de GraphViz (contenant "dot.exe") doit être ajouté au PATH.
Le dossier "bin" de l'installation de UMLGraph doit également être ajouté dans le PATH. Le fichier exécutable ("umlgraph", pour Unix ou "umlgraph.bat", pour Windows), qui est contenu dans le dossier "bin" de l'installation d'UMLGraph doit être mis à jour. Dans ce fichier, la variable "UMLGRAPH_HOME" doit être ajustée pour pointer sur le dossier "lib" de l'installation qui doit contenir le fichier "UmlGraph.jar".
L'historique des versions d'UMLGraph indique que :
- depuis la version 4.9 (28/09/2007), UMLGraph nécessite au minimum JDK 6 ;
- depuis la version 3.1 (26/03/2005), UMLGraph nécessite au minimum JDK 5 ;
- depuis la version 2.6 (03/08/2004), UMLGraph nécessite au minimum JDK 1.4.
Si la version du JDK est mauvaise, on obtient une erreur "java.lang.UnsupportedClassVersionError : Bad version number in .class file" à l'exécution. La solution est de télécharger les sources et de lancer le build ant afin d'obtenir un fichier .jar compatible avec la version de JDK.
II-B. Sources d'exemples▲
Voici un exemple assez simple de code Java (adaptation simplifiée du Design Pattern Décorateur) permettant d'obtenir un diagramme UML.
package
com.developpez.rpouiller.umlgraph;
/**
* Définit l'interface générale.
* @note Definit l'interface generale.
*/
public
interface
Abstraction {
/**
* Méthode générale.
*/
public
void
operation
(
);
}
package
com.developpez.rpouiller.umlgraph;
/**
* Implémente l'interface générale.
* @note Implemente l'interface generale.
*/
public
class
Implementation implements
Abstraction {
/**
* Implémentation de la méthode
* pour l'opération de base
*/
public
void
operation
(
) {
System.out.println
(
"Implementation"
);
}
}
package
com.developpez.rpouiller.umlgraph;
/**
* Implémente un décorateur.
* @note Definit l'interface du decorateur et
* contient une reference vers un objet Abstraction.
* @stereotype Decorator
* @composed - - - Abstraction
*/
public
class
Decorateur implements
Abstraction {
private
Abstraction abstraction;
/**
* Le constructeur du "Decorateur" reçoit un objet "Abstraction"
*
@param
pAbstraction
*/
public
Decorateur
(
final
Abstraction pAbstraction) {
abstraction =
pAbstraction;
}
/**
* Implémentation de la méthode pour la décoration.
* Des opérations sont effectuées avant et après l'appel
* à la méthode de l'objet "Abstraction" passé au constructeur.
* La méthode ignore si cet objet est un autre décorateur ou l'implémentation.
*/
public
void
operation
(
) {
System.out.println
(
"Decorateur avant"
);
abstraction.operation
(
);
System.out.println
(
"Decorateur apres"
);
}
}
II-C. Utilisation en ligne de commande▲
Dans le dossier contenant le projet Java, exécuter la commande suivante.
java -classpath "%UMLGRAPH_HOME%\UmlGraph.jar;%JAVA_HOME%\lib\Tools.jar"
org.umlgraph.doclet.UmlGraph -operations -visibility -package -output diagramme.dot src\com\developpez\rpouiller\umlgraph\*.java
On obtient un fichier "diagramme.dot".
Utiliser la commande suivante pour générer l'image du diagramme à partir du fichier ".dot".
dot -Tpng -odiagramme.png diagramme.dot
On obtient un fichier "diagramme.png".
II-D. Utilisation depuis un script Ant▲
Il faut utiliser la tâche Ant de Javadoc en précisant UMLGraph comme doclet.
<project
default
=
"javadocs"
>
<property
name
=
"src.dir"
location
=
"src"
/>
<property
name
=
"reports.dir"
location
=
"reports"
/>
<property
name
=
"umlgraph.dir"
location
=
"[emplacement du jar d'UMLGraph]"
/>
<target
name
=
"javadocs"
>
<mkdir
dir
=
"${reports.dir}/javadoc"
/>
<javadoc
sourcepath
=
"${src.dir}"
packagenames
=
"com.developpez.rpouiller.umlgraph.*"
destdir
=
"${reports.dir}/javadoc"
>
<doclet
name
=
"org.umlgraph.doclet.UmlGraphDoc"
path
=
"${umlgraph.dir}/UMLGraph.jar"
>
<param
name
=
"-operations"
/>
<param
name
=
"-visibility"
/>
<param
name
=
"-package"
/>
</doclet>
</javadoc>
</target>
</project>
L'exécution ant génère une javadoc, contenant les diagrammes uml, dans le dossier "reports/javadoc" du projet.
II-E. Utilisation par plugin Maven générant la Javadoc▲
Il faut utiliser le plugin Maven de Javadoc en précisant UMLGraph comme doclet.
La version 5.2 d'UMLGraph n'existe pas sur le repository central Maven. Mais, la version 5.1 comporte une anomalie provoquant une NullPointerException. Il faut donc rajouter manuellement la version 5.2 dans le repository local.
<project
xmlns
=
"http://maven.apache.org/POM/4.0.0"
xmlns
:
xsi
=
"http://www.w3.org/2001/XMLSchema-instance"
xsi
:
schemaLocation
=
"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
>
<modelVersion>
4.0.0</modelVersion>
<groupId>
com.developpez</groupId>
<artifactId>
rpouiller-umlgraph</artifactId>
<packaging>
jar</packaging>
<version>
1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>
org.apache.maven.plugins</groupId>
<artifactId>
maven-javadoc-plugin</artifactId>
<configuration>
<source>
1.6</source>
<doclet>
org.umlgraph.doclet.UmlGraphDoc</doclet>
<docletArtifact>
<groupId>
org.umlgraph</groupId>
<artifactId>
doclet</artifactId>
<version>
5.2</version>
</docletArtifact>
<additionalparam>
-operations -visibility
</additionalparam>
<useStandardDocletOptions>
true</useStandardDocletOptions>
</configuration>
</plugin>
</plugins>
</build>
</project>
Utiliser la commande suivante pour générer la Javadoc par Maven.
mvn javadoc:javadoc
L'exécution génère une javadoc, contenant les diagrammes uml, dans le dossier "target/site/apidocs" du projet.
III. OPTIONS▲
Lors du lancement d'UMLGraph, il est possible de préciser certaines options (directement dans la ligne de commande ou bien dans les tags javadoc).
Les options peuvent également être précisées directement dans les tags des classes ou grâce à des classes spéciales présentées plus loin.
Mis à part les options présentées ci-après, certaines options permettent de filtrer les éléments affichés en fonction de leurs visibilités. Il s'agit d'options Javadoc :
- -public : seulement les classes et membres publics sont affichés ;
- -protected (par défaut) : seulement les classes et membres publics/protégés sont affichés ;
- -package : seulement les classes et membres publics/protégés/package sont affichés ;
- -private : toutes les classes et membres sont affichés.
III-A. Options déterminant ce qui sera affiché▲
- -all : identique au cumul des options -attributes -operations -visibility -types -enumerations -enumconstants ;
- -attributes : les champs Java seront affichés ;
- -commentname : les éléments du diagramme sont nommés grâce aux commentaires Javadoc au lieu des noms de classes ;
- -constructors : les constructeurs des classes seront affichés ;
- -enumconstants : si les énumérations sont affichées, leurs valeurs seront affichées ;
- -enumerations : les énumérations seront affichées ;
- -hide : indique les éléments à ne pas afficher grâce à une expression régulière ;
- -operations : les méthodes Java seront affichées ;
- -qualify : les noms des éléments sont complètement qualifiés (avec les noms de package) ;
- -types : ajoute les informations de type aux attributs et aux opérations ;
- -view : crée le diagramme défini dans la classe passée en paramètre ;
- -views : recherche les classes définissant une vue et génère le diagramme correspondant ;
- -visibility : affiche les informations de visibilité (privé, public, protégé, package) aux attributs et aux opérations.
III-B. Options du rendu visuel du graphe▲
- -bgcolor : définit la couleur de fond du diagramme (voir la liste des couleurs) ;
- -collapsible : rajoute un lien dans les fichiers HTML de javadoc contenant des diagrammes UML permettant de masquer/afficher les diagrammes (masqués par défaut) ;
- -edgecolor : définit la couleur du trait des relations entre classes ;
- -edgefontcolor : définit la couleur du texte des relations entre classes ;
- -edgefontname : définit la police du texte des relations entre classes ;
- -edgefontsize : définit la taille du texte des relations entre classes ;
- -horizontal : organise le diagramme dans le sens horizontal ;
- -nodefillcolor : définit la couleur de fond du noeud (classe, note...) ;
- -nodefontabstractname : définit la police du texte des méthodes abstraites des classes ;
- -nodefontclassabstractname : définit la police du texte du nom des classes abstraites ;
- -nodefontclassname : définit la police du texte du nom des classes ;
- -nodefontclasssize : définit la taille du texte du nom des classes ;
- -nodefontcolor : définit la couleur de texte du noeud (classe, note...) ;
- -nodefontname : définit la police du texte des éléments des classes (champs, méthodes, stéréotypes...) ;
- -nodefontpackagename : définit la police du texte des packages ;
- -nodefontpackagesize : définit la taille du texte des packages ;
- -nodefontsize : définit la taille du texte des éléments des classes (champs, méthodes, stéréotypes...) ;
- -nodefonttagname : définit la police du texte des étiquettes ;
- -nodefonttagsize : définit la taille du texte des étiquettes ;
- -nodesep : définit la séparation horizontale entre les éléments (0.25 par défaut). Remarque : les notions de nodesep et ranksep sont inversées lorsque l'on précise l'option horizontal ;
- -noguillemot : remplace les guillemets avant et après le mot "interface" et les noms de stéréotypes par des "<<" et des ">>" ;
- -postfixpackage : place le nom de package sur une ligne à part lorsque l'on précise l'option qualify ;
- -ranksep : définit la séparation verticale entre les éléments (0.5 par défaut) ;
- -shape : définit la forme pour le rendu des éléments. Les valeurs possibles sont class (par défaut), node, component, package, collaboration, usecase et activeclass).
III-C. Options de détermination de relations▲
- -collpackages : définit les classes considérées, si la déduction est activée, comme équivalent à des relations un-plusieurs ;
- -inferdep : indique d'examiner les champs et les méthodes afin de déduire les dépendances (par défaut inactif) ;
- -inferdepinpackage : indique d'examiner pour les classes du même package également (par défaut inactif) ;
- -inferdepvis : définit le niveau de visibilité (private, package, protected ou public ; par défaut private) le plus fin utilisé pour déduire les dépendances entre classes ;
- -inferrel : indique d'examiner les champs afin de déduire les relations (par défaut inactif) ;
- -inferreltype : indique le type de relations qui sera déduit si la déduction de relations est active (par défaut navassoc) ;
- -useimports : indique d'utiliser également les imports pour la déduction de dépendances (par défaut inactif).
III-D. Options de liens d'API▲
- -apidocmap : définit le nom d'un fichier de correspondance entre des classes externes et des URL de javadoc ;
- -apidocroot : définit l'URL de la javadoc pour les classes locales ;
- -link : définit des liens vers des javadocs pour des classes externes.
III-E. Options d'opérations▲
- -compact : génère des fichiers dot plus compacts (sur une seule ligne de texte) ;
- -d : définit le dossier de sortie (par défaut le dossier courant) ;
- -output : définit le fichier de sortie (par défaut graph.dot). Si le nom de fichier défini est un tiret (-), la sortie est la console (ce qui permet de rediriger le résultat dans dot par un pipe (|) ;
- -outputencoding : définit l'encodage de sortie (ISO-8859-1 par défaut) ;
- -verbose2 : indique d'afficher des détails de la progression de génération (différent de l'option -verbose de javadoc).
IV. ANNOTATIONS▲
UMLGraph utilise différentes annotations :
- @opt : permet de passer une option directement à une classe (voir le chapitre sur les options juste au-dessus) ;
- @stereotype nomStereotype : permet de déclarer un stéréotype ;
- @tagvalue nomEtiquette valeurEtiquette : permet de déclarer une étiquette et sa valeur ;
- @extends nomClasse : permet de déclarer un héritage ;
- @assoc informationsSource nomRelation informationsCible nomClasse : permet de déclarer une association ;
- @navassoc informationsSource nomRelation informationsCible nomClasse : permet de déclarer une association avec un sens ;
- @has informationsSource nomRelation informationsCible nomClasse : permet de déclarer une agrégation ;
- @composed informationsSource nomRelation informationsCible nomClasse : permet de déclarer une composition ;
- @depend informationsSource nomRelation informationsCible nomClasse : permet de déclarer une dépendance ;
- @note contenuNote : permet de rajouter une note à un élément du diagramme ;
- @hidden : cache l'élément ;
- @view : permet de déclarer une vue ;
- @match (s'utilise avec @view) : permet de déclarer les classes composant la vue.
V. CLASSES SPECIALES▲
V-A. Classes d'options▲
Il est possible de définir les options directement dans le code des classes. Les options peuvent être définies globalement grâce à une classe spéciale "UMLOptions", globalement pour les notes grâce à une classe spéciale "UMLNoteOptions" ou encore directement au niveau de chaque classe. La documentation pour ces fonctionnalités est disponible ici.
/**
* @hidden
* @opt constructors
* @opt types
*/
class
UMLOptions {}
/**
* @hidden
* @opt nodefillcolor orange
*/
class
UMLNoteOptions {}
/**
* @opt !bgcolor
*/
class
UneClasse {}
Il est possible de réinitialiser une option à la valeur par défaut en la précédant du point d'exclamation.
V-B. Classes de vues▲
Afin de définir des diagrammes particuliers, il est possible de déclarer des vues. La documentation pour ces fonctionnalités est disponible ici.
Une vue est déclarée grâce à l'annotation @view. Il est possible de déclarer des options au niveau de la vue.
Les classes composant la vue sont déclarées grâce à l'annotation @match. Les options déclarées au niveau de la vue sont héritées au niveau des correspondances. Il est également possible de déclarer des options au niveau des correspondances. Le premier paramètre de la correspondance est le type de celle-ci. Il devrait y avoir plusieurs types de correspondance implémentés dans UMLGraph, mais pour le moment seul le type class existe. Le deuxième paramètre est une expression régulière permettant de déterminer les classes correspondantes.
/**
* @view
* @opt all
* @opt bgcolor blue
*
* @match class com.developpez.rpouiller.umlgraph.(Classe1|Classe3)
* @opt nodefillcolor orange
* @opt nodefontcolor red
*
* @match class com.developpez.rpouiller.umlgraph.Classe2
* @opt nodefillcolor yellow
* @opt nodefontcolor green
*/
class
Vue {}
extends
VueAbstraite
Il est possible de définir des vues abstraites dont les propriétés seront héritées au niveau des vues concrètes. Seules les vues concrètes donnent lieu à des générations de diagrammes.
VI. EXEMPLES▲
VI-A. Exemples de formes▲
Voici un exemple de sources utilisant les différentes options de formes. Un autre exemple est visible ici.
package
com.developpez.rpouiller.umlgraph.formes;
/**
* @opt shape package
*/
public
interface
Package {}
package
com.developpez.rpouiller.umlgraph.formes;
/**
* @opt shape component
*/
public
class
Component implements
Package {}
package
com.developpez.rpouiller.umlgraph.formes;
/**
* @opt shape collaboration
*/
public
class
Collaboration extends
Component {}
package
com.developpez.rpouiller.umlgraph.formes;
/**
* @opt shape usecase
*/
public
class
Usecase extends
Component {}
package
com.developpez.rpouiller.umlgraph.formes;
/**
* @opt shape node
*/
public
class
Node implements
Package {}
package
com.developpez.rpouiller.umlgraph.formes;
/**
* Classe active
* @opt commentname
* @opt shape activeclass
*/
public
class
Activeclass extends
Node {}
package
com.developpez.rpouiller.umlgraph.formes;
/**
* @opt shape class
* @opt all
*/
public
class
Class extends
Node {
private
int
attributPrive;
protected
int
attributProtege;
int
attributDefaut;
public
int
attributPublic;
private
void
methodePrivee
(
) {}
;
protected
void
methodeProtegee
(
) {}
;
void
methodeDefaut
(
) {}
;
public
void
methodePublique
(
) {}
;
}
La commande ci-dessous permet de générer le diagramme ci-après.
java -classpath "%UMLGRAPH_HOME%\UmlGraph.jar;%JAVA_HOME%\lib\Tools.jar"
org.umlgraph.doclet.UmlGraph -private src\com\developpez\rpouiller\umlgraph\formes\*.java &&
dot -Tpng -ograph.png graph.dot
VI-B. Exemples de couleurs▲
Voici un exemple de sources utilisant les différentes options de couleurs. Un autre exemple est visible ici.
package
com.developpez.rpouiller.umlgraph.couleurs;
/**
* @hidden
* @opt horizontal
* @opt ranksep 0.2
* @opt bgcolor antiquewhite2
* @opt nodefillcolor darkgoldenrod
* @opt edgecolor red
* @opt edgefontcolor forestgreen
*/
class
UMLOptions {}
package
com.developpez.rpouiller.umlgraph.couleurs;
/**
* @hidden
* @opt nodefillcolor crimson
* @opt nodefontcolor blue
*/
class
UMLNoteOptions {}
package
com.developpez.rpouiller.umlgraph.couleurs;
/**
* @note Une note
* @opt nodefillcolor gold
* @opt nodefontcolor green
*
* @assoc 1\ninfo "nom\nRelation" 2 Classe2
*/
public
class
Classe1 {}
package
com.developpez.rpouiller.umlgraph.couleurs;
/**
* @opt constructors
* @opt visibility
*/
public
class
Classe2 {}
La commande ci-dessous permet de générer le diagramme ci-après.
java -classpath "%UMLGRAPH_HOME%\UmlGraph.jar;%JAVA_HOME%\lib\Tools.jar"
org.umlgraph.doclet.UmlGraph -private src\com\developpez\rpouiller\umlgraph\couleurs\*.java &&
dot -Tpng -ograph.png graph.dot
VI-C. Exemples de polices de caractères▲
Voici un exemple de sources utilisant les différentes options de polices de caractères. Un autre exemple est visible ici.
package
com.developpez.rpouiller.umlgraph.caracteres;
/**
* @hidden
* @opt attributes
* @opt operations
* @opt qualify
* @opt types
* @opt enumconstants
* @opt enumerations
* @opt postfixpackage
* @opt nodesep 0.1
*
* @opt nodefontclassname "Arial Bold"
* @opt nodefontclassabstractname "Arial Italic"
* @opt nodefontclasssize 16
*
* @opt nodefontname "Times New Roman Bold"
* @opt nodefontabstractname "Times New Roman Italic"
* @opt nodefontsize 10
*
* @opt nodefonttagname "Courier New Italic"
* @opt nodefonttagsize 10
*
* @opt nodefontpackagename "Comic Sans MS"
* @opt nodefontpackagesize 10
*
* @opt edgefontname "Courier New Bold"
* @opt edgefontsize 12
*/
public
class
UMLOptions {}
package
com.developpez.rpouiller.umlgraph.caracteres;
/**
* @stereotype abstraction
*/
public
abstract
class
ClasseAbstraite {
/**
* @stereotype Champs
*/
private
int
unChamps;
/**
* @stereotype Methode
*/
protected
abstract
long
uneMethode
(
);
}
package
com.developpez.rpouiller.umlgraph.caracteres;
/**
* @stereotype Implementation
* @opt noguillemot
* @tagvalue version 2.0
* @assoc - relation - ClasseAssociee
*/
public
class
ClasseConcrete extends
ClasseAbstraite {
/**
* @tagvalue depuis 1.0
*/
public
char
caractere;
/**
* @stereotype resultat
* @tagvalue retour 0
*/
protected
long
uneMethode
(
) {
return
0
;
}
}
package
com.developpez.rpouiller.umlgraph.caracteres;
/**
* @stereotype cache
* @opt !qualify
*/
public
class
ClasseConcrete2 extends
ClasseAbstraite {
protected
long
uneMethode
(
) {
return
1
;
}
}
package
com.developpez.rpouiller.umlgraph.caracteres;
/**
* @opt !qualify
*/
public
class
ClasseAssociee {}
La commande ci-dessous permet de générer le diagramme ci-après.
java -classpath "%UMLGRAPH_HOME%\UmlGraph.jar;%JAVA_HOME%\lib\Tools.jar"
org.umlgraph.doclet.UmlGraph -private src\com\developpez\rpouiller\umlgraph\caracteres\*.java &&
dot -Tpng -ograph.png graph.dot
VI-D. Exemples de relations▲
Voici un exemple de sources utilisant les différentes options et annotations de relations. D'autres exemples sont visibles ici, ici, ici et ici.
package
com.developpez.rpouiller.umlgraph.relations;
import
com.developpez.rpouiller.umlgraph.relations.souspack.Interface2;
public
interface
Interface extends
Interface2 {}
package
com.developpez.rpouiller.umlgraph.relations.souspack;
public
interface
Interface2 {}
package
com.developpez.rpouiller.umlgraph.relations;
public
class
Element {}
package
com.developpez.rpouiller.umlgraph.relations.souspack;
public
class
Element2 {}
package
com.developpez.rpouiller.umlgraph.relations;
public
class
Dependance {}
package
com.developpez.rpouiller.umlgraph.relations.souspack;
public
class
Dependance2 {}
package
com.developpez.rpouiller.umlgraph.relations;
public
class
Classe2 {}
package
com.developpez.rpouiller.umlgraph.relations;
public
class
Classe3 {}
package
com.developpez.rpouiller.umlgraph.relations;
/**
* @opt inferrel
* @opt collpackages java.util.*
* @opt inferdep
* @opt inferdepinpackage
* @opt useimports
* @opt hide java.*
* @opt postfixpackage
* @opt all
* @opt !constructors
* @opt nodefontpackagesize 8
* @hidden
*/
public
class
UMLOptions {
// Explication des annotations :
// @opt inferrel et collpackages : permet le lien entre ClasseAbstraite et Element
// @opt inferdep et inferdepinpackage : permet les liens entre ClasseAbstraite-Classe et Dependance
// @opt useimports : permet le lien entre Interface et Interface2
}
package
com.developpez.rpouiller.umlgraph.relations;
import
java.util.List;
/**
* @opt inferreltype composed
* @has 1 possede * com.developpez.rpouiller.umlgraph.relations.souspack.Element2
* @navassoc - gere - Interface
*/
public
abstract
class
ClasseAbstraite {
// Explication des annotations :
// @opt inferreltype : indique que le lien entre ClasseAbstraite et Element sera une composition
// @has : permet le lien entre ClasseAbstraite et Element2
// @navassoc : permet le lien entre ClasseAbstraite et Interface
protected
List<
Element>
listeElements;
public
abstract
Dependance getDependance
(
);
}
package
com.developpez.rpouiller.umlgraph.relations;
/**
* @depend - utilise - com.developpez.rpouiller.umlgraph.relations.souspack.Dependance2
* @composed - comporte 4 Classe2
* @assoc * associe * Classe3
*/
public
class
Classe extends
ClasseAbstraite implements
Interface {
// Explication des annotations :
// @depend : permet le lien entre Classe et Dependance2
// @composed : permet le lien entre Classe et Classe2
// @assoc : permet le lien entre Classe et Classe3
public
Dependance getDependance
(
) {
return
null
;
}
}
La commande ci-dessous permet de générer le diagramme ci-après.
java -classpath "%UMLGRAPH_HOME%\UmlGraph.jar;%JAVA_HOME%\lib\Tools.jar"
org.umlgraph.doclet.UmlGraph -private src\com\developpez\rpouiller\umlgraph\relations\*.java &&
dot -Tpng -ograph.png graph.dot
Lors de la rédaction de l'article, j'ai rencontré un problème pour générer les relations composed et has. Le code .dot n'était pas correct. J'ai modifié la classe ClassGraph d'UMLGraph comme ceci :
class
ClassGraph {
...
static
{
associationMap.put
(
RelationType.ASSOC, "arrowhead=none"
);
associationMap.put
(
RelationType.NAVASSOC, "arrowhead=open"
);
associationMap.put
(
RelationType.HAS, "arrowhead=none, arrowtail=ediamond, dir=back"
);
associationMap.put
(
RelationType.COMPOSED, "arrowhead=none, arrowtail=diamond, dir=back"
);
associationMap.put
(
RelationType.DEPEND, "arrowhead=open, style=dashed"
);
}
...
J'ai ajouté deux fois ", dir=back" et généré un nouveau fichier .jar d'UMLGraph grâce au script ant build.xml.
VI-E. Exemples de vues▲
Voici un exemple de sources utilisant les différentes options et annotations de vues. D'autres exemples sont visibles ici, ici et ici.
package
com.developpez.rpouiller.umlgraph.vues;
public
class
Classe1 {
private
int
champs;
}
package
com.developpez.rpouiller.umlgraph.vues;
/**
* @depend - - - Classe3
*/
public
class
Classe2 {
protected
Classe3 methode
(
) {
return
null
;
}
;
}
package
com.developpez.rpouiller.umlgraph.vues;
public
class
Classe3 extends
Classe1 {
public
Valeur valeur;
}
package
com.developpez.rpouiller.umlgraph.vues;
public
enum
Valeur {
VALEUR_1, VALEUR_2, VALEUR_3
}
package
com.developpez.rpouiller.umlgraph.vues;
/**
* @view
* @opt types
* @opt visibility
*/
public
abstract
class
AbstractVue {}
package
com.developpez.rpouiller.umlgraph.vues;
/**
* @view
* @opt attributes
* @opt hide
*
* @match class com.developpez.rpouiller.umlgraph.vues.(Classe1|Classe3)
* @opt !hide
*/
public
class
Vue1 extends
AbstractVue {}
package
com.developpez.rpouiller.umlgraph.vues;
/**
* @view
* @opt operations
*
* @match class com.developpez.rpouiller.umlgraph.vues.Classe1
* @opt hide
*/
public
class
Vue2 extends
AbstractVue {}
package
com.developpez.rpouiller.umlgraph.vues;
/**
* @view
* @opt enumerations
* @opt enumconstants
*
* @match class com.developpez.rpouiller.umlgraph.vues.(Classe1|Classe2|Classe3)
* @opt nodefillcolor LightGray
*
* @match class com.developpez.rpouiller.umlgraph.vues.Valeur
* @opt nodefillcolor antiquewhite2
*/
public
class
Vue3 {}
La commande ci-dessous permet de générer les diagrammes ci-après.
java -classpath "%UMLGRAPH_HOME%\UmlGraph.jar;%JAVA_HOME%\lib\Tools.jar"
org.umlgraph.doclet.UmlGraph -views -private src\com\developpez\rpouiller\umlgraph\vues\*.java
&&
dot -Tpng -oVue1.png Vue1.dot &&
dot -Tpng -oVue2.png Vue2.dot &&
dot -Tpng -oVue3.png Vue3.dot
Résultat de la Vue1 :
Résultat de la Vue2 :
Résultat de la Vue3 :
VI-F. Exemples de liens▲
Voici un exemple de sources utilisant les différentes options et annotations de liens.
LazyList http://commons.apache.org/collections/api-release/org/apache/commons/collections/list
StringUtils http://commons.apache.org/lang/api-release/org/apache/commons/lang
package
com.developpez.rpouiller.umlgraph.liens;
/**
* @view
* @opt all
* @opt qualify
* @opt inferrel
* @opt inferdep
* @opt apidocmap liens.txt
* @opt apidocroot http://rpouiller.developpez.com/tutoriels/java/generation-diagrammes-uml-avec-umlgraph
* @opt link http://java.sun.com/j2se/1.5.0/docs/api
*/
public
class
Vue {}
package
com.developpez.rpouiller.umlgraph.liens;
import
java.util.List;
import
org.apache.commons.collections.Factory;
import
org.apache.commons.collections.list.LazyList;
import
org.apache.commons.lang.StringUtils;
/**
* @depend - - - java.math.BigDecimal
* @has - - - StringUtils
*/
public
class
Classe extends
LazyList {
StringUtils util;
protected
Classe
(
List list, Factory factory) {
super
(
list, factory);
}
}
La commande ci-dessous permet de générer ce diagramme SVG.
java -classpath "%UMLGRAPH_HOME%\UmlGraph.jar;%JAVA_HOME%\lib\Tools.jar"
org.umlgraph.doclet.UmlGraph -view com.developpez.rpouiller.umlgraph.liens.Vue
-private src\com\developpez\rpouiller\umlgraph\liens\*.java &&
dot -Tsvg -oVue.svg Vue.dot
VII. REMERCIEMENTS▲
Je remercie sincèrement par ordre plus ou moins chronologique :
- www.developpez.com me permettant de publier cet article ;
- Nono40 pour ses outils ;
- Baptiste Wicht pour sa relecture technique ;
- jacques_jean pour sa relecture orthographique.