BPMN Grundlagen: Prozessmodellierung mit Events, Gateways, Tasks, Pools & Lanes

Dieser Beitrag ist eine umfassende Einführung in die BPMN Grundlagen – inklusive Prozessmodellierung mit Events, Gateways, Tasks, Pools und Lanes mit praktischen Beispielen.

In a Nutshell

BPMN (Business Process Model and Notation) ist eine standardisierte Notation zur Modellierung von Geschäftsprozessen mit grafischen Elementen wie Events, Gateways, Tasks und Swimlanes.

Kompakte Fachbeschreibung

BPMN (Business Process Model and Notation) ist ein grafischer Standard zur Beschreibung von Geschäftsprozessen. Sie ermöglicht eine einheitliche Darstellung von Prozessabläufen unabhängig von Tools und Organisationen.

Wichtige BPMN-Elemente:

Events (Ereignisse)

Start Event: Prozessbeginn (Kreis, dünn umrandet)
End Event: Prozessende (Kreis, dick umrandet)
Intermediate Event: Zwischenereignis (Kreis, doppelt umrandet)
Boundary Event: Fehlerereignis an Task
Timer Event: Zeitgesteuerte Ereignisse
Message Event: Nachrichtenbasierte Ereignisse

Tasks (Aufgaben)

User Task: Manuelle Aufgabe durch Benutzer
Service Task: Automatisierte Aufgabe
Script Task: Skript-Ausführung
Manual Task: Manuelle Aufgabe ohne Systemunterstützung
Receive Task: Warten auf Nachricht
Send Task: Nachricht senden

Gateways (Gateways/Verzweigungen)

Exclusive Gateway: Exklusive Verzweigung (X)
Parallel Gateway: Parallele Ausführung (+)
Inclusive Gateway: Inklusive Verzweigung (O)
Complex Gateway: Komplexe Bedingungen
Event Gateway: Ereignisbasierte Verzweigung

Swimlanes (Schwimmbahnen)

Pool: Prozesscontainer für eine Organisation
Lane: Verantwortlichkeitsbereich innerhalb eines Pools
Participant: Akteur im Prozess

Prüfungsrelevante Stichpunkte

BPMN: Standardisierte Prozessmodellierungsnotation
Events: Prozessereignisse (Start, End, Intermediate)
Tasks: Prozessaufgaben (User, Service, Script)
Gateways: Prozessverzweigungen (Exclusive, Parallel, Inclusive)
Pools/Lanes: Organisatorische Zuordnung (Swimlanes)
Sequence Flow: Prozessfluss zwischen Elementen
Message Flow: Kommunikation zwischen Pools
IHK-relevant: Wichtig für Geschäftsprozessanalyse und -optimierung

Kernkomponenten

Events: Prozesssteuerung durch Ereignisse
Tasks: Ausführung von Arbeitsschritten
Gateways: Entscheidungen und Verzweigungen
Pools: Prozesscontainer für Organisationen
Lanes: Verantwortlichkeitsbereiche
Sequence Flow: Prozessabläufe
Message Flow: Zwischenprozesskommunikation
Artifacts: Zusätzliche Informationen (Datenobjekte, Gruppen)

Praxisbeispiele

