Tagged articles
Activiti
40 articles · Page 1 of 1

java1234Aug 6, 2026 · Backend Development
Flowable is an open‑source Java workflow engine that follows the BPMN 2.0 standard, offering tighter Spring Boot integration, full CMMN/DMN support, better performance than Activiti, and flexible deployment options, with detailed comparisons to Activiti and Camunda and step‑by‑step Spring Boot and standalone examples.
ActivitiBPMNCamunda
0 likes · 8 min read

This article walks through designing, deploying, and executing a multi‑level leave‑approval workflow using the Activiti BPM engine, covering BPMN diagram creation, Spring Boot configuration, Java code for process initiation and task handling, database tables, key services, and best‑practice development steps.
ActivitiBPMNBackend
0 likes · 23 min read

This guide walks you through designing a multi‑level leave‑approval workflow using Activiti, from drawing the BPMN diagram and configuring the engine to deploying the process, handling tasks, setting variables, and visualizing execution history, all with concise Java code examples and practical tips.
ActivitiBPMNProcessEngine
0 likes · 23 min read

This article explains how to design, configure, and operate an Activiti workflow engine in a Java Spring Boot application, covering BPMN diagram creation, engine setup, deployment, task handling, code examples, API usage, and comparisons with other workflow solutions.
ActivitiBPMNJava
0 likes · 26 min read

This article explains how to design and implement a multi‑level approval workflow for an office automation system using the Activiti BPMN engine, covering process diagram creation, Spring Boot configuration, Java code for deployment and task handling, database tables, API overview, and comparisons with similar frameworks.
ActivitiBPMNJava
0 likes · 25 min read

This article explains how to build a multi‑level office approval workflow using the Activiti engine, covering BPMN diagram design, deployment, Java code for process creation, task handling, gateway logic, database schema, API overview, framework comparisons, and further learning directions.
ActivitiBPMNJava
0 likes · 23 min read

Activiti is a BPMN workflow engine that provides components such as Process, Repository, Runtime, Task, and History services, stores definitions, runtime data, and history in a relational database schema, and is used by deploying BPMN diagrams, starting instances, and managing tasks via its Java API.
ActivitiBPMNDatabase Design
0 likes · 21 min read

This article provides a detailed tutorial on the Activiti 7 workflow engine, covering workflow concepts, BPMN modeling, environment configuration, Maven dependencies, database schema creation, deployment methods, process instance management, task handling, and historical data querying, with complete code examples for Java developers.
ActivitiBPMNJava
0 likes · 38 min read

This article explains how to design, configure, and code a multi‑level leave‑approval workflow using the Activiti BPM engine, covering process diagram creation, deployment, task handling, exclusive gateways, and database schema while providing complete Java examples and best‑practice recommendations.
ActivitiBPMNJava
0 likes · 25 min read

This article explains how to design a two‑level leave‑approval process using the Activiti BPMN engine, covering diagram creation, Spring‑Boot configuration, deployment, task handling, exclusive gateways, database tables, API overview, and practical tips for extending the workflow.
ActivitiBPMNJava
0 likes · 25 min read

This article demonstrates how to design, deploy, and run a two‑level leave‑approval workflow using the Activiti BPMN engine, covering diagram creation, Spring Boot configuration, process variables, task handling, exclusive gateways, database tables, API overview, and best‑practice tips for extending the flow.
ActivitiBPMNJava
0 likes · 25 min read

This article walks you through designing, deploying, and managing a multi‑level approval workflow using the Activiti engine, covering BPMN diagram creation, Spring Boot integration, database schema, API usage, code examples, and best practices for extending processes without additional code.
ActivitiBPMNJava
0 likes · 26 min read

This article explains how to design a multi‑level workflow approval system using the Activiti engine, covering process diagram creation, deployment, task handling, variable management, exclusive gateways, and complete project configuration with Spring Boot and an H2 database.
ActivitiBPMNJava
0 likes · 26 min read

This article explains how to use the Activiti workflow engine to design a multi‑level leave‑approval process, covering BPMN diagram creation, Spring Boot configuration, deployment, Java code for starting instances, task handling, database schema, API overview, and tips for extending the workflow without additional code.
ActivitiBPMNJava
0 likes · 24 min read

