当前位置：首页 > news >正文

工作流程引擎之flowable（集成springboot）

news 2025/10/31 18:44:09

0、背景

现状：公司各部门业务系统有各自的工作流引擎，也有cross function的业务在不同系统或OA系统流转，没有统一的去规划布局统一的BPM解决方案，近期由于一个项目引发朝着整合统一的BPM方案，特了解一下市面上比较主流的开源和收费的工作流引擎。本文主要介绍开源的工作流引擎flowable.

1、开源工作流引擎比较

开源工作流引擎是一种用于管理和自动化业务流程的软件，它可以帮助用户实现业务流程的可视化设计、流程编排、任务调度、监控和优化等功能。本文将介绍几种常见的开源工作流引擎，并进行比较。目前市场上比较主流的开源流程引擎有：Activiti、Camunda、Flowable。

1.1、Activiti

Activiti是一个轻量级的开源工作流引擎，采用Java语言开发，基于BPMN 2.0规范，支持嵌入式部署和分布式部署。Activiti提供了丰富的API和插件，支持与Java应用程序进行集成。它还提供了Web界面和REST API，可以方便地进行流程设计、部署、调度和监控。Activiti具有以下优点：

易用性和灵活性：Activiti提供了简单易用的流程设计器和API，支持多种流程模型和任务类型，可以满足不同场景和需求的使用。
可伸缩性和性能：Activiti支持嵌入式和分布式部署，可以扩展集群规模以支持更大的业务流程和更高的并发量。此外，它还提供了优化和缓存机制，可以提高性能和响应速度。
社区支持和生态系统：Activiti拥有庞大的社区和活跃的开发者，提供了丰富的插件和工具，可以扩展其功能和使用。例如，Activiti Explorer可以用于流程设计和管理，Camunda Modeler可以用于编辑BPMN模型，Flowable Task可以用于任务管理等。
安全性和可靠性：Activiti提供了可靠的安全性控制，可以对数据进行访问控制和加密，以满足不同场景和需求的安全要求。它还提供了事务管理和错误处理机制，可以保证业务流程的可靠性和稳定性。

1.2、Camunda

Camunda是一个强大的开源工作流引擎，采用Java语言开发，支持BPMN 2.0规范和CMMN规范。Camunda提供了丰富的API和插件，支持与Java应用程序进行集成。它还提供了Web界面和REST API，可以方便地进行流程设计、部署、调度和监控。Camunda具有以下优点：

功能丰富和灵活性：Camunda提供了丰富的功能和灵活的流程设计，支持多种流程模型和任务类型，可以满足不同场景和需求的使用。
可伸缩性和性能：Camunda支持嵌入式和分布式部署，可以扩展集群规模以支持更大的业务流程和更高的并发量。此外，它还提供了优化和缓存机制，可以提高性能和响应速度。
社区支持和生态系统：Camunda拥有庞大的社区和活跃的开发者，提供了丰富的插件和工具，可以扩展其功能和使用。例如，Camunda Modeler可以用于编辑BPMN模型，Camunda Cockpit可以用于任务管理和流程监控，Camunda Tasklist可以用于任务列表等。
可扩展的架构和API：Camunda采用可扩展的架构和API，可以方便地进行集成和扩展。例如，它支持自定义流程引擎插件、外部任务处理器、表单引擎等。
安全性和可靠性：Camunda提供了可靠的安全性控制，可以对数据进行访问控制和加密，以满足不同场景和需求的安全要求。它还提供了事务管理和错误处理机制，可以保证业务流程的可靠性和稳定性。

1.3、Flowable

Flowable是一个开源的轻量级工作流引擎，基于Activiti 5.x版本开发，支持BPMN 2.0规范和CMMN规范。Flowable提供了丰富的API和插件，支持与Java应用程序进行集成。它还提供了Web界面和REST API，可以方便地进行流程设计、部署、调度和监控。Flowable具有以下优点：

