Flowable工作流基础介绍

已于 2023-07-04 16:30:29 修改
阅读量2.8k 收藏 14
点赞数 2
文章标签： java
于 2022-10-28 17:56:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suiyishiguang/article/details/127567438
版权

文章目录

一：Flowable UI应用与本地部署

1.1 应用

  Flowable提供了几个web应用，用于演示及介绍Flowable项目提供的功能：

  • Flowable IDM: 身份管理应用。为所有Flowable UI应用提供单点登录认证功能，并且为拥有IDM管理员权限的用户提供了管理用户、组与权限的功能。
  • Flowable Modeler: 让具有建模权限的用户可以创建流程模型、表单、选择表与应用定义。
  • Flowable Task: 运行时任务应用。提供了启动流程实例、编辑任务表单、完成任务，以及查询流程实例与任务的功能。
  • Flowable Admin: 管理应用。让具有管理员权限的用户可以查询BPMN、DMN、Form及Content引擎，并提供了许多选项用于修改流程实例、任务、作业等。管理应用通过REST API连接至引擎，并与Flowable Task应用及Flowable REST应用一同部署。

  所有其他的应用都需要Flowable IDM提供认证。每个应用的WAR文件可以部署在相同的servlet容器（如Apache Tomcat）中，也可以部署在不同的容器中。由于每个应用使用相同的cookie进行认证，因此应用需要运行在相同的域名下。

1.2 本地的安装部署

1.2.1 安装tomcat

tomcat官网：https://tomcat.apache.org/download-80.cgi
在这里插入图片描述
下载后，解压到非中文的安装目录下

1.2.2 安装flowable-ui

下载地址：https://github.com/flowable/flowable-engine/releases/tag/flowable-6.7.2
在这里插入图片描述
然后把解压缩后的两个war包拷贝到Tomcat的解压缩的webapps目录下
在这里插入图片描述
Tomcat目录：
在这里插入图片描述

1.2.3 修改flowable-ui.war的配置文件

在D:\Tomcat\webapps\flowable-ui\WEB-INF\classes修改flowable-default文件的配置信息
在这里插入图片描述
1）指定端口号，默认为8080
2）连接数据库的注册驱动，以及连接信息，如果数据库没有flowable的库，则会自动创建
3）配置连接数据库的用户名和密码

1.2.4 启动tomcat来部署flowable

进入到tomcat/bin目录下，双击startup.bat文件
在这里插入图片描述
在这里插入图片描述
此时访问 http://127.0.0.1:8080/flowable-ui/,默认的登录用户名和密码为admin test
![在这里插入图片描述](https://img-blog.csdnimg.cn/c4953ec2e9914ee19aa77a2d08b27a16.png

1.2.5 flowable启动报错问题解决

当启动时，遇到如下图问题
问题1：Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException:
在这里插入图片描述
问题2：
Caused by: java.lang.IllegalStateException: Cannot load driver class: com.mysql.cj.jdbc.Driver
在这里插入图片描述
1）修改flowable-default的注册驱动，mysql版本8.0以上要加上cj

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

2）修改mysql的连接信息，加上characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&nullCatalogMeansCurrent=true&useSSL=false

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/flowable?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&allowMultiQueries=true&nullCatalogMeansCurrent=true&useSSL=false

3）下载mysql-connector-java-8.0.16.jar的包
下载地址：https://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-java-8.0.16.zip
下载后，把下载好的jar包，拷贝到D:\Tomcat\webapps\flowable-ui\WEB-INF\lib目录下
此时就不报错了！！！

1.3 用户管理

emsp;我们先在 身份管理应用程序 中创建用户并授权
在这里插入图片描述
创建用户
在这里插入图片描述
填写详细信息
在这里插入图片描述
授权管理
在这里插入图片描述

1.4 绘制流程

1）创建新的流程
在这里插入图片描述
2）流程图界面
在这里插入图片描述
3）创建流程，分配处理人
在这里插入图片描述
在这里插入图片描述

4）继续完成流程图的创建
在这里插入图片描述

1.5 部署流程

emsp; 绘制好的流程图，我们只需要一键导出即可
在这里插入图片描述
下载下来后拷贝到项目的resource目录下即可
在这里插入图片描述
然后就是正常的操作流程了！

二：Flowable介绍

Flowable是BPMN的一个基于java的软件实现，不过Flowable不仅仅包括BPMN，还有DMN决策表和CMMN Case管理引擎，并且有自己的用户管理、微服务API等一系列功能，是一个服务平台。
在这里插入图片描述

三：Flowable基础

官方手册：https://tkjohn.github.io/flowable-userguide/#_introduction

3.1 创建ProcessEngine

 用IDEA创建一个基本的maven工程，然后添加两个依赖。

  • Flowable流程引擎。使我们可以创建一个ProcessEngine流程引擎对象，并访问Flowable API。
  • 一个是MySQL的数据库驱动

在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>

emsp;然后创建一个普通的Java类，添加对应的main方法，首先要做的是初始化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();
}

 注意在mysql8.0中执行可能出现如下的错误
