Activiti-Service-API

注意

流程实例变量【启动流程实例时传入变量Map，启动后根据实例ID获取或设置变量Map】和，任务变量
通过流程变量可以设置候选人、网关条件、都会决定流程中的网关走向
添加任务变量、任务人员数据时，不仅在运行时表中添加，还会在历史表中添加
同理添加流程实例变量数据时，不仅在运行时表中添加，还会在历史表中添加
任务完成或流程实例完成，运行时表中数据就会被清除，历史表中依然存在

删除流程实例：先删除运行数据，再删除历史数据

if (runtimeService.createProcessInstanceQuery().processInstanceId(procInstId).count() > 0) {
  runtimeService.deleteProcessInstance(procInstId, commonService.getLoginUsername() + "-删除流程实例：" + procInstId);
}

if (historyService.createHistoricProcessInstanceQuery().processInstanceId(procInstId).count() > 0) {
  historyService.deleteHistoricProcessInstance(procInstId);
}

常用总结

流程实例

设置流程变量

1	runtimeService.setVariable(procInstId, ActivitiConstant.VARIABLELOCAL_EVENT_PROCINSID_HISTORY, "C202210230111");

获取流程变量

HistoricVariableInstance historicVariableInstance = historyService.createHistoricVariableInstanceQuery()
                    .processInstanceId(procInstId)
                    .variableName(ActivitiConstant.VARIABLELOCAL_EVENT_PROCINSID_HISTORY).singleResult();
if(historicVariableInstance != null) {
  String eventId = (String) historicVariableInstance.getValue();
}

任务实例

获取流程实例-指定节点的历史任务实例

Task t = tasks.get(0);
List<HistoricTaskInstance> historicTaskInstanceList = historyService.createHistoricTaskInstanceQuery()
                    .processInstanceId(procInstId) // 流程实例
                    .taskDefinitionKey(t.getTaskDefinitionKey()) // 任务所在节点
                    .orderByHistoricTaskInstanceEndTime().desc().list(); // 任务完成时间倒序

设置任务实例变量

VariableTaskOperation variableTaskOperation = new VariableTaskOperation();
variableTaskOperation.setAppcode(appcode);
variableTaskOperation.setProcInsIdExt(procInsIdExt);

taskService.setVariable(taskId, ActivitiConstant.VARIABLELOCAL_TASK_OPERATION_APP_EXT, variableTaskOperation);

获取任务实例变量

HistoricVariableInstance historicVariableInstance = historyService.createHistoricVariableInstanceQuery()
                        .taskId(historicTaskInstanceId)
                        .variableName(ActivitiConstant.VARIABLELOCAL_TASK_OPERATION_APP_EXT).singleResult();
if (historicVariableInstance != null) {
  // 历史任务的流程变量或当前任务已经添加的流程变量
  VariableTaskOperation taskOperation = (VariableTaskOperation) historicVariableInstance.getValue();
  if (taskOperation != null) {
    String appcode = taskOperation.getAppcode();
    if (StrUtil.isNotBlank(appcode)) {
      // 再次批转到对应系统-状态为二次派遣
      event.setActStatus(ActivitiConstant.STATUS_TO_REPORT_AGAIN);
      event.setStatus(ActivitiConstant.STATUS_TO_REPORT_AGAIN);
      return toServiceSystem(event, appcode, request);
    }
  }
}

获取任务历史关联人信息

1	List<HistoricIdentityLink> his = historyService.getHistoricIdentityLinksForTask(taskId);

RepositoryService

流程仓库服务，管理流程仓库，比如部署、删除、读取流程资源

创建一个流程模型

该模型是瞬态的，必须使用saveModel(Model)保存

1	Model newModel();

保存模型

如果模型已存在，则更新模型，否则创建新模型

参数：模型 - 要保存的模型，不能为空

1	void saveModel(Model model);

删除模型

modelId - 要删除的模型的 id，不能为空。当为不存在的模型传递 id 时，此操作将被忽略

1	void deleteModel(String modelId);

保存模型的模型编辑器源

参数：
modelId - 要删除的模型的 id，不能为空。当为不存在的模型传递 id 时，此操作将被忽略。

1	void addModelEditorSource(String modelId, byte[] bytes);

保存模型的额外的模型编辑器源

参数：
modelId - 要删除的模型的 id，不能为空。当为不存在的模型传递 id 时，此操作将被忽略。

1	void addModelEditorSourceExtra(String modelId, byte[] bytes);

查询模型

1
2
3

ModelQuery createModelQuery();

NativeModelQuery createNativeModelQuery();

查看模型

参数：modelId – 模型的 id

1	Model getModel(String modelId);

返回模型编辑器源

参数：modelId – 模型的 id

1	byte[] getModelEditorSource(String modelId);

返回模型额外编辑器源

参数：modelId – 模型的 id

1	byte[] getModelEditorSourceExtra(String modelId);

创建新部署

1	DeploymentBuilder createDeployment();

删除给定的部署

deploymentId - 部署的 id，不能为空

1	void deleteDeployment(String deploymentId);

删除给定的部署并级联删除流程实例、历史流程实例和作业

deploymentId - 部署的 id，不能为空

1	void deleteDeploymentCascade(String deploymentId);

删除给定的部署

cascade是否并级联删除流程实例、历史流程实例和作业

1	void deleteDeployment(String deploymentId, boolean cascade);

设置部署的类别

1	void setDeploymentCategory(String deploymentId, String category);

查询部署资源列表

按字母顺序排列，deploymentId - 部署的 id，不能为空

1	List<String> getDeploymentResourceNames(String deploymentId);

通过字节流访问部署资源

deploymentId - 部署的 id，不能为空，resourceName – 资源名称，不能为空

InputStream getResourceAsStream(String deploymentId, String resourceName);

// 示例
ProcessDefinition pd = repositoryService.createProcessDefinitionQuery()
                .processDefinitionId(id).singleResult();

String resourceName = pd.getDiagramResourceName();
InputStream inputStream = repositoryService.getResourceAsStream(pd.getDeploymentId(),
                                                                resourceName);

try {
  response.setContentType("application/octet-stream;charset=UTF-8");
  response.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(resourceName, "UTF-8"));
  byte[] b = new byte[1024];
  int len = -1;
  while ((len = inputStream.read(b, 0, 1024)) != -1) {
    response.getOutputStream().write(b, 0, len);
  }
  response.flushBuffer();
} catch (IOException e) {
  log.error(e.toString());
}

更改部署的租户标识符以匹配给定的租户标识符

deploymentId – 将更改租户标识符的部署的 ID，newTenantId – 新租户标识符

1	void changeDeploymentTenantId(String deploymentId, String newTenantId);

查询流程定义

1	ProcessDefinitionQuery createProcessDefinitionQuery();

查询流程定义

1	NativeProcessDefinitionQuery createNativeProcessDefinitionQuery();

查询部署

1
2
3

DeploymentQuery createDeploymentQuery();

NativeDeploymentQuery createNativeDeploymentQuery();

挂起流程定义

如果流程定义处于挂起状态，则无法根据流程定义启动新流程实例。注意：流程定义的所有流程实例仍将处于活动状态（即未暂停）！

1	void suspendProcessDefinitionById(String processDefinitionId);

