Das UML Anwendungsfalldiagramm und die Modellierung mit plantUML

Das UML Anwendungsfalldiagramm und die Modellierung mit plantUML

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

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

PlantUML, UML, Anwendungsfalldiagramm, Use Case, Akteur, Systemgrenze, include, extend, Generalisierung, Multiplizität, Diagram as Code

tl/dr; (ca. 17 min Lesezeit): Praktische Tipps, wie UML Anwendungsfalldiagramme mit Hilfe von PlantUML erstellt werden können. Ich versuche mich dabei näher an die UML-Spezifikation zu halten, als dies auf der PlantUML-Seite der Fall ist. Informationen zu UML-Anwendungsfalldiagrammen allgemein finden sich in einem gesonderten Use-Case-Diagramm-Artikel [AI-Assisted]. (Zuletzt geändert am 29.10.2026)

Dieser Artikel ist Teil einer Artikelreihe über Anwendungsfälle: Anwendungsfälle tabellarisch erfassen / Grundlagen des Anwendungsfalldiagramms (Übungsaufgaben) / Anwendungsfalldiagramme mit PlantUML / Kurzübung: Mitfahr-App.

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

Als PlantUML-Grundlagen kann ich nach Durchlesen des Artikels…

  • … ein Anwendungsfalldiagramm mit Akteur*innen (actor), Anwendungsfällen (usecase) und Systemgrenze (rectangle) in PlantUML notieren.

  • … Generalisierungen von Akteur*innen und Anwendungsfällen mit <|- bzw. -|> notieren und abstrakte Elemente kennzeichnen.

  • … «include»- und «extend»-Beziehungen in PlantUML notieren und bei «extend» Erweiterungspunkt und Bedingung angeben.

  • … Multiplizitäten und gerichtete Assoziationen zu sekundären Akteur*innen in PlantUML notieren.

Darüber hinaus kann ich als PlantUML-Expertenwissen…

  • … die Anordnung der Elemente über Linienlänge, Pfeilrichtung und Reihenfolge der Nennung steuern.

  • … das Aussehen von Diagrammen mit skinparam und Optionen anpassen.

PlantUML ist ein Tool, um textbasiert deklarativ UML-Diagramme zu erstellen (oder, als Buzzword formuliert: diagram as code). Das bietet zwei große Vorteile:

  • Die Diagramme sind einfach mit der Codebasis versionierbar, können jederzeit und von überall kurzfristig angepasst werden.

  • Die Diagramme können direkt in die Readme.md-Dateien in den Repositories integriert werden, da relativ viele Markdown-Engines der gängigen git-Dienstleister diese unmittelbar rendern.

Ein großer Nachteil soll jedoch nicht verschwiegen werden: PlantUML ist recht störrisch, was die genaue Positionierung von Elementen angeht. Besser, man findet sich schnell damit ab, wo PlantUML das jeweilige Objekt hinrendert – sonst wird das schnell frustrierend.

Wie fängt man am besten an? Mit einem Beispiel-Diagramm. Und dem größten Vorteil: dieser Link speichert das Diagramm und öffnet es direkt im Webeditor von planttext.com. Im Folgenden sind zu den meisten Diagrammen solche Links angegeben. Das ist aber nur ein Weg, PlantUML zu bearbeiten. Für so ziemlich alle IDEs, git-Dienste, Editoren usw. gibt es PlantUML-Plugins.

Am Ende dieses Artikels kannst Du ein Diagramm wie das folgende mit den wichtigsten Notationselementen notieren: Generalisierung von Akteurinnen, «include», «extend» mit Erweiterungspunkt und Bedingung sowie eine gerichtete Assoziation zu einer sekundären Akteurin. Den Quelltext dieses Diagramms findest Du im Repository; er nutzt zusätzlich die Formatvorlage (umlusecase.cfg) von oer-informatik.de.

Anwendungsfalldiagramm „Shopsystem“ mit den wichtigsten Notationselementen: abstrakte Akteurin mit Generalisierung, Systemgrenze, «include», «extend» mit Erweiterungspunkt und Bedingung sowie gerichtete Assoziation zum Bezahldienst (mit KI erstellt)

Akteurinnen und Anwendungsfälle