1. BPMN-Prozess: Bestellabwicklung

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             targetNamespace="http://www.example.com/bpmn">
    
    <!-- Prozess: Bestellabwicklung -->
    <process id="bestellprozess" name="Bestellabwicklung" isExecutable="false">
        
        <!-- Start Event -->
        <startEvent id="start_bestellung" name="Bestellung eingegangen"/>
        
        <!-- User Task: Bestellung prüfen -->
        <userTask id="pruefe_bestellung" name="Bestellung prüfen">
            <documentation>
                Mitarbeiter prüft Bestellung auf Vollständigkeit und Verfügbarkeit
            </documentation>
        </userTask>
        
        <!-- Exclusive Gateway: Bestellung gültig? -->
        <exclusiveGateway id="gueltig_pruefung" name="Bestellung gültig?"/>
        
        <!-- Service Task: Lager prüfen -->
        <serviceTask id="pruefe_lager" name="Lagerbestand prüfen">
            <documentation>
                Automatisierte Prüfung der Lagerverfügbarkeit
            </documentation>
        </serviceTask>
        
        <!-- Parallel Gateway: Parallelverarbeitung -->
        <parallelGateway id="parallel_start" name="Parallel starten"/>
        
        <!-- User Task: Rechnung erstellen -->
        <userTask id="erstelle_rechnung" name="Rechnung erstellen">
            <potentialOwner>
                <resourceAssignmentExpression>
                    <formalExpression>finanzabteilung</formalExpression>
                </resourceAssignmentExpression>
            </potentialOwner>
        </userTask>
        
        <!-- Service Task: Ware versenden -->
        <serviceTask id="versende_ware" name="Ware versenden">
            <documentation>
                Automatisierter Versand über Logistiksystem
            </documentation>
        </serviceTask>
        
        <!-- Parallel Gateway: Zusammenführen -->
        <parallelGateway id="parallel_end" name="Zusammenführen"/>
        
        <!-- End Event: Bestellung abgeschlossen -->
        <endEvent id="end_erfolgreich" name="Bestellung abgeschlossen"/>
        
        <!-- End Event: Bestellung abgelehnt -->
        <endEvent id="end_abgelehnt" name="Bestellung abgelehnt"/>
        
        <!-- Sequence Flows -->
        <sequenceFlow sourceRef="start_bestellung" targetRef="pruefe_bestellung"/>
        <sequenceFlow sourceRef="pruefe_bestellung" targetRef="gueltig_pruefung"/>
        
        <sequenceFlow sourceRef="gueltig_pruefung" targetRef="pruefe_lager">
            <conditionExpression xsi:type="tFormalExpression">${bestellungGueltig == true}</conditionExpression>
        </sequenceFlow>
        
        <sequenceFlow sourceRef="gueltig_pruefung" targetRef="end_abgelehnt">
            <conditionExpression xsi:type="tFormalExpression">${bestellungGueltig == false}</conditionExpression>
        </sequenceFlow>
        
        <sequenceFlow sourceRef="pruefe_lager" targetRef="parallel_start"/>
        <sequenceFlow sourceRef="parallel_start" targetRef="erstelle_rechnung"/>
        <sequenceFlow sourceRef="parallel_start" targetRef="versende_ware"/>
        <sequenceFlow sourceRef="erstelle_rechnung" targetRef="parallel_end"/>
        <sequenceFlow sourceRef="versende_ware" targetRef="parallel_end"/>
        <sequenceFlow sourceRef="parallel_end" targetRef="end_erfolgreich"/>
        
    </process>
</definitions>

2. BPMN mit Java-Implementierung

import java.util.*;
import java.time.*;

// BPMN-Prozess-Engine (vereinfacht)
class BPMNProcessEngine {
    private Map<String, BPMNElement> elements = new HashMap<>();
    private Map<String, List<String>> sequenceFlows = new HashMap<>();
    private Set<String> completedElements = new HashSet<>();
    private Map<String, Object> processVariables = new HashMap<>();
    
    public void addElement(BPMNElement element) {
        elements.put(element.getId(), element);
    }
    
    public void addSequenceFlow(String from, String to) {
        sequenceFlows.computeIfAbsent(from, k -> new ArrayList<>()).add(to);
    }
    
    public void setVariable(String name, Object value) {
        processVariables.put(name, value);
    }
    
    public Object getVariable(String name) {
        return processVariables.get(name);
    }
    
    public void executeProcess(String startElementId) {
        System.out.println("=== BPMN-Prozess-Start ===");
        executeElement(startElementId);
    }
    
