Flowable 开发环境搭建指南

June 24, 2025

在开始自定义和扩展 Flowable 之前，我们需要搭建一个完整的开发环境。本文将详细介绍如何配置 Java 开发环境和 Maven 依赖管理，让你能够顺利开始 Flowable 的开发工作。

设置开发环境

要自定义 Flowable，你需要一个能够开发 Java 项目的环境。因此，你需要安装 Java JDK 和你选择的集成开发环境（IDE）。

如果你还对前端自定义感兴趣，可以查看前端开发环境设置相关文档。

配置 Maven 下载 Flowable 依赖

要下载 Flowable Work/Engage 的依赖包，你需要访问 Flowable 的制品仓库。你可以通过以下 ~/.m2/settings.xml 配置你的 Maven 仓库。需要将 USER 和 PASSWORD 替换为你的凭据。

密码可以加密存储，你可以按照以下指南之一操作：

使用 Maven 主密码进行密码加密
使用 JFrog 身份令牌：前往 Flowable Artifacts，点击右上角的用户图标，然后选择"编辑个人资料"。生成一个新的身份令牌。此令牌可以在你的 settings.xml 中用作密码。
使用 JFrog 加密密码：前往 Flowable Artifacts，点击右上角的用户图标，然后选择"编辑个人资料"。用你的密码解锁设置并复制加密密码。此密钥可以在你的 settings.xml 中用作密码。

重要提示

Flowable 制品仓库是受限的，凭据仅提供给活跃客户。如果在访问 Flowable 制品仓库时遇到问题，请联系 Flowable 支持团队或你的客户成功经理。

Maven Settings.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <servers>
        <server>
            <id>flowable-repo</id>
            <username>USER</username> <!-- 替换为你的用户名 -->
            <password>PASSWORD</password> <!-- 替换为你的密码 -->
        </server>
    </servers>

    <profiles>
        <profile>
            <id>flowable-artifacts</id>
            <repositories>
                <repository>
                    <snapshots>
                        <enabled>false</enabled>
                    </snapshots>
                    <id>flowable-repo</id>
                    <name>flowable-maven-all</name>
                    <url>https://repo.flowable.com/artifactory/flowable-maven-all</url>
                </repository>
            </repositories>
        </profile>
    </profiles>

    <activeProfiles>
        <activeProfile>flowable-artifacts</activeProfile>
    </activeProfiles>
</settings>

API 密钥的废弃

为了分发制品，Flowable 使用 JFrog。JFrog 已废弃 API 密钥，因此需要将其替换为身份令牌或密码本身。

提示

你可以使用密码登录或使用身份令牌。身份令牌或密码哪个更合适取决于你在哪里使用密码。身份令牌会在一年后自动过期，你可以撤销令牌。

对于代理制品仓库的中心位置，使用密码可能更好，因为它不会过期。

开发环境准备清单

在开始 Flowable 开发之前，请确保你已完成以下步骤：

1. Java 开发环境

✅ 安装 Java JDK 8 或更高版本
✅ 配置 JAVA_HOME 环境变量
✅ 选择并安装 IDE（推荐 IntelliJ IDEA 或 Eclipse）

2. Maven 配置

✅ 安装 Maven 3.6+
✅ 配置 ~/.m2/settings.xml 文件
✅ 获取 Flowable 制品仓库访问凭据
✅ 测试 Maven 依赖下载

3. 验证配置

创建一个简单的测试项目来验证你的配置：

<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-engine</artifactId>
    <version>7.0.1</version>
</dependency>

如果依赖能够成功下载，说明你的开发环境配置正确！

下一步

环境搭建完成后，你可以：

创建你的第一个 Flowable 项目
学习 Flowable 的核心概念
开始构建你的工作流应用

祝你在 Flowable 开发之旅中一切顺利！

Flowable 后端脚本

May 6, 2025

Flowable 脚本 API 架构

简介

脚本可以在各种场景中使用，如流程的脚本任务、案例的脚本任务以及使用脚本的服务注册定义中。

可以使用符合JSR-223标准的脚本语言（如JavaScript或Groovy）来编写脚本，Flowable将脚本API暴露到脚本上下文中，您可以访问各种实用工具，以及创建JSON对象、访问服务、请求输入变量和注册输出参数，当然这取决于您的具体使用场景。

本文档主要介绍Flowable脚本API，它通过flw对象进行访问和使用。

输入和输出

在脚本中，您可以使用flw.getInput(name)获取输入值，根据上下文的不同，返回的可能是具有请求名称的变量或具有该名称的输入参数。

同样，使用flw.setOutput(name, value)可以设置变量值或注册输出参数值。

以下方法可用：

flw.getInput(name) - 根据上下文的不同，返回请求名称的变量或对应名称的输入参数。
flw.setOutput(name, value) - 设置变量值或注册输出参数值。
flw.setTransientOutput(name, value) - 设置临时变量值。
flw.setLocalOutput(name, value) - 将变量值设置为本地作用域。

脚本任务示例：

flw.getInput('foo'); 将返回名为foo的变量。
flw.setOutput('bar', myBarValue); 将存储一个名为bar的新变量，其值由本地脚本变量myBarValue提供。

使用脚本的注册服务示例：

flw.getInput('foo'); 将返回名为foo的映射输入参数。
flw.setOutput('bar', myBarValue); 将本地脚本变量myBarValue提供的值注册为名为bar的输出参数。

BPMN错误

脚本API支持使用以下方法抛出BPMN错误：

flw.bpmn.throwError('ERROR_CODE')
flw.bpmn.throwError('ERROR_CODE', 'Error Message')

BPMN错误可以在BPMN模型中使用错误边界事件或错误事件子流程进行处理，这使其成为基于模型的错误处理的强大工具，无需修改Java代码。

这些工具方法相当于便捷地执行throw new org.flowable.engine.delegate.BpmnError('ERROR_CODE')。

JSON工具

脚本API还支持各种围绕JSON对象处理的工具，如创建JSON对象或数组，或将JSON字符串转换为JSON对象结构。

您可以通过flw.json访问这些工具。

要创建一个新的空JSON对象，使用flw.json.createObject()，并将结果存储为本地变量，或使用返回的JSON对象的流式API来创建其值。

带有简单值的JSON对象

只使用值而不带嵌套或列表值的简单JSON对象可以如下创建：

示例：

var myJson = flw.json.createObject();
myJson.putString('name', 'Sample Json object');
myJson.putInteger('sum', 100);
myJson.putBoolean('verified', true);

这个例子也可以写成：

var myJson = flw.json.createObject()
    .putString('name', 'Sample Json object')
    .putInteger('sum', 100)
    .putBoolean('verified', true);

或者，如果用作输出值：

flw.setOutput('myJsonOutputParameter', flw.json.createObject()
    .putString('name', 'Sample Json object')
    .putInteger('sum', 100)
    .putBoolean('verified', true));

脚本变量、JSON和FLOWABLE变量

有不同的方式来表示脚本中的数据：

Groovy/JavaScript变量（以下为简化起见，专注于JavaScript）
JSON
Flowable变量

在JavaScript中，您可以创建对象结构并向这些对象添加不同的元素，包括例如日期。例如：{name: 'Sample Json object', myDate: new Date()}

将其转换为JSON将产生如下结果：{"test":"2024-01-17T05:53:01.880Z"}。这可以在JavaScript中分配给变量，但并不是每个JavaScript变量都是有效的JSON。例如，{test: () => { return 'test' }}在JavaScript中是有效的对象，但将其转换为JSON会导致一个空对象{}。

Flowable的flw.json API在不同脚本语言之间与向后兼容性无关。JavaScript执行来自Nashorn引擎，可能在不同的Java版本和/或类路径上可用的Nashorn引擎版本之间有所不同。

也可以直接使用JavaScript/Groovy创建JSON结构，只需注意这取决于执行引擎。

以下示例将使用JavaScript引擎创建一个对象，将其转换为JSON，然后将其添加为Flowable JSON变量testJson：

flw.setOutput("testJson",
   flw.json.stringToJson(
      JSON.stringify({name: 'Sample Json object', test: new Date()})
   )
);

嵌套JSON对象

嵌套对象也可以轻松创建：

var myJson = flw.json.createObject()
    .putString('name', 'Sample Json object');

myJson.createChildObject('nestedObject')
    .putString('nestedObjectName', 'Nested Json object');

注意

createChildObject方法将创建一个新的子JSON对象，并使用提供的字段名将其添加到当前对象（从中调用该方法的对象）。

请注意返回值；createObject()将返回根JSON对象，但createChildObject始终只返回新创建的子对象以进行进一步处理，如添加值。如果您最终需要使用根对象，请确保保留一个包含返回的根JSON对象的变量，而不仅仅是最新的嵌套对象。

JSON数组

JSON数组可以作为"根"JSON对象创建，也可以作为嵌套对象创建。

创建JSON数组可以使用json工具的createArray方法：

var myJsonArray = flw.json.createArray()
    .addString('hello')
    .addString('world');

创建嵌套JSON数组也很简单：

var myJson = flw.json.createObject()
    .putString('name', 'Sample Json object');

myJson.createChildArray('nestedList')
    .addString('hello')
    .addString('world');

注意

要向数组添加值，请使用addXY方法，而不是用于设置JSON对象值的putXY方法。

可用方法

以下部分列出了使用flw.json.createObject，flw.json.createArray或flw.json.stringToJson创建的JSON对象的可用方法。

通用方法

这是可用通用方法的列表：

size() 此对象的属性数量或数组长度。
isArray() 当节点是数组节点时返回true。
isObject() 当节点是对象节点时返回true。
isValue() 当节点是值节点时返回true。
isPresent() 当节点存在时返回true。
isNonNull() 当节点存在且不为null时返回true。
iterator() 返回一个迭代器以迭代数组元素。对于对象节点，返回带有对象本身的单个元素迭代器。

对象方法

这是JSON对象（非数组）可用方法的列表：

putString(fieldName, value) 带有String值。
putInteger(fieldName, value) 带有Number值。
putInt(fieldName, value) 带有int值。
putBoolean(fieldName, value) 带有boolean值。
putShort(fieldName, value) 带有Number或short值。
putLong(fieldName, value) 带有Number或long值。
putDouble(fieldName, value) 带有Number或double值。
putFloat(fieldName, value) 带有Number或float值。
putObject(fieldName, value) 添加一个对象。该对象可以是null（则使用putNull）或另一个JSON对象或数组。
putNull(fieldName) 向对象添加null值。
createChildObject(fieldName) 创建一个新的子JSON对象并将其作为嵌套对象添加到当前对象。
createChildArray(fieldName) 创建一个新的JSON数组并将其作为子数组添加到当前对象。
path(path) 返回给定路径的JSON节点。当路径不存在时，结果对象对isPresent()返回false。
fieldNames() 返回对象节点的所有字段名称的集合。如果节点不是对象，则返回空集合。

数组方法

这是JSON数组（非对象）可用方法的列表：

addString(value) 带有String值。
addInteger(value) 带有Number值。
addInt(value) 带有int值。
addBoolean(value) 带有boolean值。
addShort(value) 带有Number或short值。
addLong(value) 带有Number或long值。
addDouble(value) 带有Number或double值。
addFloat(value) 带有Number或float值。
addNull() 向数组添加null值。
addObject(value) 向数组添加对象。该对象可以是null或另一个JSON对象或数组。
path(index) 将返回提供的索引处的元素。当索引不存在时，结果对象对isPresent()返回false。

值方法

这是值可用方法的列表。所有方法在被调用在非值或null节点上时都会抛出FlowableException。

asString() 将给定值节点作为字符串返回。将非字符串值转换为其字符串表示形式。
asInteger() 将数值作为整数返回。如果不是整数或整数溢出，则抛出FlowableException。
asLong() 将数值作为long返回。如果不是整数，则抛出FlowableException。
asDouble() 将数值作为double返回。
asBoolean() 返回布尔值。不将其他值类型强制转换为布尔值。
isString() 当节点是字符串时返回true。
isNumber() 当节点是数字时返回true。
isBoolean() 当节点是布尔值时返回true。

JSON字符串转换

如果您有表示JSON对象的字符串，可以将其转换为JSON对象以进行进一步处理，如果需要，也可以转回字符串。

flw.json.stringToJson
flw.json.jsonToString

示例：

var myJsonString = '{ "foo": "fooValue", "bar": "barValue", "sum": 100, "verified": true }';
var myJson = flw.json.stringToJson(myJsonString);
myJson.putString("my_value", "value");
var string = flw.json.jsonToString(myJson);

时间工具

脚本API还支持日期和时间处理的实用工具，可通过flw.time访问。如果没有特别说明，默认时区始终是UTC。

您可以使用与表达式中相同的功能，使用flwTimeUtils。

以下是可用函数的列表：

函数	描述
`Instant now()`	返回UTC中的当前日期和时间。
`Instant currentDate()`	返回UTC时间上午00:00的当前日期作为Instant。
`LocalDate currentLocalDate()`	返回系统时区（即UTC）中的当前日期，作为LocalDate实例。
`LocalDateTime currentLocalDateTime()`	返回系统时区（即UTC）中的当前日期和时间，作为LocalDateTime实例。
`Instant instantFromTimestamp(long timestamp)`	从1970年1月1日以来经过的秒数（Unix时间戳）返回一个Instant。
`Date dateFromTimestamp(long timestamp)`	从1970年1月1日以来经过的秒数（Unix时间戳）返回一个Date。
`Instant parseInstant(Date date)`	从Date中返回一个Instant。
`Instant parseInstant(String instantIsoString)`	将ISO8601格式的字符串解析为Instant。
`Instant parseInstant(Object value, String pattern)`	使用提供的模式将对象解析为Instant。支持的输入是String、Json TextNode或null。
`LocalDate parseLocalDate(Object value, String pattern)`	使用提供的模式将对象解析为LocalDate。支持的输入是String、Json TextNode或null。
`LocalDateTime parseLocalDateTime(Object value, String pattern)`	使用提供的模式将对象解析为LocalDateTime。支持的输入是String、Json TextNode或null。
`Instant asInstant(Object value)`	将值转换为带有UTC时区的Instant。支持的值有：Date、Instant（直接返回）、LocalDate、LocalDateTime、ISO8601格式的String或null。
`Instant asInstant(Object value, String timeZoneId)`	将值转换为给定时区的Instant。支持的值有：Date、Instant（直接返回）、LocalDate、LocalDateTime、ISO8601格式的String或null。
`LocalDate asLocalDate(Object value)`	将值转换为带有UTC时区的LocalDate。支持的值有：Date、Instant、LocalDate（直接返回）、LocalDateTime、ISO8601格式的String或null。
`LocalDate asLocalDate(Object value, String timeZoneId)`	将值转换为给定时区的LocalDate。支持的值有：Date、Instant、LocalDate（直接返回）、LocalDateTime、ISO8601格式的String或null。
`LocalDateTime asLocalDateTime(Object value)`	将值转换为带有UTC时区的LocalDateTime。支持的值有：Date、Instant、LocalDate、LocalDateTime（直接返回）、ISO8601格式的String或null。
`LocalDateTime asLocalDateTime(Object value, String timeZoneId)`	将值转换为给定时区的LocalDateTime。支持的值有：Date、Instant、LocalDate、LocalDateTime（直接返回）、ISO8601格式的String或null。
`Date asDate(Object value)`	将值转换为UTC时区中的Date。支持的值有Instant、LocalDate、LocalDateTime、ISO8601格式的String或null。
`Object atTime(Object value, int hours, int minutes, int seconds)`	在UTC时区中将值的时间设置为指定的小时、分钟和秒。支持的值有Date、Instant、LocalDateTime或ISO8601格式的String。返回值将与输入类型相同，对于字符串，根据提供的字符串格式，将是Instant或LocalDateTime。
`Object atTimeWithTimeZone(Object value, int hours, int minutes, int seconds, String timeZoneId)`	在给定时区中将值的时间设置为指定的小时、分钟和秒。支持的值有Date、Instant、LocalDateTime或ISO8601格式的String。返回值将与输入类型相同，对于字符串，根据提供的字符串格式，将是Instant或LocalDateTime。
`Object atTimeZone(Object value, String timeZoneId)`	返回指定时区的Instant。支持的值有Date或Instant。仅将此用于显示目的，切勿将日期存储在UTC以外的其他时区中。
`List<String> getAvailableTimeZoneIds()`	返回可用时区ID的列表。更完整的列表也可以在这里找到。
`int getField(Object value, String chronoFieldString)`	通过指定ChronoField作为字符串来获取"时间片段"。chrono字段可以指定为显示名称或枚举名称。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。所有chrono字段的列表可以在这里找到。例如：`flw.time.getField(flw.time.now(), 'DAY_OF_WEEK')`或`flw.time.getField(flw.time.now(), 'AlignedWeekOfYear')`。
`boolean isWeekend(Object value)`	确定给定值是否表示周末。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Instant fullDateTimeInstant(int year, int month, int day, int hour, int minute, int second)`	使用给定的值在UTC时区创建Instant。
`Date fullDateTimeDate(int year, int month, int day, int hour, int minute, int second)`	使用给定的值创建Date。
`Object plusSeconds(Object value, long seconds)`	向给定值添加秒数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object plusMinutes(Object value, long minutes)`	向给定值添加分钟数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object plusHours(Object value, long hours)`	向给定值添加小时数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object plusDays(Object value, long days)`	向给定值添加天数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object plusWeeks(Object value, long days)`	向给定值添加周数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object plusMonths(Object value, long days)`	向给定值添加月数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object plusYears(Object value, long days)`	向给定值添加年数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object plusDuration(Object value, String iso8601Duration)`	向给定值添加ISO8601编码的持续时间。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。例如：`flw.time.plusDuration(flw.time.now(), 'P1Y')`（向现在添加一年），`flw.time.plusDuration(flw.time.now(), 'P14D')`（向现在添加14天），`flw.time.plusDuration(flw.time..now(), 'PT30M10S')`（向现在添加30分钟和10秒）。
`Object minusSeconds(Object value, long seconds)`	从给定值减去秒数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object minusMinutes(Object value, long minutes)`	从给定值减去分钟数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object minusHours(Object value, long hours)`	从给定值减去小时数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object minusDays(Object value, long days)`	从给定值减去天数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object minusWeeks(Object value, long days)`	从给定值减去周数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object minusMonths(Object value, long days)`	从给定值减去月数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object minusYears(Object value, long days)`	从给定值减去年数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`Object minusDuration(Object value, String iso8601Duration)`	从给定值减去ISO8601编码的持续时间。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。例如：`flw.time.minusDuration(flw.time.now(), 'P1Y')`（从现在减去一年），`flw.time.minusDuration(flw.time.now(), 'P14D')`（从现在减去14天），`flw.time.minusDuration(flw.time..now(), 'PT30M10S')`（从现在减去30分钟和10秒）。
`long secondsOfDuration(String iso8601Duration)`	返回ISO持续时间字符串中的秒数，例如PT60M返回3600。
`boolean isBefore(Object firstValue, Object secondValue)`	检查第一个值是否在第二个值之前。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。这些值不需要是相同类型，如果需要，它们将自动转换。
`boolean isBeforeOrEqual(Object firstValue, Object secondValue)`	检查第一个值是否在第二个值之前或等于第二个值。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。这些值不需要是相同类型，如果需要，它们将自动转换。
`boolean isAfter(Object firstValue, Object secondValue)`	检查第一个值是否在第二个值之后。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。这些值不需要是相同类型，如果需要，它们将自动转换。
`boolean isAfterOrEqual(Object firstValue, Object secondValue)`	检查第一个值是否在第二个值之后或等于第二个值。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。这些值不需要是相同类型，如果需要，它们将自动转换。
`boolean areEqual(Object firstValue, Object secondValue)`	检查第一个值是否等于第二个值。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。这些值不需要是相同类型，如果需要，它们将自动转换。
`boolean isBeforeTime(Object value, String timeZoneId, int hours, int minutes, int seconds)`	检查给定值是否在给定时区的某个时间之前。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`boolean isAfterTime(Object value, String timeZoneId, int hours, int minutes, int seconds)`	检查给定值是否在给定时区的某个时间之后。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`long getFieldFromDurationBetweenDates(Object firstValue, Object secondValue, String chronoUnitString)`	返回两个值之间的持续时间。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。支持以下单位：Nanos、Micros、Millis、Seconds、Hours、HalfDays、Days、Weeks、Months、Years、Decades、Centuries、Millenia。请注意，数字始终是long类型，即数字始终会被四舍五入。
`long secondsBetween(Object firstValue, Object secondValue)`	返回两个值之间的秒数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`long minutesBetween(Object firstValue, Object secondValue)`	返回两个值之间的分钟数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`long hoursBetween(Object firstValue, Object secondValue)`	返回两个值之间的小时数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`long daysBetween(Object firstValue, Object secondValue)`	返回两个值之间的天数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`long weeksBetween(Object firstValue, Object secondValue)`	返回两个值之间的周数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`long monthsBetween(Object firstValue, Object secondValue)`	返回两个值之间的月数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`long yearsBetween(Object firstValue, Object secondValue)`	返回两个值之间的年数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。
`long getTimeZoneOffset(Object value, String timeZoneId)`	计算指定时区中特定时间点与UTC的偏移秒数。支持的值有Date、Instant、LocalDate、LocalDateTime或ISO8601格式的String。

字符串工具

脚本API还支持字符串处理的实用工具，可通过flw.string访问。

您可以使用与表达式中相同的功能，使用flwStringUtils。

以下是可用函数的列表：

函数	描述
`String toUpperCase(Object text)`	将对象的所有字母转换为大写。支持的值有String、Json TextNode或null。
`String toLowerCase(Object text)`	将对象的所有字母转换为小写。支持的值有String、Json TextNode或null。
`String capitalize(Object text)`	将文本首字母大写，即将第一个字母设置为大写。支持的值有String、Json TextNode或null。
`String trimWhitespace(Object text)`	删除文本中所有前导和尾随空格。支持的值有String、Json TextNode或null。
`boolean hasText(Object text)`	检查字符串是否包含文本（不为null或空）。支持的值有String、Json TextNode或null。
`boolean contains(Object text, String otherText)`	检查字符串是否包含另一个字符串。支持的值有String、Json TextNode或null。
`boolean containsIgnoreCase(Object text, String otherText)`	检查字符串是否包含另一个字符串，忽略大小写。支持的值有String、Json TextNode或null。
`boolean matches(Object text, String regularExpression)`	检查文本是否匹配正则表达式。支持的值有String、Json TextNode或null。
`boolean equals(Object text, String otherText)`	检查两个字符串是否相等。支持的值有String、Json TextNode或null。
`boolean equalsIgnoreCase(Object text, String otherText)`	检查两个字符串是否相等，忽略大小写。支持的值有String、Json TextNode或null。
`String substring(Object text, int from, int to)`	返回提供的字符范围内的子字符串。索引基于0，from包含在内，to不包含在内。支持的值有String、Json TextNode或null。
`String substringFrom(Object text, int from)`	返回从给定位置开始的文本（索引基于0）。支持的值有String、Json TextNode或null。
`List<String> split(Object text, String delimiter)`	使用给定的分隔符将文本拆分为集合。分隔符可以是单个字符，例如分号，或正则表达式。支持的值有String、Json TextNode或null。
`String join(Collection<String> collection, String delimiter)`	使用给定的分隔符将列表或集合的所有条目连接为单个字符串。支持的值有String、Json TextNode或null。
`String newline()`	返回新行/换行符。
`String carriageReturn()`	返回回车符。
`String escapeHtml(Object text)`	使用HTML实体转义对象中的字符。支持的值有String、Json TextNode或null。
`String unescapeHtml(Object text)`	将包含实体转义的字符串转义为包含与转义对应的实际Unicode字符的字符串。支持的值有String、Json TextNode或null。

数学工具

脚本API还支持数学运算工具，可通过flw.math访问。

您可以使用与表达式中相同的功能，使用flwMathUtils。

以下是可用函数的列表：

函数	描述
`double sum(Collection<Double> numbers)`	计算数字列表的总和。
`double average(Collection<Double> numbers)`	计算数字列表的平均值。
`double floor(double number)`	返回提供的数字的下一个较低整数。
`double ceil(double number)`	返回提供的数字的下一个较高整数。
`double round(double number)`	将数字四舍五入为整数值。
`double round(double number, int scale)`	使用RoundingMode#HALF_UP将数字四舍五入到最多小数位数。
`double min(Collection<Double> numbers)`	返回数字列表中的最小数字。
`double max(Collection<Double> numbers)`	返回数字列表中的最大数字。
`double abs(double number)`	返回数字的绝对值。
`double median(Collection<Double> numbers)`	返回数字列表的中位数。
`double parseDouble(String string)`	将字符串转换为double值。
`int parseInt(String string)`	将字符串转换为整数值。

区域工具

脚本API还提供用于处理区域设置、国家和语言的工具，可通过flw.locale访问。

您可以使用与表达式中相同的功能，使用flwLocaleUtils。

以下是可用函数的列表：

函数	描述
`Locale getLocaleForLanguageTag(String languageTag)`	返回具有给定语言标签的区域设置，例如'ch-DE'。
`List<Locale> getAvailableLocales()`	返回可用区域设置的列表。
`Locale getDefaultLocale()`	返回系统默认区域设置。
`List<String> getAllCountryCodes()`	返回所有2字母ISO国家代码的列表。
`List<String> getAllLanguageCodes()`	返回所有ISO语言代码的列表，例如"de"（不是"de-CH"）。
`String getLanguageDisplayName(String languageIsoCode, String displayLanguageTag)`	返回某种语言的单一语言名称，例如"German"或"Spanish"。
`String getCountryDisplayName(String languageTag, String displayLanguageTag)`	返回某种语言的单一国家名称，例如"Switzerland"或"Germany"。
`List<String> getAllLanguageDisplayNames(String displayLanguageTag)`	返回某种语言中所有语言名称的列表。
`List<String> getAllCountryDisplayNames(String displayLanguageTag)`	返回某种语言中所有国家名称的列表。

格式化工具

脚本API还提供围绕格式化的工具，可通过flw.format访问。

您可以使用与表达式中相同的功能，使用flwFormatUtils。

以下是可用函数的列表：

函数	描述
`String formatString(String text, Object... substitutes)`	根据Java格式化程序规范格式化字符串，参见这里或这里。
`String formatDate(Object value, String dateFormat)`	使用给定格式将值格式化为字符串。支持的值有Date、Instant、LocalDate、LocaDateTime或ISO8601格式的字符串。
`String formatDecimal(String pattern, double decimal)`	使用默认区域设置中的十进制格式化程序根据Java格式化程序规范格式化字符串。参见格式化规范。
`String formatStringWithLocale(String languageTag, String text, Object... substitutes)`	根据Java格式化程序规范格式化字符串。字符串根据提供的语言标签的区域设置中指定的格式进行格式化。参见这里或这里。
`String formatCurrencyWithLocale(String currencyCode, double amount, String languageTag)`	根据提供的语言标签的区域设置中指定的格式格式化货币金额。

AI赋能Flowable：破解传统BPM的响应延迟与决策盲区

April 3, 2025

Flowable AI Cover

在数字化转型的浪潮中，业务流程管理（BPM）正从传统的规则驱动向智能化跃迁。Flowable作为轻量级、高性能的流程引擎，凭借其灵活性和扩展性，正在与人工智能（AI）技术深度结合，推动企业运营效率的颠覆性提升。2024年9月，Flowable推出了Flowable AI Studio，引入了一系列AI辅助功能，旨在提升工作流自动化和智能化。这些功能包括生成式AI建模、AI服务和内容分析，旨在解决传统建模中的"空白画布"问题，并增强运行时的决策能力。

AI功能详解

Flowable AI Studio通过REST API和Java集成实现了一系列强大的AI功能，这些功能可以轻松嵌入现有应用或作为云服务运行。以下是核心功能详解：

功能类型	功能描述	应用价值	实际案例
AI辅助建模	通过自然语言提示生成流程、案例、表单和应用程序的初稿	显著加速建模过程	根据业务描述自动生成完整的客户服务工作流模型
AI服务集成	将AI能力无缝集成到业务流程中	创建智能、自适应的工作流系统	基于实时数据智能调整审批流程路径
智能内容管理	提供内容摘要、情感分析、自动翻译等能力	增强文档处理和内容分析能力	自动生成业务报告摘要，实时分析客户反馈情绪
生成式AI建模	提供全方位的模型创建支持	解决建模起点难题，降低入门门槛	快速生成新项目的初始流程图和相关配置
分析性AI决策	提供实时决策支持和流程优化建议	提升运营效率和资源利用率	基于AI预测结果优化任务分配和资源调度

应用场景分析

1. 智能客户入职流程

在金融与电信行业中，AI赋能的客户入职流程展现出显著优势：

智能数据分析：自动处理信用评分和收入证明
风险评估：基于AI模型进行实时风险评估
动态流程：根据评估结果自动调整审批路径
效率提升：显著减少人工干预，加快处理速度

2. 智能文档处理系统

在法律和医疗领域，AI驱动的文档处理带来革新性变化：

自动分类：智能识别和分类各类专业文档
信息提取：准确提取文档中的关键信息
智能路由：自动将文档分发至相关处理部门
流程自动化：实现发票等标准文档的自动处理流程

3. 预测性设备维护

在制造业场景中，AI与工作流的结合优化了设备维护流程：

故障预测：通过AI分析设备运行数据
预警机制：及时发现潜在问题
自动调度：智能安排维护人员和资源
效益提升：有效减少设备停机时间

技术实现路径与开发指南

要实现Flowable的AI赋能，开发者需关注以下关键点：

1. AI模型与流程引擎的松耦合设计

通过REST API或消息队列集成AI服务，避免紧耦合带来的维护成本。例如：

@Service
public class AIServiceIntegration {
    @Autowired
    private RestTemplate restTemplate;
    
    public AIAnalysisResult analyzeProcess(ProcessData data) {
        return restTemplate.postForObject("/ai/analyze", data, AIAnalysisResult.class);
    }
}

2. 动态变量与上下文感知

利用Flowable的流程变量（execution variables）传递AI分析结果，例如通过runtimeService.setVariable()动态更新决策参数：

@Service
public class AIDecisionService {
    @Autowired
    private RuntimeService runtimeService;
    
    public void updateProcessDecision(String executionId, AIDecision decision) {
        runtimeService.setVariable(executionId, "aiDecision", decision);
    }
}

3. 事件监听与实时反馈

通过TaskListener和ExecutionListener捕获流程节点事件，触发AI模型的再训练与优化：

public class AIFeedbackListener implements TaskListener {
    @Override
    public void notify(DelegateTask task) {
        // 收集任务完成数据用于AI模型优化
        AIFeedbackData feedback = collectTaskData(task);
        aiModelService.updateModel(feedback);
    }
}

未来展望：AI与流程引擎的共生演进

随着大语言模型（LLM）的普及，Flowable的智能化将呈现新趋势：

1. 自然语言驱动的流程设计

用户可通过对话描述业务需求，AI自动生成BPMN流程图。这种方式将大大降低流程建模的门槛，使业务人员能够更直接地参与流程设计。例如，通过简单的描述："创建一个客户订单审批流程，包含销售审核、财务审核和最终确认三个步骤"，AI就能自动生成对应的BPMN模型。

2. 自适应流程优化

基于强化学习（RL）的AI模型持续迭代流程规则，实现"越用越智能"的闭环。系统将通过分析历史数据、执行效率和业务成功率，自动调整流程路径和决策规则，不断优化流程执行效果。

3. 人机协同的混合流程

AI处理标准化任务，复杂场景无缝转交人工，形成双向交互机制。这种协同模式将充分发挥AI在处理重复性工作中的效率优势，同时保留人类在处理复杂决策时的判断能力。具体表现为：

AI自动处理数据录入、文档分类等标准化任务
遇到异常或复杂情况时，智能转交给人工处理
人工处理过程中的决策数据被用来训练AI模型，提高其处理能力

总结

Flowable AI Studio的推出标志着BPM领域进入智能化新纪元。通过AI技术的深度整合，Flowable不仅提升了流程自动化水平，更为企业数字化转型提供了强大动力。随着技术持续演进，Flowable必将在智能流程管理领域发挥更大价值。

Flowable 后端表达式

April 2, 2025

后端表达式

简介

后端表达式是一种在执行流程、案例或决策表期间获取或设置变量的工具。后端表达式还可以用于实现自定义逻辑，或将该逻辑委托给部署在服务器上的Java服务。使用表达式的示例包括设置动态任务名称、网关后序列流的评估，或创建特定类型的变量。顾名思义，这些表达式在执行期间在后端运行。因此，在评估时它们无法访问前端数据。

在Flowable Design中，表达式可以在带有闪电图标的字段中使用：⚡️

Flowable使用统一表达式语言(UEL)来解析表达式。UEL的文档是了解语法和可用运算符的良好参考。每个表达式都以${开始，以}结束。

表达式分为两种类型：

值表达式：提供一个值。支持的值包括布尔值、字符串、整数、浮点数和null。典型的值表达式形式为${variable.property}或${bean.property}。
方法表达式：调用带参数或不带参数的方法。方法表达式的示例为${bean.setPropertyValue('newValue')}。为了区分不带参数的值表达式和方法表达式，在方法调用的末尾使用空括号。例如：${variable.toString()}。

理论上，任何暴露给应用程序的Spring bean都可以在后端表达式中使用，但并非所有类都能以允许正确表达式评估的方式进行序列化。

信息提示某些表达式可在脚本中使用（例如在BPMN或CMMN脚本任务中）。可用表达式的列表可在后端脚本文档中找到。

关键字

流程和CMMN引擎支持上下文相关的对象。两种引擎都可以解析层次对象，如root和parent，并可用于访问它们的本地属性。root代表执行层次结构顶部的对象，可以是流程实例或案例实例。parent是对当前对象在层次结构中紧邻上方的第一个流程或案例实例的引用。

对于流程实例和案例实例，definition提供对定义及其所有属性的访问。

在BPMN执行上下文中，额外的保留关键字包括execution和authenticatedUserId：

execution：引用当前的"执行路径"或"令牌"。它提供对name、businessKey、processDefinitionId和parentExecution等属性的访问（在技术上，它由ExecutionEntity类支持）。
task：引用当前任务（在技术上，它由TaskEntity类支持）。
authenticatedUserId：当前认证用户的字符串标识符。如果没有认证用户，该变量将不可用。

CMMN引擎上下文支持task（见上文）、caseInstance和planItemInstance：

caseInstance：引用当前案例实例。它提供对name、state、businessKey、caseDefinitionId和parentId等属性的访问（在技术上，它由CaseInstanceEntity类支持）。
planItemInstance：引用与案例关联的计划项实例。

表达式概述

流程实例属性

以下属性在流程实例上可用，例如当使用root或parent时。

示例用法：${root.businessKey}

属性	描述
businessKey	流程实例的业务键（如果已设置）
businessStatus	流程实例的业务状态（如果已设置）
callbackId	如果流程实例是通过CMMN案例实例中的流程任务启动的，此值将引用关联的计划项实例的ID
description	流程实例的描述（如果已设置）
definition	流程定义。详细信息见下文
id	流程实例的唯一技术标识符
name	流程实例的名称（如果已设置）
startTime	流程实例启动的时间（java.util.Date类型）
startUserId	启动此流程实例的用户ID
tenantId	此流程实例的租户标识符

案例实例属性

以下属性在案例实例上可用，例如当使用root或parent时。

示例用法：${parent.businessStatus}

属性	描述
businessKey	案例实例的业务键（如果已设置）
businessStatus	案例实例的业务状态（如果已设置）
callbackId	如果案例实例是通过CMMN案例实例中的案例任务启动的，此值将引用关联的计划项实例的ID
description	案例实例的描述（如果已设置）
definition	案例定义。详细信息见下文
id	案例实例的唯一技术标识符
name	案例实例的名称（如果已设置）
startTime	案例实例启动的时间（java.util.Date类型）
startUserId	启动此案例实例的用户ID
tenantId	此案例实例的租户标识符

定义属性

属性	描述
id	定义的唯一技术标识符
category	定义的类别（如果在相关模型中设置）
deploymentId	与此定义相关的部署引用。查看部署文档以了解更多信息
description	定义的描述（如果在模型中配置）
key	定义的键，对于所有类似的模型类型必须是唯一的。对于给定的键，通常在运行时系统中部署多个版本
name	定义的名称，与BPMN或CMMN模型的名称匹配
tenantId	部署此定义的租户标识符
version	定义的版本。每次发布模型时，都会为相同的键创建一个新定义，版本等于最后版本 + 1

变量函数

变量操作是表达式的重要用例。

设置变量可以通过runtimeService完成：

${runtimeService.setVariable(processInstanceId, variableName, variableValue)}
${cmmnRuntimeService.setVariable(caseInstanceId, variableName, variableValue)}

或在关键字对象上（取决于上下文）：

${execution.setVariable(varName, varValue)} 设置当前流程实例的变量varName的值为varValue
${caseInstance.setVariable(varName, varValue)} 设置当前案例实例的变量varName的值为varValue
${planItemInstance.setVariable(varName, varValue)} 设置当前案例实例的变量varName的值为varValue
${task.setVariable(varName, varValue)} 设置当前流程/案例实例的变量varName的值为varValue

以下函数可用于处理变量，适用于BPMN和CMMN上下文：

函数	描述
`${var:get(varName)}`	获取变量的值。与直接在表达式中写变量名的主要区别是，使用此函数在变量不存在时不会抛出异常
`${var:getOrDefault(varName, defaultValue)}`	获取变量值，如果变量不存在则返回默认值
`${var:exists(varName)}`	检查变量是否存在
`${var:isEmpty(varName)}`	检查变量值是否为空。根据变量类型，行为如下：对于String变量，如果是空字符串则为空；对于java.util.Collection变量，如果集合没有元素则为真；对于ArrayNode变量，如果没有元素则为真。如果变量为null，始终返回真
`${var:isNotEmpty(varName)}`	isEmpty的反向操作
`${var:equals(varName, value)}`	检查变量是否等于给定值。这是`${execution.getVariable("varName") != null && execution.getVariable("varName") == value}`的简写函数
`${var:notEquals(varName, value)}`	equals的反向操作
`${var:contains(varName, value1, value2, ...)}`	检查所有提供的值是否包含在变量中。根据变量类型有不同的行为
`${var:containsAny(varName, value1, value2, ...)}`	类似于contains函数，但如果任何（而不是所有）传递的值包含在变量中，则返回true
`${var:base64(varName)}`	将Binary或String变量转换为Base64字符串
`${var:lowerThan(varName, value)}`	`${execution.getVariable("varName") != null && execution.getVariable("varName") < value}`的简写。别名 = lt
`${var:lowerThanOrEquals(varName, value)}`	类似，但用于 <= 。别名 = lte
`${variables:greaterThan(varName, value)}`	类似，但用于 > 。别名 = gr
`${variables:greaterThanOrEquals(varName, value)}`	类似，但用于 >= 。别名 = gte

流程分配函数

以下函数在BPMN流程执行上下文中可用：

函数	描述
`${bpmn:setAssignee(processInstanceId, userId)}`	将指定processInstanceId的流程的受理人设置为给定的userId
`${bpmn:getAssignee()}`	返回当前流程的受理人
`${bpmn:getAssignee(processInstanceId)}`	返回指定processInstanceId的流程的受理人
`${bpmn:removeAssignee()}`	移除当前流程的受理人
`${bpmn:removeAssignee(processInstanceId)}`	移除指定processInstanceId的流程的受理人
`${bpmn:setOwner(processInstanceId, userId)}`	将指定processInstanceId的流程的所有者设置为给定的userId
`${bpmn:getOwner()}`	返回当前流程的所有者
`${bpmn:getOwner(processInstanceId)}`	返回指定processInstanceId的流程的所有者
`${bpmn:removeOwner()}`	移除当前流程的所有者
`${bpmn:removeOwner(processInstanceId)}`	移除指定processInstanceId的流程的所有者
`${bpmn:addParticipantUser(processInstanceId, userId)}`	将给定userId的用户作为参与者添加到指定processInstanceId的流程中
`${bpmn:addParticipantUsers(processInstanceId, userIds)}`	将给定userIds的用户作为参与者添加到指定processInstanceId的流程中。userIds可以是ArrayNode、Iterable或逗号分隔的userId列表
`${bpmn:removeParticipantUser(processInstanceId, userId)}`	从指定processInstanceId的流程中移除给定userId的参与者用户
`${bpmn:removeParticipantUsers(processInstanceId, userIds)}`	从指定processInstanceId的流程中移除给定userIds的参与者用户。userIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串
`${bpmn:addCandidateUser(processInstanceId, userId)}`	将给定userId的用户作为候选人添加到指定processInstanceId的流程中
`${bpmn:addCandidateUsers(processInstanceId, userIds)}`	将给定userIds的用户作为候选人添加到指定processInstanceId的流程中。userIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串
`${bpmn:removeCandidateUser(processInstanceId, userId)}`	从指定processInstanceId的流程中移除给定userId的候选人用户
`${bpmn:removeCandidateUsers(processInstanceId, userIds)}`	从指定processInstanceId的流程中移除给定userIds的候选人用户。userIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串
`${bpmn:addCandidateGroup(processInstanceId, groupId)}`	将给定groupId的组作为候选组添加到指定processInstanceId的流程中
`${bpmn:addCandidateGroups(processInstanceId, groupIds)}`	将给定groupIds的组作为候选组添加到指定processInstanceId的流程中。groupIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串
`${bpmn:removeCandidateGroup(processInstanceId, groupId)}`	从指定processInstanceId的流程中移除给定groupId的候选组
`${bpmn:removeCandidateGroups(processInstanceId, groupIds)}`	从指定processInstanceId的流程中移除给定groupIds的候选组。groupIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串

案例分配函数

以下函数在CMMN案例执行上下文中可用：

函数	描述
`${cmmn:setAssignee(caseInstanceId, userId)}`	将指定caseInstanceId的案例的受理人设置为给定的userId
`${cmmn:getAssignee()}`	返回当前案例的受理人
`${cmmn:getAssignee(caseInstanceId)}`	返回指定caseInstanceId的案例的受理人
`${cmmn:removeAssignee()}`	移除当前案例的受理人
`${cmmn:removeAssignee(caseInstanceId)}`	移除指定caseInstanceId的案例的受理人
`${cmmn:setOwner(caseInstanceId, userId)}`	将指定caseInstanceId的案例的所有者设置为给定的userId
`${cmmn:getOwner()}`	返回当前案例的所有者
`${cmmn:getOwner(caseInstanceId)}`	返回指定caseInstanceId的案例的所有者
`${cmmn:removeOwner()}`	移除当前案例的所有者
`${cmmn:removeOwner(caseInstanceId)}`	移除指定caseInstanceId的案例的所有者
`${cmmn:addParticipantUser(caseInstanceId, userId)}`	将给定userId的用户作为参与者添加到指定caseInstanceId的案例中
`${cmmn:addParticipantUsers(caseInstanceId, userIds)}`	将给定userIds的用户作为参与者添加到指定caseInstanceId的案例中。userIds可以是ArrayNode、Iterable或逗号分隔的userId列表
`${cmmn:removeParticipantUser(caseInstanceId, userId)}`	从指定caseInstanceId的案例中移除给定userId的参与者用户
`${cmmn:removeParticipantUsers(caseInstanceId, userIds)}`	从指定caseInstanceId的案例中移除给定userIds的参与者用户。userIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串
`${cmmn:addCandidateUser(caseInstanceId, userId)}`	将给定userId的用户作为候选人添加到指定caseInstanceId的案例中
`${cmmn:addCandidateUsers(caseInstanceId, userIds)}`	将给定userIds的用户作为候选人添加到指定caseInstanceId的案例中。userIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串
`${cmmn:removeCandidateUser(caseInstanceId, userId)}`	从指定caseInstanceId的案例中移除给定userId的候选人用户
`${cmmn:removeCandidateUsers(caseInstanceId, userIds)}`	从指定caseInstanceId的案例中移除给定userIds的候选人用户。userIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串
`${cmmn:addCandidateGroup(caseInstanceId, groupId)}`	将给定groupId的组作为候选组添加到指定caseInstanceId的案例中
`${cmmn:addCandidateGroups(caseInstanceId, groupIds)}`	将给定groupIds的组作为候选组添加到指定caseInstanceId的案例中。groupIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串
`${cmmn:removeCandidateGroup(caseInstanceId, groupId)}`	从指定caseInstanceId的案例中移除给定groupId的候选组
`${cmmn:removeCandidateGroups(caseInstanceId, groupIds)}`	从指定caseInstanceId的案例中移除给定groupIds的候选组。groupIds可以是TextNode的ArrayNode、String的Iterable或逗号分隔的userId字符串

CMMN函数

以下函数在CMMN上下文中可用：

函数	描述
`${cmmn:copyLocalVariable(planItemInstance, localVariableName, index, variableName)}`	将计划项实例的本地变量复制到案例实例
`${cmmn:getTask(taskId)}`	返回具有提供的ID的任务（运行时或历史）
`${cmmn:isPlanItemCompleted(planItemInstance)}`	此函数评估计划项是否已完成，这很可能用于具有重复规则的计划项，以检查它是否已经完成
`${cmmn:isStageCompletable()}`	返回当前案例阶段是否可完成（取决于阶段及其元素的配置，参见"自动完成"等）
`${cmmn:replaceVariableInList(planItemInstance, variableName, index, listVariableName)}`	使用variableName引用的变量值更改具有给定listVariableName的列表中提供的索引处的条目
`${cmmn:setBusinessStatus(caseInstanceId, businessStatus)}`	v3.16.0+ 更改匹配提供的caseInstanceId的案例实例的业务状态属性
`${cmmn:triggerCaseEvaluation(<parameter>)}`	触发案例实例的案例实例哨兵的评估。参数可以是planItemInstance、caseInstance或案例实例的ID

BPMN函数

以下函数在BPMN上下文中可用：

函数	描述
`${bpmn:copyLocalVariable(localVariableName, variableName)}`	将执行本地变量复制到流程实例
`${bpmn:copyLocalVariableToParent(localVariableName, variableName)}`	将执行本地变量复制到其父执行
`${bpmn:getTask(taskId)}`	返回具有提供的ID的任务（运行时或历史）
`${bpmn:replaceVariableInList(variableName, index, listVariableName)}`	使用variableName引用的变量值更改具有给定listVariableName的列表中提供的索引处的条目
`${bpmn:setBusinessStatus(processInstanceId, businessStatus)}`	v3.16.0+ 更改匹配提供的processInstanceId的流程实例的业务状态属性
`${bpmn:triggerCaseEvaluation()}`	触发作为流程实例父级的案例实例的案例实例哨兵的评估

字符串工具函数

字符串操作方法是表达式的经典用例。以下方法可用：

表达式	描述
`${flwStringUtils.carriageReturn()}`	返回回车字符
`${flwStringUtils.capitalize(text)}`	将文本首字母大写。支持的值类型有String、Json TextNode或null
`${flwStringUtils.contains(text, otherText)}`	检查字符串是否包含另一个字符串。支持的值类型有String、Json TextNode或null
`${flwStringUtils.containsIgnoreCase(text, otherText)}`	检查字符串是否包含另一个字符串（忽略大小写）。支持的值类型有String、Json TextNode或null
`${flwStringUtils.equals(text, otherText)}`	检查两个字符串是否相等。支持的值类型有String、Json TextNode或null
`${flwStringUtils.equalsIgnoreCase(text, otherText)}`	检查两个字符串是否相等（忽略大小写）。支持的值类型有String、Json TextNode或null
`${flwStringUtils.escapeHtml(text)}`	使用HTML实体转义对象中的字符。支持的值类型有String、Json TextNode或null
`${flwStringUtils.hasText(text)}`	检查字符串是否包含文本（不为null或空）。支持的值类型有String、Json TextNode或null
`${flwStringUtils.join(collection, String delimiter)}`	使用给定的分隔符将列表或集合的所有条目连接成单个字符串。支持的值类型有String、Json TextNode或null
`${flwStringUtils.matches(text, regularExpression)}`	检查文本是否匹配正则表达式。支持的值类型有String、Json TextNode或null
`${flwStringUtils.newline()}`	返回换行符
`${flwStringUtils.substring(text, from, to)}`	返回提供的字符范围内的子字符串。索引从0开始，from包含在内，to不包含在内。支持的值类型有String、Json TextNode或null
`${flwStringUtils.substringFrom(text, from)}`	返回从给定位置开始的文本（索引从0开始）。支持的值类型有String、Json TextNode或null
`${flwStringUtils.split(text, delimiter)}`	使用给定的分隔符将文本分割成集合。分隔符可以是单个字符（如分号）或正则表达式。支持的值类型有String、Json TextNode或null
`${flwStringUtils.toLowerCase(text)}`	将字符串的所有字符转换为小写
`${flwStringUtils.toUpperCase(text)}`	将字符串的所有字符转换为大写
`${flwStringUtils.trimWhitespace(text)}`	删除文本中的所有前导和尾随空格。支持的值类型有String、Json TextNode或null
`${flwStringUtils.unescapeHtml(text)}`	将包含实体转义的字符串转换为包含对应Unicode字符的字符串。支持的值类型有String、Json TextNode或null

日期和时间工具函数

以下是可用的日期和时间操作函数：

基本操作

表达式	描述
`${flwTimeUtils.now()}`	返回UTC时区的当前日期和时间
`${flwTimeUtils.currentDate()}`	返回UTC时区00:00 AM的当前日期，返回类型为Instant
`${flwTimeUtils.currentLocalDate()}`	返回系统时区（UTC）的当前日期，返回类型为LocalDate
`${flwTimeUtils.currentLocalDateTime()}`	返回系统时区（UTC）的当前日期和时间，返回类型为LocalDateTime

转换函数

表达式	描述
`${flwTimeUtils.instantFromTimestamp(long timestamp)}`	从Unix时间戳（自1970年1月1日起的秒数）创建Instant
`${flwTimeUtils.dateFromTimestamp(long timestamp)}`	从Unix时间戳创建Date
`${flwTimeUtils.parseInstant(Date date)}`	将Date转换为Instant
`${flwTimeUtils.parseInstant(String instantIsoString)}`	将ISO8601格式的字符串解析为Instant
`${flwTimeUtils.parseInstant(Object value, String pattern)}`	使用指定模式将对象解析为Instant
`${flwTimeUtils.parseLocalDate(Object value, String pattern)}`	使用指定模式将对象解析为LocalDate
`${flwTimeUtils.parseLocalDateTime(Object value, String pattern)}`	使用指定模式将对象解析为LocalDateTime

类型转换函数

表达式	描述
`${flwTimeUtils.asInstant(Object value)}`	将值转换为UTC时区的Instant
`${flwTimeUtils.asInstant(Object value, String timeZoneId)}`	将值转换为指定时区的Instant
`${flwTimeUtils.asLocalDate(Object value)}`	将值转换为UTC时区的LocalDate
`${flwTimeUtils.asLocalDate(Object value, String timeZoneId)}`	将值转换为指定时区的LocalDate
`${flwTimeUtils.asLocalDateTime(Object value)}`	将值转换为UTC时区的LocalDateTime
`${flwTimeUtils.asLocalDateTime(Object value, String timeZoneId)}`	将值转换为指定时区的LocalDateTime
`${flwTimeUtils.asDate(Object value)}`	将值转换为UTC时区的Date

时间操作函数

表达式	描述
`${flwTimeUtils.atTime(Object value, int hours, int minutes, int seconds)}`	在UTC时区设置指定时间的小时、分钟和秒
`${flwTimeUtils.atTimeWithTimeZone(Object value, int hours, int minutes, int seconds, String timeZoneId)}`	在指定时区设置指定时间的小时、分钟和秒
`${flwTimeUtils.atTimeZone(Object value, String timeZoneId)}`	返回指定时区的Instant（仅用于显示，不要用于存储）
`${flwTimeUtils.getAvailableTimeZoneIds()}`	返回可用时区ID列表
`${flwTimeUtils.getField(Object value, String chronoFieldString)}`	获取指定ChronoField的时间片段
`${flwTimeUtils.isWeekend(Object value)}`	判断给定值是否为周末

日期时间创建函数

表达式	描述
`${flwTimeUtils.fullDateTimeInstant(int year, int month, int day, int hour, int minute, int second)}`	在UTC时区创建具有给定值的Instant
`${flwTimeUtils.fullDateTimeDate(int year, int month, int day, int hour, int minute, int second)}`	创建具有给定值的Date

时间增加函数

表达式	描述
`${flwTimeUtils.plusSeconds(Object value, long seconds)}`	添加秒数
`${flwTimeUtils.plusMinutes(Object value, long minutes)}`	添加分钟数
`${flwTimeUtils.plusHours(Object value, long hours)}`	添加小时数
`${flwTimeUtils.plusDays(Object value, long days)}`	添加天数
`${flwTimeUtils.plusWeeks(Object value, long weeks)}`	添加周数
`${flwTimeUtils.plusMonths(Object value, long months)}`	添加月数
`${flwTimeUtils.plusYears(Object value, long years)}`	添加年数
`${flwTimeUtils.plusDuration(Object value, String iso8601Duration)}`	添加ISO8601编码的持续时间

时间减少函数

表达式	描述
`${flwTimeUtils.minusSeconds(Object value, long seconds)}`	减少秒数
`${flwTimeUtils.minusMinutes(Object value, long minutes)}`	减少分钟数
`${flwTimeUtils.minusHours(Object value, long hours)}`	减少小时数
`${flwTimeUtils.minusDays(Object value, long days)}`	减少天数
`${flwTimeUtils.minusWeeks(Object value, long weeks)}`	减少周数
`${flwTimeUtils.minusMonths(Object value, long months)}`	减少月数
`${flwTimeUtils.minusYears(Object value, long years)}`	减少年数
`${flwTimeUtils.minusDuration(Object value, String iso8601Duration)}`	减少ISO8601编码的持续时间

时间比较和计算函数

表达式	描述
`${flwTimeUtils.secondsOfDuration(String iso8601Duration)}`	返回ISO持续时间字符串中的秒数
`${flwTimeUtils.isBefore(Object firstValue, Object secondValue)}`	检查第一个值是否在第二个值之前
`${flwTimeUtils.isBeforeOrEqual(Object firstValue, Object secondValue)}`	检查第一个值是否在第二个值之前或等于第二个值
`${flwTimeUtils.isAfter(Object firstValue, Object secondValue)}`	检查第一个值是否在第二个值之后
`${flwTimeUtils.isAfterOrEqual(Object firstValue, Object secondValue)}`	检查第一个值是否在第二个值之后或等于第二个值
`${flwTimeUtils.areEqual(Object firstValue, Object secondValue)}`	检查两个值是否相等
`${flwTimeUtils.isBeforeTime(Object value, String timeZoneId, int hours, int minutes, int seconds)}`	检查给定值是否在指定时区的某个时间之前
`${flwTimeUtils.isAfterTime(Object value, String timeZoneId, int hours, int minutes, int seconds)}`	检查给定值是否在指定时区的某个时间之后

时间间隔计算函数

表达式	描述
`${flwTimeUtils.getFieldFromDurationBetweenDates(Object firstValue, Object secondValue, String chronoUnitString)}`	返回两个值之间的持续时间
`${flwTimeUtils.secondsBetween(Object firstValue, Object secondValue)}`	返回两个值之间的秒数
`${flwTimeUtils.minutesBetween(Object firstValue, Object secondValue)}`	返回两个值之间的分钟数
`${flwTimeUtils.hoursBetween(Object firstValue, Object secondValue)}`	返回两个值之间的小时数
`${flwTimeUtils.daysBetween(Object firstValue, Object secondValue)}`	返回两个值之间的天数
`${flwTimeUtils.weeksBetween(Object firstValue, Object secondValue)}`	返回两个值之间的周数
`${flwTimeUtils.monthsBetween(Object firstValue, Object secondValue)}`	返回两个值之间的月数
`${flwTimeUtils.yearsBetween(Object firstValue, Object secondValue)}`	返回两个值之间的年数
`${flwTimeUtils.getTimeZoneOffset(Object value, String timeZoneId)}`	计算指定时区的特定时间点与UTC的秒数偏移量

注意：对于大多数函数，支持的值类型包括Date、Instant、LocalDate、LocalDateTime或ISO8601格式的字符串。不同类型的值会在需要时自动转换。

JSON工具函数

以下函数在BPMN和CMMN上下文中处理JSON对象时可用：

表达式	描述
`${json:object()}`	返回一个空的JSON对象
`${json:array()}`	返回一个空的JSON数组
`${json:arrayWithSize(size)}`	返回指定大小的JSON数组
`${json:addToArray(arrayNode, object)}`	将给定对象添加到给定的数组节点中

格式化工具函数

以下方法用于格式化值：

表达式	描述
`${flwFormatUtils.formatString(text, substitutes)}`	根据Java格式化器规范格式化字符串
`${flwFormatUtils.formatDate(value, dateFormat)}`	使用给定格式将值格式化为字符串。支持Date、Instant、LocalDate、LocalDateTime或ISO8601格式的字符串
`${flwFormatUtils.formatDecimal(pattern, decimal)}`	使用默认区域设置的十进制格式化器根据Java格式化器规范格式化字符串
`${flwFormatUtils.formatStringWithLocale(languageTag, text, substitutes)}`	根据Java格式化器规范格式化字符串。字符串根据提供的语言标签的区域设置格式进行格式化
`${flwFormatUtils.formatCurrencyWithLocale(currencyCode, amount, languageTag)}`	根据提供的语言标签的区域设置格式化货币金额

示例：${flwFormatUtils.formatDate(flwTimeUtils.now(), 'dd.MM.yyyy')} 将今天的日期格式化为dd.MM.yyyy格式

区域设置工具函数

表达式	描述
`${flwLocaleUtils.getLocaleForLanguageTag(languageTag)}`	返回具有给定语言标签的区域设置，例如'ch-DE'
`${flwLocaleUtils.getAvailableLocales()}`	返回可用区域设置列表
`${flwLocaleUtils.getDefaultLocale()}`	返回系统默认区域设置
`${flwLocaleUtils.getAllCountryCodes()}`	返回所有2字母ISO国家代码列表
`${flwLocaleUtils.getAllLanguageCodes()}`	返回所有ISO语言代码列表，例如"de"（不是"de-CH"）
`${flwLocaleUtils.getLanguageDisplayName(languageIsoCode, displayLanguageTag)}`	返回某种语言的单一语言名称，例如"German"或"Spanish"
`${flwLocaleUtils.getCountryDisplayName(languageTag, displayLanguageTag)}`	返回某种语言的单一国家名称，例如"Switzerland"或"Germany"
`${flwLocaleUtils.getAllLanguageDisplayNames(displayLanguageTag)}`	返回某种语言的所有语言名称列表
`${flwLocaleUtils.getAllCountryDisplayNames(displayLanguageTag)}`	返回某种语言的所有国家名称列表

数学工具函数

以下方法用于执行数学运算：

表达式	描述
`${flwMathUtils.abs(number)}`	返回数字的绝对值
`${flwMathUtils.average(numbers)}`	计算数字列表的平均值
`${flwMathUtils.ceil(number)}`	返回提供的数字的下一个更高整数
`${flwMathUtils.floor(number)}`	返回提供的数字的下一个更低整数
`${flwMathUtils.median(numbers)}`	返回数字列表的中位数
`${flwMathUtils.min(numbers)}`	返回数字列表中的最小数
`${flwMathUtils.max(numbers)}`	返回数字列表中的最大数
`${flwMathUtils.parseDouble(string)}`	将字符串转换为双精度值
`${flwMathUtils.parseInt(string)}`	将字符串转换为整数值
`${flwMathUtils.round(number)}`	将数字四舍五入为整数值
`${flwMathUtils.round(number, scale)}`	使用RoundingMode#HALF_UP将数字四舍五入到最多小数位数
`${flwMathUtils.sum(numbers)}`	计算数字列表的总和

用户函数

以下方法可用于检索用户信息：

表达式	描述
`${findUser(userId)}`	返回与传递的ID对应的用户表示
`${findGroupMemberUserIds('GROUP_A, GROUP_B')}`	v3.14.0+ 返回给定组成员的userIds的字符串集合。注意：字符串集合String应该只是暂时存储，如果要将其作为变量持久化，需要将其转换为JSON
`${findGroupMemberEmails('GROUP_A, GROUP_B')}`	v3.14.0+ 返回给定组成员的电子邮件的字符串集合。忽略没有电子邮件的用户
`${isUserInAllGroups(userId, groupKeys)}`	如果给定的userId在具有给定键的提供组中，则返回true
`${isUserInAnyGroup(userId, groupKeys)}`	如果给定的userId在具有给定键的提供组中的任何一个中，则返回true
`${isUserInNoGroup(userId, groupKeys)}`	如果给定的userId不在具有给定键的提供组中的任何一个中，则返回true
`${userInfo:findUserInfo(property, findUser(authenticatedUserId))}`	返回当前用户的给定用户信息属性
`${userInfo:findBooleanUserInfo(property, findUser(authenticatedUserId))}`	返回当前用户的给定布尔用户信息属性

任务服务

任务服务可以在表达式中用于以编程方式与任务交互：

表达式	描述
`${taskService.claim(taskId, userId)}`	由具有提供的用户ID的用户认领给定ID的任务
`${taskService.unclaim(taskId)}`	取消认领已认领的任务
`${taskService.complete(taskId, userId, variables)}`	完成给定的任务。userId和variables（String到Objects的Map）是可选的
`${taskService.setDueDate(taskId, userId)}`	为任务设置截止日期
`${taskService.setPriority(taskId, userId)}`	为任务设置优先级
`${taskService.setAssignee(taskId, userId)}`	将给定的userId设置为任务的受理人
`${taskService.setOwner(taskId, userId)}`	将给定的userId设置为任务的所有者
`${taskService.addCandidateUser(taskId, userId)}`	将给定的userId添加为任务的候选用户
`${taskService.addCandidateGroup(taskId, userId)}`	将给定的groupId添加为任务的候选组
`${taskService.addUserIdentityLink(taskId, userId, identityLink)}`	向给定任务添加用户身份链接
`${taskService.addGroupIdentityLink(taskId, groupId, identityLink)}`	向给定任务添加组身份链接

序列模型

在使用序列模型时，经常需要在BPMN或CMMN实例的活动名称中生成这些数字。以下函数可用于此目的：

表达式	描述
`${seq:nextNumber(<parameter>, sequenceDefinitionKey)}`	返回序列的下一个数字。参数应该是具有对当前变量访问权限的运行时对象，如流程实例、案例实例、执行、任务、计划项实例等。sequenceDefinitionKey应与模型中设置的键匹配
`${seq:next(<parameter>, sequenceDefinitionKey)}`	与前一个类似，但也考虑了在模型中设置的格式配置设置

配置服务

配置服务允许访问配置属性（例如在application.properties文件或类似文件中设置的属性）。在表达式中，此服务很有用，因为它允许根据环境特定属性（例如DEV、TEST、PROD环境）更改行为。

表达式	描述
`${propertyConfigurationService.getProperty(key, defaultValue)}`	返回配置属性的字符串值
`${propertyConfigurationService.getBooleanProperty(key, defaultValue)}`	返回配置属性的布尔值
`${propertyConfigurationService.getIntegerProperty(key, defaultValue)}`	返回配置属性的整数值

认证令牌

这个高级表达式在使用外部服务和OAuth时很有用。显然，在表达式中硬编码凭据是不可取的。此表达式将帮助解决这个问题：

${flwAuthTokenUtils.getAccessToken('externalServiceId')} - 注意：当给定的externalServiceId有可用的Spring Security OAuth2客户端配置时，解析该外部服务ID的访问令牌。

集合工具

以下选项用于处理集合或ContentItem列表：

表达式	描述
`${flwCollectionUtils.emptyNode()}`	创建一个空的JSON对象节点
`${flwCollectionUtils.emptyList()}`	创建一个空的Java List。结果不应直接存储为非瞬态变量
`${flwCollectionUtils.emptyMap()}`	创建一个空的Java Map。结果不应直接存储为非瞬态变量
`${flwCollectionUtils.distinct(list)}`	从Java列表中删除重复元素。结果只应为ContentItems存储为非瞬态变量
`${flwCollectionUtils.listWithElements(itemOne, itemTwo, ...)}`	创建包含多个元素的Java列表。结果只应为ContentItem存储为非瞬态变量
`${flwCollectionUtils.mergeCollections(collection1, collection2, ...)}`	将多个Java集合合并为单个列表。结果只应为ContentItem存储为非瞬态变量

注意：当使用Java的List或Map时，它们将作为可序列化对象存储在Flowable数据库中。这意味着它们将存储在字节数组表中，对于大量数据可能会变得效率低下。ContentItem列表是唯一的例外。

表达式自定义

使用场景

让我们考虑一个实际的例子：假设有一个依赖于公司部门的流程实例。用户任务的分配取决于流程实例在哪个部门执行。表达式是确定受理人的自然方式。

假设有一个作为流程实例变量的部门引用。给定部门ID后，可以用它来查找部门成员，并使用该信息来确定给定流程的受理人。

使用Bean实现

扩展表达式功能最直接的方式是暴露一个带有方法的Spring Bean。默认情况下，表达式可以包含Spring Bean引用。

在Spring配置中的Bean定义：

@Bean
public DepartmentResolver departmentResolver() {
    return new DepartmentResolver();
}

这是一个简单的解析器示例：

public class DepartmentResolver {
    public String getAssignee(ExecutionEntity execution) {
        String departmentId = execution.getVariable("departmentId", String.class);
        return departmentId + ".assignee";
    }
}

最后一步是在流程定义中使用这个Bean：

<process id="oneTaskProcess">
  <startEvent id="start"/>
  <sequenceFlow id="flow1" sourceRef="start" targetRef="theTask"/>
  <userTask id="theTask" name="My Task" flowable:assignee="${departmentResolver.getAssignee(execution)}"/>
  <sequenceFlow id="flow2" sourceRef="theTask" targetRef="theEnd" />
  <endEvent id="theEnd"/>
</process>

下面的JUnit测试验证了用户任务受理人是否来自DepartmentResolver：

@Test
@Deployment(resources = "AssigneeExpressionBeanTest.oneTaskProcessWithBeanAssignment.bpmn20.xml")
public void springBeanAssignUserTask() {
    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess", 
        Collections.singletonMap("departmentId", "testDepartmentId"));
    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
    assertThat(task.getAssignee()).isEqualTo("testDepartmentId.assignee");
}

对于CMMN示例，请参考SpringCustomBeanTest及其相关文件和资源。

使用表达式解析器实现

使用表达式Bean（如${departmentResolver.getAssignee(execution)}）非常容易，但它们不是一等公民表达式。它们需要执行方法调用并将execution作为参数传入方法。为了避免这一步，我们可以使用简单的受理人表达式格式${departmentAssignee}。这需要扩展引擎表达式管理器中的表达式解析器（ELResolvers）。

@Bean
public SpringProcessEngineConfiguration processEngineConfiguration(ApplicationContext applicationContext, 
    DataSource dataSource, PlatformTransactionManager transactionManager) {
    SpringProcessEngineConfiguration configuration = new SpringProcessEngineConfiguration();
    configuration.setDataSource(dataSource);
    configuration.setTransactionManager(transactionManager);
    configuration.setDatabaseSchemaUpdate("true");
    configuration.setExpressionManager(new CustomExpressionManager(applicationContext, Collections.emptyMap()));
    return configuration;
}

CustomExpressionManager通过新的部门特定ELResolver扩展了可用的ELResolvers集合：

public static class CustomExpressionManager extends SpringExpressionManager {
    @Override
    protected ELResolver createElResolver(VariableContainer variableContainer) {
        CompositeELResolver compositeElResolver = new CompositeELResolver();
        compositeElResolver.add(createVariableElResolver(variableContainer));
        compositeElResolver.add(createSpringElResolver());
        compositeElResolver.add(new ArrayELResolver());
        compositeElResolver.add(new ListELResolver());
        compositeElResolver.add(new MapELResolver());
        compositeElResolver.add(new JsonNodeELResolver());
        compositeElResolver.add(new BeanELResolver());
        compositeElResolver.add(new DepartmentELResolver(variableContainer));
        compositeElResolver.add(new CouldNotResolvePropertyELResolver());
        return compositeElResolver;
    }
}

DepartmentELResolver解析"departmentAssignee"关键字并返回其关联的部门特定值：

public static class DepartmentELResolver extends VariableContainerELResolver {
    public DepartmentELResolver(VariableContainer variableContainer) {
        super(variableContainer);
    }

    @Override
    public Object getValue(ELContext context, Object base, Object property) {
        if (base == null && "departmentAssignee".equals(property) && variableContainer instanceof ExecutionEntity) {
            Object departmentId = variableContainer.getVariable("departmentId");
            if (departmentId == null) {
                throw new RuntimeException("departmentId was not found in execution " + 
                    ((ExecutionEntity) variableContainer).getId());
            }
            context.setPropertyResolved(true);
            return getDepartmentAssignee(departmentId);
        }
        return null;
    }

    protected String getDepartmentAssignee(Object departmentId) {
        return departmentId + ".assignee";
    }

    @Override
    public boolean isReadOnly(ELContext context, Object base, Object property) {
        return true;
    }
}

现在流程模型用户任务规范变为：

<userTask id="theTask" name="My Task" flowable:assignee="${departmentAssignee}"/>

设置值

到目前为止，所有表达式示例都只是返回值。但是，表达式也可以用来改变值。例如，给定这个人工任务案例模型：

<case id="oneHumanTaskCase">
    <casePlanModel id="myPlanModel" name="My CasePlanModel">
        <planItem id="planItem1" name="The Task" definitionRef="theTask" />
        <humanTask id="theTask" name="The Task" isBlocking="true" flowable:assignee="johnDoe"/>
    </casePlanModel>
</case>

可以在不使用任何表达式的情况下更新案例实例变量，如下面的JUnit测试所示：

@Test
@CmmnDeployment(resources = "org/flowable/cmmn/test/task/CmmnTaskServiceTest.testOneHumanTaskCase.cmmn")
public void testOneHumanTaskCaseScopeExpression() {
    // 创建带有一个人工任务的案例实例
    CaseInstance caseInstance = cmmnRuntimeService.createCaseInstanceBuilder()
                    .caseDefinitionKey("oneHumanTaskCase")
                    // 创建变量并设置其值。默认表达式管理器允许变量更新
                    .variable("variableToUpdate", "VariableValue")
                    .start();
    Task task = cmmnTaskService.createTaskQuery().caseInstanceId(caseInstance.getId()).singleResult();

    // 完成任务并更新案例实例中的变量
    cmmnTaskService.complete(task.getId(), Collections.singletonMap(
            "${variableToUpdate}", "updatedVariableValue"
        )
    );
    HistoricCaseInstance historicCaseInstance = cmmnHistoryService
                    .createHistoricCaseInstanceQuery()
                    .caseInstanceId(caseInstance.getId())
                    .includeCaseVariables().singleResult();
    assertThat(historicCaseInstance.getCaseVariables().get("variableToUpdate"), is("updatedVariableValue"));
}

代码将变量variableToUpdate添加到案例中，值为"VariableValue"。在任务完成时，VariableContainerELResolver解析表达式${variableToUpdate}并为变量设置新值"updatedVariableValue"。assertThat()验证这确实发生了。

更多设置值的表达式示例可以在CmmnTaskServiceTest中找到。

Flowable中的四种核心流程控制模式：会签、或签、分支与并行

March 27, 2025

在业务流程管理(BPM)领域，合理选择和应用流程模式对于满足复杂业务需求至关重要。Flowable作为一个灵活的BPM引擎，支持多种流程控制模式的实现。本文将重点介绍四种常用的流程模式：会签流程、或签流程、分支流程和并行流程，并结合Flowable展示其具体实现方法。

流程模式基础概念

在深入了解各种流程模式之前，先简单介绍一下BPMN基本概念：

流程定义(Process Definition)：业务流程的静态模型
流程实例(Process Instance)：流程定义的运行时执行实例
任务(Task)：流程中的工作单元，通常需要人工处理
网关(Gateway)：控制流程执行路径的节点
流程变量(Process Variable)：存储和传递流程数据的容器

会签流程模式

会签流程（也称为"全部审批"模式）要求多个参与者必须全部同意才能继续流程。这常用于重要决策审批、合同审核等场景。

会签流程模式

会签流程的特点

多人必须全部完成任务才能继续流程
可设置驳回机制，任一人拒绝即可终止流程
可配置顺序执行或并行执行

Flowable中的会签实现

在Flowable中，会签流程主要通过多实例用户任务(Multi-Instance User Task)实现，配合条件表达式控制流程走向。

<userTask id="approvalTask" name="部门经理审批" flowable:assignee="${assignee}">
  <multiInstanceLoopCharacteristics isSequential="false">
    <loopCardinality>${nrOfApprovers}</loopCardinality>
    <completionCondition>${nrOfCompletedInstances == nrOfInstances}</completionCondition>
  </multiInstanceLoopCharacteristics>
</userTask>

上面的示例中：

isSequential="false" 表示所有审批任务会并行创建
completionCondition 设置为只有当所有实例都完成时才继续流程

会签流程的核心API使用

// 设置审批人列表
List<String> approverList = Arrays.asList("manager1", "manager2", "manager3");
Map<String, Object> variables = new HashMap<>();
variables.put("approverList", approverList);
variables.put("nrOfApprovers", approverList.size());

// 启动会签流程
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(
    "contractApprovalProcess", 
    "CONTRACT-2025-001", 
    variables
);

// 查询当前待办任务
List<Task> tasks = taskService.createTaskQuery()
    .processInstanceId(processInstance.getId())
    .taskCandidateOrAssigned("manager1")
    .list();

会签流程的高级应用

在实际应用中，会签流程常常需要处理一些特殊情况：

动态会签人：根据业务数据动态确定审批人

// 动态构建审批人列表
List<String> approvers = userService.getDepartmentManagers(departmentId);
execution.setVariable("approverList", approvers);
execution.setVariable("nrOfApprovers", approvers.size());

会签结果汇总：收集所有审批人的意见

<multiInstanceLoopCharacteristics isSequential="false">
  <loopCardinality>${nrOfApprovers}</loopCardinality>
  <inputDataItem name="approver" />
  <inputDataItem name="comments" />
  <completionCondition>${nrOfCompletedInstances == nrOfInstances}</completionCondition>
</multiInstanceLoopCharacteristics>

或签流程模式

或签流程（也称为"任一审批"模式）只需要多个参与者中的任意一个同意即可继续流程。这适用于一般性审批、资源分配等场景。

或签流程模式

或签流程的特点

任意一人完成任务即可继续流程
适合平级审批或并行审批场景
提高审批效率，避免流程阻塞

Flowable中的或签实现

或签流程在Flowable中同样使用多实例用户任务实现，但通过完成条件(completionCondition)控制只需一人完成即可。

<userTask id="approvalTask" name="部门审批" flowable:assignee="${assignee}">
  <multiInstanceLoopCharacteristics isSequential="false">
    <loopCardinality>${nrOfApprovers}</loopCardinality>
    <completionCondition>${nrOfCompletedInstances >= 1}</completionCondition>
  </multiInstanceLoopCharacteristics>
</userTask>

上面的示例中：

completionCondition 设置为只要有一个实例完成即可继续流程

候选人方式实现或签

除了多实例方式外，也可以使用候选人(Candidate)机制实现或签：

<userTask id="approvalTask" name="部门审批">
  <potentialOwner>
    <resourceAssignmentExpression>
      <formalExpression>user1,user2,user3</formalExpression>
    </resourceAssignmentExpression>
  </potentialOwner>
</userTask>

配合Java代码：

// 设置候选人
List<String> candidateUsers = Arrays.asList("user1", "user2", "user3");
for (String user : candidateUsers) {
    taskService.addCandidateUser(task.getId(), user);
}

// 认领任务
taskService.claim(taskId, "user1");

// 完成任务
taskService.complete(taskId);

分支流程模式

分支流程（也称为"条件路由"模式）根据业务条件选择不同的执行路径。这是BPM中最常用的控制流模式之一。

分支流程模式

分支流程的特点

基于条件表达式动态选择流程路径
可实现复杂的业务决策逻辑
支持默认路径设置

排他网关实现分支

在Flowable中，分支流程主要通过排他网关(Exclusive Gateway)实现：

<exclusiveGateway id="approvalDecision" name="审批决策" />

<sequenceFlow id="flow1" sourceRef="approvalDecision" targetRef="approvedPath">
  <conditionExpression xsi:type="tFormalExpression">${approved == true}</conditionExpression>
</sequenceFlow>

<sequenceFlow id="flow2" sourceRef="approvalDecision" targetRef="rejectedPath">
  <conditionExpression xsi:type="tFormalExpression">${approved == false}</conditionExpression>
</sequenceFlow>

包容网关实现复杂分支

当需要同时选择多个满足条件的分支时，可以使用包容网关(Inclusive Gateway)：

<inclusiveGateway id="riskAssessment" name="风险评估" />

<sequenceFlow id="flow1" sourceRef="riskAssessment" targetRef="creditCheck">
  <conditionExpression xsi:type="tFormalExpression">${amount > 10000}</conditionExpression>
</sequenceFlow>

<sequenceFlow id="flow2" sourceRef="riskAssessment" targetRef="identityVerification">
  <conditionExpression xsi:type="tFormalExpression">${customerType == 'new'}</conditionExpression>
</sequenceFlow>

<sequenceFlow id="flow3" sourceRef="riskAssessment" targetRef="basicProcessing">
  <conditionExpression xsi:type="tFormalExpression">${amount <= 10000 && customerType != 'new'}</conditionExpression>
</sequenceFlow>

动态分支控制

在实际应用中，我们可以通过Java代码动态设置流程变量，进而控制分支流向：

// 设置决策变量
Map<String, Object> variables = new HashMap<>();
variables.put("approved", riskScore > 70);
variables.put("amount", loanRequest.getAmount());
variables.put("customerType", customer.getType());

// 完成任务，触发网关决策
taskService.complete(taskId, variables);

并行流程模式

并行流程（也称为"同步执行"模式）允许多个活动同时执行，提高流程效率。适用于相互独立的任务处理场景。

并行流程模式

并行流程的特点

多个任务可同时执行，互不干扰
可设置同步点，等待所有分支完成
提高流程执行效率，缩短总处理时间

并行网关实现

在Flowable中，并行流程通过并行网关(Parallel Gateway)实现：

<!-- 分叉：开始并行执行 -->
<parallelGateway id="forkProcess" />
<sequenceFlow id="flow1" sourceRef="startEvent" targetRef="forkProcess" />

<sequenceFlow id="flow2" sourceRef="forkProcess" targetRef="documentReview" />
<sequenceFlow id="flow3" sourceRef="forkProcess" targetRef="technicalReview" />
<sequenceFlow id="flow4" sourceRef="forkProcess" targetRef="financialReview" />

<!-- 各并行任务 -->
<userTask id="documentReview" name="文档审查" />
<userTask id="technicalReview" name="技术评估" />
<userTask id="financialReview" name="财务审核" />

<!-- 汇合：等待所有并行分支完成 -->
<sequenceFlow id="flow5" sourceRef="documentReview" targetRef="joinProcess" />
<sequenceFlow id="flow6" sourceRef="technicalReview" targetRef="joinProcess" />
<sequenceFlow id="flow7" sourceRef="financialReview" targetRef="joinProcess" />
<parallelGateway id="joinProcess" />

<sequenceFlow id="flow8" sourceRef="joinProcess" targetRef="finalApproval" />

并行流与会签结合

并行流和会签可以结合使用，实现更复杂的业务场景：

<parallelGateway id="forkProcess" />

<sequenceFlow id="flow1" sourceRef="forkProcess" targetRef="hrApproval" />
<sequenceFlow id="flow2" sourceRef="forkProcess" targetRef="financeApproval" />

<!-- HR部门会签 -->
<userTask id="hrApproval" name="HR部门审批" flowable:assignee="${hrApprover}">
  <multiInstanceLoopCharacteristics isSequential="false">
    <loopCardinality>${hrApproverCount}</loopCardinality>
    <completionCondition>${nrOfCompletedInstances == nrOfInstances}</completionCondition>
  </multiInstanceLoopCharacteristics>
</userTask>

<!-- 财务部门会签 -->
<userTask id="financeApproval" name="财务部门审批" flowable:assignee="${financeApprover}">
  <multiInstanceLoopCharacteristics isSequential="false">
    <loopCardinality>${financeApproverCount}</loopCardinality>
    <completionCondition>${nrOfCompletedInstances == nrOfInstances}</completionCondition>
  </multiInstanceLoopCharacteristics>
</userTask>

<parallelGateway id="joinProcess" />

实际应用场景：采购审批流程

下面是一个结合了上述四种流程模式的采购审批流程示例：

采购审批流程综合示例

<process id="purchaseApprovalProcess" name="采购审批流程">
  <startEvent id="startEvent" />
  <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="initiatePurchase" />
  
  <!-- 初始化采购申请 -->
  <userTask id="initiatePurchase" name="填写采购申请" />
  <sequenceFlow id="flow2" sourceRef="initiatePurchase" targetRef="amountGateway" />
  
  <!-- 分支流：根据金额决定审批路径 -->
  <exclusiveGateway id="amountGateway" />
  <sequenceFlow id="flow3" sourceRef="amountGateway" targetRef="simpleApproval">
    <conditionExpression xsi:type="tFormalExpression">${amount <= 10000}</conditionExpression>
  </sequenceFlow>
  <sequenceFlow id="flow4" sourceRef="amountGateway" targetRef="complexApprovalFork">
    <conditionExpression xsi:type="tFormalExpression">${amount > 10000}</conditionExpression>
  </sequenceFlow>
  
  <!-- 或签流程：小额采购任一经理审批 -->
  <userTask id="simpleApproval" name="经理审批">
    <potentialOwner>
      <resourceAssignmentExpression>
        <formalExpression>manager1,manager2,manager3</formalExpression>
      </resourceAssignmentExpression>
    </potentialOwner>
  </userTask>
  <sequenceFlow id="flow5" sourceRef="simpleApproval" targetRef="endEvent" />
  
  <!-- 并行流程：大额采购需多部门审核 -->
  <parallelGateway id="complexApprovalFork" />
  <sequenceFlow id="flow6" sourceRef="complexApprovalFork" targetRef="departmentApproval" />
  <sequenceFlow id="flow7" sourceRef="complexApprovalFork" targetRef="financeCheck" />
  
  <!-- 会签流程：部门经理全部审批 -->
  <userTask id="departmentApproval" name="部门经理审批" flowable:assignee="${assignee}">
    <multiInstanceLoopCharacteristics isSequential="false">
      <loopCardinality>${nrOfManagers}</loopCardinality>
      <completionCondition>${nrOfCompletedInstances == nrOfInstances}</completionCondition>
    </multiInstanceLoopCharacteristics>
  </userTask>
  
  <!-- 财务审核 -->
  <userTask id="financeCheck" name="财务审核" />
  
  <!-- 汇合所有审批 -->
  <sequenceFlow id="flow8" sourceRef="departmentApproval" targetRef="complexApprovalJoin" />
  <sequenceFlow id="flow9" sourceRef="financeCheck" targetRef="complexApprovalJoin" />
  <parallelGateway id="complexApprovalJoin" />
  
  <!-- 最终CEO审批 -->
  <sequenceFlow id="flow10" sourceRef="complexApprovalJoin" targetRef="ceoApproval" />
  <userTask id="ceoApproval" name="CEO审批" />
  <sequenceFlow id="flow11" sourceRef="ceoApproval" targetRef="endEvent" />
  
  <endEvent id="endEvent" />
</process>

使用Java代码启动上述流程：

// 设置流程变量
Map<String, Object> variables = new HashMap<>();
variables.put("amount", 15000);
variables.put("nrOfManagers", 3);
variables.put("assignee1", "manager1");
variables.put("assignee2", "manager2");
variables.put("assignee3", "manager3");

// 启动流程实例
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(
    "purchaseApprovalProcess", 
    "PUR-2025-001", 
    variables
);

流程模式设计最佳实践

在使用Flowable设计和实现上述流程模式时，以下是一些最佳实践建议：

明确业务需求：在选择流程模式前，明确业务需要"会签"还是"或签"，是否有分支条件等。
简化流程设计：流程设计应尽量简洁，避免过度复杂的路由逻辑。
合理使用表达式：流程条件表达式应清晰、简单，易于维护。
考虑异常处理：设计流程时，需考虑异常情况，如审批人不在岗、驳回处理等。
预留扩展点：流程设计应考虑未来可能的变更，预留扩展点。

使用监听器记录关键事件：

public class ApprovalTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        if (TaskListener.EVENTNAME_COMPLETE.equals(delegateTask.getEventName())) {
            // 记录任务完成事件
            boolean approved = (boolean) delegateTask.getVariable("approved");
            String comment = (String) delegateTask.getVariable("comment");
            LoggingService.logApproval(delegateTask.getId(), approved, comment);
        }
    }
}

总结

BPM流程设计中的会签流程、或签流程、分支流程和并行流程是解决复杂业务场景的基础模式。Flowable通过其灵活的BPMN实现和丰富的API，提供了这些模式的完整支持。通过合理组合这些模式，可以构建出满足各种业务需求的复杂工作流，提高业务流程的自动化水平和执行效率。

在实际应用中，应根据具体业务场景选择适当的流程模式，并遵循流程设计的最佳实践，确保流程定义清晰、高效且可维护。Flowable作为一个成熟的BPM引擎，为这些流程模式的落地实施提供了强大的技术支持。

Flowable 案例迁移

March 17, 2025

在业务流程管理系统中，案例定义（Case Definition）的版本更新是一个常见的需求。Flowable提供了强大的案例迁移(Case Migration)功能，允许您将案例实例从一个定义版本迁移到另一个版本。本文将详细介绍这个功能的使用方法。

迁移API概览

Flowable提供了多个层级的迁移API：

单个案例实例迁移
从特定案例定义迁移所有案例实例
批量迁移特定案例定义的所有案例实例

除了上述API外，Flowable还支持历史案例实例的迁移，这对于使用案例重新激活功能特别有用。需要注意的是，在迁移历史案例实例时，不能指定迁移映射和表达式，因为案例仍然处于关闭状态。

迁移文档简单示例

迁移过程的核心是迁移文档（Migration Document），这是一个JSON格式的配置文件。让我们通过一个具体的例子来说明：

假设我们要将以下testMigrationCase案例（包含两个人工任务，通过sentry连接）：

CMMN案例迁移前

迁移到新版本（包含一个人工任务和一个服务任务，通过sentry连接）：

CMMN案例迁移后

迁移文档的JSON结构如下：

{
  "toCaseDefinitionKey": "testMigrationCase",
  "toCaseDefinitionVersion": 2,
  "terminatePlanItemDefinitions": [
    {
      "planItemDefinitionId": "humanTask2"
    }
  ],
  "moveToAvailablePlanItemDefinitions": [
    {
      "planItemDefinitionId": "serviceTask1"
    }
  ]
}

迁移文档的主要配置项

1. 目标定义配置

toCaseDefinitionId：目标案例定义的唯一ID
toCaseDefinitionKey：目标案例定义的键值
toCaseDefinitionVersion：目标案例定义的版本号
toCaseDefinitionTenantId：多租户环境下的租户ID

2. 状态变更配置

迁移文档支持多种状态变更操作：

激活计划项（Activate Plan Items）
- 用于激活新的计划项
- 可设置新负责人和本地变量
移动到可用状态（Move to Available）
- 适用于由sentry控制的新计划项
- 可设置本地变量
终止计划项（Terminate Plan Items）
- 用于移除或停止计划项
- 仅对活动项生效
重复等待状态管理
- waitingForRepetitionPlanItemDefinitions：添加重复等待
- removeWaitingForRepetitionPlanItemDefinitions：移除重复等待

3. 高级配置

预升级和后升级表达式：用于执行迁移前后的自定义逻辑
案例实例变量：设置案例级别的变量
计划项ID变更：处理计划项ID发生变化的情况

CMMN迁移服务接口

Flowable提供了CmmnMigrationService接口来管理案例实例的迁移。以下是主要的接口方法：

迁移构建器创建方法

// 创建案例实例迁移构建器
CaseInstanceMigrationBuilder createCaseInstanceMigrationBuilder();

// 从迁移文档创建案例实例迁移构建器
CaseInstanceMigrationBuilder createCaseInstanceMigrationBuilderFromCaseInstanceMigrationDocument(CaseInstanceMigrationDocument document);

// 创建历史案例实例迁移构建器
HistoricCaseInstanceMigrationBuilder createHistoricCaseInstanceMigrationBuilder();

// 从迁移文档创建历史案例实例迁移构建器
HistoricCaseInstanceMigrationBuilder createHistoricCaseInstanceMigrationBuilderFromHistoricCaseInstanceMigrationDocument(HistoricCaseInstanceMigrationDocument document);

迁移验证方法

// 验证单个案例实例的迁移
CaseInstanceMigrationValidationResult validateMigrationForCaseInstance(String caseInstanceId, CaseInstanceMigrationDocument document);

// 验证案例定义下所有案例实例的迁移
CaseInstanceMigrationValidationResult validateMigrationForCaseInstancesOfCaseDefinition(String caseDefinitionId, CaseInstanceMigrationDocument document);

// 验证指定版本案例定义下所有案例实例的迁移
CaseInstanceMigrationValidationResult validateMigrationForCaseInstancesOfCaseDefinition(String caseDefinitionKey, int caseDefinitionVersion, String caseDefinitionTenantId, CaseInstanceMigrationDocument document);

迁移执行方法

// 迁移单个案例实例
void migrateCaseInstance(String caseInstanceId, CaseInstanceMigrationDocument document);

// 迁移单个历史案例实例
void migrateHistoricCaseInstance(String caseInstanceId, HistoricCaseInstanceMigrationDocument document);

// 迁移案例定义下的所有案例实例
void migrateCaseInstancesOfCaseDefinition(String caseDefinitionId, CaseInstanceMigrationDocument document);

// 迁移案例定义下的所有历史案例实例
void migrateHistoricCaseInstancesOfCaseDefinition(String caseDefinitionId, HistoricCaseInstanceMigrationDocument document);

// 迁移指定版本案例定义下的所有案例实例
void migrateCaseInstancesOfCaseDefinition(String caseDefinitionKey, int caseDefinitionVersion, String caseDefinitionTenantId, CaseInstanceMigrationDocument document);

// 迁移指定版本案例定义下的所有历史案例实例
void migrateHistoricCaseInstancesOfCaseDefinition(String caseDefinitionKey, int caseDefinitionVersion, String caseDefinitionTenantId, HistoricCaseInstanceMigrationDocument document);

批量迁移方法

// 批量迁移案例定义下的所有案例实例
Batch batchMigrateCaseInstancesOfCaseDefinition(String caseDefinitionId, CaseInstanceMigrationDocument document);

// 批量迁移案例定义下的所有历史案例实例
Batch batchMigrateHistoricCaseInstancesOfCaseDefinition(String caseDefinitionId, HistoricCaseInstanceMigrationDocument document);

// 批量迁移指定版本案例定义下的所有案例实例
Batch batchMigrateCaseInstancesOfCaseDefinition(String caseDefinitionKey, int caseDefinitionVersion, String caseDefinitionTenantId, CaseInstanceMigrationDocument document);

// 批量迁移指定版本案例定义下的所有历史案例实例
Batch batchMigrateHistoricCaseInstancesOfCaseDefinition(String caseDefinitionKey, int caseDefinitionVersion, String caseDefinitionTenantId, HistoricCaseInstanceMigrationDocument document);

// 获取批量迁移的结果
CaseInstanceBatchMigrationResult getResultsOfBatchCaseInstanceMigration(String migrationBatchId);

实际应用场景

假设您有一个"项目案例"的CMMN模型，当前版本包含以下阶段和计划项：

项目准备阶段
- 项目章程创建（人工任务）
- 项目团队组建（人工任务）
- 项目计划制定（人工任务）
项目执行阶段
- 需求分析（人工任务）
- 设计开发（人工任务）
- 测试验证（人工任务）

现在需要升级到新版本，增加以下改进：

在项目准备阶段增加风险评估计划项
将项目计划制定改为自动服务任务
在项目执行阶段增加代码审查计划项

迁移文档示例：

{
  "toCaseDefinitionKey": "projectCase",
  "toCaseDefinitionVersion": 2,
  "terminatePlanItemDefinitions": [
    {
      "planItemDefinitionId": "projectPlanTask"
    }
  ],
  "moveToAvailablePlanItemDefinitions": [
    {
      "planItemDefinitionId": "riskAssessmentPlan",
      "localVariables": {
        "riskAssessmentType": "comprehensive"
      }
    },
    {
      "planItemDefinitionId": "codeReviewTask"
    }
  ],
  "activatePlanItemDefinitions": [
    {
      "planItemDefinitionId": "autoProjectPlan",
      "localVariables": {
        "planTemplate": "standard"
      }
    }
  ]
}

使用建议

在进行迁移前，建议先备份相关数据
仔细规划迁移策略，确保所有必要的状态转换都被正确处理
使用条件表达式（condition）来控制迁移行为
在测试环境中先进行迁移测试
记录迁移过程中的关键操作和结果

总结

Flowable的Case Migration功能提供了灵活且强大的案例版本迁移能力。通过合理使用迁移文档中的各种配置项，您可以安全地将案例实例从一个版本迁移到另一个版本，同时保持业务流程的连续性和完整性。

Flowable 自动部署模型

March 15, 2025

Flowable 提供了从类路径上可用的模型和配置文件进行自动部署的选项。这种功能极大地简化了开发和部署流程，使开发者能够专注于业务逻辑而非部署细节。 Flowable 自动部署概述

应用自动部署

使用自动部署功能最简单的方式是从类路径将应用部署到 Flowable 平台。通过这种方式，应用中包含的所有模型都将被部署并与同一父部署相连接。以下文件夹默认支持：

apps/
com/flowable/app/default/**/
com/flowable/app/custom/**/
com/flowable/app/example/**/

在这些文件夹中，只有后缀为 .bar 和 .zip 的应用文件会被考虑。可以通过在应用属性中设置 flowable.app.resource-location 值来更改应用文件夹。

主要模型自动部署

流程模型

默认文件夹：processes/
支持文件：.bpmn 和 .bpmn20.xml
配置属性：flowable.process-definition-location-prefix

案例模型

默认文件夹：cases/
支持文件：.cmmn 和 .cmmn.xml
配置属性：flowable.cmmn.resource-location

决策模型

默认文件夹：dmn/
支持文件：.dmn 和 .dmn.xml
配置属性：flowable.dmn.resource-location

表单模型

默认文件夹：forms/
支持文件：.form 和 .page
配置属性：flowable.form.resource-location

Flowable Work 默认模型

Flowable Work 应用包含多个默认模型，这些模型在应用启动时自动部署。主要包括：

默认动作模型

提供了一系列标准动作，如：

取消流程实例
完成用户任务
开始进行任务
取消案例实例
用户管理相关动作

默认安全策略

包含两个重要的安全策略模型：

常规安全策略（basic-security-policy）：用于所有权限检查
严格安全策略：提供更严格的权限控制

默认内容模型

提供三种基本内容类型：

合同
通用
策略

总结

Flowable 的自动部署功能为开发者提供了一种简单而强大的方式，从类路径直接部署各种模型和配置文件到 Flowable 平台。通过合理利用这些功能，可以显著提高开发效率和部署可靠性。

无论是使用默认的部署路径，还是通过配置属性自定义部署选项，Flowable 都提供了灵活的方式来满足各种部署需求。

Flowable-UI 入门指南：从零开始的 BPM 之旅

March 14, 2025

什么是Flowable-UI?

Flowable-UI 是 Flowable BPM 平台的用户界面组件，作为一个轻量级的开源工具，它提供了直观的图形化界面，让用户能够便捷地进行业务流程管理。无需编写代码，用户就能快速验证和实现业务流程逻辑，这使其成为流程原型开发的理想选择。

核心模块

Flowable-UI 整合了四个核心模块，每个模块都专注于特定的功能领域： Flowable-UI 模块架构

Flowable Modeler（流程建模器）
- 基于 BPMN 2.0 标准的流程设计工具
- 支持拖拽式的流程图设计
- 可视化的流程定义和编辑功能

Flowable Modeler 界面

Flowable Task（任务管理）
- 流程实例的启动和管理
- 用户任务的处理和分配
- 实时流程状态跟踪

Task 模块界面

Flowable Admin（管理控制台）
- 流程引擎的监控和管理
- 提供数据查询功能
- 流程调试工具

Admin 控制台

Flowable IDM（身份管理）
- 用户和角色管理
- 权限控制
- 支持单点登录
- 多应用协同管理

IDM 管理界面

主要功能

通过 Flowable-UI，用户可以实现以下核心功能：

直观地创建和编辑业务流程
支持多种建模标准：
- BPMN（业务流程建模与符号）
- CMMN（案例管理模型与符号）
- DMN（决策模型与符号）
覆盖从流程设计到执行的完整生命周期管理

快速部署

Flowable-UI 提供了 Docker 镜像，可以通过以下简单步骤快速部署。

1. 使用默认 H2 数据库部署

最简单的部署方式是使用默认的 H2 内存数据库：

docker run -p 8080:8080 flowable/flowable-ui

2. 使用 MySQL 数据库部署

在生产环境中，建议使用 MySQL 等关系型数据库来持久化数据。以下是使用 MySQL 的部署步骤，完整的部署配置代码可以在 GitHub 仓库中找到。

创建配置文件 flowable-default.properties，并修改下面的配置：

# 数据库配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://mysql:3306/flowable?characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456

下载 MySQL 驱动：
- 从 Maven 中央仓库下载 MySQL 驱动：mysql-connector-java-8.0.27.jar
创建 docker-compose.yml 文件：

version: '3'

services:
  flowable-ui:
    image: flowable/flowable-ui
    container_name: flowable-ui
    restart: always
    ports:
      - 8080:8080
    volumes:
      - ./flowable-default.properties:/app/WEB-INF/classes/flowable-default.properties
      - ./mysql-connector-java-8.0.27.jar:/app/WEB-INF/lib/mysql-connector-java-8.0.27.jar
  mysql:
    image: mysql:5.7
    environment:
      TZ: Asia/Shanghai
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: flowable
    restart: always
    volumes:
      - ./data/mysql/data:/var/lib/mysql

启动服务：

docker-compose up -d

访问应用部署完成后，访问以下地址：

打开浏览器访问 http://localhost:8080/flowable-ui
默认登录凭据：
- 用户名：admin
- 密码：test

适用场景

Flowable-UI 特别适合以下场景：

需要快速验证业务流程逻辑的项目
希望通过可视化方式设计流程的团队
追求低代码/无代码流程开发的组织
需要统一的流程管理平台的企业

通过 Flowable-UI，企业可以显著提升业务流程的设计和管理效率，实现流程自动化的快速落地。

重要提示

自 Flowable 7.0.0 版本起，Flowable-UI 应用程序（包括 Flowable Modeler、Task、Admin 和 IDM）已从开源项目中移除。本文内容适用于 Flowable 6.x 及更早版本的历史参考。

Flowable 数据库表结构详解

March 13, 2025

在Flowable工作流引擎中，数据库表结构是整个系统的基础。本文将详细介绍Flowable中最重要的几类表结构，帮助大家更好地理解Flowable的内部工作机制。

Flowable表结构概览

1. 通用命名规则

Flowable的表名都遵循特定的命名规则，主要包括以下前缀：

ACT_RE_*：'RE'表示repository，这些表包含流程定义和流程静态资源
ACT_RU_*：'RU'表示runtime，这些表存储流程运行时的数据
ACT_HI_*：'HI'表示history，这些表存储历史数据
ACT_ID_*：'ID'表示identity，这些表存储身份信息
ACT_GE_*：'GE'表示general，这些表存储通用数据
ACT_APP_*：'APP'表示application，这些表存储应用级别的信息
ACT_CMMN_*：'CMMN'表示Case Management，这些表存储案例管理相关数据
ACT_DMN_*：'DMN'表示Decision Management，这些表存储决策管理相关数据
FLW_*：'FLW'表示Flowable特定的扩展表

2. 核心功能模块表结构

2.1 流程定义相关表（Repository）

ACT_RE_DEPLOYMENT：流程部署表
- 主要字段：
  - ID_：部署ID，主键
  - NAME_：部署名称
  - CATEGORY_：部署类别
  - DEPLOY_TIME_：部署时间
  - TENANT_ID_：租户ID，用于多租户
- 使用场景：每次部署流程定义文件时会产生记录
ACT_RE_PROCDEF：流程定义表
- 主要字段：
  - ID_：主键
  - KEY_：流程定义的标识
  - VERSION_：版本号
  - NAME_：流程定义名称
  - RESOURCE_NAME_：资源文件名称
  - DGRM_RESOURCE_NAME_：流程图资源名称
  - SUSPENSION_STATE_：暂停状态
- 使用场景：存储流程定义的元数据，支持流程定义的版本控制

2.2 运行时数据表（Runtime）

ACT_RU_EXECUTION：运行时流程执行实例表
- 主要字段：
  - ID_：执行实例ID
  - PROC_INST_ID_：流程实例ID
  - BUSINESS_KEY_：业务标识
  - PARENT_ID_：父执行流ID
  - PROC_DEF_ID_：流程定义ID
  - SUPER_EXEC_：父流程实例ID（用于子流程）
- 常用查询示例：
```
-- 查询某个业务关联的流程实例
SELECT * FROM ACT_RU_EXECUTION 
WHERE BUSINESS_KEY_ = '业务ID';

-- 查询所有活动的子流程
SELECT * FROM ACT_RU_EXECUTION 
WHERE SUPER_EXEC_ IS NOT NULL;
```
ACT_RU_TASK：运行时任务表
- 主要字段：
  - ID_：任务ID
  - NAME_：任务名称
  - ASSIGNEE_：受理人
  - CREATE_TIME_：创建时间
  - DUE_DATE_：到期时间
  - PRIORITY_：优先级
  - CATEGORY_：任务类别
- 性能优化建议：
  - 建议为ASSIGNEE_字段创建索引
  - 对于到期时间的查询，建议增加DUE_DATE_的索引
ACT_RU_VARIABLE：运行时变量表
- 主要字段：
  - ID_：变量ID
  - TYPE_：变量类型
  - NAME_：变量名称
  - EXECUTION_ID_：所属执行实例ID
  - PROC_INST_ID_：所属流程实例ID
  - TASK_ID_：所属任务ID
  - BYTEARRAY_ID_：字节数组ID（用于存储序列化的变量）
- 变量类型说明：
  - string：字符串类型
  - integer：整数类型
  - boolean：布尔类型
  - date：日期类型
  - serializable：序列化对象

2.3 历史数据表（History）

ACT_HI_PROCINST：历史流程实例表
- 主要字段：
  - ID_：流程实例ID
  - START_TIME_：开始时间
  - END_TIME_：结束时间
  - DURATION_：持续时间
  - START_USER_ID_：启动用户
  - SUPER_PROCESS_INSTANCE_ID_：父流程实例ID
- 数据清理建议：
```
-- 删除30天前的已完成流程
DELETE FROM ACT_HI_PROCINST 
WHERE END_TIME_ < DATE_SUB(NOW(), INTERVAL 30 DAY);
```
ACT_HI_TASKINST：历史任务实例表
- 主要字段：
  - ID_：任务实例ID
  - PROC_DEF_ID_：流程定义ID
  - TASK_DEF_KEY_：任务定义的ID
  - START_TIME_：开始时间
  - END_TIME_：结束时间
  - ASSIGNEE_：受理人
- 常用统计查询：
```
-- 统计用户任务处理时长
SELECT 
  ASSIGNEE_,
  AVG(TIMESTAMPDIFF(MINUTE, START_TIME_, END_TIME_)) as avg_duration
FROM ACT_HI_TASKINST
WHERE END_TIME_ IS NOT NULL
GROUP BY ASSIGNEE_;
```

2.4 身份数据表（Identity）

ACT_ID_USER：用户表
- 主要字段：
  - ID_：用户ID
  - FIRST_：名
  - LAST_：姓
  - EMAIL_：邮箱
  - PWD_：密码
- 安全建议：
  - 密码字段建议使用加密存储
  - 建议使用外部认证系统集成
ACT_ID_GROUP：用户组表
- 主要字段：
  - ID_：组ID
  - NAME_：组名称
  - TYPE_：组类型
- 应用场景：
  - 部门管理
  - 角色管理
  - 权限分组

2.5 作业和事件相关表

ACT_RU_JOB：运行时作业表
- 主要字段：
  - ID_：作业ID
  - TYPE_：作业类型
  - DUEDATE_：到期时间
  - REPEAT_：重复规则
- 相关作业表：
  - ACT_RU_TIMER_JOB：定时作业表
  - ACT_RU_SUSPENDED_JOB：暂停的作业表
  - ACT_RU_DEADLETTER_JOB：无法执行的作业表
  - ACT_RU_EXTERNAL_JOB：外部作业表
  - ACT_RU_HISTORY_JOB：历史作业表
事件相关表：
- ACT_RU_EVENT_SUBSCR：事件订阅表
- ACT_EVT_LOG：事件日志表
- FLW_EVENT_DEFINITION：事件定义表
- FLW_CHANNEL_DEFINITION：通道定义表

2.6 通用支持表

ACT_GE_BYTEARRAY：二进制数据存储表
- 存储流程定义文件、表单文件等
- 主要字段：
  - ID_：主键
  - NAME_：文件名
  - BYTES_：二进制内容
  - DEPLOYMENT_ID_：部署ID
ACT_GE_PROPERTY：属性表
- 存储系统级别的属性信息
- 主要字段：
  - NAME_：属性名
  - VALUE_：属性值
  - REV_：版本号

3. 扩展功能模块表结构

3.1 CMMN（案例管理）相关表

部署相关表：
- ACT_CMMN_DEPLOYMENT：CMMN部署表
- ACT_CMMN_CASEDEF：案例定义表
运行时表：
- ACT_CMMN_RU_CASE_INST：运行时案例实例表
- ACT_CMMN_RU_PLAN_ITEM_INST：计划项实例表
历史表：
- ACT_CMMN_HI_CASE_INST：历史案例实例表

3.2 DMN（决策管理）相关表

部署相关表：
- ACT_DMN_DEPLOYMENT：DMN部署表
- ACT_DMN_DECISION：决策表定义表
历史表：
- ACT_DMN_HI_DECISION_EXECUTION：决策执行历史表

4. 表关系与性能优化

4.1 核心表关系

流程引擎核心表关系：
ACT_RE_DEPLOYMENT ←──┐
      ↓              │
ACT_RE_PROCDEF ←─┐   │
      ↓          │   │
ACT_RU_EXECUTION │   │
      ↓          │   │
ACT_RU_TASK      │   │
      ↓          │   │
ACT_HI_PROCINST ─┘   │
      ↓              │
ACT_HI_TASKINST ────┘

4.2 性能优化建议

索引优化：

CREATE INDEX idx_task_assignee ON ACT_RU_TASK(ASSIGNEE_);
CREATE INDEX idx_hi_proc_inst_end ON ACT_HI_PROCINST(END_TIME_);
CREATE INDEX idx_ru_execution_proc ON ACT_RU_EXECUTION(PROC_DEF_ID_);

数据清理策略：
- 按年月分表存储历史数据
- 定期归档历史数据
- 及时清理过期数据
查询优化：
- 优先使用API而非直接SQL查询
- 合理使用分页查询
- 避免全表扫描

5. 最佳实践与应用场景

5.1 常见应用场景

5.1.1 请假审批流程示例

让我们通过一个具体的请假审批流程来看数据是如何在各个表中流转的：

请假流程数据流转示意图

流程定义部署阶段

-- ACT_RE_DEPLOYMENT 新增一条部署记录
INSERT INTO ACT_RE_DEPLOYMENT(ID_, NAME_, DEPLOY_TIME_) 
VALUES ('1', '请假流程-V1', '2025-03-13 10:00:00');

-- ACT_RE_PROCDEF 新增一条流程定义记录
INSERT INTO ACT_RE_PROCDEF(ID_, NAME_, KEY_, VERSION_, DEPLOYMENT_ID_)
VALUES ('leave:1:1', '请假申请', 'leave', 1, '1');

发起请假申请

-- ACT_RU_EXECUTION 新增流程实例
INSERT INTO ACT_RU_EXECUTION(ID_, PROC_INST_ID_, BUSINESS_KEY_, PROC_DEF_ID_)
VALUES ('2001', '2001', 'LEAVE-2025-001', 'leave:1:1');

-- ACT_RU_TASK 新增员工填写任务
INSERT INTO ACT_RU_TASK(ID_, EXECUTION_ID_, PROC_INST_ID_, TASK_DEF_KEY_, NAME_)
VALUES ('2002', '2001', '2001', 'fillForm', '填写请假申请');

-- ACT_RU_VARIABLE 保存表单数据
INSERT INTO ACT_RU_VARIABLE(ID_, EXECUTION_ID_, NAME_, TYPE_, TEXT_)
VALUES 
('2003', '2001', 'days', 'integer', '3'),
('2004', '2001', 'reason', 'string', '年假');

直接主管审批

-- ACT_RU_TASK 更新前一个任务状态，新增审批任务
UPDATE ACT_RU_TASK SET END_TIME_ = NOW() WHERE ID_ = '2002';
INSERT INTO ACT_RU_TASK(ID_, EXECUTION_ID_, PROC_INST_ID_, TASK_DEF_KEY_, NAME_, ASSIGNEE_)
VALUES ('2005', '2001', '2001', 'leaderApprove', '直接主管审批', 'leader1');

-- ACT_HI_TASKINST 记录任务历史
INSERT INTO ACT_HI_TASKINST(ID_, PROC_INST_ID_, TASK_DEF_KEY_, NAME_, START_TIME_, END_TIME_)
VALUES ('2002', '2001', 'fillForm', '填写请假申请', '2025-03-13 10:05:00', '2025-03-13 10:10:00');

人事审批

-- ACT_RU_TASK 更新主管审批任务，新增人事审批任务
UPDATE ACT_RU_TASK SET END_TIME_ = NOW() WHERE ID_ = '2005';
INSERT INTO ACT_RU_TASK(ID_, EXECUTION_ID_, PROC_INST_ID_, TASK_DEF_KEY_, NAME_, ASSIGNEE_)
VALUES ('2006', '2001', '2001', 'hrApprove', '人事审批', 'hr1');

-- ACT_HI_TASKINST 记录主管审批历史
INSERT INTO ACT_HI_TASKINST(ID_, PROC_INST_ID_, TASK_DEF_KEY_, NAME_, START_TIME_, END_TIME_)
VALUES ('2005', '2001', 'leaderApprove', '直接主管审批', '2025-03-13 10:10:00', '2025-03-13 11:00:00');

流程结束

-- ACT_RU_TASK 删除最后一个任务
DELETE FROM ACT_RU_TASK WHERE ID_ = '2006';

-- ACT_RU_EXECUTION 删除执行实例
DELETE FROM ACT_RU_EXECUTION WHERE PROC_INST_ID_ = '2001';

-- ACT_HI_PROCINST 更新流程实例历史
UPDATE ACT_HI_PROCINST 
SET END_TIME_ = NOW(), 
    DURATION_ = TIMESTAMPDIFF(SECOND, START_TIME_, NOW())
WHERE PROC_INST_ID_ = '2001';

-- ACT_HI_TASKINST 记录最后一个任务历史
INSERT INTO ACT_HI_TASKINST(ID_, PROC_INST_ID_, TASK_DEF_KEY_, NAME_, START_TIME_, END_TIME_)
VALUES ('2006', '2001', 'hrApprove', '人事审批', '2025-03-13 11:00:00', '2025-03-13 11:30:00');

数据流转说明：

部署阶段：
- 流程定义文件存储在 ACT_GE_BYTEARRAY
- 部署信息记录在 ACT_RE_DEPLOYMENT
- 流程定义信息记录在 ACT_RE_PROCDEF
运行时阶段：
- 流程实例数据在 ACT_RU_EXECUTION
- 当前任务数据在 ACT_RU_TASK
- 流程变量在 ACT_RU_VARIABLE
历史记录：
- 流程实例历史在 ACT_HI_PROCINST
- 任务历史在 ACT_HI_TASKINST
- 变量历史在 ACT_HI_VARINST

5.2 多引擎集成建议

流程引擎与CMMN集成：
- 使用统一的事务管理
- 共享用户数据
- 统一历史数据管理
DMN决策表使用：
- 在流程中调用决策表
- 在案例中使用决策节点

5.3 最佳实践清单

数据管理：
- 定期清理历史数据
- 实施合理的归档策略
- 监控表数据量增长
性能优化：
- 合理使用索引
- 优化查询方式
- 定期维护数据库
安全建议：
- 注意多租户数据隔离
- 加密敏感信息
- 控制数据访问权限

总结

了解Flowable的表结构设计对于以下方面很有帮助：

理解Flowable的工作原理
进行流程调试和问题排查
优化系统性能
实现复杂业务场景
多引擎协同工作

希望本文能帮助大家更好地理解Flowable的数据库设计，为后续的开发和维护工作提供参考。

Spring Boot + Flowable 工作流开发教程：整合 BPMN 和 CMMN 实战

March 12, 2025

Flowable 作为一个强大的开源工作流引擎，不仅支持传统的 BPMN 工作流，还提供了 CMMN 案例管理的能力，能够同时应对结构化和非结构化的业务场景。

本文将通过一个实际的服务台(Helpdesk)系统示例，详细介绍如何使用 Spring Boot 集成 Flowable，实现 BPMN 工作流与 CMMN 案例管理的完美结合。通过这个示例，你将学习到：

如何在 Spring Boot 项目中集成 Flowable
BPMN 和 CMMN 的最佳实践及应用场景
工作流引擎的核心 API 使用方法
服务台系统的完整实现流程

让我们开始这段整合之旅吧！

1. BPMN vs CMMN

在开始之前，让我们先了解 BPMN 和 CMMN 的区别：

1.1 BPMN（Business Process Model and Notation）

适用于结构化的业务流程
强调顺序流和控制流
流程是预定义的，步骤相对固定
典型应用：请假审批、报销流程等

1.2 CMMN（Case Management Model and Notation）

适用于非结构化的业务场景
强调灵活性和适应性
任务可以动态启动和完成
典型应用：客服工单、医疗诊断等

2. 项目环境

JDK 8+
Spring Boot 2.7.x
Flowable 6.8.0（包含 BPMN 和 CMMN 引擎）
Maven

3. 项目初始化

3.1 添加依赖

首先创建一个 Spring Boot 项目，在 pom.xml 中添加以下依赖：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.flowable</groupId>
    <artifactId>flowable-springboot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.18</version>
    </parent>

    <properties>
        <java.version>8</java.version>
        <flowable.version>6.8.0</flowable.version>
    </properties>

    <dependencies>
        <!-- Spring Boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- Flowable -->
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-spring-boot-starter-rest</artifactId>
            <version>${flowable.version}</version>
        </dependency>
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-spring-boot-starter-basic</artifactId>
            <version>${flowable.version}</version>
        </dependency>

        <!-- Database -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3.2 配置文件

在 src/main/resources/application.yml 中添加以下配置：

server:
  port: 8080

spring:
  datasource:
    url: jdbc:h2:mem:flowable;DB_CLOSE_DELAY=-1
    username: sa
    password:
    driver-class-name: org.h2.Driver
  h2:
    console:
      enabled: true
      path: /h2-console

flowable:
  database-schema-update: true
  async-executor-activate: false
  bpmn:
    enabled: true
  cmmn:
    enabled: true

4. 流程与案例模型

4.1 BPMN 流程模型

Helpdesk BPMN 流程模型

在 src/main/resources/processes 目录下创建 helpdesk.bpmn20.xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
             xmlns:flowable="http://flowable.org/bpmn"
             targetNamespace="http://flowable.org/examples">

    <process id="leaveProcess" name="Leave Process">
        <startEvent id="startEvent" name="Start"/>
        <sequenceFlow id="flow1" sourceRef="startEvent" targetRef="submitTask"/>

        <userTask id="submitTask" name="Submit Leave Request"
                  flowable:assignee="${applicant}"/>
        <sequenceFlow id="flow2" sourceRef="submitTask" targetRef="approveTask"/>

        <userTask id="approveTask" name="Approve Leave Request"
                  flowable:candidateGroups="managers"/>
        <sequenceFlow id="flow3" sourceRef="approveTask" targetRef="endEvent"/>

        <endEvent id="endEvent" name="End"/>
    </process>

</definitions>

4.2 CMMN 案例模型

Helpdesk CMMN 案例模型

在 src/main/resources/cases 目录下创建 helpdesk-case.cmmn.xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/CMMN/20151109/MODEL"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:flowable="http://flowable.org/cmmn"
             xmlns:cmmndi="http://www.omg.org/spec/CMMN/20151109/CMMNDI"
             xmlns:dc="http://www.omg.org/spec/CMMN/20151109/DC"
             xmlns:di="http://www.omg.org/spec/CMMN/20151109/DI"
             targetNamespace="http://www.flowable.org/casedef"
             exporter="Flowable Open Source Modeler"
             exporterVersion="6.8.0">

    <case id="helpDeskCase" name="Help Desk Case" flowable:initiatorVariableName="initiator">
        <documentation>Help Desk Case for handling support requests</documentation>
        <casePlanModel id="casePlanModel" flowable:formFieldValidation="true">
            <planItem id="planItem1" name="Register Request" definitionRef="sid-D23F3A7F-E35E-491B-A801-CAE2A8DF141D"></planItem>
            <planItem id="planItem2" name="Handle Request" definitionRef="sid-43B74981-CB5A-441E-ABDD-D0509AD0A4F8">
                <entryCriterion id="sid-C006CACE-99AC-47CD-AF5D-6102F52D856A" sentryRef="sentry1"></entryCriterion>
            </planItem>

            <sentry id="sentry1">
                <planItemOnPart id="sentryOnPart1" sourceRef="planItem1">
                    <standardEvent>complete</standardEvent>
                </planItemOnPart>
            </sentry>

            <humanTask id="sid-D23F3A7F-E35E-491B-A801-CAE2A8DF141D" name="Register Request" flowable:formFieldValidation="true"></humanTask>
            <humanTask id="sid-43B74981-CB5A-441E-ABDD-D0509AD0A4F8" name="Handle Request" flowable:formFieldValidation="true"></humanTask>
        </casePlanModel>
    </case>

    <cmmndi:CMMNDI>
        <cmmndi:CMMNDiagram id="CMMNDiagram_helpdeskCase">
            <cmmndi:CMMNShape id="CMMNShape_casePlanModel" cmmnElementRef="casePlanModel">
                <dc:Bounds height="714.0" width="718.0" x="40.0" y="40.0"></dc:Bounds>
                <cmmndi:CMMNLabel></cmmndi:CMMNLabel>
            </cmmndi:CMMNShape>
            <cmmndi:CMMNShape id="CMMNShape_planItem1" cmmnElementRef="planItem1">
                <dc:Bounds height="80.0" width="100.0" x="167.0" y="189.57881699604252"></dc:Bounds>
                <cmmndi:CMMNLabel></cmmndi:CMMNLabel>
            </cmmndi:CMMNShape>
            <cmmndi:CMMNShape id="CMMNShape_planItem2" cmmnElementRef="planItem2">
                <dc:Bounds height="80.0" width="100.0" x="555.0" y="185.0"></dc:Bounds>
                <cmmndi:CMMNLabel></cmmndi:CMMNLabel>
            </cmmndi:CMMNShape>
            <cmmndi:CMMNShape id="CMMNShape_sid-C006CACE-99AC-47CD-AF5D-6102F52D856A" cmmnElementRef="sid-C006CACE-99AC-47CD-AF5D-6102F52D856A">
                <dc:Bounds height="22.0" width="14.0" x="547.6330130435323" y="218.57881699604252"></dc:Bounds>
                <cmmndi:CMMNLabel></cmmndi:CMMNLabel>
            </cmmndi:CMMNShape>
            <cmmndi:CMMNEdge id="CMMNEdge_sid-E0987438-F457-41CD-9AD9-61A0E53EC4D0" cmmnElementRef="planItem1" targetCMMNElementRef="sid-C006CACE-99AC-47CD-AF5D-6102F52D856A">
                <di:extension>
                    <flowable:docker type="source" x="50.0" y="40.0"></flowable:docker>
                    <flowable:docker type="target" x="7.0" y="11.0"></flowable:docker>
                </di:extension>
                <di:waypoint x="266.95000000000005" y="229.57881699604252"></di:waypoint>
                <di:waypoint x="547.6330130435323" y="229.57881699604252"></di:waypoint>
                <cmmndi:CMMNLabel></cmmndi:CMMNLabel>
            </cmmndi:CMMNEdge>
        </cmmndi:CMMNDiagram>
    </cmmndi:CMMNDI>
</definitions>

5. 控制器实现

5.1 BPMN 流程控制器

@RestController
@RequestMapping("/bpmn")
@RequiredArgsConstructor
public class BpmnController {
    private final RuntimeService runtimeService;
    private final TaskService taskService;
    private final HistoryService historyService;
    private final RepositoryService repositoryService;
    
    @PostMapping("/process/start")
    public Map<String, Object> startProcess(@RequestBody Map<String, Object> variables) {
        variables.put("initiator", variables.getOrDefault("userId", "unknown"));
        
        ProcessInstance processInstance = runtimeService.createProcessInstanceBuilder()
                .processDefinitionKey("helpDeskProcess")
                .variables(variables)
                .start();
                
        Map<String, Object> result = new HashMap<>();
        result.put("processInstanceId", processInstance.getId());
        result.put("processDefinitionId", processInstance.getProcessDefinitionId());
        result.put("variables", variables);
        return result;
    }
    
    // ... 其他 BPMN 相关接口
}

5.2 CMMN 案例控制器

@RestController
@RequestMapping("/cmmn")
@RequiredArgsConstructor
public class CmmnController {
    private final CmmnRuntimeService cmmnRuntimeService;
    private final CmmnTaskService cmmnTaskService;
    private final CmmnHistoryService cmmnHistoryService;
    private final CmmnRepositoryService cmmnRepositoryService;
    
    // ... 其他代码见GitHub仓库
}

6. API 测试

6.1 BPMN 流程接口测试

# 启动流程
curl -X POST "http://localhost:8080/bpmn/process/start" \
     -H "Content-Type: application/json" \
     -d '{"userId": "john"}'

# 查询任务
curl "http://localhost:8080/bpmn/tasks?assignee=john"

# 完成任务
curl -X POST "http://localhost:8080/bpmn/tasks/{taskId}/complete" \
     -H "Content-Type: application/json" \
     -d '{"approved": true}'

6.2 CMMN 案例接口测试

# 启动案例
curl -X POST "http://localhost:8080/cmmn/helpdesk/start" \
     -H "Content-Type: application/json" \
     -d '{"userId": "john"}'

# 查询任务
curl "http://localhost:8080/cmmn/tasks?assignee=john"

# 完成任务
curl -X POST "http://localhost:8080/cmmn/tasks/69e07941-d34a-11ee-9b85-0242ac110002/complete" \
     -H "Content-Type: application/json" \
     -d '{"analysis": "网络连接问题"}'

# 查询支持组任务
curl "http://localhost:8080/cmmn/tasks?candidateGroup=support"

# 认领任务
curl -X POST "http://localhost:8080/cmmn/tasks/7a1b8c52-d34a-11ee-9b85-0242ac110002/claim?userId=mary"

7. Flowable API 说明

7.1 BPMN 相关 API

RuntimeService

主要用于管理运行中的流程实例

// 启动流程实例
ProcessInstance processInstance = runtimeService.createProcessInstanceBuilder()
    .processDefinitionKey("helpDeskProcess")
    .variables(variables)
    .start();

// 触发信号事件
runtimeService.signalEventReceived("signalName");

// 设置流程变量
runtimeService.setVariable(processInstanceId, "varName", value);

// 删除流程实例
runtimeService.deleteProcessInstance(processInstanceId, "reason");

TaskService

负责管理和操作用户任务

// 查询任务
List<Task> tasks = taskService.createTaskQuery()
    .taskAssignee("john")
    .active()
    .list();

// 完成任务
taskService.complete(taskId);

// 认领任务
taskService.claim(taskId, userId);

// 设置任务变量
taskService.setVariable(taskId, "varName", value);

RepositoryService

管理流程定义和部署

// 部署流程定义
Deployment deployment = repositoryService.createDeployment()
    .addClasspathResource("processes/helpdesk.bpmn20.xml")
    .deploy();

// 查询流程定义
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
    .processDefinitionKey("helpDeskProcess")
    .latestVersion()
    .singleResult();

HistoryService

访问历史数据

// 查询历史流程实例
List<HistoricProcessInstance> historicProcessInstances = historyService
    .createHistoricProcessInstanceQuery()
    .finished()
    .list();

// 查询历史任务
List<HistoricTaskInstance> historicTasks = historyService
    .createHistoricTaskInstanceQuery()
    .taskAssignee("john")
    .finished()
    .list();

7.2 CMMN 相关 API

CmmnRuntimeService

管理运行中的案例实例

// 启动案例实例
CaseInstance caseInstance = cmmnRuntimeService.createCaseInstanceBuilder()
    .caseDefinitionKey("helpDeskCase")
    .variables(variables)
    .start();

// 终止案例实例
cmmnRuntimeService.terminateCaseInstance(caseInstanceId);

// 查询案例实例
CaseInstance caseInstance = cmmnRuntimeService.createCaseInstanceQuery()
    .caseInstanceId(caseInstanceId)
    .singleResult();

CmmnTaskService

管理案例中的人工任务

// 查询任务
List<Task> tasks = cmmnTaskService.createTaskQuery()
    .taskAssignee("john")
    .list();

// 完成任务
cmmnTaskService.complete(taskId, variables);

// 认领任务
cmmnTaskService.claim(taskId, userId);

// 委派任务
cmmnTaskService.delegateTask(taskId, userId);

CmmnRepositoryService

管理案例定义和部署

// 部署案例定义
CmmnDeployment deployment = cmmnRepositoryService.createDeployment()
    .addClasspathResource("cases/helpdesk.cmmn")
    .deploy();

// 查询案例定义
CaseDefinition caseDefinition = cmmnRepositoryService.createCaseDefinitionQuery()
    .caseDefinitionKey("helpDeskCase")
    .latestVersion()
    .singleResult();

CmmnHistoryService

访问案例历史数据

// 查询历史案例实例
List<HistoricCaseInstance> historicCases = cmmnHistoryService
    .createHistoricCaseInstanceQuery()
    .finished()
    .list();

// 查询历史任务
List<HistoricTaskInstance> historicTasks = cmmnHistoryService
    .createHistoricTaskInstanceQuery()
    .taskAssignee("john")
    .finished()
    .list();

// 查询历史变量
List<HistoricVariableInstance> historicVariables = cmmnHistoryService
    .createHistoricVariableInstanceQuery()
    .caseInstanceId(caseInstanceId)
    .list();

7.3 查询 API 的通用方法

Flowable 的查询 API 提供了丰富的链式调用方法：

// 通用的查询方法
.asc()/.desc()           // 排序
.listPage(start, size)   // 分页查询
.count()                 // 计数
.singleResult()          // 获取单个结果
.list()                  // 获取列表结果

// 时间相关查询
.before(date)            // 在指定时间之前
.after(date)             // 在指定时间之后

// 排序方法
.orderByTaskCreateTime()
.orderByProcessInstanceId()
.orderByCaseInstanceId()

7.4 变量处理

Flowable 支持多种类型的变量：

// 设置变量
Map<String, Object> variables = new HashMap<>();
variables.put("stringVar", "value");
variables.put("numberVar", 123);
variables.put("dateVar", new Date());
variables.put("booleanVar", true);

// 在流程/案例中使用变量
runtimeService.setVariables(processInstanceId, variables);
cmmnRuntimeService.setVariables(caseInstanceId, variables);

// 获取变量
Map<String, Object> processVariables = runtimeService.getVariables(processInstanceId);
Map<String, Object> caseVariables = cmmnRuntimeService.getVariables(caseInstanceId);

8. BPMN 和 CMMN 的应用场景

8.1 BPMN 适用场景

标准化的审批流程
固定步骤的业务流程
需要严格控制流程顺序的场景

8.2 CMMN 适用场景

动态变化的服务请求
需要灵活处理的客户案例
基于知识工作者判断的任务

9. 最佳实践

选择合适的模型
- 对于结构化、固定流程，使用 BPMN
- 对于非结构化、动态场景，使用 CMMN
- 可以在同一系统中结合使用两种模型
流程与案例的集成
- BPMN 流程可以调用 CMMN 案例
- CMMN 案例可以触发 BPMN 流程
- 根据业务需求灵活组合
数据共享
- 流程和案例可以共享变量
- 使用统一的数据存储
- 保持数据一致性