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

Spring Boot 项目集成camunda流程引擎

作者：小蓝xlanll | 2024-02-27 10:38:31

赞

踩

Spring Boot 项目集成camunda流程引擎

使用camunda开源工作流引擎有：通过docker运行、使用springboot集成、部署camunda发行包、基于源代码编译运行等多种方式。

其中，通过源代码编译运行的方式最为复杂，具体参考：https://lowcode.blog.csdn.net/article/details/136206057

文本重点介绍如何在Spring Boot应用程序中如何集成Camunda Platform开源流程平台，这也是项目中最为常见的一种使用方式。

在本教程中，我们假设您熟悉 Java Web 应用程序开发和 Spring Boot 的基础知识。前提条件是您已经安装了 Eclipse/IDEA等Java开发工具和 Camunda Modeler流程设计器。

1、新建Spring Boot 项目集成camunda

首先，让我们在您选择的 IDE 中设置您的第一个流程应用程序项目。

该项目需要 Java jdk8以上版本。我本地使用的JDK版本为11，使用的开发工具IDEA2023。

1.1、创建新的 Maven 项目

首先，用IDEA工具建立了一个新的基于 Apache Maven 的项目，项目名称命名为camunda7-springboot。

1.2、添加 Camunda 平台和 Spring Boot 依赖项

下一步包括为新项目设置 Maven 依赖项。需要将 Maven 依赖添加到项目的文件中。由于本示例要使用camunda流程引擎、web界面、Rest服务接口，所以需要导入camunda-bpm-spring-boot-starter-rest、camunda-bpm-spring-boot-starter-webapp依赖包。我们在“依赖管理”部分添加了 Spring Boot BOM和camunda相关依赖，这将自动将  camunda 引擎、rest服务接口和 Web 应用程序包含在应用程序中。

我们使用camunda7.19.0版本，该版本支持jdk8和springboot2。camunda和springboot版本的依赖对应关系，查看官方文档说明：Spring Boot Version Compatibility | docs.camunda.org

  1.  
  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0"
  4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  6.     <modelVersion>4.0.0</modelVersion>
  7.  
  8.     <groupId>com.yuncheng</groupId>
  9.     <artifactId>camunda7-springboot</artifactId>
  10.     <version>1.0-SNAPSHOT</version>
  11.  
  12.     <properties>
  13.         <maven.compiler.source>11</maven.compiler.source>
  14.         <maven.compiler.target>11</maven.compiler.target>
  15.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  16.         <camunda.spring-boot.version>7.19.0</camunda.spring-boot.version>
  17.         <spring-boot.version>2.7.9</spring-boot.version>
  18.     </properties>
  19.  
  20.     <dependencyManagement>
  21.         <dependencies>
  22.             <dependency>
  23.                 <groupId>org.springframework.boot</groupId>
  24.                 <artifactId>spring-boot-dependencies</artifactId>
  25.                 <version>${spring-boot.version}</version>
  26.                 <type>pom</type>
  27.                 <scope>import</scope>
  28.             </dependency>
  29.         </dependencies>
  30.     </dependencyManagement>
  31.  
  32.     <dependencies>
  33.         <dependency>
  34.             <groupId>org.camunda.bpm.springboot</groupId>
  35.             <artifactId>camunda-bpm-spring-boot-starter-webapp</artifactId>
  36.             <version>${camunda.spring-boot.version}</version>
  37.         </dependency>
  38.         <dependency>
  39.             <groupId>org.camunda.bpm.springboot</groupId>
  40.             <artifactId>camunda-bpm-spring-boot-starter-rest</artifactId>
  41.             <version>${camunda.spring-boot.version}</version>
  42.         </dependency>
  43.         <dependency>
  44.             <groupId>org.springframework.boot</groupId>
  45.             <artifactId>spring-boot-starter-jdbc</artifactId>
  46.         </dependency>
  47.         <dependency>
  48.             <groupId>com.h2database</groupId>
  49.             <artifactId>h2</artifactId>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>com.mysql</groupId>
  53.             <artifactId>mysql-connector-j</artifactId>
  54.         </dependency>
  55.         <dependency>
  56.             <groupId>com.sun.xml.bind</groupId>
  57.             <artifactId>jaxb-impl</artifactId>
  58.             <version>2.3.6</version>
  59.         </dependency>
  60.     </dependencies>
  61.  
  62.     <build>
  63.         <finalName>${project.artifactId}</finalName>
  64.         <plugins>
  65.             <plugin>
  66.                 <groupId>org.springframework.boot</groupId>
  67.                 <artifactId>spring-boot-maven-plugin</artifactId>
  68.             </plugin>
  69.             <!--指定JDK编译版本 -->
  70.             <plugin>
  71.                 <groupId>org.apache.maven.plugins</groupId>
  72.                 <artifactId>maven-compiler-plugin</artifactId>
  73.                 <configuration>
  74.                     <source>1.8</source>
  75.                     <target>1.8</target>
  76.                     <encoding>UTF-8</encoding>
  77.                 </configuration>
  78.             </plugin>
  79.         </plugins>
  80.     </build>
  81. </project>