如果流程定义处于挂起状态，则无法根据流程定义启动新流程实例，suspendProcessInstances – 如果为 true，所提供流程定义的所有流程实例也将被挂起。暂停日期 - 流程定义挂起的日期。如果为空，流程定义将立即挂起。注意：作业执行程序需要处于活动状态才能使用它！

1	void suspendProcessDefinitionById(String processDefinitionId, boolean suspendProcessInstances, Date suspensionDate);

挂起流程定义

使用给定的键（= bpmn20.xml 文件中的 id）暂停所有流程定义。如果流程定义处于挂起状态，则无法根据流程定义启动新流程实例。注意：流程定义的所有流程实例仍将处于活动状态（即未暂停）！

1	void suspendProcessDefinitionByKey(String processDefinitionKey);

使用给定的键（= bpmn20.xml 文件中的 id）暂停所有流程定义。如果流程定义处于挂起状态，则无法根据流程定义启动新流程实例。suspendProcessInstances – 如果为 true，所提供流程定义的所有流程实例也将被挂起。
暂停日期 - 流程定义将暂停的日期。如果为空，流程定义将立即挂起。注意：作业执行程序需要处于活动状态才能使用它！

1	void suspendProcessDefinitionByKey(String processDefinitionKey, boolean suspendProcessInstances, Date suspensionDate);

挂起流程定义

类似于suspendProcessDefinitionByKey(String) ，但仅适用于给定的租户标识符

1	void suspendProcessDefinitionByKey(String processDefinitionKey, String tenantId);

类似于suspendProcessDefinitionByKey(String, boolean, Date) ，但仅适用于给定的租户标识符

1	void suspendProcessDefinitionByKey(String processDefinitionKey, boolean suspendProcessInstances, Date suspensionDate, String tenantId);

激活流程定义

1	void activateProcessDefinitionById(String processDefinitionId);

使用给定的 id 激活流程定义，activationDate – 流程定义将被激活的日期。如果为空，则立即激活流程定义。注意：作业执行程序需要处于活动状态才能使用它！activateProcessInstances-激活流程实例

1	void activateProcessDefinitionById(String processDefinitionId, boolean activateProcessInstances, Date activationDate);

激活流程定义

1	void activateProcessDefinitionByKey(String processDefinitionKey);

使用给定的键（= bpmn20.xml 文件中的 id）激活流程定义。activationDate – 流程定义将被激活的日期。如果为空，则立即激活流程定义。注意：作业执行程序需要处于活动状态才能使用它！

1	void activateProcessDefinitionByKey(String processDefinitionKey, boolean activateProcessInstances, Date activationDate);

激活流程定义

activateProcessDefinitionByKey(String) ，但仅适用于给定的租户标识符

1	void activateProcessDefinitionByKey(String processDefinitionKey, String tenantId);

类似于activateProcessDefinitionByKey(String, boolean, Date) ，但仅适用于给定的租户标识符

1	void activateProcessDefinitionByKey(String processDefinitionKey, boolean activateProcessInstances, Date activationDate, String tenantId);

设置流程定义的类别

可以按类别查询流程定义：参见ProcessDefinitionQuery.processDefinitionCategory(String) 。

1	void setProcessDefinitionCategory(String processDefinitionId, String category);

查看流程模型、流程定义、流程图

例如 BPMN 2.0 XML 文件

1	InputStream getProcessModel(String processDefinitionId);

通过字节流访问已部署的流程图，例如 PNG 图像

参数：processDefinitionId – ProcessDefinition id，不能为 null。

返回：当ProcessDefinition的图表资源名称为 null 时为 null。

1	InputStream getProcessDiagram(String processDefinitionId);

返回ProcessDefinition包括所有 BPMN 信息，如附加属性（例如文档）。

1	ProcessDefinition getProcessDefinition(String processDefinitionId);

返回与具有提供的流程定义 ID 的流程定义对应的BpmnModel 。 BpmnModel是 BPMN 2.0 xml 的 pojo 版本，可用于使用常规 Java 内省流程定义。

1	BpmnModel getBpmnModel(String processDefinitionId);

提供由getProcessDiagram(String)提供的流程图中元素的位置和尺寸。此方法需要部署流程模型和图表图像。

参数：
processDefinitionId – processDefinitionId，不能为 null。
返回：
以流程元素 ID 作为键，以位置和维度作为值进行映射。

1	DiagramLayout getProcessDiagramLayout(String processDefinitionId);

检查流程定义是否挂起

1	boolean isProcessDefinitionSuspended(String processDefinitionId);

流程定义添加候选启动用户

参数：processDefinitionId – 流程定义的id，不能为空。
userId – 涉及的用户ID，不能为空。

1	void addCandidateStarterUser(String processDefinitionId, String userId);

流程定义授权候启动选组

参数：
processDefinitionId – 流程定义的id，不能为空。
groupId - 涉及的组的 id，不能为空。

1	void addCandidateStarterGroup(String processDefinitionId, String groupId);

删除流程定义候选启动用户

参数：

processDefinitionId – 流程定义的id，不能为空。
userId – 涉及的用户ID，不能为空。

1	void deleteCandidateStarterUser(String processDefinitionId, String userId);

删除流程定义的候选启动组

参数：
processDefinitionId – 流程定义的id，不能为空。
groupId - 涉及的组的 id，不能为空。

1	void deleteCandidateStarterGroup(String processDefinitionId, String groupId);

查询流程定义关联的IdentityLink

这样的IdentityLink通知如何为某个流程定义授权某个身份（例如组或用户）

1	List<IdentityLink> getIdentityLinksForProcessDefinition(String processDefinitionId);

根据在 Activiti 引擎上执行流程定义的规则验证给定的流程定义

要从字符串创建这样的BpmnModel ，可以使用以下代码： XMLInputFactory xif = XMLInputFactory.newInstance(); InputStreamReader in = new InputStreamReader(new ByteArrayInputStream(myProcess.getBytes()), “UTF-8”); // 更改为其他流，例如从类路径 XMLStreamReader xtr = xif.createXMLStreamReader(in); bpmnModel = new BpmnXMLConverter().convertToBpmnModel(xtr);

1	List<ValidationError> validateProcess(BpmnModel bpmnModel);

RuntimeService

运行服务，处理所有正在运行态的流程实例、任务等

启动一个流程实例ByKey

参数：
processDefinitionKey – 流程定义键，不能为空。

1	ProcessInstance startProcessInstanceByKey(String processDefinitionKey);

使用给定的键在流程定义的最新版本中启动一个新流程实例

可以提供业务密钥，将流程实例与具有明确业务含义的某个标识符相关联。例如，在订单流程中，业务键可以是订单 ID。然后可以使用此业务键轻松查找该流程实例，请参阅ProcessInstanceQuery.processInstanceBusinessKey(String) 。提供这样的业务密钥绝对是最佳实践。

参数：
processDefinitionKey – 流程定义键，不能为空。
businessKey – 在上下文或给定流程定义中唯一标识流程实例的键。

1	ProcessInstance startProcessInstanceByKey(String processDefinitionKey, String businessKey);

使用给定的键在最新版本的流程定义中启动一个新流程实例

参数：
processDefinitionKey – 流程定义键，不能为空。
variables - 要传递的变量，可以为空。

1	ProcessInstance startProcessInstanceByKey(String processDefinitionKey, Map<String, Object> variables);

