Camunda 7工作流引擎 API 以及与Springboot集成实现工作流配置全纪录_camunda7

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

Process Engine-流程引擎

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

示例代码放到了github上，地址在下面

ricardo-m-yu/spring-boot-camunda (github.com)

API介绍

Process Engine API | docs.camunda.org

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

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

        <dependency>
            <groupId>org.camunda.bpm.springboot</groupId>
            <artifactId>camunda-bpm-spring-boot-starter</artifactId>
            <version>7.18.0</version>
        </dependency>
        <dependency>
            <groupId>org.camunda.bpm.springboot</groupId>
            <artifactId>camunda-bpm-spring-boot-starter-rest</artifactId>
            <version>7.18.0</version>
        </dependency>
        <dependency>
            <groupId>org.camunda.bpm.springboot</groupId>
            <artifactId>camunda-bpm-spring-boot-starter-webapp</artifactId>
            <version>7.18.0</version>
        </dependency>

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

POM文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>camunda-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>camunda-demo</name>
    <description>camunda-demo</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.camunda.bpm.springboot</groupId>
            <artifactId>camunda-bpm-spring-boot-starter</artifactId>
            <version>7.18.0</version>
        </dependency>
        <dependency>
            <groupId>org.camunda.bpm.springboot</groupId>
            <artifactId>camunda-bpm-spring-boot-starter-rest</artifactId>
            <version>7.18.0</version>
        </dependency>
        <dependency>
            <groupId>org.camunda.bpm.springboot</groupId>
            <artifactId>camunda-bpm-spring-boot-starter-webapp</artifactId>
            <version>7.18.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
 application.yml 
 server:
  port: 8081
# camunda登录信息配置
camunda.bpm:
  admin-user:
    id: admin  #用户名
    password: 123456  #密码
    firstName: yu
  filter:
    create: All tasks