在这里插入图片描述
emsp;出现这种情况只需要在mysql的连接字符串中添加上nullCatalogMeansCurrent=true，设置为只查当前连接的schema库即可。

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

emsp;然后应用运行没有问题，但也没有在控制台提供有用的信息，只有一条消息提示日志没有正确配置。Flowable使用SLF4J作为内部日志框架。在这个例子中，我们使用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>

 Log4j需要一个配置文件。在src/main/resources文件夹下添加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

 重新运行应用。应该可以看到关于引擎启动与创建数据库表结构的提示日志：
在这里插入图片描述
 同时可以看到创建了相关的表结构在数据库中
在这里插入图片描述
 这样就得到了一个启动可用的流程引擎。接下来为它提供一个流程！

3.2 部署流程定义

 接下来我们构建一个非常简单的请假流程，Flowable引擎需要流程定义为BPMN 2.0格式，这是一个业界广泛接受的XML标准。 在Flowable术语中，我们将其称为一个流程定义(process definition)。一个流程定义可以启动多个流程实例(process instance)。流程定义可以看做是重复执行流程的蓝图。 在这个例子中，流程定义定义了请假的各个步骤，而一个流程实例对应某个雇员提出的一个请假申请。
  BPMN 2.0存储为XML，并包含可视化的部分：使用标准方式定义了每个步骤类型（人工任务，自动服务调用，等等）如何呈现，以及如何互相连接。这样BPMN 2.0标准使技术人员与业务人员能用双方都能理解的方式交流业务流程。
我们要使用的流程定义为：
在这里插入图片描述
 流程定义说明：

  • 我们假定启动流程需要提供一些信息，例如雇员名字、请假时长以及说明。当然，这些可以单独建模为流程中的第一步。 但是如果将它们作为流程的“输入信息”，就能保证只有在实际请求时才会建立一个流程实例。否则（将提交作为流程的第一步），用户可能在提交之前改变主意并取消，但流程实例已经创建了。 在某些场景中，就可能影响重要的指标（例如启动了多少申请，但还未完成），取决于业务目标。
  • 左侧的圆圈叫做启动事件(start event)。这是一个流程实例的起点。
  • 第一个矩形是一个用户任务(user task)。这是流程中用户操作的步骤。在这个例子中，经理需要批准或驳回申请
  • 取决于经理的决定，排他网关(exclusive gateway) (带叉的菱形)会将流程实例路由至批准或驳回路径
  • 如果批准，则需要将申请注册至某个外部系统，并跟着另一个用户任务，将经理的决定通知给申请人。当然也可以改为发送邮件。
  • 如果驳回，则为雇员发送一封邮件通知他。

  一般来说，这样的流程定义使用可视化建模工具建立，如Flowable Designer(Eclipse)或Flowable Web Modeler(Web应用)。但在这里我们直接撰写XML，以熟悉BPMN 2.0及其概念。
  与上面展示的流程图对应的BPMN 2.0 XML在下面显示。请注意这只包含了“流程部分”。如果使用图形化建模工具，实际的XML文件还将包含“可视化部分”，用于描述图形信息，如流程定义中各个元素的坐标（所有的图形化信息包含在XML的BPMNDiagram标签中，作为definitions标签的子元素）。
  将下面的XML保存在src/main/resources文件夹下名为holiday-request.bpmn20.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="Holiday Request" isExecutable="true">

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

        <userTask id="approveTask" name="Approve or reject request"/>
        <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>

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

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

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

    /**
     * 部署流程
     */
    @Test
    public void testDeploy(){
        // 配置数据库相关信息 获取 ProcessEngineConfiguration
        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true")
                .setJdbcUsername("root")
                .setJdbcPassword("123456")
                .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("holiday-request.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图片会保存在该表中
在这里插入图片描述
 我们现在可以通过API查询验证流程定义已经部署在引擎中（并学习一些API）。通过RepositoryService创建的ProcessDefinitionQuery对象实现。

/**
     * 查看流程定义
     */
    @Test
    public void testDeployQuery(){
        // 配置数据库相关信息 获取 ProcessEngineConfiguration
        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true")
                .setJdbcUsername("root")
                .setJdbcPassword("123456")
                .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("2501")
                .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());

    }

输出结果为：

processDefinition.getId() = holidayRequest:2:2503
processDefinition.getName() = Holiday Request
processDefinition.getDeploymentId() = 2501
processDefinition.getDescription() = null

3.3 启动流程实例

msp;现在已经在流程引擎中部署了流程定义，因此可以使用这个流程定义作为“模板”启动流程实例。
在这里插入图片描述
 要启动流程实例，需要提供一些初始化流程变量。一般来说，可以通过呈现给用户的表单，或者在流程由其他系统自动触发时通过REST API，来获取这些变量。在这个例子里，我们简化直接在代码中定义了，我们使用RuntimeService启动一个流程实例。

    /**
     * 启动流程实例
     */
    @Test
    public void testRunProcess(){
        // 配置数据库相关信息 获取 ProcessEngineConfiguration
        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true")
                .setJdbcUsername("root")
                .setJdbcPassword("123456")
                .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("employee","张三") ;// 谁申请请假
        variables.put("nrOfHolidays",3); // 请几天假
        variables.put("description","工作累了，想出去玩玩"); // 请假的原因
        // 启动流程实例，第一个参数是流程定义的id
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceByKey("holidayRequest", variables);// 启动流程实例
        // 输出相关的流程实例信息
        System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());
        System.out.println("流程实例的ID：" + processInstance.getId());
        System.out.println("当前活动的ID：" + processInstance.getActivityId());
    }

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

流程定义的ID：holidayRequest:2:2503
流程实例的ID：5001
当前活动的ID：null

对应的流程实例ID为：5001
启动流程实例涉及到的表结构：

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

3.4 查看任务

 上面员工发起了一个请假流程，接下来就会流转到总经理这儿来处理，之前我们没有指定经理这的处理人，我们可以加一个
在这里插入图片描述
 然后我们来查看下lisi的任务

    /**
     * 查看任务
     */
    @Test
    public void testQueryTask(){
        // 配置数据库相关信息 获取 ProcessEngineConfiguration
        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true")
                .setJdbcUsername("root")
                .setJdbcPassword("123456")
                .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("holidayRequestNew")
                .taskAssignee("lisi")
                .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() = holidayRequestNew:1:10003
task.getId() = 12508
task.getAssignee() = lisi
task.getName() = Approve or reject request

3.5 完成任务

 现在李四这个角色可以来完成当前的任务了
在这里插入图片描述
emsp;在此处我们直接解决掉这个请假，然后会走发送拒绝邮件的流程，这块我们需要用到JavaDelegate来触发。
在这里插入图片描述
我们定义这样一个Java类

public class SendRejectionMail implements JavaDelegate {
    /**
     * 触发发送邮件的操作
     * @param delegateExecution
     */
    @Override
    public void execute(DelegateExecution delegateExecution) {
        System.out.println("请假被拒绝,,,安心工作吧");
    }
}

然后来完成任务

    /**
     * 完成任务
     */
    @Test
    public void testCompleteTask(){
        // 配置数据库相关信息 获取 ProcessEngineConfiguration
        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true")
                .setJdbcUsername("root")
                .setJdbcPassword("123456")
                .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("holidayRequestNew")
                .taskAssignee("lisi")
                .singleResult();
        // 添加流程变量
        Map<String,Object> variables = new HashMap<>();
        variables.put("approved",false); // 拒绝请假
        // 完成任务
        taskService.complete(task.getId(),variables);
    }

然后可以看到JavaDelegate触发了
在这里插入图片描述

3.6 流程的删除

  有些流程已经没有用了，我们需要删除掉，其实也非常简单

    /**
     * 删除流程
     */
    @Test
    public void testDeleteProcess(){
        // 配置数据库相关信息 获取 ProcessEngineConfiguration
        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true")
                .setJdbcUsername("root")
                .setJdbcPassword("123456")
                .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("2501",true);

    }

3.7 查看历史信息

emsp; 选择使用Flowable这样的流程引擎的原因之一，是它可以自动存储所有流程实例的审计数据或历史数据。这些数据可以用于创建报告，深入展现组织运行的情况，瓶颈在哪里，等等。

  例如，如果希望显示流程实例已经执行的时间，就可以从ProcessEngine获取HistoryService，并创建*历史活动(historical activities)*的查询。在下面的代码片段中，可以看到我们添加了一些额外的过滤条件：

  • 只选择一个特定流程实例的活动
  • 只选择已完成的活动

  结果按照结束时间排序，代表其执行顺序。

/**
     * 查看历史
     */
    @Test
    public void testQueryHistory(){
        // 配置数据库相关信息 获取 ProcessEngineConfiguration
        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true")
                .setJdbcUsername("root")
                .setJdbcPassword("123456")
                .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("holidayRequestNew:1:10003")
                .finished()
                .orderByHistoricActivityInstanceEndTime().asc()
                .list();
        for (HistoricActivityInstance historicActivityInstance : list) {
            System.out.println(historicActivityInstance.getActivityId() + " took "
                    + historicActivityInstance.getDurationInMillis() + " milliseconds");
        }

    }

输出结果

startEvent took 1 milliseconds
approveTask took 837735 milliseconds
decision took 13 milliseconds
sendRejectionMail took 2 milliseconds
rejectEnd took 1 milliseconds

好了~flowable的基本应用我们就先介绍到这里了。

四：Flowable基础表结构

4.1 表结构讲解

 工作流程的相关操作都是操作存储在对应的表结构中，为了能更好的弄清楚Flowable的实现原理和细节，我们有必要先弄清楚Flowable的相关表结构及其作用。在Flowable中的表结构在初始化的时候会创建五类表结构，具体如下：

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

4.2 ProcessEngine讲解

4.2.1 硬编码的方式

 我们前面讲解案例的时候是通过ProcessEngineConfiguration这个配置类来加载的。

// 配置数据库相关信息 获取 ProcessEngineConfiguration
ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
    .setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn2?serverTimezone=UTC&nullCatalogMeansCurrent=true")
    .setJdbcUsername("root")
    .setJdbcPassword("123456")
    .setJdbcDriver("com.mysql.cj.jdbc.Driver")
    .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
// 获取流程引擎对象
ProcessEngine processEngine = cfg.buildProcessEngine();

 这种方式会调用buildProcessEngine()方法，里面的核心代码为：
在这里插入图片描述
在这里插入图片描述

4.2.2 配置文件

  除了上面的硬编码的方式外，我们还可以在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>

  在上面的配置文件中配置相关的信息。我们在Java代码中就可以简化为：

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

 可以看下getDefaultProcessEngine的源码，在里面最终还是执行了和硬编码一样的代码

    public static ProcessEngine getProcessEngine(String processEngineName) {
        if (!isInitialized()) {
            init(); // 完成初始化操作
        }
        return processEngines.get(processEngineName);
    }

  进入init方法

    public static synchronized void init() {
        if (!isInitialized()) {
            if (processEngines == null) {
                // Create new map to store process-engines if current map is null
                processEngines = new HashMap<>();
            }
            ClassLoader classLoader = ReflectUtil.getClassLoader();
            Enumeration<URL> resources = null;
            try {
                resources = classLoader.getResources("flowable.cfg.xml"); // 加载flowable.cfg.xml配置文件
            } catch (IOException e) {
                throw new FlowableIllegalArgumentException("problem retrieving flowable.cfg.xml resources on the classpath: " + System.getProperty("java.class.path"), e);
            }

            // Remove duplicated configuration URL's using set. Some
            // classloaders may return identical URL's twice, causing duplicate
            // startups
            Set<URL> configUrls = new HashSet<>();
            while (resources.hasMoreElements()) {
                configUrls.add(resources.nextElement());
            }
            for (Iterator<URL> iterator = configUrls.iterator(); iterator.hasNext();) {
                URL resource = iterator.next();
                LOGGER.info("Initializing process engine using configuration '{}'", resource.toString());
                initProcessEngineFromResource(resource); // 初始化ProcessEngine
            }

            try {
                resources = classLoader.getResources("flowable-context.xml"); // 在整合Spring的情况下加载该文件
            } catch (IOException e) {
                throw new FlowableIllegalArgumentException("problem retrieving flowable-context.xml resources on the classpath: " + System.getProperty("java.class.path"), e);
            }
            while (resources.hasMoreElements()) {
                URL resource = resources.nextElement();
                LOGGER.info("Initializing process engine using Spring configuration '{}'", resource.toString());
                initProcessEngineFromSpringResource(resource); // 从Spring的资源文件中完成ProcessEngine的初始化
            }

            setInitialized(true);
        } else {
            LOGGER.info("Process engines already initialized");
        }
    }

  在源码中提供了单独使用好整合Spring的配置加载方式。再进入到initProcessEngineFromResource(resource)方法中：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
而且我们也可以看到ProcessEngine最终的实现是 ProcessEngineImpl对象。

4.2.3 自定义配置文件

 最后我们如果要加载自定义名称的配置文件可以通过ProcessEngineConfiguration中的对应构造方法来实现

    @Test
    public void test2() throws Exception{
        ProcessEngineConfiguration configuration = ProcessEngineConfiguration
                .createProcessEngineConfigurationFromResource("flowable.cfg.xml");
        ProcessEngine processEngine = configuration.buildProcessEngine();
        System.out.println("processEngine = " + processEngine);
    }

4.3 Servcie服务接口

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

4.3.1 Service创建方式

通过ProcessEngine创建Service
方式如下：

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

4.3.2 Service总览

在这里插入图片描述
简单介绍：

RepositoryService

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

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

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

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

RuntimeService

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

TaskService

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

HistoryService

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

ManagementService

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

4.4 图标介绍

  BPMN 2.0是业务流程建模符号2.0的缩写。它由Business Process Management Initiative这个非营利协会创建并不断发展。作为一种标识，BPMN 2.0是使用一些符号来明确业务流程设计流程图的一整套符号规范，它能增进业务建模时的沟通效率。目前BPMN2.0是最新的版本，它用于在BPM上下文中进行布局和可视化的沟通。接下来我们先来了解在流程设计中常见的 符号。

BPMN2.0的基本符合主要包含：

4.4.1 事件图标

emsp;在Flowable中的事件图标启动事件，边界事件,中间事件和结束事件.
在这里插入图片描述

4.4.2 活动(任务)图标

  活动是工作或任务的一个通用术语。一个活动可以是一个任务，还可以是一个当前流程的子处理流程； 其次，你还可以为活动指定不同的类型。常见活动如下:
在这里插入图片描述

4.4.3 网关图标

emsp; 网关用来处理决策，有几种常用网关需要了解：
在这里插入图片描述

4.5 流程部署详解

4.5.1 部署实现

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

/**
     * 部署流程
     */
    @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());
    }

4.5.2 部署涉及表结构

涉及到的三张表：
部署资源表：act_ge_bytearray
在这里插入图片描述
部署ID表：act_re_deployment
在这里插入图片描述
流程表：act_re_procdef
在这里插入图片描述
注意：
业务流程定义数据表。此表和ACT_RE_DEPLOYMENT是多对一的关系，即，一个部署的bar包里可能包含多个流程定义文件，每个流程定义文件都会有一条记录在ACT_REPROCDEF表内，每个流程定义的数据，都会对于ACT_GE_BYTEARRAY表内的一个资源文件和PNG图片文件。和ACT_GE_BYTEARRAY的关联是通过程序用ACT_GE_BYTEARRAY.NAME与ACT_RE_PROCDEF.NAME_完成的

4.5.3 挂起和激活

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

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

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

具体的实现其实就是更新了流程定义表中的字段
在这里插入图片描述
而且通过REV_字段来控制数据安全，也是一种乐观锁的体现了，如果要启动一个已经挂起的流程就会出现如下的错误
在这里插入图片描述

4.6 启动流程实例

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

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

4.7 处理流程

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

// 获取流程引擎对象
        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 运行时变量表
  • ACT_RU_TASK 运行时任务表 :会新生成一条记录

当然流程实例也可以挂起

// 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 + "，已挂起");
}

4.8 完成一个流程

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

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 历史的流程运行中的变量信息

随意石光
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
flowable工作流看这一篇就够了（基础篇）
qq_38196449的博客
12-10 4737
接下来我们构建一个非常简单的请假流程，Flowable引擎需要流程定义为BPMN 2.0格式，这是一个业界广泛接受的XML标准。在Flowable术语中，我们将其称为一个流程定义(process definition)。一个流程定义可以启动多个流程实例(process instance)。流程定义可以看做是重复执行流程的蓝图。在这个例子中，流程定义定义了请假的各个步骤，而一个流程实例对应某个雇员提出的一个请假申请。
Springboot集成flowable modeler web流程设计器
06-11 3458
之前画流程图都是用tomcat启动flowable modeler，但是这样启动就不能在分配任务用户/用户组的时候查询自己系统里的数据。所以现在需要把flowable modeler集成到项目里来。 之前自己也搜索了很多文章，都感觉不是很清晰，可能也是因为我刚接触不久。现在自己集成好了之后，记录一下自己学习的结果。 首先需要创建一个springboot应用，pom文件中引入相关jar包： <properties> <java.version>1.8</java.ve
SpringBoot2.7集成flowable最新版，java工作流服务端实现，解耦设计
02-28
# 基于原生flowable实现的流程引擎 本项目基于最新6.8.0的flowable，使用最新springboot集成。文档请联系作者索要。 在尽可能保证原生的基础上，扩展适配了一套sdk，可以安全稳定地集成到各种项目上 ## 实现核心 在尽可能复用flowable代码的基础上，我们做了如下适配： 1. 多租户存储适配。flowable默认不分库，单表使用字段区分。我们为了服务性能，将重写其入库逻辑，实现schema隔离 2. 用户权限适配，基于flowable IDM模块进行适配，将用户、组、权限与实际项目进行融合，提供适配模块开箱即用 3. 超级灵活的回调机制，不需要耦合任何业务逻辑就可以在任何项目中集成 ## 快速集成思路 flowable官方提供了rest-api包，本项目已经集成，可以直接由第三方调用。 我们为此开发一个轻量级的SDK，通过声明式快速集成REST API，然后注入自己的interface，像调用原生一样调用flowable方法。 ## 使用方法 单独启动项目后，通过配套的sdk调用官方接口，就能够完成工作流的快速接入，轻量解耦。
Flowable 基本用法
最新发布
m0_65037354的博客
04-21 961
Flowable 是一个基于 Java 的开源工作流引擎，用于实现和管理业务流程。它提供了强大的工作流引擎和一套丰富的工具，使开发人员能够轻松地建模、部署、执行和监控各种类型的业务流程。Flowable 是 Activiti 工作流引擎的一个分支，诞生于 Activiti 项目与 Alfresco 合并后的分裂，继承了 Activiti 的大部分特性并在此基础上进行了进一步的开发和改进。Flowable 提供了灵活且可扩展的工作流引擎，可以根据不同的业务需求定制和扩展业务流程。
flowable web界面 war包
12-19
flowable web界面支持 做flowable工作流程图使用 使用方法自行百度
Flowable工作流实战课程
05-17
课程分享——Flowable工作流实战课程，完整版视频课程下载。 Flowable是Activiti原班人马开发的一套新的工作流框架，支持了cmmn引擎以及dmn引擎。重构了Activiti的源码，使Flowable的性能更加的流畅。课程可以让大家快速入门 Flowable。 让零基础的学员通过学习一步步成为使用流程设计高手，让流程变的如此简单!你也可以成为流程大神!让零基础学员通过学习了解Bpmn发展前景及应用范围，通过系统学习能成为工作流架构师!
hsweb-flowable-modeler：flowable在线设计器
01-30
flowable在线流程设计器spring-boot集成 基于flowable5.23，spring-boot 1.4.5.RELEASE $ git clone https://github.com/hs-web/hsweb-flowable-modeler.git 导入ide。启动test目录下的FlowableModelTest 。 启动完成后，浏览器打开http://localhost:8080/workflow/modeler.html?modelId=5或者根据控制台提示打开对应的链接
Flowable流程入门课程
05-08
本课程基于最新版开源工作流Flowable 6.6.0进行讲解。着重讲解Flowable工作流的概念、理论和实战。课程内容包括Flowable的架构、安装部署与配置、工作流应用开发与运行的主要过程、Flowable流程引擎服务及其API、Flowable主要元素如事件/序列流/网关/活动和任务、Flowable表单引擎的安装配置和引擎服务、Flowable表单引擎与Spring的集成、表单定义及部署、表单REST API、 Flowable 身份管理应用、Flowable 建模器应用、Flowable 任务应用和Flowable 管理应用等概念、术语和实战内容，让大家能快速实现基于Flowable的流程应用开发。通过对Flowable官方文档进行了彻底梳理和融汇贯通，并结合实践，整合成13小时15分钟共56节的基础课程，系统、简明地呈现给大家，让大家从开源软件文档冗长耗时、英文晦涩难懂、概念理解困难的困境中解脱出来，从而能快速地将Flowable应用到项目实践中去。课程特色： 案例和代码驱动、概念与实战相结合。
SpringBoot整合Flowable modeler设计器
u011353623的博客
12-22 859
再添加一个同包名和类名的获取用户信息类，覆盖flowable的。2.设置modeler跳过它自带的security安全认证。yml一般无需特别的配置，使用默认的配置即可。这样即可在页面中访问了（无需登录）。在main中排除安全配置类。
如何整合Flowable-modeler到自己的项目中
wscwsc58888的专栏
05-24 9913
如何整合Flowable-modeler到自己的项目中 Flowable工作流 flowable-modeler 几年没做工作流了，时过进迁，时不时忆起当年，还时那般激情热血。牢骚完，感慨闭，几年后的今天又要开始做自定义工作流的开发，今天首先分享一下我的第一步，整合Web流程设计器官方demo自带的modeler。这里要说几句题外话，本身原计划还时打算继续使用activiti的，想当年我还是基...
SpringBoot 集成 Flowable + Flowable Modeler 流程配置可视化（图解）
流楚丶格念的博客
09-08 2663
然后我们想要把他连接到Flowable包的代码逻辑和存储数据库就要编写与应用我们的项目自己配置类其中主要改用Flowable包下的几个配置类。
Flowable从入门到精通
12-31
从基础讲起，结合应用场景，由浅到深细化讲解BPMN和Flowable的相关组件，并结合具体实例，演示功能的使用和注意事项。最终结合Springboot搭建一套工作流系统，囊括一般项目中所需要的知识点，理论结合实际，让真正入门到熟练。 1 简介 2 学习指南 2.1 Flowable初体验 2.1.1 Flowable是什么？ 2.1.2 Flowable 和 Activiti 2.1.3 构建命令行应用程序 2.1.3.1 创建一个流程引擎 2.1.3.2 部署一个流程定义 2.1.3.3 启动一个流程实例 2.1.3.4 查询和完成一个任务 2.1.3.5 写一个JavaDelegate 2.1.3.6 查询历史数据 2.2 Flowable整合Spring 2.3 Flowable整合SpringBoot 2.4 Flowable流程定义部署 2.4.1 使用xml部署 2.4.2 使用压缩文件部署 2.4.3 使用IO流部署 3 BPMN2.0简介 3.1 什么是BPMN2.0 3.2 创建一个BPMN 3.2.1 直接编写XML文件 3.2.2 使用插件编写 3.2.2.1 在线安装插件 3.2.2.2 离线安装 3.2.2.3 插件使用说明 4 BPMN2.0组成 4.1 事件 4.1.1 事件定义 4.1.2 计时器事件定义 4.1.2.1 timeDate 4.1.2.1.1 开始事件TimerStartEvent 4.1.2.1.2 中间事件TimerCatchingEvent 4.1.2.1.3 边界事件TimerBoundaryEvent 4.1.2.2 timeDuration 4.1.2.2.1 开始事件TimerStartEvent 4.1.2.1.2 中间事件TimerCatchingEvent 4.1.2.1.3 边界事件TimerBoundaryEvent 4.1.2.3 timeCycle 4.1.2.3.1 开始事件TimerStartEvent 4.1.2.3.2 中间事件TimerCatchingEvent 4.1.2.3.3 边界事件TimerBoundaryEvent 4.1.3 消息事件 4.1.3.1 开始事件MessageStartEvent 4.1.3.2 中间事件MessagecatchingEvent 4.1.3.3 边界事件MessageBoundaryEvent 4.1.4 错误事件 4.1.4.1 开始事件ErrorStartEvent 4.1.4.2 边界事件ErrorBoundaryEvent 4.1.5 信号事件 4.1.5.1 开始事件SignalStartEvent 4.1.5.2 中间事件 4.1.5.2.1 捕捉事件SignalCatchingEvent 4.1.5.2.2 抛出事件SignalThrowingEvent 4.1.5.3 边界事件SignalBoundaryEvent dream21st 4.1.6结束事件 4.1.6.1 错误结束事件ErrorEndEvent 4.1.6.2 中断结束事件TerminateEndEvent 4.1.6.2.1 中断结束事件案例一 4.1.6.2.2 中断结束事件案例二 4.1.6.3 取消结束事件 CancelEndEvent 4.1.7 补偿事件CompensationThrowing 4.1.8 网关 4.1.8.1 并行网关ParallelGateway 4.1.8.2 排他网关ExclusiveGateway 4.1.8.3 包容网关InclusiveGateWay 4.1.8.4 事件网关EventGateway 4.2 任务 4.2.1 用户任务UserTask 4.2.1.1 用户任务入门案例Assignee指定 4.2.1.2 CandidateUser和CandidateGroup指定 4.2.1.3 多人会签MultiInstance 4.2.1.4 动态表单 4.2.2 服务任务ServiceTask 4.2.3 手工任务ManualTask 4.2.4 接受任务ReceiveTask 4.2.5 调用流程CallActivity 4.2.5.1 固定子流程 4.2.5.2 动态子流程 4.3 容器 5 工作流实战案例 5.1 实战案例一 5.1.1 部署流程定义 5.1.2 启动流程实例 5.1.3 查询待办任务 5.1.4 提交任务 5.1.5 查询候选任务 5.1.6 获取候选任务 5.1.7 通过流程实例ID查询任务流转图 5.2 实战案例二
flowable-6.5.0.rar
06-29
Flowable 项目提供了一组结构紧凑且高效的开源业务流程引擎。它们为开发人员、系统管理员和业务用户提供工作流和业务流程管理 （BPM） 平台。 其中心是一个闪电般的快速，久经考验的动态BPMN过程引擎，附带的DMN决策表和CMMN案例管理引擎，全部用Java编写。它们是 Apache 2.0 许可的开源，具有一个坚定的社区。 所有引擎都可以在 Java 应用程序中运行，也可以作为服务运行在服务器、群集和云中。它们可以作为独立的引擎或服务运行，也可以集成在一起，为业务流程管理提供丰富的套件。它们与春天完美融合。借助丰富的 Java 和 REST API，它们是协调人工或机器人自动化处理的理想基础。它们支持微服务编排或软线微服务本身。
Flowable课件-基础篇.md
07-21
Flowable课件-基础篇.md
工作流Flowable入门教程：flowableUI的安装使用，RepositoryService、RuntimeService、TaskService、HistoryService的使用
weixin_41677422的博客
02-24 3243
我们要构建的流程是一个非常简单的请假流程。Flowable引擎需要流程定义为BPMN 2.0格式，这是一个业界广泛接受的XML标准。在Flowable术语中，我们将其称为一个流程定义(process definition)。一个流程定义可以启动多个流程实例(process instance)。流程定义可以看做是重复执行流程的蓝图。在这个例子中，流程定义定义了请假的各个步骤，而一个流程实例对应某个雇员提出的一个请假申请。
从入门到实战—————Flowable(工作流)
q3198215426的博客
12-27 6624
Flowable是一个使用Java编写的轻量级业务流程引擎。Flowable流程引擎可用于部署BPMN 2.0流程定义（用于定义流程的行业XML标准）， 创建这些流程定义的流程实例，进行查询，访问运行中或历史的流程实例与相关数据，等等。
Flowable教程
tttalk的博客
12-28 4539
Flowable实战
【Flowable】Flowable工作流教程
Syals的博客
10-14 8986
我们要构建的流程是一个非常简单的请假流程。Flowable引擎需要流程定义为BPMN 2.0格式，这是一个业界广泛接受的XML标准。在Flowable术语中，我们将其称为一个流程定义(process definition)。一个流程定义可以启动多个流程实例(process instance)。流程定义可以看做是重复执行流程的蓝图。在这个例子中，流程定义定义了请假的各个步骤，而一个流程实例对应某个雇员提出的一个请假申请。我们要使用的流程定义为：这个流程应该已经十分自我解释了。
flowable部署流程的6种方式
weixin_42467369的博客
01-15 5022
一、部署工作流6中方式 使用文件流stream，部署工作流 使用classpath，部署工作流 使用压缩文件格式（zip）ZipStream，部署工作流 使用纯文本格式text，部署工作流 使用字节数组，部署工作流 使用动态创建的流程图，部署工作流 1. 使用文件流stream，部署工作流 上传的文件必须是XXXbpmn20.xml格式的。resourceName的后缀格式必须是XXXbpmn20.xml。 /**【1】使用文件流stream，部署工作流*/ //假设不是null，忽略此处赋值为nu
工作流框架flowable
09-04
Flowable是一套由原Activiti团队开发的工作流框架，它支持cmmn引擎和dmn引擎，并对Activiti的源码进行了重构，以提升性能和流畅度。Flowable可以帮助零基础的学员逐步学习并掌握工作流的应用。Flowable还提供了一个可操作界面的Web应用，称为Flowable UI，通过该应用可以进行流程的设计和操作。 Flowable提供了多种方式进行流程的设计，包括手动编写BPMN文件、使用Eclipse Designer、Idea actiBPM和Flowable UI等工具。此外，Flowable还提供了详细的文档和教程来帮助用户快速上手和理解框架的使用方法。 Flowable的表结构是其基础操作和整合Spring Boot的重要组成部分。用户可以根据具体需求配置依赖和文件，并通过编写代码来实现Flowable的各种功能。 总之，Flowable是一个功能强大的工作流框架，通过它可以实现复杂的流程管理和控制，并且提供了丰富的文档和工具来帮助用户快速上手。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Flowable工作流实战课程](https://download.csdn.net/download/hnmwykka/85399850)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [工作流框架Flowable](https://blog.csdn.net/m0_37583655/article/details/123899994)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

随意石光

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

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

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

打赏作者

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

抵扣说明：

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

余额充值