devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

保姆级教程！SpringBoot 优雅集成 Camunda 7 工作流引擎_camunda7

作者：Guff_9hys | 2024-07-09 15:43:09

赞

踩

camunda7

项目中需要用到工作流引擎来设计部分业务流程，框架选型最终选择了 Camunda7，关于 Camunda以及 Activity 等其他工作流 引擎的介绍及对比不再介绍，这里只介绍与现有Springboot项目的集成以及具体使用及配置

概念

  • 流程（PROCESS）: 通过工具建模最终生成的BPMN文件，里面有整个流程的定义

  • 流程实例（Instance）：流程启动后的实例

  • 流程变量（Variables）：流程任务之间传递的参数

  • 任务（TASK）：流程中定义的每一个节点

  • 流程部署：将之前流程定义的.bpmn文件部署到工作流平台

核心组件

  • Process Engine-流程引擎

  • Web Applicatons-web应用：基于web的管理页面

API介绍

官方文档

https://docs.camunda.org/manual/7.18/user-guide/process-engine/process-engine-api/

下面是官网的一些文档，有时间可以看看，下面说一些核心的东西。

图片

ProcessEngine

为流程引擎，可以通过他获取相关service，里面集成了很多相关service，默认实现如下：

图片

RepositoryService

此服务提供用于管理和操作部署和流程定义的操作，使用camunda的第一要务

RuntimeService

运行相关，启动流程实例、删除、搜索等

TaskService

所有围绕任务相关的操作，如完成、分发、认领等

HistoryService

提供引擎搜集的历史数据服务

IdentityService

用户相关，实际中用不太到

Springboot集成

依赖集成
maven

https://mvnrepository.com/search?q=org.camunda.bpm.springboot

可以根据需要引用版本，我这边用的是 7.18

需要3个maven依赖，分别是对应 流程引擎、Web管理平台、提供rest api操作接口包

  1. <dependency>
  2.     <groupId>org.camunda.bpm.springboot</groupId>
  3.     <artifactId>camunda-bpm-spring-boot-starter</artifactId>
  4.     <version>7.18.0</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>org.camunda.bpm.springboot</groupId>
  8.     <artifactId>camunda-bpm-spring-boot-starter-rest</artifactId>
  9.     <version>7.18.0</version>
  10. </dependency>
  11. <dependency>
  12.     <groupId>org.camunda.bpm.springboot</groupId>
  13.     <artifactId>camunda-bpm-spring-boot-starter-webapp</artifactId>
  14.     <version>7.18.0</version>
  15. </dependency>
数据库

我这边使用的是mysql，建了个新库 camunda（可自定义），启动后会自动生成所需表结构

POM文件
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.7.3</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.example</groupId>
  12.     <artifactId>camunda-demo</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>camunda-demo</name>
  15.     <description>camunda-demo</description>
  16.  
  17.     <properties>
  18.         <java.version>17</java.version>
  19.     </properties>
  20.  
  21.     <dependencies>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter</artifactId>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>org.camunda.bpm.springboot</groupId>
  28.             <artifactId>camunda-bpm-spring-boot-starter</artifactId>
  29.             <version>7.18.0</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.camunda.bpm.springboot</groupId>
  33.             <artifactId>camunda-bpm-spring-boot-starter-rest</artifactId>
  34.             <version>7.18.0</version>
  35.         </dependency>
  36.         <dependency>
  37.             <groupId>org.camunda.bpm.springboot</groupId>
  38.             <artifactId>camunda-bpm-spring-boot-starter-webapp</artifactId>
  39.             <version>7.18.0</version>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>mysql</groupId>
  43.             <artifactId>mysql-connector-java</artifactId>
  44.             <version>8.0.32</version>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework.boot</groupId>
  48.             <artifactId>spring-boot-starter-test</artifactId>
  49.             <scope>test</scope>
  50.         </dependency>
  51.     </dependencies>
  52.  
  53.  
  54.     <build>
  55.         <plugins>
  56.             <plugin>
  57.                 <groupId>org.springframework.boot</groupId>
  58.                 <artifactId>spring-boot-maven-plugin</artifactId>
  59.             </plugin>
  60.         </plugins>
  61.     </build>
  62.  
  63. </project>
