Activiti-相关API
本文介绍与Activiti工作流具体操作相关的API。
第一部分 几个Service相关的API
1.流程定义API--RepostoryService API
activiti.cfg.xml是一个spring依赖注入的xml文件，其具体内容可以参考
Spring集成activiti
测试类
public class ProcessDefinitionTest {
// activitii.cfg.xml已经在classpath目录下，直接加载默认的流程引擎即可
private ProcessEngine processEngine = processEngines.getDefaultProcessEngine();
}1.1 部署流程定义
和流程部署相关的表
| 表名 | 中文名 | 解释 |
|---|---|---|
| act_re_deployment | 部署对象信息表 | 存放流程定义的显示名称和部署时间，部署一次增加一条记录，注意：当流程定义的key相同的情况下，使用的是版本升级 |
| act_re_procdef | 流程定义表 | 存放流程定义的属性信息，部署每一个新的流程定义都会在这张表中增加一条记录 |
| act_ge_bytearray | 资源文件表 | 存储流程定义相关的部署信息，即流程定义文档的存放地。每部署一次就会增加两条记录，一条是关于bpmn规则文件的，一条是图片的（如果部署时只指定了bpmn一个文件，activiti会在部署时解析bpmn文件内容自动生成流程图），两个文件不是很大，都是以二进制形式存储在数据库中。 |
| act_ge_property | 主键生成策略表 | - |
从classpath部署流程
@Test
public void deploymentProcessDefinition_classpath() {
Deployment deployment = processEngine.getRepositoryService() // 获取流程定义和部署对象相关的Service
.createDeployment() // 创建一个部署对象
.name("helloworld入门程序") //添加部署名称
.addClasspathResource("diagrams/helloworld.bpmn") // 从classpath的资源中加载，一次只能加载一个文件
.addClasspathResource("diagrams/helloworld.png") // 从classpath的资源中加载，一次只能加载一个文件
.deploy(); // 完成部署
System.out.println(deployment.getId()); // 1
System.out.println(deployment.getName()); // helloworld入门程序
}从zip部署流程
// 从zip部署流程
// 打包helloworld文件，包含helloworld.bpmn, helloworld.png, 存放到classpath目录下
@Test
public void deploymentProcessDefinition_zip() {
InputStream in = this.getClass().getClassLoader().getResourceAsStream("diagrams/helloworld.zip")
ZipInputStream zipInputStream = new ZipInputStream(in);
// 1.部署流程定义-- activitii.cfg.xml已经在classpath目录下，直接加载默认的流程引擎即可
ProcessEngine processEngine = processEngines.getDefaultProcessEngine();
Deployment deployment = processEngine.getRepositoryService() // 获取流程定义和部署对象相关的Service
.createDeployment() // 创建一个部署对象
.name("helloworld入门程序") //添加部署名称
.addZipInputStream(zipInputStream) // 指定zip格式的文件完成部署
.deploy(); // 完成部署
System.out.println(deployment.getId()); // 1
System.out.println(deployment.getName()); // helloworld入门程序
}inputStream方式部署
// 通过addInputStream 方式部署流程定义实现--此处从绝对路径，即classpath下查找bpmn和png资源
@Test
public void deploymentProcessDefinition_inputstream() {
InputStream bmpnInputstream = this.getClass().getResourceAsStream("/diagrams/processVariables.bpmn");
InputStream pngInputstream = this.getClass().getResourceAsStream("/diagrams/processVariables.bpmn");
Deployment deployment = processEngine.getRepositoryService()
.createDeployment()
.name("流程定义")
.addInputStream("processVariables.bpmn", bmpnInputstream)
.addInputStream("processVariables.png", pngInputstream)
.deploy();
System.out.println("DEPLOYMENT_ID: " + deployment.getId());
System.out.println("DEPLOYMENT_NAME: " + deployment.getName());
}几种获取inputStrem的方式及其异同
当testVariables.bpmn文件存在于 /src/main/java/processDefine/helloworld.bpmn目录下且下面的代码在helloworld.bpmn的同目录下的类中时，有以下几种获取InputStream的方式
// 从类加载器中加载input stream
InputStream is = this.getClass().getClassLoader().getResourceAsStream("processDefine/helloworld.bpmn") // 类加载器
// 从当前类的包下找
InputStream is = this.getClass().getResourceAsStream("helloworld.bpmn")
// 从classpath下找
InputStream is = this.getClass().getResourceAsStream("/processDefine/helloworld.bpmn")1.2 查询流程定义
查询流程定义
// 查询流程定义
@Test
public void findProcessDefinition() {
List<ProcessDefinition> list = processEngine.getRepositoryService() // 与部署和流程定义相关的service
.createProcessDefinitionQuery() // 创建一个流程定义查询
// 指定查询条件，where条件
// .deploymentId(deploymentId) // 使用部署对象ID查询
// .processDefinitionId(processDefinitionId) // 使用流程定义Id查询
// .processDefinitionKey(processDefinitionKey) // 使用流程定义的key查询
// .processDefinitionNameLike(processDefinitionNameLike) // 使用流程定义的名称模糊查询
// 排序
// .orderByProcessDefinitionVersion().asc() // 按照版本的升序排序
.orderByProcessDefinitionName().desc() // 按照流程定义的名称降序排序
// 返回的结果集
.list(); // 返回一个集合列表，封装流程定义
// .singleResult(); // 返回唯一结果集
// .count(); // 返回结果集数量
// .listPage(firstResult, maxResults); // 分页查询
if (list != null && list.size() > 0) {
for (ProcessDefinition pd:list) {
System.out.println("流程定义Id： " + pd.getId()); // 流程定义的key + 版本 + 随机生成树
System.out.println("流程定义名称： " + pd.getName()); // 对应helloworld.bpmn文件中的name属性值
System.out.println("流程定义的key： " + pd.getKey()); // 对应helloworld.bpmn文件中的id属性值
System.out.println("流程定义的版本： " + pd.getVersion()); // 流程定义key相同时，版本升级
System.out.println("资源名称bpmn文件： " + pd.getResourceName());
System.out.println("资源名称png文件： " + pd.getDaigramResourceName());
System.out.println("部署对象ID: " + pd.DeploymentId());
}
}
}查询所有最新的流程定义
// 查询所有最新版本的流程定义
@Test
public void findLastVersionProcessDefinition() {
List<ProcessDefinition> list = ProcessEngine processEngine = processEngines.getDefaultProcessEngine()
.createProcessDefinitionQuery()
.orderByProcessDefinitionVersion().asc() // 使用流程定义的升序排列
.list();
Map<String, ProcessDefinition> map = new LinkedHashMap<>();
if (list != null && list.size() > 0) {
for (ProcessDefinition pd : list) {
map.put(pd.getKey(), pd);
}
}
List<PorcessDefinition> pdList = new ArrayList<>(map.values());
if (pdList != null && pdList.size() > 0) {
for (ProcessDefinition pd:pdList) {
System.out.println("流程定义Id： " + pd.getId()); // 流程定义的key + 版本 + 随机生成树
System.out.println("流程定义名称： " + pd.getName()); // 对应helloworld.bpmn文件中的name属性值
System.out.println("流程定义的key： " + pd.getKey()); // 对应helloworld.bpmn文件中的id属性值
System.out.println("流程定义的版本： " + pd.getVersion()); // 流程定义key相同时，版本升级
System.out.println("资源名称bpmn文件： " + pd.getResourceName());
System.out.println("资源名称png文件： " + pd.getDaigramResourceName());
System.out.println("部署对象ID: " + pd.DeploymentId());
}
}
}小结
- 流程定义和部署对象相关的service都是RepositoryService
- 创建流程定义查询对象，可以在ProcessDefinitionQuery上设置查询的相关参数
- 调用ProcessDefinitionQuery对象的list方法，执行查询，获得符合条件的流程定义列表
- 运行结果可以看出，
Key和Name的值为：bpmn文件process节点的id和name的属性值
<process id="LeaveFlow" name="请假流程" isExecutable="true"> - key属性被用来区别不同的流程定义
- 带有特定key的流程定义第一次部署时，版本为1.之后每次部署都会在当前最高版本号上加1
- Id的值的生成规则为: {processDefinitionKey}:{processDefinitionVersion}:{generated-id}，这里的generated-id是一个自动生成的唯一的数字
- 重复部署一次，deploymentId的值以一定的形式变化，规则act_ge_property表生成
1.3 删除流程定义
删除流程定义--根据部署ID删除
// 删除流程定义
@Test
public void deleteProcessDefinition() {
String deploymentId = "1";
// 不带级联的删除
// 只能删除没有启动的流程，如果流程启动，就会抛出异常
// processEngine.getRepositoryService()
// .deleteDeployment(deploymentId);
// 级联删除
// 不管流程是否启动，都可以删除
processEngine.getRepositoryService()
.deleteDeployment(deploymentId, true);
System.out.println("删除成功！");
}删除流程定义--删除key相同的所有不同版本的流程定义
// 删除流程定义（删除key相同的所有不同版本的流程定义）
@Test
public void deleteProcessDefinitionByKey() {
String processDefinitionKey = "helloworld";
// 先使用流程定义的key查询流程定义，查询出所有的版本
List<ProcessDefinition> list = processEngine.getRepositoryService()
.createProcessDefinitionQuery()
.processDefinitionKey(processDefinitionKey)
.list();
// 遍历删除
if (list != null && list.size() > 0) {
for (ProcessDefinition pd:list) {
// 获取部署ID
String deploymentId = pd.getDeploymentId();
processEngine.getRepositoryService()
.deleteDeployment(deploymentId, true);
}
}
}小结
- 因为删除的是流程定义，而流程定义的部署是属于仓库服务的，所以应该先得到RepositoryService
- 如果该流程定义下没有正在运行的流程，则可以用普通删除。如果是有关联的信息，用级联删除。项目开发中使用级联删除的情况比较多，删除操作一般只开放给超级管理员使用。
1.4 查看流程图
// 查看流程图
@Test
public void viewPic() throws IOException {
// 将生成的图片放置到文件夹下
String deploymentId = "801"; // act_ge_bytearray 表中的deployment_id字段
// 获取图片资源名称
List<String> list = processEngine.getRepositoryService()
.getDeploymentResourceNames(deploymentId); // 两个值，一个是bpmn文件名，一个是png文件名
String resourceName = "";
if (list != null && list.size() > 0) {
for (String name : list) {
if (name.indexOf(".png") >= 0) {
resourceName = name;
}
}
}
InputStream in = processEngine.getRepositoryService()
.getResourceAsStream(deploymentId, resourceName);
// 将图片生成到D盘的目录下
File file = new File("D://" + resourceName);
// 将输入流的图片写到D盘下
FileUtils.copyInputStreamToFile(in, file);
}2.运行时RuntimeService API
流程实例对象：ProcessInstance代表流程定义的实例。如范冰冰请了一天的假，她就必须发出一个流程实例的申请。一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。流程实例就表示一个流程从开始到结束的最大的流程分支，即一个流程中流程实例只有一个。
执行对象：Activiti 用这个对象去描述流程执行的每一个节点。在没有并发的情况下，Execution就是同 ProcessInstance。流程按照流程定义的规则执行一次的过程，就可以表示执行对象Execution。
流程图依旧接着第一部分的流程图（helloworld.bpmn）。
在做后面的启动流程实例和完成任务的过程中，完成以下查询。
select * from act_ru_execution # 正在执行的执行对象列表
select * from act_hi_procinst # 流程实例的历史列表，启动一个流程，产生一个流程实例历史记录，直到流程结束也只产生这一笔 记录
select * from act_ru_task # 正在执行的任务表（只有节点是UserTask的时候，该表中才会有数据）
select * from act_hi_taskinst # 任务历史表（只有节点是UserTask的时候，该表中才会有数据）
select * from act_hi_actinst # 所有活动节点的历史表（包括开始节点，任务节点，结束节点等）测试类
public class ProcessInstanceTest {
// activitii.cfg.xml已经在classpath目录下，直接加载默认的流程引擎即可
private ProcessEngine processEngine = processEngines.getDefaultProcessEngine();
}2.1 启动流程实例
// 启动流程实例
// 默认启动最新版本的流程
@Test
public void startProcessInstance() {
String processEngine = "helloworld";
ProcessInstance pi = processEngine.getRuntimeService()
.startProcessInstanceByKey(processDefinitionKey) // 使用流程定义的key启动实例，key对应helloworld.bpmn中Propertes流程的Id属性值
System.out.println(pi.getId()); // 流程实例Id 101
System.out.println(pi.getProcessDefinitionId()); // 流程定义Id： 1:4
}做一下如下查询
select * from act_ru_execution
select * from act_hi_procinst会发现，流程实例和执行对象相同。
2.2 查询流程状态
查询运行时是否存在流程实例来判断流程是正在进行中还是已结束。
// 查询流程状态（判断流程正在执行，还是结束）
@Test
public void isProcessEnd() {
String processInstanceId = "1001";
ProcessInstance pi = processEngine.getRuntimeService() // 正在执行的流程实例和执行对象
.createProcessInstanceQuery() // 创建流程实例查询
.processInstanceId(processInstanceId) // 根据流程实例ID查询
.singleResult();
if (pi == null) {
System.out.println("流程已结束");
} else {
System.out.println("流程没有结束");
}
}3.TaskService API
流程图接着第一部分的流程图（helloworld.bpmn）。
测试类接着第二部分的测试类。
3.1 查询指定人（assignee）的用户的用户任务
// 查询当前人的个人任务
@Test
public void findMyPersonTask() {
String assignee = "张三";
List<Task> list = processEngine.getTaskService() // 与正在执行的任务管理相关的service;
.createTaskQuery()
// 查询条件，where部分
.taskAssignee(assignee) // 指定个人任务查询，指定办理人
// .taskCandidateUser(candidateUser) // 组任务的办理人查询
// .processDefinitionId(processDefinitionId) // 使用流程定义ID查询
// .processInstanceId(processInstanceId) // 使用流程实例ID查询
// .executionId(executionId) // 使用执行对象ID查询
// 排序
// .orderByTaskDescription().asc() //
// .orderByTaskAssignee().asc() // 按处理
// .orderByTaskCreateTime().asc() // 按照创建时间排序
// 返回结果集
// .singleResult(); // 范围唯一结果集
// .count(); // 返回结果集的数量
// .listPage(first, max); // 分页查询
.list(); // 返回列表
if (list != null && list.size() > 0) {
for (Task task: list) {
System.out.println("任务Id：" + task.getId());
System.out.println("任务名称：" + task.getName());
System.out.println("任务创建时间：" + task.getCreateTime());
System.out.println("任务办理人：" + task.getAssignee());
System.out.println("流程实例ID：" + task.getProcessInstanceId());
System.out.println("执行对象ID：" + task.getExecutionId());
System.out.println("流程定义ID：" + task.getProcessDefinitionId());
System.out.println("######################################################");
}
}
}3.2 完成任务
// 完成我的任务
@Test
public void completeMyPersonTask() {
String taskId = "104";
processEngine.getTaskService()
.complete(taskId);
System.out.println("完成任务，任务ID： " + taskId);
}4.HistoryService API
测试类
public class HistoryQueryTest {
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
}4.1 查询指定某人的历史任务
// 根据历史任务办理人查询历史任务
@Test
public void findHistoryTask() {
String taskAssignee = "张三";
List<HistoricTaskInstance> list = processEngine.getHistoryService() // 与历史数据（历史表）相关的service
.createHistoricTaskInstanceQuery()
.taskAssignee(taskAssignee) // 指定历史任务的办理人
.list();
if (list != null && list.size() > 0 ) {
for (HistoricTaskInstance hti: list) {
System.out.println(hti.getId() + " " + hti.getName() + " " + hti.getProcessInstanceId() + " " + hti.getStartTime()
+ " " + hti.getEndTime() + " " + hti.getDurationInMillis());
System.out.println("####################################################");
}
}
}4.2 流程执行完后，可以根据流程实例ID查询流程历史
流程执行完后，历史流程实例的endTime，durationInMillis将会有数据，在执行完之前，endTime，durationInMillis为空。
// 根据流程实例ID查询历史流程实例
@Test
public void findHistoryProcessInstance() {
String processInstanceId = "1001";
HistoricProcessInstance hpi = processEngine.getHistoryService()
.createHistoricProcessInstanceQuery() // 历史流程实例查询
.processInstanceId(processInstanceId) // 使用流程实例ID查询
.singleResult();
System.out.println(hpi.getId() + ", " +
hpi.getProcessDefinitionId() + ", " +
hpi.getStartTime() + ", " +
hpi.getEndTime() + ", " +
hpi.getDurationInMillis());
}4.3 根据流程实例ID查询历史流程实例
@Test
public void findHistoryProcessInstanceHistory() {
String processInstanceId = "";
HistoryProcessInstance hpi = processEngine.getHistoryService()
.createHisotricProcessInstanceQuery()
.processInstanceId(processInstanceId()
.singleResult();
}4.4 根据流程实例ID查询历史活动
@Test
public void findHisotryActiviti() {
String processInstanceId=""
List<HistoricActivityInstance> list = processEngine.getHistoryService();
.createHistoricActivityInstanceQuery()
.processInstanceId(processInstanceId())
.orderByHistoricActivityInstanceStartTime().asc()
.list();
// 遍历并打印：活动类型，开始时间，结束时间，活动耗时
// sysout: list-> hai: activityType, startTime, endTime, durationInMillis
}4.5 根据流程实例ID查询历史任务
@Test
public void findHistoricTask() {
String processInstanceId=""
List<HistoricTaskInstance> list = processEngine.getHistoryService();
.createHistoricTaskInstanceQuery()
.processInstanceId(processInstanceId)
.orderByHistoricTaskInstanceStartTime().asc()
.list();
// 遍历并打印：任务ID，任务名称，流程实例ID，开始时间，结束时间，任务完成耗时
// sysout: list-> hai: id, name, processInstanceId, startTime, endTime, durationInMillis
}4.6 根据流程实例ID查询历史变量
@Test
public void findHistoryVariables() {
String processInstanceId=""
List<HistoricVariableInstance> list = processEngine.getHistoryService();
.createHistoricVariableInstanceQuery()
.processInstanceId(processInstanceId)
.orderByHistoricTaskInstanceStartTime().asc()
.list();
// 遍历并打印：流程变量ID，流程实例ID，变量名，变量类型名，变量值
// sysout: list-> hai: id, processInstanceId, variableName, variableTypeName, value
}第二部分 核心知识点
1.流程变量
流程变量的作用：
- 用来传递业务参数
- 指定连线完成任务（同意和拒绝）
- 动态指定任务的办理人
和流程变量相关的表：
| column | 中文名 |
|---|---|
| act_ru_variable | 正在执行的流程变量表 |
| act_hi_varinst | 历史的流程变量表 |
测试类定义如下
public class ProcessVariablesTest {
ProcessEngine processEngine = ProccessEngines.getDefaultProcessEngine();
// 部署流程定义，此处建议采用inputStream方式部署，参考流程定义部分代码
// 启动流程代码
}processVariables.bpmn
流程变量支持的数据类型
string
long
double
serializable
binary
date
short
integer1.1 在任务中设置流程变量--taskService
// 设置流程变量
@Test
public void setVariables() {
// 与任务相关的，正在执行的
TaskService taskService = processEngine.getTaskService();
String taskId = "1504";
// 设置流程变量，使用基本数据类型
taskService.setVariableLocal(taskId, "请假天数", 3); // 与任务ID绑定，当任务流转到下一个任务时，将不能再查询到这个参数
taskService.setVariable(taskId, "请假日期", new Date());
taskService.setVariable(taskId, "请假原因", "回家探亲");
System.out.println("设置流程变量成功！");
}1.2 获取流程变量
// 获取流程变量
@Test
public void getVariables() {
// 与任务相关的，正在执行的
TaskService taskService = processEngine.getTaskService();
String taskId = "1504";
Integer days = (Integer)taskService.getVariable(taskId, "请假天数");
Date date = (Date)taskService.getVariable(taskId, "请假日期");
String reason = (String)taskService.getVariable(taskId, "请假原因");
System.out.println("请假天数：" + days + ", 请假日期： " + date + ", 请假原因： " + reason);
}1.3 其它几种设置流程变量的方式
用HashMap同时设置多个参数--runtimeService和taskService均可设置流程变量
runtimeService.setVariables(executionId, variables) // variables: Map集合，表示使用执行对象ID和Map集合设置流程变量的名称，map集合的value就是变量的值
taskService.setVariable(taskId, variab****les) // variables: Map集合启动流程实例时设置流程变量
runtimeService.startProcessInstanceByKey(processDefinitionKey, variables) // 表示启动流程实例的时候可以设置map参数完成任务时设置流程变量
taskService.complete(taskId, variables) // 表示完成实例的时候可以设置map参数设置流程变量仅在当前任务有效--Local
runtimeService.setVariableLocal(executionId, variableName, value)
taskService.setVariableLocal(executionId, variableName, value)1.4 其它几种获取流程变量的方式
根据variableName获取值--runtimeService和taskService均可获取流程变量
runtimeService.getVariable(executionId, variableName) // 使用执行对象Id，和流程变量的名称，获取流程变量的值
taskService.getVariable(taskId, variableName) // 使用任务Id，和流程变量的名称，获取流程变量的值根据执行对象ID或taskId获取键值的HashMap集合（全部的）
runtimeService.getVariables(executionId) // 使用执行对象Id，将流程变量放置到Map集合中
taskService.getVariables(taskId) // 使用任务Id，将流程变量放置到Map集合中传入指定的variableNames（HashMap）获取键值的HashMap集合（指定name的）
runtimeService.getVariables(executionId, variableNames) // 使用执行对象ID获取流程变量的值，通过设置流程变量的名称存放到一个集合中，获取指定流程变量名称的流程变量值的集合
taskService.getVariables(taskId, variableNames) // 使用任务Id获取流程变量的值，通过设置流程变量的名称存放到一个集合中，获取指定流程变量名称的流程变量值的集合1.5 汇总
// 模拟设置和获取流程变量的场景
@Test
public void setAndGetVariables() {
// 与流程实例，执行对象相关的
RuntimeService runtimeService = processEngine.getRuntimeService()
// 与任务相关的，正在执行的
TaskService taskService = processEngine.getTaskService();
// runtimeService.setVariable(executionId, variableName, value) // 表示使用执行对象ID，和流程变量的名称，设置流程变量的值（一次只能设置一个值）
// runtimeService.setVariables(executionId, variables) // variables: Map集合，表示使用执行对象ID和Map集合设置流程变量的名称，map集合的value就是变量的值
// taskService.setVariable(taskId, variableName, value)
// taskService.setVariable(taskId, variables) // variables: Map集合
// runtimeService.startProcessInstanceByKey(processDefinitionKey, variables) // 表示启动流程实例的时候可以设置map参数
// taskService.complete(taskId, variables) // 表示完成实例的时候可以设置map参数
// 获取流程变量
// runtimeService.getVariable(executionId, variableName) // 使用执行对象Id，和流程变量的名称，获取流程变量的值
// runtimeService.getVariables(executionId) // 使用执行对象Id，将流程变量放置到Map集合中
// runtimeService.getVariables(executionId, variableNames) // 使用执行对象ID获取流程变量的值，通过设置流程变量的名称存放到一个集合中，获取指定流程变量名称的流程变量值的集合
// taskService.getVariable(taskId, variableName) // 使用任务Id，和流程变量的名称，获取流程变量的值
// taskService.getVariables(taskId) // 使用任务Id，将流程变量放置到Map集合中
// taskService.getVariables(taskId, variableNames) // 使用任务Id获取流程变量的值，通过设置流程变量的名称存放到一个集合中，获取指定流程变量名称的流程变量值的集合
}1.6 传参-javabean
定义Person类
public class Person implements Serializable{
private Integer id;
private String name;
// getter ... setter ...
}设置流程变量
Person p = new Person();
p.setId(10);
p.setName("翠花");
taskService.setVariable(taskId, "人员信息", p);值得注意的是，serializable类型的参数值是二进制类型的，会存放到 act_ge_bytearray 表中，当一个javabean（实现序列化）放置到流程变量中，要求javabean的属性不能再发生变化，如果发生变化，再获取的时候，抛出异常（假定你在Person中再加一个education属性，那么你再获取先前set的值，则取不出来了），要解决这个问题，需要给Person类添加序列化ID。
publlic static final long serialVersionUID=253678908763728903L;获取person
@Test
public void getVariables() {
Person p = (Person) taskService.getVariable(taskId, "人员信息");
System.out.println("person.id = " + p.getId() + ", person.name = " + p.getName());
}1.7 查询历史的流程变量
@Test
public void findHistoryProcessVariables() {
List<HistoricVariableInstancce> list = processEngine.getHistoryService()
.createHistoricVariableInstanceQuery()
.variableName("请假天数")
.list();
if(list != null and list.size > 0) {
for (HistoricVariableInstancce hvi: list) {
System.out.println("id = " + hvi.getId()
+ ", processInstanceId = " + hvi.getProcessInstanceId()
+ ", variableName = " + hvi.getVariableName()
+ ", variableValue = " + hvi.getVariableValue());
System.out.println("######################");
}
}
}2.连线
流程图
测试类
public class SequenceFlowTest {
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 部署流程
// 启动流程实例
}参数传入“不重要”，走连线a
// 完成个人任务
@Test
public void completePersonProcess() {
String taskId = "";
Map<String, Object> variables = new HashMap<>();
variables.put("message", "不重要");
proccessEngine.getTaskService
.complete(taskId, variables);
System.out.println("taskId = " + taskId);
}参数传入“重要”，走连线b
// 完成个人任务2 -- 会执行到总经理再结束
@Test
public void completePersonProcess() {
String taskId = "";
Map<String, Object> variables = new HashMap<>();
variables.put("message", "重要");
proccessEngine.getTaskService
.complete(taskId, variables);
System.out.println("taskId = " + taskId);
}3.排他网关
流程图
测试类
public class ExclusiveGateWayTest {
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 部署流程
// 启动流程实例
}完成任务--money参数分别传入800,1200,300
// 完成任务
completeMyPersonTask() {
String taskId = "";
Map<String, Object> variables = new HashMap<>();
variables.put("money", 800); // 800 -> 部门经理射频
// 1200 -> 总经理
// 300 -> 财务
proccessEngine.getTaskService
.complete(taskId, variables);
sysout: taskId
}小结
- 一个排他网关对应一个以上的顺序流
- 由排他网关流出的顺序流都有个conditionExpression 元素，在内部维护返回boolean类型的决策结果。
- 决策网关只会返回一条结果，当流程执行到排他网关时，流程引擎会自动检索网关出口，从上到下检索如果发现第一条决策结果为true或者没有设置条件的（默认为成立），则流出。
- 如果没有任何一个出口符合条件，则抛出异常。
- 如果流程变量，设置连线的条件，并按照连线的条件执行工作流，如果没有符合的条件，则以默认的连线（Default Flow）离开。
4.并行网关
并行网关可以表示分支和聚合 -- 流程实例和执行对象将不再是同一个
流程图
测试类
public class ParallelGateWayTest {
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 部署流程
// 启动流程实例
}依次完成任务
// 完成任务
@Test
public void completeMyPersonTask() {
String taskId = "";
proccessEngine.getTaskService()
.complete(taskId);
sysout: taskId
}流程执行过程
当启动流程实例时
select * from act_ru_execution
3条记录，一个流程实例，两个执行对象
act_hi_procinst 流程实例的历史表
1条记录
act_ru_task 正在执行的任务
2个，付款和发货
act_hi_taskinst 历史任务表
2个，付款和发货
act_hi_actinst 历史活动
4个，付款，发货，开始和并行网关当所有任务完成后
select * from act_ru_execution
0
act_hi_procinst 流程实例的历史表
1条记录
act_ru_task 正在执行的任务
0
act_hi_taskinst 历史任务表
4个，付款，发货，收货，收款
act_hi_actinst 历史活动
9个，付款，发货，收货，收款，开始，结束，并行网关1（分支），并行网关2-商家（聚合），并行网关2-厂家（聚合）小结
- 一个流程中流程实例只有1个，执行对象有多个
- 并行网关的功能是基于进入和外出的顺序流的：
分支：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支
聚合：所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关 - 并行网关的进入和外出都是使用相同节点标识
- 如果同一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能。这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。
- 并行网关并不会解析条件。即使顺序流中定义了条件，也会被忽略。
- 并行网关不需要是“平衡的”（比如，对应并行网关的进入和外出节点数目不一定相等）
5.开始活动
流程图
开始活动节点流程图就是从开始节点直接到结束节点，基本上没多大意义。
代码
小结
- 结束节点没有出口
- 其它节点有一个或多个出口
如果有一个出口，则代表是一个单线流程
如果有多个出口，则代表是开启并发流程
6.接收任务活动
概念
接收任务是一个简单任务，它会等待对应消息的到达。当前，官方只实现了这个任务的java语义。当流程达到接收任务，流程状态会保存到数据库中。
在任务创建后，意味着流程会进入等待状态直到引擎接收了一个特定的消息，这会触发流程穿过接收任务继续执行。
流程图
代码
// 启动流程实例推断流程是否结束 + 查询历史
@Test
public void startProcessInstance() {
// 流程定义的key
String processDefinitionKey = "receiveTask";
ProcessInstance pi = processEngine.getRuntimeService() // 与正在执行的流程实例和执行对象相关的 Service
.startProcessInstanceByKey(processDefinitionKey); // 使用 流程定义的key启动流程实例，key对应helloworld.bpmn文件中id属性的值
System.out.println("流程实例ID：" + pi.getId());
System.out.println("流程实例ID：" + pi.getId());
// 查询执行对象ID
Execution execution1 = processEngine.getRuntimeService()
.createExecutionQuery() // 创建执行对象查询
.processInstanceId(pi.getId()) // 使用流程实例ID查询
.activityId("receivetask1") // 当前活动的id，对应receiveTask.bpmn文件中的活动节点id的属性值
.singleResult();
// 使用流程变量设置当日销售额，用来传递业务参数
processEngine.getRuntimeService()
.setVariable(execution1.getId(), "汇总当日销售额", 21000);
// 向后执行一步，如果流程处于等待状态，使得流程继续执行
processEngine.getRuntimeService()
.signal(execution1.getId());
// 查询执行对象ID
Execution execution2 = processEngine.getRuntimeService()
.createExecutionQuery() // 创建执行对象查询
.processInstanceId(pi.getId()) // 使用流程实例ID查询
.activityId("receivetask2") // 当前活动的id，对应receiveTask.bpmn文件中的活动节点id的属性值
.singleResult();
// 向后执行一步，如果流程处于等待状态，使得流程继续执行
processEngine.getRuntimeService()
.signal(execution2.getId());
// 执行完后，流程结束
}小结：
- 当前任务（一般指机器自动完成，但需要耗费一定时间的工作）完成后，向后推移流程，可以调用runtimeService.signal(executionId)，传递接收执行对象的ID
- receiveTask在act_ru_task表中是不会产生数据的
7.任务分配
任务分配包括个人任务分配和组任务分配，两者均存在3种任务分配方式：
- 直接指定办理人--先前的任务分配均是此种，指定具体的人来办理；
- 使用流程变量动态分配；
- 实现 org.activiti.engine.delegate.TaskListener 接口动态分配任务。
7.1 个人任务分配
Ⅰ 直接指定任务办理人
略，前面几节讲的都是直接在流程定义中指定Assignee来指定任务办理人。
Ⅱ 使用流程变量动态分配任务办理人
如下图所示，在任务的Properties中指定Assignee为一个变量${userId}
我们可以在流程启动时，指定流程变量userId
Map<String, Object> variables = new HashMap<>();
variables.put("userId", "周芷若");
processEngine.getRuntimeService().startProcessInstanceByKey(processInstanceKey, variables);当然，你也可以在其它地方指定流程变量userId，譬如，本次任务完成时，指定下一个任务的办理人，在某个条件下通过taskService.setVariable(taskId, "userId", "王五");来指定任务办理人。
Ⅲ 实现 org.activiti.engine.delegate.TaskListener 接口动态分配任务。
先设置Main Config下的Assignee的值为空
在Listener下，指定类 TaskListenerImpl ，实现接口org.activiti.engine.delegate.TaskListener
New的内容如下：
Event=create
Type=java class
点击Select Class去选择TaskListenerImplTaskListenerImpl 类定义如下
public class TaskListenerImpl implements TaskListener {
public void notify(DeletegateTask delegateTask) {
// 指定个人任务的办理人，也可以指定组任务的办理人
// 个人任务：通过类去查询数据库，将下一个任务的办理人查询获取，然后通过 setAssignee() 方法指定任务的办理人
delegateTask.setAssignee("灭绝师太");
}
}在启动流程实例时，会执行回调函数。
当然，你也可以在指定了任务办理人后再重新分配任务办理人(认领任务)。
String taskId = "5804";
String userId = "张翠山";
processEngine.getTaskService()
setAssignee(taskId, userId);小结
个人任务及三种分配方式：
- 在taskProcess.bpmn中直接写assignee="张三丰"
- 在taskProcess.bpmn中写 assignee="#{userId}"，变量的值是String的。使用流程变量指定办理人。
- 使用TaskListener接口，要使类实现该接口，在实现方法中调用 delegateTask.setAssignee(assignee) 来指定个人任务的办理人。
最后，还可以通过任务ID和办理人重新指定办理人：
processEngine.getTaskService().setAssignee(taskId, userId);7.2 组任务分配
流程图
和组任务相关的表
a.任务表（个人任务，组任务）
select * from act_ru_identitylink
-- 其中字段 TYPE的值有如下两个：
participant // 参与者
candidate // 候选者b.历史任务办理人表
select * from act_hi_identitylink
该表中，个人任务的TYPE_都为participant（参与者）
每一个组任务用户的TYPE_包含participant和candidate两条数据做如下操作
1.部署流程
2.启动流程实例Ⅰ 直接指定任务办理人
查询我的组任务
// 查询我的组任务
findMyGroupTask() {
String candidateUser = "小A";
List<Task> list = processEngine.getTaskService
.createTaskQuery
.taskCandidateUser(candidateUser)
.orderByTaskCreateTime().asc()
.list()
}查询正在执行的任务办理人表
// 查询正在执行的任务办理人表
findRunPersonTask() {
String taskId = "";
List<IdenityLink> list = processEngine.getTaskService
.getIdentityLinksForTask(taskId)
if list != null && list.size > 0
for tl:list
sysout: tl -> taskId, type, processInstanceId, userId // 小C, 小D, 小B, 小A
}查询历史任务的办理人表
// 查询历史任务的办理人表
findHistoryPersonTask() {
String processInstanceId = "";
List<HistoricIdentityLink> list = processEngine.getHistoryService
.getHistoricIdentityLinksForProcessInstance(processInstanceId)
if list != null && list.size > 0
for hil:list
sysout: tl -> taskId, type, processInstanceId, userId
}拾取任务，将组任务分配给个人任务，指定任务的办理人字段
// 拾取任务，将组任务分配给个人任务，指定任务的办理人字段
claim() {
// 将组任务分配给个人任务
String taskId = "";
// 分配的个人任务（可以是组任务中的成员，也可以是非组任务的成员）
String userId = "小C" // 后再改为大F可以测试非组任务成员，指定了大F之后，再用小A查它的组任务结果为空，可以通过下面的方法改回到组任务
proccessEngine.getTaskService
.claim(taskId, userId);
}将个人任务回退到组任务，前提，之前一定是个组任务
// 将个人任务回退到组任务，前提，之前一定是个组任务
setAssignee() {
String taskId ="";
processEngine.getTaskService
.setAssignee(taskId, null);
}向组任务中添加成员
// 向组任务中添加成员
addGroupUser() {
String taskId = "";
String userId = "大H";
processEngine.getTaskService
.addCadidateUser(taskId, userId);
}从组任务中删除成员
// 从组任务中删除成员
deleteGroupUser() {
String taskId = "";
String userId = "小B";
processEngine.getTaskService
.deleteCandidateUser(taskId, userId); // 删除后查询小B的组任务，结果为空。但删除仅删除了小B的候选者数据，并没有删除参与者数据。
}说明：
- 小A，小B，小C，小D是组任务的办理人
- 这样分配组任务的办理人不够灵活，因为项目开发中任务的办理人不要放置XML文件中
- act_ru_identitylink表存放任务的办理人，包括个人任务和组任务，表示正在执行的任务。
- act_hi_identitylink表存放任务的办理人，包括个人任务和组任务，表示历史任务
区别在于：
如果是个人任务TYPE的类型表示participant(参与者)
如果是组任务TYPE的类型表示candidate(候选者)和participant(参与者)
Ⅱ 通过流程变量指定组任务成员
修改bpmn文件，指定Candidate users
Main Config/Candidate users: #{userIDs}启动流程实例时指定组成员
// 启动流程实例时指定组成员
startProcessInstance
variables.put("userIDs", "大大,中中,小小");
之后完成下面的步骤
- 启动完后，查询大大的组任务
- 指定大大拾取claim任务
- 拾取后，正在执行的任务表中，就有大大了
- 完成任务
- 查询历史任务表就能查询到大大完成了任务
Ⅲ 使用TaskListener来分配组任务
在bpmn文件中指定Listener
Listeners
create class TaskListenerImpl implements TaskListener编写TaskListenerImpl 类
public class TaskListenerImpl implements TaskListener {
public void notify(DeletegateTask delegateTask) {
delegateTask.addCadidateUser("郭靖")
delegateTask.addCadidateUser("黄蓉")
// delegateTask.addCadidateUsers(Collection)
}
}后续完成下面的步骤
- 部署流程
- 启动流程
- 查询表：run任务表，act_run_execution表，act_ru_identitylink表
- 用郭靖查组任务
- 用郭靖拾取claim任务
- 查询执行任务表中，郭靖在表中
- 查询郭靖的个人任务
- 完成个人任务
- 查询表，act_hi_identitylink表，查询历史任务表
说明：
- 在类中使用delegateTask.addCandidateUser(userId); 的方式分配组任务的处理人，此时郭靖和黄蓉是下一个任务的办理人。
通过processEngine.getTaskService().claim(taskId, userId); 将组任务分配给个人任务，也叫认领任务，即指定某个人去办理这个任务，此时由郭靖办理任务。
注意：认领任务的时候，可以是组任务成员中的人，也可以不是组任务成员中的人，此时通过TYPE的类型participant来指定任务的办理人
- addCandidateUser()即向组任务添加成员，deleteCandidateUser()即删除组任务的成员
在开发中，可以将每一个人物的办理人规定好，例如张三的领导是李四和王五，这样张三提交任务，由李四或者王五去查询组任务，可以看到对应张三的申请李四或王五在通过认领任务(claim)的方式，由某个人去完成这个任务。
小结：
组任务及三种分配方式：
- 在taskProcess.bpmn中直接写candidate-users="小A,小B,小C,小D"
- 在在taskProcess.bpmn中写candidate-users="#{userIDs}"，变量的值要是String的。
使用流程变量指定办理人的代码如下
Map<String, Object> variables = new HashMap<>();
variables.put("userIDs", "大大,中中,小小");- 使用TaskListener接口，使用类实现该接口，在类中定义：
// 添加组任务的用户
delegateTask.addCandidateUser(userId1);
delegateTask.addCandidateUser(userId2);组任务分配给个人任务
processEngine.getTaskService().claim(taskId, userId);个人任务分配给组任务：
processEngine.getTaskService().setAssignee(taskId, null);向组任务添加成员：
processEngine.getTaskService().addCandidateUser(taskId, userId)向组任务删除人员：
processEngine.getTaskService().deleteCandidateUser(taskId, userId)个人任务和组任务存放办理人对应的表：
- act_ru_identitylink 表存放任务的办理人，包括个人任务和组任务表，表示正在执行的任务
- act_hi_identitylink 表存放任务的办理人，包括个人任务和组任务表，表示历史任务区别：
- 如果是个人任务TYPE的类型表示participant（参与者）
- 如果是组任务TYPE的类型表示candidate（候选者）和participant（参与者）
8. 工作流定义的角色组（了解）
流程图
注：
- bpmn文件中指定角色组
- Main Config/Candidate groups 指定角色组：部门经理
在deploymentprocessDefinition方法的最后
// 添加用户角色组
IdentityService identityService = processEngine.getIdentityService()
// 创建角色
// GroupEntity是Group接口的子类
identityService.saveGroup(new GroupEntity("总经理"))
identityService.saveGroup(new GroupEntity("部门经理"))
// 创建用户
// UserEntity是User接口的子类
identityService.saveUser(new UserEntity("张三")/*.set 去尝试一下这个操作*/);
identityService.saveUser(new UserEntity("李四"));
identityService.saveUser(new UserEntity("王五"));
// 建立用户和角色的关联关系
identityService.createMembership("张三", "部门经理");
identityService.createMembership("李四", "部门经理");
identityService.createMembership("王五", "总经理经理");
sysout: 添加组织机构成功！
- 部署流程
- 查询表
select * from act_id_group // 工作流提供的角色表
select * from act_id_user // 用户表
select * from act_id_membership // 用户角色关联表- 启动流程实例
查询act_ru_identitylink表，可以得知“审批”任务是一个组任务，其TYPE_字段值为candidate，其GROUP_ID的值为部门经理
- 查询张三的组任务，可以查询到张三拥有“审批”这个组任务。
- 查询李四的组任务，可以查询到李四拥有“审批”这个组任务。
试一下王五呢，（已知：Main Config配置了角色）
- 拾取任务给张三
查询act_ru_task，就可以看到assignee就有值了，其值为张三
完成任务
【小主，觉得有用打赏点哦！多多少少没关系，一分也是对我的支持和鼓励。谢谢！】