Flowable

gitee: https://gitee.com/cy140427/flowable-learn.git

Flowable介绍

为开发人员、系统管理员和业务用户提供紧凑高效的工作流和业务流程管理（BPM）平台。

Flowable基础

创建ProcessEngine

1. pom.xml添加依赖

   <dependency>
       <groupId>org.flowable</groupId>
       <artifactId>flowable-engine</artifactId>
       <version>6.3.0</version>
   </dependency>
   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>8.0.21</version>
   </dependency>
   

2. 初始化ProcessEngine流程引擎实例。 ProcessEngine有ProcessEngineConfiguration实例创建。该实例可以配置与调整流程引擎的设置。通常使用一个配置XMl文件创建ProcessEngineConfiguration，但是（像这里一样）也可以编程方式创建它。ProcessEngineConfiguration所需的最小配置，是数据库JDBC连接。

   public static void main(String[] args) {
       ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
           .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn?serverTimezone=UTC")
           .setJdbcUsername("root")
           .setJdbcPassword("123456")
           .setJdbcDriver("com.mysql.cj.jdbc.Driver")
           .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
       ProcessEngine processEngine = cfg.buildProcessEngine();
   }
   

3. 配置日志打印 Flowable使用SLF4J (opens new window)作为内部日志框架。在这个例子中，我们使用log4j作为SLF4J的实现。因此在pom.xml文件中添加下列依赖：

   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
       <version>1.7.21</version>
   </dependency>
   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-log4j12</artifactId>
       <version>1.7.21</version>
   </dependency>
   

   再src/main/resource文件下添加log4j.properties文件，并写入下列内容：

   log4j.rootLogger=DEBUG, CA
   
   log4j.appender.CA=org.apache.log4j.ConsoleAppender
   log4j.appender.CA.layout=org.apache.log4j.PatternLayout
   log4j.appender.CA.layout.ConversionPattern= %d{hh:mm:ss,SSS} [%t] %-5p %c %x - %m%n
   

4. 重启应用数据库生成表

   

部署流程定义

一个流程定义可以启动多个流程实例(process instance)。流程定义可以看做是重复执行流程的蓝图。

有了流程BPMN 2.0 XML文件，下来需要将它***部署(deploy)***到引擎中。部署一个流程定义意味着：

• 流程引擎会将XML文件存储在数据库中，这样可以在需要的时候获取它
• 流程定义转换为内部的、可执行的对象模型，这样使用它就可以启动流程实例。

将流程定义部署至Flowable引擎，需要使用RepositoryService，其可以从ProcessEngine对象获取，使用RepositoryService，可以通过XML文件的路径创建一个新的部署（Deployment），并调用deploy()方法实际执行：

下面我们部署一个请假流程：

@Test
public void test(){
    // 配置数据库相关信息 获取 ProcessEngineConfiguration
    ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
            .setJdbcUrl("jdbc:mysql://localhost:3306/flowable_study?serverTimezone=UTC&nullCatalogMeansCurrent=true")
            .setJdbcUsername("root")
            .setJdbcPassword("chengyi123")
            .setJdbcDriver("com.mysql.cj.jdbc.Driver")
            .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    // 获取流程引擎对象
    ProcessEngine processEngine = cfg.buildProcessEngine();
    // 部署流程 获取RepositoryService对象
    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deployment = repositoryService.createDeployment()// 创建Deployment对象
            .addClasspathResource("leave.bpmn20.xml") // 添加流程部署文件
            .name("请求流程") // 设置部署流程的名称
            .deploy(); // 执行部署操作
    System.out.println("deployment.getId() = " + deployment.getId());
    System.out.println("deployment.getName() = " + deployment.getName());
}

执行成功日志

act_re_deployment：流程定义部署表，每部署一次就增加一条记录

act_re_procdef：流程定义表，部署每个新的流程定义都会在这张表中增加一条记录