Im Wesentlichen besteht ein Anwendungsfalldiagramm aus _Akteur*innen_ (actor), Anwendungsfällen (usecase) und der Systemgrenze (wird in PlantUML mit rectangle deklariert). Ein minimales Anwendungsfalldiagramm sieht mit PlantUML wie folgt aus:

@startuml
left to right direction
actor :Kundin: as customer

rectangle Shopsystem {

    usecase (Ware \n bestellen) as bestellen
    customer -- (informieren)
    customer -- bestellen
  }
@enduml
Ein einfaches UseCase-Diagramm mit Akteurin, Systemgrenze und UseCase

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext)

Der PlantUML-Quelltext wird immer zwischen @startuml und @enduml eingefasst. Damit die Akteurinnen wie im UseCase-Diagramm üblich links des Systems stehen, muss left to right direction vorangestellt werden. Der Übersichtlichkeit halber werden diese Befehle in den folgenden Codefragmenten ausgespart und sind nur unter den „Codebeispiel“-Links komplett einbezogen.

Akteurinnen werden außerhalb der Systemgrenzen definiert und mit einem angezeigten Namen (hier: „Kundin“) und einem Alias zur Referenzierung (hier: „customer“) versehen.

actor :Kundin: as customer

Anwendungsfälle können gesondert deklariert und mit Alias versehen werden:

usecase (Ware \n bestellen) as bestellen

In Kurzform können sie auch direkt bei Assoziationen erwähnt werden, sind dann allerdings nicht über Aliase referenzierbar:

customer -- (informieren)

Vererbung von Akteuren und “oder”-Beziehungen

Vererbungsbeziehungen zwischen Akteurinnen werden in PlantUML mithilfe ASCII-stilisierter Pfeilspitzen modelliert: die Operatoren -|> und <|- symbolisieren jeweils die in Richtung der Generalisierung weisende Pfeilspitze.

mitarbeiter <|- prokurist

Ein komplettes UML-Diagramm wäre etwa wie folgt:

actor :Mitarbeiterin: as mitarbeiter
actor :Prokuristin: as prokurist

rectangle Vertragswesen {
  usecase (Vertrag \n ausfertigen) as ausfertigen
  usecase (Vertrag \n unterschreiben) as unterschreiben

  mitarbeiter -- ausfertigen
  prokurist -- unterschreiben
  mitarbeiter <|- prokurist
}
Vererbungsbeziehung in einem Usecase-Diagramm

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext)

Die Reihenfolge der Akteurinnen legt fest, wie sie im Diagramm erscheinen. Die erstgenannte Akteurin erscheint oberhalb der zweitgenannten (sofern left to right direction aktiviert wurde – andernfalls erscheint die erstgenannte links):

gf -|> befugte

Abstraktion wird wie in der UML üblich mit kursiver Schreibweise oder über den Constraint {abstract} notiert. Kursive Schreibweise wird über die HTML-Tags <i>...</i> realisiert. In den Akteurinnen-Namen können über das Steuerzeichen \n auch Zeilenumbrüche genutzt werden:

actor :{abstract}\n<i>Befugte</i>: as befugte

Vererbungsbeziehung mit abstrakten Akteuren

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext)

Hier wurde eine Akteurin oberhalb und eine unterhalb positioniert, indem die Reihenfolge der Nennung und die Pfeilrichtung umgekehrt wurde.

Vererbung von Anwendungsfällen

Die Syntax zur Vererbung von Anwendungsfällen ist analog zu der Syntax für Akteurinnen: wird ein Anwendungsfall „Artikel kaufen“ durch die Anwendungsfälle „eBook kaufen“ und „Buch per Versand kaufen“ spezialisiert, so wird auch hier der stilisierte Pfeil -|> als Operator verwendet:

eBookKaufen -|> ArtikelKaufen

ArtikelKaufen <|- BuchKaufen

Ebenso können Use-Cases, die nicht eigenständig nutzbar sind, sondern nur Teilszenarien modellieren, die in anderen Use-Cases konkretisiert werden, als abstrakt deklariert werden. In PlantUML lässt sich dies wieder über die HTML-Tags <i>...</i> kursiv setzen oder über den Constraint {abstract} markieren. PlantUML zeigt den Constraint {abstract} als Text über dem Namen an, setzt den Namen aber nicht automatisch kursiv (getestet mit PlantUML 1.2026.8); die Kursivschrift kommt über <i>...</i>.

