The Art of Process Modeling: Designing Processes with Activiti

The art of process modeling: using Activiti to design processes

Preface
Process related
- define a process
- start a process
- Delete a process
Method related
- Create process
- Verify whether the process model is legal
- Get the current person’s to-do list
- Query candidate tasks
- Delete historical process
- Get a list of unfinished historical process instances
- Get a list of completed historical task instances
- Query historical activity instances based on business ID

Foreword

“Today’s businesses and organizations increasingly rely on process automation to increase efficiency, reduce costs and ensure consistency. In this digital age, process engines such as Activiti and Flowable have become indispensable tools. However, to realize their full potential , you need to have an in-depth understanding of their working principles and best practices. This blog will give you an initial understanding of the activiti process engine, from basic concepts to practical applications, allowing you to navigate the world of process automation with ease.”

Process related

Define a process

repositoryService.createDeployment().addBpmnModel(name, bpmnModel).tenantId("ceshibo").deploy()

[Explanation] Executing the above method will insert data into 3 tables.

ACT_RE_DEPLOYMENT: Stores process deployment information, including deployment ID, name, time, etc.
ACT_GE_BYTEARRAY: Stores process definition files, including files in BPMN, PNG, XML and other formats.
ACT_RE_PROCDEF: Stores process definition information, including process definition ID, KEY, version number, name, deployment ID, XML file name, etc.

[Warning] The above addBpmnModel(name,bpmnModel) adds a BPMN model to the deployment object. It must be noted that the name must end with .bpmn, otherwise ACT_RE_PROCDEF without data will appear.

Start a process

The premise is to obtain the ProcessDefinition and obtain it according to the id of ACT_RE_DEPLOYMENT

Fields that should be included in the business table

ID: An ID that uniquely identifies a process definition.
KEY: The identifier of the process definition, equivalent to the name of the process definition.
NAME: The name of the process definition, used for display in the process designer.
VERSION: The version number of the process definition, used to distinguish different versions of process definitions.
DEPLOYMENT_ID: The deployment ID to which the process definition belongs.
RESOURCE_NAME: The resource name of the process definition, that is, the corresponding BPMN file name.
DIAGRAM_RESOURCE_NAME: The graphic resource name of the process definition, that is, the corresponding flow chart name.
TENANT_ID: The tenant ID to which the process definition belongs. If there is no multi-tenant requirement, it can be empty.

Get process definition entity

// Get the process definition based on the deployment ID
  ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
  .deploymentId(deploymentId)
  .singleResult();

Start the process based on the process id, the id of ACT_RE_PROCDEF

// Variables are process variables, and businessKey is added here, which is the business id, because each process definition corresponds to multiple process instances.
ProcessInstanceBuilder processInstanceBuilder = runtimeService.createProcessInstanceBuilder();
            ProcessInstance processInstance = processInstanceBuilder
                    .processDefinitionId(startProcessInstanceDTO.getProcessDefinitionId())
                    .variables(processVariables)
                    .businessKey("test01")
                    .businessStatus(BUSINESS_STATUS_1)
                    .start();

Start a process instance based on the process definition key

// Because there will be multiple versions of the process instance, the same key will exist. The latest process instance will be taken here.
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process_key", variables);

Tables that will be affected after starting the process

ACT_HI_ACTINST: It is a history table that records information about all activity instances, including completed and running activity instances.
ACT_HI_PROCINST: Historical process instance table, which contains process start time, end time, duration, etc.
ACT_HI_TASKINST: Historical task instance information. During the process execution, the task instance is not completed but started, and it will also be inserted into this table.
ACT_HI_VARINST: Variable information of process instance, process variables and task variables. For each variable that changes, a record is generated in the table. A record corresponds to the change history of a variable, including variable name, variable value, modification time and other information.
ACT_RU_EXECUTION: It is a runtime process execution instance table. Each executing process instance corresponds to a piece of data in this table. The data in this table will continue to change as the process is executed, including process start, process node completion, etc. Generally speaking, if a process has ended, the corresponding record will be deleted from the ACT_RU_EXECUTION table. If a process has not yet ended, the corresponding record will remain in the table until the process ends. A process instance will correspond to one piece of data in the ACT_RU_EXECUTION table, but if there are multiple execution processes under the process instance (for example, if there are sub-processes or parallel gateways), it will correspond to multiple pieces of data.
ACT_RU_VARIABLE: Variable information in the executing process instance
ACT_RU_TASK: The runtime information of the current to-do task, including the task ID, name, description, priority, creation time, expiration time, handler, task status and other information. The data in this table will be deleted after the task is completed.

Delete a process

Deleting process instances is divided into two aspects: deleting runtime data and historical data. Deleting runtime data will delete all runtime data of the process instance, including tasks, execution processes, events, etc., and the historical data of the process instance will also be deleted. Deleting historical data is to delete the historical data of the process instance that has ended, including historical tasks, historical variables, etc.

In addition, when using the process engine to delete process instances, you need to pay attention to the following points:

If there are to-do tasks for this process instance, these tasks need to be deleted or completed first.
If the process instance has been associated with information such as attachments, comments, historical records, etc., these associated information need to be cleared first.
If the process instance that needs to be deleted has already generated historical records, the historical records need to be deleted at the same time.

Map<String, Object> map = new HashMap<>();
// This step checks whether the historical process instance ACT_HI_PROCINST has a qualified one. Here is the business key, and what is returned is a single historical process instance.
HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery()
  .processInstanceBusinessKey(bizId).orderByProcessInstanceStartTime().desc().singleResult();
if (processInstance == null) {<!-- -->
  map.put("code", 1001);
  map.put("msg", "The process has not started!");
  return map;
}
String processInstId = processInstance.getId();
// Here you can not check the runtime process instance, but directly query whether endtime is null from the above historical process instance data. If it is not null, it means that the process has ended. You can use processInstance.getEndTime() to obtain it.
ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(processInstId).singleResult();
if (pi == null) {<!-- -->
  //This process instance has been completed
  historyService.deleteHistoricProcessInstance(processInstId);
} else {<!-- -->
  // TODO to-do refresh, because it has been deleted and cannot be found, so it is queried first and then pushed after deletion.
  //The following is to delete process instances, do not change the order.
  runtimeService.deleteProcessInstance(processInstId, "");
  historyService.deleteHistoricProcessInstance(processInstId);
}
map.put("code", 1000);
map.put("msg", "Process deleted successfully!");
return map;

Deleting the process will delete all data in the tables affected by the above started process (Current process instance)

Method related

Create process

Deployment deploy = repositoryService.createDeployment().addBpmnModel(bpmnName, bpmnModel).tenantId(tenantId.toString()).deploy();

[Explanation] The returned Deployment corresponds to the ACT_RE_DEPLOYMENT table

Verify whether the process model is legal

ProcessValidatorFactory processValidatorFactory = new ProcessValidatorFactory();
ProcessValidator processValidator = processValidatorFactory.createDefaultProcessValidator();
List<ValidationError> validate = processValidator.validate(bpmnModel);

【illustrate】

ProcessValidatorFactory is a factory class used to create process validators in Activiti. The createDefaultProcessValidator() method creates a default process validator instance. The given bpmnModel is then validated using the process validator, returning a List containing error information found during the validation process.

The validation process can help check whether the process definition conforms to the BPMN 2.0 specification, such as checking for the presence of unconnected nodes, invalid expressions, duplicate elements, etc. If there is error information in the verification results, you can make repairs or adjust the process definition based on the error information to ensure its correctness.