Shulou(Shulou.com)06/01 Report--

This article mainly introduces how to use Springboot+Flowable to quickly achieve the development of workflow related knowledge, the content is detailed and easy to understand, the operation is simple and fast, has a certain reference value, I believe that everyone after reading this article on how to use Springboot+Flowable to quickly achieve workflow development article will have a harvest, let's take a look.

I. flowable-ui deployment and operation

Flowable-6.6.0 runs the official demo

1. Download flowable-6.6.0: https://github.com/flowable/flowable-engine/releases/download/flowable-6.6.0/flowable-6.6.0.zip from the official website

2. Throw the flowable-6.6.0\ wars\ flowable-ui.war in the compressed package into Tomcat and run

3. Open the http://localhost:8080/flowable-ui account: log in with admin/test

4. Enter the APP.MODELER creation process, and then export the process to the project, or configure apache-tomcat-9.0.37\ webapps\ flowable-ui\ WEB-INF\ classes\ flowable-default.properties to connect to the local database.

Note: java driver jar (mysql-connector-java-5.1.45.jar) needs to be copied to apache-tomcat-9.0.37\ webapps\ flowable-rest\ WEB-INF\ lib

In this way, the process back-end program created can directly use the

Second, draw the flow chart

According to the business needs, draw the flow chart in flowable-ui > APP.MODELER, such as the figure above. Explain some concepts first.

Events (event) are usually used to model what happens in the process lifecycle, with the start and end circles in the diagram.

A sequential flow (sequence flow) is a connector between two elements in a process. In the picture is the arrow line segment.

The gateway (gateway) is used to control the flow of execution.

In the picture is [diamond (with X in the middle)]

User tasks (user task) are used to model tasks that need to be performed manually. The picture is [rectangle].

These are probably the elements of a simple workflow (there are many more that will not be extended here). Here is a description of how the workflow flows.

First, after the workflow is started, the [start] node automatically flows to the [student] node, waiting for the task to be executed. The assigned student user flows to the [teacher] node after the task is executed, and waits for the task to be executed again. After execution, the assigned teacher user flows to the [gateway], which checks each exit and flows to the qualified task. For example, if the teacher agrees to execute the task, it flows to the [principal] node and waits for the task to be executed. After execution, it is similar to the teacher, and after consent, it flows to the end node, and the whole process ends here.

Drawing details:

1. Retain the process model

2. Sequential flow can be restricted by setting flow conditions, such as the gateway exit above.

3. Executive users whose tasks need to be assigned can be assigned to candidate groups or directly to candidates

Finally, export the workflow file

File content

Omit here first.

4. Import bpmn files

If necessary, you can download the process file and import it directly for use

Third, backstage project construction

Background projects are based on jdk8 and use the springboot framework

Spring version

Org.springframework.boot spring-boot-starter-parent 2.3.0.RELEASE

The project depends on pom.xml

Org.flowable flowable-spring-boot-starter 6.6.0 mysql mysql-connector-java 5.1.45

Project configuration application.yml

Spring: datasource: url: jdbc:mysql://localhost:3306/flowable?useSSL=false&characterEncoding=UTF-8&serverTimezone=GMT%2B8 driver-class-name: com.mysql.jdbc.Driver username: root password: 123456 IV. Database

1. All database tables in Flowable start with ACT_. The second part is a two-character identifier that describes the purpose of the table. The naming of the service API also roughly conforms to this rule.

2. ACT_RE_: 'RE' stands for repository. Tables with this prefix contain "static" information, such as process definitions and process resources (pictures, rules, etc.).

3. ACT_RU_: 'RU' stands for runtime. These tables store runtime information, such as process instance (process instance), user task (user task), variable (variable), job (job), etc. Flowable only saves run-time data in the process instance and deletes records at the end of the process instance. This ensures that the runtime table is small and fast.

4. ACT_HI_: 'HI' stands for history. These tables store historical data, such as completed process instances, variables, tasks, and so on.

5. ACT_GE_: general data. It is used in many places.

1) General data sheets (2)

Act_ge_bytearray: binary data tables, such as process definitions, process templates, byte flow files for flowcharts

Act_ge_property: attribute data sheet (not commonly used)

2) History tables (8, tables operated by HistoryService interface)