usecase ({abstract}\n<i>Artikel kaufen</i>) as ArtikelKaufen

Ein Beispiel könnte etwa so aussehen.

actor :Kundin: as customer

rectangle Shopsystem {
  usecase ({abstract}\n<i>Artikel kaufen</i>) as ArtikelKaufen
  usecase (eBook kaufen) as eBookKaufen
  usecase (Buch per Versand kaufen) as BuchKaufen

  customer -- eBookKaufen
  customer -- BuchKaufen

  eBookKaufen -|> ArtikelKaufen
  ArtikelKaufen <|- BuchKaufen
}
Generalisierung von Anwendungsfällen mit einem abstrakten Anwendungsfall „Artikel kaufen“

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext)

Anwendungsfälle, die weitere Anwendungsfälle immer beinhalten

Um include-Beziehungen mit PlantUML zu modellieren – also Anwendungsfälle, die die Funktionalität anderer Anwendungsfälle in jedem Fall enthalten –, wird zum einen die Linienform und Pfeilspitze variiert, indem zwischen den Anwendungsfällen der Operator .> notiert wird, zum anderen wird neben dem Pfeil das Stereotyp «include» notiert:

ausfertigen .> drucken : <<include>>

include-Beziehung: „Vertrag ausfertigen“ beinhaltet immer „Vertrag ausdrucken“

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext)

actor :Mitarbeiterin: as mitarbeiter

rectangle Vertragswesen {
    usecase (Vertrag \n ausfertigen) as ausfertigen
    usecase (Vertrag \n ausdrucken) as drucken

    mitarbeiter -- ausfertigen

    'Die gestrichelte Linie wird per .> angegeben
    'und das Stereotyp nach dem Doppelpunkt:
    ausfertigen .> drucken : <<include>>
}

Anwendungsfälle, die unter Umständen durch weitere Anwendungsfälle erweitert werden

Extend-Beziehungen, bei denen Anwendungsfälle nur unter bestimmten Umständen um die Funktionalitäten eines zweiten Anwendungsfalls erweitert werden, können in PlantUML nur über ein paar Tricks modelliert werden. Analog zu include-Beziehungen werden der gestrichelte Pfeil und das zugehörige Stereotyp «extend» notiert:

bestellen <.(Neukunden-Registrierung) : <<extend>>

Zur genauen Zuordnung der Bedingung, unter der die Erweiterung gilt, muss jedoch zusätzlich noch ein extension point und eine condition angegeben werden.

Der Erweiterungspunkt (extension point) wird zum einen direkt in der Ellipse des Anwendungsfalls referenziert:

usecase bestellen as "bestellen
  --
  <i>extension points:</i>
  Registrierung"

Zum anderen muss er – mit zugehöriger Bedingung (condition) – in einer Notiz notiert werden, die mit der zugehörigen Beziehung verbunden ist.

bestellen <.(Neukunden-Registrierung) : <<extend>>

note top on link
  <i>condition:</i>
  {Neukunde}
  <i>extension point:</i>
  Registrierung
end note
Extend-Beziehungen mit PlantUML modellieren

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext)

Wie viele Akteurinnen stehen mit wie vielen UseCases in Beziehung?

Multiplizitäten werden in PlantUML direkt bei den Assoziationen und in Anführungszeichen notiert. Es empfiehlt sich, längere Verbindungslinien zwischen Akteurinnen und Anwendungsfällen zu zeichnen (über drei Bindestriche: ---), damit die Zahlen weit genug auseinander liegen und leichter zugeordnet werden können.

player "3..*" --- "1" rundlauf

Multiplizitäten in Use-Case-Diagrammen

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext)

actor :Spielerin: as player
actor :Schiedsrichterin: as referee

rectangle Tischtennis {
    usecase (Rundlauf) as rundlauf

    'Multiplizitäten werden an den Assoziationen angegeben
    player "3..*" --- "1" rundlauf
    referee "0..1" --- "0..*" rundlauf
}

Gerichtete Assoziationen (initiierende und sekundäre Akteurinnen)

Für die seltenen Fälle, in denen zwischen initiierenden und sekundären Akteurinnen unterschieden werden muss, kann in PlantUML der Operator --> (bzw. ---> für eine längere Linie) genutzt werden, um eine gerichtete Assoziation zu zeichnen.