使用给定的键在流程定义的最新版本中启动一个新流程实例。可以提供业务密钥，将流程实例与具有明确业务含义的某个标识符相关联。例如，在订单流程中，业务键可以是订单 ID。然后可以使用此业务键轻松查找该流程实例，请参阅ProcessInstanceQuery.processInstanceBusinessKey(String) 。提供这样的业务密钥绝对是最佳实践。 processdefinitionKey-businessKey 的组合必须是唯一的。

参数：
processDefinitionKey – 流程定义键，不能为空。
businessKey – 在上下文或给定流程定义中唯一标识流程实例的键。
variables - 要传递的变量，可以为空。

1	ProcessInstance startProcessInstanceByKey(String processDefinitionKey, String businessKey, Map<String, Object> variables);

启动一个流程实例，但使用特定的租户标识符

1	ProcessInstance startProcessInstanceByKeyAndTenantId(String processDefinitionKey, String tenantId);

1	ProcessInstance startProcessInstanceByKeyAndTenantId(String processDefinitionKey, String businessKey, String tenantId);

1	ProcessInstance startProcessInstanceByKeyAndTenantId(String processDefinitionKey, Map<String, Object> variables, String tenantId);

1	ProcessInstance startProcessInstanceByKeyAndTenantId(String processDefinitionKey, String businessKey, Map<String, Object> variables, String tenantId);

启动一个流程实例ById

参数：
processDefinitionId – 流程定义的id，不能为空。

1	ProcessInstance startProcessInstanceById(String processDefinitionId);

1	ProcessInstance startProcessInstanceById(String processDefinitionId, String businessKey);

1	ProcessInstance startProcessInstanceById(String processDefinitionId, Map<String, Object> variables);

1	ProcessInstance startProcessInstanceById(String processDefinitionId, String businessKey, Map<String, Object> variables);

根据消息启动流程实例

调用此方法可能有两种不同的结果：
如果消息名称与消息启动事件相关联，则会启动一个新的流程实例。
如果不存在对具有给定名称的消息的订阅，则抛出ActivitiException

参数：
messageName – 作为 bpmn20 元素上的属性指定的消息的“名称”。
返回：
表示已启动流程实例的ProcessInstance对象

1	ProcessInstance startProcessInstanceByMessage(String messageName);

1	ProcessInstance startProcessInstanceByMessageAndTenantId(String messageName, String tenantId);

1	ProcessInstance startProcessInstanceByMessage(String messageName, String businessKey);

1	ProcessInstance startProcessInstanceByMessageAndTenantId(String messageName, String businessKey, String tenantId);

1	ProcessInstance startProcessInstanceByMessage(String messageName, Map<String, Object> processVariables);

1	ProcessInstance startProcessInstanceByMessageAndTenantId(String messageName, Map<String, Object> processVariables, String tenantId);

1	ProcessInstance startProcessInstanceByMessage(String messageName, String businessKey, Map<String, Object> processVariables);

1	ProcessInstance startProcessInstanceByMessageAndTenantId(String messageName, String businessKey, Map<String, Object> processVariables, String tenantId);

删除运行时流程实例

参数：
processInstanceId – 要删除的流程实例的 id，不能为 null。
deleteReason – 删除原因，可以为空。

删除流程实例：还包括任务，不包括历史

1 2	void deleteProcessInstance(String processInstanceId, String deleteReason); // 未审批的任务会被删除，流程历史不会被删除，并且流程历史的状态为finished完成

查找活动中等待的所有执行的活动 ID

参数：
executionId - 执行的 id，不能为空。

1	List<String> getActiveActivityIds(String executionId);

将外部触发器发送到在给定执行中等待的活动实例

参数：
executionId - 要发出信号的执行 ID，不能为空。

1	void signal(String executionId);

将外部触发器发送到在给定执行中等待的活动实例。

参数：
executionId - 要发出信号的执行 ID，不能为空。
processVariables – 过程变量图

1	void signal(String executionId, Map<String, Object> processVariables);

更新流程实例的businessKey

参数：
processInstanceId – 设置业务key的流程实例id，不能为空
businessKey – 新的 businessKey 值

1	void updateBusinessKey(String processInstanceId, String businessKey);

给流程实例添加涉及的用户

身份链接的类型由给定的 identityLinkType 定义。

参数：
processInstanceId – 流程实例的id，不能为空。
userId – 涉及的用户ID，不能为空。
identityLinkType – identityLink 的类型，不能为 null（@see IdentityLinkType ）。

void addUserIdentityLink(String processInstanceId, String userId, String identityLinkType);

// addUserIdentityLink(String, String, String) 便捷简写； 类型为IdentityLinkType.CANDIDATE
void addParticipantUser(String processInstanceId, String userId);

给流程实例添加涉及的用户组

identityLink 的类型由给定的 identityLink 定义。

参数：
processInstanceId – 流程实例的id，不能为空。
groupId - 要涉及的组的 id，不能为空。
identityLinkType – 身份类型，不能为空（@see IdentityLinkType ）。

void addGroupIdentityLink(String processInstanceId, String groupId, String identityLinkType);

// addGroupIdentityLink(String, String, String)便捷简写； 类型为IdentityLinkType.CANDIDATE
void addParticipantGroup(String processInstanceId, String groupId);

删除流程实例涉及的用户

void deleteUserIdentityLink(String processInstanceId, String userId, String identityLinkType);

// deleteUserIdentityLink(String, String, String)便捷简写； 类型为IdentityLinkType.CANDIDATE
void deleteParticipantUser(String processInstanceId, String userId);

删流程实例涉及的用户组

参数：
processInstanceId – 流程实例的id，不能为空。
groupId - 要涉及的组的 id，不能为空。
identityLinkType – 身份类型，不能为空（@see IdentityLinkType ）。

void deleteGroupIdentityLink(String processInstanceId, String groupId, String identityLinkType);

// deleteGroupIdentityLink(String, String, String)便捷简写； 类型为IdentityLinkType.CANDIDATE
void deleteParticipantGroup(String processInstanceId, String groupId);

获取流程实例涉及的用户

1	List<IdentityLink> getIdentityLinksForProcessInstance(String instanceId);

从给定的执行范围（包括父范围）可见的所有变量

参数：
executionId - 执行的id，不能为空。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, Object> getVariables(String executionId);

从给定的执行范围（包括父范围）可见的所有变量

参数：
executionId - 执行的id，不能为空。
返回：
如果未找到此类变量，则为变量实例或空映射。

1	Map<String, VariableInstance> getVariableInstances(String executionId);

从给定的执行范围（包括父范围）可见的所有变量

参数：
executionIds - 执行的 id，不能为空。
返回：
变量。

1	List<VariableInstance> getVariableInstancesByExecutionIds(Set<String> executionIds);

从给定的执行范围（包括父范围）可见的所有变量

参数：
executionId - 执行的id，不能为空。
locale – 应返回变量名称和描述的区域设置（如果可用）。
withLocalizationFallback – 如果没有找到指定的语言环境，真正的本地化将回退到更通用的语言环境，包括 JVM 的默认语言环境。
返回：
如果未找到此类变量，则为变量实例或空映射。

1	Map<String, VariableInstance> getVariableInstances(String executionId, String locale, boolean withLocalizationFallback);

