Flowable流程部署、启动、处理、完成各模块的代码详解（图解）

原创 已于 2024-12-28 16:29:49 修改 · 2.4k 阅读 · 31 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring

于 2023-12-29 15:58:15 首次发布
该博客围绕Java Spring项目展开，介绍了项目准备工作，包括数据库创建、Spring Boot项目配置等。重点阐述模块实现，涵盖流程部署、查询、删除、挂起激活等操作，详细说明了各操作涉及的表结构，如部署资源表、运行时实例表、历史表等，展示了流程从启动到完成的全过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

项目准备

新建一个数据库名为：flowable-leaarn（新建的没截图，这是已经初始化后的）
在这里插入图片描述

新建springboot项目就不说了，都学得Flowable了，应该会的吧，下面直接是配置准备：

新建Test类，增加before方法，运行先获取processEngine引擎配置，并且进行初始化数据库

ProcessEngineConfiguration configuration = null;

@Before
public void before(){
    // 获取  ProcessEngineConfiguration 对象
    configuration = new StandaloneProcessEngineConfiguration();
    // 配置 相关的数据库的连接信息
    configuration.setJdbcDriver("com.mysql.cj.jdbc.Driver");
    configuration.setJdbcUsername("root");
    configuration.setJdbcPassword("root");
    configuration.setJdbcUrl("jdbc:mysql://localhost:3306/flowable1?serverTimezone=UTC&nullCatalogMeansCurrent=true");
    // 如果数据库中的表结构不存在就新建
    configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
}

运行初始化：
在这里插入图片描述
在这里插入图片描述
如果你有了数据库，可以设置更新表结构的配置

// 如果数据库中的表结构不存在就新建
configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

准备请假流程的流程图bpnm.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:xsd="http://www.w3.org/2001/XMLSchema"
             xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
             xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"
             xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"
             xmlns:flowable="http://flowable.org/bpmn"
             typeLanguage="http://www.w3.org/2001/XMLSchema"
             expressionLanguage="http://www.w3.org/1999/XPath"
             targetNamespace="http://www.flowable.org/processdef">

    <process id="holidayRequest" name="请假流程" isExecutable="true">

        <startEvent id="startEvent"/>
        <sequenceFlow sourceRef="startEvent" targetRef="approveTask"/>

        <userTask id="approveTask" name="同意或者拒绝请假" flowable:assignee="zhangsan"/>
        <sequenceFlow sourceRef="approveTask" targetRef="decision"/>

        <exclusiveGateway id="decision"/>
        <sequenceFlow sourceRef="decision" targetRef="externalSystemCall">
            <conditionExpression xsi:type="tFormalExpression">
                <![CDATA[
          ${approved}
        ]]>
            </conditionExpression>
        </sequenceFlow>
        <sequenceFlow  sourceRef="decision" targetRef="sendRejectionMail">
            <conditionExpression xsi:type="tFormalExpression">
                <![CDATA[
          ${!approved}
        ]]>
            </conditionExpression>
        </sequenceFlow>

        <serviceTask id="externalSystemCall" name="Enter holidays in external system"
                     flowable:class="org.flowable.CallExternalSystemDelegate"/>
        <sequenceFlow sourceRef="externalSystemCall" targetRef="holidayApprovedTask"/>

        <userTask id="holidayApprovedTask" name="Holiday approved"/>
        <sequenceFlow sourceRef="holidayApprovedTask" targetRef="approveEnd"/>

        <serviceTask id="sendRejectionMail" name="Send out rejection email"
                     flowable:class="org.flowable.SendRejectionMail"/>
        <sequenceFlow sourceRef="sendRejectionMail" targetRef="rejectEnd"/>

        <endEvent id="approveEnd"/>

        <endEvent id="rejectEnd"/>
    </process>

</definitions>

导入相关包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yyl</groupId>
    <artifactId>FlowableDemoTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-engine</artifactId>
            <version>6.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-json-converter</artifactId>
            <version>6.3.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <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>
    </dependencies>

</project>

模块实现

流程部署

流程图部署实现

我们先来看下流程部署的具体过程，代码实现

/**
* 部署流程
*/
@Test
public void testDeploy(){
   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());
}

结果如下：

deploy.getId() = 7501
deploy.getName() = 请求流程

部署过程涉及表结构

其中部署流程需要涉及到的三张表：

部署资源表：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

如数据库里所展示：

在这里插入图片描述

部署ID表：act_re_deployment

字段名称备注
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

查看数据库表：
在这里插入图片描述

注意：

业务流程定义数据表。此表和ACT_RE_DEPLOYMENT是多对一的关系，即，一个部署的bar包里可能包含多个流程定义文件，每个流程定义文件都会有一条记录在ACT_REPROCDEF表内，每个流程定义的数据，都会对于ACT_GE_BYTEARRAY表内的一个资源文件和PNG图片文件。和ACT_GE_BYTEARRAY的关联是通过程序用ACT_GE_BYTEARRAY.NAME与ACT_RE_PROCDEF.NAME_完成的

查询流程定义

查询流程定义的信息代码：

@Test
public void testDeployQuery(){
    ProcessEngine processEngine = configuration.buildProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    /*ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
    ProcessDefinition processDefinition = processDefinitionQuery.deploymentId("1").singleResult();*/
    ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
            .deploymentId("7503")
            .singleResult();
    System.out.println("processDefinition.getDeploymentId() = " + processDefinition.getDeploymentId());
    System.out.println("processDefinition.getName() = " + processDefinition.getName());
    System.out.println("processDefinition.getDescription() = " + processDefinition.getDescription());
    System.out.println("processDefinition.getId() = " + processDefinition.getId());
}

结果如下：

processDefinition.getDeploymentId() = 7501
processDefinition.getName() = 请假流程
processDefinition.getDescription() = null
processDefinition.getId() = holidayRequest:2:7503

删除流程定义

/**
 * 删除流程定义
 */
@Test
public void testDeleteDeploy(){
    ProcessEngine processEngine = configuration.buildProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    // 删除部署的流程 第一个参数是 id  如果部署的流程启动了就不允许删除了
   // repositoryService.deleteDeployment("2501");
    // 第二个参数是级联删除，如果流程启动了 相关的任务一并会被删除掉
     repositoryService.deleteDeployment("20001",true);
}

挂起和激活

部署的流程默认的状态为激活，如果我们暂时不想使用该定义的流程，那么可以挂起该流程。当然该流程定义下边所有的流程实例全部暂停。

流程定义为挂起状态，该流程定义将不允许启动新的流程实例，同时该流程定义下的所有的流程实例都将全部挂起暂停执行。

/**
 * 挂起流程
 */
@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);
    }
}

具体的实现其实就是更新了流程定义表中的字段

image-20220321210010518

而且通过REV_字段来控制数据安全，也是一种乐观锁的体现了，如果要启动一个已经挂起的流程就会出现如下的错误

image-20220321211858122

启动流程实例

然后我们来看看启动流程实例的过程。实现代码如下：

/**
     * 启动流程实例
     */
    @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());
    }

holidayRequest.getProcessDefinitionId() = holidayRequest:2:7503
holidayRequest.getActivityId() = null
holidayRequest.getId() = 10001

当我们启动了一个流程实例后，会在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 运行时变量表

ACT_RU_EXECUTION表结构

字段名称备注
ID_主键
REV_版本号
PROC_INST_ID_流程实例ID
BUSINESS_KEY_业务主键ID
PARENT_ID_父执行流的ID
PROC_DEF_ID_流程定义的数据ID
SUPER_EXEC_
ROOT_PROC_INST_ID_流程实例的root流程id
ACT_ID_节点实例ID
IS_ACTIVE_是否存活
IS_CONCURRENT_执行流是否正在并行
IS_SCOPE_
IS_EVENT_SCOPE_
IS_MI_ROOT_
SUSPENSION_STATE_流程终端状态
CACHED_ENT_STATE_
TENANT_ID_租户编号
NAME_
START_TIME_开始时间
START_USER_ID_开始的用户编号
LOCK_TIME_锁定时间
IS_COUNT_ENABLED_
EVT_SUBSCR_COUNT_
TASK_COUNT_
JOB_COUNT_
TIMER_JOB_COUNT_
SUSP_JOB_COUNT_
DEADLETTER_JOB_COUNT_
VAR_COUNT_
ID_LINK_COUNT_

创建流程实例后对应的表结构的数据

image-20220322133108405

image-20220322133219534

ACT_RU_TASK 运行时任务表

字段名称备注
ID_主键
REV_版本号
EXECUTION_ID_任务所在的执行流ID
PROC_INST_ID_流程实例ID
PROC_DEF_ID_流程定义数据ID
NAME_任务名称
PARENT_TASK_ID_父任务ID
DESCRIPTION_说明
TASK_DEF_KEY_任务定义的ID值
OWNER_任务拥有人
ASSIGNEE_被指派执行该任务的人
DELEGATION_委托人
PRIORITY_优先级
CREATE_TIME_创建时间
DUE_DATE_耗时
CATEGORY_类别
SUSPENSION_STATE_是否挂起1代表激活 2代表挂起
TENANT_ID_租户编号
FORM_KEY_
CLAIM_TIME_拾取时间

创建流程实例后对应的表结构的数据

image-20220322133307195

image-20220322133335326

ACT_RU_VARIABLE 运行时变量表

字段名称备注
ID_主键
REV_版本号
TYPE_参数类型可以是基本的类型，也可以用户自行扩展
NAME_参数名称
EXECUTION_ID_参数执行ID
PROC_INST_ID_流程实例ID
TASK_ID_任务ID
BYTEARRAY_ID_资源ID
DOUBLE_参数为double，则保存在该字段中
LONG_参数为long，则保存在该字段中
TEXT_用户保存文本类型的参数值
TEXT2_用户保存文本类型的参数值

创建流程实例后对应的表结构的数据

image-20220322133406398

image-20220322133439827

ACT_RU_IDENTITYLINK 运行时用户关系信息

字段名称备注
ID_主键
REV_版本号
GROUP_ID_用户组ID
TYPE_关系数据类型assignee支配人(组)、candidate候选人(组)、owner拥有人,participant参与者
USER_ID_用户ID
TASK_ID_任务ID
PROC_INST_ID_流程定义ID
PROC_DEF_ID_属性ID

创建流程实例后对应的表结构的数据:

image-20220322133501720

任务查询测试

/**
 * 测试任务查询
 */
@Test
public void testQueryTask(){
    ProcessEngine processEngine = configuration.buildProcessEngine();
    TaskService taskService = processEngine.getTaskService();
    List<Task> list = taskService.createTaskQuery()
            .processDefinitionKey("holidayRequest") // 指定查询的流程编程
            .taskAssignee("zhangsan") // 查询这个任务的处理人
            .list();
    for (Task task : list) {
        System.out.println("task.getProcessDefinitionId() = " + task.getProcessDefinitionId());
        System.out.println("task.getName() = " + task.getName());
        System.out.println("task.getAssignee() = " + task.getAssignee());
        System.out.println("task.getDescription() = " + task.getDescription());
        System.out.println("task.getId() = " + task.getId());
    }

结果如下：

task.getProcessDefinitionId() = holidayRequest:2:7503
task.getName() = 同意或者拒绝请假
task.getAssignee() = zhangsan
task.getDescription() = null
task.getId() = 10008

处理流程

上面的流程已经流转到了zhangsan这个用户这里，然后可以开始审批了

// 获取流程引擎对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionId("holidayRequest")
                .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 运行时变量表

ACT_RU_TASK 运行时任务表 :会新生成一条记录

image-20220322135040119

image-20220322135125703

ACT_RU_VARIABLE 运行时变量表:会记录新的流程变量

image-20220322135204021

当然流程实例也可以挂起

// 1.获取ProcessEngine对象
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 2.获取RuntimeService
RuntimeService runtimeService = engine.getRuntimeService();
// 3.获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
    .processInstanceId("25001")
    .singleResult();
// 4.获取相关的状态操作
boolean suspended = processInstance.isSuspended();
String id = processInstance.getId();
if(suspended){
    // 挂起--》激活
    runtimeService.activateProcessInstanceById(id);
    System.out.println("流程定义：" + id + "，已激活");
}else{
    // 激活--》挂起
    runtimeService.suspendProcessInstanceById(id);
    System.out.println("流程定义：" + id + "，已挂起");
}

启动第二个流程实例后再查看相关的表结构时，对他们的关系理解会更加的清楚一些

启动一个新的流程实例对应的就会产生两条记录

image-20220322135605252

IDENTITYLINK中会记录每次流程操作的信息

image-20220322135636841

image-20220322135659671

流程变量数据，及时key 相同，但是属于不同的流程实例相互间也是隔离的

image-20220322135719104

完成流程

然后我们把第一个流程处理完成

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_RU_EXECUTION 运行时流程执行实例
  • ACT_RU_IDENTITYLINK 运行时用户关系信息
  • ACT_RU_TASK 运行时任务表
  • ACT_RU_VARIABLE 运行时变量表

这四张表中对应的数据都没有了，也就是这个流程已经不是运行中的流程了。然后在对应的历史表中我们可以看到相关的信息

  • 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_HI_ACTINST 历史的流程实例

字段名称备注
ID_主键
PROC_DEF_ID_流程定义ID
PROC_INST_ID_流程实例ID
EXECUTION_ID_执行ID
ACT_ID_节点实例ID
TASK_ID_任务ID
CALL_PROC_INST_ID_调用外部的流程实例ID
ACT_NAME_节点名称
ACT_TYPE_节点类型
ASSIGNEE_处理人
START_TIME_开始时间
END_TIME_结束时间
DURATION_耗时
DELETE_REASON_删除原因
TENANT_ID_租户编号

image-20220322141800554

image-20220322141825065

ACT_HI_IDENTITYLINK 历史的流程运行过程中用户关系

字段名称备注
ID_主键
GROUP_ID_组编号
TYPE_类型
USER_ID_用户编号
TASK_ID_任务编号
CREATE_TIME_创建时间
PROC_INST_ID_流程实例编号
SCOPE_ID_
SCOPE_TYPE_
SCOPE_DEFINITION_ID_

image-20220322141717826

ACT_HI_PROCINST 历史的流程实例

字段名称备注
ID_主键
PROC_INST_ID_流程实例ID
BUSINESS_KEY_业务主键
PROC_DEF_ID_属性ID
START_TIME_开始时间
END_TIME_结束时间
DURATION_耗时
START_USER_ID_起始人
START_ACT_ID_起始节点
END_ACT_ID_结束节点
SUPER_PROCESS_INSTANCE_ID_父流程实例ID
DELETE_REASON_删除原因
TENANT_ID_租户编号
NAME_名称

image-20220322141855401

image-20220322141912602

ACT_HI_TASKINST 历史的任务实例

字段名称备注
ID_主键
PROC_DEF_ID_流程定义ID
TASK_DEF_KEY_任务定义的ID值
PROC_INST_ID_流程实例ID
EXECUTION_ID_执行ID
PARENT_TASK_ID_父任务ID
NAME_名称
DESCRIPTION_说明
OWNER_实际签收人 任务的拥有者签收人（默认为空，只有在委托时才有值）
ASSIGNEE_被指派执行该任务的人
START_TIME_开始时间
CLAIM_TIME_任务拾取时间
END_TIME_结束时间
DURATION_耗时
DELETE_REASON_删除原因
PRIORITY_优先级别
DUE_DATE_过期时间
FORM_KEY_节点定义的formkey
CATEGORY_类别
TENANT_ID_租户

image-20220322142609163

image-20220322142650699

ACT_HI_VARINST 历史的流程运行中的变量信息：流程变量虽然在任务完成后在流程实例表中会删除，但是在历史表中还是会记录的

字段名称备注
ID_主键
PROC_INST_ID_流程实例ID
EXECUTION_ID_指定ID
TASK_ID_任务ID
NAME_名称
VAR_TYPE_参数类型
REV_数据版本
BYTEARRAY_ID_字节表ID
DOUBLE_存储double类型数据
LONG_存储long类型数据
…

image-20220322142756867

Flowable基本操作
04-27 799
flowable
Flowable 管理各业务流程：流程设计器 (获取流程模型 XML)、流程部署、启动流程、流程审批、流程挂起和激活、任务分配
专注于计算机研发知识和资讯分享
01-18 741
BPMN 定义了如何用符号来描述业务流程，这种符号组合在一起就是个模型，但是程序不能直接识别这些符号，因此 BPMN 规定使用 XML 格式来编码业务流程模型，这种编码形式称为 BPMN XML。Flowable 官方有提供一个名为 Flowable-UI 的东西，这是一个 Web 应用，可以直接在这上面设计业务流程，但是 Flowable-UI 从 Flowable 7 以后就没提供了，我们一般使用流程设计器画图业务流程模型，再导出为 BPMN 规范的 XML 文件，然后再使用。
Flowable 自动部署模型 详解
csdn_tom_168的博客
07-14 775
Flowable自动部署模型详解： 核心机制：引擎启动时自动扫描BPMN/DMN/CMMN等资源文件，通过哈希比对避免重复部署，支持原子性回滚。 配置方式：通过YAML定义扫描路径、文件类型和部署模式，支持多环境差异化配置。 执行流程：包含资源扫描→模型校验→数据库写入（ACT_RE_DEPLOYMENT等表）→版本控制四阶段。 高级特性：租户隔离、部署监听器、生产环境手动API部署等。典型问题包含文件修改未生效、多模块扫描失败等，可通过强制部署或classpath*:前缀解决。建议生产环境关闭自动扫描，改
Flowable API实战：动态流程控制与事件处理
最新发布
dom_jun的博客
07-22 798
本文深入探讨了Flowable API在动态流程控制与事件处理中的实战应用。首先介绍了三种动态任务分配方式：运行时设置负责人、候选人与候选组机制，以及通过自定义AssignmentHandler实现复杂审批逻辑。接着详细解析了Flowable的事件监听机制，包括全局事件监听器的配置和任务监听器的实现方法，展示了如何在不侵入流程定义的情况下实现业务逻辑的解耦处理。文章通过具体代码示例，演示了如何动态指定审批人、处理多人协作任务场景，以及如何在流程关键节点插入业务逻辑（如日志记录、通知发送等），为复杂业务流程的
Flowable-BPMN操作流程部署启动源码
01-11
Flowable-BPMN操作流程部署启动源码，具体理解和操作参考我的专栏https://blog.csdn.net/houyj1986/column/info/31755，第10节
flowable源码解析之流程部署
Sombie Fate的专栏
08-25 1415
本文详细剖析了流程部署的过程，流程部署的核心在于将流程模型的 XML 文件解析为 BpmnModel 对象，然后生成流程定义信息，并最终对 BpmnModel 对象和流程定义信息进行缓存。尽管如此，本文尚未对将流程模型的 XML 文件转换为 BpmnModel 对象的具体过程进行深入探讨。
Flowable深入浅出-13 Flowable-BPMN操作流程之流程进展查看之流程图
01-17
Flowable深入浅出-13 Flowable-BPMN操作流程之流程进展查看之流程图,欢迎在我的专栏查看该文章（第13篇），专栏地址:https://blog.csdn.net/houyj1986/column/info/31755
SpringBoot整合Flowable工作流之流程部署
桐花思雨
10-25 4867
有的时候，我们的流程可能并不是提前设计好的，而是项目启动之后，动态部署的，例如项目启动成功之后，动态上传一个流程的。当然，无论是存放流程文件的位置，还是流程文件的格式，都是可以定制的，涉及到的属性主要有三个，可在。文件进行部署，这也是一种比较常见的场景，对于这种情况，我们可以按照如下方式进行部署。目录下的所有流程文件会自动被部署，流程文件的后缀有两种形式。默认情况下，我们放在。
flowable通过代码部署流程、启动流程、审批流程、挂起激活流程
风之前
03-16 770
flowable java 工作流
自学Flowable流程引擎
07-04
自学Flowable流程引擎
【flowable流程引擎入门】
热门推荐
weixin_38128387的博客
02-28 1万+
flowable流程引擎入门
Flowable 6.4.0官方github源代码
12-23
Flowable 6.4.0官方github源代码，可以编译通过的代码，对于学习Flowable的底层机制是一个必不可少的资源
Flowable深入浅出-14 Flowable-BPMN操作流程之任务完成
01-19
Flowable深入浅出-14 Flowable-BPMN操作流程之任务完成,欢迎进入我的专栏第14节查看，专栏地址:https://blog.csdn.net/houyj1986/column/info/31755
flowable流程在线编辑项目
09-27
最新版flowable6.3.1流程在线编辑项目，war包形式，放置Tomcat的webapp下，自动部署安装。
flowableDemo
10-10
简单的流程实现，可以运行。开发环境是idea,用的工作流flowable6.2.1
三.Flowable流程关系及数据表详细说明
东天里的冬天
05-20 3428
通过本篇文章你能够学习到如下知识点： 1.流程的概念以及流程之间的关系； 2.Flowable数据表的命名规则； 3.数据表的分类以及相关表的功能； 4.数据表详细字段的含义以及表关联关系；
flowable(六) -维修流程java代码。
吴灵辉的博客
10-12 621
模仿demo写实例 采用springboot+flowable快速实现工作流 clone下来他的请假流程。 把他的bpm2.xml导入到modeler查看流程图 demo的流程和代码分析 局部变量的使用 连线条件 监听器 任务监听器 执行监听器 ...
Spring Boot3.x集成Flowable7.x（一）Spring Boot集成与设计、部署、发起、完成简单流程
weixin_56672359的博客
12-25 2854
Spring Boot3.x集成Flowable7.x实现Spring Boot集成与设计、部署、发起、查询流程进度、查询代办任务、完成任务、终止实例等实现代码及案例
Java如何使用flowable流代码示例
DKPT的博客
06-14 820
Flowable 是一个开源的 BPMN 2.0 工作流引擎，用于在 Java 应用中构建业务流程和案例管理。以下是一个简单的 Java 代码示例，说明如何使用 Flowable API 来部署一个 BPMN 2.0 流程定义，并启动一个流程实例。在实际应用中，可能需要处理流程中的用户任务、等待状态、事件等。流程定义的 key（“myProcess”）是用于启动流程实例的，它应该与 BPMN 文件中的流程定义 ID 或 key 相匹配。首先，确保已经在项目中添加了 Flowable 的依赖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

清河大善人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值