    private void executeElement(String elementId) {
        if (completedElements.contains(elementId)) {
            return;
        }
        
        BPMNElement element = elements.get(elementId);
        if (element == null) {
            throw new RuntimeException("Element nicht gefunden: " + elementId);
        }
        
        System.out.println("\n--- Ausführe: " + element.getName() + " (" + elementId + ") ---");
        
        // Element ausführen
        element.execute(this);
        completedElements.add(elementId);
        
        // Nächste Elemente finden
        List<String> nextElements = sequenceFlows.get(elementId);
        if (nextElements != null) {
            for (String nextId : nextElements) {
                executeElement(nextId);
            }
        }
    }
}

// BPMN-Element-Interface
interface BPMNElement {
    String getId();
    String getName();
    void execute(BPMNProcessEngine engine);
}

// Event-Implementierungen
class StartEvent implements BPMNElement {
    private String id;
    private String name;
    
    public StartEvent(String id, String name) {
        this.id = id;
        this.name = name;
    }
    
    @Override
    public String getId() { return id; }
    
    @Override
    public String getName() { return name; }
    
    @Override
    public void execute(BPMNProcessEngine engine) {
        System.out.println("Prozess gestartet: " + name);
        engine.setVariable("startTime", LocalDateTime.now());
    }
}

class EndEvent implements BPMNElement {
    private String id;
    private String name;
    
    public EndEvent(String id, String name) {
        this.id = id;
        this.name = name;
    }
    
    @Override
    public String getId() { return id; }
    
    @Override
    public String getName() { return name; }
    
    @Override
    public void execute(BPMNProcessEngine engine) {
        System.out.println("Prozess beendet: " + name);
        engine.setVariable("endTime", LocalDateTime.now());
        
        Duration duration = Duration.between(
            (LocalDateTime) engine.getVariable("startTime"),
            (LocalDateTime) engine.getVariable("endTime")
        );
        System.out.println("Prozessdauer: " + duration.toSeconds() + " Sekunden");
    }
}

// Task-Implementierungen
class UserTask implements BPMNElement {
    private String id;
    private String name;
    private String assignee;
    
    public UserTask(String id, String name, String assignee) {
        this.id = id;
        this.name = name;
        this.assignee = assignee;
    }
    
    @Override
    public String getId() { return id; }
    
    @Override
    public String getName() { return name; }
    
    @Override
    public void execute(BPMNProcessEngine engine) {
        System.out.println("User Task zugewiesen an: " + assignee);
        System.out.println("Aufgabe: " + name);
        
        // Simuliere Benutzerinteraktion
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        System.out.println("User Task abgeschlossen");
        engine.setVariable("userTask_" + id + "_completed", true);
    }
}

class ServiceTask implements BPMNElement {
    private String id;
    private String name;
    private String serviceClass;
    
    public ServiceTask(String id, String name, String serviceClass) {
        this.id = id;
        this.name = name;
        this.serviceClass = serviceClass;
    }
    
    @Override
    public String getId() { return id; }
    
    @Override
    public String getName() { return name; }
    
    @Override
    public void execute(BPMNProcessEngine engine) {
        System.out.println("Service Task: " + name);
        System.out.println("Service-Klasse: " + serviceClass);
        
        // Simuliere Service-Aufruf
        if (serviceClass.equals("LagerService")) {
            boolean verfuegbar = checkLagerverfuegbarkeit(engine);
            engine.setVariable("lagerVerfuegbar", verfuegbar);
            System.out.println("Lagerverfügbarkeit: " + verfuegbar);
        } else if (serviceClass.equals("RechnungService")) {
            String rechnungsNummer = generateRechnung(engine);
            engine.setVariable("rechnungsNummer", rechnungsNummer);
            System.out.println("Rechnung erstellt: " + rechnungsNummer);
        }
    }
    
    private boolean checkLagerverfuegbarkeit(BPMNProcessEngine engine) {
        // Simuliere Lagerprüfung
        return Math.random() > 0.3; // 70% Verfügbarkeit
    }
    