在执行范围内定义的所有变量值，不考虑外部范围

如果您有许多任务局部变量而您只需要几个，请考虑使用getVariablesLocal(String, Collection)以获得更好的性能。

参数：
executionId - 执行的id，不能为空。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, Object> getVariablesLocal(String executionId);

在执行范围内定义的所有变量值，不考虑外部范围

如果您有许多任务局部变量而您只需要几个，请考虑使用getVariableInstancesLocal(String, Collection)以获得更好的性能。

参数：
executionId - 执行的id，不能为空。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, VariableInstance> getVariableInstancesLocal(String executionId);

在执行范围内定义的所有变量值，不考虑外部范围

如果您有许多任务局部变量而您只需要几个，请考虑使用getVariableInstancesLocal(String, Collection)以获得更好的性能。

参数：
executionId - 执行的id，不能为空。
locale – 应返回变量名称和描述的区域设置（如果可用）。
withLocalizationFallback – 如果没有找到指定的语言环境，真正的本地化将回退到更通用的语言环境，包括 JVM 的默认语言环境。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, VariableInstance> getVariableInstancesLocal(String executionId, String locale, boolean withLocalizationFallback);

所有给定 variableNames 的变量值都考虑了从给定执行范围（包括父范围）可见的所有变量。

参数：
executionId - 执行的id，不能为空。
variableNames – 应检索的变量名称的集合。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, Object> getVariables(String executionId, Collection<String> variableNames);

所有给定 variableNames 的变量值都考虑了从给定执行范围（包括父范围）可见的所有变量

参数：
executionId - 执行的id，不能为空。
variableNames – 应检索的变量名称的集合。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, VariableInstance> getVariableInstances(String executionId, Collection<String> variableNames);

所有给定 variableNames 的变量值都考虑了从给定执行范围（包括父范围）可见的所有变量

参数：
executionId - 执行的id，不能为空。
variableNames – 应检索的变量名称的集合。
locale – 应返回变量名称和描述的区域设置（如果可用）。
withLocalizationFallback – 如果没有找到指定的语言环境，真正的本地化将回退到更通用的语言环境，包括 JVM 的默认语言环境。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, VariableInstance> getVariableInstances(String executionId, Collection<String> variableNames, String locale, boolean withLocalizationFallback);

给定 variableNames 的变量值仅考虑给定的执行范围，而不考虑外部范围

参数：
executionId - 执行的id，不能为空。
variableNames – 应检索的变量名称的集合。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, Object> getVariablesLocal(String executionId, Collection<String> variableNames);

给定 variableNames 的变量值仅考虑给定的执行范围，而不考虑外部范围

参数：
executionId - 执行的id，不能为空。
variableNames – 应检索的变量名称的集合。
返回：
如果未找到此类变量，则为变量或空映射。

1	Map<String, VariableInstance> getVariableInstancesLocal(String executionId, Collection<String> variableNames);

给定 variableNames 的变量值仅考虑给定的执行范围，而不考虑外部范围

1	Map<String, VariableInstance> getVariableInstancesLocal(String executionId, Collection<String> variableNames, String locale, boolean withLocalizationFallback);

获取执行实例的变量值

在给定执行可见的所有范围（包括父范围）中搜索变量。当没有找到具有给定名称的变量值或该值设置为 null 时，返回 null。

参数：
executionId - 执行的id，不能为空。
variableName – 变量名称，不能为空。
返回：
如果变量未定义或变量的值为 null，则为变量值或 null。

1	Object getVariable(String executionId, String variableName);

获取执行实例的变量实例

在给定执行可见的所有范围（包括父范围）中搜索变量。当没有找到具有给定名称的变量值或该值设置为 null 时，返回 null。

参数：
executionId - 执行的id，不能为空。
variableName – 变量名称，不能为空。
返回：
如果变量未定义，则为变量或 null。

1	VariableInstance getVariableInstance(String executionId, String variableName);

获取执行实例的变量实例

在给定执行可见的所有范围（包括父范围）中搜索变量。当没有找到具有给定名称的变量值或该值设置为 null 时，返回 null。

参数：
executionId - 执行的id，不能为空。
variableName – 变量名称，不能为空。
locale – 应返回变量名称和描述的区域设置（如果可用）。
withLocalizationFallback – 如果没有找到指定的语言环境，真正的本地化将回退到更通用的语言环境，包括 JVM 的默认语言环境。
返回：
如果变量未定义，则为变量或 null。

1	VariableInstance getVariableInstance(String executionId, String variableName, String locale, boolean withLocalizationFallback);

获取执行实例的变量值

在给定执行可见的所有范围（包括父范围）中搜索变量。当没有找到具有给定名称的变量值或该值设置为 null 时，返回 null。当无法将变量强制转换为给定类时抛出 ClassCastException

参数：
executionId - 执行的id，不能为空。
variableName – 变量名称，不能为空。
variableClass – 变量名，不能为空。
返回：
如果变量未定义或变量的值为 null，则为变量值或 null。

1	<T> T getVariable(String executionId, String variableName, Class<T> variableClass);

检查此执行是否具有使用给定名称设置的变量，在给定执行可见的所有范围（包括父范围）中搜索变量

1	boolean hasVariable(String executionId, String variableName);

执行的变量值

为执行设置变量时返回值（而不是搜索父作用域）。当没有找到具有给定名称的变量值或该值设置为 null 时，返回 null。

1	Object getVariableLocal(String executionId, String variableName);

执行的变量

为执行（而不是搜索父作用域）设置变量时返回该变量。当没有找到具有给定名称的变量或值设置为 null 时，返回 null。

参数：
executionId - 执行的id，不能为空。
variableName – 变量名称，不能为空。
返回：
如果变量未定义，则为变量或 null。

1	VariableInstance getVariableInstanceLocal(String executionId, String variableName);

执行的变量

为执行（而不是搜索父作用域）设置变量时返回该变量。当没有找到具有给定名称的变量或值设置为 null 时，返回 null

1	VariableInstance getVariableInstanceLocal(String executionId, String variableName, String locale, boolean withLocalizationFallback);

执行的变量值。当为执行设置变量时（而不是搜索父作用域），返回转换为给定类的值。当没有找到具有给定名称的变量值或该值设置为 null 时，返回 null

1	<T> T getVariableLocal(String executionId, String variableName, Class<T> variableClass);

检查此执行是否具有使用给定名称设置的局部变量

1	boolean hasVariableLocal(String executionId, String variableName);

为执行更新或创建变量

该变量是根据VariableScope.setVariable(String, Object)记录的算法设置的。

参数：
executionId - 要在其中设置变量的执行 ID，不能为空。
variableName – 要设置的变量名称，不能为空。
value - 要设置的值。传递 null 时，不会删除该变量，只会将其值设置为 null。

1	void setVariable(String executionId, String variableName, Object value);

为执行更新或创建变量（不考虑父作用域）。如果变量不存在，它将在给定的执行中创建。

1	void setVariableLocal(String executionId, String variableName, Object value);

为执行更新或创建给定变量（包括父作用域）

变量是根据VariableScope.setVariables(Map)记录的算法设置的，分别应用于每个变量。

参数：
executionId - 执行的 id，不能为空。
variables - 包含名称（键）和变量值的映射，可以为空。