act_ge_bytearray：流程资源表，流程部署的bpmn文件和png图片都会保存在该表中

通过RepositoryService查询创建的ProcessDefinitionQuery对象实现

/**
 * 查看流程定义
 */
@Test
public void testDeployQuery(){
    // 配置数据库相关信息 获取 ProcessEngineConfiguration
    ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
            .setJdbcUrl("jdbc:mysql://localhost:3306/flowable_study?serverTimezone=UTC&nullCatalogMeansCurrent=true")
            .setJdbcUsername("root")
            .setJdbcPassword("chengyi123")
            .setJdbcDriver("com.mysql.cj.jdbc.Driver")
            .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    // 获取流程引擎对象
    ProcessEngine processEngine = cfg.buildProcessEngine();
    // 部署流程 获取RepositoryService对象
    RepositoryService repositoryService = processEngine.getRepositoryService();
    // 获取流程定义对象
    ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
            .deploymentId("10001")
            .singleResult();
    System.out.println("processDefinition.getId() = " + processDefinition.getId());
    System.out.println("processDefinition.getName() = " + processDefinition.getName());
    System.out.println("processDefinition.getDeploymentId() = " + processDefinition.getDeploymentId());
    System.out.println("processDefinition.getDescription() = " + processDefinition.getDescription());

}

输出结果

启动流程实例

使用流程定义作为模版，启动流程实例

要启动流程实例，需要提供一些初始化流程变量。一般来说，可以通过呈现给用户的表单，或者在流程由其他系统自动触发时通过REST API，来获取这些变量。在这个例子里，我们简化直接在代码中定义了，我们使用RuntimeService启动一个流程实例。

/**
 * 启动流程实例
 */
@Test
public void testRunProcess(){
    // 配置数据库相关信息 获取 ProcessEngineConfiguration
    ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
            .setJdbcUrl("jdbc:mysql://localhost:3306/flowable_study?serverTimezone=UTC&nullCatalogMeansCurrent=true")
            .setJdbcUsername("root")
            .setJdbcPassword("chengyi123")
            .setJdbcDriver("com.mysql.cj.jdbc.Driver")
            .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    // 获取流程引擎对象
    ProcessEngine processEngine = cfg.buildProcessEngine();
    // 启动流程实例通过 RuntimeService 对象
    RuntimeService runtimeService = processEngine.getRuntimeService();
    // 构建流程变量
    Map<String,Object> variables = new HashMap<>();
    variables.put("approval","chengyi") ;// 谁处理请假
    // 启动流程实例，第一个参数是流程定义的id
    ProcessInstance processInstance = runtimeService
            .startProcessInstanceByKey("Process_1733454925308", variables);// 启动流程实例
    // 输出相关的流程实例信息
    System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());
    System.out.println("流程实例的ID：" + processInstance.getId());
    System.out.println("当前活动的ID：" + processInstance.getActivityId());
}

启动成功，输出结果如下：

流程定义的ID：Process_1733454925308:2:12504
流程实例的ID：20001
当前活动的ID：null

启动流程实例设计到的表结构：

• act_hi_actinst 流程实例执行历史
• act_hi_identitylink 流程的参与用户的历史信息
• act_hi_procinst 流程实例历史信息
• act_hi_taskinst 流程任务历史信息
• act_ru_execution 流程执行信息
• act_ru_identitylink 流程的参与用户信息
• act_ru_task 任务信息

查看任务

接下来我们查看chengyi的任务