注意：camunda官方帮助文档中少一个spring-boot-starter-jdbc配置，如果没有这个配置，启动项目，会报如下错误：

Field transactionManager in org.camunda.bpm.spring.boot.starter.configuration.impl.DefaultDatasourceConfiguration required a bean of type 'org.springframework.transaction.PlatformTransactionManager' that could not be found.

需要在pom.xml配置文件里把spring-boot-starter-jdbc加上

  1.         <dependency>
  2.  
  3.             <groupId>org.springframework.boot</groupId>
  4.  
  5.             <artifactId>spring-boot-starter-jdbc</artifactId>
  6.  
  7.         </dependency>

1.3、配置 Spring Boot 项目

在项目中src/main/resources新建application.yaml或者application.properties配置文件

让我们在文件夹中创建一个包含以下内容的文件：application.yaml

  1. server:
  2.   port: 8080
  3. spring:
  4.   datasource:
  5.     url: jdbc:h2:mem:camunda;DB_CLOSE_DELAY=1000;LOCK_TIMEOUT=10000
  6.     username: sa
  7.     password:
  8.     driver-class-name: org.h2.Driver
  9. camunda:
  10.   bpm:
  11.     database:
  12.       type: h2 #可改成 mysql
  13.       schema-update: true
  14.     auto-deployment-enabled: false # 自动部署 resources 下的 bpmn文件
  15.     admin-user:
  16.       id: demo
  17.       password: demo

此配置将导致以下结果：

  1. 将创建具有提供的密码和名字的管理员用户“demo”。
  2. 默认使用h2数据库，启动时自动创建数据库。

1.4、编写Spring Boot启动类

接下来，我们添加一个带有 main 方法的应用程序类，该方法将成为启动 Spring Boot 应用程序的入口点。该类上有@SpringBootApplication注解，它隐含地添加了几个方便的功能（自动配置、组件扫描等 - 参见 Spring Boot 文档）。

  1. package com.yuncheng;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.context.ConfigurableApplicationContext;
  6. import org.springframework.core.env.Environment;
  7.  
  8. @SpringBootApplication
  9. public class Camunda7Application {
  10.     public static void main(String... args) {
  11.         ConfigurableApplicationContext application =  SpringApplication.run(Camunda7Application.class, args);
  12.         Environment env = application.getEnvironment();
  13.         String port = env.getProperty("server.port");
  14.         String path = env.getProperty("server.servlet.context-path");
  15.         if (path == null || "".equals(path)) {
  16.             path = "/";
  17.         }
  18.         System.out.println("\n----------------------------------------------------------\n" +
  19.                 "\tCamunda7Application is running!\n" +
  20.                 "\tPort:\t" + port + "\n" +
  21.                 "\tPath:\t" + path + "\n" +
  22.                 "----------------------------------------------------------");
  23.     }
  24. }

1.5、启动Spring Boot工程

在IDEA的maven操作窗口，执行mvn clean install命令，下载相关的第三方Jar包。

我们的第一个 Camunda Spring Boot 应用程序现已准备就绪，此程序是一个 Spring Boot 应用程序，它作为 Web 容器、Camunda 引擎和 Camunda Web 应用程序资源嵌入到 Tomcat 中，并使用了H2 数据库。您可以通过右键单击该类并选择Camunda7Application 来运行应用程序。

现在，当您在浏览器中打开 http://localhost:8080/ 时，您可以使用我们之前配置的登录名和密码“demo/demo”来访问 Camunda Web 应用程序。