易用性和灵活性：Flowable提供了简单易用的流程设计器和API，支持多种流程模型和任务类型，可以满足不同场景和需求的使用。
可伸缩性和性能：Flowable支持嵌入式和分布式部署，可以扩展集群规模以支持更大的业务流程和更高的并发量。此外，它还提供了优化和缓存机制，可以提高性能和响应速度。
社区支持和生态系统：Flowable拥有庞大的社区和活跃的开发者，提供了丰富的插件和工具，可以扩展其功能和使用。例如，Flowable Modeler可以用于流程设计和管理，Flowable Task可以用于任务管理和流程监控，Flowable Admin可以用于集群管理等。
可扩展的架构和API：Flowable采用可扩展的架构和API，可以方便地进行集成和扩展。例如，它支持自定义流程引擎插件、外部任务处理器、表单引擎等。
安全性和可靠性：Flowable提供了可靠的安全性控制，可以对数据进行访问控制和加密，以满足不同场景和需求的安全要求。它还提供了事务管理和错误处理机制，可以保证业务流程的可靠性和稳定性。

2、flowable安装

2.1、下载软件

Github链接，目前flowable已经更新到Flowable 7.0.0.M2版本了。

安装方式有很多，可以通过下载zip包也可以通过docker拉取镜像进行部署，本文采用zip的window环境部署。

下载安装包，我下载的是flowable-6.7.0版本，同时需要配合tomcat（选择的是apache-tomcat-9.0.79版本）服务进行部署，tomcat下载地址：

下载上面两个软件之后还需要配置flowale的配置数据存储，我选择的mysql数据库，当然他还支持其他数据库类型。mysql数据库是docker镜像运行的，这里不再赘述安装过程，可以看我往期docker mysql安装.

2.2、解压运行

分别解压tomcat和flowable：

把flowable-6.7.0\wars目录下的flowable-ui.war拷贝到apache-tomcat-9.0.79\webapps下面启动tomcat startup.bat

此时会解压war文件，同时会删除war文件，同时会生成新文件apache-tomcat-9.0.79\webapps\flowable-ui.

2.3、配置数据源

修改apache-tomcat-9.0.79\webapps\flowable-ui\WEB-INF\classes\flowable-default.properties

参考：

