UML-Sequenzdiagramme mit PlantUML erstellen

https://bildung.social/@oerinformatik/

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

UML-Sequenzdiagramm, PlantUML, Diagram as Code, Lebenslinie, synchrone Nachricht, asynchrone Nachricht, kombiniertes Fragment, Interaktionsrahmen, skinparam, UML 2.5

tl/dr; (ca. 21 min Lesezeit): Mithilfe des Tools PlantUML lassen sich UML-Sequenzdiagramme codebasiert erstellen. Dieser Artikel zeigt für die Notationselemente des Sequenzdiagramms die passende PlantUML-Syntax und gibt Tipps, wie die Diagramme möglichst UML-konform und ansehnlich werden [AI-Assisted]. (Zuletzt geändert am 29.10.2026)

Dieser Artikel ist Teil einer Artikelreihe über UML-Sequenzdiagramme: Einstieg in das Sequenzdiagramm (Übungsaufgaben) / Sequenzdiagramme mit PlantUML erstellen / Kurzübungen: TCP-Handshake, 2FA, CRAM-MD5, MQTT-Nachrichtenfluss, Webpage per MVP-Pattern, Zugriff erlauben mit OAuth2, Authentifizieren mit Passkey.

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 Einstieg in das Sequenzdiagramm auf.

Als PlantUML-Sequenzdiagramm-Grundlagen kann ich nach Durchlesen des Artikels…

  • … den Aufbau eines PlantUML-Quelltexts (@startuml, @enduml, Sender -> Empfänger: Nachricht) nennen und damit ein einfaches Sequenzdiagramm erstellen.

  • … Kommunikationspartner mit participant, actor, database oder collections und einem Alias deklarieren und so ihre Reihenfolge festlegen.

  • … synchrone Nachrichten, Antworten und asynchrone Nachrichten in PlantUML notieren und Ausführungsbalken mit activate und deactivate setzen.

  • … Objekterzeugung (create), Objektzerstörung (destroy, !!), Selbstnachrichten sowie gefundene und verlorene Nachrichten in PlantUML darstellen.

  • … die kombinierten Fragmente loop, alt, opt und par mit ihren Guards in PlantUML notieren.

  • … mit skinparam style strictuml und hide footbox UML-konformere Diagramme erzeugen.

Darüber hinaus kann ich als PlantUML-Sequenzdiagramm-Expertenwissen…

  • … Teilabläufe mit ref over auslagern und sie mit mainframe sd als eigenes Diagramm darstellen.

  • … Dauer-Zusicherungen mit der Engine teoz darstellen.

  • … Formatierungen in eine zentrale Konfigurationsdatei auslagern und Diagramme über den PlantUML-Webservice erzeugen.

PlantUML stellt einen einfach versionierbaren und änderbaren Weg zur Verfügung, mit Open-Source-Software UML-Diagramme zu erstellen. Die Diagramme können auch direkt in die Dokumentation von Repositorys eingebunden werden: GitLab rendert PlantUML-Blöcke in Markdown direkt (auf gitlab.com ist das aktiviert), GitHub dagegen unterstützt in Markdown nur Mermaid-Diagramme – dort bindet man PlantUML-Diagramme als Bild ein, z. B. über den PlantUML-Webservice. Leider nimmt es die Referenzbeschreibung von PlantUML (plantuml.com/de/sequence-diagram) mit dem UML-Standard nicht allzu genau. Im Folgenden werden einige Tipps gegeben, wie sich mit PlantUML ansehnliche und relativ standardkonforme Sequenzdiagramme darstellen lassen. Die Übersicht zeigt die wichtigsten Notationselemente und daneben jeweils den PlantUML-Code, der sie erzeugt:

Überblick: Sequenzdiagramm mit synchroner Nachricht, Schleife, Objekterzeugung und -zerstörung, asynchroner Nachricht und Antwort, daneben jeweils der PlantUML-Code (mit KI erstellt)

Minimales Sequenzdiagramm mit PlantUML

PlantUML-Quelltexte beginnen mit @startuml und enden mit @enduml. Die Kommunikationspartner werden automatisch erkannt, wenn man mit einem Pfeil signalisiert, von wo nach wo eine Nachricht versendet werden soll. Nach einem Doppelpunkt kann der Nachrichteninhalt übermittelt werden:

Sender -> Empfänger: Nachricht

Solange der stilisierte Pfeil auf den Empfänger zeigt, können die Teilnehmer auch vertauscht werden:

