Diagrammes UML : de la théorie à la pratique

Introduction - Diagramme de classe UML

Je pense que tout le monde a déjà entendu le dicton « Mieux vaut prévenir que guérir ». Ce conseil s'applique aussi en programmation. Il est toujours préférable de songer à l'implémentation avant de passer du temps à la réaliser. Lors de l'implémentation, tu as souvent besoin de créer des classes et de réfléchir à la façon dont elles vont interagir. Une représentation visuelle de tout cela peut souvent t'aider à trouver la solution la plus juste. C'est là qu'UML vole à notre secours.

Qu'est-ce qu'UML ?

Les images des résultats des moteurs de recherche te diront qu'un diagramme de classe UML comporte des flèches et des carrés. L'abréviation « diagramme UML » signifie Diagramme en Langage de Modélisation Unifié. Unifié est le mot important ici. Cela signifie que nos images seront comprises non seulement par nous, mais aussi par toute autre personne qui connaît le langage UML. C'est la langue véhiculaire pour dessiner des diagrammes. D'après Wikipédia,La chose la plus intéressante, que tout le monde ne devinerait pas au premier abord, est qu'UML a des spécifications. Et il existe même une spécification UML 2. Tu trouveras plus d'informations sur la spécification sur le site Web de l'Object Management Group. En fait, ce groupe développe les spécifications d'UML. Il est également intéressant de noter qu'un diagramme ou schéma UML ne se limite pas à décrire la structure des classes. Un diagramme UML de classe peut prendre diverses formes. Wikipédia offre une brève description pour chaque type de diagramme de classe UML : Diagrammes UML. Pour en revenir aux diagrammes de classe UML, il convient de mentionner que le livre « Design Patterns - Tête la première » utilise des diagrammes UML pour illustrer les modèles de conception. Ce qu'on veut dire, c'est qu'UML est réellement utilisé. Et il s'avère très utile de connaître ce langage et de comprendre son utilisation.

Application - Diagramme UML

Découvrons comment travailler avec les diagrammes de classe UML dans un EDI. Nous allons utiliser IntelliJ IDEA. Si tu utilises IntelliJ IDEA Ultimate, tu auras le plug-in « UML Support » installé d'office. Il te permet de générer automatiquement de beaux diagrammes de classes. Par exemple, utilise Ctrl+N ou l'élément de menu « Navigate » > « Class » pour accéder à la classe ArrayList. Maintenant, dans le menu contextuel du nom de classe, sélectionne « Diagram » -> « Show diagram popup ». Et tu te retrouves avec un beau diagramme. Et si tu veux dessiner le diagramme toi-même ? Ou que tu n'as pas la version Ultimate ? Avec IntelliJ IDEA Community Edition, nous n'avons pas d'autre choix. Nous devons donc comprendre comment un diagramme UML est organisé. Il nous faut d'abord installer Graphviz. C'est un ensemble d'outils de visualisation graphique. Le plug-in que nous allons utiliser repose dessus. Après installation, tu dois ajouter le répertoire bin du répertoire d'installation de Graphviz à la variable d'environnement PATH. Après cela, dans IntelliJ IDEA, sélectionne File > Settings dans le menu. Dans la fenêtre « Settings », sélectionne la catégorie « Plugins », clique sur le bouton « Browse repositories » et installe le plug-in PlantUML integration. Qu'est-ce qui rend PlantUML si bon ? Il décrit UML à l'aide d'un langage de description graphique appelé « dot », ce qui le rend plus universel, car le langage dot est utilisé au-delà de PlantUML. Qui plus est, tout ce que nous faisons ci-dessous peut être réalisé non seulement dans un EDI, mais aussi en ligne sur planttext.com. Après l'installation du plugin PlantUML, nous serons en mesure de créer des diagrammes UML en utilisant « File » -> « New ». Créons un diagramme de « classes UML ». Cela générera automatiquement un modèle avec un exemple. Nous allons supprimer son contenu et ajouter le nôtre. Pour comprendre comment représenter cela en texte, tu peux jeter un œil au manuel de PlantUML : diagramme de classes plantuml. En nous appuyant sur ces matériaux, commençons à créer notre diagramme UML. Ajoute le contenu suivant, qui décrit deux classes :

@startuml
class ArrayList {
}
class LinkedList {
}
@enduml

Pour voir le résultat dans IDEA, sélectionne « View » -> « Tool Windows » -> « PlantUML ». Nous n'avons que deux carrés qui représentent les classes. Nous savons que ces deux classes implémentent l'interface List. Cette relation de classe s'appelle réalisation. Cette relation est représentée à l'aide d'une flèche avec une ligne pointillée. Dessinons-la :

interface List
List <|.. ArrayList
List <|.. LinkedList

List est un des enfants de la classe Collection. C'est-à-dire qu'elle hérite de Collection. Cette relation s'appelle généralisation. Elle ressemble à une flèche avec une ligne continue ordinaire. Dessinons-la :

interface Collection
Collection <|-- List

Pour le type de relation suivant, ajoute à la description de la classe ArrayList une entrée sur un tableau d'éléments package private :

~Object[] elementData

