Introduction

Les diagrammes de classes PlantUML décrivent la structure statique d’un système : ses classes, attributs, opérations et relations. Vous écrivez une spécification textuelle que vous rendez sous forme de diagramme, ce qui rend la source facile à modifier et à suivre sous contrôle de version.
1. Un diagramme minimal
Un diagramme de classe commence par@startuml et se termine par@enduml:

@startuml
class User
class Order
User --> Order : places
@enduml
PlantUML peut inférer les classes à partir des déclarations de relations, mais leur déclaration explicite rend les diagrammes plus grands plus faciles à parcourir et à maintenir.
2. Classes, attributs et méthodes
Placez les attributs et les opérations entre accolades. Un deux-points sépare un nom de membre de son type ; des parenthèses marquent une opération.

@startuml
class User {
-id: int
-email: String
+login(password: String): boolean
+logout(): void
}
@enduml
Les marqueurs de visibilité sont :
-
+public -
-private -
#protected -
~package-private
Vous pouvez également écrire le type avant le nom du membre — par exemple, +String email ou +void logout(). PlantUML prend en charge à la fois la notation de membre familière de type code et ces marqueurs de visibilité.
Membres statiques et abstraits
Utilisez {static} ou {classifier} pour les membres statiques et {abstract} pour les membres abstraits :

@startuml
class abstraite PaymentMethod {
{abstract} +authorize(amount: Decimal): boolean
{static} +supportedCurrencies: String[]
}
class CardPayment {
+authorize(amount: Decimal): boolean
}
PaymentMethod <|-- CardPayment
@enduml
Une classe abstraite peut également être déclarée avec classe abstraite.
3. Relations
La forme de la flèche indique le type de relation. La direction de la ligne est déterminée par l’ordre des noms ; utilisez des étiquettes pour clarifier sa signification.
| Relation | Notation PlantUML | Signification typique |
|---|---|---|
| Héritage / généralisation | `Parent < | — Child` |
| Réalisation d’interface | `Interface < | .. Class` |
| Composition | Tout *-- Partie |
Le cycle de vie de la partie est géré par le tout |
| Agrégation | Tout o-- Partie |
Le tout regroupe ou fait référence à des parties qui peuvent exister indépendamment |
| Association dirigée | A --> B |
A a une relation navigable vers B |
| Dépendance | A ..> B |
A utilise ou dépend de B |
Il s’agit des notations de relation standard de PlantUML.

@startuml
interface Repository
class SqlRepository
class OrderService
class Order
class OrderLine
Repository <|.. SqlRepository
OrderService ..> Repository : utilise
Order *-- "1..*" OrderLine : contient
@enduml
Choisissez avec soin :La composition et l’agrégation expriment des sémantiques de cycle de vie différentes. Utilisez la composition uniquement lorsque la partie est significativement possédée par le tout ; utilisez une simple association lorsque aucune interprétation de propriété ne convient.
4. Multiplicité, noms de rôles et étiquettes
La multiplicité spécifie combien d’objets peuvent participer à chaque extrémité d’une association. Les formes courantes incluent"1", "0..1", "*", et"1..*".

@startuml
class Client
class Commande
Client "1" --> "0..*" Commande : passe
@enduml
Ici, chaqueCommande est associée à unClient, tandis qu’unClient peut passer zéro ou plusieurs commandes. Lisez les multiplicités depuis l’extrémité opposée : le nombre près de “Commande décrit combien de commandes peuvent être associées à un client.
Pour plus de précision, ajoutez des noms de rôles ou des contraintes :

@startuml
class Team
class Player
Team "1" o-- "0..*" Player : membres
note sur le lien
Un joueur peut changer d'équipe.
end note
@enduml
5. Interfaces, énumérations, stéréotypes et paquets
PlantUML prend en charge des déclarations telles que interface, énumération, classe abstraite, et des stéréotypes écrits entre << et >>.

@startuml
package "Commande" {
interface PasserellePaiement {
+charge(amount: Decimal): ResultatPaiement
}
enum StatutCommande {
NOUVELLE
PAYÉE
ANNULÉE
}
class Commande <<Entité>> {
+id: UUID
+status: StatutCommande
}
class ServicePaiement <<Service>> {
+checkout(order: Commande): ResultatPaiement
}
ServicePaiement ..> PasserellePaiement : appelle
Commande --> StatutCommande
}
@enduml
Les packages regroupent visuellement les types liés. Utilisez des stéréotypes tels que “<<Entity>> ou “<<Service>> lorsqu’ils ajoutent un contexte utile ; évitez d’ajouter des étiquettes qui répètent simplement ce que le nom de la classe indique déjà.
6. Notes, alias et mise en page
Les notes peuvent expliquer des décisions de conception ou clarifier une contrainte sans surcharger les noms de classes. Les alias aident lorsque le nom affiché contient des espaces ou de la ponctuation.