server.port=8080
server.servlet.context-path=/flowable-ui
spring.jmx.unique-names=true
# This is needed to force use of JDK proxies instead of using CGLIB
spring.aop.proxy-target-class=false
spring.aop.auto=false
spring.application.name=flowable-ui
spring.banner.location=classpath:/org/flowable/spring/boot/flowable-banner.txt
# The default domain for generating ObjectNames must be specified. Otherwise when multiple Spring Boot applications start in the same servlet container
# all would be created with the same name (com.zaxxer.hikari:name=dataSource,type=HikariDataSource) for example
spring.jmx.default-domain=${spring.application.name}
#
# SECURITY
#
spring.security.filter.dispatcher-types=REQUEST,FORWARD,ASYNC# Expose all actuator endpoints to the web
# They are exposed, but only authenticated users can see /info and /health abd users with access-admin can see the others
management.endpoints.web.exposure.include=*
# Full health details should only be displayed when a user is authorized
management.endpoint.health.show-details=when_authorized
# Only users with role access-admin can access full health details
management.endpoint.health.roles=access-admin
# Spring prefixes the roles with ROLE_. However, Flowable does not have that concept yet, so we need to override that with an empty string
flowable.common.app.role-prefix=#
# SECURITY OAuth2
# Examples are for Keycloak
#
#spring.security.oauth2.resourceserver.jwt.issuer-uri=<keycloakLocation>/auth/realms/<realmName>
#spring.security.oauth2.client.registration.keycloak.client-id=<clientId>
#spring.security.oauth2.client.registration.keycloak.client-secret=<clientSecret>
#spring.security.oauth2.client.registration.keycloak.client-name=Flowable UI Keycloak
#spring.security.oauth2.client.registration.keycloak.authorization-grant-type=authorization_code
#spring.security.oauth2.client.provider.keycloak.issuer-uri=<keycloakLocation>/auth/realms/<realmName>
#spring.security.oauth2.client.provider.keycloak.user-name-attribute=preferred_username#flowable.common.app.security.type=oauth2
#flowable.common.app.security.oauth2.authorities-attribute=groups
#flowable.common.app.security.oauth2.groups-attribute=userGroups
#flowable.common.app.security.oauth2.default-authorities=access-task
#flowable.common.app.security.oauth2.default-groups=flowableUser
#flowable.common.app.security.oauth2.full-name-attribute=name
#flowable.common.app.security.oauth2.email-attribute=email#
# DATABASE
##spring.datasource.driver-class-name=org.h2.Driver
#spring.datasource.url=jdbc:h2:~/flowable-db/engine-db;AUTO_SERVER=TRUE;AUTO_SERVER_PORT=9093;DB_CLOSE_DELAY=-1spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.56.100:13306/flowable?characterEncoding=UTF-8#spring.datasource.driver-class-name=org.postgresql.Driver
#spring.datasource.url=jdbc:postgresql://localhost:5432/flowable#spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver
#spring.datasource.url=jdbc:sqlserver://localhost:1433;databaseName=flowablea#spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
#spring.datasource.url=jdbc:oracle:thin:@localhost:1521:FLOWABLE#spring.datasource.driver-class-name=com.ibm.db2.jcc.DB2Driver
#spring.datasource.url=jdbc:db2://localhost:50000/flowablespring.datasource.username=root
spring.datasource.password=my-secret-pw# JNDI CONFIG# If uncommented, the datasource will be looked up using the configured JNDI name.
# This will have preference over any datasource configuration done below that doesn't use JNDI
#
# Eg for JBoss: java:jboss/datasources/flowableDS
#
#spring.datasource.jndi-name==jdbc/flowableDS# Set whether the lookup occurs in a J2EE container, i.e. if the prefix "java:comp/env/" needs to be added if the JNDI
# name doesn't already contain it. Default is "true".
#datasource.jndi.resourceRef=true#
# Connection pool (see https://github.com/brettwooldridge/HikariCP#configuration-knobs-baby)
#spring.datasource.hikari.poolName=${spring.application.name}
# 10 minutes
spring.datasource.hikari.maxLifetime=600000
# 5 minutes
spring.datasource.hikari.idleTimeout=300000
spring.datasource.hikari.minimumIdle=10
spring.datasource.hikari.maximumPoolSize=50
# test query for H2, MySQL, PostgreSQL and Microsoft SQL Server
#spring.datasource.hikari.connection-test-query=select 1
# test query for Oracle
#spring.datasource.hikari.connection-test-query=SELECT 1 FROM DUAL
# test query for DB2
#spring.datasource.hikari.connection-test-query=SELECT current date FROM sysibm.sysdummy1#
# Default Task Executor (will be used for @Async)
#
spring.task.execution.pool.core-size=2
spring.task.execution.pool.max-size=50
spring.task.execution.pool.queue-capacity=10000
spring.task.execution.thread-name-prefix=flowable-ui-task-Executor-#
# Task scheduling
#
spring.task.scheduling.pool.size=5#
# EMAIL
##flowable.mail.server.host=localhost
#flowable.mail.server.port=1025
#flowable.mail.server.username=
#flowable.mail.server.password=#
# FLOWABLE
#flowable.process.definition-cache-limit=512
#flowable.dmn.strict-mode=false
flowable.process.async.executor.default-async-job-acquire-wait-time=PT5S
flowable.process.async.executor.default-timer-job-acquire-wait-time=PT5Sflowable.cmmn.async.executor.default-async-job-acquire-wait-time=PT5S
flowable.cmmn.async.executor.default-timer-job-acquire-wait-time=PT5S# The maximum file upload limit. Set to -1 to set to 'no limit'. Expressed in bytes
spring.servlet.multipart.max-file-size=10MB
# The maximum request size limit. Set to -1 to set to 'no limit'.
# When multiple files can be uploaded this needs to be more than the 'max-file-size'.
spring.servlet.multipart.max-request-size=10MB# For development purposes, data folder is created inside the sources ./data folder
flowable.content.storage.root-folder=data/
flowable.content.storage.create-root=trueflowable.common.app.idm-admin.user=admin
flowable.common.app.idm-admin.password=testflowable.experimental.debugger.enabled=false# Rest API in task application# If false, disables the rest api in the task app
flowable.task.app.rest-enabled=true# Configures the way user credentials are verified when doing a REST API call:
# 'any-user' : the user needs to exist and the password need to match. Any user is allowed to do the call (this is the pre 6.3.0 behavior)
# 'verify-privilege' : the user needs to exist, the password needs to match and the user needs to have the 'rest-api' privilege
# If nothing set, defaults to 'verify-privilege'
flowable.rest.app.authentication-mode=verify-privilege# Enable form field validation after form submission on the engine side
flowable.form-field-validation-enabled=false# Flowable Admin Properties# Passwords for rest endpoints and master configs are stored encrypted in the database using AES/CBC/PKCS5PADDING
# It needs a 128-bit initialization vector (http://en.wikipedia.org/wiki/Initialization_vector)
# and a 128-bit secret key represented as 16 ascii characters below
#
# Do note that if these properties are changed after passwords have been saved, all existing passwords
# will not be able to be decrypted and the password would need to be reset in the UI.
flowable.admin.app.security.encryption.credentials-i-v-spec=j8kdO2hejA9lKmm6
flowable.admin.app.security.encryption.credentials-secret-spec=9FGl73ngxcOoJvmL
#flowable.admin.app.security.preemptive-basic-authentication=true# Flowable IDM Properties#
# LDAP
#
#flowable.idm.ldap.enabled=true
#flowable.idm.ldap.server=ldap://localhost
#flowable.idm.ldap.port=10389
#flowable.idm.ldap.user=uid=admin, ou=system
#flowable.idm.ldap.password=secret
#flowable.idm.ldap.base-dn=o=flowable
#flowable.idm.ldap.query.user-by-id=(&(objectClass=inetOrgPerson)(uid={0}))
#flowable.idm.ldap.query.user-by-full-name-like=(&(objectClass=inetOrgPerson)(|({0}=*{1}*)({2}=*{3}*)))
#flowable.idm.ldap.query.all-users=(objectClass=inetOrgPerson)
#flowable.idm.ldap.query.groups-for-user=(&(objectClass=groupOfUniqueNames)(uniqueMember={0}))
#flowable.idm.ldap.query.all-groups=(objectClass=groupOfUniqueNames)
#flowable.idm.ldap.query.group-by-id=(&(objectClass=groupOfUniqueNames)(uniqueId={0}))
#flowable.idm.ldap.attribute.user-id=uid
#flowable.idm.ldap.attribute.first-name=cn
#flowable.idm.ldap.attribute.last-name=sn
#flowable.idm.ldap.attribute.email=mail
#flowable.idm.ldap.attribute.group-id=cn
#flowable.idm.ldap.attribute.group-name=cn
#flowable.idm.ldap.cache.group-size=10000
#flowable.idm.ldap.cache.group-expiration=180000#
# Keycloak
#
#flowable.idm.app.keycloak.enabled=true
#flowable.idm.app.keycloak.server=<keycloakLocation>
#flowable.idm.app.keycloak.authentication-realm=master
#flowable.idm.app.keycloak.authentication-user=admin
#flowable.idm.app.keycloak.authentication-password=admin
#flowable.idm.app.keycloak.realm=<realm>#
# DEFAULT ADMINISTRATOR ACCOUNT
#flowable.idm.app.admin.user-id=admin
flowable.idm.app.admin.password=test
flowable.idm.app.admin.first-name=Test
flowable.idm.app.admin.last-name=Administrator
flowable.idm.app.admin.email=test-admin@example-domain.tld# Enable and configure JMS
#flowable.task.app.jms-enabled=true
#spring.activemq.broker-url=tcp://localhost:61616# Enable and configure RabbitMQ
#flowable.task.app.rabbit-enabled=true
#spring.rabbitmq.addresses=localhost:5672
#spring.rabbitmq.username=guest
#spring.rabbitmq.password=guest# Enable and configure Kafka
#flowable.task.app.kafka-enabled=true
#spring.kafka.bootstrap-servers=localhost:9092

