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 :

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.

Abstraction.java
CacherSélectionnez
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();
}
Implementation.java
CacherSélectionnez
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");
    }
}
Decorateur.java
CacherSélectionnez
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.

Commande de génération du fichier .dot
CacherSélectionnez
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".

Commande de génération du fichier .png
CacherSélectionnez
dot -Tpng -odiagramme.png diagramme.dot

On obtient un fichier "diagramme.png".

Image non disponible

II-D. Utilisation depuis un script Ant

Il faut utiliser la tâche Ant de Javadoc en précisant UMLGraph comme doclet.

build.xml
CacherSélectionnez
<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.

Image non disponible

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.

pom.xml
CacherSélectionnez
<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.

Commande de génération de la Javadoc par Maven
CacherSélectionnez
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

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

 
Sélectionnez
/**
 * @hidden
 * @opt constructors
 * @opt types
 */
class UMLOptions {}
 
Sélectionnez
/**
 * @hidden
 * @opt nodefillcolor orange
 */
class UMLNoteOptions {}
 
Sélectionnez
/**
 * @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.

 
Sélectionnez
/**
 * @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.

 
Sélectionnez
package com.developpez.rpouiller.umlgraph.formes;

/**
 * @opt shape package
 */
public interface Package {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.formes;

/**
 * @opt shape component
 */
public class Component implements Package {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.formes;

/**
 * @opt shape collaboration
 */
public class Collaboration extends Component {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.formes;

/**
 * @opt shape usecase
 */
public class Usecase extends Component {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.formes;

/**
 * @opt shape node
 */
public class Node implements Package {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.formes;

/**
 * Classe active
 * @opt commentname
 * @opt shape activeclass
 */
public class Activeclass extends Node {}
 
Sélectionnez
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.

Commande de génération du diagramme
Sélectionnez
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
Image non disponible

VI-B. Exemples de couleurs

Voici un exemple de sources utilisant les différentes options de couleurs. Un autre exemple est visible ici.

 
Sélectionnez
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 {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.couleurs;

/**
 * @hidden
 * @opt nodefillcolor crimson
 * @opt nodefontcolor blue
 */
class UMLNoteOptions {}
 
Sélectionnez
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 {}
 
Sélectionnez
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.

Commande de génération du diagramme
Sélectionnez
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
Image non disponible

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.

 
Sélectionnez
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 {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.caracteres;

/**
 * @stereotype abstraction
 */
public abstract class ClasseAbstraite {
	/**
	 * @stereotype Champs
	 */
	private int unChamps;
	
	/**
	 * @stereotype Methode
	 */
	protected abstract long uneMethode();
}
 
Sélectionnez
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;
	}
}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.caracteres;

/**
 * @stereotype cache
 * @opt !qualify
 */
public class ClasseConcrete2 extends ClasseAbstraite {

	protected long uneMethode() {
		return 1;
	}
}
 
Sélectionnez
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.

Commande de génération du diagramme
Sélectionnez
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
Image non disponible

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.

 
Sélectionnez
package com.developpez.rpouiller.umlgraph.relations;

import com.developpez.rpouiller.umlgraph.relations.souspack.Interface2;

public interface Interface extends Interface2 {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.relations.souspack;

public interface Interface2 {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.relations;

public class Element {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.relations.souspack;

public class Element2 {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.relations;

public class Dependance {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.relations.souspack;

public class Dependance2 {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.relations;

public class Classe2 {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.relations;

public class Classe3 {}
 
Sélectionnez
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

}
 
Sélectionnez
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();
}
 
Sélectionnez
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.

Commande de génération du diagramme
Sélectionnez
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
Image non disponible

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 :

 
Sélectionnez
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.

 
Sélectionnez
package com.developpez.rpouiller.umlgraph.vues;

public class Classe1 {
	private int champs;
}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.vues;

/**
 * @depend - - - Classe3
 */
public class Classe2 {
	protected Classe3 methode() {
		return null;
	};
}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.vues;

public class Classe3 extends Classe1 {
	public Valeur valeur;
}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.vues;

public enum Valeur {
	VALEUR_1, VALEUR_2, VALEUR_3
}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.vues;

/**
 * @view
 * @opt types
 * @opt visibility
 */
public abstract class AbstractVue {}
 
Sélectionnez
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 {}
 
Sélectionnez
package com.developpez.rpouiller.umlgraph.vues;

/**
 * @view
 * @opt operations
 * 
 * @match class com.developpez.rpouiller.umlgraph.vues.Classe1
 * @opt hide
 */
public class Vue2 extends AbstractVue {}
 
Sélectionnez
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.

Commande de génération des diagrammes
Sélectionnez
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 :

Image non disponible

Résultat de la Vue2 :

Image non disponible

Résultat de la Vue3 :

Image non disponible

VI-F. Exemples de liens

Voici un exemple de sources utilisant les différentes options et annotations de liens.

liens.txt
Sélectionnez
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
 
Sélectionnez
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 {}
 
Sélectionnez
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.

Commande de génération du diagramme
Sélectionnez
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 :