Flowable从零单排（一）

灰太狼 2022-11-02 11:45 317阅读 0赞

**一、Flowable 入门介绍**

官网地址：https://www.flowable.org/

Flowable6.3中文教程：https://tkjohn.github.io/flowable-userguide/\#\_introduction

可以在官网下载对应的jar包在本地部署运行，官方提供了下面的五个应用程序：

--------------------

Flowable Modeler：流程定义管理

Flowable Task：用户任务管理

Flowable IDM：用户组权限管理

Flowable REST API：流程引擎对外提供的API接口

Flowable Admin：后台管理

**二、初识Flowable五大引擎**

Flowable有五大引擎，每个之间都是相互独立互不影响。

ProcessEngine是里面最核心也是最重要的一个引擎，如果失去它那Flowable也就意义了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTQwMjA1_size_16_color_FFFFFF_t_70][]

**三、流程引擎初体验**

1.简单了解Bpmn

1.1Task任务：

用户任务（userTask）

系统任务（serviceTask ）

1.2Event事件：

定时器事件（timerEventDefinition）

1.3Gateway网关：

排他网关（exclusive gateway）

2.目标：实现以下简化版的请假流程

请假流程图（简单版）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTQwMjA1_size_16_color_FFFFFF_t_70 1][]

步骤1：定义相应的BPMN文件

步骤2：配置flowable.cfg.xml

步骤3：将流程定义添加到Repository仓储中

步骤4：Runtime开始一个流程实例

**四、数据库介绍**

**flowable命名规则：**

*  ACT\_RE\_\* ：’ RE ’表示repository（存储）。RepositoryService接口操作的表。带此前缀的表包含的是静态信息，如，流程定义，流程的资源（图片，规则等）。
 *  ACT\_RU\_\* ：’ RU ’表示runtime。这是运行时的表存储着流程变量，用户任务，变量，职责（job）等运行时的数据。flowable只存储实例执行期间的运行时数据，当流程实例结束时，将删除这些记录。这就保证了这些运行时的表小且快。
 *  ACT\_ID\_\* : ’ ID ’表示identity(组织机构)。这些表包含标识的信息，如用户，用户组，等等。
 *  ACT\_HI\_\* : ’ HI ’表示history。就是这些表包含着历史的相关数据，如结束的流程实例，变量，任务，等等。
 *  ACT\_GE\_\* : 普通数据，各种情况都使用的数据。

**34张表说明：**