能正常登录访问这个界面，表示基于springboot集成camunda成功了。

1.6、切换成mysql数据库

camunda流程引擎默认使用的是h2数据库，我们把它切换成大家比较熟悉的mysql数据库，我本地使用的是mysql8.0版本数据库进行测试验证。

首先在pom.xml配置文件里增加mysql数据库Jar包引用

  1. <dependency>
  2.     <groupId>com.mysql</groupId>
  3.     <artifactId>mysql-connector-j</artifactId>
  4. </dependency>

然后，修改application.yaml配置文件，改为mysql数据库

  1. server:
  2.   port: 8080
  3. spring:
  4.   datasource:
  5.     url: jdbc:mysql://127.0.0.1:3306/camunda719?characterEncoding=UTF-8&useUnicode=true&useSSL=false&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai
  6.     username: root
  7.     password: root
  8.     driver-class-name: com.mysql.cj.jdbc.Driver
  9. camunda:
  10.   bpm:
  11.     database:
  12.       type: mysql
  13.       schema-update: false
  14.     auto-deployment-enabled: false # 自动部署 resources 下的 bpmn文件
  15.     admin-user:
  16.       id: demo
  17.       password: demo

这里我们设置了schema-update: false，表示不自动执行数据库脚本，需要手动创建数据库。先创建一个数据库,命名为camunda719。

然后找到camunda-bpm-platform-7.19.0\engine\src\main\resources\org\camunda\bpm\engine\db\create文件夹下的数据库脚本，选择mysql脚本依次执行即可。

执行完成后，通过工具打开数据库控制台查看，一共有49张表。

再次执行mvn clean install命令,并启动Springboot工程，浏览器中打开 http://localhost:8080/ 时，通过登录名和密码“demo/demo”来访问 Camunda Web 应用程序，验证是否成功。

2、设计并部署一个BPMN流程

在本节中，我们将学习如何使用camunda流程设计器设计一个BPMN2的业务流程，并部署流程。

2.1、下载安装流程设计器

下载地址：https://downloads.camunda.cloud/release/camunda-modeler/5.19.0/camunda-modeler-5.19.0-win-x64.zip

下载 流程设计器后camunda-modeler后，只需将下载内容解压缩到您选择的文件夹中即可。

成功解压缩后，对于 Windows 用户运行Camunda Modeler.exe，对于 Mac 用户或 Linux 用户运行.sh文件，启动流程建模器。

2.2、设计BPMN流程

首先使用 Camunda Modeler 对可执行流程进行建模。设置两个人工任务节点，配置流程处理人为demo用户。