Act_hi_actinst: historical node table, which stores the information of each node running by the process instance (including non-task nodes such as start and end)

Act_hi_attachment: history attachment table, which stores the attachment information uploaded by history nodes (not commonly used)

Act_hi_comment: historical opinion form

Act_hi_detail: historical details table, storing some information about the operation of nodes (not commonly used)

Act_hi_identitylink: historical process personnel table, which stores information about candidates and managers of each node of the process. It is often used to query the completed tasks of a person or department.

Act_hi_procinst: historical process instance table, which stores historical data of process instances (including running process instances)

Act_hi_taskinst: historical process task table, storage historical task node

Act_hi_varinst: process history variable table, which stores the variable information of the process history node

3) user-related tables (4, tables operated by IdentityService interface)

Act_id_group: user group information table, corresponding to the candidate group information selected by the node

Act_id_info: user extension information table, storing user extension information

Act_id_membership: user and user group relationship table

Act_id_user: user information table, corresponding to the information of the manager or candidate selected by the node

4) process definition, process template related tables (3, tables operated by RepositoryService interface)

Act_re_deployment: subordinate information table, storing process definition, template deployment information

Act_re_procdef: the process definition information table stores the description information related to the process definition, but its real content is stored in the act_ge_ bytearray table in bytes

Act_re_model: the process template information table, which stores the description information related to the process template, but its real content is stored in the act_ge_ byte table in bytes.

5) process runtime tables (6, tables operated by RuntimeService interface)

Act_ru_task: runtime process task node table, which stores the task node information of the running process. It is important and is often used when querying people or departments'to-do tasks.

Act_ru_event_subscr: monitoring information table, not commonly used

Act_ru_execution: runtime process execution instance table, recording each branch information of the running process (when there is no sub-process, its data corresponds to the act_ru_ task table data one to one)

Act_ru_identitylink: runtime process personnel table, important, often used when querying people or department to-do tasks

Act_ru_job: runtime timed task data table, which stores timed task information of the process

Act_ru_variable: runtime process variable data table, which stores the variable information of each node of the running process

Process engine API and service

1. RepositoryService is probably the first service to use when using the Flowable engine. This service provides management and control deployment (deployments) and process definition (process definitions) operations. Manage static information

2. RuntimeService is used to start a new process instance of a process definition.

3. IdentityService is very simple. It is used to manage (create, update, delete, query... ) groups and users.

4. FormService is an optional service. In other words, Flowable works well without it without sacrificing any functionality.

5. HistoryService exposes all historical data collected by the Flowable engine. To provide the ability to query historical data.

6. ManagementService usually does not need to be used when writing user applications in Flowable. It can read the information of database tables and raw data of tables, and also provides query and management operations for jobs (job).

7. DynamicBpmnService can be used to modify parts of a process definition without having to redeploy it. For example, you can modify the handler settings for a user task in the process definition, or modify the class name in a service task.

Next, use the previous leave flow chart and code it.

Code