<table> 
 <tbody> 
  <tr> 
   <th>表分类</th> 
   <th>表名</th> 
   <th>表说明</th> 
  </tr> 
  <tr> 
   <td>一般数据(2)</td> 
   <td>ACT_GE_BYTEARRAY</td> 
   <td>通用的流程定义和流程资源</td> 
  </tr> 
  <tr> 
   <td>ACT_GE_PROPERTY</td> 
   <td>系统相关属性</td> 
  </tr> 
  <tr> 
   <td>流程历史记录(8)</td> 
   <td>ACT_HI_ACTINST</td> 
   <td>历史的流程实例</td> 
  </tr> 
  <tr> 
   <td>ACT_HI_ATTACHMENT</td> 
   <td>历史的流程附件</td> 
  </tr> 
  <tr> 
   <td>ACT_HI_COMMENT</td> 
   <td>历史的说明性信息</td> 
  </tr> 
  <tr> 
   <td>ACT_HI_DETAIL</td> 
   <td>历史的流程运行中的细节信息</td> 
  </tr> 
  <tr> 
   <td>ACT_HI_IDENTITYLINK</td> 
   <td>历史的流程运行过程中用户关系</td> 
  </tr> 
  <tr> 
   <td>ACT_HI_PROCINST</td> 
   <td>历史的流程实例</td> 
  </tr> 
  <tr> 
   <td>ACT_HI_TASKINST</td> 
   <td>历史的任务实例</td> 
  </tr> 
  <tr> 
   <td>ACT_HI_VARINST</td> 
   <td>历史的流程运行中的变量信息</td> 
  </tr> 
  <tr> 
   <td>用户用户组表(9)</td> 
   <td>ACT_ID_BYTEARRAY</td> 
   <td>二进制数据表</td> 
  </tr> 
  <tr> 
   <td>ACT_ID_GROUP</td> 
   <td>用户组信息表</td> 
  </tr> 
  <tr> 
   <td>ACT_ID_INFO</td> 
   <td>用户信息详情表</td> 
  </tr> 
  <tr> 
   <td>ACT_ID_MEMBERSHIP</td> 
   <td>人与组关系表</td> 
  </tr> 
  <tr> 
   <td>ACT_ID_PRIV</td> 
   <td>权限表</td> 
  </tr> 
  <tr> 
   <td>ACT_ID_PRIV_MAPPING</td> 
   <td>用户或组权限关系表</td> 
  </tr> 
  <tr> 
   <td>ACT_ID_PROPERTY</td> 
   <td>属性表</td> 
  </tr> 
  <tr> 
   <td>ACT_ID_TOKEN</td> 
   <td>系统登录日志表</td> 
  </tr> 
  <tr> 
   <td>ACT_ID_USER</td> 
   <td>用户表</td> 
  </tr> 
  <tr> 
   <td>流程定义表(3)</td> 
   <td>ACT_RE_DEPLOYMENT</td> 
   <td>部署单元信息</td> 
  </tr> 
  <tr> 
   <td>ACT_RE_MODEL</td> 
   <td>模型信息</td> 
  </tr> 
  <tr> 
   <td>ACT_RE_PROCDEF</td> 
   <td>已部署的流程定义</td> 
  </tr> 
  <tr> 
   <td>运行实例表(10)</td> 
   <td>ACT_RU_DEADLETTER_JOB</td> 
   <td>正在运行的任务表</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_EVENT_SUBSCR</td> 
   <td>运行时事件</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_EXECUTION</td> 
   <td>运行时流程执行实例</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_HISTORY_JOB</td> 
   <td>历史作业表</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_IDENTITYLINK</td> 
   <td>运行时用户关系信息</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_JOB</td> 
   <td>运行时作业表</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_SUSPENDED_JOB</td> 
   <td>暂停作业表</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_TASK</td> 
   <td>运行时任务表</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_TIMER_JOB</td> 
   <td>定时作业表</td> 
  </tr> 
  <tr> 
   <td>ACT_RU_VARIABLE</td> 
   <td>运行时变量表</td> 
  </tr> 
  <tr> 
   <td>其他表(2)</td> 
   <td>ACT_EVT_LOG</td> 
   <td>事件日志表</td> 
  </tr> 
  <tr> 
   <td>ACT_PROCDEF_INFO</td> 
   <td>流程定义信息</td> 
  </tr> 
 </tbody> 
</table>

--------------------

**编码实战**

创建一个springboot工程,引入flowable的依赖和mysql的依赖,我们要将数据持久化

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.flowable</groupId>
                <artifactId>flowable-spring-boot-starter</artifactId>
                <version>6.4.0</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.2</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>

*  1、部署流程定义

我们要构建的流程是一个非常简单的请假流程。Flowable引擎需要流程定义为BPMN 2.0格式，这是一个业界广泛接受的XML标准。 在Flowable术语中，我们将其称为一个**流程定义(process definition)**。一个*流程定义*可以启动多个**流程实例(process instance)**。*流程定义*可以看做是重复执行流程的蓝图。 在这个例子中，*流程定义*定义了请假的各个步骤，而一个*流程实例*对应某个雇员提出的一个请假申请。

BPMN 2.0存储为XML，并包含可视化的部分：使用标准方式定义了每个步骤类型（人工任务，自动服务调用，等等）如何呈现，以及如何互相连接。这样BPMN 2.0标准使技术人员与业务人员能用双方都能理解的方式交流业务流程。

我们要使用的流程定义为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTQwMjA1_size_16_color_FFFFFF_t_70 2][]

这个流程应该已经十分自我解释了。但为了明确起见，说明一下几个要点：