# mysql连接信息
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:8101/camunda
    username: root
    password: 123456
    type: com.mysql.cj.jdbc.MysqlDataSource 
 准备好前置工作，启动后效果如下： 
 如果 都为true，则走任务1，3 
 如果 switch2d 为true switch3d为false，则只走任务1 
 如果 switch3d 为true switch2d为false，则只走任务3 
 如果都为false，则直接走网关，然后结束 
 将画好的流程图保存文件为 test_1.bpmn，在刚才的springboot项目中resources新建一个bpmn文件夹，放进去， 
    public void startProcess() {
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("key");
        System.out.println(instance.toString());
    public List<ProcessDefinition> findProcesses() {
        return repositoryService.createProcessDefinitionQuery().list();
    public List<Task> findTasks() {
        return taskService.createTaskQuery().list();
 启动流程成功，说明问题不大，接下来详细业务改进。 
 下一篇介绍详细的业务集成及各种API（变量传递、自动任务）的使用 
 API使用 
 流程相关API 
 创建流程： 
 会同时创建第一个任务 
 ProcessInstance instance = runtimeService.startProcessInstanceByKey(processKey, params); 
 流程暂停后，再执行相关任务会报错，需要先重新激活任务 
 runtimeService.suspendProcessInstanceById(instance.getId()); 
 重新激活流程 
 runtimeService.activateProcessInstanceById(instance.getId()); 
 会同时删除任务 
 runtimeService.deleteProcessInstance(instance.getId(), "手动删除"); 
 基于service的查询类，都可先构建一个 query，然后在附上查询条件，实例几个 
 List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().list();
List<Task> list = taskService.createTaskQuery().taskAssignee("zhangsan").list();
List<ProcessInstance> instances = runtimeService.createProcessInstanceQuery().listPage(1, 10); 
 查询历史任务 
 List<HistoricProcessInstance> list = historyService.createHistoricProcessInstanceQuery().list(); 
 查询当前任务/分页 
 List<Task> list = taskService.createTaskQuery().orderByTaskCreateTime().desc().list(); 
 大体思路是拿到当前的任务，及当前任务的上一个历史任务，然后重启 
  Task activeTask = taskService.createTaskQuery()
                .taskId(taskId)
                .active()
                .singleResult();
        List<HistoricTaskInstance> historicTaskInstance = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(instanceId)
                .orderByHistoricActivityInstanceStartTime()
                .desc()
                .list();
        List<HistoricTaskInstance> historicTaskInstances = historicTaskInstance.stream().filter(v -> !v.getTaskDefinitionKey().equals(activeTask.getTaskDefinitionKey())).toList();
        Assert.notEmpty(historicTaskInstances, "当前已是初始任务！");
        HistoricTaskInstance curr = historicTaskInstances.get(0);
        runtimeService.createProcessInstanceModification(instanceId)
                .cancelAllForActivity(activeTask.getTaskDefinitionKey())
                .setAnnotation("重新执行")
                .startBeforeActivity(curr.getTaskDefinitionKey())
                .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); 
 历史变量查询 
  HistoricVariableInstance variableInstance = historyService.createHistoricVariableInstanceQuery().processInstanceId(bo.getId().toString()).
            variableName(Constants.PATIENT_ID).singleResult();
//变量值
variableInstance.getValue();
//变量名称
variableInstance.getName(); 
 针对后端来说任务类型主要有两种。 
 用户任务-userTask 
 即需要用户参与的任务，因为工作流执行过程中需要涉及到审批、过审之类的需要用户参与的任务，这个时候需要用户参与，然后调用接口完成任务。 
 服务任务-serviceTask 
 即自动执行的任务，比如用户提交后，系统自动存储、修改状态等自动完成的任务。 
 任务类型是关键，可根据配型配置实现调用 java的方法，spring 的bean方法，等等有这么几种类型 
 配置表达式，可以实现JavaDelegate接口使用类名配置，快捷写法如下，比较推荐下面这种，此种可灵活配置bean和spring结合使用，注入service等业务方法 
   @Bean("t17")
    JavaDelegate t17() {
        return execution -> {
            Map<String, Object> variables = execution.getVariables();
            Task task = taskService.createTaskQuery().processInstanceId(execution.getProcessInstanceId()).singleResult();
            //业务逻辑
            task.setOwner(String.valueOf(dentistId));
 Java Class ： 
 配置java类名，需要实现JavaDelegate接口，注意是全路径名，不可以使用Spring的bean配置！！！ 
 @Component
public class T17Delegate implements JavaDelegate {
    @Override
    public void execute(DelegateExecution execution) throws Exception {
            String taskId = execution.getId();
            String instanceId = execution.getProcessInstanceId();
            Map<String, Object> variables = execution.getVariables();
 下面两种可使用spring的配置 
 Expression：  
 EL表达式，调用java类的方法 ，规范： 
 expression=“#{monitorExecution.execution(execution)}” 
 @Component("monitorExecution")
public class MonitorExecution {
    public void execution(DelegateExecution execution){
        String processInstanceId = execution.getProcessInstanceId();
 任务监听器 - Task Listener 
 任务监听器用于在某个与任务相关的事件发生时执行自定义Java逻辑或表达式。它只能作为用户任务的子元素添加到流程定义中。请注意，这也必须作为BPMN 2.0扩展元素的子级和Camunda命名空间中发生，因为任务侦听器是专门为Camunda引擎构建的。 
 适用场景： 
 @Bean
    TaskListener t21() {
        return delegateTask -> {
            String taskId = delegateTask.getId();
            String instanceId = delegateTask.getProcessInstanceId();
            Map<String, Object> variables = delegateTask.getVariables();
            // TODO: 20log/3/22
            delegateTask.setVariable("", "");
 执行监听器 - Execution Listener 
 执行侦听器在流程执行过程中发生某些事件时执行外部Java代码或计算表达式。可以用在任何任务中，可以捕获的事件有： 
 流程实例的开始和结束。 
 进行过渡。 
 活动的开始和结束。 
 网关的开始和结束。 
 中间事件的开始和结束。 
 结束开始事件或开始结束事件 
 适用场景：每个任务结束时设置任务进度 
  public class ExampleExecutionListenerOne implements ExecutionListener {
    public void notify(DelegateExecution execution) throws Exception {
      execution.setVariable("variableSetInExecutionListener", "firstValue");
      execution.setVariable("eventReceived", execution.getEventName());
 扩展属性- Extension properties 
 扩展属性适用于很多自定义的业务属性，比如设置业务流程进度 
 流程权限及创建人设置 
 IdentityService为鉴权相关服务，但是我们实际开发中，一般会用到我们自己的鉴权系统，所以可以使用camunda提供的api来设置，具体可以看IdentityServiceImpl这个类，其中也是使用了ThreadLocal来保存鉴权信息 ，代码在下面 
 private ThreadLocal<Authentication> currentAuthentication = new ThreadLocal<Authentication>(); 
 用户信息设置： 
 // Userutil是我们自己封装的用户工具类
identityService.setAuthenticatedUserId(UserUtil.getUserId().toString());
Authentication authentication = identityService.getCurrentAuthentication(); 
 他内置很多比如开启流程时候，会默认找当前登录的人，这个类DefaultHistoryEventProducer 
   // set super process instance id
    ExecutionEntity superExecution = executionEntity.getSuperExecution();
    if (superExecution != null) {
      evt.setSuperProcessInstanceId(superExecution.getProcessInstanceId());
    //state
    evt.setState(HistoricProcessInstance.STATE_ACTIVE);
    // set start user Id
    evt.setStartUserId(Context.getCommandContext().getAuthenticatedUserId());
 任务执行人及发起人设置 
 //根据任务id设置执行人
taskService.setAssignee(task.getId(), UserUtil.getUserId().toString()); 
                                    Camunda支持三种引擎模式的特点如下：
1. Container-managed Engine：流程引擎会作为一个独立的组件运行在JVM中，由CAMUNDA容器管理，也就是官方自带了一套管理系统。
2. Embedded Engine：流程引擎会嵌入到你的应用中，由应用直接管理，因此可以获得更好的控制和性能。
3. Remote Engine：流程引擎会作为一个独立的组件运行在另一个JVM中，作为远程BPM服务器运行，通过RMI或HTTP通信与远程引擎交互。
                                    2.根据自己环境选择合适的版本，选择完毕点击GENRATE PROJECT导出项目即可。1.通过Idea初始化创建Springboot项目，并在pom文件中添加相关的依赖。完成上述配置后,即可启动项目，项目运行成功后会在数据库中创建相对应的49张数据表。一、Springboot集成Camunda有两种方式，以下均可。输入application.yml中设置的用户名和密码。对application.yml进行设置。打开浏览器访问即可出现如下所示界面。出现如上所示代表搭建成功。
                                    工作流（Workflow），是对工作流程及其各操作步骤之间业务规则的抽象、概括描述。指在组织中，多个任务、活动或过程之间的顺序和控制流。这些任务通常涉及多个参与者、系统或部门，工作流的目标是将复杂的业务逻辑分解为多个可管理的逻辑段，并统一控制这些逻辑段的执行条件、执行顺序以及相互通信，从而实现业务逻辑的解耦与优化。这种方式不仅提高了业务流程的灵活性和可维护性，还促进了各个环节之间的协同工作。
                                    Camunda 是一种轻量级的商业流程开源平台。Camunda是一个基于Java的框架，支持用于工作流和流程自动化的BPMN、用于案例管理的CMMN和用于业务决策管理的DMN
                                    工作流可以实现业务流程的自动化，用户可以自己定义工作流程，通过流程来把常用的任务组织起来，而无需在程序中固化流程。这也符合当今微服务，低代码开发的趋势。Camunda是目前主流的一个工作流平台，遵循业界的标准(BPMN, DMN...)，国内的很多低代码工作流平台也是基于Camunda来做进一步的定制开发的。Camunda目前有7和8两个版本，其中最新的8版本是采用SAAS的方式来提供服务，也可以基于Kubernets来部署在云上。但是8版本虽然可以免费使用和更改，但是如果用于商业用途是受限制的。7版本分为
                                    这里我传递了审批人（流程界面中，设置了${adminList} ${mpmList}）由于taskid已经在url中传递了，所以审批人是可以确定的。传递你的bpmn名称，通过file类型选择bpmn文件。5.3 获取待办任务 （BusinessKey）5.1 获取待办任务 （某人&进程ID）以下接口，除了端口和参数，其他无需改动。并且设置了businessKey。上面的id，就是步骤3返回的id。上面的Id就是来自步骤2的id。5.2 获取待办任务 （某人）webapp 是网页。
       1、前端传他自己的Json结构。当然必要时需要添加后端定制化的东西
       2、后端解析为Camunda识别的Json结构
       3、解析中需要通过camunda 的 用户任务与服务任务调用自己业务的逻辑
       4、发布流程定义