This article reviews the most popular open‑source BPM engines—Osworkflow, JBPM, Activiti, Flowable, and Camunda—examines their histories, features, and performance, and provides a detailed functional and benchmark comparison between Flowable and Camunda to guide engine selection.
ActivitiBPMCamunda
0 likes · 12 min read

This article reviews popular open‑source workflow engines—including Osworkflow, JBPM, Activiti, Flowable, and Camunda—examines their features, performance, and limitations, and provides a detailed comparison between Flowable and Camunda to guide developers in selecting the most suitable engine for low‑code, BPM, or OA projects.
ActivitiBPMCamunda
0 likes · 12 min read

This article reviews popular open‑source workflow engines—including Osworkflow, JBPM, Activiti, Flowable, and Camunda—compares their features and performance, and offers a clear recommendation for selecting the most suitable engine for low‑code, OA, or BPM projects.
ActivitiBPMCamunda
0 likes · 13 min read


转转QAJan 23, 2024 · Backend Development
This article describes how a corporate legal department streamlined contract handling by abstracting template contracts into an OA-based online process, reusing common approval nodes, leveraging a configuration center for validation, and implementing a generic validator with sample Java code, resulting in reduced workload and improved user experience.
ActivitiOA SystemProcess Optimization
0 likes · 10 min read

This tutorial demonstrates how to integrate Activiti workflow engine event listeners into a Spring Boot application, covering task assignment, task completion, and process completion events with code examples, testing steps, and important configuration details.
ActivitiJavaSpring Boot
0 likes · 5 min read

This guide shows how to extend a Spring Boot application with Activiti to query historic process data, generate highlighted process diagrams, and expose endpoints that display real‑time workflow progress, including code snippets for service methods, configuration, utilities, and a controller for image rendering.
ActivitiJavaSpring Boot
0 likes · 8 min read

This guide walks through setting up a Spring Boot 2.2.11 environment with Activiti 7.1, configuring Maven dependencies, explaining the Activiti database tables, defining a BPMN leave‑request process, implementing service and controller layers, and demonstrating API calls to deploy, start, query, and complete the workflow.
ActivitiBPMNWorkflow
0 likes · 18 min read

This article provides a step‑by‑step guide for integrating Activiti 7 workflow engine into a Spring Boot application, covering Maven dependencies, environment setup, process deployment, task handling, business keys, suspension/activation, candidate users, variables, gateways, and various advanced operations with complete code examples.
ActivitiBPMNJava
0 likes · 32 min read

This article provides a step‑by‑step guide on integrating Activiti7 into a SpringBoot project, covering Maven dependencies, IDE configuration, deployment of BPMN files, starting and managing process instances, handling tasks, business keys, process variables, candidate users, and gateway configurations, all illustrated with complete Java code examples.
ActivitiBPMNJava
0 likes · 29 min read

This article provides a comprehensive guide on using Activiti7 in a SpringBoot project, covering Maven dependencies, IDE configuration, process deployment, task handling, business keys, process suspension/activation, candidate users, gateways, and includes complete Java code examples for each step.
ActivitiBPMNJava
0 likes · 28 min read

This article provides a comprehensive tutorial on Activiti 7, covering workflow concepts, engine configuration files, process engine creation methods, service interfaces, BPMN diagram symbols, deployment techniques, task management, process variables, gateway types, and integration with Spring and Spring Boot.
ActivitiBPMNJava
0 likes · 28 min read

This article provides a comprehensive guide to the Activiti 7 workflow engine, covering its core concepts, Maven dependencies, XML configuration, engine creation methods, service interfaces, process deployment, instance management, task handling, variable usage, gateway types, and integration with Spring and Spring Boot, all illustrated with practical code examples.
ActivitiBPMNJava
0 likes · 26 min read

This article explains what a workflow is, introduces the Activiti 7 workflow engine, walks through environment setup with Maven and MySQL, and provides complete Java code examples for initializing tables, deploying processes, starting instances, querying definitions, deleting deployments, and retrieving BPMN/PNG resources.
ActivitiBPMNJava
0 likes · 18 min read

