Seminar Flowable Intensivseminar: Entwicklung, Integration und Open Source

Das Intensivformat führt technische Teams von der Engine- und Projektstruktur bis zu einer integrierten, getesteten und auslieferbaren Anwendung. Open-Source-Komponenten und Plattformfunktionen werden gemeinsam betrachtet, damit Architekturentscheidungen nicht an Produktgrenzen scheitern.

Inhaltsverzeichnis

1. Einordnung und Einsatzfelder
2. Zielgruppe
3. Voraussetzungen
4. Lernziele
5. Seminarinhalte
   • Tag 1: Open Source, Engines und Spring-Boot-Projekt
   • Tag 2: Java APIs, Erweiterungen und Laufzeitlogik
   • Tag 3: REST, Headless und Integrationsmuster
   • Tag 4: Events, Worker und Benutzeroberflächen-Erweiterung
   • Tag 5: Tests, CI/CD und Abschlussprojekt
6. Praxisprojekt
7. Arbeitsweise im Seminar

Einordnung und Einsatzfelder

Jeder Tag erweitert dasselbe Projekt. Dadurch werden Java- und REST-Erweiterungen, Services, Ereignisse, Datenmapping, Tests und Deployment nicht als Einzelübungen, sondern als zusammenhängender Entwicklungslebenszyklus erlebt.

Zielgruppe

Java-Entwickler, Integrationsentwickler, Softwarearchitekten, technische Consultants und DevOps Engineers.

Voraussetzungen

Sichere Java- und Spring-Grundkenntnisse sowie Erfahrung mit REST, Build-Werkzeugen und Versionsverwaltung. BPMN-Grundlagen sind hilfreich.

Lernziele

• Flowable-Engines und Plattformkomponenten in Spring-Boot-Projekten einsetzen.
• Java APIs, Listener, Delegates und eigene Services sauber erweitern.
• REST-, Event- und Worker-Integrationen robust implementieren.
• Automatisierte Tests für Modelle, Java-Code und Schnittstellen erstellen.
• Anwendung und Modelle über eine kontrollierte CI/CD-Strecke bereitstellen.

Seminarinhalte

Tag 1: Open Source, Engines und Spring-Boot-Projekt

1. Schritt 1: Engine-Architektur, Services, Datenbanktabellen und Abhängigkeiten von BPMN, CMMN, DMN, Form und Event Registry einordnen.
2. Schritt 2: Ein Spring-Boot-Projekt mit den benötigten Startern, Datenbankkonfiguration und Profilen aufsetzen.
3. Schritt 3: Modelle automatisch bereitstellen, Prozess- und Fallinstanzen starten und Aufgaben über Java Services bearbeiten.
4. Schritt 4: Transaktionen, Historie, Mandantenbezug und Konfigurationsgrenzen im eingebetteten Betrieb nachvollziehen.
5. Schritt 5: Projektstruktur, Paketgrenzen, Logging und lokale Entwicklungsinfrastruktur für die folgenden Tage vorbereiten.

Tag 2: Java APIs, Erweiterungen und Laufzeitlogik

1. Schritt 1: Repository-, Runtime-, Task-, History- und Management-Services gezielt einsetzen und Abfragen performant gestalten.
2. Schritt 2: Java Delegates, Listener, Ausdrücke, eigene Service Tasks und Spring Beans mit klaren Schnittstellen implementieren.
3. Schritt 3: Variablen, typisierte Daten, Dokumentreferenzen und Fehler zwischen Modell und Java-Code kontrolliert übergeben.
4. Schritt 4: Asynchrone Jobs, Transaktionsgrenzen, Retry-Verhalten und technische Fehlerbehandlung im Code berücksichtigen.
5. Schritt 5: Erweiterungen paketieren, automatisch konfigurieren und von nichtöffentlichen Implementierungsdetails entkoppeln.

Tag 3: REST, Headless und Integrationsmuster

1. Schritt 1: Bestehende REST APIs für Deployments, Instanzen, Aufgaben, Variablen und Abfragen sicher verwenden.
2. Schritt 2: Eigene REST Controller beziehungsweise API-Fassaden mit Validierung, Fehlerformat und Berechtigungsprüfung ergänzen.
3. Schritt 3: Synchrone Services, Service Registry, Connectors und externe Systeme mit Mapping, Authentisierung und Timeouts anbinden.
4. Schritt 4: Idempotenz, Korrelation, Retries und Kompensation für robuste Integrationsabläufe umsetzen.
5. Schritt 5: Eine Headless-Anwendung mit klarer Trennung zwischen Workflow-Service, Fach-API und Benutzeroberfläche entwerfen.

Tag 4: Events, Worker und Benutzeroberflächen-Erweiterung

1. Schritt 1: Event- und Kanalmodelle erstellen und Prozess- beziehungsweise Fallinstanzen über Geschäftsschlüssel korrelieren.
2. Schritt 2: Externe Worker oder entkoppelte Services für langlaufende und skalierbare Verarbeitung einsetzen.
3. Schritt 3: Duplikate, Reihenfolge, Dead-Letter und Wiederanlauf in ereignisgesteuerten Abläufen beherrschen.
4. Schritt 4: Eigene Formular- oder Work-Komponenten mit React-Schnittstellen einordnen und einen kleinen Erweiterungspunkt implementieren.
5. Schritt 5: Observability für Services, Events, Jobs und Benutzeraktionen mit Metriken, Logs und Auditdaten ergänzen.

Tag 5: Tests, CI/CD und Abschlussprojekt

1. Schritt 1: JUnit- und Spring-Tests für Prozesse, Fälle, Entscheidungen, Timer und asynchrone Jobs aufbauen.
2. Schritt 2: Mocks, Contract Tests und Integrationstests für REST-Dienste, Events und Worker einrichten.
3. Schritt 3: Modelle, Java-Artefakte und Frontend-Bundles versionieren, validieren und als reproduzierbares Release paketieren.
4. Schritt 4: Eine CI/CD-Pipeline mit Qualitätsgates, Deployment, Smoke Test und Rollback-Schritt entwerfen.
5. Schritt 5: Das Abschlussprojekt ausführen, Fehlerbilder provozieren, Diagnose und Wiederanlauf durchführen und die Architektur begründen.

Praxisprojekt

Im Abschlussprojekt entsteht eine Spring-Boot-basierte Flowable-Anwendung mit BPMN, CMMN oder DMN, eigener Java-Erweiterung, REST-Schnittstelle, Eventfluss, automatisierten Tests und einer Releasepipeline.

• Projekt und Modelle aufsetzen.
• Java- und REST-Erweiterung implementieren.
• Event- oder Worker-Integration ergänzen.
• Test- und Deploymentpipeline fertigstellen.

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.