@startuml
class "External Payment API" as PaymentApi
class CheckoutService
CheckoutService ..> PaymentApi : soumet le paiement
note right of CheckoutService
Réessaie les échecs transitoires.
Ne réessaie pas les paiements refusés.
end note
direction de gauche à droite
@enduml
direction de gauche à droite modifie la direction globale de la mise en page ; la valeur par défaut est de haut en bas. Vous pouvez également utiliser des directions de relation telles que “-left-> ou “-up-|> pour guider le placement local.
7. Un exemple plus complet
Cet exemple combine la visibilité, les types, les méthodes, les énumérations, les multiplicités, la composition et la dépendance :

@startuml
direction de gauche à droite
package "Sales" {
class Customer {
-id: UUID
+name: String
+placeOrder(): Order
}
class Order {
-id: UUID
-status: OrderStatus
+addLine(product: Product, quantity: int): void
+total(): Decimal
}
class OrderLine {
-quantity: int
+lineTotal(): Decimal
}
class Product {
+sku: String
+price: Decimal
}
enum OrderStatus {
NEW
PAID
CANCELLED
}
interface PaymentGateway {
+charge(amount: Decimal): PaymentResult
}
class CheckoutService {
+checkout(order: Order): PaymentResult
}
Customer "1" --> "0..*" Order : passe
Order *-- "1..*" OrderLine : contient
OrderLine "*" --> "1" Product : fait référence à
Order --> OrderStatus
CheckoutService ..> PaymentGateway : utilise
}
@enduml
8. Outils : Visual Paradigm VPasCode
VPasCode est un éditeur de texte vers diagramme basé sur le navigateur, développé par Visual Paradigm. Il prend en charge les diagrammes de classes PlantUML et propose un éditeur de code avec prévisualisation en direct, vous permettant d’écrire ou de coller du code PlantUML et d’inspecter le résultat rendu au fur et à mesure de votre travail.

Un flux de travail typique :
-
Ouvrez VPasCode et sélectionnez l’éditeur PlantUML ou un exemple PlantUML.
-
Remplacez le texte de démarrage par votre diagramme, en incluant
@startumlet@enduml. -
Vérifiez la prévisualisation en direct ; si le rendu échoue, inspectez l’erreur de syntaxe mise en évidence et sa ligne.
-
Affinez le diagramme, puis exportez-le ou partagez-le selon les besoins. VPasCode décrit les options d’export SVG, PNG et PDF.
VPasCode propose également une interface de sélection de thèmes pour PlantUML, incluant les thèmes Visual Paradigm et Rose. Pour des résultats cohérents au sein d’une équipe, conservez la source PlantUML à côté de votre documentation ou de votre code, plutôt que de vous fier uniquement à une image exportée.
9. Pièges courants et bonnes pratiques

-
Ne confondez pas une association avec une dépendance.Une dépendance signifie généralement « utilise » ; une association représente souvent une relation structurelle plus persistante.
-
Évitez de surutiliser la composition.Elle implique une affirmation plus forte concernant le cycle de vie qu’une simple connexion.
-
Étiquetez les multiplicités depuis l’extrémité opposée.Le nombre à côté d’une classe indique combien d’instances de cette classe peuvent être liées à une instance située à l’autre extrémité.
-
Gardez les diagrammes ciblés.Divisez un modèle très volumineux en paquets ou en diagrammes distincts pour des préoccupations différentes.
-
Montrez les détails qui servent le public.Une vue d’ensemble conceptuelle peut ne nécessiter que les noms de classes et les relations ; un diagramme de niveau conception peut nécessiter les types, la visibilité et les opérations.
-
Traitez la source comme l’artefact maintenu.Examinez les modifications apportées au texte, effectuez le rendu après les modifications, et régénérez les exports lorsque la source change.
Rappel rapide

@startuml
class A {
+publicField: String
-privateField: int
#protectedMethod(): void
~packageMember(): boolean
}
interface I
abstract class Base
enum State { READY; DONE }
Base <|-- A
I <|.. A
A *-- B : composition
A o-- C : aggregation
A --> D : association
A ..> I : dependency
@enduml
PlantUML prend en charge des fonctionnalités supplémentaires de diagramme de classes, notamment le regroupement des membres, les notes, les couleurs, etc., lorsqu’un diagramme nécessite un affinage supplémentaire.