This article provides a detailed tutorial on Activiti 7 workflow engine, covering workflow fundamentals, BPMN modeling, environment setup, Maven dependencies, configuration files, process deployment, instance creation, task querying and completion, process definition management, resource extraction, and historical data inspection, all illustrated with Java code examples.
ActivitiBPMNProcessEngine
0 likes · 38 min read

This comprehensive guide explains workflow concepts, introduces the Activiti 7 BPMN engine, walks through environment setup, configuration, database schema creation, process definition, deployment, instance start, task handling, and history inspection with complete Java code examples.
ActivitiJava
0 likes · 45 min read

This article provides an in‑depth tutorial on Activiti 7 workflow management, covering workflow concepts, system architecture, BPMN modeling, environment setup, Maven dependencies, database configuration, deployment methods, process execution, task handling, and historical data retrieval for Java backend development.
ActivitiBPMNJava
0 likes · 43 min read

This tutorial walks through creating a leave‑approval process in Spring Boot 2.3.12 with Activiti 7.1, illustrating how an Exclusive Gateway routes requests based on leave days, how flags control loop‑back or completion, and provides full BPMN, service, and controller code examples.
ActivitiBPMNWorkflow
0 likes · 12 min read

This guide demonstrates how to integrate Spring Boot with the Activiti workflow engine, covering common operations such as querying owner tasks, retrieving assigned tasks, suspending, activating, and deleting process instances, complete with controller examples and sample API calls.
ActivitiProcess ManagementREST API
0 likes · 6 min read

This guide explains how to configure and use Activiti's TaskRuntimeEventListeners and ProcessRuntimeEventListeners in a Spring Boot application, covering TaskAssignedEvent, TaskCompletedEvent, and ProcessCompletedEvent with code examples, testing steps, and important authentication settings.
ActivitiSpring BootWorkflow
0 likes · 5 min read

This tutorial demonstrates how to extend a Spring Boot application with Activiti to query historic process data, configure a diagram generator bean, compute highlighted flows, expose a REST endpoint for real-time process diagram rendering, and verify the workflow through a series of API calls and screenshots.
ActivitiSpring BootWorkflow
0 likes · 10 min read

This guide walks through setting up a Spring Boot 2.2.11 project with Activiti 7.1, configuring Maven dependencies, explaining Activiti table prefixes, defining core services, creating a BPMN leave request process, configuring security and datasource, and exposing REST APIs for deployment, execution, and task handling.
ActivitiBPMNMySQL
0 likes · 21 min read

This guide walks through cloning the RuoYi‑Process repository, configuring the database and application settings, building the project with Spring Boot, and launching the workflow system at http://localhost:8888.
ActivitiJavaRuoYi
0 likes · 3 min read

This article explains how to integrate the Activiti BPMN 2.0 workflow engine into a Spring Boot application, covering Maven dependencies, data source and Activiti configuration, Spring MVC setup, Java code for starting, approving, and querying leave requests, as well as a simple AngularJS front‑end for task management.
ActivitiAngularJSSpring Boot
0 likes · 10 min read

This article demonstrates how to integrate the Activiti 6.0 workflow engine into a Spring Boot application, covering Maven dependencies, YAML configuration, Spring MVC setup, Java service methods for starting, auditing, and querying leave processes, as well as an AngularJS front‑end for task handling.
ActivitiAngularJSBPM
0 likes · 11 min read

This article explains the concept of workflow, introduces the open‑source Activiti engine that implements BPMN 2.0, describes its database schema, outlines the basic lifecycle of a workflow, and provides step‑by‑step guidance on creating, deploying, starting, and managing processes with Java and Spring.
ActivitiBPMNWorkflow
0 likes · 8 min read

This article shares three practical techniques for streamlining Activiti BPMN processes—omitting exclusive gateways by moving conditions to outgoing sequence flows, using skip expressions to bypass unnecessary user tasks, and employing parallel gateways with task listeners to enable multi‑role approvals—complete with XML examples and diagrams.
ActivitiBPMNParallel Gateway
0 likes · 10 min read