    private String generateRechnung(BPMNProcessEngine engine) {
        return "RG-" + System.currentTimeMillis();
    }
}

// Gateway-Implementierungen
class ExclusiveGateway implements BPMNElement {
    private String id;
    private String name;
    private Map<String, String> conditions;
    
    public ExclusiveGateway(String id, String name) {
        this.id = id;
        this.name = name;
        this.conditions = new HashMap<>();
    }
    
    public void addCondition(String targetId, String condition) {
        conditions.put(targetId, condition);
    }
    
    @Override
    public String getId() { return id; }
    
    @Override
    public String getName() { return name; }
    
    @Override
    public void execute(BPMNProcessEngine engine) {
        System.out.println("Exclusive Gateway: " + name);
        
        // Bedingung auswerten
        boolean bestellungGueltig = (boolean) engine.getVariable("bestellungGueltig");
        
        System.out.println("Bedingung 'bestellungGueltig': " + bestellungGueltig);
        
        // Entscheidung treffen
        if (bestellungGueltig) {
            engine.setVariable("gateway_decision_" + id, "gueltig");
        } else {
            engine.setVariable("gateway_decision_" + id, "ungueltig");
        }
    }
}

class ParallelGateway implements BPMNElement {
    private String id;
    private String name;
    
    public ParallelGateway(String id, String name) {
        this.id = id;
        this.name = name;
    }
    
    @Override
    public String getId() { return id; }
    
    @Override
    public String getName() { return name; }
    
    @Override
    public void execute(BPMNProcessEngine engine) {
        System.out.println("Parallel Gateway: " + name);
        
        if (name.contains("starten")) {
            System.out.println("Parallele Ausführung gestartet");
            engine.setVariable("parallel_branches_active", true);
        } else {
            System.out.println("Parallele Ausführung zusammengeführt");
            engine.setVariable("parallel_branches_active", false);
        }
    }
}

// BPMN-Demo
public class BPMDemo {
    public static void main(String[] args) {
        System.out.println("=== BPMN Prozessmodellierung Demo ===");
        
        // Prozess-Engine erstellen
        BPMNProcessEngine engine = new BPMNProcessEngine();
        
        // BPMN-Elemente erstellen
        StartEvent start = new StartEvent("start_bestellung", "Bestellung eingegangen");
        UserTask pruefung = new UserTask("pruefe_bestellung", "Bestellung prüfen", "sachbearbeiter");
        ExclusiveGateway gueltigCheck = new ExclusiveGateway("gueltig_pruefung", "Bestellung gültig?");
        ServiceTask lagerPruefung = new ServiceTask("pruefe_lager", "Lagerbestand prüfen", "LagerService");
        ParallelGateway parallelStart = new ParallelGateway("parallel_start", "Parallel starten");
        UserTask rechnung = new UserTask("erstelle_rechnung", "Rechnung erstellen", "finanzabteilung");
        ServiceTask versand = new ServiceTask("versende_ware", "Ware versenden", "VersandService");
        ParallelGateway parallelEnd = new ParallelGateway("parallel_end", "Zusammenführen");
        EndEvent endErfolgreich = new EndEvent("end_erfolgreich", "Bestellung abgeschlossen");
        EndEvent endAbgelehnt = new EndEvent("end_abgelehnt", "Bestellung abgelehnt");
        
        // Elemente zur Engine hinzufügen
        engine.addElement(start);
        engine.addElement(pruefung);
        engine.addElement(gueltigCheck);
        engine.addElement(lagerPruefung);
        engine.addElement(parallelStart);
        engine.addElement(rechnung);
        engine.addElement(versand);
        engine.addElement(parallelEnd);
        engine.addElement(endErfolgreich);
        engine.addElement(endAbgelehnt);
        
        // Sequence Flows definieren
        engine.addSequenceFlow("start_bestellung", "pruefe_bestellung");
        engine.addSequenceFlow("pruefe_bestellung", "gueltig_pruefung");
        
        // Bedingte Flows für Exclusive Gateway
        engine.addSequenceFlow("gueltig_pruefung", "pruefe_lager");
        engine.addSequenceFlow("gueltig_pruefung", "end_abgelehnt");
        
        engine.addSequenceFlow("pruefe_lager", "parallel_start");
        engine.addSequenceFlow("parallel_start", "erstelle_rechnung");
        engine.addSequenceFlow("parallel_start", "versende_ware");
        engine.addSequenceFlow("erstelle_rechnung", "parallel_end");
        engine.addSequenceFlow("versende_ware", "parallel_end");
        engine.addSequenceFlow("parallel_end", "end_erfolgreich");
        
        // Prozessvariablen setzen
        engine.setVariable("bestellungGueltig", true);
        
        // Prozess ausführen
        engine.executeProcess("start_bestellung");
        
        // Prozessstatistik
        System.out.println("\n=== Prozessstatistik ===");
        System.out.println("Abgeschlossene Elemente: " + engine.completedElements.size());
        
        // Zweiter Durchlauf mit ungültiger Bestellung
        System.out.println("\n=== Zweiter Durchlauf (ungültige Bestellung) ===");
        BPMNProcessEngine engine2 = new BPMNProcessEngine();
        
        // Elemente wieder hinzufügen
        Arrays.asList(start, pruefung, gueltigCheck, endAbgelehnt).forEach(engine2::addElement);
        engine2.addSequenceFlow("start_bestellung", "pruefe_bestellung");
        engine2.addSequenceFlow("pruefe_bestellung", "gueltig_pruefung");
        engine2.addSequenceFlow("gueltig_pruefung", "end_abgelehnt");
        
        engine2.setVariable("bestellungGueltig", false);
        engine2.executeProcess("start_bestellung");
    }
}