*  我们假定启动流程需要提供一些信息，例如雇员名字、请假时长以及说明。当然，这些可以单独建模为流程中的第一步。 但是如果将它们作为流程的“输入信息”，就能保证只有在实际请求时才会建立一个流程实例。否则（将提交作为流程的第一步），用户可能在提交之前改变主意并取消，但流程实例已经创建了。 在某些场景中，就可能影响重要的指标（例如启动了多少申请，但还未完成），取决于业务目标。
 *  左侧的圆圈叫做**启动事件(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" flowable:candidateGroups="managers"/>
        <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" flowable:assignee="${employee}"/>
        <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>

第2至11行看起来挺吓人，但其实在大多数的流程定义中都是一样的。这是一种*样板文件*，需要与BPMN 2.0标准规范完全一致。

每一个步骤（在BPMN 2.0术语中称作***活动(activity)***）都有一个*id*属性，为其提供一个在XML文件中唯一的标识符。所有的*活动*都可以设置一个名字，以提高流程图的可读性。

*活动*之间通过**顺序流(sequence flow)**连接，在流程图中是一个有向箭头。在执行流程实例时，执行(execution)会从*启动事件*沿着*顺序流*流向下一个*活动*。

离开*排他网关(带有X的菱形)*的*顺序流*很特别：都以*表达式(expression)*的形式定义了*条件(condition)* （见第25至32行）。当流程实例的执行到达这个*网关*时，会计算*条件*，并使用第一个计算为*true*的顺序流。这就是*排他*的含义：只选择一个。当然如果需要不同的路由策略，可以使用其他类型的网关。

这里用作条件的*表达式*为*$\{approved\}*，这是*$\{approved == true\}*的简写。变量’approved’被称作**流程变量(process variable)**。*流程变量*是持久化的数据，与流程实例存储在一起，并可以在流程实例的生命周期中使用。在这个例子里，我们需要在特定的地方（当经理用户任务提交时，或者以Flowable的术语来说，*完成(complete)*时）设置这个*流程变量*，因为这不是流程实例启动时就能获取的数据。

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

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

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

@SpringBootTest
    class FlowableApplicationTests {
        @Autowired
        private RepositoryService repositoryService;
    
        /**
         * 流程部署
         */
        @Test
        void contextLoads() {
            Deployment deployment = repositoryService.createDeployment()
                    .addClasspathResource("holiday-request.bpmn20.xml")
                    .deploy();
            System.out.println(deployment.toString());
        }
    
    }

![20210225153455499.png][]

流程定义部署成功后会在三个表生成记录。ACT\_RE\_DEPLOYMENT 流程部署表，ACT\_RE\_PROCDEF 流程定义表（主键策略是key:version:uuid）和ACT\_GE\_BYTEARRAY 资源文件表。其中ACT\_RE\_DEPLOYMENT 流程部署表是主表，它的ID关联另外两张表，是一对一的关系。

SELECT*FROM `act_re_deployment` WHERE ID_='6a950956-773b-11eb-9a64-00ff26a38e74'

![20210225153532287.png][]

SELECT*FROM `act_ge_bytearray` WHERE `DEPLOYMENT_ID_`='6a950956-773b-11eb-9a64-00ff26a38e74'

![20210225153605899.png][]

SELECT*FROM `act_re_procdef` WHERE `DEPLOYMENT_ID_`='6a950956-773b-11eb-9a64-00ff26a38e74'

![20210225153634331.png][]

我们现在可以通过API查询验证流程定义已经部署在引擎中（并学习一些API）。通过*RepositoryService*创建的*ProcessDefinitionQuery*对象实现。查询的是ACT\_RE\_PROCDEF 流程定义表。

@Test
        void processDefinitionQuery() {
            List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().list();
            for (ProcessDefinition processDefinition : list) {
                System.out.println(processDefinition.getId()); // key:version:uuid
                System.out.println(processDefinition.getKey());
                System.out.println(processDefinition.getVersion());
                System.out.println(processDefinition.getName());
                System.out.println(processDefinition.getResourceName());
                System.out.println(processDefinition.getDeploymentId());
                System.out.println("--------------------");
            }
        }

![20210225153705837.png][]

*  2、启动流程实例

现在已经在流程引擎中*部署*了流程定义，因此可以使用这个*流程定义*作为“蓝图”启动*流程实例*。

要启动流程实例，需要提供一些初始化*流程变量*。一般来说，可以通过呈现给用户的表单，或者在流程由其他系统自动触发时通过REST API，来获取这些变量。在这个例子里，我们简化为使用java.util.Scanner类在命令行输入一些数据：

Scanner scanner= new Scanner(System.in);
    
    System.out.println("Who are you?");
    String employee = scanner.nextLine();
    
    System.out.println("How many holidays do you want to request?");
    Integer nrOfHolidays = Integer.valueOf(scanner.nextLine());
    
    System.out.println("Why do you need them?");
    String description = scanner.nextLine();

接下来，我们使用*RuntimeService*启动一个*流程实例*。收集的数据作为一个*java.util.Map*实例传递，其中的键就是之后用于获取变量的标识符。这个流程实例使用*key*启动。这个*key*就是BPMN 2.0 XML文件中设置的*id*属性，在这个例子里是*holidayRequest*。

（请注意：除了使用key之外，在后面你还会看到有很多其他方式启动一个流程实例）

@Test
        void startProcessInstanceByKey() {
            String employee = "Jack";
            Integer nrOfHolidays = 3;
            String description = "ill";
            Map<String, Object> variables = new HashMap<>();
            variables.put("employee", employee);
            variables.put("nrOfHolidays", nrOfHolidays);
            variables.put("description", description);
            // 1.获取页面表单填报的内容. 请假时间,请假理由,申请人等
            // 2.写入业务表,返回业务表的主键ID=businessKey
            // 3.把业务数据与Activiti流程数据关联
            String businessKey = UUID.randomUUID().toString();
            ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("holidayRequest", businessKey, variables);
            System.out.println("流程实例ID:"+processInstance.getProcessInstanceId());
        }

![20210225153805662.png][]

在流程实例启动后，会创建一个**执行(execution)**，并将其放在启动事件上。从这里开始，这个*执行*沿着顺序流移动到经理审批的用户任务，并执行用户任务行为。这个行为将在数据库中创建一个任务，该任务可以之后使用查询找到。用户任务是一个*等待状态(wait state)*，引擎会停止执行，返回API调用处。

流程启动成功后会在ACT\_RU\_EXECUTION 流程实例执行过程的所有节点记录表生成2条记录（后续的任务节点记录也会在这张表生成），会在ACT\_RU\_TASK 流程实例运行时的任务表生成一条任务记录，会在ACT\_RU\_VARIABLE 流程实例运行时节点的变量表生成流程变量。（历史表也会生成一些数据，比如ACT\_HI\_VARINST 流程实例的历史运行节点的变量表也会记录流程变量）

SELECT*FROM `act_ru_execution` WHERE `PROC_INST_ID_`='5e8a0a7c-773c-11eb-a6f1-00ff26a38e74'

![20210225153954789.png][]

SELECT*FROM `act_ru_task` WHERE `PROC_INST_ID_`='5e8a0a7c-773c-11eb-a6f1-00ff26a38e74'

![20210225154027674.png][]

SELECT*FROM `act_ru_variable` WHERE `PROC_INST_ID_`='5e8a0a7c-773c-11eb-a6f1-00ff26a38e74'

![20210225154133525.png][]

*  另一个话题：事务

在Flowable中，数据库事务扮演了关键角色，用于保证数据一致性，并解决并发问题。当调用Flowable API时，默认情况下，所有操作都是同步的，并处于同一个事务下。这意味着，当方法调用返回时，会启动并提交一个事务。

流程启动后，会有**一个数据库事务**从流程实例启动时持续到下一个*等待状态*。在这个例子里，指的是第一个用户任务。当引擎到达这个用户任务时，状态会持久化至数据库，提交事务，并返回API调用处。

在Flowable中，当一个流程实例运行时，总会有一个数据库事务从前一个*等待状态*持续到下一个*等待状态*。数据持久化之后，可能在数据库中保存很长时间，甚至几年，直到某个API调用使流程实例继续执行。请注意当流程处在等待状态时，不会消耗任何计算或内存资源，直到下一次APi调用。

在这个例子中，当第一个用户任务完成时，会启动一个数据库事务，从用户任务开始，经过排他网关（自动逻辑），直到第二个用户任务。或通过另一条路径直接到达结束。

*  查询与完成任务

在更实际的应用中，会为雇员及经理提供用户界面，让他们可以登录并查看任务列表。其中可以看到作为*流程变量*存储的流程实例数据，并决定如何操作任务。在这个例子中，我们通过执行API调用来模拟任务列表，通常这些API都是由UI驱动的服务在后台调用的。

我们还没有为用户任务配置办理人。我们想将第一个任务指派给"经理(managers)"组，而第二个用户任务指派给请假申请的提交人。因此需要为第一个任务添加*candidateGroups*属性：

并如下所示为第二个任务添加*assignee*属性。请注意我们没有像上面的’managers’一样使用静态值，而是使用一个流程变量动态指派。这个流程变量是在流程实例启动时传递的：

要获得实际的任务列表，需要通过*TaskService*创建一个*TaskQuery*。我们配置这个查询只返回’managers’组的任务：

/**
         * 查询任务
         */
        @Test
        void taskQuery() {
            List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup("managers").list();
            System.out.println("You have " + tasks.size() + " tasks:");
            for (Task task : tasks) {
                System.out.println("task:" + task);
                Map<String, Object> processVariables = taskService.getVariables(task.getId());
                System.out.println(processVariables.get("employee") + " wants " +
                        processVariables.get("nrOfHolidays") + " of holidays. Do you approve this?");
            }
        }

![20210225155539284.png][]

经理现在就可以**完成任务**了。在现实中，这通常意味着由用户提交一个表单。表单中的数据作为*流程变量*传递。在这里，我们在完成任务时传递带有’approved’变量（这个名字很重要，因为之后会在顺序流的条件中使用！）的map来模拟：

/**
         * 完成/执行任务
         */
        @Test
        void completeTask() {
            Map<String, Object> variables = new HashMap<>();
            variables.put("approved", true);
            taskService.complete("5e8ec573-773c-11eb-a6f1-00ff26a38e74", variables);
        }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTQwMjA1_size_16_color_FFFFFF_t_70 3][] 注意要手动添加这个包和这个类。XML文件里的排他网关的任务批准后的自动任务：**服务任务(service task)**，这个任务是自动执行的，执行的就是CallExternalSystemDelegate类里面的内容。