@Test
public void testQueryTask(){
    // 配置数据库相关信息 获取 ProcessEngineConfiguration
    ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
            .setJdbcUrl("jdbc:mysql://localhost:3306/flowable_study?serverTimezone=UTC&nullCatalogMeansCurrent=true")
            .setJdbcUsername("root")
            .setJdbcPassword("chengyi123")
            .setJdbcDriver("com.mysql.cj.jdbc.Driver")
            .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    // 获取流程引擎对象
    ProcessEngine processEngine = cfg.buildProcessEngine();
    TaskService taskService = processEngine.getTaskService();
    List<Task> list = taskService.createTaskQuery()
            .processDefinitionKey("Process_1733454925308")
            .taskAssignee("chengyi")
            .list();
    for (Task task : list) {
        System.out.println("task.getProcessDefinitionId() = " + task.getProcessDefinitionId());
        System.out.println("task.getId() = " + task.getId());
        System.out.println("task.getAssignee() = " + task.getAssignee());
        System.out.println("task.getName() = " + task.getName());
    }
}

输出结果为：

task.getProcessDefinitionId() = Process_1733454925308:2:12504
task.getId() = 20006
task.getAssignee() = chengyi
task.getName() = 

完成任务

应该是设置任务为完成，跳转至任务结束节点

 @Test
public void testCompleteTask(){
    // 配置数据库相关信息 获取 ProcessEngineConfiguration
    ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
            .setJdbcUrl("jdbc:mysql://localhost:3306/flowable_study?serverTimezone=UTC&nullCatalogMeansCurrent=true")
            .setJdbcUsername("root")
            .setJdbcPassword("chengyi123")
            .setJdbcDriver("com.mysql.cj.jdbc.Driver")
            .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    // 获取流程引擎对象
    ProcessEngine processEngine = cfg.buildProcessEngine();
    TaskService taskService = processEngine.getTaskService();
    Task task = taskService.createTaskQuery()
            .processDefinitionKey("Process_1733454925308")
            .taskAssignee("chengyi")
            .singleResult();
    // 添加流程变量
    Map<String,Object> variables = new HashMap<>();
    variables.put("approved",false); // 拒绝请假
    variables.put("day", 3);
    // 完成任务
    taskService.complete(task.getId(),variables);
}

流程的删除

/**
 * 删除流程
 */
@Test
public void testDeleteProcess(){
    // 配置数据库相关信息 获取 ProcessEngineConfiguration
    ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
            .setJdbcUrl("jdbc:mysql://localhost:3306/flowable_study?serverTimezone=UTC&nullCatalogMeansCurrent=true")
            .setJdbcUsername("root")
            .setJdbcPassword("chengyi123")
            .setJdbcDriver("com.mysql.cj.jdbc.Driver")
            .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    // 获取流程引擎对象
    ProcessEngine processEngine = cfg.buildProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    // 删除流程定义，如果该流程定义已经有了流程实例启动则删除时报错
    // repositoryService.deleteDeployment("1");
    // 设置为TRUE 级联删除流程定义，及时流程有实例启动，也可以删除，设置为false 非级联删除操作。
    repositoryService.deleteDeployment("12501",true);
}

查看历史信息

/**
 * 查看历史
 */
@Test
public void testQueryHistory(){
    // 配置数据库相关信息 获取 ProcessEngineConfiguration
    ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
            .setJdbcUrl("jdbc:mysql://localhost:3306/flowable_study?serverTimezone=UTC&nullCatalogMeansCurrent=true")
            .setJdbcUsername("root")
            .setJdbcPassword("chengyi123")
            .setJdbcDriver("com.mysql.cj.jdbc.Driver")
            .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
    // 获取流程引擎对象
    ProcessEngine processEngine = cfg.buildProcessEngine();
    HistoryService historyService = processEngine.getHistoryService();
    List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery()
            .processDefinitionId("Process_1733454925308:2:12504")
            .finished()
            .orderByHistoricActivityInstanceEndTime().asc()
            .list();
    for (HistoricActivityInstance historicActivityInstance : list) {
        System.out.println(historicActivityInstance.getActivityId() + " took "
                + historicActivityInstance.getDurationInMillis() + " milliseconds");
    }
}

Flowable表结构

