Séquence Usecase Classe Activité Composant État Objet Déploiement Temps Regex Network Wireframe Archimate Gantt MindMap WBS EBNF JSON YAML
PlantUML Language specification Class Diagram

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Diagramme de classes

Les diagrammes de classes sont conçus à l'aide d'une syntaxe qui reflète celle traditionnellement employée dans les langages de programmation. Cette ressemblance favorise un environnement familier pour les développeurs, facilitant ainsi un processus de création de diagrammes plus facile et plus intuitif.

Cette approche de la conception est non seulement succincte, mais elle permet également de créer des représentations à la fois concises et expressives. De plus, elle permet la représentation des relations entre les classes à travers une syntaxe qui fait écho à celle des diagrammes de séquence, ouvrant la voie à une représentation fluide et perspicace des interactions entre les classes.

Au-delà des représentations structurelles et relationnelles, la syntaxe des diagrammes de classes supporte d'autres enrichissements tels que l'inclusion de notes et l'application de couleurs, permettant aux utilisateurs de créer des diagrammes qui sont à la fois informatifs et visuellement attrayants.

Vous pouvez en apprendre plus sur certaines des commandes communes dans PlantUML pour améliorer votre expérience de création de diagrammes.

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Élément déclaratif

🎉 Copied! 

@startuml
abstract        abstract
abstract class  "abstract class"
annotation      annotation
circle          circle
()              circle_short_form
class           class
class           class_stereo  <<stereotype>>
dataclass       dataclass
diamond         diamond
<>              diamond_short_form
entity          entity
enum            enum
exception       exception
interface       interface
metaclass       metaclass
protocol        protocol
record          record
stereotype      stereotype
struct          struct
@enduml

[Réf. pour protocol et struct: GH-1028, pour exception: QA-16258, pour record et dataclass: GH-2232]

[Ref. for protocol and struct: GH-1028, for exception: QA-16258, for record and dataclass: GH-2232]

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Relations entre classes

Les relations entre les classes sont définies en utilisant les symboles suivants :

Type Symbole Objectif
Extension <|-- Spécialisation d'une classe dans une hiérarchie
Implémentation <|.. Réalisation d'une interface par une classe
Composition *-- La partie ne peut exister sans le tout
Agrégation o-- La partie peut exister indépendamment du tout
Dépendance --> L'objet utilise un autre objet
Dépendance ..> Une forme plus faible de dépendance

Il est possible de substituer -- par .. pour obtenir une ligne pointillée.

Grâce à ces règles, il est possible de faire les diagrammes suivants :

🎉 Copied! 

@startuml
Class01 <|-- Class02
Class03 *-- Class04
Class05 o-- Class06
Class07 .. Class08
Class09 -- Class10
@enduml

🎉 Copied! 

@startuml
Class11 <|.. Class12
Class13 --> Class14
Class15 ..> Class16
Class17 ..|> Class18
Class19 <--* Class20
@enduml

🎉 Copied! 

@startuml
Class21 #-- Class22
Class23 x-- Class24
Class25 }-- Class26
Class27 +-- Class28
Class29 ^-- Class30
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Libellés sur les relations

Il est possible de rajouter un libellé sur une relation, en utilisant les deux points :, suivi du texte du libellé.

Pour les cardinalité, vous pouvez utiliser des guillemets "" des deux cotés de la relation.

🎉 Copied! 

@startuml
Class01 "1" *-- "many" Class02 : contains

Class03 o-- Class04 : aggregation

Class05 --> "1" Class06
@enduml

Vous pouvez ajouter une flèche désignant quel objet agit sur l'autre en utilisant < ou > au début ou à la fin du libellé.

🎉 Copied! 

@startuml
class Car

Driver - Car : drives >
Car *- Wheel : have 4 >
Car -- Person : < owns

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Caractères non alphabétiques dans les noms d'éléments et les étiquettes de relations

Si vous voulez utiliser autre chose que des lettres dans les noms des classes (ou les enums...), vous pouvez :

🎉 Copied! 

@startuml
class "Voici ma classe" as classe1
class classe2 as "Cette façon fonctionne aussi"

classe2 *-- "machin/truc" : utilise
@enduml

Si un alias est assigné à un élément, le reste du fichier doit se référer à cet élément par cet alias et non son nom.

Commencer un nom avec $

Note : les noms qui commencent par $ ne peuvent pas être cachés ou supprimés par après, parce que les commandes hide et remove les considéreront comme une $etiquette et non comme un nom de composant. Pour supprimer de tels éléments, ils doivent avoir un alias ou une étiquette.

