UML Aktivitätsdiagramm und die Modellierung mit plantUML

UML Aktivitätsdiagramm und die Modellierung mit plantUML

https://oer-informatik.de/uml-aktivitaetsdiagramm-plantuml

https://bildung.social/@oerinformatik/112066979165700523

UML-Aktivitätsdiagramm, PlantUML, Diagram as Code, Aktion, Verzweigung, Schleife, Parallelisierung, Swimlanes, Signale, Objektknoten, skinparam

tl/dr; (ca. 19 min Lesezeit): Mithilfe von PlantUML lassen sich auch UML-Aktivitätsdiagramme per „Diagram as Code“ erstellen. Das geht nicht ganz so leicht von der Hand wie bei Sequenz- oder Klassendiagrammen, weil PlantUML hier etwas umständlich ist und teilweise vom UML-Standard abweicht. Hier wird Schritt für Schritt erklärt, wie Du Aktionen, Verzweigungen, Schleifen, Parallelisierung, Partitionen, Signale und Notizen notierst und die Diagramme gestaltest [AI-Assisted]. (Zuletzt geändert am 11.11.2026)

Dieser Artikel ist Teil einer Artikelreihe über UML-Aktivitätsdiagramme: Grundlagen des Aktivitätsdiagramms (Übungsaufgaben) / Objektflüsse, Signale und Ausnahmen / Aktivitätsdiagramme mit PlantUML / Kurzübung: WebApp-Seite zusammenstellen / Anwendung: Geschäftsprozesse digitalisieren.

Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast.

Dieser Artikel baut auf der Kann-Liste des Artikels Grundlagen des Aktivitätsdiagramms auf.

Als PlantUML-Grundlagen kann ich nach Durchlesen des Artikels…

  • … ein einfaches Aktivitätsdiagramm mit Start, Aktionen und Ende in PlantUML notieren.

  • … Verzweigungen mit Bedingungen (Guards) an den Kanten sowie Mehrfachverzweigungen mit switch notieren.

  • … kopf- und fußgesteuerte Schleifen mit while und repeat notieren.

  • … parallele Abläufe mit fork und Ablaufenden mit end darstellen.

  • … Verantwortungsbereiche (Partitionen) mit |Partition| festlegen.

  • … Diagramme über den PlantUML-Webservice rendern und als Link weitergeben.

Darüber hinaus kann ich als PlantUML-Expertenwissen…

  • … Signale, Objektknoten, Konnektoren sowie Vor- und Nachbedingungen notieren und benennen, wo PlantUML vom UML-Standard abweicht.

  • … das Aussehen von Diagrammen mit skinparam anpassen.

PlantUML bietet die Möglichkeit, UML-Diagramme als Code zu definieren und so einfach in die Dokumentationen der Repositories einzubinden. Man braucht dazu eigentlich nur einen Browser und einen Webservice wie Planttext oder PlantUML.

Die Markdown-Engines von GitLab, GitHub, Bitbucket & Co. unterstützen PlantUML nativ und zeigen die Diagramme direkt an. Wenn man sich an den UML-Standard halten will, macht es einem PlantUML aber nicht immer einfach - und auch die Online-Referenz (plantuml.com/de/activity-diagram-beta) geht sehr pragmatisch mit der UML um.

Im Folgenden werden einige Tipps gegeben, wie sich mit PlantUML ansehnliche und relativ standardkonforme Aktivitätsdiagramme darstellen lassen. Der Überblick zeigt die wichtigsten Notationselemente zusammen mit dem PlantUML-Code, der sie erzeugt:

Überblick: Notationselemente des Aktivitätsdiagramms mit dem zugehörigen PlantUML-Code (mit KI erstellt)

Ein einfaches unverzweigtes Aktivitätsdiagramm

PlantUML fügt die einzelnen Aktionen zwischen start und stop ein, wobei jede Aktion mit einem Doppelpunkt beginnt und mit einem Semikolon endet: :Aktionsname;. Der gesamte Quelltext steht zwischen @startuml und @enduml:

@startuml
' @startuml steht immer am Anfang, @enduml am Ende
start
:Schritt 1;
:Multiline
    Schritt **2**;
stop
@enduml

In der Abbildung ist das einfache Aktivitätsdiagramm um erläuternde Notizen ergänzt worden:

UML Aktivitätsdiagramm - Simple Start Stop

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

Kontrollstrukturen: Verzweigung und Vereinigung

Kontrollstrukturen sind leider in PlantUML wenig intuitiv. Da wir die Guards an den Kanten notieren wollen, müssen wir die Syntax etwas aufbohren. Von Haus aus schreibt PlantUML einen Text in die decision node und zeichnet sie dann als Sechseck - das ist nicht im Standard enthalten. Ich löse das so: die erste Bedingung wird hinter then() in Klammern notiert, den else-Block sollte man in jedem Fall notieren:

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

if() then ([Geld ausreichend])
    :kaufe Produkt;
else ([else])
endif
Verzweigungen mit einfacher Bedingung im UML Aktivitätsdiagramm

Beispiel mit Aktionen an beiden Alternativkanten ( online bearbeitbar / vollständiger Quelltext )

start
if() then ([Code fehlerfrei])
    :Code compilieren;
else ([else])
    :Fehlermeldung erstellen;
endif
stop
Verzweigungen mit einfacher Bedingung im UML Aktivitätsdiagramm

Nicht alle Bedingungen lassen sich unmittelbar als Prädikat formulieren. Sofern nähere Erläuterungen nötig sind, sieht die UML vor, dass diese über eine Notiz mit dem Stereotyp <<decisionInput>> erfolgen, die mit der decision node verbunden wird.

In PlantUML gibt es diese Möglichkeit nicht, daher muss man sich mit einer Notiz, die neben der vorigen Aktion steht, behelfen. Gemäß UML wird innerhalb der decision node nichts notiert - hier weicht die PlantUML-Dokumentation vom UML-Standard ab.

Komplexere Verzweigungen im UML Aktivitätsdiagramm

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

:Schritt davor;

if() then ([true])
note right
    <<decisionInput>>
    Ist hinreichend
    Bonität vorhanden?
end note
    :Kaufvertrag abwickeln;
else ([false])
    :zunächst Beratung anbieten;
endif

Für mehrfache Verzweigungen muss statt verschachtelten If-Statements in PlantUML Switch/Case genutzt werden:

Mehrfache Verzweigungen im UML Aktivitätsdiagramm

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

switch ()
case ( [Taste A] )
 :Bewegung nach links;
case ( [Taste D] ) 
 :Bewegung nach rechts;
case ( [else] )
  :nur geradeaus fahren;
endswitch

Wiederholungsstrukturen: kopf- und fußgesteuerte Schleifen

Mit PlantUML erfolgt die Modellierung einer fußgesteuerten Schleife mit einem repeat … repeat while () is ([guard])-Block:

Fußgesteuerte Schleifen im UML Aktivitätsdiagramm

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

start
repeat
    :Stufe hochsteigen;
repeat while () is ([else])
->[oben angekommen];
stop

Im Fall einer kopfgesteuerten Schleife wird die Bedingung zunächst geprüft, die zu wiederholenden Aktionen also ggf. nie ausgeführt.

Kopfgesteuerte Schleifen im UML Aktivitätsdiagramm

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

start
while() is ([hungrig])
    :Brot schmieren;
    :Brot essen;
endwhile ([satt])
stop

Concurrency: Parallelisierung von Aktionen (Splitting und Synchronisation)

Eine Gabelung (fork node) reicht ein eintreffendes Token an alle ausgehenden Kanten weiter, die folgenden Stränge laufen also parallel. Bei einer Synchronisation (join node) müssen – anders als bei einer Zusammenführung (merge node) – an allen eingehenden Kanten Token anliegen, bevor ein Token weitergereicht wird. In PlantUML wird dies durch einen fork... fork again... end fork-Block erreicht:

Synchronisierung von UML Aktivitätsdiagrammen mit PlantUML

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

start
fork
    :Mache dies;