• ACT_RE ：'RE'表示 repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。
• ACT_RU：'RU'表示 runtime。 这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的数据。 Flowable只在流程实例执行过程中保存这些数据， 在流程结束时就会删除这些记录。 这样运行时表可以一直很小速度很快。
• ACT_HI：'HI'表示 history。 这些表包含历史数据，比如历史流程实例， 变量，任务等等。
• ACT_GE： GE 表示 general。 通用数据， 用于不同场景下
• ACT_ID: ’ID’表示identity(组织机构)。这些表包含标识的信息，如用户，用户组，等等。

具体的表结构含义：

表分类	表名	解释
一般数据
	[ACT_GE_BYTEARRAY]	通用的流程定义和流程资源
	[ACT_GE_PROPERTY]	系统相关属性
流程历史记录
	[ACT_HI_ACTINST]	历史的流程实例
	[ACT_HI_ATTACHMENT]	历史的流程附件
	[ACT_HI_COMMENT]	历史的说明性信息
	[ACT_HI_DETAIL]	历史的流程运行中的细节信息
	[ACT_HI_IDENTITYLINK]	历史的流程运行过程中用户关系
	[ACT_HI_PROCINST]	历史的流程实例
	[ACT_HI_TASKINST]	历史的任务实例
	[ACT_HI_VARINST]	历史的流程运行中的变量信息
流程定义表
	[ACT_RE_DEPLOYMENT]	部署单元信息
	[ACT_RE_MODEL]	模型信息
	[ACT_RE_PROCDEF]	已部署的流程定义
运行实例表
	[ACT_RU_EVENT_SUBSCR]	运行时事件
	[ACT_RU_EXECUTION]	运行时流程执行实例
	[ACT_RU_IDENTITYLINK]	运行时用户关系信息，存储任务节点与参与者的相关信息
	[ACT_RU_JOB]	运行时作业
	[ACT_RU_TASK]	运行时任务
	[ACT_RU_VARIABLE]	运行时变量表
用户用户组表
	[ACT_ID_BYTEARRAY]	二进制数据表
	[ACT_ID_GROUP]	用户组信息表
	[ACT_ID_INFO]	用户信息详情表
	[ACT_ID_MEMBERSHIP]	人与组关系表
	[ACT_ID_PRIV]	权限表
	[ACT_ID_PRIV_MAPPING]	用户或组权限关系表
	[ACT_ID_PROPERTY]	属性表
	[ACT_ID_TOKEN]	记录用户的token信息
	[ACT_ID_USER]	用户表

配置文件启动

在resources目录下创建一个flowable.cfg.xml文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="processEngineConfiguration"
          class="org.flowable.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/flow1?allowMultiQueries=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false&amp;serverTimezone=UTC&amp;nullCatalogMeansCurrent=true" /><property name="jdbcDriver" value="com.mysql.cj.jdbc.Driver" />
        <property name="jdbcUsername" value="root" />
        <property name="jdbcPassword" value="123456" />
        <property name="databaseSchemaUpdate" value="true" />
        <property name="asyncExecutorActivate" value="false" />
    </bean>
</beans>

获取ProcessEngine可以简化为

@Test
public void test01(){
    // 获取流程引擎对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    System.out.println("processEngine = " + processEngine);
}

SpringBoot starter启动

---------------- TODO ----------------------

Service服务

Service是工作流引擎提供用于进行工作流部署、执行、管理的服务接口，我们使用这些接口可以就是操作服务对应的数据表

通过ProcessEngine创建Service 方式如下：

RuntimeService runtimeService = processEngine.getRuntimeService();
RepositoryService repositoryService = processEngine.getRepositoryService();
TaskService taskService = processEngine.getTaskService();
// ...

service名称	service作用
RepositoryService	Flowable的资源管理类
RuntimeService	Flowable的流程运行管理类
TaskService	Flowable的任务管理类
HistoryService	Flowable的历史管理类
ManagerService	Flowable的引擎管理类