application.yml
  1. server:
  2.   port: 8081
  3.  
  4.  
  5. # camunda登录信息配置
  6. camunda.bpm:
  7.   admin-user:
  8.     id: admin  #用户名
  9.     password: 123456  #密码
  10.     firstName: yu
  11.   filter:
  12.     create: All tasks
  13.  
  14. # mysql连接信息
  15. spring:
  16.   datasource:
  17.     driver-class-name: com.mysql.cj.jdbc.Driver
  18.     url: jdbc:mysql://localhost:8101/camunda
  19.     username: root
  20.     password: 123456
  21.     type: com.mysql.cj.jdbc.MysqlDataSource
启动效果

准备好前置工作，启动后效果如下：

图片

数据库表结构

启动后自动生成的表结构如下

图片

大概有这么几个表模块，重要的详细介绍下：

ACT_ID_

这部分表示用户模块，配置文件里面的用户，信息就在此模块

图片

ACT_HI_

表示流程历史记录

  • act_hi_actinst：执行的活动历史

  • act_hi_taskinst：执行任务历史

  • act_hi_procinst：执行流程实例历史

  • act_hi_varinst：流程变量历史表

ACT_RE_

表示流程资源存储

  • act_re_procdef：流程定义存储

  • act_re_deployment: 自动部署，springboot每次启动都会重新部署，生成记录

ACT_RU_

表示流程运行时表数据，流程结束后会删除

  • act_ru_execution：运行时流程实例

  • act_ru_task：运行时的任务

  • act_ru_variable：运行时的流程变量

ACT_GE_

流程通用数据

  • act_ge_bytearray：每次部署的文件2进制数据，所以如果文件修改后，重启也没用，因为重新生成了记录，需要清掉数据库，或者这个表记录

登录界面

登录地址为 http://localhost:8081/，输入用户名密码即为配置文件里面的 admin,123456

图片

主控制台

登陆成功后，如下所示，具体的使用在下面介绍

图片

具体业务集成

绘制流程图
下载

首先需要一个工具 Camunda Modeler 来画，下载地址：

https://camunda.com/download/modeler/

图片

解压缩后打开如下：

图片

绘制

新建一个

图片

我这边稍微画了一个，具体怎么画，就不在细说了，最后效果如下，模拟了个OA的流程

图片

任务分类

只介绍最常用的两种

  • 用户任务 （User Task）

图片

具体来说就是需要手动执行的任务，即需要我们这变写完业务代码后，调用代码

taskService.complete(taskId, variables);

才会完成的任务

  • 系统任务（Service Task）

图片

系统会自动帮我们完成的任务

网关

分为这么几类，会根据我们传入的流程变量及设定的条件走

图片

  • 排他网关（exclusive gateway）

这个网关只会走一个，我们走到这个网关时，会从上到下找第一个符合条件的任务往下走

  • 并行网关（Parallel Gateway）

这个网关不需要设置条件，会走所有的任务

  • 包含网关（Inclusive Gateway）

这个网关会走一个或者多个符合条件的任务

示例

图片

如上图包含网关，需要在网关的连线初设置表达式 condition，

参数来自于流程变量

两个参数：

switch2d 、 switch3d

  • 如果 都为true，则走任务1，3

  • 如果 switch2d 为true switch3d为false，则只走任务1

  • 如果 switch3d 为true switch2d为false，则只走任务3

  • 如果都为false，则直接走网关，然后结束

引入项目

将画好的流程图保存文件为 test_1.bpmn，在刚才的springboot项目中resources新建一个bpmn文件夹，放进去

图片

重启项目，发现web界面中已经被集成进来了

图片

具体开发

写几个测试controller和service

controller

图片

service

  1. public void startProcess() {
  2.     ProcessInstance instance = runtimeService.startProcessInstanceByKey("key");
  3.     System.out.println(instance.toString());
  4. }
  5.  
  6. public List<ProcessDefinition> findProcesses() {
  7.     return repositoryService.createProcessDefinitionQuery().list();
  8. }
  9.  
  10. public List<Task> findTasks() {
  11.     return taskService.createTaskQuery().list();
  12. }

启动流程成功，说明问题不大，接下来详细业务改进。

下一节介绍详细的业务集成及各种API（变量传递、自动任务）的使用

API使用

流程相关API
创建流程：

会同时创建第一个任务

ProcessInstance instance = runtimeService.startProcessInstanceByKey(processKey, params);
暂停流程

流程暂停后，再执行相关任务会报错，需要先重新激活任务

runtimeService.suspendProcessInstanceById(instance.getId());
重新激活流程
runtimeService.activateProcessInstanceById(instance.getId());
删除流程

会同时删除任务