流程模型bpmn内容:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.  
  3. <bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" xmlns:modeler="http://camunda.org/schema/modeler/1.0" id="Definitions_0lwtj60" targetNamespace="http://bpmn.io/schema/bpmn" exporter="Camunda Modeler" exporterVersion="5.19.0" modeler:executionPlatform="Camunda Platform" modeler:executionPlatformVersion="7.20.0">
  4.  
  5.   <bpmn:process id="Process_15r7d3m" name="UserTask Flow1" isExecutable="true" camunda:historyTimeToLive="180">
  6.  
  7.     <bpmn:startEvent id="StartEvent_1">
  8.  
  9.       <bpmn:outgoing>Flow_11x673q</bpmn:outgoing>
  10.  
  11.     </bpmn:startEvent>
  12.  
  13.     <bpmn:sequenceFlow id="Flow_11x673q" sourceRef="StartEvent_1" targetRef="Activity_10ell5p" />
  14.  
  15.     <bpmn:sequenceFlow id="Flow_0foitiz" sourceRef="Activity_10ell5p" targetRef="Activity_09u1so2" />
  16.  
  17.     <bpmn:endEvent id="Event_0e68o48">
  18.  
  19.       <bpmn:incoming>Flow_01cgzte</bpmn:incoming>
  20.  
  21.     </bpmn:endEvent>
  22.  
  23.     <bpmn:sequenceFlow id="Flow_01cgzte" sourceRef="Activity_09u1so2" targetRef="Event_0e68o48" />
  24.  
  25.     <bpmn:userTask id="Activity_10ell5p" name="申请" camunda:assignee="demo">
  26.  
  27.       <bpmn:incoming>Flow_11x673q</bpmn:incoming>
  28.  
  29.       <bpmn:outgoing>Flow_0foitiz</bpmn:outgoing>
  30.  
  31.     </bpmn:userTask>
  32.  
  33.     <bpmn:userTask id="Activity_09u1so2" name="审批" camunda:assignee="demo">
  34.  
  35.       <bpmn:incoming>Flow_0foitiz</bpmn:incoming>
  36.  
  37.       <bpmn:outgoing>Flow_01cgzte</bpmn:outgoing>
  38.  
  39.     </bpmn:userTask>
  40.  
  41.   </bpmn:process>
  42.  
  43.   <bpmndi:BPMNDiagram id="BPMNDiagram_1">
  44.  
  45.     <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_15r7d3m">
  46.  
  47.       <bpmndi:BPMNShape id="Activity_1xzvv8s_di" bpmnElement="Activity_10ell5p">
  48.  
  49.         <dc:Bounds x="270" y="77" width="100" height="80" />
  50.  
  51.       </bpmndi:BPMNShape>
  52.  
  53.       <bpmndi:BPMNShape id="Activity_1h27nqt_di" bpmnElement="Activity_09u1so2">
  54.  
  55.         <dc:Bounds x="460" y="77" width="100" height="80" />
  56.  
  57.       </bpmndi:BPMNShape>
  58.  
  59.       <bpmndi:BPMNShape id="Event_0e68o48_di" bpmnElement="Event_0e68o48">
  60.  
  61.         <dc:Bounds x="652" y="99" width="36" height="36" />
  62.  
  63.       </bpmndi:BPMNShape>
  64.  
  65.       <bpmndi:BPMNShape id="_BPMNShape_StartEvent_2" bpmnElement="StartEvent_1">
  66.  
  67.         <dc:Bounds x="152" y="99" width="36" height="36" />
  68.  
  69.       </bpmndi:BPMNShape>
  70.  
  71.       <bpmndi:BPMNEdge id="Flow_11x673q_di" bpmnElement="Flow_11x673q">
  72.  
  73.         <di:waypoint x="188" y="117" />
  74.  
  75.         <di:waypoint x="270" y="117" />
  76.  
  77.       </bpmndi:BPMNEdge>
  78.  
  79.       <bpmndi:BPMNEdge id="Flow_01cgzte_di" bpmnElement="Flow_01cgzte">
  80.  
  81.         <di:waypoint x="560" y="117" />
  82.  
  83.         <di:waypoint x="652" y="117" />
  84.  
  85.       </bpmndi:BPMNEdge>
  86.  
  87.       <bpmndi:BPMNEdge id="Flow_0foitiz_di" bpmnElement="Flow_0foitiz">
  88.  
  89.         <di:waypoint x="370" y="117" />
  90.  
  91.         <di:waypoint x="460" y="117" />
  92.  
  93.       </bpmndi:BPMNEdge>
  94.  
  95.     </bpmndi:BPMNPlane>
  96.  
  97.   </bpmndi:BPMNDiagram>
  98.  
  99. </bpmn:definitions>

2.3、发布BPMN流程

点击流程设计器左下方的发布流程按钮：

3、验证camunda流程引擎

3.1、通过camunda web控制台测试

现在，当您在浏览器中打开 http://localhost:8080/camunda/app/tasklist/ 时，您可以使用我们之前配置的登录名和密码“demo/demo”来访问 Camunda Web 应用程序。

选择刚刚设计的的流程“UserTask Flow1”，发起一个流程实例。点击左侧“Add a simple filter”添加一个默认待办任务过滤器，就可以查看到刚刚提交的流程待办任务了。

此时，我看打开mysql数据库表，查看camunda数据库表里的数据：

打开流程定义发布表act_re_deployment，看到我们刚刚发布的这个流动定义模型。

打开流程实例历史表act_hi_procinst，看到我们刚刚发起的这个流程实例数据。

打开流程待办任务表act_ru_task，多了一条demo用户待处理的任务。

3.2、通过camunda rest接口测试

以上我们通过camunda的web界面进行了发起流程测试验证，下面我们通过Camunda REST API的方式进行测试验证。

Camunda Platform REST API官方说明文档：Camunda Platform REST API

3.2.1、查询流程定义