• RepositoryService

  是activiti的资源管理类，提供了管理和控制流程发布包和流程定义的操作。使用工作流建模工具设计的业务流程图需要使用此service将流程定义文件的内容部署到计算机。

  除了部署流程定义以外还可以：查询引擎中的发布包和流程定义。

  暂停或激活发布包，对应全部和特定流程定义。 暂停意味着它们不能再执行任何操作了，激活是对应的反向操作。获得多种资源，像是包含在发布包里的文件， 或引擎自动生成的流程图。

  获得流程定义的pojo版本， 可以用来通过java解析流程，而不必通过xml。

• RuntimeService

  Activiti的流程运行管理类。可以从这个服务类中获取很多关于流程执行相关的信息

• TaskService

  Activiti的任务管理类。可以从这个类中获取任务的信息。

• HistoryService

  Flowable的历史管理类，可以查询历史信息，执行流程时，引擎会保存很多数据（根据配置），比如流程实例启动时间，任务的参与者， 完成任务的时间，每个流程实例的执行路径，等等。 这个服务主要通过查询功能来获得这些数据。

• ManagementService

  Activiti的引擎管理类，提供了对Flowable 流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序中使用，主要用于 Flowable 系统的日常维护。

流程详解

部署流程定义

/**
 * 部署流程
 */
@Test
public void test3(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deploy = repositoryService.createDeployment()
            .addClasspathResource("holiday-request-new.bpmn20.xml")
            .name("请假流程...")
            .category("请假") // 分类
            .tenantId("dpb") // 租户id
            .deploy();
    System.out.println("deploy.getId() = " + deploy.getId());
    System.out.println("deploy.getName() = " + deploy.getName());
    System.out.println("deploy.getCategory() = " + deploy.getCategory());
}

涉及到3张表：

act_ge_bytearray： 部署资源表

字段	名称	备注
ID_	主键
REV_	版本号
NAME_	名称	部署的文件名称，如：holiday-request-new.bpmn20.xml、holiday-request-new.bpmn20.png
DEPLOYMENT_ID_	部署ID
BYTES_	字节（二进制数据）
GENERATED_	是否系统生成	0为用户上传， 1为系统自动生成， 比如系统会 自动根据xml生 成png

act_re_deployment：部署ID表

字段	名称	备注
ID_	主键
NAME_	名称
CATEGORY_	分类
TENANT_ID_	租户ID
DEPLOY_TIME_	部署时间
DERIVED_FROM_	来源于
DERIVED_FROM_ROOT_	来源于
ENGINE_VERSION_	流程引擎的版本

act_re_procdef：流程表

字段	名称	备注
ID_	主键
REV_	版本号
CATEGORY_	分类	流程定义的Namespace就是类别
NAME_	名称
KEY_	标识
VERSION_	版本
DEPLOYMENT_ID_	部署ID
RESOURCE_NAME_	资源名称	流程bpmn文件名称
DGRM_RESOURCE_NAME_	图片资源名称
DESCRIPTION_	描述
HAS_START_FORM_KEY_	拥有开始表单标识	start节点是否存在formKey 0否 1是
HAS_GRAPHICAL_NOTATION_	拥有图形信息
SUSPENSION_STATE_	挂起状态	暂停状态 1激活 2暂停
TENANT_ID_	租户ID

启动流程实例

/**
 * 启动流程实例
 */
@Test
public void testRunProcess(){
    // 获取流程引擎对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    // 启动流程实例通过 RuntimeService 对象
    RuntimeService runtimeService = processEngine.getRuntimeService();
    // 构建流程变量
    Map<String,Object> variables = new HashMap<>();
    variables.put("employee","张三") ;// 谁申请请假
    variables.put("nrOfHolidays",3); // 请几天假
    variables.put("description","工作累了，想出去玩玩"); // 请假的原因
    // 启动流程实例，第一个参数是流程定义的id
    ProcessInstance processInstance = runtimeService
            .startProcessInstanceById("holiday:1:4", variables);// 启动流程实例
    // 输出相关的流程实例信息
    System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());
    System.out.println("流程实例的ID：" + processInstance.getId());
    System.out.println("当前活动的ID：" + processInstance.getActivityId());
}

