Multilingual Wiki Documentation

You are currently using syntax.
In an attempt to improve PlantUML documentation...
Please do not use this website for your own diagrams.
You can click here and use the online server here for your own documentation.

Wiki Toc    View page history    Add new chapter    Reorder page    Raw


Diagramme de classes

Class Diagram

Déclaration d'un élément

Declaring element

@startuml
abstract        abstract
abstract class  "abstract class"
annotation      annotation
circle          circle
()              circle_short_form
class           class
diamond         diamond
<>              diamond_short_form
entity          entity
enum            enum
interface       interface
@enduml

@startuml
abstract        abstract
abstract class  "abstract class"
annotation      annotation
circle          circle
()              circle_short_form
class           class
diamond         diamond
<>              diamond_short_form
entity          entity
enum            enum
interface       interface
@enduml

Relations entre classes

Relations between classes

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

Type Symbol Drawing
Extension <|--
Composition *--
Aggregation o--

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

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

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

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

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

Relations between classes are defined using the following symbols :

Type Symbol Drawing
Extension <|--
Composition *--
Aggregation o--

It is possible to replace -- by .. to have a dotted line.

Knowing those rules, it is possible to draw the following drawings:

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

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

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

Libellés sur les relations

Label on 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.

@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é.

@startuml
class Car

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

@enduml

It is possible to add a label on the relation, using :, followed by the text of the label.

For cardinality, you can use double-quotes "" on each side of the relation.

@startuml

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

Class03 o-- Class04 : aggregation

Class05 --> "1" Class06

@enduml

You can add an extra arrow pointing at one object showing which object acts on the other object, using < or > at the begin or at the end of the label.

@startuml
class Car

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

@enduml

Définir les méthodes

Adding methods

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.

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

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

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

You can use {field} and {method} modifiers to override default behaviour of the parser about fields and methods.

@startuml
class Dummy {
  {field} A field (despite parentheses)
  {method} Some method
}

@enduml

To declare fields and methods, you can use the symbol : followed by the field's or method's name.

The system checks for parenthesis to choose between methods and fields.

@startuml
Object <|-- ArrayList

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

@enduml

It is also possible to group between brackets {} all fields and methods.

Note that the syntax is highly flexible about type/name order.

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

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

You can use {field} and {method} modifiers to override default behaviour of the parser about fields and methods.

@startuml
class Dummy {
  {field} A field (despite parentheses)
  {method} Some method
}

@enduml

Définition de la visibilité

Defining visibility

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

@startuml

class Dummy {
 -field1
 #field2
 ~method1()
 +method2()
}

@enduml

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

@startuml
skinparam classAttributeIconSize 0
class Dummy {
 -field1
 #field2
 ~method1()
 +method2()
}

@enduml

When you define methods or fields, you can use characters to define the visibility of the corresponding item:

Character Icon for field Icon for method Visibility
- private
# protected
~ package private
+ public

@startuml

class Dummy {
 -field1
 #field2
 ~method1()
 +method2()
}

@enduml

You can turn off this feature using the skinparam classAttributeIconSize 0 command :

@startuml
skinparam classAttributeIconSize 0
class Dummy {
 -field1
 #field2
 ~method1()
 +method2()
}

@enduml

Abstrait et statique

Abstract and Static

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

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

You can define static or abstract methods or fields using the {static} or {abstract} modifier.

These modifiers can be used at the start or at the end of the line. You can also use {classifier} instead of {static}.

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

Corps de classe avancé

Advanced class body

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.

@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

By default, methods and fields are automatically regrouped by PlantUML. You can use separators to define your own way of ordering fields and methods. The following separators are possible : -- .. == __.

You can also use titles within the separators:

@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

Notes et stéréotypes

Notes and stereotypes

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

@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

Stereotypes are defined with the class keyword, << and >>.

You can also define notes using note left of , note right of , note top of , note bottom of keywords.

You can also define a note on the last defined class using note left, note right, note top, note bottom.

A note can be also define alone with the note keywords, then linked to other objects using the .. symbol.

@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

Plus de notes

More on notes

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

  • <b>
  • <u>
  • <i>
  • <s> , <del>, <strike>
  • <font color="#AAAAAA"> ou <font color="colorName">
  • <color:#AAAAAA> ou <color:colorName>
  • <size:nn> pour changer la taille de la police
  • <img src="file"> ou <img:file>: le fichier doit être accessible par le système de fichiers

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