Eva <- Adam: Nochmal Hallo

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

@startuml
Adam -> Eva: Hallo
@enduml
Ein minimales Sequenzdiagramm

Die folgenden Diagramme wurden mit Layout-Befehlen angepasst (Details dazu im Abschnitt „Aufhübschen“, siehe unten). Um die Diagramme UML-konform zu halten, sind folgende Einstellungen im Kopf nötig:

@startuml
skinparam style strictuml
hide footbox
@enduml
  • hide footbox versteckt die (in der UML nicht vorgesehenen) unteren Bezeichnungsboxen der Lebenslinien,

  • skinparam style strictuml ersetzt die halboffenen Pfeilspitzen bei synchronen Nachrichten durch geschlossene, ausgefüllte – wie im Standard vorgesehen.

Kommunikationspartner darstellen mit PlantUML

Sofern die Kommunikationspartner (Lebenslinien) ein besonderes Symbol erhalten sollen (in UML nicht so vorgesehen), einen Namen mit Leer- oder Sonderzeichen bekommen (wie z. B. bei objektinstanzname :Klassenname) oder eine bestimmte Reihenfolge sichergestellt werden soll, werden die Kommunikationspartner vorab deklariert. Die Deklaration wird wie folgt notiert:

SYMBOLTYP "NameImDiagramm" as ALIASNAME

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

participant frontend
participant ":Backend" as backend
actor "martin :User" as martin
database "db :Datenbank" as db
collections "liste :Collection" as liste
Unterschiedliche Symbole für Kommunikationspartner

Synchrone Nachrichten und aktive Lebenslinien

Man unterscheidet aktive Lebenslinien, auf denen ein schmales Rechteck liegt (Ausführungsspezifikation, execution specification), und passive Lebenslinien, die nur als gestrichelte Linie gezeichnet werden. PlantUML löst dies durch die Befehle activate LEBENSLINIENNAME und deactivate LEBENSLINIENNAME. Solange eine Akteurin selbst etwas ausführt oder auf die Antwort einer anderen Teilnehmerin wartet, ist sie aktiv.

Bei Nachrichten unterscheidet die UML zwischen synchronen und asynchronen Nachrichten. Bei synchronen Nachrichten wartet die Absenderin darauf, dass die Empfängerin die Nachricht vollständig bearbeitet hat (z.B. die aufgerufene Methode beendet wurde). Es kann (muss aber nicht) eine Antwort auf eine synchrone Nachricht folgen (bei Methodenaufrufen: Rückgabewert). Notiert wird die Nachricht mit einem durchgezogenen Pfeil mit ausgefüllter Pfeilspitze:

Absender -> Empfänger: SynchroneNachricht

Die Antwort wird als gestrichelte Linie mit offener Pfeilspitze notiert, was in PlantUML folgendermaßen angegeben werden muss:

Absender <<-- Empfänger: SynchroneNachricht(): Rückgabewert

Nach UML wiederholt die Antwort den Namen der beantworteten Nachricht samt Argumenten; dahinter folgt nach einem Doppelpunkt der Rückgabewert (z. B. getName(): "Hannes"). Gibt die Methode nichts zurück, entfällt der Teil nach dem Doppelpunkt.

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

activate starter

starter -> meinKonto: setName("Hannes")
activate meinKonto
deactivate meinKonto

starter -> meinKonto: getName()
activate meinKonto
starter <<-- meinKonto: getName(): "Hannes"
deactivate meinKonto

starter -> meinKonto: getKontoNr()
activate meinKonto
starter <<-- meinKonto: getKontoNr(): "123456"
deactivate meinKonto

deactivate starter
Synchrone Nachrichten mit und ohne Antwort zwischen StarterKlasse und meinKonto (mit KI erstellt)

Asynchrone Nachrichten

Bei Parallelisierung sind Nachrichten i.d.R. asynchron: die Absenderin wartet nicht darauf, dass eine Nachricht bearbeitet wurde und geht unmittelbar zur nächsten Aktion über. In der UML werden diese Nachrichten mit einer offenen Pfeilspitze notiert.

Asynchrone Nachrichten haben per Definition keine Antwortnachricht. Reaktionen auf asynchrone Nachrichten werden als neue selbständige asynchrone Nachrichten notiert.

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

starter ->> meinThread1:start()
activate meinThread1
starter ->> meinThread2:start()
activate meinThread2
starter <<- meinThread2:Bearbeitung beendet
deactivate meinThread2
Asynchrone Nachricht

