시퀀스 유스케이스 클래스 액티비티 컴포넌트 상태 객체 배치 타이밍 Regex Network Wireframe Archimate Gantt MindMap WBS EBNF JSON YAML
PlantUML Language specification Class Diagram

Edit in DokuwikiEdit in AsciidocEdit in Markdown
클래스 다이어그램

클래스 다이어그램은 시스템의 정적 구조를 표현합니다. 클래스, 그 속성과 메서드, 그리고 클래스 간의 관계를 기술하며, 코드의 구성과 설계를 문서화하는 데 가장 널리 사용되는 UML 다이어그램입니다.

PlantUML에서는 구문이 프로그래밍 언어와 유사하므로, 속성, 메서드, 가시성 기호를 자연스럽게 작성할 수 있습니다. 관계를 나타내는 화살표는 시퀀스 다이어그램과 동일한 스타일을 사용합니다.

모든 다이어그램 유형에서 사용 가능한 기능은 공통 명령어를 참조하세요.

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Declarative element

🎉 Copied! 

@startuml
hide empty members
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

[Ref. for protocol and struct: GH-1028; for exception: GH-1056, QA-16258; for metaclass and stereotype: GH-1159, QA-16784; for record and dataclass: GH-2232]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
클래스 관계

클래스 관계는 다음과 같은 부호를 사용합니다.

유형 기호 목적
확장 <|-- 계층 구조에서 클래스의 특수화
구현 <|.. 클래스에 의한 인터페이스의 실현
컴포지션 *-- 부분이 전체 없이는 존재할 수 없음
집합 o-- 부분이 전체와 독립적으로 존재할 수 있음
의존성 --> 객체가 다른 객체를 사용함
약한 의존성 ..> 더 약한 형태의 의존성

-- 는 .. 점선으로 대체 가능합니다.

이러한 규칙들로 다음과 같은 다이어그램을 그리는 것이 가능합니다.

🎉 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

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
관계를 나타내기 위한 레이블

관계에서 레이블을 추가하기 위해서는 뒤에 : 를 붙이고 레이블을 작성하면 됩니다.

관계차수를 나타내기 위해서는 ""를 이용하여 관계의 양쪽 끝에 작성하면 됩니다.

🎉 Copied! 

@startuml

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

Class03 o-- Class04 : aggregation

Class05 --> "1" Class06

@enduml

< 또는 >을 사용하여 객체가 다른 객체에 대한 흐름 관계를 더 자세히 설명할 수 있습니다.

🎉 Copied! 

@startuml
class Car

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

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Using non-letters in element names and relation labels

If you want to use non-letters in the class (or enum...) display name, you can either :

🎉 Copied! 

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

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

If an alias is assigned to an element, the rest of the file must refer to the element by the alias instead of the name.

Starting names with $

Note that names starting with $ cannot be hidden or removed later, because hide and remove command will consider the name a $tag instead of a component name. To later remove such elements they must have an alias or must be tagged.

🎉 Copied! 

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

Also note that names starting with $ are valid, but to assign an alias to such element the name must be put between quotes "".

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Adding methods

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.

🎉 Copied! 

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

🎉 Copied! 

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

🎉 Copied! 

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

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
메소드, 필드 가시화(Visibility) 정의

메소드나 필드들을 정의할 때, 특수문자를 사용하여 관련된 아이템을 가시화할 수 있습니다. 명령어는 다음과 같습니다:

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

🎉 Copied! 

@startuml

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

@enduml

skinparam classAttributeIconSize 0를 사용하여, 아이콘 표시를 끌 수 있습니다. 명령어는 다음과 같습니다:

🎉 Copied! 

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

@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
Abstract and Static

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

🎉 Copied! 

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Advanced class body

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:

🎉 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 and stereotypes

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

You can also define notes using note left of , <code>note right of</code> , 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.

🎉 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
More on notes

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

You can also have a note on several lines.

You can also define a note on the last defined element using 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:https://plantuml.com/sourceforge.jpg>
end note

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Note on field (field, attribute, member) or method

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

⚠ Constraint

Note on field or method

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

🎉 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

[Ref. QA-3474 and QA-5835]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Note on links

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.

🎉 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
Abstract class and interface

<a name="enum" id="enum">You can declare a class as abstract using "abstract" or "abstract class" keywords.</a>

The class will be printed in italic.</p>

You can use the interface, annotation and enum keywords too.</p>

🎉 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

@enduml

*[Ref. 'Annotation with members' [Issue#458](https://github.com/plantuml/plantuml/issues/458)]*
WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Hide attributes, methods...

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:

You can also provide, just after the hide or show keyword:

You can use several show/hide commands to define rules and 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

You can also mix with visibility:

🎉 Copied! 

@startuml
hide private members
hide protected members
hide package members

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

[Ref. QA-2913]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Hide classes

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.

🎉 Copied! 

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

hide Foo2

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Remove classes

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.

🎉 Copied! 

@startuml

class Foo1
class Foo2

Foo2 *-- Foo1

remove Foo2

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Hide, Remove or Restore tagged element or wildcard

You can put $tags (using $) on elements, then remove, hide or restore components either individually or by tags.

By default, all components are displayed:

🎉 Copied! 

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

But you can:

🎉 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
Hide or Remove unlinked class

By default, all classes are displayed:

🎉 Copied! 

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

But you can:

🎉 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

[Adapted from QA-11052]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Use generics

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

🎉 Copied! 

@startuml

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

@enduml

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Specific Spot

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:

🎉 Copied! 

@startuml

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Packages

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

Note that package definitions can be nested.

🎉 Copied! 

@startuml

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

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

@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Packages style

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:

🎉 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

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

🎉 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
Namespaces

Starting with version 1.2023.2, PlantUML handles differently namespaces and packages.

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

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Automatic namespace creation

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

🎉 Copied! 

@startuml

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

@enduml

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

🎉 Copied! 

@startuml

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

@enduml

WARNING
 This translation need to be updated. 
WARNING

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Lollipop interface

You can also define lollipops interface on classes, using the following syntax:

🎉 Copied! 

@startuml
class foo
bar ()- foo
@enduml

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Changing arrows orientation

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:

🎉 Copied! 

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

You can also change directions by reversing the link:

🎉 Copied! 

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

🎉 Copied! 

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

🎉 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
Association classes

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

🎉 Copied! 

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

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

You can define it in another 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 on same class

🎉 Copied! 

@startuml
class Station {
    +name: string
}

class StationCrossing {
    +cost: TimeInterval
}

<> diamond

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

[Ref. Incubation: Associations]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Skinparam

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

You can use this command :

🎉 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
Skinned Stereotypes

You can define specific color and fonts for stereotyped classes.

🎉 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: unlike class stereotypes, there must be no space between the skin parameter and the following stereotype.

Any of the spaces shown as _ below will cause all skinparams to be ignored, see discord discussion and issue #1932:

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Color gradient

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: depending on the direction of the gradient.

For example:

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

🎉 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
대용량 파일 분할하기

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

🎉 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
Extends and implements

It is also possible to use extends and implements keywords.

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

Line style

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

🎉 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

[Adapted from QA-4181]

Line color

🎉 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

Line thickness

🎉 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

[Ref. QA-4949]

Mix

🎉 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
Change relation (linking or arrow) color and style (inline style)

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

🎉 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

[See similar feature on deployment]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Change class color and style (inline style)

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

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

🎉 Copied! 

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

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

First original example:

🎉 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

[Ref. QA-3770]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Arrows from/to class members

🎉 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

[Ref. QA-5261]

Edit in DokuwikiEdit in AsciidocEdit in Markdown
Grouping inheritance arrow heads

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

GroupInheritance 1 (no grouping)

🎉 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 (grouping from 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 (grouping only from 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 (grouping only from 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

[Ref. QA-3193, and Defect 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]