fork again
    :...und mache
    gleichzeitig das;
end fork
stop

Partitionen / Swimlanes zur Unterscheidung von Verantwortungsbereichen

Die UML sieht vor, dass modelliert werden kann, welche Akteurin oder welches System für bestimmte Aktionen verantwortlich oder organisatorisch zuständig ist. Aufgrund des Aussehens werden diese Verantwortungsbereiche, die die UML partition nennt, oft swimlanes genannt. Diese Verantwortungsbereiche werden in PlantUML definiert, indem in der Zeile oberhalb einer Aktion zwischen Pipes der Partitionsname steht (|Partition|). Das wird leider schnell etwas unübersichtlich, aber mit etwas Übung klappt das:

Swimlanes per PlantUML: Kunde, Fachabteilung und Geschäftsführer erstellen Lastenheft, Pflichtenheft und Angebot (mit KI erstellt)

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

'Durch Nennung Reihenfolge festlegen
|Geschäftsführer|
|Fachabteilung|
|Kunde|
    start
|Kunde|
    :Lastenheft
    erstellen;
|Fachabteilung|
    :Pflichtenheft
    erstellen;
|Geschäftsführer|
    :Angebot auf Basis
    des Pflichtenhefts
    erstellen;
|Kunde|
    :Angebot prüfen;
    :Vertrag abschließen;
    stop

Signale/ Ereignisse senden und empfangen; Objektflüsse darstellen

Wenn neben dem Kontrollfluss noch der Objektfluss in ein Diagramm einfließen soll, stößt PlantUML schnell an seine Grenzen. Es können Signale empfangen (:empfange; <<input>>) und gesendet werden (:sende; <<output>>). Außerdem können mit Objektknoten Daten und der Kontrollfluss von einer Aktion zur nächsten übergeben werden (:übergebenes Objekt; <<object>>). Präzisere Notationen (Pin-Notation, Parametersätze, Streams) sind mit PlantUML leider nicht möglich (oder mir nicht bekannt).

Die früher üblichen Kurzformen :empfange<, :sende> und :Objekt] erkennen aktuelle PlantUML-Versionen nicht mehr (getestet mit Version 1.2026.8): Sie führen zu einem Syntaxfehler.

Empfangende und gesendete Signale sowie Objektfluss (mit KI erstellt)

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

:HTTP-POST-Request; <<input>>
:Message Header + Body; <<object>>
:Nachricht verarbeiten und
Antwortnachricht erzeugen;
:Response; <<object>>
:sende Response; <<output>>
stop

Ablaufende

Wenn das Erreichen eines Endes zwar den aktuellen Ausführungsstrang beendet - also den eingetroffenen Token konsumiert - aber in der Gesamtaktivität noch weitere Token vorhanden sein können, muss ein Ablaufende mit einem einfachen end modelliert werden.

Ablaufende als Tokensenke

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

start
fork
    :atmen;
fork again
    :denken;
fork again
    :singen;
    end
end fork
stop

Konnektoren (Sprungmarken) zur übersichtlicheren Darstellung

Konnektoren lassen sich relativ einfach über geklammerte Sprungmarkennamen ((A)) erzeugen. Wenn danach keine ausgehenden Kanten dargestellt werden sollen, muss zusätzlich ein detach notiert werden:

Konnektoren und Sprungmarken

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

start
fork
    (A)
    detach
    (B)
fork again
    :Mach' das;
end fork
stop


(A)
repeat
    :immer wieder das;
repeat while () is ([weiter])
->[aufhören];
(B)

Vor- und Nachbedingungen

Aktionen können mit Vor- und Nachbedingungen versehen werden. Nach UML 2.5.1 ist jede Bedingung eine eigene Notiz mit dem Stereotyp <<localPrecondition>> bzw. <<localPostcondition>>, z. B. die Vorbedingung links und die Nachbedingung rechts der Aktion. PlantUML setzt die Notizen neben die Aktion, zeichnet aber keine gestrichelte Verbindungslinie.

Aktion mit lokaler Vor- und Nachbedingung als getrennte Notizen (mit KI erstellt)

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