1	void setVariables(String executionId, Map<String, ? extends Object> variables);

为执行更新或创建给定变量（不考虑父作用域）。如果变量不存在，它将在给定的执行中创建

参数：
executionId - 执行的 id，不能为空。
variables - 包含名称（键）和变量值的映射，可以为空。

1	void setVariablesLocal(String executionId, Map<String, ? extends Object> variables);

删除执行的变量

参数：
executionId - 要删除变量的执行 ID。
variableName – 要删除的变量的名称。

1	void removeVariable(String executionId, String variableName);

删除执行的变量（不考虑父作用域）

参数：
executionId - 要删除变量的执行 ID。
variableName – 要删除的变量的名称。

1	void removeVariableLocal(String executionId, String variableName);

删除执行的变量

参数：
executionId - 要删除变量的执行 ID。
variableNames – 包含要删除的变量名称的集合。

1	void removeVariables(String executionId, Collection<String> variableNames);

删除执行的变量（不考虑父作用域）

参数：
executionId - 要删除变量的执行 ID。
variableNames – 包含要删除的变量名称的集合。

1	void removeVariablesLocal(String executionId, Collection<String> variableNames);

创建一个新的ExecutionQuery实例，可用于查询执行和流程实例

1	ExecutionQuery createExecutionQuery();

创建一个新的NativeExecutionQuery直接通过 SQL 查询Execution

1	NativeExecutionQuery createNativeExecutionQuery();

创建一个新的ProcessInstanceQuery实例，可用于查询流程实例

1	ProcessInstanceQuery createProcessInstanceQuery();

创建一个新的NativeProcessInstanceQuery直接通过 SQL 查询ProcessInstance

1	NativeProcessInstanceQuery createNativeProcessInstanceQuery();

挂起流程实例

如果流程实例处于挂起状态，activiti 将不会执行与该实例关联的作业（计时器、消息）。如果您有一个流程实例层次结构，从层次结构中挂起一个流程实例不会从该层次结构中挂起其他流程实例

1	void suspendProcessInstanceById(String processInstanceId);

使用给定的 id 激活流程实例。如果您有一个流程实例层次结构，从层次结构中挂起一个流程实例不会从该层次结构中挂起其他流程实例

1	void activateProcessInstanceById(String processInstanceId);

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给所有等待该信号的执行

注意：等待的执行是同步通知的。

参数：
signalName – 信号事件的名称

1	void signalEventReceived(String signalName);

类似于signalEventReceived(String) ，但在一个租户的上下文中。

1	void signalEventReceivedWithTenantId(String signalName, String tenantId);

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给所有等待该信号的执行

参数：
signalName – 信号事件的名称

1	void signalEventReceivedAsync(String signalName);

类似于signalEventReceivedAsync(String) ，但在一个租户的上下文中。

1	void signalEventReceivedAsyncWithTenantId(String signalName, String tenantId);

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给所有等待该信号的执行

注意：等待的执行是同步通知的。

参数：
signalName – 信号事件的名称
processVariables – 添加到执行中的变量映射

1	void signalEventReceived(String signalName, Map<String, Object> processVariables);

类似于signalEventReceived(String, Map < String , Object > ) ，但在一个租户的上下文中

1	void signalEventReceivedWithTenantId(String signalName, Map<String, Object> processVariables, String tenantId);

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给单个执行，即由“executionId”引用的执行。同步通知等待执行

参数：
signalName – 信号事件的名称
executionId - 将信号传递到的执行的 id

1	void signalEventReceived(String signalName, String executionId);

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给单个执行，即由“executionId”引用的执行。同步通知等待执行

参数：
signalName – 信号事件的名称
executionId - 将信号传递到的执行的 id
processVariables – 添加到执行中的变量映射

1	void signalEventReceived(String signalName, String executionId, Map<String, Object> processVariables);

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给单个执行，即由“executionId”引用的执行。异步通知等待执行

参数：
signalName – 信号事件的名称
executionId - 将信号传递到的执行的 id

1	void signalEventReceivedAsync(String signalName, String executionId);

通知流程引擎已收到名为“messageName”的消息事件，并已将其与 ID 为“executionId”的执行相关联。同步通知等待执行

参数：
messageName – 消息事件的名称
executionId - 将消息传递到的执行的 id

1	void messageEventReceived(String messageName, String executionId);

通知流程引擎已收到名为“messageName”的消息事件，并已将其与 ID 为“executionId”的执行相关联。同步通知等待执行

为订阅消息名称的消息事件的执行范围设置变量。例如：

主流程中的中间消息事件的范围是流程实例的范围
子流程中的中间消息事件的范围是子流程的范围
边界消息事件的范围是事件附加到的活动的执行范围
变量是根据VariableScope.setVariables(Map)记录的算法设置的，分别应用于每个变量。

参数：
messageName – 消息事件的名称
executionId - 将消息传递到的执行的 id
processVariables – 添加到执行中的变量映射

1	void messageEventReceived(String messageName, String executionId, Map<String, Object> processVariables);

通知流程引擎已收到名为“messageName”的消息事件，并已将其与 ID 为“executionId”的执行相关联。异步通知等待执行

参数：
messageName – 消息事件的名称
executionId - 将消息传递到的执行的 id

1	void messageEventReceivedAsync(String messageName, String executionId);

添加一个事件侦听器，调度程序将通知所有事件

参数：
listenerToAdd – 要添加的侦听器

1	void addEventListener(ActivitiEventListener listenerToAdd);

添加一个事件监听器，它只会在事件发生时收到通知，该事件类型在给定类型中

参数：
listenerToAdd – 要添加的侦听器
类型 - 应通知侦听器的事件类型

1	void addEventListener(ActivitiEventListener listenerToAdd, ActivitiEventType... types);

从此调度程序中删除给定的侦听器。无论最初注册的类型是什么，侦听器都不会再收到通知

参数：
listenerToRemove – 要删除的侦听器

1	void removeEventListener(ActivitiEventListener listenerToRemove);

将给定的事件分派给任何注册的侦听器

参数：
event – 要调度的事件

1	void dispatchEvent(ActivitiEvent event);

设置流程实例的名称

参数：
processInstanceId – 要更新的流程实例的 ID
name - 流程实例的新名称

1	void setProcessInstanceName(String processInstanceId, String name);

获取流程实例相关的所有事件

1	List<Event> getProcessInstanceEvents(String processInstanceId);

创建一个 ProcessInstanceBuilder

1	ProcessInstanceBuilder createProcessInstanceBuilder();

identityService

设置流程实例发起人

 // 流程实例发起人
String username = loginUser.getUsername();
identityService.setAuthenticatedUserId(username);

// 流程变量
Map<String, Object> params = BeanUtil.beanToMap(event);
params.put("creator", username);
if (StringUtils.isNotEmpty(conditionDictCode)) {
  params.put(conditionDictCode, conditionDictValue);
}

// 启动流程
ProcessInstance processInstance = runtimeService.startProcessInstanceById(procDefId, params);

TaskService

任务服务，管理（签收、办理、指派等）、查询任务

创建任务

创建一个与流程实例的新任务

返回的任务是暂时的，必须使用saveTask(Task) 保存

1	Task newTask();

使用任务 id 创建一个新任务

1	Task newTask(String taskId);

保存任务

如果任务已存在于持久存储中，则更新它。保存新任务后，将使用新创建的任务的 ID 更新传递给此方法的任务实例

参数：任务实例，不能为空

1	void saveTask(Task task);

删除任务

不删除与此任务相关的历史信息

参数：taskId – 将被删除的任务的 id，不能为空。如果不存在具有给定 taskId 的任务，则忽略该操作。
抛出：ActivitiObjectNotFoundException – 当给定 id 的任务不存在时。
ActivitiException – 当删除任务时发生错误或任务是正在运行的进程的一部分时

void deleteTask(String taskId);

void deleteTask(String taskId, boolean cascade); // 级联- 如果级联为真，则与此任务相关的历史信息也会被删除

void deleteTask(String taskId, String deleteReason); // deleteReason – 任务被删除的原因。 如果启用，则记录在历史记录中

删除多个任务

不删除与这些任务相关的历史信息

参数：taskIds – 将被删除的任务的 id，不能为空。列表中没有现有任务的所有 id 都将被忽略。
抛出：ActivitiObjectNotFoundException – 当其中一项任务不存在时。
ActivitiException – 当删除任务时发生错误或其中一个任务是正在运行的进程的一部分时发生

void deleteTasks(Collection<String> taskIds);

void deleteTasks(Collection<String> taskIds, boolean cascade); // 级联- 如果级联为真，则与此任务相关的历史信息也会被删除

void deleteTasks(Collection<String> taskIds, String deleteReason); // deleteReason – 任务被删除的原因。 如果启用，则记录在历史记录中

认领任务

参数：taskId - 要声明的任务，不能为空。
userId – 声明任务的用户。当 userId 为 null 时，任务无人认领，没有分配给任何人。
抛出：ActivitiObjectNotFoundException – 当任务不存在时。
ActivitiTaskAlreadyClaimedException – 当任务已经被另一个用户认领

与 setAssignee(String taskId, String userId) 不同在于，这里会检查任务是否已被认领，如果被认领则会抛出ActivitiTaskAlreadyClaimedException

1	void claim(String taskId, String userId);

取消认领

参数：taskId - 要取消声明的任务，不能为空。
抛出：ActivitiObjectNotFoundException – 当任务不存在时

1	void unclaim(String taskId);

完成任务

参数：taskId - 要完成的任务的 id，不能为空。
抛出：ActivitiObjectNotFoundException – 当给定 id 的任务不存在时。
ActivitiException – 当这个任务是DelegationState.PENDING委托时

1	void complete(String taskId);

完成任务、提供流程变量

需要的任务参数由最终用户给出
参数：taskId - 要完成的任务的 id，不能为空。
变量- 任务参数。可能为 null 或为空。
抛出：ActivitiObjectNotFoundException – 当给定 id 的任务不存在时

1	void complete(String taskId, Map<String, Object> variables);

完成任务、提供本地流程变量

参数：taskId - 要完成的任务的 id，不能为空。
变量- 任务参数。可能为 null 或为空。
localScope – 如果为 true，则提供的变量将存储在任务本地，而不是流程实例范围内,默认为true
抛出：ActivitiObjectNotFoundException – 当给定 id 的任务不存在时。

1	void complete(String taskId, Map<String, Object> variables, boolean localScope);

委托

将任务委派给另一个用户

这意味着受让人已设置，并且委托状态已设置为DelegationState.PENDING 。如果没有为任务设置所有者，则所有者将设置为任务的当前受理人

参数：taskId – 将被委派的任务的 ID。
userId – 将被设置为受理人的用户 ID。
抛出：ActivitiObjectNotFoundException – 当给定 id 的任务不存在时

void delegateTask(String taskId, String userId);

/**
   * 将任务委托给另一个人,修改act_ru_task表记录
   * 如果没有任务所有者(owner_),则将该字段置为任务的当前受理人
   * 任务委托状态(delegation_)变更为PENDING
   * 当前审批人(assignee_) 变更为被委托人，类似于 setAssignee 效果
   * 
   * @param taskId 需要转交的任务节点ID
   * @param userId 被委托人
   * @throws ActivitiObjectNotFoundException 无法找到任务节点ID
   */

1
2
3

// 示例
taskService.delegateTask(taskId, toUser);
taskService.setOwner(taskId, getLoginUsername());

指定任务的归属者 owner

参数：taskId - 任务的 id，不能为空。
userId – 获得所有权的人的ID 。
抛出：ActivitiObjectNotFoundException – 当任务或用户不存在时。

1	void setOwner(String taskId, String userId);

指定任务的受理人 assignee

参数：taskId - 任务的 id，不能为空。
userId – 用作受让人的用户的 ID。
抛出：ActivitiObjectNotFoundException – 当任务或用户不存在时。

1	void setAssignee(String taskId, String userId);

被委托人完成任务

只能在此任务为DelegationState.PENDING委托时调用。此方法返回后， delegationState设置为DelegationState.RESOLVED 。

并且可以将其发送回所有者

参数：taskId - 要解决的任务的 id，不能为空。
抛出：ActivitiObjectNotFoundException – 当给定 id 的任务不存在时

void resolveTask(String taskId);

/**
   * 被加签人处理完毕,节点处理人回转到委托人
   * 只有在委托状态(delegation_)为PENDING才能执行
   * 委托状态(delegation_)变更为RESOLVED
   * 当前审批人(assignee_)变更为 委托人
   * 
   * @param taskId 任务节点ID
   * @throws ActivitiObjectNotFoundException 无法找到任务节点ID
   */

被委托人完成任务、提供流程变量

将其发送回所有者

只能在此任务为DelegationState.PENDING委托时调用。此方法返回后， delegationState设置为DelegationState.RESOLVED 。

参数：任务编号
变量
抛出：ProcessEngineException – 当不存在具有给定 ID 的任务时。

1	void resolveTask(String taskId, Map<String, Object> variables);

查询与给定任务关联的IdentityLink

这样的IdentityLink通知某个身份（例如组或用户）如何与某个任务（例如作为候选人、受托人等）相关联。

1	List<IdentityLink> getIdentityLinksForTask(String taskId);

任务添加候选人

参数：taskId - 任务的 id，不能为空。
userId - 用作候选的用户 ID，不能为空。
抛出：ActivitiObjectNotFoundException – 当任务或用户不存在时

注意：会在运行时和历史表中添加数据

1	void addCandidateUser(String taskId, String userId);

任务添加候选人组

参数：taskId - 任务的 id，不能为空。
groupId - 用作候选的组的 id，不能为空。
抛出：ActivitiObjectNotFoundException – 当任务或组不存在时。

1	void addCandidateGroup(String taskId, String groupId);

让用户参与一项任务

身份链接的类型由给定的 identityLinkType 定义。

参数：taskId - 任务的 id，不能为空。
userId – 涉及的用户ID，不能为空。
identityLinkType – identityLink 的类型，不能为 null（@see IdentityLinkType ）。
抛出：ActivitiObjectNotFoundException – 当任务或用户不存在时。

1	void addUserIdentityLink(String taskId, String userId, String identityLinkType);

让用户组参与一项任务

identityLink 的类型由给定的 identityLink 定义。
参数：taskId - 任务的 id，不能为空。
groupId - 要涉及的组的 id，不能为空。
identityLinkType –身份类型，不能为空（@see IdentityLinkType ）。
抛出：ActivitiObjectNotFoundException – 当任务或组不存在时。

1	void addGroupIdentityLink(String taskId, String groupId, String identityLinkType);

任务删除用户

参数：taskId - 任务的 id，不能为空。
userId – 涉及的用户ID，不能为空。
identityLinkType – identityLink 的类型，不能为 null。
抛出：ActivitiObjectNotFoundException – 当任务或用户不存在时。

void deleteUserIdentityLink(String taskId, String userId, String identityLinkType);

// deleteUserIdentityLink(String, String, String)便捷简写； 类型为IdentityLinkType.CANDIDATE
void deleteCandidateUser(String taskId, String userId);

任务删除用户组

参数：taskId - 任务的 id，不能为空。
groupId - 要涉及的组的 id，不能为空。
identityLinkType –身份类型，不能为空。
抛出：ActivitiObjectNotFoundException – 当任务或组不存在时

void deleteGroupIdentityLink(String taskId, String groupId, String identityLinkType);

// deleteGroupIdentityLink(String, String, String)便捷简写； 类型为IdentityLinkType.CANDIDATE
void deleteCandidateGroup(String taskId, String groupId);

更改任务的优先级

授权：实际所有者/业务管理员

参数：taskId - 任务的 id，不能为空。
优先级- 任务的新优先级。
抛出：ActivitiObjectNotFoundException – 当任务不存在时。

1	void setPriority(String taskId, int priority);

更改任务的截止日期

参数：taskId - 任务的 id，不能为空。
DueDate – 任务的新截止日期
抛出：ActivitiException – 当任务不存在时

1	void setDueDate(String taskId, Date dueDate);

返回一个新的TaskQuery ，可用于动态查询任务

1	TaskQuery createTaskQuery();

为任务返回一个新的NativeQuery

1	NativeTaskQuery createNativeTaskQuery();

任务变量

在任务上设置变量，会在act_ru_variable 和 act_hi_varinst 中添加

如果变量不存在，它将在最外层范围内创建。这意味着在此任务与执行相关的情况下的流程实例。

1	void setVariable(String taskId, String variableName, Object value);

在任务上设置变量。如果变量不存在，它将在最外层范围内创建。这意味着在此任务与执行相关的情况下的流程实例

1	void setVariables(String taskId, Map<String, ? extends Object> variables);

在任务上设置变量。如果变量不存在，它将在任务中创建。

1	void setVariableLocal(String taskId, String variableName, Object value);

在任务上设置变量。如果变量不存在，它将在任务中创建。

1	void setVariablesLocal(String taskId, Map<String, ? extends Object> variables);

获取变量并在任务范围内搜索，如果可用，还可以搜索执行范围。

1	Object getVariable(String taskId, String variableName);

获取变量并在任务范围内搜索，如果可用，还搜索执行范围

1	<T> T getVariable(String taskId, String variableName, Class<T> variableClass);

检查任务是否在任务范围内以及执行范围内是否具有使用给定名称定义的变量

1	boolean hasVariable(String taskId, String variableName);

检查任务是否具有使用给定名称定义的变量。

1	Object getVariableLocal(String taskId, String variableName);

检查任务是否具有使用给定名称定义的变量

1	<T> T getVariableLocal(String taskId, String variableName, Class<T> variableClass);

检查任务是否具有使用给定名称定义的变量，仅限本地任务范围

1	boolean hasVariableLocal(String taskId, String variableName);

获取所有变量并在任务范围内搜索，如果可用，还可以搜索执行范围。如果您有很多变量而您只需要几个，请考虑使用getVariables(String, Collection)以获得更好的性能。

1	Map<String, Object> getVariables(String taskId);

获取所有变量并仅在任务范围内搜索。如果您有许多任务局部变量而您只需要几个，请考虑使用getVariablesLocal(String, Collection)以获得更好的性能

1	Map<String, Object> getVariablesLocal(String taskId);

获取所有给定变量名的值并仅在任务范围内搜索。

1	Map<String, Object> getVariables(String taskId, Collection<String> variableNames);

获取任务的变量

1	Map<String, Object> getVariablesLocal(String taskId, Collection<String> variableNames);

获取所有变量并仅在任务范围内搜索

1	List<VariableInstance> getVariableInstancesLocalByTaskIds(Set<String> taskIds);

从任务中删除变量。当变量不存在时，什么也不会发生

1	void removeVariable(String taskId, String variableName);

从任务中删除变量（不考虑父作用域）。当变量不存在时，什么也不会发生。

1	void removeVariableLocal(String taskId, String variableName);

从任务中删除给定集合中的所有变量。不存在的变量名将被简单地忽略

1	void removeVariables(String taskId, Collection<String> variableNames);

从任务中删除给定集合中的所有变量（不考虑父作用域）。不存在的变量名将被简单地忽略。

1	void removeVariablesLocal(String taskId, Collection<String> variableNames);

任务注释

向任务和/或流程实例添加注释

1	Comment addComment(String taskId, String processInstanceId, String message);

向具有自定义类型的任务和/或流程实例添加注释

1	Comment addComment(String taskId, String processInstanceId, String type, String message);

给定流程实例相关的注释

1	List<Comment> getProcessInstanceComments(String processInstanceId);

63.给定流程实例相关的注释。

1	List<Comment> getProcessInstanceComments(String processInstanceId, String type);

返回具有给定 id 的单个评论。如果给定的 id 不存在评论，则返回 null。

1	Comment getComment(String commentId);

从提供的任务和/或流程实例中删除所有评论

1	void deleteComments(String taskId, String processInstanceId);

删除具有给定 ID 的单个评论
抛出：ActivitiObjectNotFoundException – 当给定的 id 不存在评论时。

1	void deleteComment(String commentId);

给定任务相关的评论

1	List<Comment> getTaskComments(String taskId);

给定类型的给定任务相关的注释

1	List<Comment> getTaskComments(String taskId, String type);

给定类型的所有评论

1	List<Comment> getCommentsByType(String type);

任务事件

给定任务相关的所有事件

1	List<Event> getTaskEvents(String taskId);

返回具有给定 ID 的单个事件。如果给定 id 的事件不存在，则返回 null。

1	Event getEvent(String eventId);

任务附件

向任务和/或流程实例添加新附件并使用输入流提供内容

1	Attachment createAttachment(String attachmentType,String taskId, String processInstanceId, String attachmentName, String attachmentDescription, InputStream content);

向任务和/或流程实例添加新附件并使用 url 作为内容

1	Attachment createAttachment(String attachmentType, String taskId,String processInstanceId, String attachmentName,String attachmentDescription, String url);

更新附件的名称和描述

1	void saveAttachment(Attachment attachment);

检索特定附件

1	Attachment getAttachment(String attachmentId);

检索特定附件的流内容

1	InputStream getAttachmentContent(String attachmentId);

与任务关联的附件列表

1	List<Attachment> getTaskAttachments(String taskId);

与流程实例关联的附件列表

1	List<Attachment> getProcessInstanceAttachments(String processInstanceId);

删除附件

1	void deleteAttachment(String attachmentId);

此父任务的子任务列表

1	List<Task> getSubTasks(String parentTaskId);

HistoryService

历史服务，管理所有历史数据：流程实例、活动实例、任务实例、流程变量、流程参与者

查询历史流程实例 HistoricProcessInstances

1	HistoricProcessInstanceQuery createHistoricProcessInstanceQuery();

查询历史活动实例HistoricActivityInstance

1	HistoricActivityInstanceQuery createHistoricActivityInstanceQuery();

查询历史任务实例 HistoricTaskInstances

1	HistoricTaskInstanceQuery createHistoricTaskInstanceQuery();

查询历史详情HistoricDetails

1	HistoricDetailQuery createHistoricDetailQuery();

查询原生历史详情

1	NativeHistoricDetailQuery createNativeHistoricDetailQuery();

查询历史流程变量

1	HistoricVariableInstanceQuery createHistoricVariableInstanceQuery();

查询原生历史流程变量

1	NativeHistoricVariableInstanceQuery createNativeHistoricVariableInstanceQuery();

删除历史任务实例

如果历史任务实例不存在,则不抛出异常，方法返回正常

1	void deleteHistoricTaskInstance(String taskId);

删除历史流程实例

所有历史活动、历史任务和历史细节（变量更新、表单属性）也将被删除

1	void deleteHistoricProcessInstance(String processInstanceId);

查询原生历史流程实例 HistoricProcessInstances

1	NativeHistoricProcessInstanceQuery createNativeHistoricProcessInstanceQuery();

查询原生历史任务实例HistoricTaskInstances

1	NativeHistoricTaskInstanceQuery createNativeHistoricTaskInstanceQuery();

查询原生历史活动实例HistoricActivityInstances

1	NativeHistoricActivityInstanceQuery createNativeHistoricActivityInstanceQuery();

查询与给定任务关联的HistoricIdentityLinks

这样一个IdentityLink告知一个特定的身份(例如:组或用户)与某个任务相关联(例如:作为候选者、受让者等)，即使任务已经完成，而不是只存在于活动任务中的IdentityLinks

1	List<HistoricIdentityLink> getHistoricIdentityLinksForTask(String taskId);

查询与给定流程实例关联的HistoricIdentityLink

这样的IdentityLink通知某个身份（例如，组或用户）如何与某个流程实例相关联，即使该实例已完成，而不是IdentityLink仅存在于活动实例中

1	List<HistoricIdentityLink> getHistoricIdentityLinksForProcessInstance (String processInstanceId);

查询一个流程实例的ProcessInstanceHistoryLog

1	ProcessInstanceHistoryLogQuery createProcessInstanceHistoryLogQuery(String processInstanceId);

IdentityLinkType

public static final String ASSIGNEE = "assignee";  // 受理人：认领任务的人、受托人
public static final String CANDIDATE = "candidate"; // 候选人
public static final String OWNER = "owner"; // 归属者
public static final String STARTER = "starter"; // 发起
public static final String PARTICIPANT = "participant"; // 参与者

注意

常用总结

流程实例

设置流程变量

获取流程变量

任务实例

获取流程实例-指定节点的历史任务实例

设置任务实例变量

获取任务实例变量

获取任务历史关联人信息

RepositoryService

创建一个流程模型

保存模型

删除模型

保存模型的模型编辑器源

保存模型的额外的模型编辑器源

查询模型

查看模型

返回模型编辑器源

返回模型额外编辑器源

创建新部署

删除给定的部署

删除给定的部署并级联删除流程实例、历史流程实例和作业

删除给定的部署

设置部署的类别

查询部署资源列表

通过字节流访问部署资源

更改部署的租户标识符以匹配给定的租户标识符

查询流程定义

查询流程定义

查询部署

挂起流程定义

挂起流程定义

挂起流程定义

激活流程定义

激活流程定义

激活流程定义

设置流程定义的类别

查看流程模型、流程定义、流程图

检查流程定义是否挂起

流程定义添加候选启动用户

流程定义授权候启动选组

删除流程定义候选启动用户

删除流程定义的候选启动组

查询流程定义关联的IdentityLink

根据在 Activiti 引擎上执行流程定义的规则验证给定的流程定义

RuntimeService

启动一个流程实例ByKey

启动一个流程实例 ，但使用特定的租户标识符

启动一个流程实例ById

根据消息启动流程实例

删除运行时流程实例

查找活动中等待的所有执行的活动 ID

将外部触发器发送到在给定执行中等待的活动实例

将外部触发器发送到在给定执行中等待的活动实例。

更新流程实例的businessKey

给流程实例添加涉及的用户

给流程实例添加涉及的用户组

删除流程实例涉及的用户

删流程实例涉及的用户组

获取流程实例涉及的用户

从给定的执行范围（包括父范围）可见的所有变量

从给定的执行范围（包括父范围）可见的所有变量

从给定的执行范围（包括父范围）可见的所有变量

从给定的执行范围（包括父范围）可见的所有变量

在执行范围内定义的所有变量值，不考虑外部范围

在执行范围内定义的所有变量值，不考虑外部范围

在执行范围内定义的所有变量值，不考虑外部范围

所有给定 variableNames 的变量值都考虑了从给定执行范围（包括父范围）可见的所有变量。

所有给定 variableNames 的变量值都考虑了从给定执行范围（包括父范围）可见的所有变量

所有给定 variableNames 的变量值都考虑了从给定执行范围（包括父范围）可见的所有变量

给定 variableNames 的变量值仅考虑给定的执行范围，而不考虑外部范围

给定 variableNames 的变量值仅考虑给定的执行范围，而不考虑外部范围

给定 variableNames 的变量值仅考虑给定的执行范围，而不考虑外部范围

获取执行实例的变量值

获取执行实例的变量实例

获取执行实例的变量实例

获取执行实例的变量值

检查此执行是否具有使用给定名称设置的变量，在给定执行可见的所有范围（包括父范围）中搜索变量

执行的变量值

启动一个流程实例，但使用特定的租户标识符

执行的变量值。当为执行设置变量时（而不是搜索父作用域），返回转换为给定类的值。当没有找到具有给定名称的变量值或该值设置为 null 时，返回 null

为执行更新或创建变量（不考虑父作用域）。如果变量不存在，它将在给定的执行中创建。

为执行更新或创建给定变量（不考虑父作用域）。如果变量不存在，它将在给定的执行中创建

使用给定的 id 激活流程实例。如果您有一个流程实例层次结构，从层次结构中挂起一个流程实例不会从该层次结构中挂起其他流程实例

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给所有等待该信号的执行

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给所有等待该信号的执行

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给所有等待该信号的执行

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给单个执行，即由“executionId”引用的执行。同步通知等待执行

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给单个执行，即由“executionId”引用的执行。同步通知等待执行

通知流程引擎已收到名称为“signalName”的信号事件。此方法将信号传递给单个执行，即由“executionId”引用的执行。异步通知等待执行

通知流程引擎已收到名为“messageName”的消息事件，并已将其与 ID 为“executionId”的执行相关联。同步通知等待执行

通知流程引擎已收到名为“messageName”的消息事件，并已将其与 ID 为“executionId”的执行相关联。同步通知等待执行

通知流程引擎已收到名为“messageName”的消息事件，并已将其与 ID 为“executionId”的执行相关联。异步通知等待执行

从此调度程序中删除给定的侦听器。无论最初注册的类型是什么，侦听器都不会再收到通知