Maintenant, nous voulons montrer qu'ArrayList contient des objets. Dans ce cas, il y aura une relation d'agrégation. ArrayList est un agrégat, car il contient d'autres objets. Nous disons agrégation, car les objets de la liste peuvent exister sans la liste : ils ne font pas partie intégrante de la liste. Leur durée de vie n'est pas liée à celle de la liste. Le mot « agrégat » nous vient du latin et se traduit par « assemblage », c'est-à-dire quelque chose fait de quelque chose. Par exemple, dans la vie, nous avons un assemblage de pompe (agrégat), qui se compose d'une pompe et d'un moteur. L'assemblage lui-même peut être démonté, et nous pouvons utiliser certains de ses composants séparément. Par exemple, pour les vendre ou les utiliser dans un autre assemblage. C'est la même chose dans une liste. Elle est exprimée avec un losange vide au niveau de l'agrégat et une ligne continue. Nous allons représenter cela comme suit :

class Object{
}
ArrayList o- Object

Maintenant, nous voulons montrer que contrairement à ArrayList, la classe LinkedList contient des nœuds, des conteneurs qui font référence aux données stockées. Dans ce cas, les nœuds font partie de LinkedList et n'ont pas d'existence indépendante. Un nœud n'est pas le contenu lui-même. Il ne contient qu'une référence au contenu. Par exemple, lorsque nous ajoutons une chaîne à une LinkedList, nous ajoutons un nouveau nœud qui contient une référence à la chaîne, ainsi qu'un lien vers les nœuds précédent et suivant. Cette relation s'appelle composition. Elle est représentée en dessinant une ligne continue avec un losange rempli sur le composite (quelque chose fait de parties constitutives). Maintenant, nous allons représenter la relation sous forme de texte :

class Node{
}
LinkedList *-- Node

Et maintenant, tu dois apprendre à dépeindre un autre type important de relation : la dépendance. Elle est utilisée lorsqu'une classe en utilise une autre, mais que la classe ne contient ni n'hérite de la classe utilisée. Par exemple, LinkedList et ArrayList savent comment créer un ListIterator. Nous représentons cela sous forme de flèches avec une ligne pointillée :

class ListIterator
ListIterator <... ArrayList : create
ListIterator <... LinkedList : create

Après avoir fait tout cela, nous obtenons : Tu peux ajouter autant de détails que nécessaire. Bien sûr, il n'y a rien de surhumain à dessiner un tel diagramme. Lorsque tu travailles sur tes propres tâches, tu peux rapidement les dessiner à la main. Cela t'aidera à développer ta capacité à réfléchir à l'architecture d'une application et à identifier les lacunes dans la structure de classes dès le début, et pas une fois que tu auras passé la journée à implémenter le mauvais modèle. Ça te fait une bonne raison d'essayer, tu ne crois pas ? :)

Automatisation

Il existe différentes façons de générer automatiquement un schéma UML avec PlantUML. Par exemple, IDEA dispose du plugin SketchIT, mais il ne dessine pas les diagrammes tout à fait correctement. Disons que l'implémentation des interfaces est mal dessinée (elle est représentée sous forme d'héritage). Sur Internet, tu trouveras des exemples sur la façon d'intégrer cela dans le processus de construction de ton projet. Par exemple, tu peux découvrir comment utiliser uml-java-docklet avec Maven. Pour te montrer cela, nous allons utiliser Maven Archetype pour créer rapidement un projet Maven. Exécution

mvn archetype:generate

En réponse à Choose a number or apply filter, laisse la valeur par défaut, et appuie simplement sur Entrée. Ce sera toujours « maven-archetype-quickstart ». Sélectionne la dernière version. Ensuite, nous répondons à quelques questions et terminons la création du projet : Maven n'est pas le sujet de cet article, mais tu pourras trouver des réponses à tes questions sur Maven sur le Centre des utilisateurs Maven. Dans le projet généré, ouvre le fichier de description de projet, pom.xml, pour le modifier. Nous allons copier le contenu de la description uml-java-docklet installing dans ce fichier. L'artefact utilisé dans la description ne se trouve pas dans le référentiel Maven Central. Mais ce qui suit a fonctionné pour moi : https://mvnrepository.com/artifact/com.chfourie/uml-java-doclet/1.0.0. En d'autres termes, dans la description, il te suffit de remplacer le groupId « info.leadinglight » par « com.chfourie » et de définir la version sur « 1.0.0 ». Après cela, nous pouvons exécuter les commandes suivantes dans le répertoire avec le fichier pom.xml :

mvn clean install

et

mvn javadoc: javadoc

Si nous ouvrons maintenant la documentation générée (explorer target\site\apidocs\index.html), nous verrons les diagrammes UML. Soit dit en passant, la relation d'implémentation s'affiche maintenant correctement :)

Conclusion

Comme tu peux le voir, UML te permet de visualiser la structure de ton application. Mais UML peut faire beaucoup plus que cela. Tu peux utiliser UML pour décrire divers processus au sein de ton entreprise ou le fonctionnement du processus d'affaires qui englobe une fonction que tu écris. Tu devras découvrir toi-même comment UML pourra t'aider personnellement, mais peu importe ce que tu choisis, il sera toujours utile de trouver le temps d'en apprendre plus à son sujet.