diff --git a/README.md b/README.md index 7057d3f..a53b036 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,7 @@ This repository contains the source code as also build scripts to setup an Dynam **Topics** +- [Imixs Worklflow Engine - BPMN 2.0](./doc/IMIXS_WORKFLOW_EN.md) - [Retrieval Augmented Generation (RAG)](./doc/RAG.md) - [A2A Agent Integration](./doc/A2A.md) - [Knowledge DB (Apache Cassandra)](./doc/RAG_CASSANDRA.md) diff --git a/doc/IMIXS_WORKFLOW_DE.md b/doc/IMIXS_WORKFLOW_DE.md new file mode 100644 index 0000000..e37e75b --- /dev/null +++ b/doc/IMIXS_WORKFLOW_DE.md @@ -0,0 +1,437 @@ +# Technical Paper: Imixs Workflow Engine + +## Eine umfassende Analyse der Open-Source BPMN 2.0 Workflow-Engine + +**Version:** 1.0 +**Datum:** Juni 2025 +**Autor:** Technische Dokumentation + +--- + +## Executive Summary + +Die Imixs Workflow Engine ist eine leistungsstarke Open-Source BPMN 2.0 Workflow-Engine, die auf der Jakarta EE Plattform basiert und speziell für human-zentrierte Geschäftsprozesse entwickelt wurde. Mit ihrer Micro-Kernel-Architektur, fortschrittlichen Sicherheitskonzepten und nativen Jakarta EE Integration bietet sie eine robuste Lösung für moderne Business Process Management (BPM) Anforderungen. + +### Kernmerkmale + +- **BPMN 2.0 Standard-Konformität** mit event-driven Modellierungskonzept +- **Micro-Kernel-Architektur** mit Plugin- und Adapter-System +- **Enterprise-Security** mit multi-level Zugriffskontrolle +- **Jakarta EE Native** für Skalierbarkeit und Vendor-Unabhängigkeit + +--- + +## 1. Einführung + +### 1.1 Projektüberblick + +Imixs-Workflow ist eine Open-Source BPMN 2.0 Workflow-Engine mit moderner API und Plugin-Architektur, die Low-Code-Modellierung, Enterprise-Sicherheit und Microservice-Deployment für Java Business-Anwendungen bietet. Das Projekt konzentriert sich auf human-zentrierte Workflows und unterscheidet sich von task-orientierten Engines durch seinen event-basierten Ansatz. + +### 1.2 Architektonische Vision + +Das Ziel des Open-Source-Projekts ist es, die Komplexität von Business-Anwendungen zu reduzieren, indem ein flexibles Framework zur Implementierung von Geschäftslogik auf Basis des BPMN 2.0 Standards bereitgestellt wird. Die Engine ermöglicht es, Geschäftslogik modellgetrieben zu implementieren, wodurch Änderungen ohne Code-Anpassungen möglich werden. + +--- + +## 2. BPMN 2.0 Modellierung + +### 2.1 BPMN 2.0 Standard-Unterstützung + +Imixs-Workflow unterstützt den BPMN 2.0 Standard und vereinfacht den Weg zu einem Low-Code-zentrierten Business Process Management. Die Business Process Model and Notation (BPMN 2.0) ist ein offener Standard zur Beschreibung von Geschäftsprozessen, die in Diagramm-Editoren visualisiert und von BPMN 2.0-konformen Prozess-Engines ausgeführt werden können. + +### 2.2 Event-driven Modellierungskonzept + +Die Imixs-Engine implementiert ein einzigartiges event-getriebenes Modellierungskonzept: + +- **Tasks** repräsentieren verschiedene Zustände eines Geschäftsprozesses +- **Events** steuern Übergänge zwischen Zuständen +- **Gateways** ermöglichen komplexe Geschäftsregeln und Entscheidungen + +Imixs-Workflow ist eine human-zentrierte Business Process Management Lösung, die ein event-getriebenes Modellierungskonzept verwendet. Innerhalb des Prozessflusses können Events entweder von menschlichen Akteuren oder Services bei jeder Aufgabe ausgelöst werden. + +### 2.3 Imixs-BPMN Modeler + +Das Projekt stellt mit Imixs-BPMN einen spezialisierten Modeler zur Verfügung: + +- **Open-BPMN Basis**: Imixs-BPMN basiert auf dem Open Source Projekt Open-BPMN und erweitert dieses Framework mit den Aspekten eines human-zentrierten Workflow-Modells, das auf der Imixs-Workflow Engine ausführbar ist +- **Multi-Platform-Unterstützung**: Integration in Visual Studio Code, Eclipse oder Web Browser +- **Erweiterte BPMN-Elemente**: Spezielle Event-Elemente für Workflow-spezifische Funktionalitäten + +### 2.4 Deployment und Model Management + +Die Imixs-Workflow Rest API bietet eine komfortable Möglichkeit, ein BPMN-Modell hochzuladen oder den Deployment-Status von BPMN-Modellen zu überprüfen. Models können sowohl über die REST API als auch programmatisch deployed werden: + +```java +import org.imixs.workflow.bpmn.BPMNModel; +import org.imixs.workflow.bpmn.BPMNParser; + +BPMNModel model = BPMNParser.parseModel(file.getData(), "UTF-8"); +modelService.importBPMNModel(model); +``` + +--- + +## 3. Micro-Kernel-Architektur + +### 3.1 Architektonische Grundlagen + +Die Imixs-Workflow Adapter API ist Teil des Microkernel-Architekturmusters und bietet einen Erweiterungsmechanismus zur Anpassung des Verarbeitungslebenszyklus eines BPMN Events. Diese Architektur folgt dem Hexagonal Architecture Pattern und ermöglicht eine klare Trennung zwischen Kernlogik und externen Komponenten. + +### 3.2 Plugin-System + +Das Plugin-System bildet das Herzstück der erweiterbaren Architektur: + +#### 3.2.1 Plugin API + +Die Imixs Plugin-API ist das allgemeine Erweiterungskonzept der Imixs-Workflow Engine. Plugins implementieren drei Callback-Methoden: + +```java +public void init(WorkflowContext workflowContext) throws PluginException; +public ItemCollection run(ItemCollection document, ItemCollection event) throws PluginException; +public void close(boolean rollbackTransaction) throws PluginException; +``` + +#### 3.2.2 Two-Phase Commit Konzept + +Die Imixs Plugin-API definiert drei Callback-Methoden, die von der Workflow Engine in einer einzigen Transaktion während des Verarbeitungslebenszyklus aufgerufen werden. Dies ist das Konzept eines Two-Phase Commit (2PC). + +### 3.3 Adapter-System + +Das Adapter-System ergänzt das Plugin-System für spezifischere Anwendungsfälle: + +#### 3.3.1 Signal Adapter + +- **Event-spezifische Bindung**: Im Unterschied zur Plugin API ist der SignalAdapter an ein einzelnes Event innerhalb eines BPMN 2.0 Modells gebunden. Dies ermöglicht eine feinere Konfiguration +- **Frühe Ausführung**: Ausführung vor dem Plugin-Verarbeitungslebenszyklus + +#### 3.3.2 Generic Adapter + +- **Modell-unabhängige Ausführung**: Allgemeine Geschäftslogik unabhängig vom BPMN-Modell +- **CDI-Integration**: Die Imixs-Workflow Adapter API unterstützt auch CDI. Auf diese Weise kann ein EJB oder eine Ressource durch die entsprechende CDI-Annotation in eine Adapter-Klasse injiziert werden + +### 3.4 Hexagonal Architecture Implementation + +Mit den zwei Interface-Definitionen 'Imixs-Plugin' und 'Imixs-Adapter' können Sie individuelle Funktionalitäten von der Kern-Geschäftslogik trennen, die von der Imixs-Workflow Engine verwaltet wird. Diese Architektur bietet: + +- **Ports**: Interface-Definitionen für Erweiterungspunkte +- **Adapters**: Konkrete Implementierungen der Interfaces +- **Kern-Business-Logik**: Geschützt im inneren Hexagon + +--- + +## 4. Security-Konzept + +### 4.1 Multi-Level Security Model + +Imixs-Workflow bietet Ihnen ein leistungsstarkes Sicherheitsmodell zum Schutz Ihrer Geschäftsdaten basierend auf individuellen Workflow-Modellen. Die Imixs-Workflow Engine unterstützt Sie mit einem Multi-Level-Sicherheitsmodell für eine feingliedrige Zugriffskontrolle. + +### 4.2 Access Control Lists (ACL) + +Das ACL-System ermöglicht: + +- **Status-spezifische Berechtigung**: Sie können eine Access Control List (ACL) für jeden einzelnen Prozessstatus innerhalb Ihres Workflow-Modells definieren. Die ACL wird automatisch von der Imixs-Workflow Engine auf eine laufende Prozessinstanz angewendet +- **Laufzeit-Anpassung**: Sicherheitseinstellungen können zur Laufzeit geändert werden +- **Modell-getriebene Sicherheit**: Keine hardcodierte Sicherheitslogik erforderlich + +### 4.3 Jakarta EE Security Integration + +Die Implementierung basiert auf dem Java Authentication and Authorization Service (JAAS), das Teil der Jakarta EE Spezifikation ist. Jedes von Ihrer Anwendungsserver-Umgebung unterstützte Authentifizierungs- und Autorisierungs-Framework kann integriert werden. + +#### 4.3.1 Container-Managed Security + +- **Standardisierte Authentifizierung**: Integration mit Jakarta EE Security APIs +- **Vendor-Unabhängigkeit**: Läuft auf allen Jakarta EE-kompatiblen Servern +- **OIDC-Unterstützung**: Moderne Single Sign-On Lösungen + +#### 4.3.2 Programmatische Sicherheit + +- **API-basierte Kontrolle**: Programmatische Zugriffskontrolle über Java APIs +- **Rollen-basierte Berechtigung**: Integration mit Jakarta EE Rollen-Konzepten +- **Custom Identity Stores**: Erweiterbare Authentifizierungsquellen + +### 4.4 Transparente Sicherheitsarchitektur + +Mit diesem Sicherheitskonzept von Imixs-Workflow wird Sicherheit durch ein gut dokumentiertes Prozessmodell definiert und muss nicht länger hart codiert werden. Dies bietet: + +- **Dokumentierte Sicherheitsrichtlinien**: Sicherheit als Teil des BPMN-Modells +- **Auditierbare Berechtigungen**: Nachvollziehbare Zugriffskontrolle +- **Business-User-freundlich**: Sicherheitsregeln ohne Programmierung anpassbar + +--- + +## 5. Jakarta EE Plattform + +### 5.1 Jakarta EE Foundation + +Imixs-Workflow ist eine native Jakarta EE Workflow-Engine, die Transaktionsmanagement, JPA-Persistierung und container-managed Sicherheit out-of-the-box bietet. Entwickelt für moderne Cloud-Umgebungen, integriert sie sich nahtlos in Ihre Microservice-Architektur bei vollständiger Jakarta EE-Konformität. + +### 5.2 Enterprise-Grade Funktionalitäten + +#### 5.2.1 Transaktionsmanagement + +- **Container-Managed Transactions**: Automatische Transaktionskontrolle +- **Two-Phase Commit**: Sichere Verarbeitung über Plugin-Grenzen hinweg +- **Rollback-Mechanismen**: Fehlerbehandlung mit automatischem Rollback + +#### 5.2.2 Persistence Layer + +- **JPA Integration**: Durch die Verwendung der Java Persistence API (JPA) ist die Workflow-Engine datenbankindependent und kann mit jeder relationalen SQL-Datenbank verwendet werden +- **Vendor-Unabhängigkeit**: Unterstützung aller JDBC-kompatiblen Datenbanken +- **Clustering-Support**: Multi-Node-Deployments möglich + +#### 5.2.3 Application Server Support + +Unterstützte Plattformen: + +- **WildFly**: Mit der neuesten Version von Imixs-Workflow (6.2.0) haben wir auf GraalVM 24.1.2 und Wildfly 29.0.1-Final-JDK-17 aktualisiert +- **Payara**: Vollständige Kompatibilität +- **Open Liberty**: Eclipse MicroProfile Unterstützung +- **Apache TomEE**: Lightweight Jakarta EE Implementierung + +### 5.3 Microservice-Architektur + +Imixs-Workflow bietet eine RESTful API zur Integration der Imixs-Workflow Engine in eine Microservice-Architektur. In einer solchen Architektur kann die Imixs-Workflow Engine als separater Microservice deployed werden, der human-zentrierte Workflow-Aufgaben verwaltet. + +#### 5.3.1 REST API + +- **JAX-RS Implementation**: Standardisierte REST-Services +- **JSON/XML Support**: Flexible Datenformate +- **OpenAPI Documentation**: Automatisch generierte API-Dokumentation + +#### 5.3.2 Container-Native Deployment + +- **Docker Support**: Das Imixs Process Manager ermöglicht es Ihnen, innerhalb von Sekunden zu starten. Es kommt mit einem Docker Image, das lokal oder in einer containerisierten Umgebung wie Docker Swarm oder Kubernetes deployed werden kann +- **Kubernetes Integration**: Native Cloud-Deployment-Optionen +- **Horizontal Scaling**: Automatische Lastverteilung + +### 5.4 Integration Capabilities + +Jakarta EE ist darauf ausgelegt, die Integration verschiedener Enterprise-Komponenten und -Systeme zu unterstützen, indem es eine robuste Architektur verwendet, die nahtlose Kommunikation und Zusammenarbeit ermöglicht. Technologien wie die Java API for RESTful Web Services (JAX-RS), Java Message Service (JMS) oder Jakarta Security 3.0 bieten wesentliche Bausteine für die Entwicklung skalierbarer und interoperabler Enterprise-Anwendungen. + +--- + +## 6. Technische Architektur + +### 6.1 Core Components + +#### 6.1.1 Workflow Kernel + +- **Event Processing**: Zentrale Event-Verarbeitung +- **State Management**: Zustandsverwaltung für Prozessinstanzen +- **Plugin Orchestration**: Koordination der Plugin-Ausführung + +#### 6.1.2 Model Service + +- **BPMN Parser**: XML-basierte Modell-Verarbeitung +- **Model Validation**: Konsistenzprüfung der Prozessmodelle +- **Version Management**: Mehrere Modellversionen parallel + +#### 6.1.3 Document Service + +- **Process Instances**: Verwaltung von Workflow-Instanzen +- **Data Storage**: Flexible Datenstrukturen +- **History Tracking**: Vollständige Audit-Trails + +### 6.2 Performance und Skalierung + +Mit seiner Micro-Container-Architektur bietet Jakarta EE Funktionen für den Aufbau skalierbarer und leistungsstarker Enterprise-Anwendungen, ein kritischer Aspekt für BPM-Systeme, die oft eine erhebliche Anzahl gleichzeitiger Prozesse und Benutzerinteraktionen verwalten müssen. + +#### 6.2.1 Clustering + +- **Session Replication**: Zustandssynchronisation zwischen Knoten +- **Load Balancing**: Automatische Lastverteilung +- **Failover**: Hochverfügbarkeitsszenarien + +#### 6.2.2 Caching + +- **Second-Level Cache**: JPA-basierte Caching-Strategien +- **Process Instance Cache**: Optimierte Zugriffe auf aktive Prozesse +- **Model Cache**: Schneller Zugriff auf BPMN-Definitionen + +### 6.3 Monitoring und Management + +- **JMX Integration**: Management Bean Support +- **Health Checks**: Jakarta EE Health Check API +- **Metrics**: MicroProfile Metrics Integration +- **Logging**: Strukturierte Log-Ausgaben + +--- + +## 7. Erweiterte Funktionalitäten + +### 7.1 Machine Learning Integration + +Mit seiner neuesten Version integriert die Open Source Workflow Engine Imixs-Workflow vollständig das AI Framework SpaCy v3.1. Die Integration basiert auf der Imixs Micro Kernel Architektur, die eine moderne modellbasierte Entwicklung ermöglicht. + +#### 7.1.1 Imixs-ML Adapter + +- **NLP Integration**: Natural Language Processing Funktionalitäten +- **Entity Recognition**: Automatische Extraktion von Geschäftsdaten +- **Training Model Integration**: Selbstlernende Systeme + +### 7.2 Stream Analytics + +Basierend auf der Imixs Micro-Kernel-Architektur kann ein Geschäftsprozess mit verschiedenen Adapter- oder Plugin-Modulen erweitert werden, die zusätzliche Funktionalität bieten. Der Imixs-ML Adapter zum Beispiel bietet eine generische API zur Integration verschiedener ML-Frameworks wie spaCy oder Apache mxnet. + +### 7.3 Event Streaming + +In einer event-basierten Workflow-Engine wie Imixs-Workflow werden die verschiedenen Zustände eines Geschäftsprozesses als Tasks beschrieben. Der Übergang von einem Zustand zum nächsten wird durch Event-Elemente beschrieben. Events können durch das Konsumieren eines Kafka-Streaming-Events ausgelöst werden, aber auch durch externe Services oder menschliche Akteure. + +--- + +## 8. Deployment-Optionen + +### 8.1 Traditional Deployment + +#### 8.1.1 Application Server Deployment + +- **WAR/EAR Deployment**: Klassische Enterprise-Deployment-Methoden +- **Shared Libraries**: Optimierte Ressourcennutzung +- **Hot Deployment**: Entwicklungsfreundliche Updates + +### 8.2 Cloud-Native Deployment + +#### 8.2.1 Docker Containerization + +```yaml +version: "3.1" +services: + app: + image: imixs/imixs-microservice + environment: + POSTGRES_CONNECTION: "jdbc:postgresql://db/workflow" + ports: + - "8080:8080" +``` + +#### 8.2.2 Kubernetes Orchestration + +Imixs-Office-Workflow bietet eine container-basierte Architektur, die perfekt in jede Art von Kubernetes-Clustern passt: + +- **Helm Charts**: Standardisierte Kubernetes-Deployments +- **ConfigMaps**: Externalisierte Konfiguration +- **Persistent Volumes**: Datenbank- und Index-Persistierung + +### 8.3 Microservice Architecture + +Imixs Micro ist ein leichtgewichtiges verteiltes Workflow-Management-System basierend auf der Imixs-Workflow-Technologie. Dieses System kann beispielsweise als Workflow-Service in einer industriellen Produktionsanlage verwendet werden. + +--- + +## 9. Development Best Practices + +### 9.1 Model-Driven Development + +Imixs-Workflow ist eine BPMN Workflow-Engine. BPMN gibt Ihnen den perfekten Ort, um Ihren Geschäftsprozess einschließlich des Workflows, der Verantwortlichkeiten und Geschäftsregeln zu beschreiben. Auch wenn Sie ein erfahrener Java-Entwickler sind, versuchen Sie, Ihren Geschäftsprozess zuerst im BPMN-Modell zu beschreiben. + +### 9.2 Plugin Development Guidelines + +```java +public class MyPlugin extends AbstractPlugin { + @Override + public ItemCollection run(ItemCollection workitem, ItemCollection event) + throws PluginException { + // Validate and aggregate + double budget = workitem.getItemValueDouble("budget"); + if (budget <= 0) { + throw new PluginException(MyPlugin.class.getName(), + "INPUT ERROR", "Please enter the Budget."); + } else { + workitem.setItemValue("budget", Math.round(budget)); + } + return workitem; + } +} +``` + +### 9.3 Signal Adapter Pattern + +Versuchen Sie, SignalAdapters zu verwenden. Die Imixs-Workflow Engine bietet eine Cross-Function-API basierend auf CDI Events: + +```java +public class DemoAdapter implements org.imixs.workflow.SignalAdapter { + @Inject + ModelService modelService; + + @Override + public ItemCollection execute(ItemCollection document, ItemCollection event) + throws AdapterException { + // Business logic implementation + return document; + } +} +``` + +--- + +## 10. Vergleichsanalyse + +### 10.1 Imixs vs. Camunda + +Während Camunda eine starke Wahl für entwicklergeleitete Prozessautomatisierung bleibt, bietet Imixs-Workflow eine eigenständige Alternative für Organisationen, die ihre Business User befähigen möchten. + +#### 10.1.1 Architektonische Unterschiede + +- **Imixs**: Jakarta EE-basiert, human-zentriert +- **Camunda**: Spring-basiert, entwickler-orientiert + +#### 10.1.2 Zielgruppen + +- **Imixs**: Business Users und Fachabteilungen +- **Camunda**: Entwicklerteams und IT-Abteilungen + +### 10.2 Technologische Positionierung + +Jakarta EE, früher bekannt als Java EE, repräsentiert den Industriestandard für Enterprise Computing und bringt bedeutende Vorteile für die Architektur von Imixs-Workflow. Im Kern gewährleistet Jakarta EEs container-managed Ansatz optimale Ressourcenverwaltung und Transaktionsmanagement mit minimalem Konfigurationsaufwand. + +--- + +## 11. Fazit und Ausblick + +### 11.1 Zusammenfassung der Kernstärken + +Die Imixs Workflow Engine zeichnet sich durch folgende Kernkompetenzen aus: + +1. **BPMN 2.0 Konformität** mit erweiterten human-zentrierten Funktionalitäten +2. **Micro-Kernel-Architektur** für maximale Erweiterbarkeit und Flexibilität +3. **Enterprise-Security** mit modellgetriebenen Sicherheitsrichtlinien +4. **Jakarta EE Native** für Skalierbarkeit und Vendor-Unabhängigkeit + +### 11.2 Anwendungsszenarien + +Die Engine eignet sich besonders für: + +- **Human-zentrierte Geschäftsprozesse** mit komplexen Approval-Workflows +- **Regulatory Compliance** Prozesse mit Audit-Anforderungen +- **Document Management** Systeme mit Workflow-Integration +- **Case Management** Anwendungen + +### 11.3 Technologische Roadmap + +Die Weiterentwicklung fokussiert auf: + +- **Cloud-Native Features**: Erweiterte Kubernetes-Integration +- **AI/ML Integration**: Verstärkte Machine Learning Capabilities +- **Low-Code/No-Code**: Vereinfachte Business User Interfaces +- **Event Streaming**: Erweiterte Integration mit Event-driven Architectures + +### 11.4 Community und Ecosystem + +Imixs Workflow ist ein Open Source Projekt und wir laden Sie herzlich ein, daran teilzunehmen. Es gibt verschiedene Wege, wie Sie das tun können. Treten Sie dem Imixs Workflow Projekt jetzt auf GitHub bei. Das aktive Community-Ecosystem bietet kontinuierliche Weiterentwicklung und Support. + +--- + +## Literaturverzeichnis + +1. Imixs-Workflow Official Documentation. (2025). https://www.imixs.org/ +2. Imixs-BPMN Modeler Documentation. (2025). https://www.imixs.org/sub_modeler.html +3. Jakarta EE Security Specification. (2025). https://jakarta.ee/ +4. Business Process Model and Notation (BPMN) 2.0. Object Management Group. +5. Imixs-Workflow GitHub Repository. (2025). https://github.com/imixs/imixs-workflow + +--- + +**Anhang A: API-Referenzen** +**Anhang B: Konfigurationsbeispiele** +**Anhang C: Performance-Benchmarks** +**Anhang D: Migration Guidelines** diff --git a/doc/IMIXS_WORKFLOW_EN.md b/doc/IMIXS_WORKFLOW_EN.md new file mode 100644 index 0000000..e38d861 --- /dev/null +++ b/doc/IMIXS_WORKFLOW_EN.md @@ -0,0 +1,437 @@ +# Technical Paper: Imixs Workflow Engine + +## A Comprehensive Analysis of the Open-Source BPMN 2.0 Workflow Engine + +**Version:** 1.0 +**Date:** June 2025 +**Author:** Technical Documentation + +--- + +## Executive Summary + +The Imixs Workflow Engine is a powerful open-source BPMN 2.0 workflow engine built on the Jakarta EE platform, specifically designed for human-centric business processes. With its micro-kernel architecture, advanced security concepts, and native Jakarta EE integration, it provides a robust solution for modern Business Process Management (BPM) requirements. + +### Core Features + +- **BPMN 2.0 Standard Compliance** with event-driven modeling concept +- **Micro-Kernel Architecture** with plugin and adapter system +- **Enterprise Security** with multi-level access control +- **Jakarta EE Native** for scalability and vendor independence + +--- + +## 1. Introduction + +### 1.1 Project Overview + +Imixs-Workflow is an open-source BPMN 2.0 workflow engine with modern API and plugin architecture that combines low-code modeling, enterprise security, and microservice deployment for Java business applications. The project focuses on human-centric workflows and differs from task-oriented engines through its event-based approach. + +### 1.2 Architectural Vision + +The goal of the open-source project is to reduce the complexity of business applications by providing a flexible framework for implementing business logic based on the BPMN 2.0 standard. The engine enables model-driven implementation of business logic, making changes possible without code modifications. + +--- + +## 2. BPMN 2.0 Modeling + +### 2.1 BPMN 2.0 Standard Support + +Imixs-Workflow supports the BPMN 2.0 standard and simplifies the path to Low-Code-centric Business Process Management. The Business Process Model and Notation (BPMN 2.0) is an open standard for describing business processes that can be visualized in diagram editors and executed by BPMN 2.0-compliant process engines. + +### 2.2 Event-Driven Modeling Concept + +The Imixs engine implements a unique event-driven modeling concept: + +- **Tasks** represent different states of a business process +- **Events** control transitions between states +- **Gateways** enable complex business rules and decisions + +Imixs-Workflow is a human-centric business process management solution that uses an event-driven modeling concept. Within the process flow, events can be triggered either by human actors or services at each task. + +### 2.3 Imixs-BPMN Modeler + +The project provides a specialized modeler with Imixs-BPMN: + +- **Open-BPMN Foundation**: Imixs-BPMN is based on the Open Source project Open-BPMN and extends this framework with aspects of a human-centric workflow model executable on the Imixs-Workflow Engine +- **Multi-Platform Support**: Integration in Visual Studio Code, Eclipse, or Web Browser +- **Extended BPMN Elements**: Special event elements for workflow-specific functionalities + +### 2.4 Deployment and Model Management + +The Imixs-Workflow Rest API provides a convenient way to upload a BPMN model or verify the deployment status of BPMN models. Models can be deployed both via the REST API and programmatically: + +```java +import org.imixs.workflow.bpmn.BPMNModel; +import org.imixs.workflow.bpmn.BPMNParser; + +BPMNModel model = BPMNParser.parseModel(file.getData(), "UTF-8"); +modelService.importBPMNModel(model); +``` + +--- + +## 3. Micro-Kernel Architecture + +### 3.1 Architectural Foundations + +The Imixs-Workflow Adapter API is part of the microkernel architecture pattern and provides an extension mechanism to adapt the processing lifecycle of a BPMN Event. This architecture follows the Hexagonal Architecture Pattern and enables clear separation between core logic and external components. + +### 3.2 Plugin System + +The plugin system forms the heart of the extensible architecture: + +#### 3.2.1 Plugin API + +The Imixs Plugin-API is the general extension concept of the Imixs-Workflow Engine. Plugins implement three callback methods: + +```java +public void init(WorkflowContext workflowContext) throws PluginException; +public ItemCollection run(ItemCollection document, ItemCollection event) throws PluginException; +public void close(boolean rollbackTransaction) throws PluginException; +``` + +#### 3.2.2 Two-Phase Commit Concept + +The Imixs Plugin-API defines three callback methods called by the Workflow Engine in one single transaction during the processing lifecycle. This is the concept of a two-phase commit (2PC). + +### 3.3 Adapter System + +The adapter system complements the plugin system for more specific use cases: + +#### 3.3.1 Signal Adapter + +- **Event-Specific Binding**: In contrast to the Plugin API, the SignalAdapter is bound to a single Event within a BPMN 2.0 model. This allows fine-grained configuration +- **Early Execution**: Execution before the plugin processing lifecycle + +#### 3.3.2 Generic Adapter + +- **Model-Independent Execution**: General business logic independent from the BPMN model +- **CDI Integration**: The Imixs-Workflow Adapter API also supports CDI. In this way, an EJB or Resource can be injected into an adapter class by the corresponding CDI annotation + +### 3.4 Hexagonal Architecture Implementation + +With the two interface definitions 'Imixs-Plugin' and 'Imixs-Adapter', you can separate individual functionality from the core business logic managed by the Imixs-Workflow engine. This architecture provides: + +- **Ports**: Interface definitions for extension points +- **Adapters**: Concrete implementations of the interfaces +- **Core Business Logic**: Protected in the inner hexagon + +--- + +## 4. Security Concept + +### 4.1 Multi-Level Security Model + +Imixs-Workflow provides you with a powerful security model to protect your business data based on individual workflow models. The Imixs-Workflow engine supports you with a multi-level security model for fine-grained access control. + +### 4.2 Access Control Lists (ACL) + +The ACL system enables: + +- **Status-Specific Authorization**: You can define an access control list (ACL) for every single process status within your workflow model. The ACL will automatically be applied by the Imixs-Workflow engine to a running process instance +- **Runtime Adaptation**: Security settings can be changed at runtime +- **Model-Driven Security**: No hard-coded security logic required + +### 4.3 Jakarta EE Security Integration + +The implementation is based on the Java Authentication and Authorization Service (JAAS), which is part of the Jakarta EE specification. Any authentication and authorization framework supported by your application server environment can be integrated. + +#### 4.3.1 Container-Managed Security + +- **Standardized Authentication**: Integration with Jakarta EE Security APIs +- **Vendor Independence**: Runs on all Jakarta EE-compatible servers +- **OIDC Support**: Modern Single Sign-On solutions + +#### 4.3.2 Programmatic Security + +- **API-Based Control**: Programmatic access control via Java APIs +- **Role-Based Authorization**: Integration with Jakarta EE role concepts +- **Custom Identity Stores**: Extensible authentication sources + +### 4.4 Transparent Security Architecture + +With this security concept of Imixs-Workflow, security is defined by a well-documented process model and no longer needs to be hard-coded. This provides: + +- **Documented Security Policies**: Security as part of the BPMN model +- **Auditable Permissions**: Traceable access control +- **Business-User Friendly**: Security rules adjustable without programming + +--- + +## 5. Jakarta EE Platform + +### 5.1 Jakarta EE Foundation + +Imixs-Workflow is a native Jakarta EE workflow engine providing transaction management, JPA persistence, and container-managed security out of the box. Built for modern cloud environments, it seamlessly integrates into your microservice architecture while maintaining full Jakarta EE compliance. + +### 5.2 Enterprise-Grade Functionalities + +#### 5.2.1 Transaction Management + +- **Container-Managed Transactions**: Automatic transaction control +- **Two-Phase Commit**: Secure processing across plugin boundaries +- **Rollback Mechanisms**: Error handling with automatic rollback + +#### 5.2.2 Persistence Layer + +- **JPA Integration**: By using the Java Persistence API (JPA), the workflow engine is database independent and can be used with any relational SQL database +- **Vendor Independence**: Support for all JDBC-compatible databases +- **Clustering Support**: Multi-node deployments possible + +#### 5.2.3 Application Server Support + +Supported platforms: + +- **WildFly**: With the latest version of Imixs-Workflow (6.2.0), we upgraded to GraalVM 24.1.2 and Wildfly 29.0.1-Final-JDK-17 +- **Payara**: Full compatibility +- **Open Liberty**: Eclipse MicroProfile support +- **Apache TomEE**: Lightweight Jakarta EE implementation + +### 5.3 Microservice Architecture + +Imixs-Workflow provides a RESTful API to integrate the Imixs-Workflow engine into a microservice architecture. In such an architecture, the Imixs-Workflow engine can be deployed as a separate microservice managing human-centric workflow tasks. + +#### 5.3.1 REST API + +- **JAX-RS Implementation**: Standardized REST services +- **JSON/XML Support**: Flexible data formats +- **OpenAPI Documentation**: Automatically generated API documentation + +#### 5.3.2 Container-Native Deployment + +- **Docker Support**: The Imixs Process Manager allows you to start within seconds. It comes with a Docker image that can be deployed locally or in a containerized environment like Docker Swarm or Kubernetes +- **Kubernetes Integration**: Native cloud deployment options +- **Horizontal Scaling**: Automatic load distribution + +### 5.4 Integration Capabilities + +Jakarta EE is designed to support the integration of various enterprise components and systems using a robust architecture that facilitates seamless communication and collaboration. Technologies like the Java API for RESTful Web Services (JAX-RS), Java Message Service (JMS), or Jakarta Security 3.0 provide essential building blocks for developing scalable and interoperable enterprise applications. + +--- + +## 6. Technical Architecture + +### 6.1 Core Components + +#### 6.1.1 Workflow Kernel + +- **Event Processing**: Central event processing +- **State Management**: State management for process instances +- **Plugin Orchestration**: Coordination of plugin execution + +#### 6.1.2 Model Service + +- **BPMN Parser**: XML-based model processing +- **Model Validation**: Consistency checking of process models +- **Version Management**: Multiple model versions in parallel + +#### 6.1.3 Document Service + +- **Process Instances**: Management of workflow instances +- **Data Storage**: Flexible data structures +- **History Tracking**: Complete audit trails + +### 6.2 Performance and Scaling + +With its micro-container architecture, Jakarta EE offers features for building scalable and high-performance enterprise applications, a critical aspect for BPM systems that often need to manage a substantial volume of concurrent processes and user interactions. + +#### 6.2.1 Clustering + +- **Session Replication**: State synchronization between nodes +- **Load Balancing**: Automatic load distribution +- **Failover**: High availability scenarios + +#### 6.2.2 Caching + +- **Second-Level Cache**: JPA-based caching strategies +- **Process Instance Cache**: Optimized access to active processes +- **Model Cache**: Fast access to BPMN definitions + +### 6.3 Monitoring and Management + +- **JMX Integration**: Management Bean support +- **Health Checks**: Jakarta EE Health Check API +- **Metrics**: MicroProfile Metrics integration +- **Logging**: Structured log output + +--- + +## 7. Advanced Functionalities + +### 7.1 Machine Learning Integration + +With its latest version, the Open Source Workflow Engine Imixs-Workflow fully integrates the AI Framework SpaCy v3.1. The integration is based on the Imixs Micro Kernel architecture, which allows modern model-based development. + +#### 7.1.1 Imixs-ML Adapter + +- **NLP Integration**: Natural Language Processing functionalities +- **Entity Recognition**: Automatic extraction of business data +- **Training Model Integration**: Self-learning systems + +### 7.2 Stream Analytics + +Based on the Imixs micro-kernel architecture, a business process can be extended with various adapter or plugin modules providing additional functionality. The Imixs-ML Adapter, for example, provides a generic API to integrate various ML frameworks like spaCy or Apache mxnet. + +### 7.3 Event Streaming + +In an event-based workflow engine like Imixs-Workflow, the different states of a business process are described as Tasks. The transition from one state to the next is described by Event elements. Events can be triggered by consuming a Kafka streaming event, as well as by external services or human actors. + +--- + +## 8. Deployment Options + +### 8.1 Traditional Deployment + +#### 8.1.1 Application Server Deployment + +- **WAR/EAR Deployment**: Classic enterprise deployment methods +- **Shared Libraries**: Optimized resource utilization +- **Hot Deployment**: Development-friendly updates + +### 8.2 Cloud-Native Deployment + +#### 8.2.1 Docker Containerization + +```yaml +version: "3.1" +services: + app: + image: imixs/imixs-microservice + environment: + POSTGRES_CONNECTION: "jdbc:postgresql://db/workflow" + ports: + - "8080:8080" +``` + +#### 8.2.2 Kubernetes Orchestration + +Imixs-Office-Workflow offers a container-based architecture that fits perfectly into any kind of Kubernetes clusters: + +- **Helm Charts**: Standardized Kubernetes deployments +- **ConfigMaps**: Externalized configuration +- **Persistent Volumes**: Database and index persistence + +### 8.3 Microservice Architecture + +Imixs Micro is a lightweight distributed workflow management system based on the Imixs-Workflow technology. This system can be used, for example, as a workflow service in an industrial production plant. + +--- + +## 9. Development Best Practices + +### 9.1 Model-Driven Development + +Imixs-Workflow is a BPMN workflow engine. BPMN gives you the perfect place to describe your business process including the workflow, responsibilities, and business rules. Even if you are an experienced Java developer, try to describe your business process in the BPMN model first. + +### 9.2 Plugin Development Guidelines + +```java +public class MyPlugin extends AbstractPlugin { + @Override + public ItemCollection run(ItemCollection workitem, ItemCollection event) + throws PluginException { + // Validate and aggregate + double budget = workitem.getItemValueDouble("budget"); + if (budget <= 0) { + throw new PluginException(MyPlugin.class.getName(), + "INPUT ERROR", "Please enter the Budget."); + } else { + workitem.setItemValue("budget", Math.round(budget)); + } + return workitem; + } +} +``` + +### 9.3 Signal Adapter Pattern + +Try to use SignalAdapters instead. The Imixs-Workflow Engine provides a Cross-Function-API based on CDI Events: + +```java +public class DemoAdapter implements org.imixs.workflow.SignalAdapter { + @Inject + ModelService modelService; + + @Override + public ItemCollection execute(ItemCollection document, ItemCollection event) + throws AdapterException { + // Business logic implementation + return document; + } +} +``` + +--- + +## 10. Comparative Analysis + +### 10.1 Imixs vs. Camunda + +While Camunda remains a strong choice for developer-led process automation, Imixs-Workflow offers a distinct alternative for organizations seeking to empower their business users. + +#### 10.1.1 Architectural Differences + +- **Imixs**: Jakarta EE-based, human-centric +- **Camunda**: Spring-based, developer-oriented + +#### 10.1.2 Target Audiences + +- **Imixs**: Business users and business departments +- **Camunda**: Developer teams and IT departments + +### 10.2 Technology Positioning + +Jakarta EE, formerly known as Java EE, represents the industry standard for enterprise computing and brings significant benefits to Imixs-Workflow's architecture. At its core, Jakarta EE's container-managed approach ensures optimal resource handling and transaction management with minimal configuration overhead. + +--- + +## 11. Conclusion and Outlook + +### 11.1 Summary of Core Strengths + +The Imixs Workflow Engine is distinguished by the following core competencies: + +1. **BPMN 2.0 Compliance** with extended human-centric functionalities +2. **Micro-Kernel Architecture** for maximum extensibility and flexibility +3. **Enterprise Security** with model-driven security policies +4. **Jakarta EE Native** for scalability and vendor independence + +### 11.2 Application Scenarios + +The engine is particularly suitable for: + +- **Human-Centric Business Processes** with complex approval workflows +- **Regulatory Compliance** processes with audit requirements +- **Document Management** systems with workflow integration +- **Case Management** applications + +### 11.3 Technology Roadmap + +Future development focuses on: + +- **Cloud-Native Features**: Extended Kubernetes integration +- **AI/ML Integration**: Enhanced Machine Learning capabilities +- **Low-Code/No-Code**: Simplified business user interfaces +- **Event Streaming**: Extended integration with event-driven architectures + +### 11.4 Community and Ecosystem + +Imixs Workflow is an open source project and we sincerely invite you to participate in it. There are different ways how you can do that. Join the Imixs Workflow Project now on GitHub. The active community ecosystem provides continuous development and support. + +--- + +## Bibliography + +1. Imixs-Workflow Official Documentation. (2025). https://www.imixs.org/ +2. Imixs-BPMN Modeler Documentation. (2025). https://www.imixs.org/sub_modeler.html +3. Jakarta EE Security Specification. (2025). https://jakarta.ee/ +4. Business Process Model and Notation (BPMN) 2.0. Object Management Group. +5. Imixs-Workflow GitHub Repository. (2025). https://github.com/imixs/imixs-workflow + +--- + +**Appendix A: API References** +**Appendix B: Configuration Examples** +**Appendix C: Performance Benchmarks** +**Appendix D: Migration Guidelines**