Import lombok.extern.slf4j.Slf4j;import org.flowable.engine.HistoryService;import org.flowable.engine.RepositoryService;import org.flowable.engine.RuntimeService;import org.flowable.engine.history.HistoricProcessInstance;import org.flowable.engine.repository.Deployment;import org.flowable.engine.repository.ProcessDefinition;import org.flowable.engine.runtime.Execution;import org.flowable.engine.runtime.ProcessInstance;import org.flowable.idm.api.Group;import org.flowable.idm.api.User;import org.flowable.task.api.Task Import org.flowable.task.api.history.HistoricTaskInstance;import org.springframework.beans.factory.annotation.Autowired;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.zip.ZipInputStream;/** * TestFlowable * * @ Author * @ Date: 23:35 * @ Version 1.0 * / @ Slf4jpublic class TestFlowable {@ Autowired private RepositoryService repositoryService; private RuntimeService runtimeService on 2021-10-17 Private HistoryService historyService; private org.flowable.engine.TaskService taskService; private org.flowable.engine.IdentityService identityService Public void createDeploymentZip () {/ * * @ Date: 23:38 * Step 1 on 2021-10-17: deploy xml (compressed to zip format, direct xml needs to be configured with relative path, trouble, not available) * / try {File zipTemp = new File ("f:/leave_approval.bpmn20.zip"); ZipInputStream zipInputStream = new ZipInputStream (new FileInputStream (zipTemp)) Deployment deployment = repositoryService .createdeployment () .addZipInputStream (zipInputStream) .deploy (); log.info ("deployment success: {}", deployment.getId ());} catch (FileNotFoundException e) {e.printStackTrace () } * @ Date: 23:40 * Step 2 on 2021-10-17: process definition for query deployment List list = repositoryService.createProcessDefinitionQuery (). ProcessDefinitionKey ("leave_approval"). List (); List pages = repositoryService.createProcessDefinitionQuery (). ProcessDefinitionKey ("leave_approval"). ListPage (1,30); * Step 3: start the process and create an instance String processDefinitionKey = "leave_approval" / / key defined by the process, corresponding to the flowchart of asking for leave String businessKey = "schoolleave"; / / Business code, according to your own business, use Map variablesDefinition = new HashMap (); / / process variables, you can customize and extend ProcessInstance processInstance = runtimeService.startProcessInstanceByKey (processDefinitionKey, businessKey, variablesDefinition); log.info ("start successfully: {}", processInstance.getId ()) * Step 4: query the list of all instances started by the specified process * list, or delete List executions = runtimeService.createExecutionQuery (). ProcessDefinitionKey ("leave_approval"). List (); List executionPages = runtimeService.createExecutionQuery (). ProcessDefinitionKey ("leave_approval"). ListPage (1,30); / / runtimeService.deleteProcessInstance (processInstanceId, deleteReason) / / delete instance * Step 5: students query tasks that can be operated, and complete the task String candidateGroup = "stu_group"; / / flowable:candidateGroups= "stu_group" List taskList = taskService.createTaskQuery (). TaskCandidateGroup (candidateGroup). OrderByTaskCreateTime (). Desc (). List () in the candidate group xml file. For (Task task: taskList) {/ / apply for the task taskService.claim (task.getId (), "my"); / / complete the taskService.complete (task.getId ()); * Step 6: the teacher queries the available tasks and completes the task String candidateGroupTe = "te_group" / / flowable:candidateGroups= "te_group" List taskListTe in the candidate group xml file = taskService.createTaskQuery (). TaskCandidateGroup (candidateGroupTe). OrderByTaskCreateTime (). Desc (). List (); for (Task task: taskListTe) {taskService.claim (task.getId (), "myte"); Map variables = new HashMap (); variables.put ("command", "agree") / / carries variables for determining the conditions of the gateway process. The condition here is to agree to taskService.complete (task.getId (), variables). * @ Date: 0:17 on 2021-10-18 * Step 7: history query, because once the process is executed, the data of the activity will be emptied, and none of the above query APIs can find the data, but provide a history query API / / history process instance List historicProcessList = historyService.createHistoricProcessInstanceQuery (). ProcessDefinitionKey ("leave_approval"). List () / / Historical task List historicTaskList = historyService.createHistoricTaskInstanceQuery () .processDefinitionKey ("leave_approval") .list (); / / instance history variable, task history variable / / historyService.createHistoricVariableInstanceQuery () .processInstanceId (processInstanceId); / / historyService.createHistoricVariableInstanceQuery () .taskId (taskId) / / * delimiter * * * / / API / / Mobile tasks that may be needed Artificially redirect task / / runtimeService.createChangeActivityStateBuilder () .processInstanceId (processInstanceId) / / .moveActivityIdTo (currentActivityTaskId, newActivityTaskId) .changeState () / / if grouping and users are configured in the database, List users = identityService.createUserQuery () .list () is also used. / / user id corresponds to the user List groups = identityService.createGroupQuery () .list () configured in xml. / / grouping query, grouping id corresponds to the grouping configured in xml, such as stu_group,te_group is the value of id in the table / / in addition, each query can spell conditions, built-in so many queries, including fuzzy queries, size comparison} on "how to use Springboot+Flowable to quickly achieve workflow development" this article is introduced here, thank you for reading! I believe that everyone has a certain understanding of the knowledge of "how to use Springboot+Flowable to quickly realize the development of workflow". If you want to learn more knowledge, welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.