@startuml

class Foo
note left: On last defined class

note top of Object
  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

It is also possible to use few HTML tags (See Creole expression) like :

  • <b>
  • <u>
  • <i>
  • <s>, <del>, <strike>
  • <font color="#AAAAAA"> or <font color="colorName">
  • <color:#AAAAAA> or <color:colorName>
  • <size:nn> to change font size
  • <img src="file"> or <img:file>: the file must be accessible by the filesystem

You can also have a note on several lines.

You can also define a note on the last defined class using note left, note right, note top, note bottom.

@startuml

class Foo
note left: On last defined class

note top of Object
  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

Note sur un champ (champ, attribut, membre) ou une méthode

Note on field (field, attribute, member) or method

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

Note sur un champ ou une méthode

@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

@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]

WARNING
 This translation need to be updated. 
WARNING

It is possible to add a note on field (field, attribut, member) or on method.

⚠ Constraint

  • This cannot be used with top or bottom (only left and right are implemented)
  • This cannot be used with namespaceSeparator ::

Note on field or method

@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 on method with the same name

@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

[Ref. QA-3474 and QA-5835]

Note sur les liens

Note on links

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.

@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

It is possible to add a note on a link, just after the link definition, using note on link.

You can also use note left on link, note right on link, note top on link, note bottom on link if you want to change the relative position of the note with the label.

@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

Classe et interface abstraites

Abstract class and interface

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

@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]

You can declare a class as abstract using abstract or abstract class keywords.

The class will be printed in italic.

You can use the interface, annotation and enum keywords too.

@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]

Caractères non alphabétiques

Using non-letters

Si vous voulez utiliser autre chose que des lettres dans les classes (ou les enums...), vous pouvez:
  • Utiliser le mot clé as dans la définition de la classe
  • Metter des guillemets "" autour du nom de la classe

@startuml
class "This is my class" as class1
class class2 as "It works this way too"

class2 *-- "foo/dummy" : use
@enduml

If you want to use non-letters in the class (or enum...) display, you can either :
  • Use the as keyword in the class definition
  • Put quotes "" around the class name

@startuml
class "This is my class" as class1
class class2 as "It works this way too"

class2 *-- "foo/dummy" : use
@enduml

Masquer les attributs et les méthodes

Hide attributes, methods...

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:
  • empty fields ou empty attributes pour des champs vides,
  • empty methods pour des méthodes vides,
  • fields or attributes qui masque les champs, même s'il y en a de définis,
  • methods qui masque les méthodes, même s'il y en a de définies,
  • members qui masque les méthodes ou les champs, même s'il y en a de définies,
  • circle pour le caractère entouré en face du nom de la classe,
  • stereotype pour le stéréotype.

Vous pouvez aussi fournir, juste après le mot-clé hide ou show :
  • class pour toutes les classes,
  • interface pour toutes les interfaces,
  • enum pour tous les enums,
  • <<foo1>> pour les classes qui sont stéréotypée avec foo1,
  • Un nom de classe existant

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

@startuml

class Dummy1 {
  +myMethods()
}

class Dummy2 {
  +hiddenMethod()
}

class Dummy3 <<Serializable>> {
String name
}

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

@enduml

You can parameterize the display of classes using the hide/show command.

The basic command is: hide empty members. This command will hide attributes or methods if they are empty.

Instead of empty members, you can use:
  • empty fields or empty attributes for empty fields,
  • empty methods for empty methods,
  • fields or attributes which will hide fields, even if they are described,
  • methods which will hide methods, even if they are described,
  • members which will hide fields and methods, even if they are described,
  • circle for the circled character in front of class name,
  • stereotype for the stereotype.

You can also provide, just after the hide or show keyword:
  • class for all classes,
  • interface for all interfaces,
  • enum for all enums,
  • <<foo1>> for classes which are stereotyped with foo1,
  • an existing class name.

You can use several show/hide commands to define rules and exceptions.

@startuml

class Dummy1 {
  +myMethods()
}

class Dummy2 {
  +hiddenMethod()
}

class Dummy3 <<Serializable>> {
String name
}

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

@enduml

Masquer les classes