3. BPMN-Datenobjekte und Artifacts

// BPMN-Datenobjekte
class DataObject {
    private String id;
    private String name;
    private Object value;
    private String dataType;
    
    public DataObject(String id, String name, String dataType) {
        this.id = id;
        this.name = name;
        this.dataType = dataType;
    }
    
    // Getter und Setter
    public String getId() { return id; }
    public String getName() { return name; }
    public Object getValue() { return value; }
    public void setValue(Object value) { this.value = value; }
    public String getDataType() { return dataType; }
    
    @Override
    public String toString() {
        return "DataObject{" + name + "=" + value + " (" + dataType + ")}";
    }
}

// BPMN-Gruppe
class BPMNGroup {
    private String id;
    private String name;
    private List<String> elementIds;
    private String categoryValue;
    
    public BPMNGroup(String id, String name, String categoryValue) {
        this.id = id;
        this.name = name;
        this.categoryValue = categoryValue;
        this.elementIds = new ArrayList<>();
    }
    
    public void addElement(String elementId) {
        elementIds.add(elementId);
    }
    
    // Getter
    public String getId() { return id; }
    public String getName() { return name; }
    public List<String> getElementIds() { return new ArrayList<>(elementIds); }
    public String getCategoryValue() { return categoryValue; }
}

// BPMN-Text Annotation
class TextAnnotation {
    private String id;
    private String text;
    private String format;
    
    public TextAnnotation(String id, String text) {
        this.id = id;
        this.text = text;
        this.format = "text/plain";
    }
    
    // Getter
    public String getId() { return id; }
    public String getText() { return text; }
    public String getFormat() { return format; }
}

// Erweiterte BPMN-Engine mit Datenobjekten
class AdvancedBPMNEngine extends BPMNProcessEngine {
    private Map<String, DataObject> dataObjects = new HashMap<>();
    private Map<String, BPMNGroup> groups = new HashMap<>();
    private Map<String, TextAnnotation> annotations = new HashMap<>();
    
    public void addDataObject(DataObject dataObject) {
        dataObjects.put(dataObject.getId(), dataObject);
    }
    