🎉 Copied! 

@startuml
class $C1
class $C2 $C2
class "$C2" as dollarC2
remove $C1
remove $C2
remove dollarC2
@enduml

Notez aussi que les noms qui commencent par $ sont valides, mais que pour assigner un alias à un tel élément le nom doit être entre guillemets "".

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Ajouter des méthodes

Pour déclarer des méthodes ou des champs, vous pouvez utiliser le caractère : suivi de la méthode ou du champ.

Le système utilise la présence de parenthèses pour choisir entre méthodes et champs.

🎉 Copied! 

@startuml
Object <|-- ArrayList

Object : equals()
ArrayList : Object[] elementData
ArrayList : size()

@enduml

Il est possible de regrouper tous les champs et méthodes en utilisant des crochets {}.

Notez que la syntaxe est très souple sur l'ordre des champs et des méthodes.

🎉 Copied! 

@startuml
class Dummy {
  String data
  void methods()
}

class Flight {
   flightNumber : Integer
   departureTime : Date
}
@enduml

Vous pouvez utiliser les directives {field} et {method} pour remplacer le comportement par défaut du système sur le choix entre champs et méthodes.

🎉 Copied! 

@startuml
class Dummy {
  {field} Un champ (malgré les parenthèses)
  {method} Une méthode
}

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Définition de la visibilité

Lorsque vous définissez des méthodes ou des champs, vous pouvez utiliser des caractères pour définir la visibilité de l'élément correspondant

Caractère Icône pour le champ Icône de la méthode Visibilité
- private
# protected
~ package private
+ public

🎉 Copied! 

@startuml

class Machin {
 -champ1
 #champ2
 ~methode1()
 +methode2()
}

@enduml

Vous pouvez désactiver cette fonctionnalité à l'aide de la commande skinparam classAttributeIconSize 0:

🎉 Copied! 

@startuml
skinparam classAttributeIconSize 0
class Machin {
 -champ1
 #champ2
 ~methode1()
 +methode2()
}

@enduml

Les indicateurs de visibilité sont facultatifs et peuvent être omis individuellement sans désactiver les icônes globalement à l'aide de skinparam classAttributeIconSize 0.

🎉 Copied! 

@startuml
class Machin {
 champ1
 champ2
 methode1()
 methode2()
}
@enduml

Dans le cas où vous voudriez utiliser des méthodes ou champs qui commencent par l'un des caractères -, #, ~ ou +, échappez le premier caractère avec \. C'est utile dans certains langages, par exemple pour définir le destructeur de la classe Machin : ~Machin() :

🎉 Copied! 

@startuml
class Machin {
 champ1
 \~Machin()
 methode1()
}
@enduml