Hide 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

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

hide Foo2

@enduml

You can also use the show/hide commands to hide classes.

This may be useful if you define a large !included file, and if you want to hide some classes after file inclusion.

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

hide Foo2

@enduml

Supprimer des classes

Remove 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

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

remove Foo2

@enduml

You can also use the remove commands to remove classes.

This may be useful if you define a large !included file, and if you want to remove some classes after file inclusion.

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

remove Foo2

@enduml

Masquer ou supprimer une classe non liée

Hide or Remove unlinked class

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

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

Mais vous pouvez :
  • hide @unlinked classes

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

hide @unlinked
@enduml

  • ou remove @unlinked classes

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

remove @unlinked
@enduml

[Adapté de QA-11052]

By default, all classes are displayed:

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

But you can:
  • hide @unlinked classes:

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

hide @unlinked
@enduml

  • or remove @unlinked classes:

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

remove @unlinked
@enduml

[Adapted from QA-11052]

Utilisation de la généricité

Use generics

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

@startuml

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

@enduml

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

You can also use bracket < and > to define generics usage in a class.

@startuml

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

@enduml

It is possible to disable this drawing using skinparam genericDisplay old command.

Caractère spécial

Specific Spot

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 :

@startuml

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

Usually, a spotted character (C, I, E or A) is used for classes, interface, enum and abstract classes.

But you can define your own spot for a class when you define the stereotype, adding a single character and a color, like in this example:

@startuml

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

Packages

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.

@startuml

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

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

@enduml

You can define a package using the package keyword, and optionally declare a background color for your package (Using a html color code or name).

Note that package definitions can be nested.

@startuml

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

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

@enduml

Modèle de paquet

Packages style

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:

@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 :

@startuml

skinparam packageStyle rectangle

package foo1.foo2 {
}

package foo1.foo2.foo3 {
  class Object
}

foo1.foo2 +-- foo1.foo2.foo3

@enduml

There are different styles available for packages.

You can specify them either by setting a default style with the command : skinparam packageStyle, or by using a stereotype on the package:

@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

You can also define links between packages, like in the following example:

@startuml

skinparam packageStyle rectangle

package foo1.foo2 {
}

package foo1.foo2.foo3 {
  class Object
}

foo1.foo2 +-- foo1.foo2.foo3

@enduml

Les espaces de nommage

Namespaces

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.

@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

In packages, the name of a class is the unique identifier of this class. It means that you cannot have two classes with the very same name in different packages.

In that case, you should use namespaces instead of packages.

You can refer to classes from other namespaces by fully qualify them. Classes from the default namespace are qualified with a starting dot.

Note that you don't have to explicitly create namespace : a fully qualified class is automatically put in the right namespace.

@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

Creation automatique d'espace de nommage

Automatic namespace creation

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

@startuml

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

@enduml

Vous pouvez désactiver la création automatique de package en utilisant la commande set namespaceSeparator none.

@startuml

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

@enduml

You can define another separator (other than the dot) using the command : set namespaceSeparator ???.

@startuml

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

@enduml

You can disable automatic package creation using the command set namespaceSeparator none.

@startuml

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

@enduml

Interface boucle

Lollipop interface

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

  • bar ()- foo
  • bar ()-- foo
  • foo -() bar

@startuml
class foo
bar ()- foo
@enduml

You can also define lollipops interface on classes, using the following syntax:
  • bar ()- foo
  • bar ()-- foo
  • foo -() bar

@startuml
class foo
bar ()- foo
@enduml

Changer la direction

Changing arrows orientation

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:

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

Vous pouvez aussi changer le sens en renversant le lien :

@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:

@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:

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

WARNING
 This translation need to be updated. 
WARNING

By default, links between classes have two dashes -- and are vertically oriented. It is possible to use horizontal link by putting a single dash (or dot) like this:

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

You can also change directions by reversing the link:

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

It is also possible to change arrow direction by adding left, right, up or down keywords inside the arrow:

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

You can shorten the arrow by using only the first character of the direction (for example, -d- instead of -down-) or the two first characters (-do-).

Please note that you should not abuse this functionality : Graphviz gives usually good results without tweaking.

And with the left to right direction parameter:

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

Classes d'association

Association classes

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:

@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 :

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

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

