关于java-ee:Flowable-已经执行完毕的流程去哪找

2次阅读

共计 7950 个字符，预计需要花费 20 分钟才能阅读完成。

@[toc]
在之前的文章中松哥和小伙伴们聊过，正在执行的流程信息是保留在以 ACT_RU_ 为前缀的表中，执行结束的流程信息则保留在以 ACT_HI_ 为前缀的表中，也就是流程历史信息表，当然这个历史信息表持续细分的话，还有好多种，明天咱们就来聊一聊这个话题。

假如我有如下一个流程：

当这个流程执行结束后，以 ACT_RU_ 为前缀的表中的数据均已清空，当初如果想查看刚刚执行过的流程信息，咱们就得去以 ACT_HI_ 为前缀的表中。

历史流程信息查看，形式如下：

@Test
void test05() {List<HistoricProcessInstance> list = historyService.createHistoricProcessInstanceQuery().finished().list();
    for (HistoricProcessInstance hpi : list) {logger.info("name:{},startTime:{},endTime:{}",hpi.getName(),hpi.getStartTime(),hpi.getEndTime());
    }
}

调用的时候执行的 finished() 办法示意查问曾经执行结束的流程信息（从这里也能够看出，对于未执行结束的流程信息也会保留在历史表中）。

咱们来看下这个查问对应的 SQL，如下：

SELECT RES.* , DEF.KEY_ as PROC_DEF_KEY_, DEF.NAME_ as PROC_DEF_NAME_, DEF.VERSION_ as PROC_DEF_VERSION_, DEF.DEPLOYMENT_ID_ as DEPLOYMENT_ID_ from ACT_HI_PROCINST RES left outer join ACT_RE_PROCDEF DEF on RES.PROC_DEF_ID_ = DEF.ID_ WHERE RES.END_TIME_ is not NULL order by RES.ID_ asc

从这个 SQL 中能够看到，这个查问实质上就是查问的 ACT_HI_PROCINST 表。如下图：

如果咱们在查问的时候不限度流程是否执行结束，那么咱们的查询方法如下：

@Test
void test05() {List<HistoricProcessInstance> list = historyService.createHistoricProcessInstanceQuery().list();
    for (HistoricProcessInstance hpi : list) {logger.info("name:{},startTime:{},endTime:{}",hpi.getName(),hpi.getStartTime(),hpi.getEndTime());
    }
}

对应的查问 SQL 如下：

SELECT RES.* , DEF.KEY_ as PROC_DEF_KEY_, DEF.NAME_ as PROC_DEF_NAME_, DEF.VERSION_ as PROC_DEF_VERSION_, DEF.DEPLOYMENT_ID_ as DEPLOYMENT_ID_ from ACT_HI_PROCINST RES left outer join ACT_RE_PROCDEF DEF on RES.PROC_DEF_ID_ = DEF.ID_ order by RES.ID_ asc

和后面的 SQL 相比，前面的 SQL 少了 WHERE RES.END_TIME_ is not NULL 条件，也就是说，判断一个流程是否执行结束，就看它的 END_TIME_ 是否为空，不为空就示意流程曾经执行完结了，为空就示意流程尚在执行中。

刚刚咱们查问的是历史流程，接下来咱们来看下历史工作，也就是查问一个流程中执行过的 Task 信息，如下示意查问所有的历史流程工作：

@Test
void test06() {List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery().list();
    for (HistoricTaskInstance hti : list) {logger.info("name:{},assignee:{},createTime:{},endTime:{}",hti.getName(),hti.getAssignee(),hti.getCreateTime(),hti.getEndTime());
    }
}

这个查问对应的 SQL 如下：

SELECT RES.* from ACT_HI_TASKINST RES order by RES.ID_ asc

能够看到，历史工作表就是 ACT_HI_TASKINST，如下图：

当然，这里还有很多其余的玩法，例如查问某一个流程曾经执行结束的历史工作，如下：

@Test
void test07() {List<HistoricProcessInstance> instanceList = historyService.createHistoricProcessInstanceQuery().list();
    for (HistoricProcessInstance hpi : instanceList) {List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery().processInstanceId(hpi.getId()).finished().list();
        for (HistoricTaskInstance hti : list) {logger.info("name:{},assignee:{},createTime:{},endTime:{}", hti.getName(), hti.getAssignee(), hti.getCreateTime(), hti.getEndTime());
        }
    }
}

这个里边的查问历史工作的 SQL 如下：

SELECT RES.* from ACT_HI_TASKINST RES WHERE RES.PROC_INST_ID_ = ? and RES.END_TIME_ is not null order by RES.ID_ asc

能够看到，跟后面相比，多了两个条件：

流程实例 ID
流程完结工夫不为 null

从这里也能够看进去，这个 finish 办法的执行逻辑跟咱们后面讲的是一样的。