查看流程定义rest接口：http://{host}:{port}/{contextPath}/process-definition

用Postman测试验证：http://localhost:8080/engine-rest/process-definition

返回结果：

  1.  
  2. [
  3.  
  4.     {
  5.  
  6.         "id": "Process_15r7d3m:1:80b53453-cfc5-11ee-a32c-32f6efb33b52",
  7.  
  8.         "key": "Process_15r7d3m",
  9.  
  10.         "category": "http://bpmn.io/schema/bpmn",
  11.  
  12.         "description": null,
  13.  
  14.         "name": "UserTask Flow1",
  15.  
  16.         "version": 1,
  17.  
  18.         "resource": "UserTask Flow1.bpmn",
  19.  
  20.         "deploymentId": "80719ba1-cfc5-11ee-a32c-32f6efb33b52",
  21.  
  22.         "diagram": null,
  23.  
  24.         "suspended": false,
  25.  
  26.         "tenantId": null,
  27.  
  28.         "versionTag": null,
  29.  
  30.         "historyTimeToLive": 180,
  31.  
  32.         "startableInTasklist": true
  33.  
  34.     }
  35.  
  36. ]

3.2.2、发起流程实例

流程发起的rest接口为：http://{host}:{port}/{contextPath}/process-definition/key/{key}/start

详细接口描述见官方文档：Camunda Platform REST API

打开postman工具进行测试验证：http://localhost:8080/engine-rest/process-definition/key/Process_15r7d3m/start

输入JSON:

  1. {
  2.  
  3.   "variables": {
  4.  
  5.     "variable1": {
  6.  
  7.       "value": "hello",
  8.  
  9.       "type": "String"
  10.  
  11.     },
  12.  
  13.     "variable2": {
  14.  
  15.       "value": true,
  16.  
  17.       "type": "Boolean"
  18.  
  19.     }
  20.  
  21.   },
  22.  
  23.   "businessKey": "myBusinessKey-test1"
  24.  
  25. }

返回结果：

  1. {
  2.  
  3.     "links": [
  4.  
  5.         {
  6.  
  7.             "method": "GET",
  8.  
  9.             "href": "http://localhost:8080/engine-rest/process-instance/2881747c-cfca-11ee-a32c-32f6efb33b52",
  10.  
  11.             "rel": "self"
  12.  
  13.         }
  14.  
  15.     ],
  16.  
  17.     "id": "2881747c-cfca-11ee-a32c-32f6efb33b52",
  18.  
  19.     "definitionId": "Process_15r7d3m:1:80b53453-cfc5-11ee-a32c-32f6efb33b52",
  20.  
  21.     "businessKey": "myBusinessKey-test1",
  22.  
  23.     "caseInstanceId": null,
  24.  
  25.     "ended": false,
  26.  
  27.     "suspended": false,
  28.  
  29.     "tenantId": null
  30.  
  31. }

3.2.3、查询待办任务

通过上面接口得知，流程当前流转到了人工节点上，那么需要查询待办任务：

查询待办任务的rest接口：http://{host}:{port}/{contextPath}/task

用Postman测试：http://localhost:8080/engine-rest/task

返回所有的流程待办任务列表：

  1. [
  2.  
  3.     {
  4.  
  5.         "id": "28b1d353-cfca-11ee-a32c-32f6efb33b52",
  6.  
  7.         "name": "申请",
  8.  
  9.         "assignee": "demo",
  10.  
  11.         "created": "2024-02-20T16:29:26.815+0800",
  12.  
  13.         "due": null,
  14.  
  15.         "followUp": null,
  16.  
  17.         "lastUpdated": null,
  18.  
  19.         "delegationState": null,
  20.  
  21.         "description": null,
  22.  
  23.         "executionId": "2881747c-cfca-11ee-a32c-32f6efb33b52",
  24.  
  25.         "owner": null,
  26.  
  27.         "parentTaskId": null,
  28.  
  29.         "priority": 50,
  30.  
  31.         "processDefinitionId": "Process_15r7d3m:1:80b53453-cfc5-11ee-a32c-32f6efb33b52",
  32.  
  33.         "processInstanceId": "2881747c-cfca-11ee-a32c-32f6efb33b52",
  34.  
  35.         "taskDefinitionKey": "Activity_10ell5p",
  36.  
  37.         "caseExecutionId": null,
  38.  
  39.         "caseInstanceId": null,
  40.  
  41.         "caseDefinitionId": null,
  42.  
  43.         "suspended": false,
  44.  
  45.         "formKey": null,
  46.  
  47.         "camundaFormRef": null,
  48.  
  49.         "tenantId": null
  50.  
  51.     }
  52.  
  53. ]