Nachrichten ohne Absender / Empfänger

Sofern der Absender / Empfänger einer Nachricht für die betreffende Modellierung nicht relevant ist (oder unbekannt ist) spricht man von gefundenen (found message) bzw. verlorenen Nachrichten (lost message). Sie starten bzw. enden nicht an Lebenslinien, sondern an einem ausgefüllten Punkt. Ältere PlantUML-Versionen zeichneten diesen Punkt nur als Kreis (so auch in der Abbildung unten); aktuelle Versionen (getestet mit 1.2026.8) füllen ihn mit dieser Notation aus:

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

'am besten geeignet
[o->> webserver: HttpGetRequest("www.beispiel.de")
webserver ->>o] : HttpResponse: "<html>...</html>"

'verloren nach / gefunden von links
[o->> webserver: HttpGetRequest("www.beispiel.de")
?<<-o webserver: HttpResponse: "<html>...</html>"

'verloren nach / gefunden von rechts
webserver o<<-? : Log aktiviert
webserver ->>o] : Zugriff loggen
Gefundene und verlorene Nachrichten

Um zu signalisieren, dass die Nachrichten im Nichts landen, wird in PlantUML an Stelle eines fehlenden Kommunikationspartners entweder der Rand des Diagramms angegeben ([ bzw. ]) oder einfach das Ende des Pfeils (mit ?; seine Länge hängt vom Nachrichtentext ab). In einigen Fällen werden die Kreise an den Pfeilenden nicht mehr komplett dargestellt, dann ist es ggf. erforderlich, etwas mit dieser nicht ganz eingängigen Notation zu spielen. Beispiele, wie die Lösung aussehen kann, finden sich oben.

Objekterzeugung / Erzeugungsaufruf

Objekterzeugungsaufrufe werden in der UML notiert wie Antworten auf synchrone Nachrichten: gestrichelte Linie und offene Pfeilspitze. In PlantUML wird diese Nachricht wie eine Antwort notiert (starter -->> meinKonto: new()) und create meinKonto vorangestellt (alternativ mit Deklaration: create participant "meinKonto :Konto" as meinKonto):

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

@startuml
participant "StarterKlasse" as starter
activate starter

participant "meinKonto :Konto" as meinKonto
create meinKonto
starter -->> meinKonto: new()

deactivate starter
@enduml
Objekterzeugungsnachrichten

Objektzerstörung (Destruktion)

Destruktionsnachrichten sind normale (synchrone oder asynchrone) Nachrichten, die das aufgerufene Objekt zerstören (je nach Programmiersprache: den Destruktor aufrufen, die letzte Referenz auf null setzen …). Die Zerstörung wird notiert, indem an das Ende der Lebenslinie ein „X“ gezeichnet wird. In PlantUML wird destroy meinKonto notiert:

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

starter -> meinKonto: kontoAufloesen()
activate meinKonto
deactivate meinKonto
destroy meinKonto
Objektzerstörung

In aktuellen PlantUML-Versionen (getestet mit 1.2026.8) fehlt das „X“ bei dieser Schreibweise mitunter, etwa wenn die Lebenslinie vor destroy deaktiviert wurde und danach keine Nachricht mehr folgt. Zuverlässig ist die Kurzform !! direkt an der zerstörenden Nachricht:

starter -> meinKonto !! : kontoAufloesen()

Selbstnachrichten

Nachrichten kann jeder Teilnehmer auch an sich selbst schicken (Methodenaufrufe eines Objekts auf sich selbst). Absenderin und Empfängerin sind dann identisch.

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

konto->konto : getKontostand()
activate konto
konto<<--konto : getKontostand():123,45
deactivate konto
Selbstaufruf

Schleifen im Sequenzdiagramm

Schleifen werden im UML-Sequenzdiagramm über kombinierte Fragmente dargestellt. Im Fall einer Wiederholung über den Operator loop, dem optional die Zahl der Durchläufe (loop(n) bzw. loop(min, max)) und/oder ein guard in eckigen Klammern folgt: eine Bedingung, solange deren Zutreffen der Schleifenrumpf ausgeführt wird. In PlantUML erzeugt loop bedingung den Kopf mit dem Guard [bedingung]; für die Zahl der Durchläufe eignet sich group loop(n) wie im folgenden Beispiel.

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

group loop (verzinsungsJahre)