现在任务完成，并会在离开排他网关的两条路径中，基于’approved’流程变量选择一条。

在现实中，这个逻辑可以做任何事情：向某个系统发起一个HTTP REST服务调用，或调用某个代码。我们不会在这里实现实际的逻辑，而只是简单的日志记录*流程*。

创建一个新的类(在Eclipse里*File → New → Class*)，填入*org.flowable*作为包名，*CallExternalSystemDelegate*作为类名。让这个类实现*org.flowable.engine.delegate.JavaDelegate*接口，并实现*execute*方法：

package org.flowable;
    
    import org.flowable.engine.delegate.DelegateExecution;
    import org.flowable.engine.delegate.JavaDelegate;
    
    public class CallExternalSystemDelegate implements JavaDelegate {
    
        public void execute(DelegateExecution execution) {
            System.out.println("Calling the external system for employee "
                + execution.getVariable("employee"));
        }
    }

*  使用历史数据

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

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

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

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

/**
         * 查询历史任务
         */
        @Test
        void queryHistory() {
            List<HistoricActivityInstance> activities = historyService.createHistoricActivityInstanceQuery()
                    .processInstanceId("5e8a0a7c-773c-11eb-a6f1-00ff26a38e74")
                    .finished()
                    .orderByHistoricActivityInstanceEndTime().asc()
                    .list();
    
            for (HistoricActivityInstance activity : activities) {
                System.out.println(activity.getActivityId() + " took "
                        + activity.getDurationInMillis() + " milliseconds");
            }
        }