start
:Bestellung bearbeiten;
note left
    <<localPrecondition>>
    alle Artikel sind lieferbar
end note
note right
    <<localPostcondition>>
    Bestellstatus ist "bearbeitet"
end note
stop

plantUML-Webservice

PlantUML bietet einen Webservice, der Diagramme unmittelbar online rendert.

Variante 1: Der PlantUML-Quelltext ist online als Ressource verfügbar und soll gerendert ausgegeben werden. Hierzu muss eine URL nach dem Muster

https://www.plantuml.com/plantuml/proxy?fmt=AUSGABEFORMAT&src=https://URL_PLANTUMLSOURCE

erstellt werden, wobei als AUSGABEFORMAT png, svg, eps, epstext und txt genutzt werden kann.

Variante 2: PlantUML codiert den Quelltext, um ihn so über den Webservice zugänglich (und bearbeitbar) zu machen. Die URL ist in diesem Fall wie folgt aufgebaut:

https://www.plantuml.com/plantuml/AUSGABEFORMAT/CODIERTERQUELLTEXT

wobei als AUSGABEFORMAT png, svg, eps, epstext und txt genutzt werden kann. Wird als AUSGABEFORMAT uml gewählt, erhält man den bearbeitbaren Quelltext.

Editierbare Links lassen sich auch über den Service von planttext.com erstellen, sie nutzen dieselbe Quelltextcodierung und URLs nach dem Muster:

https://www.planttext.com/?text=CODIERTERQUELLTEXT

Auch in den erzeugten PNG-Dateien wird der Quelltext in den Metadaten hinterlegt, sodass sie sich relativ einfach später weiterverarbeiten lassen.

plantUML-Formatierung: Aufhübschen von Aktivitätsdiagrammen

Wenn die Diagramme erstmal stehen, will man sie aufhübschen. Dafür stehen allerlei Möglichkeiten zur Verfügung, die vor allem auf der PlantUML-Website dargestellt werden. Einige Beispiele sind hier abgebildet:

Der Standard bei PlantUML ist mittlerweile recht ansehnlich. In früheren Versionen waren die Diagramme für meine Begriffe zu bunt, heute sehe ich fast keine Notwendigkeit, hier anzupassen:

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

@startuml
    |QM|
  |Dev|
  |Customer|
  start
  repeat
  :add Requirment;
  |Dev|
  fork
    |QM|
    :Review;
    |Dev|
    fork again
    :ask Customer>
    Detach
    :get response<
  fork again
  :test;
  fork again
  :deploy;
  end
 |Dev|
  end fork
   |Customer|
     repeat while () is ([open tasks])
->[finished];
|Dev|
stop
@enduml
Beispiel eines einfachen Aktivitätsdiagramms mit PlantUML

Ich habe mir trotzdem angewöhnt, die Farben und Schriften anzupassen. Die meisten Diagramme, die ich hier verwende, haben die folgenden skinparams gesetzt:

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

@startuml
skinparam DefaultFontName "Lucida Sans Typewriter"

skinparam Activity{
BackgroundColor snow
BorderColor DarkSlateBlue
DiamondBackgroundColor ghostwhite
DiamondBorderColor DarkSlateBlue

}
skinparam Note{
BorderColor DarkSlateBlue
BackgroundColor LightYellow
}

skinparam ArrowColor DarkSlateBlue
|Dev|
|QM|
|Customer|
start
' … hier folgt das eigentliche Diagramm
stop
@enduml
Beispiel eines Aktivitätsdiagramms mit den Skins, wie ich sie hier nutze