    public void addGroup(BPMNGroup group) {
        groups.put(group.getId(), group);
    }
    
    public void addAnnotation(TextAnnotation annotation) {
        annotations.put(annotation.getId(), annotation);
    }
    
    public DataObject getDataObject(String id) {
        return dataObjects.get(id);
    }
    
    public void setDataObjectValue(String id, Object value) {
        DataObject dataObject = dataObjects.get(id);
        if (dataObject != null) {
            dataObject.setValue(value);
        }
    }
    
    public void printProcessInfo() {
        System.out.println("\n=== Prozess-Informationen ===");
        
        System.out.println("\nDatenobjekte:");
        dataObjects.values().forEach(System.out::println);
        
        System.out.println("\nGruppen:");
        groups.values().forEach(group -> {
            System.out.println(group.getName() + " (" + group.getCategoryValue() + "): " + 
                             group.getElementIds());
        });
        
        System.out.println("\nAnnotationen:");
        annotations.values().forEach(annotation -> 
            System.out.println(annotation.getText()));
    }
}

// Demo mit erweiterten BPMN-Features
public class AdvancedBPMDemo {
    public static void main(String[] args) {
        System.out.println("=== Erweiterte BPMN Demo ===");
        
        AdvancedBPMNEngine engine = new AdvancedBPMNEngine();
        
        // BPMN-Elemente
        StartEvent start = new StartEvent("start_antrag", "Antrag eingegangen");
        UserTask pruefung = new UserTask("pruefe_antrag", "Antrag prüfen", "sachbearbeiter");
        ServiceTask pruefungService = new ServiceTask("automatische_pruefung", 
                                                     "Automatische Prüfung", 
                                                     "PruefService");
        EndEvent endGenehmigt = new EndEvent("end_genehmigt", "Antrag genehmigt");
        EndEvent endAbgelehnt = new EndEvent("end_abgelehnt", "Antrag abgelehnt");
        
        // Elemente hinzufügen
        Arrays.asList(start, pruefung, pruefungService, endGenehmigt, endAbgelehnt)
              .forEach(engine::addElement);
        
        // Datenobjekte
        DataObject antragData = new DataObject("antrag_daten", "Antragsdaten", "Antrag");
        DataObject pruefungsErgebnis = new DataObject("pruefung_ergebnis", 
                                                   "Prüfungsergebnis", 
                                                   "Boolean");
        
        engine.addDataObject(antragData);
        engine.addDataObject(pruefungsErgebnis);
        
        // Gruppe für Prüfungsprozess
        BPMNGroup pruefungsGruppe = new BPMNGroup("pruefungsgruppe", 
                                                 "Prüfungsprozess", 
                                                 "Prüfung");
        pruefungsGruppe.addElement("pruefe_antrag");
        pruefungsGruppe.addElement("automatische_pruefung");
        engine.addGroup(pruefungsGruppe);
        
        // Annotation
        TextAnnotation hinweis = new TextAnnotation("hinweis", 
            "Wichtig: Alle Prüfungen müssen dokumentiert werden");
        engine.addAnnotation(hinweis);
        
        // Sequence Flows
        engine.addSequenceFlow("start_antrag", "pruefe_antrag");
        engine.addSequenceFlow("pruefe_antrag", "automatische_pruefung");
        engine.addSequenceFlow("automatische_pruefung", "end_genehmigt");
        
        // Datenobjekte initialisieren
        engine.setDataObjectValue("antrag_daten", "Antrag #12345");
        engine.setDataObjectValue("pruefung_ergebnis", true);
        
        // Prozess ausführen
        engine.executeProcess("start_antrag");
        
        // Prozess-Informationen ausgeben
        engine.printProcessInfo();
    }
}

BPMN-Elemente Übersicht

Events (Ereignisse)