runtimeService.deleteProcessInstance(instance.getId(), "手动删除");

图片

以上都可以在流程历史表 act_hi_procinst 里查询

任务相关API

基于service的查询类，都可先构建一个 query，然后在附上查询条件，实例几个

  1. List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().list();
  2. List<Task> list = taskService.createTaskQuery().taskAssignee("zhangsan").list();
  3. List<ProcessInstance> instances = runtimeService.createProcessInstanceQuery().listPage(1, 10);
查询历史任务
List<HistoricProcessInstance> list = historyService.createHistoricProcessInstanceQuery().list();
查询当前任务/分页
List<Task> list = taskService.createTaskQuery().orderByTaskCreateTime().desc().list();
任务回退

大体思路是拿到当前的任务，及当前任务的上一个历史任务，然后重启

代码示例

  1.  Task activeTask = taskService.createTaskQuery()
  2.                 .taskId(taskId)
  3.                 .active()
  4.                 .singleResult();
  5.         List<HistoricTaskInstance> historicTaskInstance = historyService.createHistoricTaskInstanceQuery()
  6.                 .processInstanceId(instanceId)
  7.                 .orderByHistoricActivityInstanceStartTime()
  8.                 .desc()
  9.                 .list();
  10.  
  11.         List<HistoricTaskInstance> historicTaskInstances = historicTaskInstance.stream().filter(v -> !v.getTaskDefinitionKey().equals(activeTask.getTaskDefinitionKey())).toList();
  12.  
  13.         Assert.notEmpty(historicTaskInstances, "当前已是初始任务！");
  14.         HistoricTaskInstance curr = historicTaskInstances.get(0);
  15.  
  16.         runtimeService.createProcessInstanceModification(instanceId)
  17.                 .cancelAllForActivity(activeTask.getTaskDefinitionKey())
  18.                 .setAnnotation("重新执行")
  19.                 .startBeforeActivity(curr.getTaskDefinitionKey())
  20.                 .execute();
流程变量

包括流程中产生的变量信息，包括控制流程流转的变量，网关、业务表单中填写的流程需要用到的变量等。很多地方都要用到

流程变量变量传递

变量最终会存在 act_ru_variable 这个表里面

在绘制流程图的时候，如果是用户任务（userService） 可以设置变量，比如执行人

图片

写法有这么几种方式

  • 写死，就比如 zhangsan

  • 表达式，比如上面写的 ${user}，这种需要传入参数，其实就是启动参数的时候传入，传入参数，可选值为一个Map<String, Object>，之后的流程可查看次参数，上面写的是 user， 所以map里面的key需要带着user，不然会报错。

关于扩展变量，可在流程图绘制这么设定，传递方式还是一样，

流程图里面在下面写：

图片

代码：

ProcessInstance instance = runtimeService.startProcessInstanceByKey(key, new HashMap<>());
变量设置
runtimeService.setVariable(instance.getId(), Constants.PATIENT_ID, relatedId);
变量查询
 Object variable = runtimeService.getVariable(instance.getId(), Constants.GENERAL_ID);
历史变量查询
  1.  HistoricVariableInstance variableInstance = historyService.createHistoricVariableInstanceQuery().processInstanceId(bo.getId().toString()).
  2.             variableName(Constants.PATIENT_ID).singleResult();
  3. //变量值
  4. variableInstance.getValue();
  5. //变量名称
  6. variableInstance.getName();

针对后端来说任务类型主要有两种。

用户任务-userTask

即需要用户参与的任务，因为工作流执行过程中需要涉及到审批、过审之类的需要用户参与的任务，这个时候需要用户参与，然后调用接口完成任务。

服务任务-serviceTask

即自动执行的任务，比如用户提交后，系统自动存储、修改状态等自动完成的任务。

Type

任务类型是关键，可根据配型配置实现调用 java的方法，spring 的bean方法，等等有这么几种类型

图片

推荐使用 -- Delegate Expression !!!

在系统任务中，因为是自动执行，所以实际应用中需要嵌入各种业务逻辑，可以在流程图设计中，按照下面方式调用java代码执行，在spring中配置同名的bean

图片

配置表达式，可以实现JavaDelegate接口使用类名配置，快捷写法如下，比较推荐下面这种，此种可灵活配置bean和spring结合使用，注入service等业务方法

  1. @Bean("t17")
  2. JavaDelegate t17() {
  3.     return execution -> {
  4.         Map<String, Object> variables = execution.getVariables();
  5.         Task task = taskService.createTaskQuery().processInstanceId(execution.getProcessInstanceId()).singleResult();
  6.         //业务逻辑
  7.         task.setOwner(String.valueOf(dentistId));
  8.     };
  9. }
