文章

【若依】28、流程变量

发表于
作者 月牙坠 9 分钟阅读

流程变量分类：

  1. 全局流程变量
  2. 本地流程变量
  3. 临时流程变量

    1 全局流程变量

    全局流程变量：就是和流程实例/执行实例绑定的流程变量，和某个具体的 UserTask 是没有关系的。

    1. 启动时设置

    流程启动并设置全局流程变量

    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    /**
 * 启动并设置全局流程变量
 * 流程变量将被存入到两个地方：
 * 1。ACT_HI_VARINST：历史信息表
 * 2。ACT_RU_VARIABLE：运行信息表
 */
@Test
void startProcessInstanceByKey1() {
 Map<String, Object> map = new HashMap<>();
 map.put("days", 10);
 map.put("reason", "去西藏");
 map.put("startTime", "2022-11-21");
 map.put("endTime", "2022-11-30");
 // 启动并设置全局流程变量
 runtimeService.startProcessInstanceByKey("VariableDemo", map);
}

    通过执行实例 ID 查询流程变量

    1
2
3
4
5
6
7
8
9
10
11
12

    /**
 * 通过执行实例 ID 查询流程变量
 * ACT_RU_VARIABLE
 */
@Test
void getVariableByExecutionId() {
 List<Execution> list = runtimeService.createExecutionQuery().list();
 for (Execution execution : list) {
     Object reason = runtimeService.getVariable(execution.getId(), "reason");
     log.info(")_(" + "executionName：{},reason:{}", execution.getName(), reason);
 }
}

    通过执行实例 ID 查询所有的流程变量

    1
2
3
4
5
6
7
8
9
10
11

    /**
 * 通过执行实例 ID 查询所有的流程变量
 */
@Test
void getAllVariableByExecutionId() {
 List<Execution> list = runtimeService.createExecutionQuery().list();
 for (Execution execution : list) {
     Map<String, Object> variables = runtimeService.getVariables(execution.getId());
     log.info(")_(" + "variables:{}", variables);
 }
}

    2. 通过 Task 设置

    通过 Task 设置全局流程变量分两种

  • 逐个设置
  • 批量设置

无论哪种方式，都是往ACT_RU_VARABLE和ACT_HI_VARINST表中插入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
 * 通过 Task 来设置全局流程变量
 * ACT_HI_VARINST
 * ACT_RU_VARIABLE
 * 在设置的时候，虽然需要传递 TaskId，但并不是说这个变量跟当前 Task 绑定，通过 TaskId 可以查询出这个 Task 所对应的 流程实例 ID 和 执行实例 ID，将来插入的时候会用到
 */
@Test
void setVariableByTaskId() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    log.info(")_(" + "taskId:{}", task.getId());
    // 逐个设置流程变量，第一个参数是 taskId，后面的参数是流程变量的 key-value
    taskService.setVariable(task.getId(), "result", "同意");
    Map<String, Object> map = new HashMap<>();
    map.put("a", "A");
    map.put("b", "B");
    // 批量设置流程变量
    taskService.setVariables(task.getId(), map);
}

/**
 * 根据 task 查询全局流程变量
 */
@Test
void getVariableByTaskId1() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    // 即会根据 taskId 查询，也会根据 taskId 所对应的执行实例 id 查询
    Object reason = taskService.getVariable(task.getId(), "reason");
    // 先根据 taskId 查询到执行实例 id，然后根据执行实例的 id 进行查询
    Map<String, Object> variables = taskService.getVariables(task.getId());
    log.info(")_(" + "reason:{},variables:{}", reason, variables);
}

3. 完成任务时设置

1
2
3
4
5
6
7
8
9
10

/**
 * 完成任务时设置全局流程变量
 */
@Test
void setVariableByCompleteTaskId() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    Map<String, Object> map = new HashMap<>();
    map.put("status", "完成");
    taskService.complete(task.getId(), map);
}

4. 通过流程来设置

通过流程实例来设置全局流程变量

1
2
3
4
5
6
7
8
9
10

/**
 * 由于全局流程变量是和当前流程实例相关的，所以全局流程变量也可以直接通过流程实例来设置
 */
@Test
void setVariableByExecutionId() {
    List<Execution> list = runtimeService.createExecutionQuery().list();
    for (Execution execution : list) {
        runtimeService.setVariable(execution.getId(), "a", "A");
    }
}

2 本地流程变量

2.1 为 Task 设置

全局流程变量是和一个具体的流程绑定，本地流程变量是和一个具体的 Task 绑定，即，本地流程变量，只和某一个具体的 Task 相关，Task 执行完毕，这个流程变量也就不存在了。