Typ	Symbol	Beschreibung	Beispiel
Start Event	Kreis (dünn)	Prozessbeginn	Bestellung eingegangen
End Event	Kreis (dick)	Prozessende	Bestellung abgeschlossen
Intermediate Event	Kreis (doppelt)	Zwischenereignis	Timer ausgelöst
Boundary Event	Kreis (angeheftet)	Fehlerereignis	Timeout bei Task
Message Event	Briefumschlag	Nachricht	Nachricht empfangen
Timer Event	Uhrzeit	Zeitbasiert	Wartezeit abgelaufen

Tasks (Aufgaben)

Typ	Symbol	Beschreibung	Beispiel
User Task	Rechteck mit Person	Manuelle Aufgabe	Formular ausfüllen
Service Task	Rechteck mit Zahnrad	Automatisierte Aufgabe	Datenbank speichern
Script Task	Rechteck mit Skript	Skript-Ausführung	Berechnung durchführen
Manual Task	Rechteck mit Hand	Manuell ohne IT	Paket verpacken
Receive Task	Rechteck mit Brief	Warten auf Nachricht	Auf Bestätigung warten
Send Task	Rechteck mit Brief	Nachricht senden	E-Mail senden

Gateways (Verzweigungen)

Typ	Symbol	Beschreibung	Beispiel
Exclusive Gateway	Diamant (X)	Exklusive Verzweigung	Ja/Nein Entscheidung
Parallel Gateway	Diamant (+)	Parallele Ausführung	Gleichzeitig prüfen
Inclusive Gateway	Diamant (O)	Inklusive Verzweigung	Mehrere Bedingungen
Complex Gateway	Diamand (*)	Komplexe Logik	Mehrfachbedingungen

Swimlanes (Schwimmbahnen)

Element	Beschreibung	Verwendung
Pool	Prozesscontainer	Ganzer Prozess einer Organisation
Lane	Verantwortlichkeitsbereich	Abteilung oder Rolle
Participant	Externer Partner	Kunde, Lieferant

BPMN-XML-Struktur

Grundstruktur

<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL">
    <process id="prozess_id" name="Prozessname">
        <!-- BPMN-Elemente -->
        <startEvent id="start" name="Start"/>
        <sequenceFlow sourceRef="start" targetRef="task1"/>
        <userTask id="task1" name="Aufgabe"/>
        <endEvent id="end" name="Ende"/>
    </process>
</definitions>

Erweiterte Struktur

<definitions>
    <process id="prozess">
        <!-- Pools und Lanes -->
        <participant id="participant1" name="Organisation"/>
        <lane id="lane1" name="Abteilung">
            <flowNodeRef>task1</flowNodeRef>
        </lane>
        
        <!-- Datenobjekte -->
        <dataObject id="data1" name="Daten" itemSubjectRef="itemDef1"/>
        
        <!-- Artifacts -->
        <textAnnotation id="annotation1">
            <text>Hinweis</text>
        </textAnnotation>
    </process>
</definitions>

BPMN-Best Practices

Prozess-Design

Klarheit: Prozesse einfach und verständlich halten
Konsistenz: Einheitliche Notation und Benennung
Vollständigkeit: Alle relevanten Pfade modellieren
Validierung: Regelmäßige Überprüfung der Modelle

Namenskonventionen

Element-IDs: Technische Identifikatoren (keine Leerzeichen)
Element-Namen: Menschlich lesbare Beschreibungen
Prozess-Variablen: CamelCase mit technischem Fokus
Datenobjekte: Beschreibende Namen mit Datentyp

Performance-Optimierung

Parallelisierung: Möglichkeiten für parallele Ausführung nutzen
Automatisierung: Manuelle Tasks minimieren
Simplifikation: Unnötige Gateways vermeiden
Wiederverwendung: Sub-Prozesse für wiederkehrende Abläufe

Vorteile und Nachteile

Vorteile von BPMN

Standardisierung: Einheitliche Notation weltweit
Tool-Unterstützung: Viele BPMN-Tools verfügbar
Automatisierung: Direkte Umsetzung in BPM-Systemen
Kommunikation: Gemeinsames Verständnis aller Stakeholder
Analyse: Systematische Prozessverbesserung