Java Class ：

配置java类名，需要实现JavaDelegate接口，注意是全路径名，不可以使用Spring的bean配置！！！

  1. @Component
  2. public class T17Delegate implements JavaDelegate {
  3.  
  4.     @Override
  5.     public void execute(DelegateExecution execution) throws Exception {
  6.             String taskId = execution.getId();
  7.             String instanceId = execution.getProcessInstanceId();
  8.             Map<String, Object> variables = execution.getVariables();
  9.     }
  10. }

下面两种可使用spring的配置

Expression：

EL表达式，调用java类的方法 ，规范：

expression=“#{monitorExecution.execution(execution)}”

  1. @Component("monitorExecution")
  2. public class MonitorExecution {
  3.     public void execution(DelegateExecution execution){
  4.         String processInstanceId = execution.getProcessInstanceId();
  5.     }
  6. }
任务监听器 - Task Listener

任务监听器用于在某个与任务相关的事件发生时执行自定义Java逻辑或表达式。它只能作为用户任务的子元素添加到流程定义中。

请注意，这也必须作为BPMN 2.0扩展元素的子级和Camunda命名空间中发生，因为任务侦听器是专门为Camunda引擎构建的。

适用场景：

  1. @Bean
  2. TaskListener t21() {
  3.     return delegateTask -> {
  4.  
  5.         String taskId = delegateTask.getId();
  6.         String instanceId = delegateTask.getProcessInstanceId();
  7.         
  8.         Map<String, Object> variables = delegateTask.getVariables();
  9.         // TODO: 20log/3/22
  10.         delegateTask.setVariable("", "");
  11.     };
  12. }
执行监听器 - Execution Listener

执行侦听器在流程执行过程中发生某些事件时执行外部Java代码或计算表达式。可以用在任何任务中，可以捕获的事件有：

  • 流程实例的开始和结束。

  • 进行过渡。

  • 活动的开始和结束。

  • 网关的开始和结束。

  • 中间事件的开始和结束。

  • 结束开始事件或开始结束事件

适用场景：每个任务结束时设置任务进度

  1.  public class ExampleExecutionListenerOne implements ExecutionListener {
  2.  
  3.     public void notify(DelegateExecution execution) throws Exception {
  4.       execution.setVariable("variableSetInExecutionListener", "firstValue");
  5.       execution.setVariable("eventReceived", execution.getEventName());
  6.     }
  7.   }
扩展属性- Extension properties

扩展属性适用于很多自定义的业务属性，比如设置业务流程进度

图片

流程权限及创建人设置

IdentityService为鉴权相关服务，但是我们实际开发中，一般会用到我们自己的鉴权系统，所以可以使用camunda提供的api来设置，具体可以看IdentityServiceImpl这个类，其中也是使用了ThreadLocal来保存鉴权信息 ，代码在下面

private ThreadLocal<Authentication> currentAuthentication = new ThreadLocal<Authentication>();

用户信息设置：

  1. // Userutil是我们自己封装的用户工具类
  2. identityService.setAuthenticatedUserId(UserUtil.getUserId().toString());
  3.  
  4. //获取
  5. Authentication authentication = identityService.getCurrentAuthentication();

他内置很多比如开启流程时候，会默认找当前登录的人，这个类DefaultHistoryEventProducer

  1. // set super process instance id
  2. ExecutionEntity superExecution = executionEntity.getSuperExecution();
  3. if (superExecution != null) {
  4.   evt.setSuperProcessInstanceId(superExecution.getProcessInstanceId());
  5. }
  6.  
  7. //state
  8. evt.setState(HistoricProcessInstance.STATE_ACTIVE);
  9.  
  10. // set start user Id
  11. evt.setStartUserId(Context.getCommandContext().getAuthenticatedUserId());
任务执行人及发起人设置
  1. //根据任务id设置执行人
  2. taskService.setAssignee(task.getId(), UserUtil.getUserId().toString());

最后说一句(求关注!别白嫖！)

如果这篇文章对您有所帮助，或者有所启发的话，求一键三连：点赞、转发、在看。

关注公众号：woniuxgg，在公众号中回复：笔记  就可以获得蜗牛为你精心准备的java实战语雀笔记，回复面试、开发手册、有超赞的粉丝福利！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/802882
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号