1
2
3
4
5
6
7
8
9
10
11

/**
 * 设置本地流程变量
 */
@Test
void setVariablesLocal() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    Map<String, Object> map = new HashMap<>();
    map.put("a", "A");
    map.put("b", "B");
    taskService.setVariablesLocal(task.getId(), map);
}

执行结果 image.png 可以看到，本地流程变量相比于全局流程变量，多了一个TASK_ID_字段，说明这个流程变量是一个本地流程变量，和某一个具体的 Task 绑定。 本地流程变量也会保存到ACT_HI_VARINST表中。 image.png 对于本地流程变量，如果通过执行实例 ID 查询流程变量，是查询不到的，因为这个方法对应的 SQL 中有一个TASK_ID_ is null条件

1
2
3
4
5
6
7
8
9
10
11
12

/**
 * 通过执行实例 ID 查询流程变量
 * ACT_RU_VARIABLE
 */
@Test
void getVariableByExecutionId() {
    List<Execution> list = runtimeService.createExecutionQuery().list();
    for (Execution execution : list) {
        Object a = runtimeService.getVariable(execution.getId(), "a");
        log.info(")_(" + "executionName：{},a:{}", execution.getName(), a);
    }
}

根据 TaskId 查询流程变量

1
2
3
4
5
6
7
8
9
10

/**
 * 根据 TaskId 查询流程变量
 * ACT_RU_VARIABLE
 */
@Test
void getVariableByTaskId2() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    Object a = taskService.getVariable(task.getId(), "a");
    log.info(")_(" + "a={}", a);
}

根据 TaskId 查询本地流程变量

1
2
3
4
5
6
7
8
9
10

/**
 * 根据 TaskId 查询本地流程变量
 * ACT_RU_VARIABLE
 */
@Test
void getVariableLocalByTaskId() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    Object a = taskService.getVariableLocal(task.getId(), "a");
    log.info(")_(" + "a={}", a);
}

当前任务执行完毕时，本地流程变量就会被删除。 完成一级审批的任务

1
2
3
4
5
6
7
8

/**
 * 完成一级审批的任务
 */
@Test
void completeByTaskId() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    taskService.complete(task.getId());
}

完成后，与一级审批任务相关的本地流程变量就会被自动从ACT_RU_VARIABLE表删除。 完成任务并设置本地流程变量

1
2
3
4
5
6
7
8
9
10
11

/**
 * 完成任务并设置本地流程变量
 */
@Test
void setVariablesLocalByTaskIdWithTaskComplete() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    Map<String, Object> map = new HashMap<>();
    map.put("status", "完成");
    // 第三个参数为 true 就表示这个流程变量是一个本地流程变量
    taskService.complete(task.getId(), map, true);
}

2.2 为 Execution 设置

根据执行实例 ID 设置本地流程变量

1
2
3
4
5
6
7
8
9
10

/**
 * 根据执行实例 ID 设置本地流程变量
 */
@Test
void setVariablesLocalByExecutionId() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    Map<String, Object> map = new HashMap<>();
    map.put("a", "A");
    runtimeService.setVariablesLocal(task.getExecutionId(), map);
}

根据执行实例 ID 查询本地流程变量

1
2
3
4
5
6
7
8
9

/**
 * 根据执行实例 ID 查询本地流程变量
 */
@Test
void getVariableLocalByTaskAssignee() {
    Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
    Object a = runtimeService.getVariableLocal(task.getExecutionId(), "a");
    log.info(")_(" + "a={}", a);
}

3 临时流程变量

临时流程变量是不会存入到数据库中的。两种设置方式：

  1. 流程启动并设置临时流程变量
  2. 完成流程并设置临时流程变量 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

    /**
 * 流程启动并设置临时流程变量
 */
@Test
void startProcessInstanceByKey2() {
 Map<String, Object> map = new HashMap<>();
 map.put("reason", "去西藏");
 map.put("startTime", "2022-11-21");
 map.put("endTime", "2022-11-30");
 runtimeService.createProcessInstanceBuilder()
         .transientVariable("days", 10)
         .transientVariables(map)
         .processDefinitionKey("VariableDemo")
         .start();
}

    1
2
3
4
5
6
7
8
9
10

    /**
 * 完成流程并设置临时流程变量
 */
@Test
void setVariablesByTaskIdWithTaskComplete() {
 Task task = taskService.createTaskQuery().taskAssignee("yueyazhui").singleResult();
 Map<String, Object> map = new HashMap<>();
 map.put("a" , "A");
 taskService.complete(task.getId(), null, map);
}
若依
若依
本文由作者按照 CC BY 4.0 进行授权