konto -> konto:   guthaben = verzinse(guthaben, zinsatz)
activate konto
konto <<-- konto: guthaben = verzinse(): guthaben + zins
deactivate konto

end
Wiederholungsstruktur

Bedingte Anweisungen im Sequenzdiagramm

Auch bedingte Anweisungen werden als kombiniertes Fragment dargestellt. Der guard (die Bedingung) wird von PlantUML mit eckigen Klammern umgeben, so dass die Notation einfach wie folgt ist:

alt BEDINGUNG
else else
end

Das zweite else taucht als guard im Diagramm auf. Falls ein elseif-Block folgen soll, wird else BEDINGUNG notiert.

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

Kunde -> Bank: kontoeroeffnungMoeglich(Kunde)
activate Bank

alt bestandskunde(Kunde) == true

Kunde <<-- Bank: kontoeroeffnungMoeglich(Kunde): true

else else

Bank -> Schufa: istSolvent(Kunde)
activate Schufa
Bank <<-- Schufa : istSolvent(Kunde): schufaErgebnis
deactivate Schufa
Kunde <<-- Bank: kontoeroeffnungMoeglich(Kunde): schufaErgebnis

end

deactivate Bank
Bedingte Anweisung: Die Bank antwortet Bestandskunden direkt, sonst erst nach einer Anfrage bei der Schufa (mit KI erstellt)

Concurrency - Parallelisierung im Sequenzdiagramm

Wenn mehrere Interaktionen parallel verlaufen, wird dies mit dem kombinierten Fragment par notiert.

par
INTERAKTION
else
PARALLELEINTERAKTION
end

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

activate Browser

par
Browser -> Webserver: lade("hintergrundbild.gif")
activate Webserver
Browser <<-- Webserver: lade("hintergrundbild.gif"):file
deactivate Webserver

else
Browser -> Webserver: lade("titelbild.gif")
activate Webserver
Browser <<-- Webserver: lade("titelbild.gif"):file
deactivate Webserver
end

deactivate Browser
Parallelität / Concurrency

Referenzen: Auslagern von Abschnitten in weitere Sequenzdiagramme

Zur Übersichtlichkeit können Sequenzdiagramme aufgeteilt und ineinander referenziert werden. In PlantUML wird dies über das Schlüsselwort ref umgesetzt, wobei die zu überdeckenden Lebenslinien als kommagetrennte Liste angefügt werden.

ref over nameLebenslinie1, nameLebenslinie2 : nameDesReferenziertenSequenzdiagramms

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

activate client1
client1 -> cs:setState(someState)
activate cs

ref over co1, cs : changeState

client1 <<-- cs: setState(someState)
deactivate cs
deactivate client1
Referenz: Ein ref-Fragment über subject und observer1 verweist auf das Diagramm changeState (mit KI erstellt)

Der referenzierte Bereich wird dann an anderer Stelle in einem Interaktionsrahmen als eigenes Diagramm angegeben. PlantUML nutzt hierfür das Schlüsselwort mainframe. Der UML-Standard erwartet, dass dem Namen des Interaktionsrahmens sd (für sequence diagram) vorangestellt wird. Beispiel:

mainframe sd nameDesDiagramms

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

mainframe sd changeState

participant "subject :Subject" as cs
participant "observer1 :ConcreteObserver" as co1

activate cs
|||
deactivate cs
Interaktionsrahmen

Weitere kombinierte Fragmente

UML-Sequenzdiagramme sehen eine Reihe weiterer kombinierter Fragmente vor, die in PlantUML über die folgende Notation umgesetzt werden:

group opt
  client-> server:request()
end

Neben dem hier gewählten opt (optional ausgeführter Abschnitt) können hinter group beliebige andere Zeichenketten stehen, z. B. die weiteren Operatoren der UML strict, seq, neg, assert, ignore und consider (Guard in eckigen Klammern dahinter: group neg [bedingung]). opt, break und critical kennt PlantUML auch direkt als Schlüsselwort.

Zeitliche Zusicherungen

Sofern die Abfolge von Nachrichten an bestimmte zeitliche Zusicherungen gebunden ist, kann dies im Diagramm angegeben werden. PlantUML nutzt dafür Label, die in geschweiften Klammern angegeben und den Nachrichten vorangestellt werden.

Zwischen zwei Labels wird dann die Zeitdauer als Zusicherung (duration constraint) angegeben, die nach UML-Notation in geschweiften Klammern steht. Da dies nur mit der neuen PlantUML-Engine teoz dargestellt werden kann, muss diese derzeit noch vorneweg über den Befehl !pragma teoz true aktiviert werden:

!pragma teoz true
{ChangeStateStartLabel} client1 -> cs: setState(someState)
activate cs
{ChangeStateStopLabel} client1 <<-- cs: setState(someState)
deactivate cs

{ChangeStateStartLabel} <-> {ChangeStateStopLabel} : {500ms}

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext )

Dauer-Zusicherung {500ms} zwischen dem Aufruf setState(someState) und seiner Antwort (mit KI erstellt)

PlantUML-Webservice zur Diagrammerzeugung nutzen

PlantUML bietet einen Webservice, der Diagramme unmittelbar online rendert.

  • Variante 1: Codierter Quelltext: PlantUML kodiert 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 codierte Quelltext als Titel hinterlegt, so dass sie sich relativ einfach später weiterverarbeiten lassen.

  • Variante 2: Quelltext direkt online rendern: 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 (ohne fmt wird PNG ausgegeben). Der Quelltext muss dafür öffentlich abrufbar sein.

PlantUML-Formatierung: Aufhübschen von Sequenzdiagrammen

Über Skins bietet PlantUML die Möglichkeit, die Diagramme in Schriftart, Farben und Aussehen individuell anzupassen. An drei Beispielen wird hier kurz gezeigt, wie die Konfiguration mit skinparam das Aussehen der Sequenzdiagramme individualisieren kann.

Darstellung ohne zusätzliche skinparam-Befehle

Ein Auszug aus dem Observer-Pattern sieht ohne Anpassungen des Skins mit PlantUML folgendermaßen aus:

Beispiel: ( online bearbeitbar / vollständiger Quelltext )

Beispiel ohne Formatierung

Skin mit angepassten Farben und näher am UML-Standard

Im folgenden Beispiel (das für die Diagramme oben verwendet wurde) wurden kosmetisch nur Farben und Schriftart angepasst, aber zusätzlich auch die oben genannten Tipps verwendet, um das Diagramm UML-konformer erscheinen zu lassen: skinparam style strictuml für die Pfeile und hide footbox für die Enden der Lebenslinien.

Codebeispiel: ( online bearbeitbar )

@startuml
skinparam style strictuml
skinparam DefaultFontName "Lucida Sans Typewriter"

skinparam sequence {
    ArrowColor DarkSlateBlue
    ActorBorderColor DarkSlateBlue
    ActorBackgroundColor whitesmoke

    LifeLineBorderColor DarkSlateBlue
    LifeLineBackgroundColor whitesmoke

    ParticipantBorderColor DarkSlateBlue
    ParticipantBackgroundColor whitesmoke
}

skinparam Note{
    BorderColor DarkSlateBlue
    BackgroundColor LightYellow
}

skinparam Database{
    BackgroundColor whitesmoke
    BorderColor DarkSlateBlue
}

skinparam Collections{
    BackgroundColor whitesmoke
    BorderColor DarkSlateBlue
}

hide footbox
'[...]
@enduml
Für diese Seite genutzte Formatierung

Sequenzdiagramme per Formatierung als Entwurf kennzeichnen

Um den Entwurfscharakter eines Sequenzdiagramms zu unterstützen, kann ein Layout verwendet werden, das Handschrift ähnelt. Besonders wirkungsvoll ist das, wenn auch die Schrift authentisch handschriftlich aussieht. Dies ist z. B. bei der Schriftart „FG Virgil“ der Fall. Welche Schriften das jeweilige System bietet, lässt sich mit dem PlantUML-Befehl listfonts anzeigen. Wichtig ist: sofern eine Vektorgrafik ausgegeben wird (svg, eps), muss die Schrift auf allen anzeigenden Computern vorhanden sein, andernfalls werden Ersatzschriftarten verwendet.

Beispiel: ( online bearbeitbar / vollständiger Quelltext )

!option handwritten true
skinparam style strictuml
skinparam DefaultFontName "FG Virgil"
skinparam monochrome true
skinparam packageStyle rect
skinparam shadowing false

Die handschriftliche Linienführung wird in aktuellen PlantUML-Versionen mit !option handwritten true eingeschaltet; die ältere Schreibweise skinparam handwritten true (noch im vollständigen Quelltext oben) erzeugt nur noch den Hinweis, die neue Option zu nutzen (getestet mit 1.2026.8).