*[Ref. [QA-4755](https://forum.plantuml.net/4755/provide-display-visibility-attributes-private-protected)]*
WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Visibility on compositions and aggregations

🎉 Copied! 

@startuml
class Aaa {
    -bbb : int
    +ccc : string
    #aa : float
    +void addEntry(mmm : Entry)
    +int setFactory(ddd : string)
}
class Factory {
    #fff : string
}
class Entry {
    -yyy : int
}
class Parent {
}
Aaa *--> "1..100" Entry : -entries
Aaa o--> Factory : #factory
Aaa o--> Parent : +parent
@enduml

[Ref. QA-8294]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Abstrait et statique

Vous pouvez définir une méthode statique ou abstraite ou un champ utilisant {static} ou {abstract} modificateur.

Ce modificateur peut être utilisé au début ou à la fin de la ligne. Vous pouvez alors utiliser {classifier} plutôt que {static}.

🎉 Copied! 

@startuml
class Dummy {
  {static} String id
  {abstract} void methods()
}
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Corps de classe avancé

Par défaut, méthodes et champs sont automatiquement regroupés par PlantUML. Vous pouvez utiliser un séparateur pour définir votre propre manière d'ordonner les champs et les méthodes. Les séparateurs suivants sont possibles : -- .. == __.

Vous pouvez aussi utiliser les titres dans les séparateurs.

🎉 Copied! 

@startuml
class Foo1 {
  You can use
  several lines
  ..
  as you want
  and group
  ==
  things together.
  __
  You can have as many groups
  as you want
  --
  End of class
}

class User {
  .. Simple Getter ..
  + getName()
  + getAddress()
  .. Some setter ..
  + setName()
  __ private data __
  int age
  -- encrypted --
  String password
}
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Notes et stéréotypes

Stéréotypes sont définies avec le mot clé class, << et >>.

Vous pouvez aussi définir une note en utilisant les mots clés note left of , note right of , note top of , note bottom of.

Vous pouvez aussi définir une note sur la dernière classe utilisant note left, note right, note top, note bottom.

Une note peut aussi être définie le mot clé note, puis être lié à un autre objet en utilisant le symbole ...

🎉 Copied! 

@startuml
class Object << general >>
Object <|--- ArrayList

note top of Object : In java, every class\nextends this one.

note "This is a floating note" as N1
note "This note is connected\nto several objects." as N2
Object .. N2
N2 .. ArrayList

class Foo
note left: On last defined class

@enduml

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Plus de notes

Il est également possible d'utiliser quelques balises HTML (voir expression créole) comme

Vous pouvez aussi avoir une note sur plusieurs lignes.

Vous pouvez aussi définir une note sur la dernière classe définie en utilisant note left, note right, note top , note bottom

🎉 Copied! 

@startuml

class Foo
note left: On last defined class

note top of Foo
  In java, <size:18>every</size> <u>class</u>
  <b>extends</b>
  <i>this</i> one.
end note

note as N1
  This note is <u>also</u>
  <b><color:royalBlue>on several</color>
  <s>words</s> lines
  And this is hosted by <img:sourceforge.jpg>
end note

@enduml

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Note sur un champ (champ, attribut, membre) ou une méthode

Il est possible d'ajouter une note sur un champ (champ, attribut, membre) ou une méthode.

⚠ Contrainte

Note sur un champ ou une méthode

🎉 Copied! 

@startuml
class A {
{static} int counter
+void {abstract} start(int timeout)
}
note right of A::counter
  This member is annotated
end note
note right of A::start
  This method is now explained in a UML note
end note
@enduml

Note sur une méthode de même nom

🎉 Copied! 

@startuml
class A {
{static} int counter
+void {abstract} start(int timeoutms)
+void {abstract} start(Duration timeout)
}
note left of A::counter
  This member is annotated
end note
note right of A::"start(int timeoutms)"
  This method with int
end note
note right of A::"start(Duration timeout)"
  This method with Duration
end note
@enduml

[Réf. QA-3474 et QA-5835]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Note sur les liens

Il est possible d'ajouter une note sur un lien, juste après la définition d'un lien, utiliser note on link.

Vous pouvez aussi utiliser note left on link, note right on link, note top on link, note bottom on link si vous voulez changer la position relative de la note avec l'étiquette.

🎉 Copied! 

@startuml

class Dummy
Dummy --> Foo : A link
note on link #red: note that is red

Dummy --> Foo2 : Another link
note right on link #blue
this is my note on right link
and in blue
end note

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Classe et interface abstraites

Vous pouvez déclarer une classe abstraite à l'aide des mots-clés abstract ou abstract class.

La classe sera imprimée en italique.

Vous pouvez également utiliser les mots-clés interface, annotation et enum

🎉 Copied! 

@startuml

abstract class AbstractList
abstract AbstractCollection
interface List
interface Collection

List <|-- AbstractList
Collection <|-- AbstractCollection

Collection <|- List
AbstractCollection <|- AbstractList
AbstractList <|-- ArrayList

class ArrayList {
  Object[] elementData
  size()
}

enum TimeUnit {
  DAYS
  HOURS
  MINUTES
}

annotation SuppressWarnings

annotation Annotation {
  annotation with members
  String foo()
  String bar()
}


@enduml

[Ref. 'Annotation with members'Issue#458]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Masquer les attributs et les méthodes

Vous pouvez paramétrer l'affichage des classes à l'aide de la commande hide/show .

La commande de base est: hide empty members. Cette commande va masquer la zone des champs ou des méthodes si celle-ci est vide.

A la place de empty members, vous pouvez utiliser:

Vous pouvez aussi fournir, juste après le mot-clé hide ou show :

Vous pouvez utiliser plusieurs commandes show/hide pour définir des règles et des exceptions.

🎉 Copied! 

@startuml

class Dummy1 {
  +myMethods()
}

class Dummy2 {
  +hiddenMethod()
}

class Dummy3 <<Serializable>> {
String name
}

hide members
hide <<Serializable>> circle
show Dummy1 methods
show <<Serializable>> fields

@enduml

Vous pouvez également combiner avec la visibilité :

🎉 Copied! 

@startuml
hide private members
hide protected members
hide package members

class Foo {
  - private
  # protected
  ~ package
}
@enduml

*[Ref. [QA-2913](https://forum.plantuml.net/2913/hiding-based-on-visibilty?show=2916#a2916)]*

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Masquer les classes

Vous pouvez également utiliser les commandes show/hide pour masquer les classes.

Cela peut être utile si vous définissez un grand fichier !inclus, et si vous voulez masquer certaines classes après l'inclusion du fichier

🎉 Copied! 

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

hide Foo2

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Supprimer des classes

Vous pouvez également utiliser les commandes remove pour supprimer des classes.

Cela peut être utile si vous définissez un grand fichier !inclus, et si vous voulez supprimer certaines classes après l'inclusion du fichier

🎉 Copied! 

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

remove Foo2

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Cacher, Supprimer ou Remettre des éléments marqués (tagged) ou wildcard

Vous pouvez mettre $tags (avec $) sur des éléments, puis supprimer, cacher ou remettre des composants individuellement ou en utilisant des tags.

Par défaut, tous les composants sont visibles:

🎉 Copied! 

@startuml
class C1 $tag13
enum E1
interface I1 $tag13
C1 -- I1
@enduml

Mais vous pouvez :

🎉 Copied! 

@startuml
class C1 $tag13
enum E1
interface I1 $tag13
C1 -- I1

hide $tag13
@enduml

🎉 Copied! 

@startuml
class C1 $tag13
enum E1
interface I1 $tag13
C1 -- I1

remove $tag13
@enduml

🎉 Copied! 

@startuml
class C1 $tag13 $tag1
enum E1
interface I1 $tag13
C1 -- I1

remove $tag13
restore $tag1
@enduml

🎉 Copied! 

@startuml
class C1 $tag13 $tag1
enum E1
interface I1 $tag13
C1 -- I1

remove *
restore $tag1
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Masquer ou supprimer une classe non liée

Par défaut, toutes les classes sont affichées

🎉 Copied! 

@startuml
class C1
class C2
class C3
C1 -- C2
@enduml

Mais vous pouvez :

🎉 Copied! 

@startuml
class C1
class C2
class C3
C1 -- C2

hide @unlinked
@enduml

🎉 Copied! 

@startuml
class C1
class C2
class C3
C1 -- C2

remove @unlinked
@enduml

[Adapté de QA-11052]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Utilisation de la généricité

Vous pouvez aussi utiliser les signes inférieur < et supérieur > pour définir l'utilisation de la généricité dans une classe.

🎉 Copied! 

@startuml

class Foo<? extends Element> {
  int size()
}
Foo *- Element

@enduml

On peut désactiver ce comportement avec la commande skinparam genericDisplay old.

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Caractère spécial

Normalement, un caractère (C, I, E ou A) est utilisé pour les classes, les interfaces ou les énum.

Vous pouvez aussi utiliser le caractère de votre choix, en définissant le stéréotype et en ajoutant une couleur, comme par exemple :

🎉 Copied! 

@startuml

class System << (S,#FF7700) Singleton >>
class Date << (D,orchid) >>
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Packages

Vous pouvez définir un package en utilisant le mot-clé package, et optionnellement déclarer une couleur de fond pour votre package (en utilisant un code couleur HTML ou son nom).

Notez que les définitions de packages peuvent être imbriquées.

🎉 Copied! 

@startuml

package "Classic Collections" #DDDDDD {
  Object <|-- ArrayList
}

package com.plantuml {
  Object <|-- Demo1
  Demo1 *- Demo2
}

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Modèle de paquet

Il y a différents styles de paquets disponibles.

Vous pouvez les spécifier chacun par un réglage par défaut avec la commande : skinparam packageStyle, ou par l'utilisation d'un stéréotype sur le paquet:

🎉 Copied! 

@startuml
scale 750 width
package foo1 <<Node>> {
  class Class1
}

package foo2 <<Rectangle>> {
  class Class2
}

package foo3 <<Folder>> {
  class Class3
}

package foo4 <<Frame>> {
  class Class4
}

package foo5 <<Cloud>> {
  class Class5
}

package foo6 <<Database>> {
  class Class6
}

@enduml

Vous pouvez aussi définir les liens entre les paquets, comme dans l'exemple suivant :

🎉 Copied! 

@startuml

skinparam packageStyle rectangle

package foo1.foo2 {
}

package foo1.foo2.foo3 {
  class Object
}

foo1.foo2 +-- foo1.foo2.foo3

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Les espaces de nommage

Depuis la version 1.2023.2 (publiée en béta) PlantUml a modifié le traitement des espaces de nommage et des packages.

Il n'y aura plus de différences entre espaces de nommage et packages : ces notions seront équivalentes.

Avec les packages, le nom de la classe est l'identifiant unique de la classe. Cela signifie qu'on ne peux pas avoir deux classes avec le même nom dans deux packages différents. Pour ce faire, vous devez utiliser des espace de nommage (namespace) à la place des packages.

Vous pouvez faire référence à des classes d'autres espace de nommage en les nommant complétement. Les classes de l'espace de nommage par défaut (racine) sont nommées en commençant par un point.

Il n'est pas obligatoire de créer les espaces de nom. Un classe avec son nom complet sera automatiquement ajoutée au bon espace de nommage.

🎉 Copied! 

@startuml

class BaseClass

namespace net.dummy #DDDDDD {
    .BaseClass <|-- Person
    Meeting o-- Person

    .BaseClass <|- Meeting
}

namespace net.foo {
  net.dummy.Person  <|- Person
  .BaseClass <|-- Person

  net.dummy.Meeting o-- Person
}

BaseClass <|-- net.unused.Person

@enduml

There won't be any difference between namespaces and packages anymore: both keywords are now synonymous.

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Creation automatique d'espace de nommage

Vous pouvez définir une autre séparateur (autre que le point) en utilisant la commande : set separator ???.

🎉 Copied! 

@startuml

set separator ::
class X1::X2::foo {
  some info
}

@enduml

Vous pouvez désactiver la création automatique d'espace de nommage en utilisant la commande set separator none.

🎉 Copied! 

@startuml

set separator none
class X1.X2.foo {
  some info
}

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Interface boucle

Vous pouvez aussi rajouter des interfaces sur les classes avec la syntaxe suivante:

🎉 Copied! 

@startuml
class foo
bar ()- foo
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Changer la direction des flèches

Par défaut, les liens entre les classe ont deux tirets -- et sont orientés verticalement. Il est possible d'utiliser une ligne horizontal en mettant un simple tiret (Ou un point) comme ceci:

🎉 Copied! 

@startuml
Room o- Student
Room *-- Chair
@enduml

Vous pouvez aussi changer le sens en renversant le lien :

🎉 Copied! 

@startuml
Student -o Room
Chair --* Room
@enduml

Il est aussi possible de changer la direction d'une flèche en ajoutant les mots clés left, right, up ou down à l'intérieur de la flèche:

🎉 Copied! 

@startuml
foo -left-> dummyLeft
foo -right-> dummyRight
foo -up-> dummyUp
foo -down-> dummyDown
@enduml

Il est possible de raccourcir la flèche en n'utilisant que la première lettre de la direction (par exemple, -d- au lieu de -down-) ou les deux premières lettres (-do-)

Attention à ne pas abuser de cette fonctionnalité : GraphViz donne généralement de bons résultats sans trop de raffistolages.

Et avec le paramètre left to right direction:

🎉 Copied! 

@startuml
left to right direction
foo -left-> dummyLeft
foo -right-> dummyRight
foo -up-> dummyUp
foo -down-> dummyDown
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Classes d'association

Vous pouvez définir une classe d'association après qu'une relation ait été définie entre deux classes, comme dans l'exemple suivant:

🎉 Copied! 

@startuml
class Student {
  Name
}
Student "0..*" - "1..*" Course
(Student, Course) .. Enrollment

class Enrollment {
  drop()
  cancel()
}
@enduml

Vous pouvez la définir dans une autre direction :

🎉 Copied! 

@startuml
class Student {
  Name
}
Student "0..*" -- "1..*" Course
(Student, Course) . Enrollment

class Enrollment {
  drop()
  cancel()
}
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Association sur la même classe

🎉 Copied! 

@startuml
class Station {
    +name: string
}

class StationCrossing {
    +cost: TimeInterval
}

<> diamond

StationCrossing . diamond
diamond - "from 0..*" Station
diamond - "to 0..* " Station
@enduml

[Réf. Incubation : Associations]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Personnalisation

La commande skinparam permet de changer la couleur et les polices de caractères.

Vous pouvez utiliser cette commande :

🎉 Copied! 

@startuml

skinparam class {
BackgroundColor PaleGreen
ArrowColor SeaGreen
BorderColor SpringGreen
}
skinparam stereotypeCBackgroundColor YellowGreen

Class01 "1" *-- "many" Class02 : contains

Class03 o-- Class04 : aggregation

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Stéréotypes Personnalisés

Vous pouvez définir des couleurs et des fontes de caractères spécifiques pour les classes stéréotypées.

🎉 Copied! 

@startuml

skinparam class {
BackgroundColor PaleGreen
ArrowColor SeaGreen
BorderColor SpringGreen
BackgroundColor<<Foo>> Wheat
BorderColor<<Foo>> Tomato
}
skinparam stereotypeCBackgroundColor YellowGreen
skinparam stereotypeCBackgroundColor<< Foo >> DimGray

class Class01 <<Foo>>
class Class03 <<Foo>>
Class01 "1" *-- "many" Class02 : contains

Class03 o-- Class04 : aggregation

@enduml

Important: Contrairement aux stéréotypes des classes, il ne doit pas y avoir d'espaces entre skinparam et le stéréotype suivant.

N'importe quel espace tel que _ montré ci dessous fera que tous les skinparams seront ignorés cf.discussion discord et issue #1932:

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Dégradé de couleurs

Vous pouvez déclarer des couleurs individuelles pour les classes, les notes, etc. en utilisant la notation #.

Vous pouvez utiliser des noms de couleurs standard ou des codes RVB dans diverses notations, voir Couleurs.

Vous pouvez également utiliser le dégradé de couleurs pour les couleurs de fond, avec la syntaxe suivante : deux noms de couleurs séparés soit par : selon la direction du gradient.

Par exemple

🎉 Copied! 

@startuml

skinparam backgroundcolor AntiqueWhite/Gold
skinparam classBackgroundColor Wheat|CornflowerBlue

class Foo #red-green
note left of Foo #blue\9932CC
  this is my
  note on this class
end note

package example #GreenYellow/LightGoldenRodYellow {
  class Dummy
}

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Aide pour la mise en page

Sometimes, the default layout is not perfect...

You can use together keyword to group some classes together : the layout engine will try to group them (as if they were in the same package).

You can also use hidden links to force the layout.

🎉 Copied! 

@startuml

class Bar1
class Bar2
together {
  class Together1
  class Together2
  class Together3
}
Together1 - Together2
Together2 - Together3
Together2 -[hidden]--> Bar1
Bar1 -[hidden]> Bar2


@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Découper les grands diagrammes

Parfois, vous obtiendrez des images de taille importante.

Vous pouvez utiliser la commande page (hpages)x(vpages) pour découper l'image en plusieurs fichiers:

hpages est le nombre de pages horizontales et vpages indique le nombre de pages verticales.

Vous pouvez aussi utiliser des paramètres spécifiques pour rajouter des bords sur les pages découpées (voir l'exemple).

🎉 Copied! 

@startuml
' Split into 4 pages
page 2x2
skinparam pageMargin 10
skinparam pageExternalColor gray
skinparam pageBorderColor black

class BaseClass

namespace net.dummy #DDDDDD {
    .BaseClass <|-- Person
    Meeting o-- Person

    .BaseClass <|- Meeting

}

namespace net.foo {
  net.dummy.Person  <|- Person
  .BaseClass <|-- Person

  net.dummy.Meeting o-- Person
}

BaseClass <|-- net.unused.Person
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Extension et implementation [extends, implements]

Il est aussi possible d'utiliser directement les mots clés extends and implements.

🎉 Copied! 

@startuml
class ArrayList implements List
class ArrayList extends AbstractList
@enduml

🎉 Copied! 

@startuml
class A extends B, C {
}
@enduml

[Ref. QA-2239]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Relations entre crochets (liens ou flèches) style

Style de ligne

Il est également possible d'avoir explicitement des relations, des liens ou des flèches bold, dashed, dotted, hidden ou plain:

🎉 Copied! 

@startuml
title Bracketed line style without label
class foo
class bar
bar1 : [bold]  
bar2 : [dashed]
bar3 : [dotted]
bar4 : [hidden]
bar5 : [plain] 

foo --> bar
foo -[bold]-> bar1
foo -[dashed]-> bar2
foo -[dotted]-> bar3
foo -[hidden]-> bar4
foo -[plain]-> bar5
@enduml

🎉 Copied! 

@startuml
title Bracketed line style with label
class foo
class bar
bar1 : [bold]  
bar2 : [dashed]
bar3 : [dotted]
bar4 : [hidden]
bar5 : [plain] 

foo --> bar          : ∅
foo -[bold]-> bar1   : [bold]
foo -[dashed]-> bar2 : [dashed]
foo -[dotted]-> bar3 : [dotted]
foo -[hidden]-> bar4 : [hidden]
foo -[plain]-> bar5  : [plain]

@enduml

[Adapté de QA-4181]

Couleur de ligne

🎉 Copied! 

@startuml
title Bracketed line color
class foo
class bar
bar1 : [#red]
bar2 : [#green]
bar3 : [#blue]

foo --> bar
foo -[#red]-> bar1     : [#red]
foo -[#green]-> bar2   : [#green]
foo -[#blue]-> bar3    : [#blue]
'foo -[#blue;#yellow;#green]-> bar4
@enduml

Épaisseur de ligne

🎉 Copied! 

@startuml
title Bracketed line thickness
class foo
class bar
bar1 : [thickness=1]
bar2 : [thickness=2]
bar3 : [thickness=4]
bar4 : [thickness=8]
bar5 : [thickness=16]

foo --> bar                 : ∅
foo -[thickness=1]-> bar1   : [1]
foo -[thickness=2]-> bar2   : [2]
foo -[thickness=4]-> bar3   : [4]
foo -[thickness=8]-> bar4   : [8]
foo -[thickness=16]-> bar5  : [16]

@enduml

[Réf. QA-4949]

Mélange

🎉 Copied! 

@startuml
title Bracketed line style mix
class foo
class bar
bar1 : [#red,thickness=1]
bar2 : [#red,dashed,thickness=2]
bar3 : [#green,dashed,thickness=4]
bar4 : [#blue,dotted,thickness=8]
bar5 : [#blue,plain,thickness=16]

foo --> bar                             : ∅
foo -[#red,thickness=1]-> bar1          : [#red,1]
foo -[#red,dashed,thickness=2]-> bar2   : [#red,dashed,2]
foo -[#green,dashed,thickness=4]-> bar3 : [#green,dashed,4]
foo -[#blue,dotted,thickness=8]-> bar4  : [blue,dotted,8]
foo -[#blue,plain,thickness=16]-> bar5  : [blue,plain,16]
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Modifier la couleur et le style d'une relation (lien ou flèche) (style en ligne)

Vous pouvez modifier la couleur ou le style d'une relation ou d'une flèche individuelle en utilisant la notation suivante en ligne

🎉 Copied! 

@startuml
class foo
foo --> bar : normal
foo --> bar1 #line:red;line.bold;text:red  : red bold
foo --> bar2 #green;line.dashed;text:green : green dashed
foo --> bar3 #blue;line.dotted;text:blue   : blue dotted
@enduml

[Voir une fonctionnalité similaire sur le déploiement]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Modifier la couleur et le style d'une classe (style en ligne)

Vous pouvez modifier la couleur ou le style d'une classe individuelle en utilisant les deux notations suivantes

Avec la couleur de fond d'abord (#color), puis le style de ligne et la couleur de ligne (##[style]color )

🎉 Copied! 

@startuml
abstract   abstract
annotation annotation #pink ##[bold]red
class      class      #palegreen ##[dashed]green
interface  interface  #aliceblue ##[dotted]blue
@enduml

[Réf. QA-1487]

🎉 Copied! 

@startuml
abstract   abstract
annotation annotation #pink;line:red;line.bold;text:red
class      class      #palegreen;line:green;line.dashed;text:green
interface  interface  #aliceblue;line:blue;line.dotted;text:blue
@enduml

Premier exemple original

🎉 Copied! 

@startuml
class bar #line:green;back:lightblue
class bar2 #lightblue;line:green

class Foo1 #back:red;line:00FFFF
class FooDashed #line.dashed:blue
class FooDotted #line.dotted:blue
class FooBold #line.bold
class Demo1 #back:lightgreen|yellow;header:blue/red
@enduml

[Réf. QA-3770]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Flèches de/vers les membres de la classe

🎉 Copied! 

@startuml
class Foo {
+ field1
+ field2
}

class Bar {
+ field3
+ field4
}

Foo::field1 --> Bar::field3 : foo
Foo::field2 --> Bar::field4 : bar
@enduml

Ref. QA-3636]

🎉 Copied! 

@startuml
left to right direction

class User {
  id : INTEGER
  ..
  other_id : INTEGER
}

class Email {
  id : INTEGER
  ..
  user_id : INTEGER
  address : INTEGER
}

User::id *-- Email::user_id
@enduml

[Réf. QA-5261]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Regroupement de flèche d'héritage

Vous pouvez fusionner toutes les têtes de flèche à l'aide de la fonction skinparam groupInheritance, avec un seuil comme paramètre.

GroupInheritance 1 (pas de regroupement)

🎉 Copied! 

@startuml
skinparam groupInheritance 1

A1 <|-- B1

A2 <|-- B2
A2 <|-- C2

A3 <|-- B3
A3 <|-- C3
A3 <|-- D3

A4 <|-- B4
A4 <|-- C4
A4 <|-- D4
A4 <|-- E4
@enduml

GroupInheritance 2 (regroupement à partir de 2)

🎉 Copied! 

@startuml
skinparam groupInheritance 2

A1 <|-- B1

A2 <|-- B2
A2 <|-- C2

A3 <|-- B3
A3 <|-- C3
A3 <|-- D3

A4 <|-- B4
A4 <|-- C4
A4 <|-- D4
A4 <|-- E4
@enduml

GroupInheritance 3 (regroupement uniquement à partir de 3)

🎉 Copied! 

@startuml
skinparam groupInheritance 3

A1 <|-- B1

A2 <|-- B2
A2 <|-- C2

A3 <|-- B3
A3 <|-- C3
A3 <|-- D3

A4 <|-- B4
A4 <|-- C4
A4 <|-- D4
A4 <|-- E4
@enduml

GroupInheritance 4 (regroupement uniquement à partir de 4)

🎉 Copied! 

@startuml
skinparam groupInheritance 4

A1 <|-- B1

A2 <|-- B2
A2 <|-- C2

A3 <|-- B3
A3 <|-- C3
A3 <|-- D3

A4 <|-- B4
A4 <|-- C4
A4 <|-- D4
A4 <|-- E4
@enduml

[Réf. QA-3193, et Défaut QA-13532]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Display JSON Data on Class or Object diagram

Simple example

🎉 Copied! 

@startuml
class Class
object Object
json JSON {
   "fruit":"Apple",
   "size":"Large",
   "color": ["Red", "Green"]
}
@enduml

[Ref. QA-15481]

For another example, see on JSON page.

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Packages and Namespaces Enhancement

[From V1.2023.2+, and V1.2023.5]

🎉 Copied! 

@startuml
class A.B.C.D.Z {
}
@enduml

🎉 Copied! 

@startuml
set separator none
class A.B.C.D.Z {
}
@enduml

🎉 Copied! 

@startuml
!pragma useIntermediatePackages false
class A.B.C.D.Z {
}
@enduml

🎉 Copied! 

@startuml
set separator none
package A.B.C.D {
  class Z {
  }
}
@enduml

[Ref. GH-1352]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Qualified associations

Minimal example

🎉 Copied! 

@startuml
class class1
class class2

class1 [Qualifier] - class2
@enduml

[Ref. QA-16397, GH-1467]

Another example

🎉 Copied! 

@startuml
    interface Map<K,V>
    class HashMap<Long,Customer>

    Map <|.. HashMap
    Shop [customerId: long] ---> "customer\n1" Customer
    HashMap [id: Long] -r-> "value" Customer
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Change diagram orientation

You can change (whole) diagram orientation with:

Top to bottom (by default)

With Graphviz (layout engine by default)

The main rule is: Nested element first, then simple element.

🎉 Copied! 

@startuml
class a
class b
package A {
  class a1
  class a2
  class a3
  class a4
  class a5
  package sub_a {
   class sa1
   class sa2
   class sa3
  }
}
  
package B {
  class b1
  class b2
  class b3
  class b4
  class b5
  package sub_b {
   class sb1
   class sb2
   class sb3
  }
}
@enduml

With Smetana (internal layout engine)

The main rule is the opposite: Simple element first, then nested element.

🎉 Copied! 

@startuml
!pragma layout smetana
class a
class b
package A {
  class a1
  class a2
  class a3
  class a4
  class a5
  package sub_a {
   class sa1
   class sa2
   class sa3
  }
}
  
package B {
  class b1
  class b2
  class b3
  class b4
  class b5
  package sub_b {
   class sb1
   class sb2
   class sb3
  }
}
@enduml

Left to right

With Graphviz (layout engine by default)

🎉 Copied! 

@startuml
left to right direction
class a
class b
package A {
  class a1
  class a2
  class a3
  class a4
  class a5
  package sub_a {
   class sa1
   class sa2
   class sa3
  }
}
  
package B {
  class b1
  class b2
  class b3
  class b4
  class b5
  package sub_b {
   class sb1
   class sb2
   class sb3
  }
}
@enduml

With Smetana (internal layout engine)

🎉 Copied! 

@startuml
!pragma layout smetana
left to right direction
class a
class b
package A {
  class a1
  class a2
  class a3
  class a4
  class a5
  package sub_a {
   class sa1
   class sa2
   class sa3
  }
}
  
package B {
  class b1
  class b2
  class b3
  class b4
  class b5
  package sub_b {
   class sb1
   class sb2
   class sb3
  }
}
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Role label to associations

🎉 Copied! 

@startuml
class User
class Item
User "owner which is very long"/1 -- "0..n"/items Item
@enduml

[Ref. GH-2536, GH-2537]