3.2.4、完成待办提交流程

完成待办任务，提交流程往下走，提交流程的rest服务接口为：

http://{host}:{port}/{contextPath}/task/{id}/complete

用Postman测试：http://localhost:8080/engine-rest/task/28b1d353-cfca-11ee-a32c-32f6efb33b52/complete

参数：

  1. {
  2.  
  3.   "variables": {
  4.  
  5.     "variable": {
  6.  
  7.       "value": "china"
  8.  
  9.     },
  10.  
  11.     "variable2": {
  12.  
  13.       "value": false
  14.  
  15.     }
  16.  
  17.   },
  18.  
  19.   "withVariablesInReturn": true
  20.  
  21. }

3.3、通过Java API接口测试

上面介绍了通过Camunda Web控制台界面和Camunda提供的rest接口两种方式，来调用流程引擎服务。以下介绍第三种方式，即Java编码方式，直接调用Camunda提供的Service接口。

我们自己开发一个RestController服务类，类里注入RuntimeService和TaskService的SpringBean，然后调用这两个类的API接口，实现发起流程和查询待办的逻辑。

  1. import org.camunda.bpm.engine.RuntimeService;
  2. import org.camunda.bpm.engine.TaskService;
  3. import org.camunda.bpm.engine.impl.persistence.entity.TaskEntity;
  4. import org.camunda.bpm.engine.runtime.ProcessInstance;
  5. import org.camunda.bpm.engine.task.Task;
  6. import org.springframework.web.bind.annotation.*;
  7.  
  8. import javax.annotation.Resource;
  9. import java.util.List;
  10.  
  11. @RestController
  12. @RequestMapping
  13. public class TestController {
  14.     @Resource
  15.     private RuntimeService runtimeService;
  16.     @Resource
  17.     private TaskService taskService;
  18.     /**
  19.      * 通过流程定义key，发起一个流程实例
  20.      * @param processKey 流程定义key
  21.      * @return 流程实例ID
  22.      */
  23.     @GetMapping(value = "/startProcessInstanceByKey/{processKey}")
  24.     public String startProcessInstanceByKey(@PathVariable("processKey") String processKey) {
  25.         ProcessInstance instance = runtimeService.startProcessInstanceByKey(processKey);
  26.         return instance.getRootProcessInstanceId();
  27.     }
  28.  
  29.     /**
  30.      * 查询某个用户的待办任务
  31.      * @param assignee 用户ID
  32.      * @return 待办任务列表
  33.      */
  34.     @GetMapping(value = "/getTaskByAssignee/{assignee}")
  35.     public String getTaskByAssignee(@PathVariable("assignee") String assignee) {
  36.         List<TaskEntity> taskList = (List)taskService.createTaskQuery().taskAssignee(assignee).list();
  37.        StringBuffer sb = new StringBuffer();
  38.         for (Task task : taskList) {
  39.             String taskTitle = "待办任务ID="+task.getId()+",流程实例ID="+task.getProcessInstanceId()+"\n";
  40.             System.out.println(taskTitle);
  41.             sb.append(taskTitle);
  42.         }
  43.         return sb.toString();
  44.     }
  45. }

重启启动Springboot程序，调用刚刚开发的流程接口进行测试。

发起一个流程实例：http://localhost:8080/startProcessInstanceByKey/Process_15r7d3m

执行成功，返回了流程实例ID，接着查询用户demo的待办任务：

可以看到也返回了demo用户的待办任务数据，说明通过直接调用camunda的API接口RuntimeService和TaskService也是成功的。

camunda更多的API接口介绍：https://lowcode.blog.csdn.net/article/details/130048156

至此，基于springboot集成camunda7.19开源工作流引擎完成。

关于camunda开源流程引擎数据库表结构详细介绍，请查看：https://lowcode.blog.csdn.net/article/details/109048818

关于camunda流程引擎功能体验：请查看：http://www.yunchengxc.com

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

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

  

闽ICP备14008679号