一、Flowable开发—简介安装

1. Flowable简介

• 官网地址：https://www.flowable.org/
• Flowable6.3中文教程：https://tkjohn.github.io/flowable-userguide/#_introduction
• 文档地址：https://www.flowable.org/docs/userguide/index.html#_getting_started
• 中文文档：https://tkjohn.github.io/flowable-userguide/#_getting_started

• Flowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。
• Flowable可以十分灵活地加入你的应用/服务/构架。可以将JAR形式发布的Flowable库加入应用或服务，来嵌入引擎。 以JAR形式发布使Flowable可以轻易加入任何Java环境：Java SE；Tomcat、Jetty或Spring之类的servlet容器；JBoss或WebSphere之类的Java EE服务器，等等。 另外，也可以使用Flowable REST API进行HTTP调用。也有许多Flowable应用（Flowable Modeler, Flowable Admin, Flowable IDM 与 Flowable Task），提供了直接可用的UI示例，可以使用流程与任务。

• 可以在官网下载对应的jar包在本地部署运行，官方提供了下面的五个应用程序：

  • Flowable Modeler：流程定义管理
  • Flowable Task：用户任务管理
  • Flowable IDM：用户组权限管理
  • Flowable REST API：流程引擎对外提供的API接口
  • Flowable Admin：后台管理

    2. 流程引擎使用架构

• Flowable引擎在使用前需要先通过配置来初始化ProcessEngine。

• 初始化ProcessEngineConfiguration一般有两种方式：
  • 通过Spinrg配置文件进行依赖注入，通过flowable.cfg.xml文件来初始化ProcessEngineConfiguration（这里的文件名必须为flowable.cfg.xml，否则Flowable识别不到）
  • 通过编写程序的方式来构造ProcessEngineConfiguration对象

流程引擎API架构图：

流程引擎API架构图

模型图：

模型图

ProcessEngineConfiguration在初始化过程中会同时初始化数据库，如果数据库已经存在，则不会做创建更新操作，如果数据库不存在，则会默认执行数据库创建脚本。

3. 流程引擎初体验

• 简单了解Bpmn
  • Task任务：
    用户任务（userTask）
    系统任务（serviceTask ）
  • Event事件：
    定时器事件（timerEventDefinition）
  • Gateway网关：
    排他网关（exclusive gateway）
• 目标：实现以下简化版的请假流程

请假流程图（简单版）
步骤1：定义相应的BPMN文件

步骤2：配置flowable.cfg.xml

步骤3：将流程定义添加到Repository仓储中

步骤4：Runtime开始一个流程实例

4. 下载安装

4.1. 下载

• 下载地址：https://www.flowable.org/

• 下载地址：https://github.com/flowable/flowable-engine/releases/download/flowable-6.4.2/flowable-6.4.2.zip

4.2. 解压

**目标结构**

4.3. 部署war包

4.3.1. 部署

• 拷贝war包到Tomcat的wapapps目录：
  
• 部署

4.3.2. 启动Tomcat

• 用户名 / 密码: admin/test
• 地址：
  • 流程图管理： http://localhost:8080/flowable-modeler
  • 任务管理： http://localhost:8080/flowable-task
  • 用户管理： http://localhost:8080/flowable-admin
  • 认证管理： http://localhost:8080/flowable-idm
  • 接口地址：http://localhost:8080/flowable-rest

应用权限

4.3.3.数据库分成两套

• 项目数据库：项目所需表和flowable通过jar包生成的表（34张）
• Flowable数据库：用于流程图创建保存，测试，监控（74张）
• 项目部署只需项目数据库

5. Flowable的用户权限体系

在接入Flowable的用户权限体系的时候，有四种方式：

• 使用Flowable提供的默认IdmEngine进行用户体系管理，该引擎包含了用户、组的概念。
• 集成LDAP，实现轻量级用户权限管理。通过IdentityService进行认证，用于由IdentityService处理所有认证业务的场景。
• 实现IdmIdentityService接口，自定义实现用户、组的查询
• 接入自定义的权限体系
  用户id => 获取到租户id、角色id集、部门id集
  • 单用户（assignee=”用户id”）、多用户（candidateUsers=”用户id1，用户id2”）
  • 单角色、多角色（candidateGroups=”:角色id1，:角色id2”）
  • 单部门、多部门（candidateGroups=”部门id1:，部门id2:”）
  • 角色或部门（candidateGroups=”角色id1:， :部门id1”）
  • 角色且部门

6. 数据表结构

ACT_RE_ *：RE代表repository。具有此前缀的表包含静态信息，例如流程定义和流程资源（图像，规则等）。
ACT_RU_ *：RU代表runtime。这些是包含运行时的流程实例，用户任务，变量，作业等的运行时数据的运行时表。
Flowable仅在流程实例执行期间存储运行时数据，并在流程实例结束时删除记录。这使运行时表保持小而快。
ACT_HI_ *：HI代表history。这些是包含历史数据的表，例如过去的流程实例，变量，任务等。
ACT_GE_ *：general数据，用于各种用例。
ACT_ID_*：Idm的用户、组

数据表： ACT_HI_ACTINST 流程实例的历史运行节点表 ACT_HI_TASKINST 流程实例的历史任务表 ACT_HI_VARINST 流程实例的历史运行节点的变量表 ACT_HI_PROCINST 流程历史部署记录 ACT_HI_IDENTITYLINK 对应ACT_RU_IDENTITYLINK的历史记录表 ACT_RE_DEPLOYMENT 流程部署 ACT_RE_PROCDEF 流程定义表 ACT_RU_EXECUTION 流程实例执行过程的所有节点记录 ACT_RU_IDENTITYLINK 流程实例运行过程中，各节点对应的用户 ACT_RU_TASK 流程实例运行时的任务表 ACT_RU_VARIABLE 流程实例运行时节点的变量表 ACT_GE_BYTEARRAY 资源文件表

7. Docker环境运行

7.1. 前置条件

Docker 环境

7.2. 运行 Flowable6.4.2

Docker Hub上提供了所有工作流的UI应用程序。
要启动 Flowable REST 应用需要H2内存数据库:

[root@localhost ~]# docker run -p8080:8080 flowable/flowable-rest

这个API文档的访问地址为：http://localhost:8080/flowable-rest/docs/
用户名：rest-admin 密码：test
要运行完整的Flowable 工作流，可以运行run the ‘All-in-One’ Docker 镜像，这个镜像包含Flowable IDM、Modeler、Task 、Admin UI 应用，运行容器为Tomcat,数据为内存数据库H2。

[root@localhost ~]# docker run -p8080:8080 flowable/all-in-one

Flowable Modeler; http://localhost:8080/flowable-modeler
Flowable Task; http://localhost:8080/flowable-task
Flowable Admin; http://localhost:8080/flowable-admin
Flowable IDM; http://localhost:8080/flowable-idm

7.3. 运行测试

1） 用户组权限管理

(用户名/密码: admin/test)
http://192.168.247.130:8080/flowable-idm/#/login

用户管理

2） 流程定义管理

http://192.168.247.130:8080/flowable-modeler

流程图

流程图

3） 用户任务管理

http://192.168.247.130:8080/flowable-task/#/

任务管理

4） 后台管理

http://192.168.247.130:8080/flowable-admin

二、Flowable开发—主要引擎

1. Flowable五大引擎

• flowable包含五个引擎，分别是：
  1、内容引擎 ContentEngine
  2、身份识别引擎 IdmEngine
  3、表单引擎 FormEngine
  4、决策引擎 DmnEngine
  5、流程核心引擎 ProcessEngine

• Flowable有五大引擎，每个之间都是相互独立互不影响。
• ProcessEngine是里面最核心也是最重要的一个引擎，如果失去它那Flowable也就意义了。

2. 引擎包含的服务

每个引擎由相对应的 EngineConfiguration进行创建，在创建过程中对每个引擎使用的服务进行初始化。

2.1. 内容引擎 ContentEngine

内容引擎包含的服务有：

1) ContentManagementService

ContentManagementService提供对数据库表的管理操作，包括：

Map<String, Long> getTableCount() 获取每个表的记录数量；
String getTableName(Class<?> flowableEntityClass); 根据实体类获得对应的数据库表名；
TableMetaData getTableMetaData(String tableName); 根据数据库表名获得表的列名和列类型；
TablePageQuery createTablePageQuery(); 创建一个可以进行排序、根据条件分页的查询类。

2) ContentService

实现对内容的创建、删除、保存和获取的基本操作。

ContentItem newContentItem();
void saveContentItem(ContentItem contentItem);
void saveContentItem(ContentItem contentItem, InputStream inputStream);
InputStream getContentItemData(String contentItemId);
void deleteContentItem(String contentItemId);
void deleteContentItemsByProcessInstanceId(String processInstanceId);
void deleteContentItemsByTaskId(String taskId);
ContentItemQuery createContentItemQuery();

3) ContentEngineConfiguration

ContentEngineConfiguration最主要的作用是提供Mybatis的封装，实现数据库相关配置的获取。
同时，内容引擎配置还提供了操作系统级的文件操作的路径设置、文件读取、文件保存的功能。

2.2. 身份识别引擎 IdmEngine

身份识别引擎包含的服务有：

1) IdmIdentityService

提供用户的创建、修改、删除、密码修改、登录、用户头像设置等；
提供组Group的创建、删除、用户与组关系的关联、删除关联；
提供权限的创建、删除、关联等。

2) IdmManagementService

对身份识别相关的数据库表进行统计、获取表的列信息。

3) IdmEngineConfiguration

提供数据库配置信息。

2.3. 表单引擎 FormEngine

表单引擎包含的服务有：

FormManagementService
FormRepositoryService
FormService
FormEngineConfiguration

2.4. 决策引擎 DmnEngine

决策引擎包含的服务有：

DmnManagementService
DmnRepositoryService
DmnRuleService
DmnHistoryService
DmnEngineConfiguration

2.5. 流程引擎 ProcessEngine

流程引擎包含的服务有：

RepositoryService
RuntimeService
HistoryService
IdentityService
TaskService
FormService
ManagementService
DynamicBpmnService

三、Flowable开发—SpringBoot集成

1. Maven依赖

<!--web依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--数据库操作依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
    <version>5.1.6</version>
</dependency>
<!--mybatis-plus 插件-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.1.2</version>
</dependency>
<!--druid-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.18</version>
</dependency>
<!--工作流-->
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter</artifactId>
    <version>6.4.2</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>

2. application.properties配置

server.port=7001
# 数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/workflow_flowable?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadOnly=false&serverTimezone=GMT%2b8
spring.datasource.username=root
spring.datasource.password=1234
# 数据库连接池
spring.datasource.druid.filters=stat
#spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
# 配置初始化大小/最小/最大
spring.datasource.druid.initial-size=2
spring.datasource.druid.min-idle=2
spring.datasource.druid.max-active=30
# 获取连接等待超时时间
spring.datasource.druid.max-wait=60000
# 间隔多久进行一次检测，检测需要关闭的空闲连接
spring.datasource.druid.time-between-eviction-runs-millis=60000
# 一个连接在池中最小生存的时间
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.validation-query=SELECT 'x'
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
# 打开PSCache，并指定每个连接上PSCache的大小。
# oracle设为true，mysql设为false。分库分表较多推荐设置为false
spring.datasource.druid.pool-prepared-statements=false
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
## mybatis-plus配置
mybatis-plus.mapper-locations=classpath*:/mappers/**/*.xml
# 实体扫描，多个package用逗号或者分号分隔
mybatis-plus.type-aliases-package=com.xtsz.workflow.entity
# 配置banner
mybatis-plus.global-config.banner=false
#  #主键类型  AUTO:"数据库ID自增", INPUT:"用户输入ID",ID_WORKER:"全局唯一ID (数字类型唯一ID)", UUID:"全局唯一ID UUID";
mybatis-plus.global-config.db-config.id-type=id_worker
# 字段策略 IGNORED:"忽略判断",NOT_NULL:"非 NULL 判断"),NOT_EMPTY:"非空判断"
#mybatis-plus.global-config.db-config.field-strategy=not_empty
# 逻辑删除全局值（1表示已删除，这也是Mybatis Plus的默认配置）
mybatis-plus.global-config.db-config.logic-delete-value=1
#逻辑未删除全局值（0表示未删除，这也是Mybatis Plus的默认配置）
mybatis-plus.global-config.db-config.logic-not-delete-value=0
# 配置返回数据库(column下划线命名&&返回java实体是驼峰命名)，
# 自动匹配无需as（没开启这个，SQL需要写as： select user_id as userId）
mybatis-plus.configuration.map-underscore-to-camel-case=true
mybatis-plus.configuration.cache-enabled=false
# 设置全局属性用于控制数据库的类型
mybatis-plus.configuration-properties.dbType=mysql
#在格式：logging.level.Mapper类的包=debug  会在控制台打印出sql语句
#logging.level.com.xtsz.admin.modules.system.mapper=debug
# 上传附件的目录设置以及系统一块模板word、excel的存放路径
# 这样做的原因是由于spring boot发布时打包成了jar,所以没有办法往jar中写文件
filepath.uploadpath=D:\\uploadfile\\
filepath.templatepath=D:\\templatefile\\
# flowable spring boot时自动部署resource/processes中的流程文件
flowable.check-process-definitions=true
# db-identity-used: true
# 自动生成flowable相关表 第一次生成后建议关闭提高运行速度
# 将databaseSchemaUpdate设置为true。
# 当Flowable发现库与数据库表结构不一致时，会自动将数据库表结构升级至新版本。
flowable.database-schema-update=true
# 保存历史数据级别设置为full最高级别，便于历史数据的追溯
flowable.history-level=full
# 关闭定时任务JOB
flowable.async-executor-activate=false

测试方便flowable配置为默认的即可。为了测试时方便看日志信息，我这里将flowable的定时job功能暂时关闭。
初次运行时flowable会将自动执行flowable中的初始化脚本完成工作流所需要的数据表的建立，如果指定的数据库中还未创建过flowable的相关数据表的话。

3. 定义流程文件

flowable建议采用业界标准BPMN2.0的XML来描述需要定义的工作流。

1. 创建目录processes 在项目的resource目录下，创建目录processes。
   
   创建目录processes
2. 添加流程文件 ExpenseProcess.bpmn20.xml
   流程定义文件：文件的命名必须是XXXX.bpmn20.xml，注意命名规范，扩展名必须是bpmn20.xml。
   流程定义图片：用BPMN2.0规范定义的各种图形描绘（BMPN2.0的符号及画布上的坐标信息），一般是PNG格式。
   表单文件：把表单内容保存在一个文件中，扩展名为drl。
   规则文件：扩展名为drl。

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:flowable="http://flowable.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
             xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"
             typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath"
             targetNamespace="http://www.flowable.org/processdef">
    <process id="Expense" name="ExpenseProcess" isExecutable="true">
        <documentation>报销流程</documentation>
        <startEvent id="start" name="开始"></startEvent>
        <userTask id="fillTask" name="出差报销" flowable:assignee="${taskUser}">
            <extensionElements>
                <modeler:initiator-can-complete xmlns:modeler="http://flowable.org/modeler">
                    <![CDATA[false]]></modeler:initiator-can-complete>
            </extensionElements>
        </userTask>
        <exclusiveGateway id="judgeTask"></exclusiveGateway>
        <userTask id="directorTak" name="经理审批">
            <extensionElements>
                <flowable:taskListener event="create"
                                       class="com.xtsz.workflow.handler.ManagerTaskHandler"></flowable:taskListener>
            </extensionElements>
        </userTask>
        <userTask id="bossTask" name="老板审批">
            <extensionElements>
                <flowable:taskListener event="create"
                                       class="com.xtsz.workflow.handler.BossTaskHandler"></flowable:taskListener>
            </extensionElements>
        </userTask>
        <endEvent id="end" name="结束"></endEvent>
        <sequenceFlow id="directorNotPassFlow" name="驳回" sourceRef="directorTak" targetRef="fillTask">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${outcome=='驳回'}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="bossNotPassFlow" name="驳回" sourceRef="bossTask" targetRef="fillTask">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${outcome=='驳回'}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="flow1" sourceRef="start" targetRef="fillTask"></sequenceFlow>
        <sequenceFlow id="flow2" sourceRef="fillTask" targetRef="judgeTask"></sequenceFlow>
        <sequenceFlow id="judgeMore" name="大于500元" sourceRef="judgeTask" targetRef="bossTask">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${money > 500}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="bossPassFlow" name="通过" sourceRef="bossTask" targetRef="end">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${outcome=='通过'}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="directorPassFlow" name="通过" sourceRef="directorTak" targetRef="end">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${outcome=='通过'}]]></conditionExpression>
        </sequenceFlow>
        <sequenceFlow id="judgeLess" name="小于500元" sourceRef="judgeTask" targetRef="directorTak">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${money <= 500}]]></conditionExpression>
        </sequenceFlow>
    </process>
    <bpmndi:BPMNDiagram id="BPMNDiagram_Expense">
        <bpmndi:BPMNPlane bpmnElement="Expense" id="BPMNPlane_Expense">
            <bpmndi:BPMNShape bpmnElement="start" id="BPMNShape_start">
                <omgdc:Bounds height="30.0" width="30.0" x="285.0" y="135.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="fillTask" id="BPMNShape_fillTask">
                <omgdc:Bounds height="80.0" width="100.0" x="405.0" y="110.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="judgeTask" id="BPMNShape_judgeTask">
                <omgdc:Bounds height="40.0" width="40.0" x="585.0" y="130.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="directorTak" id="BPMNShape_directorTak">
                <omgdc:Bounds height="80.0" width="100.0" x="735.0" y="110.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="bossTask" id="BPMNShape_bossTask">
                <omgdc:Bounds height="80.0" width="100.0" x="555.0" y="255.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="end" id="BPMNShape_end">
                <omgdc:Bounds height="28.0" width="28.0" x="771.0" y="281.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
                <omgdi:waypoint x="315.0" y="150.0"></omgdi:waypoint>
                <omgdi:waypoint x="405.0" y="150.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
                <omgdi:waypoint x="505.0" y="150.16611295681062"></omgdi:waypoint>
                <omgdi:waypoint x="585.4333333333333" y="150.43333333333334"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="judgeLess" id="BPMNEdge_judgeLess">
                <omgdi:waypoint x="624.5530726256983" y="150.44692737430168"></omgdi:waypoint>
                <omgdi:waypoint x="735.0" y="150.1392757660167"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="directorNotPassFlow" id="BPMNEdge_directorNotPassFlow">
                <omgdi:waypoint x="785.0" y="110.0"></omgdi:waypoint>
                <omgdi:waypoint x="785.0" y="37.0"></omgdi:waypoint>
                <omgdi:waypoint x="455.0" y="37.0"></omgdi:waypoint>
                <omgdi:waypoint x="455.0" y="110.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="bossPassFlow" id="BPMNEdge_bossPassFlow">
                <omgdi:waypoint x="655.0" y="295.0"></omgdi:waypoint>
                <omgdi:waypoint x="771.0" y="295.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="judgeMore" id="BPMNEdge_judgeMore">
                <omgdi:waypoint x="605.4340277777778" y="169.56597222222223"></omgdi:waypoint>
                <omgdi:waypoint x="605.1384083044983" y="255.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="directorPassFlow" id="BPMNEdge_directorPassFlow">
                <omgdi:waypoint x="785.0" y="190.0"></omgdi:waypoint>
                <omgdi:waypoint x="785.0" y="281.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="bossNotPassFlow" id="BPMNEdge_bossNotPassFlow">
                <omgdi:waypoint x="555.0" y="295.0"></omgdi:waypoint>
                <omgdi:waypoint x="455.0" y="295.0"></omgdi:waypoint>
                <omgdi:waypoint x="455.0" y="190.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
        </bpmndi:BPMNPlane>
    </bpmndi:BPMNDiagram>
</definitions>

这样当flowable框架启动的时候它会默认加载resource目录下的processes时就可以将此流程配置加载到数据库进行持久化了。
flowable:assignee=”${taskUser}” 与代码Map中的taskUser键对应。
flowable:taskListener 中的class指定处理器。

4. 代码编写

1. 定义配置类
   FlowableConfig.java

/**
 * 解决flowable图片中的中文乱码
 */
@Configuration
public class FlowableConfig implements EngineConfigurationConfigurer<SpringProcessEngineConfiguration> {
    @Override
    public void configure(SpringProcessEngineConfiguration engineConfiguration) {
        engineConfiguration.setActivityFontName("宋体");
        engineConfiguration.setLabelFontName("宋体");
        engineConfiguration.setAnnotationFontName("宋体");
    }
}

1. 处理器类

public class BossTaskHandler implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        delegateTask.setAssignee("老板");
    }
}
public class ManagerTaskHandler implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        delegateTask.setAssignee("经理");
    }
}

1. 控制器类

@RestController
@RequestMapping(value = "expense")
public class ExpenseController {
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private RepositoryService repositoryService;
    @Resource
    private ProcessEngine processEngine;
    /**
     * 1. 添加报销
     * 接收用户的一个请求传入用户的ID和金额以及描述信息来
     * 开启一个报销流程，并返回给用户这个流程的Id
     * @param userId    用户Id
     * @param money     报销金额
     * @param descption 描述
     */
    @RequestMapping(value = "add")
    public String addExpense(String userId, Integer money, String descption) {
        // 启动流程
        HashMap<String, Object> map = new HashMap<>();
        map.put("taskUser", userId);
        map.put("money", money);
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Expense", map);
        return "提交成功.流程Id为：" + processInstance.getId();
    }
    /**
     * 获取审批管理列表
     * 获取出此用户需要处理的流程
     */
    @RequestMapping(value = "/list")
    public Object list(String userId) {
        List<Task> tasks = taskService.createTaskQuery().taskAssignee(userId).orderByTaskCreateTime().desc().list();
        for (Task task : tasks) {
            System.out.println(task.toString());
        }
        return tasks.toArray().toString();
    }
    /**
     * 批准
     * 通过前端传入的任务ID来对此流程进行同意处理
     * @param taskId 任务ID
     */
    @RequestMapping(value = "apply")
    public String apply(String taskId) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task == null) {
            throw new RuntimeException("流程不存在");
        }
        //通过审核
        HashMap<String, Object> map = new HashMap<>();
        map.put("outcome", "通过");
        taskService.complete(taskId, map);
        return "processed ok!";
    }
    /**
     * 拒绝
     */
    @RequestMapping(value = "reject")
    public String reject(String taskId) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("outcome", "驳回");
        taskService.complete(taskId, map);
        return "reject";
    }
    /**
     * 生成流程图
     *
     * @param processId 任务ID
     */
    @RequestMapping(value = "processDiagram")
    public void genProcessDiagram(HttpServletResponse httpServletResponse, String processId) throws Exception {
        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的Id
        List<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();
            }
        }
    }
}

5. 运行测试

1. 创建一个流程
   访问：http://localhost:7001/expense/add?userId=123&money=123321
   
   创建一个流程
   返回：提交成功.流程Id为：1294e612-f289-11e9-8bad-005056c00008
2. 查询待办列表
   访问：http://localhost:7001/expense/list?userId=123
   
   查询待办列表
   输出：Task[id=129979fb-f289-11e9-8bad-005056c00008, name=出差报销]
   
   查询待办列表
3. 同意
   访问：http://localhost:7001/expense/apply?taskId=129979fb-f289-11e9-8bad-005056c00008
   
   同意
   返回：processed ok!
4. 生成流程图
   访问：http://localhost:7001/expense/processDiagram?processId=1294e612-f289-11e9-8bad-005056c00008
   
   生成流程图

6. 常见问题

1. 数据库版本问题
   请使用：5.x.x 版本，不要太高。
2. 自动布署问题
   配置文件：

# flowable spring boot时自动部署resource/processes中的流程文件
flowable.check-process-definitions=true

四、Flowable开发—流程部署

1. 部署相关的表

1. act_re_deployment：流程模型部署对象表
   每部署一次生成一条记录，首先生成这条数据，它的id主键将会被act_re_procdef和act_ge_bytearray作为外键。
2. actre_procdef：流程定义表
   一次部署可能采用zip/bar进行部署，里面是有多份流程定义文件xml的，这时候act_re_deployment只有一条部署信息，但act_re_procdef有多个记录（一个流程定义对应一条），这个表有DEPLOYMENT_ID外键字段，用它关联act_re_deployment。
3. act_ge_bytearray：资源文件表
   流程模型资源文件的真正存放地方，它每部署一次就会产生2条记录，一条是关于bpmn规范的文件内容存放在BYTES字段中，另一条是图片信息，采用二进制格式存储。
   提示：可以部署后解析bpmn文件的内容自动生成流程图，实现流程图的跟踪线路。
4. act_re_model：这张表，在xml进行部署时，它没有内容(flowable放弃了此表改用act_de_model保存流程模型信息）

2. Maven依赖

针对Model部署需增加：

<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-json-converter</artifactId>
    <version>6.4.2</version>
</dependency>
<!--流程设计器-->
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-ui-modeler-rest</artifactId>
    <version>6.4.2</version>
    <exclusions>
        <exclusion>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
        </exclusion>
    </exclusions>
</dependency>

3. 流程图部署

1. 流程资源xml部署

@SpringBootTest
@Slf4j
class WorkflowFlowableApplicationTests {
    @Autowired
    private RepositoryService repositoryService;
    @Resource
    private ProcessEngine processEngine;
    /**
     * 流程资源xml部署
     */
    @Test
    void deployFlow() {
        String filePath = "processes/OrderApproval.bpmn20.xml";
        DeploymentBuilder deploymentBuilder = repositoryService.createDeployment()
                .addClasspathResource(filePath);
        Deployment deployment = deploymentBuilder.deploy();
        log.info("成功：部署工作流成：" + filePath);
        log.info("部署ID："+deployment.getId());
        log.info("部署时间："+deployment.getDeploymentTime());
    }
}

1. zip/bar打包，多个流程资源文件部署

  /**
     * zip/bar打包，多个流程资源文件部署
     */
    @Test
    void deployFlowZip() {
        /**
         * 需要将所有流程图进行打包
         */
        String file = "diagrams/approve.zip";
        InputStream in = this.getClass().getClassLoader().getResourceAsStream(file);
        ZipInputStream zipInputStream = new ZipInputStream(in);
        // 获取流程定义和部署对象相关的Service
        Deployment deployment = processEngine.getRepositoryService()
                // 创建部署对象
                .createDeployment()
                // 使用zip方式部署，将approve.bpmn和approve.png压缩成zip格式的文件
                .addZipInputStream(zipInputStream)
                .deploy(); // 完成部署
        log.info("部署ID：" + deployment.getId());
        log.info("部署时间：" + deployment.getDeploymentTime());
    }

1. Model部署

/**
 * Model部署
 */
void deployFlowModel() {
    String modelId = "modelId";
    // 通过act_de_model中存放的Modeler内容来部署
    Model modelData = repositoryService.getModel(modelId);
    ObjectNode modelNode = null;
    try {
        // 获取模型
        byte[] bytes = repositoryService.getModelEditorSource(modelData.getId());
        if (null == bytes) {
            log.error("模型数据为空，请先设计流程并成功保存，再进行发布。");
        }
        modelNode = (ObjectNode) new ObjectMapper().readTree(bytes);
        BpmnModel model = new BpmnJsonConverter().convertToBpmnModel(modelNode);
        if (model.getProcesses().size() == 0) {
            log.error("数据模型不符要求，请至少设计一条主线流程。");
        }
        byte[] bpmnBytes = new BpmnXMLConverter().convertToXML(model);
        // 发布流程
        String processName = modelData.getName() + ".bpmn20.xml";
        repositoryService.createDeployment().name(modelData.getName()).addString(processName, new String(bpmnBytes, "UTF-8")).deploy();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

4. 流程部署示例

1. 创建流程图

流程图

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:flowable="http://flowable.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.flowable.org/processdef">
    <process id="test_bpmn" name="测试BPMN模型" isExecutable="true">
        <documentation>测试BPMN模型</documentation>
        <startEvent id="start" name="开始"></startEvent>
        <endEvent id="end" name="结束"></endEvent>
        <userTask id="testUser" name="用户任务测试"></userTask>
        <sequenceFlow id="sid-8D834F3C-45A8-4C88-9AD1-1AC426CC9002" sourceRef="start" targetRef="testUser"></sequenceFlow>
        <sequenceFlow id="sid-AB59612A-1B33-4FB8-8758-5D773EDF9C44" sourceRef="testUser" targetRef="end"></sequenceFlow>
    </process>
    <bpmndi:BPMNDiagram id="BPMNDiagram_test_bpmn">
        <bpmndi:BPMNPlane bpmnElement="test_bpmn" id="BPMNPlane_test_bpmn">
            <bpmndi:BPMNShape bpmnElement="start" id="BPMNShape_start">
                <omgdc:Bounds height="30.0" width="30.0" x="210.0" y="60.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="end" id="BPMNShape_end">
                <omgdc:Bounds height="28.0" width="28.0" x="525.0" y="61.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="testUser" id="BPMNShape_testUser">
                <omgdc:Bounds height="80.0" width="100.0" x="315.0" y="35.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNEdge bpmnElement="sid-8D834F3C-45A8-4C88-9AD1-1AC426CC9002" id="BPMNEdge_sid-8D834F3C-45A8-4C88-9AD1-1AC426CC9002">
                <omgdi:waypoint x="239.94999779398907" y="75.0"></omgdi:waypoint>
                <omgdi:waypoint x="315.0" y="75.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="sid-AB59612A-1B33-4FB8-8758-5D773EDF9C44" id="BPMNEdge_sid-AB59612A-1B33-4FB8-8758-5D773EDF9C44">
                <omgdi:waypoint x="414.9499999999903" y="75.0"></omgdi:waypoint>
                <omgdi:waypoint x="525.0" y="75.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
        </bpmndi:BPMNPlane>
    </bpmndi:BPMNDiagram>
</definitions>

1. 创建业务方法

public interface IFlowService {
    /**
     * 部署工作流
     */
    Deployment createFlow(String filePath);
}
@Primary
@Service
@Slf4j
public class FlowServiceImpl implements IFlowService {
    /**
     * Flowable运行时服务
     */
    @Autowired
    private RepositoryService repositoryService;
    @Override
    public Deployment createFlow(String filePath) {
        //解析BPMN模型看是否成功
        XMLStreamReader reader = null;
        InputStream inputStream = null;
        try {
            BpmnXMLConverter bpmnXMLConverter = new BpmnXMLConverter();
            XMLInputFactory factory = XMLInputFactory.newInstance();
            inputStream=new FileInputStream(new File(filePath));
            reader = factory.createXMLStreamReader(inputStream);
            BpmnModel model = bpmnXMLConverter.convertToBpmnModel(reader);
            List<Process> processes = model.getProcesses();
            Process curProcess = null;
            if (CollectionUtils.isEmpty(processes)) {
                log.error("BPMN模型没有配置流程");
                return null;
            }
            curProcess = processes.get(0);
            inputStream=new FileInputStream(new File(filePath));
            DeploymentBuilder deploymentBuilder = repositoryService.createDeployment().name("TEST_FLOW")
                    .addInputStream(curProcess.getName(),inputStream);
            Deployment deployment= deploymentBuilder.deploy();
            log.warn("部署流程 name:"+curProcess.getName() + " "+deployment);
            return deployment;
        }
        catch (Exception e){
            log.error("BPMN模型创建流程异常",e);
            return null;
        }
        finally {
            try {
                reader.close();
            } catch (XMLStreamException e) {
                log.error("关闭异常",e);
            }
        }
    }
}

1. 创建控制器

@RestController
@RequestMapping(value = "flow")
@Slf4j
public class FlowController {
    @Autowired
    private IFlowService flowService;
    @RequestMapping("/create")
    public Map<String, String> createFlow() throws FileNotFoundException {
        Map<String, String> res = new HashMap<>();
        String flowPath = "processes/test.bpmn20.xml";
        File file = ResourceUtils.getFile(ResourceUtils.CLASSPATH_URL_PREFIX + flowPath);
        if (null == flowService.createFlow(file.getAbsolutePath())) {
            res.put("msg", "创建流程失败");
            res.put("res", "0");
            return res;
        }
        res.put("msg", "创建流程成功");
        res.put("res", "1");
        return res;
    }
}

1. 测试
   http://localhost:7001/flow/create
   
   测试

部署ID表：act_re_deployment

部署记录

布署内容表：act_ge_bytearray

五、Flowable开发—流程审批

1. 流程审批后涉及到的表

当流程全部走完后，actru表的数据清空了，全部移到了acthi表

2. 流程示例

1. 创建流程图
   创建OrderApproval.bpmn20.xml文件
   
   创建文件
   
   创建文件
   
   改更扩展名
   
   流程图设计

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:flowable="http://flowable.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.flowable.org/processdef">
    <!--订单审批,必须定义ID-->
    <process id="OrderApproval" name="订单审批" isExecutable="true">
        <!--开始事件-->
        <startEvent id="startEvent" name="采购订单"></startEvent>
        <!--流程-->
        <sequenceFlow id="sequenceFlow-3" sourceRef="startEvent" targetRef="approveTask"></sequenceFlow>
        <!--定义任务 flowable:assignee 指定用户ID-->
        <userTask id="approveTask" name="订单审批" flowable:assignee="${userId}">
            <extensionElements>
                <modeler:initiator-can-complete xmlns:modeler="http://flowable.org/modeler"><![CDATA[false]]></modeler:initiator-can-complete>
            </extensionElements>
        </userTask>
        <!--定义网关-->
        <exclusiveGateway id="decision"></exclusiveGateway>
        <!--定义流程条件-->
        <sequenceFlow id="sequenceFlow-9" sourceRef="decision" targetRef="fail">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${!approved}]]></conditionExpression>
        </sequenceFlow>
        <!--定义任务->同意-->
        <serviceTask id="success" name="通过" flowable:class="com.xtsz.workflow.delegate.ReviewApprove"></serviceTask>
        <!--定义结束事件-->
        <endEvent id="approveEnd"></endEvent>
        <endEvent id="rejectEnd"></endEvent>
        <sequenceFlow id="sequenceFlow-e" sourceRef="success" targetRef="approveEnd"></sequenceFlow>
        <sequenceFlow id="sequenceFlow-1" sourceRef="fail" targetRef="rejectEnd"></sequenceFlow>
        <!--定义任务->拒绝-->
        <serviceTask id="fail" name="拒绝" flowable:class="com.xtsz.workflow.delegate.ReviewNoApprove"></serviceTask>
        <sequenceFlow id="sequenceFlow-5" sourceRef="approveTask" targetRef="decision"></sequenceFlow>
        <sequenceFlow id="sequenceFlow-c" sourceRef="decision" targetRef="success">
            <conditionExpression xsi:type="tFormalExpression"><![CDATA[${approved}]]></conditionExpression>
        </sequenceFlow>
    </process>
    <bpmndi:BPMNDiagram id="BPMNDiagram_OrderApproval">
        <bpmndi:BPMNPlane bpmnElement="OrderApproval" id="BPMNPlane_OrderApproval">
            <bpmndi:BPMNShape bpmnElement="startEvent" id="BPMNShape_startEvent">
                <omgdc:Bounds height="30.0" width="30.0" x="0.0" y="95.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="approveTask" id="BPMNShape_approveTask">
                <omgdc:Bounds height="60.0" width="100.0" x="75.0" y="75.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="decision" id="BPMNShape_decision">
                <omgdc:Bounds height="40.0" width="40.0" x="230.0" y="90.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="success" id="BPMNShape_success">
                <omgdc:Bounds height="60.0" width="100.0" x="320.0" y="0.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="approveEnd" id="BPMNShape_approveEnd">
                <omgdc:Bounds height="28.0" width="28.0" x="620.0" y="16.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="rejectEnd" id="BPMNShape_rejectEnd">
                <omgdc:Bounds height="28.0" width="28.0" x="570.0" y="175.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNShape bpmnElement="fail" id="BPMNShape_false">
                <omgdc:Bounds height="60.0" width="100.0" x="315.0" y="150.0"></omgdc:Bounds>
            </bpmndi:BPMNShape>
            <bpmndi:BPMNEdge bpmnElement="sequenceFlow-5" id="BPMNEdge_sequenceFlow-5">
                <omgdi:waypoint x="174.95" y="105.0"></omgdi:waypoint>
                <omgdi:waypoint x="202.5" y="105.0"></omgdi:waypoint>
                <omgdi:waypoint x="202.5" y="110.0"></omgdi:waypoint>
                <omgdi:waypoint x="230.0" y="110.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="sequenceFlow-c" id="BPMNEdge_sequenceFlow-c">
                <omgdi:waypoint x="269.9189252336448" y="110.0"></omgdi:waypoint>
                <omgdi:waypoint x="282.0" y="110.0"></omgdi:waypoint>
                <omgdi:waypoint x="282.0" y="30.000000000000004"></omgdi:waypoint>
                <omgdi:waypoint x="319.999999999994" y="30.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="sequenceFlow-1" id="BPMNEdge_sequenceFlow-1">
                <omgdi:waypoint x="414.95000000000005" y="180.0"></omgdi:waypoint>
                <omgdi:waypoint x="460.0" y="180.0"></omgdi:waypoint>
                <omgdi:waypoint x="460.0" y="189.0"></omgdi:waypoint>
                <omgdi:waypoint x="570.0" y="189.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="sequenceFlow-e" id="BPMNEdge_sequenceFlow-e">
                <omgdi:waypoint x="419.94999999998697" y="30.0"></omgdi:waypoint>
                <omgdi:waypoint x="620.0" y="30.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="sequenceFlow-3" id="BPMNEdge_sequenceFlow-3">
                <omgdi:waypoint x="29.949987029268733" y="110.0"></omgdi:waypoint>
                <omgdi:waypoint x="52.5" y="110.0"></omgdi:waypoint>
                <omgdi:waypoint x="52.5" y="105.0"></omgdi:waypoint>
                <omgdi:waypoint x="74.99999999999241" y="105.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNEdge bpmnElement="sequenceFlow-9" id="BPMNEdge_sequenceFlow-9">
                <omgdi:waypoint x="269.9189252336448" y="110.0"></omgdi:waypoint>
                <omgdi:waypoint x="282.0" y="110.0"></omgdi:waypoint>
                <omgdi:waypoint x="282.0" y="180.0"></omgdi:waypoint>
                <omgdi:waypoint x="314.9999999999916" y="180.0"></omgdi:waypoint>
            </bpmndi:BPMNEdge>
        </bpmndi:BPMNPlane>
    </bpmndi:BPMNDiagram>
</definitions>

流程图

1. 创建委托

import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.delegate.DelegateExecution;
import org.flowable.engine.delegate.JavaDelegate;
/**
 * 批准委托类
 */
@Slf4j
public class ReviewApprove implements JavaDelegate {
    @Override
    public void execute(DelegateExecution delegateExecution) {
        //可以发送消息给某人
        log.info("通过，userId是：{}",delegateExecution.getVariable("userId"));
    }
}
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.delegate.DelegateExecution;
import org.flowable.engine.delegate.JavaDelegate;
/**
 * 驳回委托类
 */
@Slf4j
public class ReviewNoApprove implements JavaDelegate {
    @Override
    public void execute(DelegateExecution delegateExecution) {
        //可以发送消息给某人
        log.info("拒绝，userId是：{}",delegateExecution.getVariable("userId"));
    }
}

1. 创建控制器

@RestController
@RequestMapping("/orderFlow")
@Slf4j
public class OrderFlowController {
    @Autowired
    private RepositoryService repositoryService;
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private HistoryService historyService;
    @Resource
    private ProcessEngine processEngine;
    /**
     * 1.提交采购订单的审批请求
     *
     * @param userId 用户id
     */
    @PostMapping("/start/{userId}/{purchaseOrderId}")
    public Result startFlow(@PathVariable String userId, @PathVariable String purchaseOrderId) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("userId", userId);
        map.put("purchaseOrderId", purchaseOrderId);
        // 流程ID->OrderApproval
        ProcessInstance processInstance =
                runtimeService.startProcessInstanceByKey("OrderApproval", map);
        String processId = processInstance.getId();
        // 名称由布署时指定
        String name = processInstance.getName();
        log.info(processId + ":" + name);
        return Result.ok(processId + ":" + name);
    }
    /**
     * 2.获取用户的任务
     *
     * @param userId 用户id
     */
    @GetMapping("/getTasks/{userId}")
    public Result getTasks(@PathVariable String userId) {
        List<Task> tasks = taskService.createTaskQuery().taskAssignee(userId).orderByTaskCreateTime().desc().list();
        return Result.ok(tasks.toString());
    }
    /**
     * 3.审批通过
     */
    @PostMapping("/success/{taskId}")
    public Result success(@PathVariable String taskId) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task == null) {
            return Result.error("流程不存在");
        }
        //通过审核
        HashMap<String, Object> map = new HashMap<>();
        // 在流程图中获取进行处理
        map.put("approved", true);
        taskService.complete(taskId, map);
        return Result.ok("流程审核通过！");
    }
    /**
     * 4.审批不通过
     */
    @PostMapping("/fail/{taskId}")
    public Result fail(@PathVariable String taskId) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task == null) {
            return Result.error("流程不存在");
        }
        //通过审核
        HashMap<String, Object> map = new HashMap<>();
        // 在流程图中获取进行处理
        map.put("approved", false);
        taskService.complete(taskId, map);
        return Result.ok();
    }
    /**
     * 5. 生成流程图
     *
     * @param httpServletResponse
     * @param processId
     * @throws Exception
     */
    @PostMapping(value = "processDiagram")
    public void genProcessDiagram(HttpServletResponse httpServletResponse, String processId) {
        /**
         * 获得当前活动的节点
         */
        String processDefinitionId = "";
        boolean isFinish = historyService.createHistoricProcessInstanceQuery().finished()
                .processInstanceId(processId).count() > 0;
        if (isFinish) {// 如果流程已经结束，则得到结束节点
            HistoricProcessInstance pi = historyService.createHistoricProcessInstanceQuery()
                    .processInstanceId(processId).singleResult();
            processDefinitionId = pi.getProcessDefinitionId();
        } else {// 如果流程没有结束，则取当前活动节点
            // 根据流程实例ID获得当前处于活动状态的ActivityId合集
            ProcessInstance pi = runtimeService.createProcessInstanceQuery()
                    .processInstanceId(processId).singleResult();
            processDefinitionId = pi.getProcessDefinitionId();
        }
        List<String> highLightedActivitis = new ArrayList<String>();
        /**
         * 获得活动的节点
         */
        List<HistoricActivityInstance> highLightedActivitList = historyService.createHistoricActivityInstanceQuery().processInstanceId(processId).orderByHistoricActivityInstanceStartTime().asc().list();
        for (HistoricActivityInstance tempActivity : highLightedActivitList) {
            String activityId = tempActivity.getActivityId();
            highLightedActivitis.add(activityId);
        }
        List<String> flows = new ArrayList<>();
        //获取流程图
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
        ProcessEngineConfiguration engconf = processEngine.getProcessEngineConfiguration();
        ProcessDiagramGenerator diagramGenerator = engconf.getProcessDiagramGenerator();
        // 注意：如果是PNG格式那么输出的是背景色是黑色，如果连接线上有字不容易看清楚。可以使用bmp
        InputStream in = diagramGenerator.generateDiagram(bpmnModel, "png", highLightedActivitis, 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);
            }
        } catch (IOException e) {
            log.error("操作异常", e);
        } finally {
            IOUtils.closeQuietly(out);
            IOUtils.closeQuietly(in);
        }
    }
}