![20210225161935207.png][]

*  小结

这个教程介绍了很多Flowable与BPMN 2.0的概念与术语，也展示了如何编程使用Flowable API。

当然，这只是个开始。下面的章节会更深入介绍许多Flowable引擎支持的选项与特性。其他章节介绍安装与使用Flowable引擎的不同方法，并详细介绍了所有可用的BPMN 2.0结构。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTQwMjA1_size_16_color_FFFFFF_t_70]: /images/20221024/2fae6966e2a74983a4a029cbf6be5ed2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTQwMjA1_size_16_color_FFFFFF_t_70 1]: /images/20221024/994653af981045bebb27634f493f6079.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTQwMjA1_size_16_color_FFFFFF_t_70 2]: /images/20221024/8208ff9694a34f4092126c2d852c886b.png
[20210225153455499.png]: /images/20221024/06b4b7e4638340e59d09ac9c8a8b3704.png
[20210225153532287.png]: /images/20221024/11453be9613a45698dc322c40c6606f5.png
[20210225153605899.png]: /images/20221024/182296dd9fb44bd7959c0b0266168f24.png
[20210225153634331.png]: /images/20221024/048cf2698f1746b2b0aee013560c8403.png
[20210225153705837.png]: /images/20221024/55aac2d734e34ef7bde9b5d26a6ff556.png
[20210225153805662.png]: /images/20221024/1ddd5b9382a740bb82b6aa0e8c2f4f93.png
[20210225153954789.png]: /images/20221024/522ae2672eb4495bac0818cae32844c7.png
[20210225154027674.png]: /images/20221024/859cbc225d2244babd8619b00c18ec21.png
[20210225154133525.png]: /images/20221024/e5d6843661cf4df39cd7c46de8a48621.png
[20210225155539284.png]: /images/20221024/dffc73e3015f4502af86fdb896c792f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5OTQwMjA1_size_16_color_FFFFFF_t_70 3]: /images/20221024/4d1a09714e404b52aec1d64b44cc16b9.png
[20210225161935207.png]: /images/20221024/3afe601f833c4e9297b24eb189d2c4f1.png