Seminar Flowable Java API und Spring Boot Entwicklung

Die Schulung richtet sich auf produktionsfähige Java-Erweiterungen statt auf isolierte Codebeispiele. Modell und Code werden durch klare Datenverträge verbunden, öffentliche APIs werden von internen Implementierungen getrennt und technische Fehler werden bewusst an Prozess- oder Fallmodelle zurückgegeben.

Inhaltsverzeichnis

1. Einordnung und Einsatzfelder
2. Zielgruppe
3. Voraussetzungen
4. Lernziele
5. Seminarinhalte
   • Tag 1: Projekt, Engines und öffentliche Services
   • Tag 2: Delegates, Listener und eigene Erweiterungen
   • Tag 3: Transaktionen, Jobs und Integration
   • Tag 4: Tests, Packaging und Produktionsreife
6. Praxisprojekt
7. Arbeitsweise im Seminar

Einordnung und Einsatzfelder

Das Projekt umfasst eingebettete Engines, Java Services, eigene Erweiterungen, asynchrone Verarbeitung, REST und automatisierte Tests. Packaging, Konfiguration und Beobachtbarkeit schließen den Entwicklungsweg ab.

Zielgruppe

Java-Entwickler, Softwarearchitekten, technische Consultants und Integrationsentwickler.

Voraussetzungen

Sichere Java- und Spring-Grundkenntnisse, Maven oder Gradle sowie grundlegende BPMN-Kenntnisse.

Lernziele

• Flowable-Engines und Services in Spring Boot konfigurieren und verwenden.
• Abfragen, Variablen und Laufzeitoperationen über öffentliche APIs umsetzen.
• Delegates, Listener und eigene Service Tasks wartbar entwickeln.
• Transaktionen, asynchrone Jobs und Fehlerpfade korrekt behandeln.
• Erweiterungen automatisiert testen, paketieren und betreibbar bereitstellen.

Seminarinhalte

Tag 1: Projekt, Engines und öffentliche Services

1. Schritt 1: Ein Spring-Boot-Projekt mit passenden Flowable-Startern, Datenbank, Profilen und automatischem Modelldeployment aufsetzen.
2. Schritt 2: Process Engine, CMMN-, DMN- und weitere Engines sowie ihre Service-Schnittstellen in der Architektur einordnen.
3. Schritt 3: Repository-, Runtime-, Task-, History- und Management-Services für typische Laufzeitoperationen verwenden.
4. Schritt 4: Abfragen mit Filtern, Paging, Mandant und Geschäftsreferenzen effizient formulieren.
5. Schritt 5: Variablen, Typen, Transienten und historische Daten anhand von Lebensdauer und Speicherbedarf auswählen.

Tag 2: Delegates, Listener und eigene Erweiterungen

1. Schritt 1: Java Delegates und Spring Beans mit klaren Ein- und Ausgaben an Service Tasks binden.
2. Schritt 2: Execution-, Task- und Event-Listener für Querschnittsfunktionen einsetzen, ohne Fachlogik zu verstecken.
3. Schritt 3: Eigene Service Tasks beziehungsweise Palette-Erweiterungen mit Konfiguration und Validierung entwerfen.
4. Schritt 4: Fehler, BPMN Errors und technische Exceptions passend aus Java-Code in das Modell zurückgeben.
5. Schritt 5: Konfigurationsklassen, Auto-Configuration und Modulgrenzen für wiederverwendbare Erweiterungspakete aufbauen.

Tag 3: Transaktionen, Jobs und Integration

1. Schritt 1: Transaktionsgrenzen zwischen Engine, Datenbank und externen Systemen nachvollziehen und Seiteneffekte minimieren.
2. Schritt 2: Asynchrone Fortsetzungen, Timer, Job Executor, Retries und Dead-Letter-Verarbeitung gezielt konfigurieren.
3. Schritt 3: Idempotenz und Korrelation für wiederholbare oder langlaufende Integrationen implementieren.
4. Schritt 4: Eigene REST Controller und fachliche API-Fassaden mit Spring Security, Validierung und Fehlerformat ergänzen.
5. Schritt 5: Metriken, strukturierte Logs und technische Auditinformationen in Erweiterungen integrieren.

Tag 4: Tests, Packaging und Produktionsreife

1. Schritt 1: Spring-basierte Tests für Prozesse, Fälle, Entscheidungen und Java-Erweiterungen mit kontrollierter Testzeit aufbauen.
2. Schritt 2: Timer und asynchrone Jobs deterministisch ausführen und externe Systeme durch Mocks oder Testcontainer ersetzen.
3. Schritt 3: Negative Tests, Wiederanlauf, Parallelität und Transaktionsfehler als feste Regressionstests ergänzen.
4. Schritt 4: Anwendung, Konfiguration und Modelle paketieren und über Profile für mehrere Umgebungen bereitstellen.
5. Schritt 5: Codequalität, API-Kompatibilität, Sicherheit, Performance und Betriebsdokumentation anhand einer Produktionscheckliste prüfen.

Praxisprojekt

Im Praxisprojekt entsteht eine Spring-Boot-Anwendung mit Prozess- und Fallmodell, eigener Service-Task-Implementierung, Listener, REST-Endpunkt, asynchroner Verarbeitung und automatisierten Tests.

• Projekt und Enginekonfiguration aufsetzen.
• Java-Erweiterungen implementieren.
• Async- und Fehlerpfade ergänzen.
• Tests und Produktionscheck durchführen.

Arbeitsweise im Seminar

Die Inhalte werden in kurzen fachlichen Einführungen, Live-Demonstrationen und aufeinander aufbauenden Übungen erarbeitet. Jeder Arbeitsschritt wird zunächst begründet, anschließend am System umgesetzt und danach anhand eines prüfbaren Ergebnisses kontrolliert. Fehlerbilder und alternative Lösungswege werden bewusst einbezogen.