Gerichtete Assoziationen

Codebeispiel: ( online bearbeitbar / vollständiger Quelltext)

actor :Bezahldienstleister: as bezahl
actor :Kundin: as kundin
rectangle OnlineShop {
    usecase (Artikel kaufen) as kauf
}
kundin --> kauf
kauf --> bezahl

PlantUML-Formatierung: Ausrichtung der Linien durch einfache oder zweifache Zeichen (- / – / . / ..)

PlantUML bietet die Möglichkeit, Assoziationsrichtungen über die Operatoren -up-, -down-, -left- und -right- vorzugeben. Wenn man jedoch die Option left to right direction nutzt, sind durch die Drehung sämtliche Richtungsanweisungen verdreht.

Als Alternative kann man auch die Notation mit einfachen und doppelten Bindestrichen wählen:

Ausrichtung der Assoziationen über einfache und doppelte Bindestriche: oben, unten, links und rechts der Akteurin 
'wie immer wurde die Richtung gedreht:
left to right direction

actor :Personaler: as personaler

'nach oben dann mit nur einem Bindestrich:
(Kündigen aussprechen \n <i> oben </i>)- personaler

'nach unten durch vertauschen von Akteurin und UseCase
personaler - (Bewerbungsgespräche führen  \n <i> unten </i>)

'seitlich nach rechts mit zwei Strichen
personaler -- (Beförderungsverfahren eröffnen  \n <i> rechts </i>)

'seitlich nach links mit Vertauschten Positionen
(Abmahnungnen aussprechen \n <i> links </i>) -- personaler

PlantUML-Formatierung: Aufhübschen von Anwendungsfall-Diagrammen

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

Minimalbeispiel: nur die Leserichtung wurde angepasst

Minimalbeispiel eines Anwendungsfalldiagramms mit Notiz, nur die Leserichtung angepasst 
@startuml

left to right direction

actor :Akteur:
rectangle System {
usecase Anwendungsfall  
Akteur -- Anwendungsfall
note top on link
Notiz...
end note
}
@enduml

Anpassung von Schriftart und Farben

Anwendungsfalldiagramm mit angepasster Schriftart und Farben 
@startuml

skinparam DefaultFontName "Lucida Sans Typewriter"
skinparam UseCase{
 BorderColor DarkSlateBlue
 BackgroundColor whitesmoke
}
skinparam Note{
 BorderColor DarkSlateBlue
 BackgroundColor LightYellow
}
skinparam Actor{
 BorderColor DarkSlateBlue
 BackgroundColor whitesmoke
}
skinparam ArrowColor DarkSlateBlue
left to right direction

actor :Akteur:
rectangle System {
usecase Anwendungsfall  
Akteur -- Anwendungsfall
note top on link
Notiz...
end note
}
@enduml

Sieht nach Entwurf aus: Skizzenstil

Um die Vorläufigkeit und Änderbarkeit zu unterstreichen, kannst Du das Diagramm wie eine Skizze aussehen lassen. Aktuelle PlantUML-Versionen schalten die Handschrift-Optik mit !option handwritten true ein; die frühere Schreibweise skinparam handwritten true blendet nur noch einen Hinweis im Diagramm ein.

Anwendungsfalldiagramm im Skizzenstil mit Handschrift-Optik 
@startuml

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

left to right direction

actor :Akteur:
rectangle System {
usecase Anwendungsfall  
Akteur -- Anwendungsfall
note top on link
Notiz...
end note
}
@enduml

Leitfragen

  1. Mit welchen PlantUML-Schlüsselwörtern notierst Du Akteur*innen, Anwendungsfälle und die Systemgrenze?

Akteur*innen mit actor :Name: as alias außerhalb der Systemgrenze, Anwendungsfälle mit usecase (Name) as alias und die Systemgrenze mit rectangle Systemname { … }. Der Quelltext steht zwischen @startuml und @enduml, left to right direction setzt die Akteur*innen nach links. Siehe Abschnitt „Akteurinnen und Anwendungsfälle“

  1. Wie modellierst Du in PlantUML, dass eine von zwei Rollen einen Anwendungsfall ausführen darf („oder“)?