You can define association class after that a relation has been defined between two classes, like in this example:

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

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

You can define it in another direction:

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

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

Association sur la même classe

Association on same class

@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]

WARNING
 This translation need to be updated. 
WARNING

@startuml
class Station {
    +name: string
}

class StationCrossing {
    +cost: TimeInterval
}

<> diamond

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

[Ref. Incubation: Associations]

Personnalisation

Skinparam

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

Vous pouvez utiliser cette commande :

@startuml

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

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

Class03 o-- Class04 : aggregation

@enduml

You can use the skinparam command to change colors and fonts for the drawing.

You can use this command :

@startuml

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

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

Class03 o-- Class04 : aggregation

@enduml

Stéréotypes Personnalisés

Skinned Stereotypes

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

@startuml

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

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

Class03 o-- Class04 : aggregation

@enduml

You can define specific color and fonts for stereotyped classes.

@startuml

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

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

Class03 o-- Class04 : aggregation

@enduml

Dégradé de couleurs

Color gradient

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 :
  • | ,
  • / ,
  • \ , ou
  • -
selon la direction du gradient.

Par exemple

@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

You can declare individual colors for classes, notes etc using the # notation.

You can use standard color names or RGB codes in various notations, see Colors.

You can also use color gradient for background colors, with the following syntax: two colors names separated either by:
  • |,
  • /,
  • \, or
  • -
depending on the direction of the gradient.

For example:

@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

Aide pour la mise en page

Help on layout

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.

@startuml

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


@enduml

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.

@startuml

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


@enduml

Découper les grands diagrammes

Splitting large files

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

@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

Sometimes, you will get some very large image files.

You can use the page (hpages)x(vpages) command to split the generated image into several files :

hpages is a number that indicated the number of horizontal pages, and vpages is a number that indicated the number of vertical pages.

You can also use some specific skinparam settings to put borders on splitted pages (see example).

@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

Extension et implementation [extends, implements]

Extends and implements

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

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

It is also possible to use extends and implements keywords.

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

Relations entre crochets (liens ou flèches) style

Bracketed relations (linking or arrow) 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:

  • sans étiquette

@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

  • avec étiquette

@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

@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

@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

@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

Line style

It's also possible to have explicitly bold, dashed, dotted, hidden or plain relation, links or arrows:

  • without label

@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

  • with label

@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

[Adapted from QA-4181]

Line color

@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

Line thickness

@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

[Ref. QA-4949]

Mix

@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

Modifier la couleur et le style d'une relation (lien ou flèche) (style en ligne)

Change relation (linking or arrow) color and style (inline style)

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

  • #color;line.[bold|dashed|dotted];text:color

@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]

You can change the color or style of individual relation or arrows using the inline following notation:

  • #color;line.[bold|dashed|dotted];text:color

@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

[See similar feature on deployment]

Modifier la couleur et le style d'une classe (style en ligne)

Change class color and style (inline style)

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

  • #color ##[style]color

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

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

[Réf. QA-1487]

  • #[color|back:color];header:color;line:color;line.[bold|dashed|dotted];text:color

@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

@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]

You can change the color or style of individual class using the two following notations:

  • #color ##[style]color

With background color first (#color), then line style and line color (##[style]color )

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

[Ref. QA-1487]

  • #[color|back:color];header:color;line:color;line.[bold|dashed|dotted];text:color

@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

First original example:

@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

[Ref. QA-3770]

Flèches de/vers les membres de la classe

Arrows from/to class members

@startuml
class Foo {
+ field1
+ field2
}

class Bar {
+ field3
+ field4
}

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

Ref. QA-3636]

@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]

@startuml
class Foo {
+ field1
+ field2
}

class Bar {
+ field3
+ field4
}

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

[Ref. QA-3636]

@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

[Ref. QA-5261]

Regroupement de flèche d'héritage

Grouping inheritance arrow heads

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)

@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)

@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)

@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)

@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]

You can merge all arrow heads using the skinparam groupInheritance, with a threshold as parameter.

GroupInheritance 1 (no grouping)

@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 (grouping from 2)

@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 (grouping only from 3)

@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 (grouping only from 4)

@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

[Ref. QA-3193, and Defect QA-13532]


Please report any bugs to plantuml@gmail.com or here.
This website is still in beta testing.