默认情况下flowable有没有把mysql驱动程序打入到war包里面，需要手动添加对应的驱动。apache-tomcat-9.0.79\webapps\flowable-ui\WEB-INF\lib 我选择的是mysql-connector-java-5.1.45.jar驱动，具体可以从网上下载也可以通过maven方式从中央仓库拉取。

再次启动tomcat，访问http://127.0.0.1:8080/flowable-ui 初始用户名和密码：admin/test

3、springboot接入flowable

登录flowable之后选择建模器应用程序，添加一个流程，我这边已经添加了一个简单的请假流程。

新入门可以导入我们流程定义，具体文件在看的我资源。重点介绍springboot如何集成flowable，配置后续有机会在单独介绍里程配置说明。

新建springboot项目添加响应的依赖。

 <dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.flowable</groupId><artifactId>flowable-spring-boot-starter</artifactId><version>6.7.0</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.45</version></dependency><!-- Flowable 内部日志采用 SLF4J --><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.21</version></dependency><dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>1.7.21</version></dependency></dependencies>

application.yml配置：

spring:datasource:url: jdbc:mysql://192.168.56.100:13306/flowable?useSSL=false&characterEncoding=UTF-8&serverTimezone=GMT%2B8driver-class-name: com.mysql.jdbc.Driverusername: rootpassword: my-secret-pw
# flowable 配置
flowable:# 关闭异步，不关闭历史数据的插入就是异步的，会在同一个事物里面，无法回滚# 开发可开启会提高些效率，上线需要关闭async-executor-activate: false
server:port: 18080