Nachteile

Komplexität: Lernkurve für komplexe Prozesse
Overhead: Detaillierte Modellierung kann aufwändig sein
Interpretation: Verschiedene Tools können leicht abweichen
Wartung: Modelle müssen aktuell gehalten werden

Häufige Prüfungsfragen

Was ist der Unterschied zwischen Pool und Lane? Pool ist der gesamte Prozesscontainer, Lane ist ein Verantwortlichkeitsbereich innerhalb eines Pools.
Erklären Sie die verschiedenen Gateway-Typen! Exclusive (exklusiv), Parallel (gleichzeitig), Inclusive (mehrere Bedingungen), Complex (komplexe Logik).
Wann verwendet man User Task vs Service Task? User Task für manuelle Aufgaben durch Benutzer, Service Task für automatisierte Systemaufgaben.
Was ist der Zweck von BPMN-Datenobjekten? Darstellung von Informationen, die im Prozess fließen und verarbeitet werden.

BPMN Grundlagen: Prozessmodellierung mit Events, Gateways, Tasks, Pools & Lanes

BPMN Grundlagen: Prozessmodellierung mit Events, Gateways, Tasks, Pools & Lanes

In a Nutshell

Kompakte Fachbeschreibung

Events (Ereignisse)

Tasks (Aufgaben)

Gateways (Gateways/Verzweigungen)

Swimlanes (Schwimmbahnen)

Prüfungsrelevante Stichpunkte

Kernkomponenten

Praxisbeispiele

1. BPMN-Prozess: Bestellabwicklung

2. BPMN mit Java-Implementierung

3. BPMN-Datenobjekte und Artifacts

BPMN-Elemente Übersicht

Events (Ereignisse)

Tasks (Aufgaben)

Gateways (Verzweigungen)

Swimlanes (Schwimmbahnen)

BPMN-XML-Struktur

Grundstruktur

Erweiterte Struktur

BPMN-Best Practices

Prozess-Design

Namenskonventionen

Performance-Optimierung

Vorteile und Nachteile

Vorteile von BPMN

Nachteile

Häufige Prüfungsfragen

Wichtigste Quellen

Ähnliche Beiträge

BPMN Grundlagen: Business Process Model and Notation

BPMN Grundlagen: Prozessmodellierung, Events, Gateways & Tasks

Aktivitätsdiagramm (UML) einfach erklärt: Prozessmodellierung, Workflow

BPMN Grundlagen: Prozessmodellierung mit Events, Gateways, Tasks, Pools & Lanes

IRC-Mania Die Seite rund um Sicherheit und Programmierung

In a Nutshell

Kompakte Fachbeschreibung

Events (Ereignisse)

Tasks (Aufgaben)

Gateways (Gateways/Verzweigungen)

Swimlanes (Schwimmbahnen)

Prüfungsrelevante Stichpunkte

Kernkomponenten

Praxisbeispiele

1. BPMN-Prozess: Bestellabwicklung

2. BPMN mit Java-Implementierung

3. BPMN-Datenobjekte und Artifacts

IRC-Security.de

BPMN-Elemente Übersicht

Events (Ereignisse)

Tasks (Aufgaben)

Gateways (Verzweigungen)

Swimlanes (Schwimmbahnen)

BPMN-XML-Struktur

Grundstruktur

Erweiterte Struktur

BPMN-Best Practices

Prozess-Design

Namenskonventionen

Performance-Optimierung

Vorteile und Nachteile

Vorteile von BPMN

Nachteile

Häufige Prüfungsfragen

Wichtigste Quellen

Premium VPS Hosting

Ähnliche Beiträge

BPMN Grundlagen: Business Process Model and Notation

BPMN Grundlagen: Prozessmodellierung, Events, Gateways & Tasks

Aktivitätsdiagramm (UML) einfach erklärt: Prozessmodellierung, Workflow