历史工作就是各种 Task，历史流动则包含跟多内容，像开始 / 完结节点，连线等等这些信息都算是流动，这个在之前的文章中松哥曾经和大家介绍过了。

查问代码如下：

@Test
void test08() {List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery().list();
    for (HistoricActivityInstance hai : list) {logger.info("name:{},startTime:{},assignee:{},type:{}",hai.getActivityName(),hai.getStartTime(),hai.getAssignee(),hai.getActivityType());
    }
}

这个查问对应的 SQL 如下：

SELECT RES.* from ACT_HI_ACTINST RES order by RES.ID_ asc

能够看到，ACT_HI_ACTINST 表中保留了历史流动信息。

查问流程执行的历史变量，形式如下：

@Test
void test09() {HistoricProcessInstance pi = historyService.createHistoricProcessInstanceQuery().singleResult();
    List<HistoricVariableInstance> list = historyService.createHistoricVariableInstanceQuery().processInstanceId(pi.getId()).list();
    for (HistoricVariableInstance hvi : list) {logger.info("name:{},type:{},value:{}", hvi.getVariableName(), hvi.getVariableTypeName(), hvi.getValue());
    }
}

这个查问对应的 SQL 如下：

SELECT RES.* from ACT_HI_VARINST RES WHERE RES.PROC_INST_ID_ = ? order by RES.ID_ asc

能够看到流程的历史变量信息保留在 ACT_HI_VARINST 表中。

有的小伙伴看到日志这两个字可能会感觉奇怪，咦？流程执行还有日志吗？没听说过呀！

其实历史日志查问就是后面那几种的一个集大成者，用法如下：

@Test
void test10() {HistoricProcessInstance pi = historyService.createHistoricProcessInstanceQuery().singleResult();
    ProcessInstanceHistoryLog historyLog = historyService.createProcessInstanceHistoryLogQuery(pi.getId())
            // 包含历史流动
            .includeActivities()
            // 包含历史工作
            .includeTasks()
            // 包含历史变量
            .includeVariables()
            .singleResult();
    logger.info("id:{},startTime:{},endTime:{}", historyLog.getId(), historyLog.getStartTime(), historyLog.getEndTime());
    List<HistoricData> historicData = historyLog.getHistoricData();
    for (HistoricData data : historicData) {if (data instanceof HistoricActivityInstance) {HistoricActivityInstance hai = (HistoricActivityInstance) data;
            logger.info("name:{},type:{}", hai.getActivityName(), hai.getActivityType());
        }
        if (data instanceof HistoricTaskInstance) {HistoricTaskInstance hti = (HistoricTaskInstance) data;
            logger.info("name:{},assignee:{}", hti.getName(), hti.getAssignee());
        }
        if (data instanceof HistoricVariableInstance) {HistoricVariableInstance hvi = (HistoricVariableInstance) data;
            logger.info("name:{},type:{},value:{}", hvi.getVariableName(), hvi.getVariableTypeName(), hvi.getValue());
        }
    }
}

这个里边，首先是查问根本的流程日志信息，这个实质上就是查问历史流程实例信息，对应的 SQL 如下：

select RES.*, DEF.KEY_ as PROC_DEF_KEY_, DEF.NAME_ as PROC_DEF_NAME_, DEF.VERSION_ as PROC_DEF_VERSION_, DEF.DEPLOYMENT_ID_ as DEPLOYMENT_ID_ from ACT_HI_PROCINST RES left outer join ACT_RE_PROCDEF DEF on RES.PROC_DEF_ID_ = DEF.ID_ where PROC_INST_ID_ = ?

接下来我写了三个 include，每一个 include 都对应一句 SQL：

includeActivities 对应的 SQL 如下：

SELECT RES.* from ACT_HI_ACTINST RES WHERE RES.PROC_INST_ID_ = ? order by RES.ID_ asc

includeTasks 对应的 SQL 如下：

SELECT RES.* from ACT_HI_TASKINST RES WHERE RES.PROC_INST_ID_ = ? order by RES.ID_ asc

includeVariables 对应的 SQL 如下：

SELECT RES.* from ACT_HI_VARINST RES WHERE RES.PROC_INST_ID_ = ? order by RES.ID_ asc

最终查问实现后，调用 getHistoricData 办法能够查看这些额定的数据，List 汇合中寄存的 HistoricData 也分为不同的类型：

includeActivities 办法对应最终查问进去的类型是 HistoricActivityInstance。
includeTasks 办法对应最终查问进去的类型是 HistoricTaskInstance。
includeVariables 办法对应最终查问进去的类型是 HistoricVariableInstance。

在遍历的时候通过类型判断去查看具体是哪一种变量类型。

综上，这个历史日志查问其实就是一个集大成者。

这个是用来查问流程或者工作的解决人，例如查问流程的解决人，形式如下：