Controller

import liquibase.pro.packaged.O;
import liquibase.pro.packaged.U;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.engine.*;
import org.flowable.engine.history.HistoricActivityInstance;
import org.flowable.engine.history.HistoricProcessInstance;
import org.flowable.engine.runtime.ActivityInstance;
import org.flowable.engine.runtime.Execution;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.image.ProcessDiagramGenerator;
import org.flowable.task.api.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;/*** @author pyj* @date 2019/10/30*/
@RestController
@RequestMapping("flowable")
public class TestController {@Autowiredprivate RuntimeService runtimeService;@Autowiredprivate TaskService taskService;@Autowiredprivate HistoryService historyService;@Autowiredprivate RepositoryService repositoryService;@Autowiredprivate ProcessEngine processEngine;/*** 创建流程** @param userId* @param days* @param reason* @return*/@GetMapping("add")public String addExpense(String userId, String days, String reason) {Map<String, Object> map = new HashMap<>();map.put("employee", userId);map.put("nrOfHolidays", days);map.put("description", reason);ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holidayRequest", map);return "提交成功,流程ID为：" + processInstance.getId();}/*** 获取指定用户组流程任务列表** @return*/@GetMapping("listtask")public Object listtask() {StringBuffer btf = new StringBuffer();List<Task> list = taskService.createTaskQuery().list();for (Task task : list){btf.append(task.getId()+"\r\n");System.out.println(task.getId());}return btf.toString();}/*** 获取指定用户组流程任务列表** @param group* @return*/@GetMapping("list")public Object list(String group) {List<Task> list = taskService.createTaskQuery().list();List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup(group).list();return tasks.toString();}/*** 通过/拒绝任务** @param taskId* @param approved 1 ：true  2：false* @return*/@GetMapping("apply")public String apply(String taskId, String approved) {Task task = taskService.createTaskQuery().taskId(taskId).singleResult();if (task == null) {return "流程不存在";}Map<String, Object> variables = new HashMap<>();Boolean apply = approved.equals("1") ? true : false;variables.put("approved", apply);taskService.complete(taskId, variables);return "审批是否通过：" + approved;}/*** 查看历史流程记录** @param processInstanceId* @return*/@GetMapping("historyList")public Object getHistoryList(String processInstanceId) {List<HistoricActivityInstance> historicActivityInstances = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId).finished().orderByHistoricActivityInstanceEndTime().asc().list();return historicActivityInstances;}/*** 驳回流程实例** @param taskId* @param targetTaskKey* @return*/@GetMapping("rollbask")public String rollbaskTask(String taskId, String targetTaskKey) {Task currentTask = taskService.createTaskQuery().taskId(taskId).singleResult();if (currentTask == null) {return "节点不存在";}List<String> key = new ArrayList<>();key.add(currentTask.getTaskDefinitionKey());runtimeService.createChangeActivityStateBuilder().processInstanceId(currentTask.getProcessInstanceId()).moveActivityIdsToSingleActivityId(key, targetTaskKey).changeState();return "驳回成功...";}/*** 终止流程实例** @param processInstanceId*/public String deleteProcessInstanceById(String processInstanceId) {// ""这个参数本来可以写删除原因runtimeService.deleteProcessInstance(processInstanceId, "");return "终止流程实例成功";}/*** 挂起流程实例** @param processInstanceId 当前流程实例id*/@GetMapping("hangUp")public String handUpProcessInstance(String processInstanceId) {runtimeService.suspendProcessInstanceById(processInstanceId);return "挂起流程成功...";}/*** 恢复（唤醒）被挂起的流程实例** @param processInstanceId 流程实例id*/@GetMapping("recovery")public String activateProcessInstance(String processInstanceId) {runtimeService.activateProcessInstanceById(processInstanceId);return "恢复流程成功...";}/*** 判断传入流程实例在运行中是否存在** @param processInstanceId* @return*/@GetMapping("isExist/running")public Boolean isExistProcIntRunning(String processInstanceId) {ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();if (processInstance == null) {return false;}return true;}/*** 判断流程实例在历史记录中是否存在* @param processInstanceId* @return*/@GetMapping("isExist/history")public Boolean isExistProcInHistory(String processInstanceId) {HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();if (historicProcessInstance == null) {return false;}return true;}/*** 我发起的流程实例列表** @param userId* @return 流程实例列表*/@GetMapping("myTasks")public List<HistoricProcessInstance> getMyStartProcint(String userId) {List<HistoricProcessInstance> list = historyService.createHistoricProcessInstanceQuery().startedBy(userId).orderByProcessInstanceStartTime().asc().list();return list;}/*** 查询流程图** @param httpServletResponse* @param processId* @throws Exception*/@RequestMapping(value = "processDiagram")public void genProcessDiagram(HttpServletResponse httpServletResponse, String processId) throws Exception {List<ActivityInstance> activityInstanceList =  runtimeService.createActivityInstanceQuery().list();for(ActivityInstance activityInstance : activityInstanceList){System.out.println(activityInstance.getId());}System.out.println("=========================================================================");List<ProcessInstance> list =  runtimeService.createProcessInstanceQuery().list();for(ProcessInstance processInstance : list){System.out.println(processInstance.getId());}ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(processId).singleResult();//流程走完的不显示图if (pi == null) {return;}Task task = taskService.createTaskQuery().processInstanceId(pi.getId()).singleResult();//使用流程实例ID，查询正在执行的执行对象表，返回流程实例对象String InstanceId = task.getProcessInstanceId();List<Execution> executions = runtimeService.createExecutionQuery().processInstanceId(InstanceId).list();//得到正在执行的Activity的IdList<String> activityIds = new ArrayList<>();List<String> flows = new ArrayList<>();for (Execution exe : executions) {List<String> ids = runtimeService.getActiveActivityIds(exe.getId());activityIds.addAll(ids);}//获取流程图BpmnModel bpmnModel = repositoryService.getBpmnModel(pi.getProcessDefinitionId());ProcessEngineConfiguration engconf = processEngine.getProcessEngineConfiguration();ProcessDiagramGenerator diagramGenerator = engconf.getProcessDiagramGenerator();InputStream in = diagramGenerator.generateDiagram(bpmnModel, "png", activityIds, flows, engconf.getActivityFontName(), engconf.getLabelFontName(), engconf.getAnnotationFontName(), engconf.getClassLoader(), 1.0,true);OutputStream out = null;byte[] buf = new byte[1024];int legth = 0;try {out = httpServletResponse.getOutputStream();while ((legth = in.read(buf)) != -1) {out.write(buf, 0, legth);}} finally {if (in != null) {in.close();}if (out != null) {out.close();}}}}

Flowable提供了几个Service接口和实现类，可以通过service拿到流程的一些定义、流转等信息。

正如TestController里面定义的几个方法，分别是实例化流程，审批流程，查看流程等操作。如下

实例化流程：

审批流程：

拉取当前流程任务清单：

查看流程状态：

具体大家可以参考如下文章有详细的springboot集成指引。

Flowable BPMN 用户手册 (v 6.3.0)