当我们启动了一个流程实例后，会在ACT_RU_*对应的表结构中操作,运行时实例涉及的表结构共10张：

• ACT_RU_DEADLETTER_JOB 正在运行的任务表
• ACT_RU_EVENT_SUBSCR 运行时事件
• ACT_RU_EXECUTION 运行时流程执行实例
• ACT_RU_HISTORY_JOB 历史作业表
• ACT_RU_IDENTITYLINK 运行时用户关系信息
• ACT_RU_JOB 运行时作业表
• ACT_RU_SUSPENDED_JOB 暂停作业表
• ACT_RU_TASK 运行时任务表
• ACT_RU_TIMER_JOB 定时作业表
• ACT_RU_VARIABLE 运行时变量表

启动一个流程实例的时候涉及到的表有

• ACT_RU_EXECUTION 运行时流程执行实例
• ACT_RU_IDENTITYLINK 运行时用户关系信息
• ACT_RU_TASK 运行时任务表
• ACT_RU_VARIABLE 运行时变量表

处理流程

// 获取流程引擎对象
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
TaskService taskService = processEngine.getTaskService();
Task task = taskService.createTaskQuery()
        .processDefinitionId("holiday:1:4")
        .taskAssignee("zhangsan")
        .singleResult();
// 添加流程变量
Map<String,Object> variables = new HashMap<>();
variables.put("approved",false); // 拒绝请假
// 完成任务
taskService.complete(task.getId(),variables);

在正常处理流程中涉及到的表结构：

• ACT_RU_EXECUTION 运行时流程执行实例
• ACT_RU_IDENTITYLINK 运行时用户关系信息
• ACT_RU_TASK 运行时任务表
• ACT_RU_VARIABLE 运行时变量表

完成流程

ProcessEngine processEngine = cfg.buildProcessEngine();
TaskService taskService = processEngine.getTaskService();
Task task = taskService.createTaskQuery()
    .processDefinitionId("holiday:1:4")
    .taskAssignee("lisi")
    .singleResult();
// 添加流程变量
Map<String,Object> variables = new HashMap<>();
variables.put("approved",false); // 拒绝请假
// 完成任务
taskService.complete(task.getId(),variables);

清除处理流程四张表中的数据，然后在对应的历史表中我们可以看到相关的信息：

• ACT_HI_ACTINST 历史的流程实例
• ACT_HI_ATTACHMENT 历史的流程附件
• ACT_HI_COMMENT 历史的说明性信息
• ACT_HI_DETAIL 历史的流程运行中的细节信息
• ACT_HI_IDENTITYLINK 历史的流程运行过程中用户关系
• ACT_HI_PROCINST 历史的流程实例
• ACT_HI_TASKINST 历史的任务实例
• ACT_HI_VARINST 历史的流程运行中的变量信息

挂起和激活

部署的流程默认的状态为激活，可以挂起该流程，该流程定义下边的所有流程实例全部暂停。

/**
 * 挂起流程
 */
@Test
public void test05(){
    // 获取流程引擎对象
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
            .processDefinitionId("holiday:1:4")
            .singleResult();
    // 获取流程定义的状态
    boolean suspended = processDefinition.isSuspended();
    System.out.println("suspended = " + suspended);
    if(suspended){
        // 表示被挂起
        System.out.println("激活流程定义");
        repositoryService.activateProcessDefinitionById("holiday:1:4",true,null);
    }else{
        // 表示激活状态
        System.out.println("挂起流程");
        repositoryService.suspendProcessDefinitionById("holiday:1:4",true,null);
    }
}