Über eine Generalisierung: Die spezielle Rolle erbt mit allgemein <|- speziell die Assoziationen der allgemeinen, die mit dem Anwendungsfall verbunden ist. Zwei Assoziationen an einem Anwendungsfall würden „und“ bedeuten. Siehe Abschnitt zur Vererbung von Akteuren

  1. Wie kennzeichnest Du einen abstrakten Anwendungsfall oder eine abstrakte Akteurin?

Mit dem Constraint {abstract} und kursivem Namen über <i>…</i>, z. B. usecase ({abstract}\n<i>Artikel kaufen</i>) as ArtikelKaufen. Siehe Abschnitt „Vererbung von Anwendungsfällen“

  1. Wie unterscheidet sich die Notation von «include» und «extend» in PlantUML?

Beide nutzen den gestrichelten Pfeil (.>) mit Stereotyp hinter dem Doppelpunkt. «include» zeigt vom Basisfall zum inkludierten Fall. «extend» zeigt vom erweiternden zum Basisfall; dazu kommen der Erweiterungspunkt im Basisfall und eine Notiz am Pfeil (note top on link) mit Bedingung und Erweiterungspunkt. Siehe Abschnitt „Anwendungsfälle, die unter Umständen durch weitere Anwendungsfälle erweitert werden“

  1. Warum helfen -up- oder -left- bei Anwendungsfalldiagrammen oft nicht weiter, und was ist die Alternative?

Mit left to right direction ist das Diagramm gedreht, sodass die Richtungsangaben nicht mehr stimmen. Stattdessen steuern ein oder zwei Striche (bzw. Punkte) und die Reihenfolge der Nennung, ob eine Linie senkrecht oder waagerecht verläuft. Siehe Abschnitt „PlantUML-Formatierung: Ausrichtung der Linien“

  • OER-Informatik Artikel zu Use-Case-Diagrammen allgemein

  • als Primärquelle: die UML-Spezifikation der Object Management Group (Definition des Standards, aktuell UML 2.5.1, jedoch nicht für Endnutzende aufbereitet): https://www.omg.org/spec/UML

  • für den Einstieg: Martina Seidl, Marion Brandsteidl, Christian Huemer, Gerti Kappel: UML@Classroom, dpunkt Verlag, Heidelberg 2012 Gut zu lesende Einführung in die wichtigsten UML-Diagramme, Empfehlung für den Einstieg.

  • für Lesefaule: Die Vorlesungsreihe der Technischen Uni Wien (zu UML@Classroom) kann hier angeschaut werden (Videos, Folien): http://www.uml.ac.at/de/lernen

  • als Nachschlagewerk: Christoph Kecher, Alexander Salvanos: UML 2.5 – Das umfassende Handbuch, Rheinwerk Bonn 2015, ISBN 978-3-8362-2977-7 Sehr umfangreiches Nachschlagewerk zu allen UML-Diagrammen

  • als Cheatsheet: die Notationsübersicht von oose.de: https://www.oose.de/wp-content/uploads/2012/05/UML-Notations%C3%BCbersicht-2.5.pdf

  • UML und Software Engineering: Chris Rupp, Stefan Queins & die SOPHISTen: UML2 glasklar, Hanser Verlag, München 2012; ISBN 978-3-446-43057-0 Schwerpunkt: Einbindung von UML-Diagrammen in den Softwareentwicklungszyklus

  • Zur Zertifizierungs-Vorbereitung: M. Chonoles: OCUP 2 Certification Guide, Morgan Kaufmann Verlag, Cambridge 2018, ISBN 978-0-12-809640-6 (Informationen zur Zertifizierung nach OMG Certified UML Professional 2™ (OCUP 2™): Foundation Level)

Software zur Erzeugung von UML-Use-Case-Diagrammen

  • PlantUML: Deklaratives UML-Tool, das in vielen Entwicklungsumgebungen integriert ist. Auch als WebEditor verfügbar. Die obigen Diagramme wurden damit erzeugt.

  • WhiteStarUML (Relativ umfangreiches Tool, viele UML-Diagramme, mit Code-Generierung für Java, C, C# und Vorlagen für Entwurfsmuster)

  • Draw.io: Online-Tool für Flowcharts usw. - aber eben auch UML

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: “Das UML Anwendungsfalldiagramm 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-usecase-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:

Tags:

You may also like...