Die neueren Diagramme dieser Artikelreihe binden statt einzelner skinparams die Hausnotation als Konfigurationsdatei ein (!include https://uml-diagramme-d87af5.gitlab.io/plantuml/umlactivity.cfg direkt nach @startuml); Pins und Exceptions, die die PlantUML-Aktivitätssyntax nicht abbildet, zeichne ich dort per DOT (@startdot).

Wenn man den Entwurfscharakter hervorheben will, ist vielleicht die handwritten-Option geeignet. Mit einer Handschrift-Schrift (die im PlantUML-System hinterlegt sein muss) sieht das ganz ansehnlich aus. Ich nutze hier lokal „FG Virgil“ (der Webservice kennt diese Schrift jedoch nicht und ersetzt sie). Ist natürlich Geschmackssache.

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

@startuml
' Welche Schriften gibt es auf dem System?
' listfonts als plantUML-Kommando gibt's aus.
skinparam DefaultFontName "FG Virgil"
skinparam handwritten true
skinparam monochrome true
skinparam packageStyle rect
skinparam shadowing false

|Dev|
|QM|
|Customer|
start
' … hier folgt das eigentliche Diagramm
stop
@enduml
PlantUML-Ansicht im Entwurfsskizzenstil mit Handschrift-Schriftbild

Leitfragen

  1. Wie notierst Du in PlantUML eine Aktion, und was steht am Anfang und Ende eines Diagramms?

Eine Aktion steht zwischen Doppelpunkt und Semikolon (:Code compilieren;). Der Quelltext steht zwischen @startuml und @enduml; Start- und Endknoten der Aktivität notierst Du mit start und stop. siehe Abschnitt „Ein einfaches unverzweigtes Aktivitätsdiagramm“

  1. Wie notierst Du Verzweigungen so, dass die Bedingungen wie in der UML an den Kanten stehen?

Die Klammer hinter if bleibt leer, die Bedingungen stehen als Guards in eckigen Klammern hinter then und else, z. B. if () then ([Code fehlerfrei]) … else ([else]) … endif. Für mehr als zwei Zweige nimmst Du switch (), case ([…]) und endswitch. siehe Abschnitt „Kontrollstrukturen: Verzweigung und Vereinigung“

  1. Worin unterscheiden sich repeat und while in PlantUML?

repeat … repeat while erzeugt eine fußgesteuerte Schleife, deren Rumpf mindestens einmal ausgeführt wird. while … endwhile prüft die Bedingung zuerst (kopfgesteuert), der Rumpf wird also unter Umständen nie ausgeführt. siehe Abschnitt „Wiederholungsstrukturen“

  1. Wie stellst Du parallele Abläufe und ein Ablaufende dar?

Parallele Stränge stehen zwischen fork, fork again und end fork. Mit end endet nur der aktuelle Strang (Ablaufende), mit stop die gesamte Aktivität. siehe Abschnitt „Concurrency“ und Abschnitt „Ablaufende“

  1. Wie legst Du Partitionen (Swimlanes) fest?

Eine Zeile |Partitionsname| ordnet alle folgenden Aktionen dieser Partition zu. Die Reihenfolge der Spalten legst Du fest, indem Du alle Partitionen am Anfang einmal nennst. siehe Abschnitt „Partitionen / Swimlanes“

  1. Welche Notationsmittel des Aktivitätsdiagramms kann PlantUML nicht oder nur angenähert darstellen?

Die PlantUML-Dokumentation schreibt Bedingungen in die Raute, was der UML widerspricht. «decisionInput»-Notizen und Vor- und Nachbedingungen lassen sich nicht mit einer Linie anbinden, Pins, Parametersätze und Streams fehlen ganz. siehe Abschnitt „Signale / Ereignisse senden und empfangen“

  1. Wie gibst Du ein PlantUML-Diagramm über den Webservice weiter?

Entweder über die Proxy-URL, die eine online abgelegte Quelltextdatei rendert, oder über eine URL mit codiertem Quelltext (…/plantuml/png/<Code>); mit uml statt png erhältst Du den bearbeitbaren Quelltext. siehe Abschnitt „plantUML-Webservice“

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “UML Aktivitätsdiagramm und die Modellierung mit plantUML” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/uml-aktivitaetsdiagramm-plantuml veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/uml/uml-diagramme. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 11.11.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]

Kommentare gerne per Mastodon, Verbesserungsvorschläge per gitlab issue (siehe oben). Beitrag teilen:

Tags:

You may also like...