Entwurfscharakter durch Handschriftart hervorheben

Diagramme vereinheitlichen und Formatierung auslagern

Damit nicht alle PlantUML-Diagramme dieselben skinparam-Sequenzen am Beginn der PlantUML-Datei nennen müssen, kann eine zentrale Konfigurationsdatei eingebunden werden, die die Formatierungen enthält:

!include https://PATH.TO/MY/UMLSEQUENCE_CONFIG.cfg

Alle Befehle in dieser Datei werden ausgeführt, als stünden sie in der umgebenden PlantUML-Datei. Um ein einheitliches Layout zu erreichen, ist diese Funktion sehr praktisch! Die ältere Schreibweise !includeurl funktioniert zwar noch, gilt aber als veraltet; !include akzeptiert auch URLs.

Leitfragen

  1. Wie ist ein minimaler PlantUML-Quelltext für ein Sequenzdiagramm aufgebaut?

Der Quelltext steht zwischen @startuml und @enduml; jede Nachricht wird als Sender -> Empfänger: Nachricht notiert, die Kommunikationspartner erkennt PlantUML dabei automatisch. Mit skinparam style strictuml und hide footbox wird die Darstellung UML-konformer. siehe Abschnitt „Minimales Sequenzdiagramm mit PlantUML“

  1. Wann und wie deklarierst Du Kommunikationspartner vorab?

Wenn ein besonderes Symbol, ein Name mit Leer- oder Sonderzeichen (z. B. name :Klasse) oder eine feste Reihenfolge gebraucht wird, deklarierst Du die Lebenslinien zu Beginn nach dem Muster SYMBOLTYP "NameImDiagramm" as ALIASNAME, z. B. participant ":Backend" as backend. siehe Abschnitt „Kommunikationspartner darstellen mit PlantUML“

  1. Wie unterscheiden sich synchrone Nachricht, Antwort und asynchrone Nachricht in PlantUML?

Eine synchrone Nachricht notierst Du mit -> (gefüllte Pfeilspitze), die Antwort darauf mit <<-- (gestrichelt, offene Pfeilspitze) und eine asynchrone Nachricht mit ->> (durchgezogen, offene Pfeilspitze, keine Antwort). Ausführungsbalken setzt Du mit activate und deactivate. siehe Abschnitt „Synchrone Nachrichten und aktive Lebenslinien“ und Abschnitt „Asynchrone Nachrichten“

  1. Wie stellst Du Erzeugung und Zerstörung eines Objekts dar?

Vor der Erzeugungsnachricht steht create objekt, die Nachricht selbst wird gestrichelt notiert (starter -->> objekt: new()). Die Zerstörung markierst Du mit destroy objekt nach der Nachricht oder zuverlässiger mit der Kurzform starter -> objekt !! : nachricht(). siehe Abschnitt „Objekterzeugung / Erzeugungsaufruf“ und Abschnitt „Objektzerstörung (Destruktion)“

  1. Wie notierst Du Schleifen, Verzweigungen und parallele Abläufe?

Als kombinierte Fragmente: loop bedingung … end bzw. group loop(n) … end, alt bedingung … else else … end und par … else … end. PlantUML setzt die Guards dabei selbst in eckige Klammern. siehe Abschnitt „Schleifen im Sequenzdiagramm“ und Abschnitt „Bedingte Anweisungen im Sequenzdiagramm“

  1. Wie lagerst Du einen Teilablauf in ein eigenes Diagramm aus?

Im aufrufenden Diagramm verweist ref over lebenslinie1, lebenslinie2 : name auf den Teilablauf; dieser wird in einem eigenen Diagramm mit mainframe sd name als Interaktionsrahmen dargestellt. siehe Abschnitt „Referenzen: Auslagern von Abschnitten in weitere Sequenzdiagramme“

  1. Wie sorgst Du für ein einheitliches Aussehen vieler PlantUML-Diagramme?

Du legst die skinparam-Einstellungen (Farben, Schrift, strictuml, hide footbox) in einer zentralen Konfigurationsdatei ab und bindest sie in jedes Diagramm mit !include <URL oder Pfad> ein. siehe Abschnitt „Diagramme vereinheitlichen und Formatierung auslagern“

Es finden sich zahlreiche Quellen und Dokumentationen zu PlantUML im Netz, erwähnenswert sind u. a.:


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-Sequenzdiagramme mit PlantUML erstellen” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/uml-sequenzdiagramm-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: 29.10.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: