跳到主要内容

REST API

Doubao 中英对照 REST API

Flowable REST 通用原则​

安装与认证​

Flowable 为 Flowable 引擎提供了 REST API，可通过将 flowable-rest.war 部署到 Apache Tomcat 等 Servlet 容器来安装。此外，也可以在另一个 Web 应用中使用它：在你的应用中包含该 Servlet（和/或其映射），并将所有 flowable-rest 依赖加入 classpath。

默认情况下，Flowable 引擎会连接一个内存中的 H2 数据库。你可以在 WEB-INF/META-INF/flowable-app 文件夹下的 flowable-app.properties 文件中更改数据库设置。REST API 使用 JSON 格式（http://www.json.org），并构建在 Spring MVC（http://docs.spring.io/spring/docs/current/spring-framework-reference/html/mvc.html）之上。

默认情况下，所有 REST 资源都要求一个具有 rest-access-api 权限的合法用户通过认证。如果希望任何合法用户都能调用 REST API，可以将 flowable.rest.app.authentication-mode 设置为 any-user（在旧版本的 Flowable 中这是默认值）。

可以通过设置以下属性来配置一个能够访问 REST API 的默认用户：

flowable.rest.app.admin.user-id=rest-admin
flowable.rest.app.admin.password=test
flowable.rest.app.admin.first-name=Rest
flowable.rest.app.admin.last-name=Admin

REST 应用启动时，若该用户尚不存在则创建，否则直接获取。该用户会被授予 access-rest-api 权限，默认情况下访问 REST API 需要此权限。之后请务必修改此用户的密码。如果未设置 flowable.rest.app.admin.user-id，则不会创建任何用户或权限。因此，在初始设置完成后移除该属性并不会删除此前已配置的用户或权限。

使用基本 HTTP 访问认证，因此在发起请求时应始终包含 Authorization: Basic …​== 请求头，或者将用户名和密码包含在请求 URL 中（例如 *http://username:password@localhost:8080/xyz*）。

我们建议将基本认证与 HTTPS 结合使用。

配置​

Flowable REST Web 应用使用 Spring Java Configuration 来启动 Flowable Form 引擎、使用 Spring Security 定义基本认证安全，并定义用于特定变量处理的变量转换器。
可以通过修改 WEB-INF/META-INF/flowable-app/flowable-app.properties 文件夹中的 flowable-app.properties 文件来定义少量属性。
如果需要更高级的配置选项，可以在 flowable-custom-context.xml 文件中覆盖默认的 Spring Bean，该文件同样位于 WEB-INF/classes 文件夹中。
此文件中已以注释形式给出了一个示例配置。这里也是覆盖默认 RestResponseFactory 的地方：定义一个名为 restResponsefactory 的新 Spring Bean，并使用你自己的自定义实现类。

在 Tomcat 中使用​

由于 Tomcat 的默认安全属性，默认不允许转义的正斜杠（%2F 和 %5C）（会返回 400 结果）。 这可能会影响部署资源及其数据 URL，因为该 URL 有可能包含转义的正斜杠。

当遇到意外的 400 结果问题时，设置以下系统属性：

-Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true

最佳实践是，对下文所述的 HTTP 请求，始终将 Accept 和 Content-Type（在 POST/PUT JSON 时）请求头设置为 application/json。

方法与返回码​

HTTP 方法与对应操作

方法操作
GET获取单个资源或获取资源集合。
POST创建新资源。也用于执行请求结构过于复杂、无法放入 GET 请求查询 URL 的资源查询。
PUT更新已有资源的属性。也用于对已有资源执行操作。
DELETE删除已有资源。

HTTP 方法响应码

响应描述
200 - Ok操作成功，已返回响应（GET 和 PUT 请求）。
201 - Created操作成功，实体已创建并在响应体中返回（POST 请求）。
204 - No content操作成功，实体已删除，因此不返回响应体（DELETE 请求）。
401 - Unauthorized操作失败。该操作需要设置 Authentication 请求头。若请求中已包含该请求头，则所提供的凭证无效，或用户无权执行此操作。
403 - Forbidden该操作被禁止，不应重试。这意味着是授权问题而非认证问题，即该操作不被允许。例如：删除属于正在运行流程的任务是不允许的，并且无论用户或流程/任务状态如何，永远不会允许。
404 - Not found操作失败。未找到请求的资源。
405 - Method not allowed操作失败。该方法不允许用于此资源。例如，尝试更新（PUT）部署资源将导致 405 状态。
409 - Conflict操作失败。它导致对某个资源的更新，而该资源已被另一操作更新，从而使本次更新失效。也可能表示正在集合中创建一个资源，但具有该标识符的资源已存在。
415 - Unsupported Media Type操作失败。请求体包含不支持的媒体类型。当请求体 JSON 包含未知属性或值、且其格式/类型不符合要求而无法被接受时，也会发生此错误。
500 - Internal server error操作失败。执行操作时发生了意外异常。响应体中包含错误详情。

除非请求的是二进制内容（例如部署资源数据），HTTP 响应的媒体类型始终为 application/json；此时则使用该内容的媒体类型。

错误响应体​

发生错误时（客户端和服务端均包括，即 4XX 和 5XX 状态码），响应体包含一个描述所发生错误的对象。以下是任务未找到时 404 状态的示例：

{
  "statusCode" : 404,
  "errorMessage" : "Could not find a task with id '444'."
}

请求参数​

URL 片段​

属于 URL 一部分的参数（例如 http://host/flowable-rest/process-api/repository/deployments/\{deploymentId} 中的 deploymentId 参数）
在片段包含特殊字符时，需要进行适当转义（参见 URL 编码或百分号编码）。大多数框架都内置了此功能，但仍应加以注意。对于可能包含正斜杠的片段（例如部署资源），尤其需要这样做。

REST URL 查询参数​

作为 URL 中查询字符串添加的参数（例如 http://host/flowable-rest/process-api/repository/deployments?name=Deployment 中使用的 name 参数）可以具有以下类型，并在相应的 REST API 文档中说明：

URL 查询参数类型

类型格式
String纯文本参数。可包含 URL 中允许的任意合法字符。对于 XXXLike 参数，字符串应包含通配符 %（经过正确的 URL 编码）。这样可以指定 like 搜索的意图。例如，'Tas%' 匹配所有以 'Tas' 开头的值。
Integer表示整数值的参数。只能包含非小数的数字值，介于 -2.147.483.648 与 2.147.483.647 之间。
Long表示 long 值的参数。只能包含非小数的数字值，介于 -9.223.372.036.854.775.808 与 9.223.372.036.854.775.807 之间。
Boolean表示布尔值的参数。只能为 true 或 false。除此以外的所有其他值都会导致 '405 - Bad request' 响应。
Date表示日期值的参数。使用 ISO-8601 日期格式（参见 维基百科上的 ISO-8601），同时包含时间和日期分量（例如 2013-04-03T23:45Z）。

JSON 体参数​

JSON 参数类型

类型格式
String纯文本参数。对于 XXXLike 参数，字符串应包含通配符 %。这样可以指定 like 搜索的意图。例如，'Tas%' 匹配所有以 'Tas' 开头的值。
Integer表示整数值的参数，使用 JSON 数字。只能包含非小数的数字值，介于 -2.147.483.648 与 2.147.483.647 之间。
Long表示 long 值的参数，使用 JSON 数字。只能包含非小数的数字值，介于 -9.223.372.036.854.775.808 与 9.223.372.036.854.775.807 之间。
Date表示日期值的参数，使用 JSON 文本。使用 ISO-8601 日期格式（参见 维基百科上的 ISO-8601），同时包含时间和日期分量（例如 2013-04-03T23:45Z）。

分页与排序​

分页和排序参数可以作为 URL 中的查询字符串添加（例如 http://host/flowable-rest/process-api/repository/deployments?sort=name 中使用的 name 参数）。

变量查询 JSON 参数

参数默认值描述
sort各查询实现不同排序键的名称，其默认值和允许值因查询实现而异。
orderasc排序顺序，可为 'asc' 或 'desc'。
start0用于结果分页的参数。默认从 0 开始返回结果。
size10用于结果分页的参数。默认大小为 10。

注意

请注意，start 参数用作查询的偏移量。例如，要将任务分成每页 3 条、共三页（9 条）来获取，我们会使用：

GET /runtime/tasks?start=0&size=3
GET /runtime/tasks?start=3&size=3
GET /runtime/tasks?start=6&size=3

JSON 查询变量格式​

{
  "name" : "variableName",
  "value" : "variableValue",
  "operation" : "equals",
  "type" : "string"
}

变量查询 JSON 参数

参数是否必需描述
name否要包含在查询中的变量名称。在某些查询中使用 'equals' 时，它可以为空，用于查询具有给定值、且任意变量名的资源。
value是查询中所包含变量的值，应包含给定类型的正确格式。
operator是查询中使用的操作符，可取以下值：equals、notEquals、equalsIgnoreCase、notEqualsIgnoreCase、lessThan、greaterThan、lessThanOrEquals、greaterThanOrEquals 和 like。
type否要使用的变量类型。省略时，类型将从 value 参数推断。任何 JSON 文本值都视为 string 类型，JSON 布尔值视为 boolean 类型，JSON 数字根据数字大小视为 long 或 integer 类型。建议在不确定时显式指定类型。开箱即用支持的类型列于下表。

默认查询 JSON 类型

类型名称描述
string值被视为并转换为 java.lang.String。
short值被视为并转换为 java.lang.Integer。
integer值被视为并转换为 java.lang.Integer。
long值被视为并转换为 java.lang.Long。
double值被视为并转换为 java.lang.Double。
boolean值被视为并转换为 java.lang.Boolean。
date值被视为并转换为 java.util.Date。JSON 字符串将使用 ISO-8601 日期格式进行转换。

变量表示​

在处理变量（执行决策）时，REST API 在读取和写入时都使用一些通用原则和 JSON 格式。变量的 JSON 表示如下所示：

{
  "name" : "variableName",
  "value" : "variableValue",
  "valueUrl" : "http://...",
  "type" : "string"
}

变量 JSON 属性

参数是否必需描述
name是变量的名称。
value否变量的值。写入变量时若省略 value，则使用 null 作为值。
valueUrl否读取 binary 或 serializable 类型的变量时，此属性指向可获取原始二进制数据的 URL。
type否变量的类型。有关类型的更多信息见下表。写入变量时若省略此值，类型将根据原始 JSON 属性请求类型推断，且仅限于 string、double、integer 和 boolean。建议始终指定类型，以确保不会对类型做出错误假设。

变量类型

类型名称描述
string值被视为 java.lang.String。写入变量时使用原始 JSON 文本值。
integer值被视为 java.lang.Integer。写入时，以 JSON 数字值作为转换基础，回退到 JSON 文本。
short值被视为 java.lang.Short。写入时，以 JSON 数字值作为转换基础，回退到 JSON 文本。
long值被视为 java.lang.Long。写入时，以 JSON 数字值作为转换基础，回退到 JSON 文本。
double值被视为 java.lang.Double。写入时，以 JSON 数字值作为转换基础，回退到 JSON 文本。
boolean值被视为 java.lang.Boolean。写入时，使用 JSON 布尔值进行转换。
date值被视为 java.util.Date。写入时，JSON 文本将使用 ISO-8601 日期格式转换。

可以通过自定义 JSON 表示（简单值或复杂/嵌套 JSON 对象）来支持额外的变量类型。通过扩展 org.flowable.dmn.rest.service.api.DmnRestResponseFactory 上的 initializeVariableConverters() 方法，你可以添加额外的 org.flowable.rest.variable.RestVariableConverter 类，以支持将你的 POJO 转换为适合通过 REST 传输的格式，并将 REST 值转换回你的 POJO。实际到 JSON 的转换由 Jackson 完成。

部署​

使用 Tomcat 时，请阅读 在 Tomcat 中使用。

部署列表​

GET repository/deployments

URL 查询参数

参数是否必需值描述
name否String仅返回具有给定名称的部署。
nameLike否String仅返回名称类似于给定名称的部署。
category否String仅返回具有给定类别的部署。
categoryNotEquals否String仅返回不具有给定类别的部署。
tenantId否String仅返回具有给定 tenantId 的部署。
tenantIdLike否String仅返回 tenantId 类似于给定值的部署。
withoutTenantId否Boolean若为 true，仅返回未设置 tenantId 的部署。若为 false，则忽略 withoutTenantId 参数。
sort否'id'（默认）、'name'、'deployTime' 或 'tenantId'排序所依据的属性，需与 'order' 一起使用。

REST 响应码

响应码描述
200表示请求成功。

成功响应体：

{
  "data": [
    {
      "id": "10",
      "name": "flowable-examples.bar",
      "deploymentTime": "2010-10-13T14:54:26.750+02:00",
      "category": "examples",
      "url": "http://localhost:8081/flowable-rest/service/repository/deployments/10",
      "tenantId": null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

获取一个部署​

GET repository/deployments/{deploymentId}

获取部署 - URL 参数

参数是否必需值描述
deploymentId是String要获取的部署的 id。

获取部署 - 响应码

响应码描述
200表示已找到并返回该部署。
404表示未找到请求的部署。

成功响应体：

{
  "id": "10",
  "name": "flowable-examples.bar",
  "deploymentTime": "2010-10-13T14:54:26.750+02:00",
  "category": "examples",
  "url": "http://localhost:8081/flowable-rest/service/repository/deployments/10",
  "tenantId" : null
}

创建新部署​

POST repository/deployments

请求体：

请求体应包含 multipart/form-data 类型的数据。请求中应恰好包含一个文件，任何额外的文件都会被忽略。部署名称即为传入的文件字段的名称。如果需要在单个部署中部署多个资源，请将这些资源压缩为一个 zip，并确保文件名以 .bar 或 .zip 结尾。

可以在请求体中传递一个名为 tenantId 的额外参数（表单字段）。该字段的值将用作本次部署所属租户的 id。

创建新部署 - 响应码

响应码描述
201表示部署已创建。
400表示请求体中没有内容，或内容的 MIME 类型不支持部署。状态描述中包含更多信息。

成功响应体：

{
  "id": "10",
  "name": "flowable-examples.bar",
  "deploymentTime": "2010-10-13T14:54:26.750+02:00",
  "category": null,
  "url": "http://localhost:8081/flowable-rest/service/repository/deployments/10",
  "tenantId" : "myTenant"
}

删除一个部署​

DELETE repository/deployments/{deploymentId}

删除部署 - URL 参数

参数是否必需值描述
deploymentId是String要删除的部署的 id。

删除部署 - 响应码

响应码描述
204表示已找到该部署并已删除。响应体按设计为空。
404表示未找到请求的部署。

列出部署中的资源​

GET repository/deployments/{deploymentId}/resources

列出部署中的资源 - URL 参数

参数是否必需值描述
deploymentId是String要获取其资源的部署的 id。

列出部署中的资源 - 响应码

响应码描述
200表示已找到该部署并已返回资源列表。
404表示未找到请求的部署。

成功响应体：

[
  {
    "id": "diagrams/my-process.bpmn20.xml",
    "url": "http://localhost:8081/flowable-rest/service/repository/deployments/10/resources/diagrams%2Fmy-process.bpmn20.xml",
    "dataUrl": "http://localhost:8081/flowable-rest/service/repository/deployments/10/resourcedata/diagrams%2Fmy-process.bpmn20.xml",
    "mediaType": "text/xml",
    "type": "processDefinition"
  },
  {
    "id": "image.png",
    "url": "http://localhost:8081/flowable-rest/service/repository/deployments/10/resources/image.png",
    "dataUrl": "http://localhost:8081/flowable-rest/service/repository/deployments/10/resourcedata/image.png",
    "mediaType": "image/png",
    "type": "resource"
  }
]
  • mediaType：包含该资源的媒体类型。它使用一个（可插拔的）MediaTypeResolver 解析，默认包含数量有限的 MIME 类型映射。
  • type：资源的类型，可能取值：
  • resource：普通资源。
  • processDefinition：包含一个或多个流程定义的资源。部署器会拾取此资源。
  • processImage：表示已部署流程定义图形布局的资源。

单个资源结果 JSON 中的 dataUrl 属性包含用于获取二进制资源的实际 URL。

获取一个部署资源​

GET repository/deployments/{deploymentId}/resources/{resourceId}

获取部署资源 - URL 参数

参数是否必需值描述
deploymentId是String请求资源所属部署的 id。
resourceId是String要获取的资源的 id。如果 resourceId 包含正斜杠，请务必对其进行 URL 编码。例如：使用 'diagrams%2Fmy-process.bpmn20.xml' 而非 'diagrams/Fmy-process.bpmn20.xml'。

获取部署资源 - 响应码

响应码描述
200表示部署和资源均已找到，并已返回该资源。
404表示未找到请求的部署，或部署中不存在具有给定 id 的资源。状态描述中包含更多信息。

成功响应体：

{
  "id": "diagrams/my-process.bpmn20.xml",
  "url": "http://localhost:8081/flowable-rest/service/repository/deployments/10/resources/diagrams%2Fmy-process.bpmn20.xml",
  "dataUrl": "http://localhost:8081/flowable-rest/service/repository/deployments/10/resourcedata/diagrams%2Fmy-process.bpmn20.xml",
  "mediaType": "text/xml",
  "type": "processDefinition"
}
  • mediaType：包含该资源的媒体类型。它使用一个（可插拔的）MediaTypeResolver 解析，默认包含数量有限的 MIME 类型映射。
  • type：资源的类型，可能取值：
  • resource：普通资源。
  • processDefinition：包含一个或多个流程定义的资源。部署器会拾取此资源。
  • processImage：表示已部署流程定义图形布局的资源。

获取部署资源内容​

GET repository/deployments/{deploymentId}/resourcedata/{resourceId}

获取部署资源内容 - URL 参数

参数是否必需值描述
deploymentId是String请求资源所属部署的 id。
resourceId是String要获取其数据的资源的 id。如果 resourceId 包含正斜杠，请务必对其进行 URL 编码。例如：使用 'diagrams%2Fmy-process.bpmn20.xml' 而非 'diagrams/Fmy-process.bpmn20.xml'。
.Get a deployment resource content - Response codes
响应码描述
200表示部署和资源均已找到，并已返回该资源的数据。
404表示未找到请求的部署，或部署中不存在具有给定 id 的资源。状态描述中包含更多信息。

成功响应体：

响应体将包含所请求资源的二进制资源内容。响应 content-type 与资源 'mimeType' 属性中返回的类型相同。此外还会设置 content-disposition 请求头，使浏览器能够下载该文件而不是直接显示。

流程定义​

流程定义列表​

GET repository/process-definitions

流程定义列表 - URL 参数

参数是否必需值描述
version否integer仅返回具有给定版本的流程定义。
name否String仅返回具有给定名称的流程定义。
nameLike否String仅返回名称类似于给定名称的流程定义。
key否String仅返回具有给定 key 的流程定义。
keyLike否String仅返回名称类似于给定名称的流程定义。
resourceName否String仅返回具有给定资源名称的流程定义。
resourceNameLike否String仅返回资源名称类似于给定资源名称的流程定义。
category否String仅返回具有给定类别的流程定义。
categoryLike否String仅返回类别类似于给定类别的流程定义。
categoryNotEquals否String仅返回不具有给定类别的流程定义。
deploymentId否String仅返回属于具有给定 id 的部署的流程定义。
startableByUser否String仅返回可由给定用户启动的流程定义。
latest否Boolean仅返回最新的流程定义版本。只能与 'key'、'keyLike'、'resourceName' 和 'resourceNameLike' 参数一起使用，使用任何其他参数都会导致 400 响应。
suspended否Boolean若为 true，仅返回已挂起的流程定义。若为 false，仅返回活动的流程定义（即未挂起的）。
sort否'name'（默认）、'id'、'key'、'category'、'deploymentId' 和 'version'排序所依据的属性，需与 'order' 一起使用。

流程定义列表 - 响应码

响应码描述
200表示请求成功，并已返回流程定义。
400表示参数格式错误，或 'latest' 与 'key' 和 'keyLike' 以外的参数一起使用。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "oneTaskProcess:1:4",
      "url" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "version" : 1,
      "key" : "oneTaskProcess",
      "category" : "Examples",
      "suspended" : false,
      "name" : "The One Task Process",
      "description" : "This is a process for testing purposes",
      "deploymentId" : "2",
      "deploymentUrl" : "http://localhost:8081/repository/deployments/2",
      "graphicalNotationDefined" : true,
      "resource" : "http://localhost:8182/repository/deployments/2/resources/testProcess.xml",
      "diagramResource" : "http://localhost:8182/repository/deployments/2/resources/testProcess.png",
      "startFormDefined" : false
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}
  • graphicalNotationDefined：表示流程定义包含图形信息（BPMN DI）。
  • resource：包含实际部署的 BPMN 2.0 xml。
  • diagramResource：包含流程的图形表示；当没有可用图表时为 null。

获取一个流程定义​

GET repository/process-definitions/{processDefinitionId}

获取流程定义 - URL 参数

参数是否必需值描述
processDefinitionId是String要获取的流程定义的 id。

获取流程定义 - 响应码

响应码描述
200表示已找到并返回该流程定义。
404表示未找到请求的流程定义。

成功响应体：

{
  "id" : "oneTaskProcess:1:4",
  "url" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
  "version" : 1,
  "key" : "oneTaskProcess",
  "category" : "Examples",
  "suspended" : false,
  "name" : "The One Task Process",
  "description" : "This is a process for testing purposes",
  "deploymentId" : "2",
  "deploymentUrl" : "http://localhost:8081/repository/deployments/2",
  "graphicalNotationDefined" : true,
  "resource" : "http://localhost:8182/repository/deployments/2/resources/testProcess.xml",
  "diagramResource" : "http://localhost:8182/repository/deployments/2/resources/testProcess.png",
  "startFormDefined" : false
}
  • graphicalNotationDefined：表示流程定义包含图形信息（BPMN DI）。
  • resource：包含实际部署的 BPMN 2.0 xml。
  • diagramResource：包含流程的图形表示；当没有可用图表时为 null。

更新流程定义的类别​

PUT repository/process-definitions/{processDefinitionId}

请求体 JSON：

{
  "category" : "updatedcategory"
}

更新流程定义类别 - 响应码

响应码描述
200表示流程的类别已更改。
400表示请求体中未定义类别。
404表示未找到请求的流程定义。

成功响应体： 参见 repository/process-definitions/{processDefinitionId} 的响应。

获取流程定义资源内容​

GET repository/process-definitions/{processDefinitionId}/resourcedata

获取流程定义资源内容 - URL 参数

参数是否必需值描述
processDefinitionId是String要获取其资源数据的流程定义的 id。

响应：

与 GET repository/deployment/{deploymentId}/resourcedata/{resourceId} 的响应码/响应体完全相同。

获取流程定义 BPMN 模型​

GET repository/process-definitions/{processDefinitionId}/model

获取流程定义 BPMN 模型 - URL 参数

参数是否必需值描述
processDefinitionId是String要获取其模型的流程定义的 id。

获取流程定义 BPMN 模型 - 响应码

响应码描述
200表示已找到该流程定义并返回模型。
404表示未找到请求的流程定义。

响应体：

响应体是 org.flowable.bpmn.model.BpmnModel 的 JSON 表示，包含完整的流程定义模型。

{
   "processes":[
      {
         "id":"oneTaskProcess",
         "xmlRowNumber":7,
         "xmlColumnNumber":60,
         "extensionElements":{

         },
         "name":"The One Task Process",
         "executable":true,
         "documentation":"One task process description",

    ]
}

挂起一个流程定义​

PUT repository/process-definitions/{processDefinitionId}

请求体 JSON：

{
  "action" : "suspend",
  "includeProcessInstances" : "false",
  "date" : "2013-04-15T00:42:12Z"
}

挂起流程定义 - 请求体 JSON 参数

参数描述是否必需
action要执行的操作。可为 activate 或 suspend。是
includeProcessInstances是否挂起/激活该流程定义正在运行的流程实例。省略时，流程实例保持其原有状态。否
date执行挂起/激活的日期（ISO-8601）。省略时，挂起/激活立即生效。否

挂起流程定义 - 响应码

响应码描述
200表示流程已挂起。
404表示未找到请求的流程定义。
409表示请求的流程定义已被挂起。

成功响应体： 参见 repository/process-definitions/{processDefinitionId} 的响应。

激活一个流程定义​

PUT repository/process-definitions/{processDefinitionId}

请求体 JSON：

{
  "action" : "activate",
  "includeProcessInstances" : "true",
  "date" : "2013-04-15T00:42:12Z"
}

参见挂起流程定义的 请求体 JSON 参数。

激活流程定义 - 响应码

响应码描述
200表示流程已激活。
404表示未找到请求的流程定义。
409表示请求的流程定义已处于活动状态。

成功响应体： 参见 repository/process-definitions/{processDefinitionId} 的响应。

获取流程定义的所有候选启动者​

GET repository/process-definitions/{processDefinitionId}/identitylinks

获取流程定义的所有候选启动者 - URL 参数

参数是否必需值描述
processDefinitionId是String要获取其身份链接的流程定义的 id。

获取流程定义的所有候选启动者 - 响应码

响应码描述
200表示已找到该流程定义并返回所请求的身份链接。
404表示未找到请求的流程定义。

成功响应体：

[
   {
      "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/groups/admin",
      "user":null,
      "group":"admin",
      "type":"candidate"
   },
   {
      "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/users/kermit",
      "user":"kermit",
      "group":null,
      "type":"candidate"
   }
]

为流程定义添加候选启动者​

POST repository/process-definitions/{processDefinitionId}/identitylinks

为流程定义添加候选启动者 - URL 参数

参数是否必需值描述
processDefinitionId是String流程定义的 id。

请求体（用户）：

{
  "user" : "kermit"
}

请求体（组）：

{
  "groupId" : "sales"
}

为流程定义添加候选启动者 - 响应码

响应码描述
201表示已找到该流程定义并已创建身份链接。
404表示未找到请求的流程定义。

成功响应体：

{
  "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/users/kermit",
  "user":"kermit",
  "group":null,
  "type":"candidate"
}

从流程定义删除候选启动者​

DELETE repository/process-definitions/{processDefinitionId}/identitylinks/{family}/{identityId}

从流程定义删除候选启动者 - URL 参数

参数是否必需值描述
processDefinitionId是String流程定义的 id。
family是String可为 users 或 groups，取决于身份链接的类型。
identityId是String要作为候选启动者移除的身份的 userId 或 groupId。

从流程定义删除候选启动者 - 响应码

响应码描述
204表示已找到该流程定义并已移除身份链接。响应体按设计为空。
404表示未找到请求的流程定义，或该流程定义不存在与 URL 匹配的身份链接。

成功响应体：

{
  "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/users/kermit",
  "user":"kermit",
  "group":null,
  "type":"candidate"
}

从流程定义获取一个候选启动者​

GET repository/process-definitions/{processDefinitionId}/identitylinks/{family}/{identityId}

从流程定义获取候选启动者 - URL 参数

参数是否必需值描述
processDefinitionId是String流程定义的 id。
family是String可为 users 或 groups，取决于身份链接的类型。
identityId是String要作为候选启动者获取的身份的 userId 或 groupId。

从流程定义获取候选启动者 - 响应码

响应码描述
200表示已找到该流程定义并返回身份链接。
404表示未找到请求的流程定义，或该流程定义不存在与 URL 匹配的身份链接。

成功响应体：

{
  "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/users/kermit",
  "user":"kermit",
  "group":null,
  "type":"candidate"
}

模型​

获取模型列表​

GET repository/models

获取模型列表 - URL 查询参数

参数是否必需值描述
id否String仅返回具有给定 id 的模型。
category否String仅返回具有给定类别的模型。
categoryLike否String仅返回类别类似于给定值的模型。使用 % 字符作为通配符。
categoryNotEquals否String仅返回不具有给定类别的模型。
name否String仅返回具有给定名称的模型。
nameLike否String仅返回名称类似于给定值的模型。使用 % 字符作为通配符。
key否String仅返回具有给定 key 的模型。
deploymentId否String仅返回部署在给定部署中的模型。
version否Integer仅返回具有给定版本的模型。
latestVersion否Boolean若为 true，仅返回最新版本的模型。最好与 key 一起使用。若传入 false，则忽略此参数并返回所有版本。
deployed否Boolean若为 true，仅返回已部署的模型。若为 false，仅返回未部署的模型（deploymentId 为 null）。
tenantId否String仅返回具有给定 tenantId 的模型。
tenantIdLike否String仅返回 tenantId 类似于给定值的模型。
withoutTenantId否Boolean若为 true，仅返回未设置 tenantId 的模型。若为 false，则忽略 withoutTenantId 参数。
sort否'id'（默认）、'category'、'createTime'、'key'、'lastUpdateTime'、'name'、'version' 或 'tenantId'排序所依据的属性，需与 'order' 一起使用。

获取模型列表 - 响应码

响应码描述
200表示请求成功，并已返回模型。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
   "data":[
      {
         "name":"Model name",
         "key":"Model key",
         "category":"Model category",
         "version":2,
         "metaInfo":"Model metainfo",
         "deploymentId":"7",
         "id":"10",
         "url":"http://localhost:8182/repository/models/10",
         "createTime":"2013-06-12T14:31:08.612+0000",
         "lastUpdateTime":"2013-06-12T14:31:08.612+0000",
         "deploymentUrl":"http://localhost:8182/repository/deployments/7",
         "tenantId":null
      },

      ...

   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

获取一个模型​

GET repository/models/{modelId}

获取模型 - URL 参数

参数是否必需值描述
modelId是String要获取的模型的 id。

获取模型 - 响应码

响应码描述
200表示已找到并返回该模型。
404表示未找到请求的模型。

成功响应体：

{
   "id":"5",
   "url":"http://localhost:8182/repository/models/5",
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":2,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "deploymentUrl":"http://localhost:8182/repository/deployments/2",
   "createTime":"2013-06-12T12:31:19.861+0000",
   "lastUpdateTime":"2013-06-12T12:31:19.861+0000",
   "tenantId":null
}

更新一个模型​

PUT repository/models/{modelId}

请求体：

{
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":2,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "tenantId":"updatedTenant"
}

所有请求值都是可选的。例如，你可以只在请求体 JSON 对象中包含 'name' 属性，仅更新模型的名称，其他字段保持不变。当某个属性被显式包含并设置为 null 时，该模型值将被更新为 null。例如：{"metaInfo" : null} 将清除模型的 metaInfo。

更新模型 - 响应码

响应码描述
200表示已找到并更新该模型。
404表示未找到请求的模型。

成功响应体：

{
   "id":"5",
   "url":"http://localhost:8182/repository/models/5",
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":2,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "deploymentUrl":"http://localhost:8182/repository/deployments/2",
   "createTime":"2013-06-12T12:31:19.861+0000",
   "lastUpdateTime":"2013-06-12T12:31:19.861+0000",
   "tenantId":""updatedTenant"
}

创建一个模型​

POST repository/models

请求体：

{
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":1,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "tenantId":"tenant"
}

所有请求值都是可选的。例如，你可以只在请求体 JSON 对象中包含 'name' 属性，仅设置模型的名称，其他字段均为 null。

创建模型 - 响应码

响应码描述
201表示模型已创建。

成功响应体：

{
   "id":"5",
   "url":"http://localhost:8182/repository/models/5",
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":1,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "deploymentUrl":"http://localhost:8182/repository/deployments/2",
   "createTime":"2013-06-12T12:31:19.861+0000",
   "lastUpdateTime":"2013-06-12T12:31:19.861+0000",
   "tenantId":"tenant"
}

删除一个模型​

DELETE repository/models/{modelId}

删除模型 - URL 参数

参数是否必需值描述
modelId是String要删除的模型的 id。

删除模型 - 响应码

响应码描述
204表示已找到该模型并已删除。响应体按设计为空。
404表示未找到请求的模型。

获取模型的编辑器源码​

GET repository/models/{modelId}/source

获取模型的编辑器源码 - URL 参数

参数是否必需值描述
modelId是String模型的 id。

获取模型的编辑器源码 - 响应码

响应码描述
200表示已找到该模型并返回源码。
404表示未找到请求的模型。

成功响应体：

响应体包含模型的原始编辑器源码。无论源码内容如何，响应的 content-type 都设置为 application/octet-stream。

设置模型的编辑器源码​

PUT repository/models/{modelId}/source

设置模型的编辑器源码 - URL 参数

参数是否必需值描述
modelId是String模型的 id。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带源码的二进制值。

设置模型的编辑器源码 - 响应码

响应码描述
200表示已找到该模型并已更新源码。
404表示未找到请求的模型。

成功响应体：

响应体包含模型的原始编辑器源码。无论源码内容如何，响应的 content-type 都设置为 application/octet-stream。

获取模型的额外编辑器源码​

GET repository/models/{modelId}/source-extra

获取模型的额外编辑器源码 - URL 参数

参数是否必需值描述
modelId是String模型的 id。

获取模型的额外编辑器源码 - 响应码

响应码描述
200表示已找到该模型并返回源码。
404表示未找到请求的模型。

成功响应体：

响应体包含模型的原始额外编辑器源码。无论额外源码内容如何，响应的 content-type 都设置为 application/octet-stream。

设置模型的额外编辑器源码​

PUT repository/models/{modelId}/source-extra

设置模型的额外编辑器源码 - URL 参数

参数是否必需值描述
modelId是String模型的 id。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带额外源码的二进制值。

设置模型的额外编辑器源码 - 响应码

响应码描述
200表示已找到该模型并已更新额外源码。
404表示未找到请求的模型。

成功响应体：

响应体包含模型的原始编辑器源码。无论源码内容如何，响应的 content-type 都设置为 application/octet-stream。

流程实例​

获取一个流程实例​

GET runtime/process-instances/{processInstanceId}

获取流程实例 - URL 参数

参数是否必需值描述
processInstanceId是String要获取的流程实例的 id。

获取流程实例 - 响应码

响应码描述
200表示已找到并返回该流程实例。
404表示未找到请求的流程实例。

成功响应体：

{
   "id":"7",
   "url":"http://localhost:8182/runtime/process-instances/7",
   "businessKey":"myBusinessKey",
   "suspended":false,
   "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
   "activityId":"processTask",
   "tenantId": null
}

删除一个流程实例​

DELETE runtime/process-instances/{processInstanceId}?deleteReason={deleteReason}

删除流程实例 - URL 参数

参数是否必需值描述
processInstanceId是String要删除的流程实例的 id。
deleteReason否String删除该流程实例的原因。

删除流程实例 - 响应码

响应码描述
204表示已找到并删除该流程实例。响应体按设计为空。
404表示未找到请求的流程实例。

激活或挂起流程实例​

PUT runtime/process-instances/{processInstanceId}

激活或挂起流程实例 - URL 参数

参数是否必需值描述
processInstanceId是String要激活/挂起的流程实例的 id。

请求响应体（挂起）：

{
   "action":"suspend"
}

请求响应体（激活）：

{
   "action":"activate"
}

激活或挂起流程实例 - 响应码

响应码描述
200表示已找到该流程实例并已执行操作。
400表示提供了无效的操作。
404表示未找到请求的流程实例。
409表示无法执行所请求的流程实例操作，因为该流程实例已处于激活/挂起状态。

启动一个流程实例​

POST runtime/process-instances

请求体（按流程定义 id 启动）：

{
   "processDefinitionId":"oneTaskProcess:1:158",
   "businessKey":"myBusinessKey",
   "returnVariables":true,
   "variables": [
      {
        "name":"myVar",
        "value":"This is a variable"
      }
   ]
}

请求体（按流程定义 key 启动）：

{
   "processDefinitionKey":"oneTaskProcess",
   "businessKey":"myBusinessKey",
   "returnVariables":false,
   "tenantId": "tenant1",
   "variables": [
      {
        "name":"myVar",
        "value":"This is a variable"
      }
   ]
}

请求体（按消息启动）：

{
   "message":"newOrderMessage",
   "businessKey":"myBusinessKey",
   "tenantId": "tenant1",
   "variables": [
      {
        "name":"myVar",
        "value":"This is a variable"
      }
   ]
}

请注意，此 JSON 中也接受 transientVariables 属性，其结构与 variables 属性相同。

returnVariables 属性可用于在响应中取回流程实例上下文中已有的变量。默认不返回变量。

请求体中只能使用 processDefinitionId、processDefinitionKey 或 message 三者之一。businessKey、variables 和 tenantId 参数是可选的。若省略 tenantId，将使用默认租户。有关变量格式的更多信息，参见 REST 变量一节。请注意，所提供的变量作用域会被忽略，流程变量始终是局部的。

启动流程实例 - 响应码

响应码描述
201表示流程实例已创建。
400表示要么未找到流程定义（基于 id 或 key）、要么发送给定消息未启动任何流程、要么传递了无效变量。状态描述中包含关于该错误的更多信息。

成功响应体：

{
   "id":"7",
   "url":"http://localhost:8182/runtime/process-instances/7",
   "businessKey":"myBusinessKey",
   "suspended":false,
   "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
   "activityId":"processTask",
   "tenantId" : null
}

流程实例列表​

GET runtime/process-instances

流程实例列表 - URL 查询参数

参数是否必需值描述
id否String仅返回具有给定 id 的流程实例。
processDefinitionKey否String仅返回具有给定流程定义 key 的流程实例。
processDefinitionId否String仅返回具有给定流程定义 id 的流程实例。
businessKey否String仅返回具有给定 businessKey 的流程实例。
involvedUser否String仅返回给定用户参与其中的流程实例。
suspended否Boolean若为 true，仅返回已挂起的流程实例。若为 false，仅返回未挂起的（活动的）流程实例。
superProcessInstanceId否String仅返回具有给定上级流程实例 id 的流程实例（用于含有调用活动的流程）。
subProcessInstanceId否String仅返回具有给定子流程实例 id 的流程实例（作为调用活动启动的流程）。
excludeSubprocesses否Boolean仅返回不是子流程的流程实例。
includeProcessVariables否Boolean指示是否在结果中包含流程变量。
tenantId否String仅返回具有给定 tenantId 的流程实例。
tenantIdLike否String仅返回 tenantId 类似于给定值的流程实例。
withoutTenantId否Boolean若为 true，仅返回未设置 tenantId 的流程实例。若为 false，则忽略 withoutTenantId 参数。
sort否String排序字段，应为 id（默认）、processDefinitionId、tenantId 或 processDefinitionKey 之一。

流程实例列表 - 响应码

响应码描述
200表示请求成功，并已返回流程实例。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
   "data":[
      {
         "id":"7",
         "url":"http://localhost:8182/runtime/process-instances/7",
         "businessKey":"myBusinessKey",
         "suspended":false,
         "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
         "activityId":"processTask",
         "tenantId" : null
      }


   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

查询流程实例​

POST query/process-instances

请求体：

{
  "processDefinitionKey":"oneTaskProcess",
  "variables":
  [
    {
        "name" : "myVariable",
        "value" : 1234,
        "operation" : "equals",
        "type" : "long"
    }
  ]
}

请求体可以包含可用于流程实例列表 URL 查询中的所有过滤器。除此之外，还可以提供一个变量数组
以包含在查询中，其格式在此说明。

通用的分页与排序查询参数可用于此 URL。

查询流程实例 - 响应码

响应码描述
200表示请求成功，并已返回流程实例。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
   "data":[
      {
         "id":"7",
         "url":"http://localhost:8182/runtime/process-instances/7",
         "businessKey":"myBusinessKey",
         "suspended":false,
         "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
         "activityId":"processTask",
         "tenantId" : null
      }


   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

获取流程实例的图表​

GET runtime/process-instances/{processInstanceId}/diagram

获取流程实例图表 - URL 参数

参数是否必需值描述
processInstanceId是String要获取其图表的流程实例的 id。

获取流程实例图表 - 响应码

响应码描述
200表示已找到该流程实例并返回图表。
400表示未找到请求的流程实例，但该流程不包含任何图形信息（BPMN:DI），无法创建图表。
404表示未找到请求的流程实例。

成功响应体：

响应是一个 Blob 对象，包含二进制数据或为 null。

获取流程实例的参与人​

GET runtime/process-instances/{processInstanceId}/identitylinks

获取流程实例的参与人 - URL 参数

参数是否必需值描述
processInstanceId是String要获取其链接的流程实例的 id。

获取流程实例的参与人 - 响应码

响应码描述
200表示已找到该流程实例并返回链接。
404表示未找到请求的流程实例。

成功响应体：

[
   {
      "url":"http://localhost:8182/runtime/process-instances/5/identitylinks/users/john/customType",
      "user":"john",
      "group":null,
      "type":"customType"
   },
   {
      "url":"http://localhost:8182/runtime/process-instances/5/identitylinks/users/paul/candidate",
      "user":"paul",
      "group":null,
      "type":"candidate"
   }
]

请注意，groupId 始终为 null，因为流程实例只能关联用户。

为流程实例添加参与用户​

POST runtime/process-instances/{processInstanceId}/identitylinks

为流程实例添加参与用户 - URL 参数

参数是否必需值描述
processInstanceId是String要为其添加链接的流程实例的 id。

请求体：

{
  "userId":"kermit",
  "type":"participant"
}

userId 和 type 都是必需的。

为流程实例添加参与用户 - 响应码

响应码描述
201表示已找到该流程实例并已创建链接。
400表示请求体中未包含 userId 或 type。
404表示未找到请求的流程实例。

成功响应体：

{
   "url":"http://localhost:8182/runtime/process-instances/5/identitylinks/users/john/customType",
   "user":"john",
   "group":null,
   "type":"customType"
}

请注意，groupId 始终为 null，因为流程实例只能关联用户。

从流程实例移除参与用户​

DELETE runtime/process-instances/{processInstanceId}/identitylinks/users/{userId}/{type}

从流程实例移除参与用户 - URL 参数

参数是否必需值描述
processInstanceId是String流程实例的 id。
userId是要删除其链接的用户的 id。
type是要删除的链接类型。

从流程实例移除参与用户 - 响应码

响应码描述
204表示已找到该流程实例并已删除链接。响应体按设计为空。
404表示未找到请求的流程实例，或要删除的链接不存在。响应状态中包含关于该错误的更多信息。

成功响应体：

{
   "url":"http://localhost:8182/runtime/process-instances/5/identitylinks/users/john/customType",
   "user":"john",
   "group":null,
   "type":"customType"
}

请注意，groupId 始终为 null，因为流程实例只能关联用户。

流程实例的变量列表​

GET runtime/process-instances/{processInstanceId}/variables

流程实例的变量列表 - URL 参数

参数是否必需值描述
processInstanceId是String要获取其变量的流程实例的 id。

流程实例的变量列表 - 响应码

响应码描述
200表示已找到该流程实例并返回变量。
404表示未找到请求的流程实例。

成功响应体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   },
   {
      "name":"byteArrayProcVar",
      "type":"binary",
      "value":null,
      "valueUrl":"http://localhost:8182/runtime/process-instances/5/variables/byteArrayProcVar/data",
      "scope":"local"
   }
]

如果变量是 binary 变量或 serializable 变量，valueUrl 指向一个用于获取原始值的 URL。如果是普通变量，值会直接出现在响应中。
请注意，只返回局部作用域的变量，因为流程实例变量没有全局作用域。

获取流程实例的一个变量​

GET runtime/process-instances/{processInstanceId}/variables/{variableName}

获取流程实例的变量 - URL 参数

参数是否必需值描述
processInstanceId是String要获取其变量的流程实例的 id。
variableName是要获取的变量的名称。

获取流程实例的变量 - 响应码

响应码描述
200表示流程实例和变量均已找到，并返回该变量。
400表示请求体不完整或包含非法值。状态描述中包含关于该错误的更多信息。
404表示未找到请求的流程实例，或该流程实例不存在具有给定名称的变量。状态描述中包含关于该错误的更多信息。

成功响应体：

   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   }

如果变量是 binary 变量或 serializable 变量，valueUrl 指向一个用于获取原始值的 URL。如果是普通变量，值会直接出现在响应中。请注意，只返回局部作用域的变量，因为流程实例变量没有全局作用域。

在流程实例上创建（或更新）变量​

POST runtime/process-instances/{processInstanceId}/variables

PUT runtime/process-instances/{processInstanceId}/variables

使用 POST 时，所传递的所有变量都会被创建。如果其中某个变量在流程实例上已存在，则请求会导致错误（409 - CONFLICT）。使用 PUT 时，流程实例上不存在的变量会被创建，已存在的变量会被覆盖，且不会有任何错误。

在流程实例上创建（或更新）变量 - URL 参数

参数是否必需值描述
processInstanceId是String要获取其变量的流程实例的 id。

请求体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123
   },

   ...
]

请求体数组中可以传入任意数量的变量。有关变量格式的更多信息，参见 REST 变量一节。请注意，scope 会被忽略，流程实例中只能设置局部变量。

在流程实例上创建（或更新）变量 - 响应码

响应码描述
201表示已找到该流程实例并已创建变量。
400表示请求体不完整或包含非法值。状态描述中包含关于该错误的更多信息。
404表示未找到请求的流程实例。
409表示已找到该流程实例，但它已包含具有给定名称的变量（仅在使用 POST 方法时抛出）。请改用更新方法。

成功响应体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   },

   ...

]

更新流程实例上的单个变量​

PUT runtime/process-instances/{processInstanceId}/variables/{variableName}

更新流程实例上的单个变量 - URL 参数

参数是否必需值描述
processInstanceId是String要获取其变量的流程实例的 id。
variableName是要获取的变量的名称。

请求体：

 {
    "name":"intProcVar"
    "type":"integer"
    "value":123
 }

有关变量格式的更多信息，参见 REST 变量一节。请注意，scope 会被忽略，流程实例中只能设置局部变量。

更新流程实例上的单个变量 - 响应码

响应码描述
200表示流程实例和变量均已找到，并已更新该变量。
404表示未找到请求的流程实例，或该流程实例不存在具有给定名称的变量。状态描述中包含关于该错误的更多信息。

成功响应体：

{
  "name":"intProcVar",
  "type":"integer",
  "value":123,
  "scope":"local"
}

如果变量是 binary 变量或 serializable 变量，valueUrl 指向一个用于获取原始值的 URL。如果是普通变量，值会直接出现在响应中。请注意，只返回局部作用域的变量，因为流程实例变量没有全局作用域。

在流程实例上创建新的 binary 变量​

POST runtime/process-instances/{processInstanceId}/variables

在流程实例上创建新的 binary 变量 - URL 参数

参数是否必需值描述
processInstanceId是String要为其创建新变量的流程实例的 id。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带变量的二进制值。除此之外，还可以包含以下额外表单字段：

  • name：变量的必需名称。
  • type：所创建变量的类型。省略时假定为 binary，请求中的二进制数据将以字节数组形式存储。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/process-instances/123/variables/binaryVariable/data"
}

在流程实例上创建新的 binary 变量 - 响应码

响应码描述
201表示变量已创建并返回结果。
400表示缺少要创建的变量名称。状态消息中提供更多信息。
404表示未找到请求的流程实例。
409表示该流程实例已存在具有给定名称的变量。请改用 PUT 方法更新该任务变量。
415表示该 serializable 数据包含某个对象，而运行 Flowable 引擎的 JVM 中不存在对应类，因此无法反序列化。

更新流程实例上已有的 binary 变量​

PUT runtime/process-instances/{processInstanceId}/variables

更新流程实例上已有的 binary 变量 - URL 参数

参数是否必需值描述
processInstanceId是String要为其更新变量的流程实例的 id。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带变量的二进制值。除此之外，还可以包含以下额外表单字段：

  • name：变量的必需名称。
  • type：所创建变量的类型。省略时假定为 binary，请求中的二进制数据将以字节数组形式存储。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/process-instances/123/variables/binaryVariable/data"
}

更新流程实例上已有的 binary 变量 - 响应码

响应码描述
200表示变量已更新并返回结果。
400表示缺少要更新的变量名称。状态消息中提供更多信息。
404表示未找到请求的流程实例，或该流程实例不存在具有给定名称的变量。
415表示该 serializable 数据包含某个对象，而运行 Flowable 引擎的 JVM 中不存在对应类，因此无法反序列化。

执行实例​

获取一个执行实例​

GET runtime/executions/{executionId}

获取执行实例 - URL 参数

参数是否必需值描述
executionId是String要获取的执行实例的 id。

获取执行实例 - 响应码

响应码描述
200表示已找到并返回该执行实例。
404表示未找到该执行实例。

成功响应体：

{
   "id":"5",
   "url":"http://localhost:8182/runtime/executions/5",
   "parentId":null,
   "parentUrl":null,
   "processInstanceId":"5",
   "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
   "suspended":false,
   "activityId":null,
   "tenantId": null
}

对执行实例执行操作​

PUT runtime/executions/{executionId}

对执行实例执行操作 - URL 参数

参数是否必需值描述
executionId是String要对其执行操作的执行实例的 id。

请求体（通知执行实例）：

{
  "action":"signal"
}

同时接受 variables 和 transientVariables 属性，结构如下：

{
  "action":"signal",
  "variables" : [
    {
      "name": "myVar",
      "value": "someValue"
    }
  ]
}

请求体（为执行实例接收信号事件）：

{
  "action":"signalEventReceived",
  "signalName":"mySignal"
  "variables": [  ]
}

通知执行实例已收到信号事件，需要 signalName 参数。可以传递可选变量，这些变量会在执行操作之前设置到执行实例上。

请求体（为执行实例接收消息事件）：

{
  "action":"messageEventReceived",
  "messageName":"myMessage"
  "variables": [  ]
}

通知执行实例已收到消息事件，需要 messageName 参数。可以传递可选变量，这些变量会在执行操作之前设置到执行实例上。

对执行实例执行操作 - 响应码

响应码描述
200表示已找到该执行实例并已执行操作。
204表示已找到该执行实例、已执行操作，且该操作导致执行实例结束。
400表示请求了非法操作、请求体中缺少必需参数，或传入了非法变量。状态描述中包含关于该错误的更多信息。
404表示未找到该执行实例。

成功响应体（当操作未导致执行实例结束时）：

{
   "id":"5",
   "url":"http://localhost:8182/runtime/executions/5",
   "parentId":null,
   "parentUrl":null,
   "processInstanceId":"5",
   "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
   "suspended":false,
   "activityId":null,
   "tenantId" : null
}

获取执行实例中的活动活动​

GET runtime/executions/{executionId}/activities

返回该执行实例中以及所有子执行实例（递归包括其子执行实例）中处于活动状态的所有活动（如果有）。

获取执行实例中的活动活动 - URL 参数

参数是否必需值描述
executionId是String要获取其活动的执行实例的 id。

获取执行实例中的活动活动 - 响应码

响应码描述
200表示已找到该执行实例并返回活动。
404表示未找到该执行实例。

成功响应体：

[
  "userTaskForManager",
  "receiveTask"
]

执行实例列表​

GET runtime/executions

执行实例列表 - URL 查询参数

参数是否必需值描述
id否String仅返回具有给定 id 的执行实例。
activityId否String仅返回具有给定活动 id 的执行实例。
processDefinitionKey否String仅返回具有给定流程定义 key 的执行实例。
processDefinitionId否String仅返回具有给定流程定义 id 的执行实例。
processInstanceId否String仅返回属于具有给定 id 的流程实例的执行实例。
messageEventSubscriptionName否String仅返回订阅了具有给定名称的消息的执行实例。
signalEventSubscriptionName否String仅返回订阅了具有给定名称的信号的执行实例。
parentId否String仅返回作为给定执行实例直接子级的执行实例。
tenantId否String仅返回具有给定 tenantId 的执行实例。
tenantIdLike否String仅返回 tenantId 类似于给定值的执行实例。
withoutTenantId否Boolean若为 true，仅返回未设置 tenantId 的执行实例。若为 false，则忽略 withoutTenantId 参数。
sort否String排序字段，应为 processInstanceId（默认）、processDefinitionId、processDefinitionKey 或 tenantId 之一。

执行实例列表 - 响应码

响应码描述
200表示请求成功，并已返回执行实例。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
   "data":[
      {
         "id":"5",
         "url":"http://localhost:8182/runtime/executions/5",
         "parentId":null,
         "parentUrl":null,
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "suspended":false,
         "activityId":null,
         "tenantId":null
      },
      {
         "id":"7",
         "url":"http://localhost:8182/runtime/executions/7",
         "parentId":"5",
         "parentUrl":"http://localhost:8182/runtime/executions/5",
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "suspended":false,
         "activityId":"processTask",
         "tenantId":null
      }
   ],
   "total":2,
   "start":0,
   "sort":"processInstanceId",
   "order":"asc",
   "size":2
}

查询执行实例​

POST query/executions

请求体：

{
  "processDefinitionKey":"oneTaskProcess",
  "variables":
  [
    {
        "name" : "myVariable",
        "value" : 1234,
        "operation" : "equals",
        "type" : "long"
    }
  ],
  "processInstanceVariables":
  [
    {
        "name" : "processVariable",
        "value" : "some string",
        "operation" : "equals",
        "type" : "string"
    }
  ]
}

请求体可以包含可用于执行实例列表 URL 查询中的所有过滤器。除此之外，还可以提供变量数组和 processInstanceVariables
以包含在查询中，其格式在此说明。

通用的分页与排序查询参数可用于此 URL。

查询执行实例 - 响应码

响应码描述
200表示请求成功，并已返回执行实例。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
   "data":[
      {
         "id":"5",
         "url":"http://localhost:8182/runtime/executions/5",
         "parentId":null,
         "parentUrl":null,
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "suspended":false,
         "activityId":null,
         "tenantId":null
      },
      {
         "id":"7",
         "url":"http://localhost:8182/runtime/executions/7",
         "parentId":"5",
         "parentUrl":"http://localhost:8182/runtime/executions/5",
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "suspended":false,
         "activityId":"processTask",
         "tenantId":null
      }
   ],
   "total":2,
   "start":0,
   "sort":"processInstanceId",
   "order":"asc",
   "size":2
}

执行实例的变量列表​

GET runtime/executions/{executionId}/variables?scope={scope}

执行实例的变量列表 - URL 参数

参数是否必需值描述
executionId是String要获取其变量的执行实例的 id。
scope否String可为 local 或 global。省略时，返回局部和全局作用域的变量。

执行实例的变量列表 - 响应码

响应码描述
200表示已找到该执行实例并返回变量。
404表示未找到请求的执行实例。

成功响应体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"global"
   },
   {
      "name":"byteArrayProcVar",
      "type":"binary",
      "value":null,
      "valueUrl":"http://localhost:8182/runtime/process-instances/5/variables/byteArrayProcVar/data",
      "scope":"local"
   }


]

如果变量是 binary 变量或 serializable 变量，valueUrl 指向一个用于获取原始值的 URL。如果是普通变量，值会直接出现在响应中。

获取执行实例的一个变量​

GET runtime/executions/{executionId}/variables/{variableName}?scope={scope}

获取执行实例的变量 - URL 参数

参数是否必需值描述
executionId是String要获取其变量的执行实例的 id。
variableName是要获取的变量的名称。
scope否String可为 local 或 global。省略时，返回局部变量（若存在）；否则返回全局变量（若存在）。

获取执行实例的变量 - 响应码

响应码描述
200表示执行实例和变量均已找到，并返回该变量。
400表示请求体不完整或包含非法值。状态描述中包含关于该错误的更多信息。
404表示未找到请求的执行实例，或该执行实例在请求的作用域中不存在具有给定名称的变量（若省略 scope 查询参数，则表示该变量在局部和全局作用域中都不存在）。状态描述中包含关于该错误的更多信息。

成功响应体：

   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   }

如果变量是 binary 变量或 serializable 变量，valueUrl 指向一个用于获取原始值的 URL。如果是普通变量，值会直接出现在响应中。

在执行实例上创建（或更新）变量​

POST runtime/executions/{executionId}/variables

PUT runtime/executions/{executionId}/variables

使用 POST 时，所传递的所有变量都会被创建。如果其中某个变量在执行实例的请求作用域中已存在，则请求会导致错误（409 - CONFLICT）。使用 PUT 时，执行实例上不存在的变量会被创建，已存在的变量会被覆盖，且不会有任何错误。

在执行实例上创建（或更新）变量 - URL 参数

参数是否必需值描述
executionId是String要获取其变量的执行实例的 id。

请求体：

[
   {
      "name":"intProcVar"
      "type":"integer"
      "value":123,
      "scope":"local"
   }



]

*请注意，只能提供具有相同作用域的变量。如果请求体数组包含混合作用域的变量，请求会导致错误（400 - BAD REQUEST）。*请求体数组中可以传入任意数量的变量。有关变量格式的更多信息，参见 REST 变量一节。请注意，scope 会被忽略，流程实例中只能设置局部变量。

在执行实例上创建（或更新）变量 - 响应码

响应码描述
201表示已找到该执行实例并已创建变量。
400表示请求体不完整或包含非法值。状态描述中包含关于该错误的更多信息。
404表示未找到请求的执行实例。
409表示已找到该执行实例，但它已包含具有给定名称的变量（仅在使用 POST 方法时抛出）。请改用更新方法。

成功响应体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   }



]

更新执行实例上的一个变量​

PUT runtime/executions/{executionId}/variables/{variableName}

更新执行实例上的变量 - URL 参数

参数是否必需值描述
executionId是String要为其更新变量的执行实例的 id。
variableName是要更新的变量的名称。

请求体：

 {
    "name":"intProcVar"
    "type":"integer"
    "value":123,
    "scope":"global"
 }

有关变量格式的更多信息，参见 REST 变量一节。

更新执行实例上的变量 - 响应码

响应码描述
200表示流程实例和变量均已找到，并已更新该变量。
404表示未找到请求的流程实例，或该流程实例不存在具有给定名称的变量。状态描述中包含关于该错误的更多信息。

成功响应体：

   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"global"
   }

如果变量是 binary 变量或 serializable 变量，valueUrl 指向一个用于获取原始值的 URL。如果是普通变量，值会直接出现在响应中。

在执行实例上创建新的 binary 变量​

POST runtime/executions/{executionId}/variables

在执行实例上创建新的 binary 变量 - URL 参数

参数是否必需值描述
executionId是String要为其创建新变量的执行实例的 id。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带变量的二进制值。除此之外，还可以包含以下额外表单字段：

  • name：变量的必需名称。
  • type：所创建变量的类型。省略时假定为 binary，请求中的二进制数据将以字节数组形式存储。
  • scope：所创建变量的作用域。省略时假定为 local。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/executions/123/variables/binaryVariable/data"
}

在执行实例上创建新的 binary 变量 - 响应码

响应码描述
201表示变量已创建并返回结果。
400表示缺少要创建的变量名称。状态消息中提供更多信息。
404表示未找到请求的执行实例。
409表示该执行实例已存在具有给定名称的变量。请改用 PUT 方法更新该任务变量。
415表示该 serializable 数据包含某个对象，而运行 Flowable 引擎的 JVM 中不存在对应类，因此无法反序列化。

更新流程实例上已有的 binary 变量​

PUT runtime/executions/{executionId}/variables/{variableName}

更新流程实例上已有的 binary 变量 - URL 参数

参数是否必需值描述
executionId是String要为其更新变量的执行实例的 id。
variableName是要更新的变量的名称。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带变量的二进制值。除此之外，还可以包含以下额外表单字段：

  • name：变量的必需名称。
  • type：所创建变量的类型。省略时假定为 binary，请求中的二进制数据将以字节数组形式存储。
  • scope：所创建变量的作用域。省略时假定为 local。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/executions/123/variables/binaryVariable/data"
}

更新流程实例上已有的 binary 变量 - 响应码

响应码描述
200表示变量已更新并返回结果。
400表示缺少要更新的变量名称。状态消息中提供更多信息。
404表示未找到请求的执行实例，或该执行实例不存在具有给定名称的变量。
415表示该 serializable 数据包含某个对象，而运行 Flowable 引擎的 JVM 中不存在对应类，因此无法反序列化。

任务​

获取一个任务​

GET runtime/tasks/{taskId}

获取任务 - URL 参数

参数是否必需值描述
taskId是String要获取的任务的 id。

获取任务 - 响应码

响应码描述
200表示已找到并返回该任务。
404表示未找到请求的任务。

成功响应体：

{
  "assignee" : "kermit",
  "createTime" : "2013-04-17T10:17:43.902+0000",
  "delegationState" : "pending",
  "description" : "Task description",
  "dueDate" : "2013-04-17T10:17:43.902+0000",
  "execution" : "http://localhost:8182/runtime/executions/5",
  "id" : "8",
  "name" : "My task",
  "owner" : "owner",
  "parentTask" : "http://localhost:8182/runtime/tasks/9",
  "priority" : 50,
  "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
  "processInstanceUrl" : "http://localhost:8182/runtime/process-instances/5",
  "suspended" : false,
  "taskDefinitionKey" : "theTask",
  "url" : "http://localhost:8182/runtime/tasks/8",
  "tenantId" : null
}
  • delegationState：任务的委派状态，可为 null、"pending" 或 "resolved"。

任务列表​

GET runtime/tasks

任务列表 - URL 查询参数

参数是否必需值描述
name否String仅返回具有给定名称的任务。
nameLike否String仅返回名称类似于给定名称的任务。
description否String仅返回具有给定描述的任务。
priority否Integer仅返回具有给定优先级的任务。
minimumPriority否Integer仅返回优先级高于给定值的任务。
maximumPriority否Integer仅返回优先级低于给定值的任务。
assignee否String仅返回分配给给定用户的任务。
assigneeLike否String仅返回 assignee 类似于给定值的任务。
owner否String仅返回归给定用户所有的任务。
ownerLike否String仅返回 owner 类似于给定值的任务。
unassigned否Boolean仅返回未分配给任何人的任务。若传入 false，则忽略此值。
delegationState否String仅返回具有给定委派状态的任务。可能取值为 pending 和 resolved。
candidateUser否String仅返回可由给定用户认领的任务。既包括该用户为显式候选人的任务，也包括该用户所属组可认领的任务。
candidateGroup否String仅返回可由给定组中用户认领的任务。
candidateGroups否String仅返回可由给定组中用户认领的任务。多个值以逗号分隔。
involvedUser否String仅返回给定用户参与其中的任务。
taskDefinitionKey否String仅返回具有给定任务定义 id 的任务。
taskDefinitionKeyLike否String仅返回任务定义 id 类似于给定值的任务。
processInstanceId否String仅返回属于具有给定 id 的流程实例的任务。
processInstanceBusinessKey否String仅返回属于具有给定业务键的流程实例的任务。
processInstanceBusinessKeyLike否String仅返回属于业务键类似于给定值的流程实例的任务。
processDefinitionId否String仅返回属于具有给定 id 的流程定义的任务。
processDefinitionKey否String仅返回属于具有给定 key 的流程定义的任务。
processDefinitionKeyLike否String仅返回属于 key 类似于给定值的流程定义的任务。
processDefinitionName否String仅返回属于具有给定名称的流程定义的任务。
processDefinitionNameLike否String仅返回属于名称类似于给定值的流程定义的任务。
executionId否String仅返回属于具有给定 id 的执行实例的任务。
createdOn否ISO Date仅返回在给定日期创建的任务。
createdBefore否ISO Date仅返回在给定日期之前创建的任务。
createdAfter否ISO Date仅返回在给定日期之后创建的任务。
dueOn否ISO Date仅返回到期日为给定日期的任务。
dueBefore否ISO Date仅返回在给定日期之前到期的任务。
dueAfter否ISO Date仅返回在给定日期之后到期的任务。
withoutDueDate否boolean仅返回没有到期日的任务。值为 false 时忽略此属性。
excludeSubTasks否Boolean仅返回不是其他任务子任务的任务。
active否Boolean若为 true，仅返回未挂起的任务（属于未挂起流程，或根本不属于任何流程）。若为 false，仅返回属于已挂起流程实例的任务。
includeTaskLocalVariables否Boolean指示是否在结果中包含任务局部变量。
includeProcessVariables否Boolean指示是否在结果中包含流程变量。
tenantId否String仅返回具有给定 tenantId 的任务。
tenantIdLike否String仅返回 tenantId 类似于给定值的任务。
withoutTenantId否Boolean若为 true，仅返回未设置 tenantId 的任务。若为 false，则忽略 withoutTenantId 参数。
candidateOrAssigned否String选择已被认领或分配给用户、或等待用户（候选人用户或组）认领的任务。
category否string选择具有给定类别的任务。请注意，这是任务类别，而非流程定义的类别（BPMN Xml 中的命名空间）。

任务列表 - 响应码

响应码描述
200表示请求成功，并已返回任务。
400表示参数格式错误，或 'delegationState' 的值无效（非 'pending' 和 'resolved'）。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "assignee" : "kermit",
      "createTime" : "2013-04-17T10:17:43.902+0000",
      "delegationState" : "pending",
      "description" : "Task description",
      "dueDate" : "2013-04-17T10:17:43.902+0000",
      "execution" : "http://localhost:8182/runtime/executions/5",
      "id" : "8",
      "name" : "My task",
      "owner" : "owner",
      "parentTask" : "http://localhost:8182/runtime/tasks/9",
      "priority" : 50,
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceUrl" : "http://localhost:8182/runtime/process-instances/5",
      "suspended" : false,
      "taskDefinitionKey" : "theTask",
      "url" : "http://localhost:8182/runtime/tasks/8",
      "tenantId" : null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询任务​

POST query/tasks

请求体：

{
  "name" : "My task",
  "description" : "The task description",

  ...

  "taskVariables" : [
    {
      "name" : "myVariable",
      "value" : 1234,
      "operation" : "equals",
      "type" : "long"
    }
  ],

    "processInstanceVariables" : [
      {
         ...
      }
    ]
  ]
}

所有允许的 JSON 参数字段与获取任务集合中的参数完全相同（candidateGroupIn 除外，它仅在此 POST 任务查询 REST 服务中可用），但以 JSON 请求体参数而非 URL 参数传递，以支持更高级的查询，并避免请求 URI 过长导致的错误。除此之外，该查询还允许基于任务变量和流程变量进行过滤。taskVariables 和 processInstanceVariables 均为 JSON 数组，其中对象的格式如此处所说明。

查询任务 - 响应码

响应码描述
200表示请求成功，并已返回任务。
400表示参数格式错误，或 'delegationState' 的值无效（非 'pending' 和 'resolved'）。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "assignee" : "kermit",
      "createTime" : "2013-04-17T10:17:43.902+0000",
      "delegationState" : "pending",
      "description" : "Task description",
      "dueDate" : "2013-04-17T10:17:43.902+0000",
      "execution" : "http://localhost:8182/runtime/executions/5",
      "id" : "8",
      "name" : "My task",
      "owner" : "owner",
      "parentTask" : "http://localhost:8182/runtime/tasks/9",
      "priority" : 50,
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceUrl" : "http://localhost:8182/runtime/process-instances/5",
      "suspended" : false,
      "taskDefinitionKey" : "theTask",
      "url" : "http://localhost:8182/runtime/tasks/8",
      "tenantId" : null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

更新一个任务​

PUT runtime/tasks/{taskId}

请求体 JSON：

{
  "assignee" : "assignee",
  "delegationState" : "resolved",
  "description" : "New task description",
  "dueDate" : "2013-04-17T13:06:02.438+02:00",
  "name" : "New task name",
  "owner" : "owner",
  "parentTaskId" : "3",
  "priority" : 20
}

所有请求值都是可选的。例如，你可以只在请求体 JSON 对象中包含 'assignee' 属性，仅更新任务的办理人，其他字段保持不变。当某个属性被显式包含并设置为 null 时，该任务值将被更新为 null。例如：{"dueDate" : null} 将清除任务的到期日。

更新任务 - 响应码

响应码描述
200表示任务已更新。
404表示未找到请求的任务。
409表示请求的任务已被并发更新。

成功响应体： 参见 runtime/tasks/{taskId} 的响应。

任务操作​

POST runtime/tasks/{taskId}

完成任务 - 请求体 JSON：

{
  "action" : "complete",
  "variables" : []
}

完成该任务。可以通过 variables 属性传入可选的变量数组。有关变量格式的更多信息，参见 REST 变量一节。请注意，所提供的变量作用域会被忽略，变量会设置到父作用域，除非某个变量存在于局部作用域（此时覆盖该局部变量）。这与 TaskService.completeTask(taskId, variables) 调用的行为相同。

请注意，此 JSON 中也接受 transientVariables 属性，其结构与 variables 属性相同。

认领任务 - 请求体 JSON：

{
  "action" : "claim",
  "assignee" : "userWhoClaims"
}

由给定 assignee 认领该任务。如果 assignee 为 null，则任务不分配给任何人，可再次被认领。

委派任务 - 请求体 JSON：

{
  "action" : "delegate",
  "assignee" : "userToDelegateTo"
}

将该任务委派给给定 assignee。assignee 是必需的。

解决任务 - 请求体 JSON：

{
  "action" : "resolve"
}

解决任务委派。任务会被分配回任务 owner（如果有）。

任务操作 - 响应码

响应码描述
200表示操作已执行。
400当请求体包含无效值，或操作要求 assignee 但缺少该参数时。
404表示未找到请求的任务。
409表示由于冲突无法执行该操作。要么任务已被并发更新，要么（对于 'claim' 操作）任务已被其他用户认领。

成功响应体： 参见 runtime/tasks/{taskId} 的响应。

删除一个任务​

DELETE runtime/tasks/{taskId}?cascadeHistory={cascadeHistory}&deleteReason={deleteReason}

删除任务 - URL 参数

参数是否必需值描述
taskId是String要删除的任务的 id。
cascadeHistory否Boolean删除任务时是否同时删除 HistoricTask 实例（如果适用）。未提供时默认为 false。
deleteReason否String删除该任务的原因。当 cascadeHistory 为 true 时，此值被忽略。

删除任务 - 响应码

响应码描述
204表示已找到该任务并已删除。响应体按设计为空。
403表示无法删除请求的任务，因为它属于某个工作流。
404表示未找到请求的任务。

获取任务的所有变量​

GET runtime/tasks/{taskId}/variables?scope={scope}

获取任务的所有变量 - URL 参数

参数是否必需值描述
taskId是String要获取其变量的任务的 id。
scope否String要返回的变量作用域。为 'local' 时，仅返回任务局部变量。为 'global' 时，仅返回任务父执行实例层次中的变量。省略时，同时返回局部和全局变量。

获取任务的所有变量 - 响应码

响应码描述
200表示已找到该任务并返回所请求的变量。
404表示未找到请求的任务。

成功响应体：

[
  {
    "name" : "doubleTaskVar",
    "scope" : "local",
    "type" : "double",
    "value" : 99.99
  },
  {
    "name" : "stringProcVar",
    "scope" : "global",
    "type" : "string",
    "value" : "This is a ProcVariable"
  }



]

变量以 JSON 数组形式返回。完整的响应说明参见通用的 REST 变量一节。

从任务获取一个变量​

GET runtime/tasks/{taskId}/variables/{variableName}?scope={scope}

从任务获取变量 - URL 参数

参数是否必需值描述
taskId是String要为其获取变量的任务的 id。
variableName是String要获取的变量的名称。
scope否String要返回的变量作用域。为 'local' 时，仅返回任务局部变量值。为 'global' 时，仅返回任务父执行实例层次中的变量值。省略时，若存在局部变量则返回局部变量，否则返回全局变量。

从任务获取变量 - 响应码

响应码描述
200表示已找到该任务并返回所请求的变量。
404表示未找到请求的任务，或该任务（在给定作用域中）不存在具有给定名称的变量。状态消息中提供更多信息。

成功响应体：

{
  "name" : "myTaskVariable",
  "scope" : "local",
  "type" : "string",
  "value" : "Hello my friend"
}

完整的响应体说明参见通用的 REST 变量一节。

获取变量的二进制数据​

GET runtime/tasks/{taskId}/variables/{variableName}/data?scope={scope}

获取变量的二进制数据 - URL 参数

参数是否必需值描述
taskId是String要为其获取变量数据的任务的 id。
variableName是String要获取其数据的变量的名称。仅 binary 和 serializable 类型的变量可用。若使用任何其他类型的变量，则返回 404。
scope否String要返回的变量作用域。为 'local' 时，仅返回任务局部变量值。为 'global' 时，仅返回任务父执行实例层次中的变量值。省略时，若存在局部变量则返回局部变量，否则返回全局变量。

获取变量的二进制数据 - 响应码

响应码描述
200表示已找到该任务并返回所请求的变量。
404表示未找到请求的任务，或该任务（在给定作用域中）不存在具有给定名称的变量，或该变量没有可用的二进制流。状态消息中提供更多信息。

成功响应体：

响应体包含该变量的二进制值。当变量为 binary 类型时，无论变量内容或请求的 accept-type 请求头如何，响应的 content-type 都设置为 application/octet-stream。对于 serializable 类型，则使用 application/x-java-serialized-object 作为 content-type。

在任务上创建新变量​

POST runtime/tasks/{taskId}/variables

在任务上创建新变量 - URL 参数

参数是否必需值描述
taskId是String要为其创建新变量的任务的 id。

创建简单（非 binary）变量的请求体：

[
  {
    "name" : "myTaskVariable",
    "scope" : "local",
    "type" : "string",
    "value" : "Hello my friend"
  },
  {

  }
]

请求体应为一个数组，包含一个或多个表示要创建变量的 JSON 对象。

  • name：变量的必需名称
  • scope：所创建变量的作用域。省略时假定为 local。
  • type：所创建变量的类型。省略时，回退到原始 JSON 值类型（string、boolean、integer 或 double）。
  • value：变量值。

有关变量格式的更多信息，参见 REST 变量一节。

成功响应体：

[
  {
    "name" : "myTaskVariable",
    "scope" : "local",
    "type" : "string",
    "value" : "Hello my friend"
  },
  {

  }
]

在任务上创建新变量 - 响应码

响应码描述
201表示变量已创建并返回结果。
400表示缺少要创建的变量名称，或试图在独立任务（无关联流程）上以 global 作用域创建变量，或请求中包含空变量数组，或请求未包含变量数组。状态消息中提供更多信息。
404表示未找到请求的任务。
409表示该任务已存在具有给定名称的变量。请改用 PUT 方法更新该任务变量。

在任务上创建新的 binary 变量​

POST runtime/tasks/{taskId}/variables

在任务上创建新的 binary 变量 - URL 参数

参数是否必需值描述
taskId是String要为其创建新变量的任务的 id。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带变量的二进制值。除此之外，还可以包含以下额外表单字段：

  • name：变量的必需名称。
  • scope：所创建变量的作用域。省略时假定为 local。
  • type：所创建变量的类型。省略时假定为 binary，请求中的二进制数据将以字节数组形式存储。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/tasks/123/variables/binaryVariable/data"
}

在任务上创建新的 binary 变量 - 响应码

响应码描述
201表示变量已创建并返回结果。
400表示缺少要创建的变量名称，或试图在独立任务（无关联流程）上以 global 作用域创建变量。状态消息中提供更多信息。
404表示未找到请求的任务。
409表示该任务已存在具有给定名称的变量。请改用 PUT 方法更新该任务变量。
415表示该 serializable 数据包含某个对象，而运行 Flowable 引擎的 JVM 中不存在对应类，因此无法反序列化。

更新任务上已有的变量​

PUT runtime/tasks/{taskId}/variables/{variableName}

更新任务上已有的变量 - URL 参数

参数是否必需值描述
taskId是String要为其更新变量的任务的 id。
variableName是String要更新的变量的名称。

更新简单（非 binary）变量的请求体：

{
  "name" : "myTaskVariable",
  "scope" : "local",
  "type" : "string",
  "value" : "Hello my friend"
}
  • name：变量的必需名称
  • scope：要更新变量的作用域。省略时假定为 local。
  • type：要更新变量的类型。省略时，回退到原始 JSON 值类型（string、boolean、integer 或 double）。
  • value：变量值。

有关变量格式的更多信息，参见 REST 变量一节。

成功响应体：

{
  "name" : "myTaskVariable",
  "scope" : "local",
  "type" : "string",
  "value" : "Hello my friend"
}

更新任务上已有的变量 - 响应码

响应码描述
200表示变量已更新并返回结果。
400表示缺少要更新的变量名称，或试图在独立任务（无关联流程）上以 global 作用域更新变量。状态消息中提供更多信息。
404表示未找到请求的任务，或该任务在给定作用域中不存在具有给定名称的变量。状态消息中包含关于该错误的更多信息。

更新任务上的 binary 变量​

PUT runtime/tasks/{taskId}/variables/{variableName}

更新任务上的 binary 变量 - URL 参数

参数是否必需值描述
taskId是String要为其更新变量的任务的 id。
variableName是String要更新的变量的名称。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带变量的二进制值。除此之外，还可以包含以下额外表单字段：

  • name：变量的必需名称。
  • scope：要更新变量的作用域。省略时假定为 local。
  • type：要更新变量的类型。省略时假定为 binary，请求中的二进制数据将以字节数组形式存储。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/tasks/123/variables/binaryVariable/data"
}

更新任务上的 binary 变量 - 响应码

响应码描述
200表示变量已更新并返回结果。
400表示缺少要更新的变量名称，或试图在独立任务（无关联流程）上以 global 作用域更新变量。状态消息中提供更多信息。
404表示未找到请求的任务，或要更新的变量在给定任务的给定作用域中不存在。
415表示该 serializable 数据包含某个对象，而运行 Flowable 引擎的 JVM 中不存在对应类，因此无法反序列化。

删除任务上的一个变量​

DELETE runtime/tasks/{taskId}/variables/{variableName}?scope={scope}

删除任务上的变量 - URL 参数

参数是否必需值描述
taskId是String要删除的变量所属任务的 id。
variableName是String要删除的变量的名称。
scope否String要删除变量的作用域。可为 local 或 global。省略时假定为 local。

删除任务上的变量 - 响应码

响应码描述
204表示已找到该任务变量并已删除。响应体按设计为空。
404表示未找到请求的任务，或该任务不存在具有给定名称的变量。状态消息中包含关于该错误的更多信息。

删除任务上的所有局部变量​

DELETE runtime/tasks/{taskId}/variables

删除任务上的所有局部变量 - URL 参数

参数是否必需值描述
taskId是String要删除的变量所属任务的 id。

删除任务上的所有局部变量 - 响应码

响应码描述
204表示已删除所有局部任务变量。响应体按设计为空。
404表示未找到请求的任务。

获取任务的所有身份链接​

GET runtime/tasks/{taskId}/identitylinks

获取任务的所有身份链接 - URL 参数

参数是否必需值描述
taskId是String要获取其身份链接的任务的 id。

获取任务的所有身份链接 - 响应码

响应码描述
200表示已找到该任务并返回所请求的身份链接。
404表示未找到请求的任务。

成功响应体：

[
  {
    "userId" : "kermit",
    "groupId" : null,
    "type" : "candidate",
    "url" : "http://localhost:8081/flowable-rest/service/runtime/tasks/100/identitylinks/users/kermit/candidate"
  },
  {
    "userId" : null,
    "groupId" : "sales",
    "type" : "candidate",
    "url" : "http://localhost:8081/flowable-rest/service/runtime/tasks/100/identitylinks/groups/sales/candidate"
  },

  ...
]

获取任务针对组或用户的所有身份链接​

GET runtime/tasks/{taskId}/identitylinks/users
GET runtime/tasks/{taskId}/identitylinks/groups

仅返回以用户或组为目标的身份链接。响应体和状态码与获取任务完整身份链接列表时完全相同。

获取任务上的单个身份链接​

GET runtime/tasks/{taskId}/identitylinks/{family}/{identityId}/{type}

获取任务针对组或用户的所有身份链接 - URL 参数

参数是否必需值描述
taskId是String任务的 id。
family是String可为 groups 或 users，取决于目标身份的种类。
identityId是String身份的 id。
type是String身份链接的类型。

获取任务针对组或用户的所有身份链接 - 响应码

响应码描述
200表示已找到任务和身份链接并返回。
404表示未找到请求的任务，或该任务不存在所请求的 identityLink。状态中包含关于此错误的更多信息。

成功响应体：

{
  "userId" : null,
  "groupId" : "sales",
  "type" : "candidate",
  "url" : "http://localhost:8081/flowable-rest/service/runtime/tasks/100/identitylinks/groups/sales/candidate"
}

在任务上创建身份链接​

POST runtime/tasks/{taskId}/identitylinks

在任务上创建身份链接 - URL 参数

参数是否必需值描述
taskId是String任务的 id。

请求体（用户）：

{
  "userId" : "kermit",
  "type" : "candidate",
}

请求体（组）：

{
  "groupId" : "sales",
  "type" : "candidate",
}

在任务上创建身份链接 - 响应码

响应码描述
201表示已找到该任务并已创建身份链接。
404表示未找到请求的任务，或该任务不存在所请求的 identityLink。状态中包含关于此错误的更多信息。

成功响应体：

{
  "userId" : null,
  "groupId" : "sales",
  "type" : "candidate",
  "url" : "http://localhost:8081/flowable-rest/service/runtime/tasks/100/identitylinks/groups/sales/candidate"
}

删除任务上的身份链接​

DELETE runtime/tasks/{taskId}/identitylinks/{family}/{identityId}/{type}

删除任务上的身份链接 - URL 参数

参数是否必需值描述
taskId是String任务的 id。
family是String可为 groups 或 users，取决于目标身份的种类。

删除任务上的身份链接 - 响应码

响应码描述
204表示已找到任务和身份链接，并已删除该链接。响应体按设计为空。
404表示未找到请求的任务，或该任务不存在所请求的 identityLink。状态中包含关于此错误的更多信息。

在任务上创建新评论​

POST runtime/tasks/{taskId}/comments

在任务上创建新评论 - URL 参数

参数是否必需值描述
taskId是String要为其创建评论的任务的 id。

请求体：

{
  "message" : "This is a comment on the task.",
  "saveProcessInstanceId" : true
}

saveProcessInstanceId 参数是可选的；若为 true，则随评论保存任务的流程实例 id。

成功响应体：

{
  "id" : "123",
  "taskUrl" : "http://localhost:8081/flowable-rest/service/runtime/tasks/101/comments/123",
  "processInstanceUrl" : "http://localhost:8081/flowable-rest/service/history/historic-process-instances/100/comments/123",
  "message" : "This is a comment on the task.",
  "author" : "kermit",
  "time" : "2014-07-13T13:13:52.232+08:00"
  "taskId" : "101",
  "processInstanceId" : "100"
}

在任务上创建新评论 - 响应码

响应码描述
201表示评论已创建并返回结果。
400表示请求中缺少评论。
404表示未找到请求的任务。

获取任务的所有评论​

GET runtime/tasks/{taskId}/comments

获取任务的所有评论 - URL 参数

参数是否必需值描述
taskId是String要获取其评论的任务的 id。

成功响应体：

[
  {
    "id" : "123",
    "taskUrl" : "http://localhost:8081/flowable-rest/service/runtime/tasks/101/comments/123",
    "processInstanceUrl" : "http://localhost:8081/flowable-rest/service/history/historic-process-instances/100/comments/123",
    "message" : "This is a comment on the task.",
    "author" : "kermit"
    "time" : "2014-07-13T13:13:52.232+08:00"
    "taskId" : "101",
    "processInstanceId" : "100"
  },
  {
    "id" : "456",
    "taskUrl" : "http://localhost:8081/flowable-rest/service/runtime/tasks/101/comments/456",
    "processInstanceUrl" : "http://localhost:8081/flowable-rest/service/history/historic-process-instances/100/comments/456",
    "message" : "This is another comment on the task.",
    "author" : "gonzo",
    "time" : "2014-07-13T13:13:52.232+08:00"
    "taskId" : "101",
    "processInstanceId" : "100"
  }
]

获取任务的所有评论 - 响应码

响应码描述
200表示已找到该任务并返回评论。
404表示未找到请求的任务。

获取任务上的一条评论​

GET runtime/tasks/{taskId}/comments/{commentId}

获取任务上的评论 - URL 参数

参数是否必需值描述
taskId是String要为其获取评论的任务的 id。
commentId是String评论的 id。

成功响应体：

{
  "id" : "123",
  "taskUrl" : "http://localhost:8081/flowable-rest/service/runtime/tasks/101/comments/123",
  "processInstanceUrl" : "http://localhost:8081/flowable-rest/service/history/historic-process-instances/100/comments/123",
  "message" : "This is a comment on the task.",
  "author" : "kermit",
  "time" : "2014-07-13T13:13:52.232+08:00"
  "taskId" : "101",
  "processInstanceId" : "100"
}

获取任务上的评论 - 响应码

响应码描述
200表示已找到任务和评论并返回该评论。
404表示未找到请求的任务，或该任务不存在具有给定 ID 的评论。

删除任务上的评论​

DELETE runtime/tasks/{taskId}/comments/{commentId}

删除任务上的评论 - URL 参数

参数是否必需值描述
taskId是String要为其删除评论的任务的 id。
commentId是String评论的 id。

删除任务上的评论 - 响应码

响应码描述
204表示已找到任务和评论并已删除该评论。响应体按设计为空。

获取任务的所有事件​

GET runtime/tasks/{taskId}/events

获取任务的所有事件 - URL 参数

参数是否必需值描述
taskId是String要获取其事件的任务的 id。

成功响应体：

[
  {
    "action" : "AddUserLink",
    "id" : "4",
    "message" : [ "gonzo", "contributor" ],
    "taskUrl" : "http://localhost:8182/runtime/tasks/2",
    "time" : "2013-05-17T11:50:50.000+0000",
    "url" : "http://localhost:8182/runtime/tasks/2/events/4",
    "userId" : null
  }

]

获取任务的所有事件 - 响应码

响应码描述
200表示已找到该任务并返回事件。
404表示未找到请求的任务。

获取任务上的一个事件​

GET runtime/tasks/{taskId}/events/{eventId}

获取任务上的事件 - URL 参数

参数是否必需值描述
taskId是String要为其获取事件的任务的 id。
eventId是String事件的 id。

成功响应体：

{
  "action" : "AddUserLink",
  "id" : "4",
  "message" : [ "gonzo", "contributor" ],
  "taskUrl" : "http://localhost:8182/runtime/tasks/2",
  "time" : "2013-05-17T11:50:50.000+0000",
  "url" : "http://localhost:8182/runtime/tasks/2/events/4",
  "userId" : null
}

获取任务上的事件 - 响应码

响应码描述
200表示已找到任务和事件并返回该事件。
404表示未找到请求的任务，或该任务不存在具有给定 ID 的事件。

在任务上创建包含外部资源链接的新附件​

POST runtime/tasks/{taskId}/attachments

在任务上创建包含外部资源链接的新附件 - URL 参数

参数是否必需值描述
taskId是String要为其创建附件的任务的 id。

请求体：

{
  "name":"Simple attachment",
  "description":"Simple attachment description",
  "type":"simpleType",
  "externalUrl":"http://flowable.org"
}

创建新附件时，仅附件名称是必需的。

成功响应体：

{
  "id":"3",
  "url":"http://localhost:8182/runtime/tasks/2/attachments/3",
  "name":"Simple attachment",
  "description":"Simple attachment description",
  "type":"simpleType",
  "taskUrl":"http://localhost:8182/runtime/tasks/2",
  "processInstanceUrl":null,
  "externalUrl":"http://flowable.org",
  "contentUrl":null
}

在任务上创建包含外部资源链接的新附件 - 响应码

响应码描述
201表示附件已创建并返回结果。
400表示请求中缺少附件名称。
404表示未找到请求的任务。

在任务上创建带附件文件的新附件​

POST runtime/tasks/{taskId}/attachments

在任务上创建带附件文件的新附件 - URL 参数

参数是否必需值描述
taskId是String要为其创建附件的任务的 id。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带变量的二进制值。除此之外，还可以包含以下额外表单字段：

  • name：变量的必需名称。
  • description：附件的描述，可选。
  • type：附件的类型，可选。支持任意字符串或有效的 HTTP content-type。

成功响应体：

{
    "id":"5",
    "url":"http://localhost:8182/runtime/tasks/2/attachments/5",
    "name":"Binary attachment",
    "description":"Binary attachment description",
    "type":"binaryType",
    "taskUrl":"http://localhost:8182/runtime/tasks/2",
    "processInstanceUrl":null,
    "externalUrl":null,
    "contentUrl":"http://localhost:8182/runtime/tasks/2/attachments/5/content"
}

在任务上创建带附件文件的新附件 - 响应码

响应码描述
201表示附件已创建并返回结果。
400表示请求中缺少附件名称，或请求中没有文件。错误消息中包含更多信息。
404表示未找到请求的任务。

获取任务的所有附件​

GET runtime/tasks/{taskId}/attachments

获取任务的所有附件 - URL 参数

参数是否必需值描述
taskId是String要获取其附件的任务的 id。

成功响应体：

[
  {
    "id":"3",
    "url":"http://localhost:8182/runtime/tasks/2/attachments/3",
    "name":"Simple attachment",
    "description":"Simple attachment description",
    "type":"simpleType",
    "taskUrl":"http://localhost:8182/runtime/tasks/2",
    "processInstanceUrl":null,
    "externalUrl":"http://flowable.org",
    "contentUrl":null
  },
  {
    "id":"5",
    "url":"http://localhost:8182/runtime/tasks/2/attachments/5",
    "name":"Binary attachment",
    "description":"Binary attachment description",
    "type":"binaryType",
    "taskUrl":"http://localhost:8182/runtime/tasks/2",
    "processInstanceUrl":null,
    "externalUrl":null,
    "contentUrl":"http://localhost:8182/runtime/tasks/2/attachments/5/content"
  }
]

获取任务的所有附件 - 响应码

响应码描述
200表示已找到该任务并返回附件。
404表示未找到请求的任务。

获取任务上的一个附件​

GET runtime/tasks/{taskId}/attachments/{attachmentId}

获取任务上的附件 - URL 参数

参数是否必需值描述
taskId是String要为其获取附件的任务的 id。
attachmentId是String附件的 id。

成功响应体：

{
  "id":"5",
  "url":"http://localhost:8182/runtime/tasks/2/attachments/5",
  "name":"Binary attachment",
  "description":"Binary attachment description",
  "type":"binaryType",
  "taskUrl":"http://localhost:8182/runtime/tasks/2",
  "processInstanceUrl":null,
  "externalUrl":null,
  "contentUrl":"http://localhost:8182/runtime/tasks/2/attachments/5/content"
}
  • externalUrl - contentUrl：如果附件是指向外部资源的链接，则 externalUrl 包含外部内容的 URL。如果附件内容存在于 Flowable 引擎中，则 contentUrl 包含一个 URL，可从该 URL 流式获取二进制内容。
  • type：可为任意值。当包含格式合法的媒体类型（例如 application/xml、text/plain）时，二进制内容 HTTP 响应的 content-type 将设置为给定值。

获取任务上的附件 - 响应码

响应码描述
200表示已找到任务和附件并返回该附件。
404表示未找到请求的任务，或该任务不存在具有给定 ID 的附件。

获取附件的内容​

GET runtime/tasks/{taskId}/attachment/{attachmentId}/content

获取附件的内容 - URL 参数

参数是否必需值描述
taskId是String要为其获取变量数据的任务的 id。
attachmentId是String附件的 id；当附件指向外部 URL 而非 Flowable 中附加的内容时，返回 404。

获取附件的内容 - 响应码

响应码描述
200表示已找到任务和附件并返回所请求的内容。
404表示未找到请求的任务，或该任务不存在具有给定 id 的附件，或该附件没有可用的二进制流。状态消息中提供更多信息。

成功响应体：

响应体包含二进制内容。默认情况下，除非附件类型包含合法的 Content-type，否则响应的 content-type 设置为 application/octet-stream。

删除任务上的附件​

DELETE runtime/tasks/{taskId}/attachments/{attachmentId}

删除任务上的附件 - URL 参数

参数是否必需值描述
taskId是String要为其删除附件的任务的 id。
attachmentId是String附件的 id。

删除任务上的附件 - 响应码

响应码描述
204表示已找到任务和附件并已删除该附件。响应体按设计为空。
404表示未找到请求的任务，或该任务不存在具有给定 ID 的附件。

历史​

获取一个历史流程实例​

GET history/historic-process-instances/{processInstanceId}

获取历史流程实例 - 响应码

响应码描述
200表示已找到该历史流程实例。
404表示未找到该历史流程实例。

成功响应体：

{
  "id" : "5",
  "businessKey" : "myKey",
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",
  "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
  "startTime" : "2013-04-17T10:17:43.902+0000",
  "endTime" : "2013-04-18T14:06:32.715+0000",
  "durationInMillis" : 86400056,
  "startUserId" : "kermit",
  "startActivityId" : "startEvent",
  "endActivityId" : "endEvent",
  "deleteReason" : null,
  "superProcessInstanceId" : "3",
  "url" : "http://localhost:8182/history/historic-process-instances/5",
  "variables": null,
  "tenantId":null
}

历史流程实例列表​

GET history/historic-process-instances

历史流程实例列表 - URL 参数

参数是否必需值描述
processInstanceId否String历史流程实例的 id。
processDefinitionKey否String历史流程实例的流程定义 key。
processDefinitionId否String历史流程实例的流程定义 id。
businessKey否String历史流程实例的业务键。
involvedUser否String历史流程实例的参与用户。
finished否Boolean指示历史流程实例是否已结束。
superProcessInstanceId否String历史流程实例的可选上级流程 id。
excludeSubprocesses否Boolean仅返回不是子流程的历史流程实例。
finishedAfter否Date仅返回在此日期之后结束的历史流程实例。
finishedBefore否Date仅返回在此日期之前结束的历史流程实例。
startedAfter否Date仅返回在此日期之后启动的历史流程实例。
startedBefore否Date仅返回在此日期之前启动的历史流程实例。
startedBy否String仅返回由此用户启动的历史流程实例。
includeProcessVariables否Boolean指示是否同时返回历史流程实例变量。
tenantId否String仅返回具有给定 tenantId 的实例。
tenantIdLike否String仅返回 tenantId 类似于给定值的实例。
withoutTenantId否Boolean若为 true，仅返回未设置 tenantId 的实例。若为 false，则忽略 withoutTenantId 参数。

历史流程实例列表 - 响应码

响应码描述
200表示可查询历史流程实例。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "businessKey" : "myKey",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "startUserId" : "kermit",
      "startActivityId" : "startEvent",
      "endActivityId" : "endEvent",
      "deleteReason" : null,
      "superProcessInstanceId" : "3",
      "url" : "http://localhost:8182/history/historic-process-instances/5",
      "variables": [
        {
          "name": "test",
          "variableScope": "local",
          "value": "myTest"
        }
      ],
      "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史流程实例​

POST query/historic-process-instances

请求体：

{
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",


  "variables" : [
    {
      "name" : "myVariable",
      "value" : 1234,
      "operation" : "equals",
      "type" : "long"
    }
  ]
}

所有允许的 JSON 参数字段与获取历史流程实例集合中的参数完全相同，但以 JSON 请求体参数而非 URL 参数传递，以支持更高级的查询，并避免请求 URI 过长导致的错误。除此之外，该查询还允许基于流程变量进行过滤。variables 属性是一个 JSON 数组，其中对象的格式如此处所说明。

查询历史流程实例 - 响应码

响应码描述
200表示请求成功，并已返回任务。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "businessKey" : "myKey",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "startUserId" : "kermit",
      "startActivityId" : "startEvent",
      "endActivityId" : "endEvent",
      "deleteReason" : null,
      "superProcessInstanceId" : "3",
      "url" : "http://localhost:8182/history/historic-process-instances/5",
      "variables": [
        {
          "name": "test",
          "variableScope": "local",
          "value": "myTest"
        }
      ],
      "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

删除一个历史流程实例​

DELETE history/historic-process-instances/{processInstanceId}

响应码

响应码描述
200表示历史流程实例已删除。
404表示未找到该历史流程实例。

获取历史流程实例的身份链接​

GET history/historic-process-instance/{processInstanceId}/identitylinks

响应码

响应码描述
200表示请求成功，并返回身份链接。
404表示未找到该流程实例。

成功响应体：

[
 {
  "type" : "participant",
  "userId" : "kermit",
  "groupId" : null,
  "taskId" : null,
  "taskUrl" : null,
  "processInstanceId" : "5",
  "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5"
 }
]

获取历史流程实例变量的二进制数据​

GET history/historic-process-instances/{processInstanceId}/variables/{variableName}/data

获取历史流程实例变量的二进制数据 - 响应码

响应码描述
200表示已找到该流程实例并返回所请求的变量数据。
404表示未找到请求的流程实例，或该流程实例不存在具有给定名称的变量，或该变量没有可用的二进制流。状态消息中提供更多信息。

成功响应体：

响应体包含该变量的二进制值。当变量为 binary 类型时，无论变量内容或请求的 accept-type 请求头如何，响应的 content-type 都设置为 application/octet-stream。对于 serializable 类型，则使用 application/x-java-serialized-object 作为 content-type。

在历史流程实例上创建新评论​

POST history/historic-process-instances/{processInstanceId}/comments

在历史流程实例上创建新评论 - URL 参数

参数是否必需值描述
processInstanceId是String要为其创建评论的流程实例的 id。

请求体：

{
  "message" : "This is a comment.",
  "saveProcessInstanceId" : true
}

saveProcessInstanceId 参数是可选的；若为 true，则随评论保存任务的流程实例 id。

成功响应体：

{
  "id" : "123",
  "taskUrl" : "http://localhost:8081/flowable-rest/service/runtime/tasks/101/comments/123",
  "processInstanceUrl" : "http://localhost:8081/flowable-rest/service/history/historic-process-instances/100/comments/123",
  "message" : "This is a comment on the task.",
  "author" : "kermit",
  "time" : "2014-07-13T13:13:52.232+08:00",
  "taskId" : "101",
  "processInstanceId" : "100"
}

在历史流程实例上创建新评论 - 响应码

响应码描述
201表示评论已创建并返回结果。
400表示请求中缺少评论。
404表示未找到请求的历史流程实例。

获取历史流程实例的所有评论​

GET history/historic-process-instances/{processInstanceId}/comments

获取流程实例的所有评论 - URL 参数

参数是否必需值描述
processInstanceId是String要为其获取评论的流程实例的 id。

成功响应体：

[
  {
    "id" : "123",
    "processInstanceUrl" : "http://localhost:8081/flowable-rest/service/history/historic-process-instances/100/comments/123",
    "message" : "This is a comment on the task.",
    "author" : "kermit",
    "time" : "2014-07-13T13:13:52.232+08:00",
    "processInstanceId" : "100"
  },
  {
    "id" : "456",
    "processInstanceUrl" : "http://localhost:8081/flowable-rest/service/history/historic-process-instances/100/comments/456",
    "message" : "This is another comment.",
    "author" : "gonzo",
    "time" : "2014-07-14T15:16:52.232+08:00",
    "processInstanceId" : "100"
  }
]

获取流程实例的所有评论 - 响应码

响应码描述
200表示已找到该流程实例并返回评论。
404表示未找到请求的任务。

获取历史流程实例上的一条评论​

GET history/historic-process-instances/{processInstanceId}/comments/{commentId}

获取历史流程实例上的评论 - URL 参数

参数是否必需值描述
processInstanceId是String要为其获取评论的历史流程实例的 id。
commentId是String评论的 id。

成功响应体：

{
  "id" : "123",
  "processInstanceUrl" : "http://localhost:8081/flowable-rest/service/history/historic-process-instances/100/comments/456",
  "message" : "This is another comment.",
  "author" : "gonzo",
  "time" : "2014-07-14T15:16:52.232+08:00",
  "processInstanceId" : "100"
}

获取历史流程实例上的评论 - 响应码

响应码描述
200表示已找到历史流程实例和评论并返回该评论。
404表示未找到请求的历史流程实例，或该历史流程实例不存在具有给定 ID 的评论。

删除历史流程实例上的评论​

DELETE history/historic-process-instances/{processInstanceId}/comments/{commentId}

删除历史流程实例上的评论 - URL 参数

参数是否必需值描述
processInstanceId是String要为其删除评论的历史流程实例的 id。
commentId是String评论的 id。

删除历史流程实例上的评论 - 响应码

响应码描述
204表示已找到历史流程实例和评论并已删除该评论。响应体按设计为空。
404表示未找到请求的任务，或该历史流程实例不存在具有给定 ID 的评论。

获取单个历史任务实例​

GET history/historic-task-instances/{taskId}

获取单个历史任务实例 - 响应码

响应码描述
200表示已找到该历史任务实例。
404表示未找到该历史任务实例。

成功响应体：

{
  "id" : "5",
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",
  "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
  "processInstanceId" : "3",
  "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
  "executionId" : "4",
  "name" : "My task name",
  "description" : "My task description",
  "deleteReason" : null,
  "owner" : "kermit",
  "assignee" : "fozzie",
  "startTime" : "2013-04-17T10:17:43.902+0000",
  "endTime" : "2013-04-18T14:06:32.715+0000",
  "durationInMillis" : 86400056,
  "workTimeInMillis" : 234890,
  "claimTime" : "2013-04-18T11:01:54.715+0000",
  "taskDefinitionKey" : "taskKey",
  "formKey" : null,
  "priority" : 50,
  "dueDate" : "2013-04-20T12:11:13.134+0000",
  "parentTaskId" : null,
  "url" : "http://localhost:8182/history/historic-task-instances/5",
  "variables": null,
  "tenantId":null
}

获取历史任务实例​

GET history/historic-task-instances

获取历史任务实例 - URL 参数

参数是否必需值描述
taskId否String历史任务实例的 id。
processInstanceId否String历史任务实例的流程实例 id。
processDefinitionKey否String历史任务实例的流程定义 key。
processDefinitionKeyLike否String历史任务实例的流程定义 key，匹配给定值。
processDefinitionId否String历史任务实例的流程定义 id。
processDefinitionName否String历史任务实例的流程定义名称。
processDefinitionNameLike否String历史任务实例的流程定义名称，匹配给定值。
processBusinessKey否String历史任务实例的流程实例业务键。
processBusinessKeyLike否String历史任务实例的流程实例业务键，匹配给定值。
executionId否String历史任务实例的执行 id。
taskDefinitionKey否String属于某流程的任务的任务定义 key。
taskName否String历史任务实例的任务名称。
taskNameLike否String对历史任务实例使用 'like' 运算符的任务名称。
taskDescription否String历史任务实例的任务描述。
taskDescriptionLike否String对历史任务实例使用 'like' 运算符的任务描述。
taskDefinitionKey否String历史任务实例在流程定义中的任务标识符。
taskCategory否String选择具有给定类别的任务。注意这是任务类别，而非流程定义的类别（BPMN Xml 中的命名空间）。
taskDeleteReason否String历史任务实例的任务删除原因。
taskDeleteReasonLike否String对历史任务实例使用 'like' 运算符的任务删除原因。
taskAssignee否String历史任务实例的办理人。
taskAssigneeLike否String对历史任务实例使用 'like' 运算符的办理人。
taskOwner否String历史任务实例的所有者。
taskOwnerLike否String对历史任务实例使用 'like' 运算符的所有者。
taskInvolvedUser否String历史任务实例的参与用户。
taskPriority否String历史任务实例的优先级。
finished否Boolean指示历史任务实例是否已结束。
processFinished否Boolean指示历史任务实例所属流程实例是否已结束。
parentTaskId否String历史任务实例的可选上级任务 id。
dueDate否Date仅返回到期日等于此日期的历史任务实例。
dueDateAfter否Date仅返回到期日在此日期之后的历史任务实例。
dueDateBefore否Date仅返回到期日在此日期之前的历史任务实例。
withoutDueDate否Boolean仅返回没有到期日的历史任务实例。若值为 false，则忽略此参数。
taskCompletedOn否Date仅返回在此日期完成的历史任务实例。
taskCompletedAfter否Date仅返回在此日期之后完成的历史任务实例。
taskCompletedBefore否Date仅返回在此日期之前完成的历史任务实例。
taskCreatedOn否Date仅返回在此日期创建的历史任务实例。
taskCreatedBefore否Date仅返回在此日期之前创建的历史任务实例。
taskCreatedAfter否Date仅返回在此日期之后创建的历史任务实例。
includeTaskLocalVariables否Boolean指示是否同时返回历史任务实例的局部变量。
includeProcessVariables否Boolean指示是否同时返回历史任务实例的全局变量。
tenantId否String仅返回具有给定 tenantId 的历史任务实例。
tenantIdLike否String仅返回 tenantId 类似于给定值的历史任务实例。
withoutTenantId否Boolean若为 true，仅返回未设置 tenantId 的历史任务实例。若为 false，则忽略 withoutTenantId 参数。

获取历史任务实例 - 响应码

响应码描述
200表示可查询历史流程实例。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceId" : "3",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
      "executionId" : "4",
      "name" : "My task name",
      "description" : "My task description",
      "deleteReason" : null,
      "owner" : "kermit",
      "assignee" : "fozzie",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "workTimeInMillis" : 234890,
      "claimTime" : "2013-04-18T11:01:54.715+0000",
      "taskDefinitionKey" : "taskKey",
      "formKey" : null,
      "priority" : 50,
      "dueDate" : "2013-04-20T12:11:13.134+0000",
      "parentTaskId" : null,
      "url" : "http://localhost:8182/history/historic-task-instances/5",
      "taskVariables": [
        {
          "name": "test",
          "variableScope": "local",
          "value": "myTest"
        }
      ],
      "processVariables": [
        {
          "name": "processTest",
          "variableScope": "global",
          "value": "myProcessTest"
        }
      ],
      "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史任务实例​

POST query/historic-task-instances

查询历史任务实例 - 请求体：

{
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",
  ...

  "variables" : [
    {
      "name" : "myVariable",
      "value" : 1234,
      "operation" : "equals",
      "type" : "long"
    }
  ]
}

所有允许的 JSON 参数字段与获取历史任务实例集合中的参数完全相同，但以 JSON 请求体参数而非 URL 参数传递，以支持更高级的查询，并避免请求 URI 过长导致的错误。除此之外，该查询还允许基于流程变量进行过滤。taskVariables 和 processVariables 属性是 JSON 数组，其中对象的格式如此处所说明。

查询历史任务实例 - 响应码

响应码描述
200表示请求成功，并已返回任务。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceId" : "3",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
      "executionId" : "4",
      "name" : "My task name",
      "description" : "My task description",
      "deleteReason" : null,
      "owner" : "kermit",
      "assignee" : "fozzie",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "workTimeInMillis" : 234890,
      "claimTime" : "2013-04-18T11:01:54.715+0000",
      "taskDefinitionKey" : "taskKey",
      "formKey" : null,
      "priority" : 50,
      "dueDate" : "2013-04-20T12:11:13.134+0000",
      "parentTaskId" : null,
      "url" : "http://localhost:8182/history/historic-task-instances/5",
      "taskVariables": [
        {
          "name": "test",
          "variableScope": "local",
          "value": "myTest"
        }
      ],
      "processVariables": [
        {
          "name": "processTest",
          "variableScope": "global",
          "value": "myProcessTest"
        }
      ],
      "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

删除一个历史任务实例​

DELETE history/historic-task-instances/{taskId}

响应码

响应码描述
200表示历史任务实例已删除。
404表示未找到该历史任务实例。

获取历史任务实例的身份链接​

GET history/historic-task-instance/{taskId}/identitylinks

响应码

响应码描述
200表示请求成功，并返回身份链接。
404表示未找到该任务实例。

成功响应体：

[
 {
  "type" : "assignee",
  "userId" : "kermit",
  "groupId" : null,
  "taskId" : "6",
  "taskUrl" : "http://localhost:8182/history/historic-task-instances/5",
  "processInstanceId" : null,
  "processInstanceUrl" : null
 }
]

获取历史任务实例变量的二进制数据​

GET history/historic-task-instances/{taskId}/variables/{variableName}/data

获取历史任务实例变量的二进制数据 - 响应码

响应码描述
200表示已找到该任务实例并返回所请求的变量数据。
404表示未找到请求的任务实例，或该流程实例不存在具有给定名称的变量，或该变量没有可用的二进制流。状态消息中提供更多信息。

成功响应体：

响应体包含该变量的二进制值。当变量为 binary 类型时，无论变量内容或请求的 accept-type 请求头如何，响应的 content-type 都设置为 application/octet-stream。对于 serializable 类型，则使用 application/x-java-serialized-object 作为 content-type。

获取历史活动实例​

GET history/historic-activity-instances

获取历史活动实例 - URL 参数

参数是否必需值描述
activityId否String活动实例的 id。
activityInstanceId否String历史活动实例的 id。
activityName否String历史活动实例的名称。
activityType否String历史活动实例的元素类型。
executionId否String历史活动实例的执行 id。
finished否Boolean指示历史活动实例是否已结束。
taskAssignee否String历史活动实例的办理人。
processInstanceId否String历史活动实例的流程实例 id。
processDefinitionId否String历史活动实例的流程定义 id。
tenantId否String仅返回具有给定 tenantId 的实例。
tenantIdLike否String仅返回 tenantId 类似于给定值的实例。
withoutTenantId否Boolean若为 true，仅返回未设置 tenantId 的实例。若为 false，则忽略 withoutTenantId 参数。

获取历史活动实例 - 响应码

响应码描述
200表示可查询历史活动实例。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "activityId" : "4",
      "activityName" : "My user task",
      "activityType" : "userTask",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceId" : "3",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
      "executionId" : "4",
      "taskId" : "4",
      "calledProcessInstanceId" : null,
      "assignee" : "fozzie",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史活动实例​

POST query/historic-activity-instances

请求体：

{
  "processDefinitionId" : "oneTaskProcess%3A1%3A4"
}

所有允许的 JSON 参数字段与获取历史任务实例集合中的参数完全相同，但以 JSON 请求体参数而非 URL 参数传递，以支持更高级的查询，并避免请求 URI 过长导致的错误。

查询历史活动实例 - 响应码

响应码描述
200表示请求成功，并已返回活动。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "activityId" : "4",
      "activityName" : "My user task",
      "activityType" : "userTask",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceId" : "3",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
      "executionId" : "4",
      "taskId" : "4",
      "calledProcessInstanceId" : null,
      "assignee" : "fozzie",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

历史变量实例列表​

GET history/historic-variable-instances

历史变量实例列表 - URL 参数

参数是否必需值描述
processInstanceId否String历史变量实例的流程实例 id。
taskId否String历史变量实例的任务 id。
excludeTaskVariables否Boolean指示是否从结果中排除任务变量。
variableName否String历史变量实例的变量名称。
variableNameLike否String对历史变量实例使用 'like' 运算符的变量名称。

历史变量实例列表 - 响应码

响应码描述
200表示可查询历史变量实例。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "14",
      "processInstanceId" : "5",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5",
      "taskId" : "6",
      "variable" : {
        "name" : "myVariable",
        "variableScope": "global",
        "value" : "test"
      }
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史变量实例​

POST query/historic-variable-instances

请求体：

{
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",
  ...

  "variables" : [
    {
      "name" : "myVariable",
      "value" : 1234,
      "operation" : "equals",
      "type" : "long"
    }
  ]
}

所有允许的 JSON 参数字段与获取历史流程实例集合中的参数完全相同，但以 JSON 请求体参数而非 URL 参数传递，以支持更高级的查询，并避免请求 URI 过长导致的错误。除此之外，该查询还允许基于流程变量进行过滤。variables 属性是一个 JSON 数组，其中对象的格式如此处所说明。

查询历史变量实例 - 响应码

响应码描述
200表示请求成功，并已返回任务。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "14",
      "processInstanceId" : "5",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5",
      "taskId" : "6",
      "variable" : {
        "name" : "myVariable",
        "variableScope": "global",
        "value" : "test"
      }
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

====获取历史任务实例变量的二进制数据

GET history/historic-variable-instances/{varInstanceId}/data

获取历史任务实例变量的二进制数据 - 响应码

响应码描述
200表示已找到该变量实例并返回所请求的变量数据。
404表示未找到请求的变量实例，或该变量实例不存在具有给定名称的变量，或该变量没有可用的二进制流。状态消息中提供更多信息。

成功响应体：

响应体包含该变量的二进制值。当变量为 binary 类型时，无论变量内容或请求的 accept-type 请求头如何，响应的 content-type 都设置为 application/octet-stream。对于 serializable 类型，则使用 application/x-java-serialized-object 作为 content-type。

获取历史明细​

GET history/historic-detail

获取历史明细 - URL 参数

参数是否必需值描述
id否String历史明细的 id。
processInstanceId否String历史明细的流程实例 id。
executionId否String历史明细的执行 id。
activityInstanceId否String历史明细的活动实例 id。
taskId否String历史明细的任务 id。
selectOnlyFormProperties否Boolean指示结果中仅返回表单属性。
selectOnlyVariableUpdates否Boolean指示结果中仅返回变量更新。

获取历史明细 - 响应码

响应码描述
200表示可查询历史明细。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "26",
      "processInstanceId" : "5",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5",
      "executionId" : "6",
      "activityInstanceId", "10",
      "taskId" : "6",
      "taskUrl" : "http://localhost:8182/history/historic-task-instances/6",
      "time" : "2013-04-17T10:17:43.902+0000",
      "detailType" : "variableUpdate",
      "revision" : 2,
      "variable" : {
        "name" : "myVariable",
        "variableScope": "global",
        "value" : "test"
      },
      "propertyId": null,
      "propertyValue": null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史明细​

POST query/historic-detail

请求体：

{
  "processInstanceId" : "5",
}

所有允许的 JSON 参数字段与获取历史流程实例集合中的参数完全相同，但以 JSON 请求体参数而非 URL 参数传递，以支持更高级的查询，并避免请求 URI 过长导致的错误。

查询历史明细 - 响应码

响应码描述
200表示请求成功，并已返回历史明细。
400表示参数格式错误。状态消息中包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "26",
      "processInstanceId" : "5",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5",
      "executionId" : "6",
      "activityInstanceId", "10",
      "taskId" : "6",
      "taskUrl" : "http://localhost:8182/history/historic-task-instances/6",
      "time" : "2013-04-17T10:17:43.902+0000",
      "detailType" : "variableUpdate",
      "revision" : 2,
      "variable" : {
        "name" : "myVariable",
        "variableScope": "global",
        "value" : "test"
      },
      "propertyId" : null,
      "propertyValue" : null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

获取历史明细变量的二进制数据​

GET history/historic-detail/{detailId}/data

获取历史明细变量的二进制数据 - 响应码

响应码描述
200表示已找到该历史明细实例并返回所请求的变量数据。
404表示未找到请求的历史明细实例，或该历史明细实例不存在具有给定名称的变量，或该变量没有可用的二进制流。状态消息中提供更多信息。

成功响应体：

响应体包含该变量的二进制值。当变量为 binary 类型时，无论变量内容或请求的 accept-type 请求头如何，响应的 content-type 都设置为 application/octet-stream。对于 serializable 类型，则使用 application/x-java-serialized-object 作为 content-type。

表单​

获取表单数据​

GET form/form-data

获取表单数据 - URL 参数

参数是否必需值描述
taskId是（若无 processDefinitionId）String与需获取的表单数据相对应的任务 id。
processDefinitionId是（若无 taskId）String与需获取的启动事件表单数据相对应的流程定义 id。

获取表单数据 - 响应码

响应码描述
200表示可查询表单数据。
404表示未找到该表单数据。

成功响应体：

{
  "data": [
    {
      "formKey" : null,
      "deploymentId" : "2",
      "processDefinitionId" : "3",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definition/3",
      "taskId" : "6",
      "taskUrl" : "http://localhost:8182/runtime/task/6",
      "formProperties" : [
        {
          "id" : "room",
          "name" : "Room",
          "type" : "string",
          "value" : null,
          "readable" : true,
          "writable" : true,
          "required" : true,
          "datePattern" : null,
          "enumValues" : [
            {
              "id" : "normal",
              "name" : "Normal bed"
            },
            {
              "id" : "kingsize",
              "name" : "Kingsize bed"
            },
          ]
        }
      ]
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

提交任务表单数据​

POST form/form-data

任务表单的请求体：

{
  "taskId" : "5",
  "properties" : [
    {
      "id" : "room",
      "value" : "normal"
    }
  ]
}

启动事件表单的请求体：

{
  "processDefinitionId" : "5",
  "businessKey" : "myKey",
  "properties" : [
    {
      "id" : "room",
      "value" : "normal"
    }
  ]
}

提交任务表单数据 - 响应码

响应码描述
200表示请求成功，并已提交表单数据。
400表示参数格式错误。状态消息中包含更多信息。

启动事件表单数据的成功响应体（任务表单数据无响应）：

{
  "id" : "5",
  "url" : "http://localhost:8182/history/historic-process-instances/5",
  "businessKey" : "myKey",
  "suspended": false,
  "processDefinitionId" : "3",
  "processDefinitionUrl" : "http://localhost:8182/repository/process-definition/3",
  "activityId" : "myTask"
}

数据库表​

表列表​

GET management/tables

表列表 - 响应码

响应码描述
200表示请求成功。

成功响应体：

[
   {
      "name":"ACT_RU_VARIABLE",
      "url":"http://localhost:8182/management/tables/ACT_RU_VARIABLE",
      "count":4528
   },
   {
      "name":"ACT_RU_EVENT_SUBSCR",
      "url":"http://localhost:8182/management/tables/ACT_RU_EVENT_SUBSCR",
      "count":3
   }

]

获取单个表​

GET management/tables/{tableName}

获取单个表 - URL 参数

参数是否必需值描述
tableName是String要获取的表的名称。

成功响应体：

{
      "name":"ACT_RE_PROCDEF",
      "url":"http://localhost:8182/management/tables/ACT_RE_PROCDEF",
      "count":60
}

获取单个表 - 响应码

响应码描述
200表示该表存在，并返回表的行数。
404表示请求的表不存在。

获取单个表的列信息​

GET management/tables/{tableName}/columns

获取单个表的列信息 - URL 参数

参数是否必需值描述
tableName是String要获取的表的名称。

成功响应体：

{
   "tableName":"ACT_RU_VARIABLE",
   "columnNames":[
      "ID_",
      "REV_",
      "TYPE_",
      "NAME_"


   ],
   "columnTypes":[
      "VARCHAR",
      "INTEGER",
      "VARCHAR",
      "VARCHAR"


   ]
}

获取单个表的列信息 - 响应码

响应码描述
200表示该表存在，并返回表的列信息。
404表示请求的表不存在。

获取单个表的行数据​

GET management/tables/{tableName}/data

获取单个表的行数据 - URL 参数

参数是否必需值描述
tableName是String要获取的表的名称。

获取单个表的行数据 - URL 查询参数

参数是否必需值描述
start否Integer要获取的第一行的索引。默认为 0。
size否Integer从 start 开始要获取的行数。默认为 10。
orderAscendingColumn否String对结果行进行升序排序所依据的列名。
orderDescendingColumn否String对结果行进行降序排序所依据的列名。

成功响应体：

{
  "total":3,
   "start":0,
   "sort":null,
   "order":null,
   "size":3,

   "data":[
      {
         "TASK_ID_":"2",
         "NAME_":"var1",
         "REV_":1,
         "TEXT_":"123",
         "LONG_":123,
         "ID_":"3",
         "TYPE_":"integer"
      }



   ]

}

获取单个表的行数据 - 响应码

响应码描述
200表示该表存在，并返回表的行数据。
404表示请求的表不存在。

引擎​

获取引擎属性​

GET management/properties

返回引擎内部所使用属性的只读视图。

成功响应体：

{
   "next.dbid":"101",
   "schema.history":"create(5.15)",
   "schema.version":"5.15"
}

获取引擎属性 - 响应码

响应码描述
200表示已返回属性。

获取引擎信息​

GET management/engine

返回此 REST 服务所使用引擎的只读视图。

成功响应体：

{
   "name":"default",
   "version":"5.15",
   "resourceUrl":"file://flowable/flowable.cfg.xml",
   "exception":null
}

获取引擎信息 - 响应码

响应码描述
200表示已返回引擎信息。

运行时​

接收到信号事件​

POST runtime/signals

通知引擎已接收到一个信号事件，该信号不明确关联到某个特定执行实例。

Body JSON：

{
  "signalName": "My Signal",
  "tenantId" : "execute",
  "async": true,
  "variables": [
      {"name": "testVar", "value": "This is a string"}

  ]
}

接收到信号事件 - JSON Body 参数

参数描述是否必需
signalName信号的名称是
tenantId应处理该信号事件的租户 ID否
async若为 true，信号的处理将异步进行。返回码为 202 - Accepted，表示请求已接受但尚未执行。若为 false，信号将被立即处理，只有成功完成后才返回结果（200 - OK）。省略时默认为 false。否
variables变量数组（采用通用变量格式），作为随信号传递的载荷。当 async 设置为 true 时不能使用，否则将导致错误。否

成功响应体：

接收到信号事件 - 响应码

响应码描述
200表示信号已处理且未发生错误。
202表示信号处理已作为作业排队，等待执行。
400信号未处理。缺少信号名称，或 variables 与 async 一起使用（不允许）。响应体中包含关于该错误的更多信息。

作业​

获取单个作业​

GET management/jobs/{jobId}

获取单个作业 - URL 参数

参数是否必需值描述
jobId是String要获取的作业的 id。

成功响应体：

{
   "id":"8",
   "url":"http://localhost:8182/management/jobs/8",
   "processInstanceId":"5",
   "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
   "processDefinitionId":"timerProcess:1:4",
   "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/timerProcess%3A1%3A4",
   "executionId":"7",
   "executionUrl":"http://localhost:8182/runtime/executions/7",
   "retries":3,
   "exceptionMessage":null,
   "dueDate":"2013-06-04T22:05:05.474+0000",
   "tenantId":null
}

获取单个作业 - 响应码

响应码描述
200表示该作业存在并已返回。
404表示请求的作业不存在。

删除一个作业​

DELETE management/jobs/{jobId}

删除作业 - URL 参数

参数是否必需值描述
jobId是String要删除的作业的 id。

删除作业 - 响应码

响应码描述
204表示已找到该作业并已删除。响应体按设计为空。
404表示未找到请求的作业。

执行单个作业​

POST management/jobs/{jobId}

Body JSON：

{
  "action" : "execute"
}

执行单个作业 - JSON Body 参数

参数描述是否必需
action要执行的操作。仅支持 execute。是

执行单个作业 - 响应码

响应码描述
204表示作业已执行。响应体按设计为空。
404表示未找到请求的作业。
500表示执行作业时发生异常。状态描述中包含关于该错误的更多细节。如有需要，之后可获取完整的错误堆栈。

获取作业的异常堆栈​

GET management/jobs/{jobId}/exception-stacktrace

获取作业的异常堆栈 - URL 参数

参数描述是否必需
jobId要为其获取堆栈的作业的 id。是

获取作业的异常堆栈 - 响应码

响应码描述
200表示已找到请求的作业并返回堆栈。响应包含原始堆栈，且 Content-type 始终为 text/plain。
404表示未找到请求的作业，或该作业没有异常堆栈。状态描述中包含关于该错误的更多信息。

获取作业列表​

GET management/jobs

获取作业列表 - URL 查询参数

参数描述类型
id仅返回具有给定 id 的作业String
processInstanceId仅返回属于具有给定 id 的流程的作业String
executionId仅返回属于具有给定 id 的执行实例的作业String
processDefinitionId仅返回具有给定流程定义 id 的作业String
withRetriesLeft若为 true，仅返回尚有剩余重试次数的作业。若为 false，则忽略此参数。Boolean
executable若为 true，仅返回可执行的作业。若为 false，则忽略此参数。Boolean
timersOnly若为 true，仅返回定时器作业。若为 false，则忽略此参数。不能与 'messagesOnly' 同时使用。Boolean
messagesOnly若为 true，仅返回消息作业。若为 false，则忽略此参数。不能与 'timersOnly' 同时使用。Boolean
withException若为 true，仅返回执行时发生过异常的作业。若为 false，则忽略此参数。Boolean
dueBefore仅返回应在此日期之前执行的作业。使用此参数时，不返回到期日的作业。Date
dueAfter仅返回应在此日期之后执行的作业。使用此参数时，不返回到期日的作业。Date
exceptionMessage仅返回具有给定异常消息的作业String
tenantId仅返回具有给定 tenantId 的作业。String
tenantIdLike仅返回 tenantId 类似于给定值的作业。String
withoutTenantId若为 true，仅返回未设置 tenantId 的作业。若为 false，则忽略 withoutTenantId 参数。Boolean
withoutScopeType若为 true，仅返回未设置 scope 类型的作业。若为 false，则忽略 withoutScopeType 参数。Boolean
sort结果排序所依据的字段，应为 id、dueDate、executionId、processInstanceId、retries 或 tenantId 之一。String

成功响应体：

{
   "data":[
      {
         "id":"13",
         "url":"http://localhost:8182/management/jobs/13",
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "processDefinitionId":"timerProcess:1:4",
         "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/timerProcess%3A1%3A4",
         "executionId":"12",
         "executionUrl":"http://localhost:8182/runtime/executions/12",
         "retries":0,
         "exceptionMessage":"Can't find scripting engine for 'unexistinglanguage'",
         "dueDate":"2013-06-07T10:00:24.653+0000",
         "tenantId":null
      }



   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

获取作业列表 - 响应码

响应码描述
200表示已返回所请求的作业。
400表示 URL 查询参数使用了非法值，或同时使用了 'messagesOnly' 和 'timersOnly' 两个参数。状态描述中包含关于该错误的更多细节。

获取单个死信作业​

GET management/deadletter-jobs/{jobId}

获取单个死信作业 - URL 参数

参数是否必需值描述
jobId是String要获取的死信作业的 id。

成功响应体：

{
   "id":"8",
   "url":"http://localhost:8182/management/jobs/8",
   "processInstanceId":"5",
   "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
   "processDefinitionId":"timerProcess:1:4",
   "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/timerProcess%3A1%3A4",
   "executionId":"7",
   "executionUrl":"http://localhost:8182/runtime/executions/7",
   "retries":0,
   "exceptionMessage":"Can't find scripting engine for 'unexistinglanguage'",
   "dueDate":"2013-06-04T22:05:05.474+0000",
   "tenantId":null
}

获取单个死信作业 - 响应码

响应码描述
200表示该死信作业存在并已返回。
404表示请求的死信作业不存在。

删除一个死信作业​

DELETE management/deadletter-jobs/{jobId}

删除死信作业 - URL 参数

参数是否必需值描述
jobId是String要删除的死信作业的 id。

删除死信作业 - 响应码

响应码描述
204表示已找到该死信作业并已删除。响应体按设计为空。
404表示未找到请求的死信作业。

恢复并执行一个死信作业​

POST management/deadletter-jobs/{jobId}

Body JSON：

{
  "action" : "move"
}

恢复并执行死信作业 - JSON Body 参数

参数描述是否必需
action要执行的操作。仅支持 execute。是

恢复并执行死信作业 - 响应码

响应码描述
204表示死信作业已执行。响应体按设计为空。
404表示未找到请求的死信作业。
500表示执行死信作业时发生异常。状态描述中包含关于该错误的更多细节。如有需要，之后可获取完整的错误堆栈。

获取死信作业的异常堆栈​

GET management/deadletter-jobs/{jobId}/exception-stacktrace

获取死信作业的异常堆栈 - URL 参数

参数描述是否必需
jobId要为其获取堆栈的死信作业的 id。是

获取死信作业的异常堆栈 - 响应码

响应码描述
200表示已找到请求的死信作业并返回堆栈。响应包含原始堆栈，且 Content-type 始终为 text/plain。
404表示未找到请求的死信作业，或该作业没有异常堆栈。状态描述中包含关于该错误的更多信息。

获取死信作业列表​

GET management/deadletter-jobs

获取死信作业列表 - URL 查询参数

参数描述类型
id仅返回具有给定 id 的作业String
processInstanceId仅返回属于具有给定 id 的流程的作业String
executionId仅返回属于具有给定 id 的执行实例的作业String
processDefinitionId仅返回具有给定流程定义 id 的作业String
executable若为 true，仅返回可执行的作业。若为 false，则忽略此参数。Boolean
timersOnly若为 true，仅返回定时器作业。若为 false，则忽略此参数。不能与 'messagesOnly' 同时使用。Boolean
messagesOnly若为 true，仅返回消息作业。若为 false，则忽略此参数。不能与 'timersOnly' 同时使用。Boolean
withException若为 true，仅返回执行时发生过异常的作业。若为 false，则忽略此参数。Boolean
dueBefore仅返回应在此日期之前执行的作业。使用此参数时，不返回到期日的作业。Date
dueAfter仅返回应在此日期之后执行的作业。使用此参数时，不返回到期日的作业。Date
withException若为 true，仅返回执行时发生过异常的作业。若为 false，则忽略此参数。Boolean
tenantIdString仅返回具有异常的作业。
tenantIdLikeString仅返回 tenantId 类似于给定值的作业。
withoutTenantIdBoolean若为 true，仅返回未设置 tenantId 的作业。若为 false，则忽略此参数。
lockedBoolean若为 true，仅返回已锁定的作业。若为 false，则忽略此参数。
unlockedBoolean若为 true，仅返回未锁定的作业。若为 false，则忽略此参数。
withoutScopeTypeBoolean若为 true，仅返回未设置 scope 类型的作业。若为 false，则忽略 withoutScopeType 参数。
sort结果排序所依据的字段，应为 id、dueDate、executionId、processInstanceId、retries 或 tenantId 之一。String

成功响应体：

{
   "data":[
      {
         "id":"13",
         "url":"http://localhost:8182/management/jobs/13",
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "processDefinitionId":"timerProcess:1:4",
         "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/timerProcess%3A1%3A4",
         "executionId":"12",
         "executionUrl":"http://localhost:8182/runtime/executions/12",
         "retries":0,
         "withException":"Can't find scripting engine for 'unexistinglanguage'",
         "dueDate":"2013-06-07T10:00:24.653+0000",
         "createTime":"2013-06-06T08:08:24.007+0000"
         "tenantId":null
      }
   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

获取死信作业列表 - 响应码

响应码描述
200表示已返回所请求的作业。
400表示 URL 查询参数使用了非法值，或同时使用了 'messagesOnly' 和 'timersOnly' 两个参数。状态描述中包含关于该错误的更多细节。

用户​

获取单个用户​

GET identity/users/{userId}

获取单个用户 - URL 参数

参数是否必需值描述
userId是String要获取的用户的 id。

成功响应体：

{
   "id":"testuser",
   "firstName":"Fred",
   "lastName":"McDonald",
   "url":"http://localhost:8182/identity/users/testuser",
   "email":"no-reply@flowable.org"
}

获取单个用户 - 响应码

响应码描述
200表示该用户存在并已返回。
404表示请求的用户不存在。

获取用户列表​

GET identity/users

获取用户列表 - URL 查询参数

参数描述类型
id仅返回具有给定 id 的用户String
firstName仅返回具有给定名字的用户String
lastName仅返回具有给定姓氏的用户String
email仅返回具有给定邮箱的用户String
firstNameLike仅返回名字类似于给定值的用户。使用 % 作为通配符。String
lastNameLike仅返回姓氏类似于给定值的用户。使用 % 作为通配符。String
emailLike仅返回邮箱类似于给定值的用户。使用 % 作为通配符。String
memberOfGroup仅返回属于给定组的用户。String
potentialStarter仅返回可启动具有给定 id 的流程定义的用户。String
sort结果排序所依据的字段，应为 id、firstName、lastname 或 email 之一。String

成功响应体：

{
   "data":[
      {
         "id":"anotherUser",
         "firstName":"Tijs",
         "lastName":"Barrez",
         "url":"http://localhost:8182/identity/users/anotherUser",
         "email":"no-reply@flowable.org"
      },
      {
         "id":"kermit",
         "firstName":"Kermit",
         "lastName":"the Frog",
         "url":"http://localhost:8182/identity/users/kermit",
         "email":null
      },
      {
         "id":"testuser",
         "firstName":"Fred",
         "lastName":"McDonald",
         "url":"http://localhost:8182/identity/users/testuser",
         "email":"no-reply@flowable.org"
      }
   ],
   "total":3,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":3
}

获取用户列表 - 响应码

响应码描述
200表示已返回所请求的用户。

更新一个用户​

PUT identity/users/{userId}

Body JSON：

{
  "firstName":"Tijs",
  "lastName":"Barrez",
  "email":"no-reply@flowable.org",
  "password":"pass123"
}

所有请求值都是可选的。例如，你可以只在请求体 JSON 对象中包含 'firstName' 属性，仅更新用户的 firstName，其他字段保持不变。当某个属性被显式包含并设置为 null 时，该用户值将被更新为 null。例如：{"firstName" : null} 将清除该用户的 firstName。

更新用户 - 响应码

响应码描述
200表示用户已更新。
404表示未找到请求的用户。
409表示请求的用户已被并发更新。

成功响应体： 参见 identity/users/{userId} 的响应。

创建一个用户​

POST identity/users

Body JSON：

{
  "id":"tijs",
  "firstName":"Tijs",
  "lastName":"Barrez",
  "email":"no-reply@flowable.org",
  "password":"pass123"
}

创建用户 - 响应码

响应码描述
201表示用户已创建。
400表示缺少用户的 id。

成功响应体： 参见 identity/users/{userId} 的响应。

删除一个用户​

DELETE identity/users/{userId}

删除用户 - URL 参数

参数是否必需值描述
userId是String要删除的用户的 id。

删除用户 - 响应码

响应码描述
204表示已找到该用户并已删除。响应体按设计为空。
404表示未找到请求的用户。

获取用户的头像​

GET identity/users/{userId}/picture

获取用户的头像 - URL 参数

参数是否必需值描述
userId是String要为其获取头像的用户的 id。

响应体：

响应体包含表示该用户头像的原始图片数据。响应的 Content-type 对应于创建头像时设置的 mimeType。

获取用户的头像 - 响应码

响应码描述
200表示已找到该用户且其有头像，并在响应体中返回。
404表示未找到请求的用户，或该用户没有头像。状态描述中包含关于该错误的更多信息。

更新用户的头像​

GET identity/users/{userId}/picture

更新用户的头像 - URL 参数

参数是否必需值描述
userId是String要为其获取头像的用户的 id。

请求体：

请求应为 multipart/form-data 类型。应包含一个文件部分，其中携带头像的二进制值。除此之外，还可以包含以下额外表单字段：

  • mimeType：上传头像的可选 mime-type。省略时，头像默认使用 image/jpeg 作为 mime-type。

更新用户的头像 - 响应码

响应码描述
200表示已找到该用户且头像已更新。响应体按设计为空。
404表示未找到请求的用户。

列出用户的信息​

PUT identity/users/{userId}/info

列出用户的信息 - URL 参数

参数是否必需值描述
userId是String要为其获取信息的用户的 id。

响应体：

[
   {
      "key":"key1",
      "url":"http://localhost:8182/identity/users/testuser/info/key1"
   },
   {
      "key":"key2",
      "url":"http://localhost:8182/identity/users/testuser/info/key2"
   }
]

列出用户的信息 - 响应码

响应码描述
200表示已找到该用户并返回信息列表（key 和 url）。
404表示未找到请求的用户。

获取用户的信息​

GET identity/users/{userId}/info/{key}

获取用户的信息 - URL 参数

参数是否必需值描述
userId是String要为其获取信息的用户的 id。
key是String要获取的用户信息的 key。

响应体：

{
   "key":"key1",
   "value":"Value 1",
   "url":"http://localhost:8182/identity/users/testuser/info/key1"
}

获取用户的信息 - 响应码

响应码描述
200表示已找到该用户且该用户具有给定 key 的信息。
404表示未找到请求的用户，或该用户不具有给定 key 的信息。状态描述中包含关于该错误的更多信息。

更新用户的信息​

PUT identity/users/{userId}/info/{key}

更新用户的信息 - URL 参数

参数是否必需值描述
userId是String要为其更新信息的用户的 id。
key是String要更新的用户信息的 key。

请求体：

{
   "value":"The updated value"
}

响应体：

{
   "key":"key1",
   "value":"The updated value",
   "url":"http://localhost:8182/identity/users/testuser/info/key1"
}

更新用户的信息 - 响应码

响应码描述
200表示已找到该用户且信息已更新。
400表示请求体中缺少 value。
404表示未找到请求的用户，或该用户不具有给定 key 的信息。状态描述中包含关于该错误的更多信息。

创建新的用户信息条目​

POST identity/users/{userId}/info

创建新的用户信息条目 - URL 参数

参数是否必需值描述
userId是String要为其创建信息的用户的 id。

请求体：

{
   "key":"key1",
   "value":"The value"
}

响应体：

{
   "key":"key1",
   "value":"The value",
   "url":"http://localhost:8182/identity/users/testuser/info/key1"
}

创建新的用户信息条目 - 响应码

响应码描述
201表示已找到该用户且信息已创建。
400表示请求体中缺少 key 或 value。状态描述中包含关于该错误的更多信息。
404表示未找到请求的用户。
409表示该用户已存在具有给定 key 的信息条目，请更新该资源实例（PUT）。

删除用户的信息​

DELETE identity/users/{userId}/info/{key}

删除用户的信息 - URL 参数

参数是否必需值描述
userId是String要为其删除信息的用户的 id。
key是String要删除的用户信息的 key。

删除用户的信息 - 响应码

响应码描述
204表示已找到该用户且具有给定 key 的信息已删除。响应体按设计为空。
404表示未找到请求的用户，或该用户不具有给定 key 的信息。状态描述中包含关于该错误的更多信息。

组​

获取单个组​

GET identity/groups/{groupId}

获取单个组 - URL 参数

参数是否必需值描述
groupId是String要获取的组的 id。

成功响应体：

{
   "id":"testgroup",
   "url":"http://localhost:8182/identity/groups/testgroup",
   "name":"Test group",
   "type":"Test type"
}

获取单个组 - 响应码

响应码描述
200表示该组存在并已返回。
404表示请求的组不存在。

获取组列表​

GET identity/groups

获取组列表 - URL 查询参数

参数描述类型
id仅返回具有给定 id 的组String
name仅返回具有给定名称的组String
type仅返回具有给定类型的组String
nameLike仅返回名称类似于给定值的组。使用 % 作为通配符。String
member仅返回具有给定用户名成员的组。String
potentialStarter仅返回其成员可启动具有给定 id 流程定义的组。String
sort结果排序所依据的字段，应为 id、name 或 type 之一。String

成功响应体：

{
   "data":[
     {
        "id":"testgroup",
        "url":"http://localhost:8182/identity/groups/testgroup",
        "name":"Test group",
        "type":"Test type"
     }
   ],
   "total":3,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":3
}

获取组列表 - 响应码

响应码描述
200表示已返回所请求的组。

更新一个组​

PUT identity/groups/{groupId}

Body JSON：

{
   "name":"Test group",
   "type":"Test type"
}

所有请求值都是可选的。例如，你可以只在请求体 JSON 对象中包含 'name' 属性，仅更新组的 name，其他字段保持不变。当某个属性被显式包含并设置为 null 时，该组值将被更新为 null。

更新组 - 响应码

响应码描述
200表示组已更新。
404表示未找到请求的组。
409表示请求的组已被并发更新。

成功响应体： 参见 identity/groups/{groupId} 的响应。

创建一个组​

POST identity/groups

Body JSON：

{
   "id":"testgroup",
   "name":"Test group",
   "type":"Test type"
}

创建组 - 响应码

响应码描述
201表示组已创建。
400表示缺少组的 id。

成功响应体： 参见 identity/groups/{groupId} 的响应。

删除一个组​

DELETE identity/groups/{groupId}

删除组 - URL 参数

参数是否必需值描述
groupId是String要删除的组的 id。

删除组 - 响应码

响应码描述
204表示已找到该组并已删除。响应体按设计为空。
404表示未找到请求的组。

获取组中的成员​

不允许对 identity/groups/members 使用 GET。请使用 identity/users?memberOfGroup=sales 这一 URL 来获取属于某个特定组的所有用户。

向组添加一个成员​

POST identity/groups/{groupId}/members

向组添加成员 - URL 参数

参数是否必需值描述
groupId是String要向其添加成员的组的 id。

Body JSON：

{
   "userId":"kermit"
}

向组添加成员 - 响应码

响应码描述
201表示已找到该组且已添加成员。
404表示请求体中未包含 userId。
404表示未找到请求的组。
409表示请求的用户已是该组的成员。

响应体：

{
   "userId":"kermit",
   "groupId":"sales",
    "url":"http://localhost:8182/identity/groups/sales/members/kermit"
}

从组中删除一个成员​

DELETE identity/groups/{groupId}/members/{userId}

从组中删除成员 - URL 参数

参数是否必需值描述
groupId是String要从中移除成员的组的 id。
userId是String要移除的用户的 id。

从组中删除成员 - 响应码

响应码描述
204表示已找到该组且已删除成员。响应体按设计为空。
404表示未找到请求的组，或该用户不是该组的成员。状态描述中包含关于该错误的更多信息。

响应体：

{
   "userId":"kermit",
   "groupId":"sales",
    "url":"http://localhost:8182/identity/groups/sales/members/kermit"
}