Ein UML-Anwendungsfalldiagramm ist eine grafische Darstellung, die zeigt, wie Nutzer (Akteure) mit einem System interagieren können.
Es beschreibt die verschiedenen Use Cases (Anwendungsfälle) und die Beziehungen zwischen ihnen und den Akteuren. Solche Diagramme helfen, die Anforderungen an ein System zu verstehen und zu planen, indem sie die Funktionen aus Sicht der Benutzer visualisieren.
Anwendungsfalldiagramme dienen der Anforderungsanalyse und helfen dabei:
Typische Einsatzbereiche:
┌────────────────────────────────────────┐
│ Anforderungsanalyse │
│ ↓ │
│ System-Design │
│ ↓ │
│ Kommunikation mit Stakeholdern │
│ ↓ │
│ Testplanung │
└────────────────────────────────────────┘
Ein Anwendungsfalldiagramm besteht aus vier Hauptelementen:
Visuelles Beispiel:
O ┌───────────────────────────┐
/|\ │ SYSTEM │
/ \ │ │
Kunde ──────────► (Use Case 1) │
│ │ │
O │ │ │
/|\ │ ↓ │
/ \ │ (Use Case 2) │
Admin ──────────► │ │
└───────────────────────────┘
Um Anwendungsfalldiagramme vollständig zu verstehen, müssen wir die einzelnen Komponenten kennen:
Eine Include-Beziehung zeigt, dass ein Use Case einen anderen Use Case immer einschließt und benötigt.
Der eingefügte Use Case ist notwendig und wird jedes Mal ausgeführt.
[Use Case A] ────────<<include>>────────► [Use Case B]
gestrichelte Linie
mit <<include>>
Pfeilrichtung: Von A nach B = "A inkludiert B"
Use Case A benötigt immer die Funktionalität von Use Case B.
Typische Szenarien:
O
/|\
/ \
Kunde
│
│
↓
┌─────────────────┐
│ Bestellen │
└─────────────────┘
│
│ <<include>>
↓
┌─────────────────┐
│ Anmelden │ ← IMMER nötig!
└─────────────────┘
│
│ <<include>>
↓
┌─────────────────┐
│ Bezahlen │ ← IMMER nötig!
└─────────────────┘
Erklärung:
Include-Beziehung = Funktionsaufruf:
public void bestellen() {
anmelden(); // <<include>> - wird IMMER aufgerufen
bezahlen(); // <<include>> - wird IMMER aufgerufen
bestaetigen();
}
┌─────────────────┐
│ Buch ausleihen │
└─────────────────┘
│
│ <<include>>
↓
┌─────────────────┐
│ Benutzer prüfen │ ← Muss IMMER geprüft werden
└─────────────────┘
│
│ <<include>>
↓
┌─────────────────┐
│ Verfügbarkeit │ ← Muss IMMER geprüft werden
│ prüfen │
└─────────────────┘
Ablauf:
Visualisierung:
Include (IMMER):
[Bestellen] ──<<include>>──► [Anmelden]
└─► "Bestellen" braucht "Anmelden" IMMER
Extend (OPTIONAL):
[Bestellen] ◄──<<extend>>── [Gutschein einlösen]
└─► "Gutschein" ist optional bei "Bestellen"
O
/|\
/ \
Kunde
│
├──────────────────────────┐
│ │
↓ ↓
┌─────────────┐ ┌─────────────┐
│Geld abheben │ │ Überweisen │
└─────────────┘ └─────────────┘
│ │
│ <<include>> │ <<include>>
↓ ↓
┌─────────────────────────────────┐
│ PIN eingeben & verifizieren │ ← Für BEIDE nötig!
└─────────────────────────────────┘
Vorteil:
Gute Verwendung:
✅ [Bestellen] ──<<include>>──► [Bezahlen]
✅ [Artikel kaufen] ──<<include>>──► [Anmelden]
✅ [Dokument drucken] ──<<include>>──► [Drucker wählen]
Schlechte Verwendung:
❌ [Bestellen] ──<<include>>──► [Newsletter abonnieren] (optional!)
❌ [Suchen] ──<<include>>──► [Favorit hinzufügen] (optional!)
<<include>>"Include" = "einschließen" = muss dabei sein
Eine Extend-Beziehung zeigt, dass ein Use Case einen anderen Use Case optional erweitern kann.
Die Erweiterung findet nur unter bestimmten Bedingungen statt.
[Use Case A] ◄────────<<extend>>──────── [Use Case B]
gestrichelte Linie
mit <<extend>>
Pfeilrichtung: Von B nach A = "B erweitert A"
Use Case B ist eine optionale Erweiterung von Use Case A.
Typische Szenarien:
O
/|\
/ \
Kunde
│
│
↓
┌─────────────────┐
│ Bestellen │ ◄─────<<extend>>────── ┌───────────────────┐
└─────────────────┘ │Gutschein einlösen │
└───────────────────┘
[Extension Point:
Wenn Gutschein
vorhanden]
Erklärung:
Extend-Beziehung = Optionaler Code:
public void bestellen() {
warenkorb_pruefen();
// EXTEND: Optional, nur wenn Bedingung erfüllt
if (kunde.hatGutschein()) {
gutschein_einloesen(); // <<extend>>
}
bezahlen();
bestaetigen();
}
Extension Points definieren, wo und wann die Erweiterung stattfindet.
┌─────────────────────────────┐
│ Produkt bestellen │
├─────────────────────────────┤
│ Extension Points: │
│ - Nach Warenkorb │
│ - Vor Bezahlung │
└─────────────────────────────┘
△
│ <<extend>>
│
┌─────────────────┐
│ Rabatt gewähren │
└─────────────────┘
[Bedingung:
VIP-Kunde]
┌─────────────────┐
│ Geld abheben │ ◄─────<<extend>>────── ┌───────────────────┐
└─────────────────┘ │ Quittung drucken │
└───────────────────┘
[Extension Point:
Nach Geldausgabe,
wenn Kunde möchte]
Ablauf:
┌─────────────────────────────────────────────────────────┐
│ INCLUDE (IMMER) │
└─────────────────────────────────────────────────────────┘
[Bestellen] ────<<include>>────► [Anmelden]
│
└─► MUSS ausgeführt werden
┌─────────────────────────────────────────────────────────┐
│ EXTEND (OPTIONAL) │
└─────────────────────────────────────────────────────────┘
[Bestellen] ◄────<<extend>>──── [Gutschein einlösen]
│
└─► KANN ausgeführt werden
O
/|\
/ \
Kunde
│
↓
┌─────────────────┐
│ Essen bestellen │
└─────────────────┘
△
│
┌────┴────┬────────────┬────────────┐
│ │ │ │
│ │ │ │
<<extend>> <<extend>> <<extend>> <<extend>>
│ │ │ │
┌─────┐ ┌──────┐ ┌──────────┐ ┌─────────┐
│Vorspeise│Dessert│ │Extra-Beilage│Getränk│
│hinzu-│ │hinzu-│ │ hinzufügen │ │hinzu-│
│fügen │ │fügen │ └──────────┘ │fügen │
└─────┘ └──────┘ └─────────┘
Alle Erweiterungen sind optional!
┌─────────────────────────────┐
│ Online bezahlen │
├─────────────────────────────┤
│ Extension Point: │
│ "Vor Abschluss" │
└─────────────────────────────┘
△
│ <<extend>>
│
┌─────────────────────────────┐
│ Zahlung in Raten aufteilen │
└─────────────────────────────┘
[Bedingung:
Betrag > 100€]
Bedeutung:
Gute Verwendung:
✅ [Bestellen] ◄──<<extend>>── [Gutschein einlösen]
✅ [Suchen] ◄──<<extend>>── [Filter anwenden]
✅ [Zahlen] ◄──<<extend>>── [Rechnung ausdrucken]
Schlechte Verwendung:
❌ [Bestellen] ◄──<<extend>>── [Bezahlen] (Pflicht, nicht optional!)
❌ [Anmelden] ◄──<<extend>>── [Passwort eingeben] (Pflicht!)
<<extend>>"Extend" = "erweitern" = kann hinzugefügt werden
┌────────────────────────────────────────────┐
│ BIBLIOTHEKS-SYSTEM │
│ │
O │ ┌─────────────────────┐ │
/|\ │ │ Katalog durchsuchen │ │
/ \ │ └─────────────────────┘ │
Besucher ────────┼────────────┘ │
│ │
△ │ │
│ │ ┌─────────────────┐ │
───┴─── │ │ Buch ausleihen │ │
│ │ │ └─────────────────┘ │
O O │ │ │
/|\ /|\ │ │ <<include>> │
/ \ / \ │ ↓ │
Gast Mitglied──────┼───►┌──────────────┐ │
│ │ │Benutzer prüfen│ │
│ │ └──────────────┘ │
│ │ │
├────────────┼───►┌─────────────────┐ │
│ │ │ Buch verlängern │ │
│ │ └─────────────────┘ │
│ │ │
└────────────┼───►┌─────────────────┐ │
│ │ Reservieren │ │
│ └─────────────────┘ │
│ △ │
│ │ <<extend>> │
│ │ │
│ ┌─────────────────────────┐ │
│ │ E-Mail-Benachrichtigung │ │
│ └─────────────────────────┘ │
│ │
└────────────────────────────────────────────┘
Erklärung:
Beispiel-Workflow:
Schritt 1: Akteure sammeln
Kunde, Administrator, Zahlungssystem
Schritt 2: Use Cases sammeln
Bestellen, Bezahlen, Produkte verwalten
Schritt 3: Systemgrenze ziehen
[System: Online-Shop]
Schritt 4: Beziehungen hinzufügen
Bestellen <<include>> Bezahlen
Bestellen <<extend>> Gutschein einlösen
Schritt 5: Review mit Team
✓ Vollständig? Korrekt?
❌ Zu technische Use Cases:
Falsch: "Datenbank abfragen"
Richtig: "Produkte suchen"
❌ Implementierungsdetails:
Falsch: "SQL-Query ausführen"
Richtig: "Kundendaten abrufen"
❌ Falsche Beziehungsrichtung:
Falsch: [Anmelden] ◄── <<extend>> ── [Bestellen]
Richtig: [Bestellen] ──── <<include>> ──► [Anmelden]
❌ Zu viele Details:
Falsch: 50 Use Cases mit allen Spezialfällen
Richtig: 10-15 Haupt-Use-Cases
| Diagramm | Zweck | Perspektive |
|---|---|---|
| Anwendungsfalldiagramm | Was kann das System? | Nutzersicht (extern) |
| UML-Klassendiagramm | Wie ist das System strukturiert? | Entwicklersicht (intern) |
| UML-Sequenzdiagramme | Wie läuft eine Interaktion ab? | Zeitlicher Ablauf |
| UML-Aktivitätsdiagramm | Wie läuft ein Prozess ab? | Workflow/Prozess |
| UML-Zustandsdiagramme | Welche Zustände hat ein Objekt? | Zustandsübergänge |
Anwendungsfalldiagramme beantworten: "WER macht WAS mit dem System?"