@Test
void test11() {HistoricProcessInstance pi = historyService.createHistoricProcessInstanceQuery().singleResult();
    List<HistoricIdentityLink> links = historyService.getHistoricIdentityLinksForProcessInstance(pi.getId());
    for (HistoricIdentityLink link : links) {logger.info("userId:{}",link.getUserId());
    }
}

这个是查问流程对应的解决人，对应的 SQL 如下：

select * from ACT_HI_IDENTITYLINK where PROC_INST_ID_ = ?

如果想查问工作的解决人，对应的形式如下：

@Test
void test12() {
    String taskName = "提交销假申请";
    HistoricTaskInstance hti = historyService.createHistoricTaskInstanceQuery().taskName(taskName).singleResult();
    List<HistoricIdentityLink> links = historyService.getHistoricIdentityLinksForTask(hti.getId());
    for (HistoricIdentityLink link : links) {logger.info("{} 工作的解决人是 {}",taskName,link.getUserId());
    }
}

这个查问对应的 SQL 如下：

select * from ACT_HI_IDENTITYLINK where TASK_ID_ = ?

和后面的相比，其实就多了一个查问条件 TASK_ID_。

和后面讲的很多查问相似，当咱们弄懂了每一个历史查问的 API 操作的是哪一个数据表，就会发现，历史数据的查问，也能够自定义 SQL。

举个例子和小伙伴们看下，例如查问某一个流程曾经执行结束的历史工作：

@Test
void test13() {List<HistoricProcessInstance> instanceList = historyService.createHistoricProcessInstanceQuery().list();
    for (HistoricProcessInstance hpi : instanceList) {List<HistoricTaskInstance> list = historyService.createNativeHistoricTaskInstanceQuery()
                .sql("SELECT RES.* from ACT_HI_TASKINST RES WHERE RES.PROC_INST_ID_ = #{pid} and RES.END_TIME_ is not null order by RES.ID_ asc")
                .parameter("pid",hpi.getId()).list();
        for (HistoricTaskInstance hti : list) {logger.info("name:{},assignee:{},createTime:{},endTime:{}", hti.getName(), hti.getAssignee(), hti.getCreateTime(), hti.getEndTime());
        }
    }
}

flowable 底层是 MyBatis，所有 SQL 中参数的传递模式和 MyBatis 统一。

Flowable 须要记录哪些历史数据，有一个日志级别用来形容这个事件，默认有四种级别：

None: 这个示意不存储任何历史信息，益处是流程执行的时候效率会比拟快，害处是流程执行完结后，看不到已经执行过的流程信息了。
Activity: 这个会存储所有流程实例和流动实例，在流程实例完结时，顶级流程实例变量的最新值将复制到历史变量实例中，不会存储详细信息。
Audit: 在 Activity 的根底上，还会存储历史详细信息，包含权限信息等。默认的日志记录级别即次。
Full: 这个是在 Audit 的根底上，还会存储变量的变动信息，这会记录大量的数据，也会导致流程执行变慢。

一共就这四种级别，在 Spring Boot 我的项目中，如果咱们想要配置这个日志记录的级别，其实十分不便，间接在 application.properties 中进行配置即可，如下：

flowable.history-level=none

配置加了这个配置，咱们轻易启动一个流程，而后去查问 ACT_HI_ 系列的表，发现都是空的，没有数据。

如果咱们将历史日志记录的级别改为 activity，那么就会记录下来流程信息以及流动信息，然而像执行的 Task 这些信息都是没有的（ACT_HI_TASKINST），包含流程参与者的信息（ACT_HI_IDENTITYLINK）等都不会记录下来。

如果咱们将历史日志记录的级别改为 audit，则下面提到的这几种日志就都会记录下来。然而 ACT_HI_DETAIL 表还是空的，具体一个流程变量的变动过程不会被记录下来。

如果咱们将日志记录级别改为 full，那么将会记录下更多的信息。ACT_HI_DETAIL 表中会记录下流程变量的详细信息。

整个过程我就不给小伙伴们演示了大家能够自行尝试。

好啦，对于历史数据的查问，松哥先和小伙伴们聊这么多～下篇文章咱们持续～

正文完

java-ee

发表至： java-ee

2022-11-08

0

关于java-ee:优雅关闭线程池的方案

关于java-ee:JVM工具1-堆栈检查利器jstat的使用

关于java-ee:Jakarta-EE-Java-EE的终结者

关于java-ee:黑马V11JavaEE精英进阶课

关于前端:React-中的类和函数组件-选择哪一个

关于java-ee:Flowable-已经执行完毕的流程去哪找

1. 历史流程信息

2. 历史工作查问

3. 历史流动查问

4. 历史变量查问

5. 历史日志查问

6. 历史权限查问

7. 自定义查问 SQL

8. 历史数据记录级别

站内搜索