关于bpmn:Flowable实战1启动第一个完整流程

发现网上对于 Flowable 的材料根本都是浅尝辄止，对如何构建一个企业级的流程利用阐明很少，所以写个实战系列，心愿对大家和本人，都有所帮忙。

Flowable 是一个应用 Java 编写的轻量级业务流程引擎。

Flowable 流程引擎可用于部署 BPMN 2.0 流程定义，创立这些流程定义的流程实例，进行查问，拜访运行中或历史的流程实例与相干数据。

Flowable 是 Activiti 的 fork，即 Flowable 源自 Activiti。所以能够看到，Flowable 很多设计与实现，与 Activiti 是雷同的。

开源 Flowable 官网：https://www.flowable.com/open…

Flowable 官网教程曾经提供了一个很简略的流程运行例子，是英文版。

上面的例子内容来源于官网教程，曾经看过的同学能够间接跳过到下一节内容。

咱们将构建的例子是一个简略的销假 (holiday request) 流程：

雇员 (employee) 申请几天的假期
经理 (manager) 批准或驳回申请
咱们会模仿将申请注册到某个内部零碎，并给雇员发送后果邮件

关上 IDEA，通过 File -> New -> Project… -> Maven 创立一个新的 Maven 我的项目

在下一个界面，填入我的项目名 Name，GroupId 和 ArtifactId 默认即可

这样就建设了空的 Maven 我的项目。

为我的项目增加 3 个依赖：

Flowable 流程引擎。使咱们能够创立一个 ProcessEngine 流程引擎对象，并拜访 Flowable API。
一个内存数据库。本例中为 H2，因为 Flowable 引擎在运行流程实例时，须要应用数据库来存储执行与历史数据。
日志框架。Flowable 应用 SLF4J 作为外部日志框架。本例中，咱们应用 log4j 作为 SLF4J 的实现。

在 pom.xml 文件中增加下列行：

<dependencies>
  <dependency>
      <groupId>org.flowable</groupId>
      <artifactId>flowable-engine</artifactId>
      <version>6.7.2</version>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <version>1.3.176</version>
    </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>

Log4j 须要一个配置文件。在 src/main/resources 文件夹下增加 log4j.properties 文件，并写入下列内容：

log4j.rootLogger=INFO, 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

留神：对于 Log4j 的近程代码执行破绽问题，影响范畴是 Apache Log4j 2.x <= 2.14.1 版本，所以下面的日志版本是平安的。

有时候，依赖 JAR 无奈主动获取，能够右键点击我的项目，并抉择 Maven ->Reload Project 以强制手动刷新。

创立一个新的 Java 类，并增加规范的 Java main 办法：

public class HolidayRequest {public static void main(String[] args) {}}

首先要做的是初始化 ProcessEngine 流程引擎实例。创立一个 ProcessEngineConfiguration 实例，并配置数据库 JDBC 连贯。而后由 ProcessEngineConfiguration 创立 ProcessEngine 实例。

import org.flowable.engine.ProcessEngine;
import org.flowable.engine.ProcessEngineConfiguration;
import org.flowable.engine.impl.cfg.StandaloneProcessEngineConfiguration;

public class HolidayRequest {public static void main(String[] args) {ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:h2:mem:flowable;DB_CLOSE_DELAY=-1")
                .setJdbcUsername("sa")
                .setJdbcPassword("")
                .setJdbcDriver("org.h2.Driver")
                .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

        ProcessEngine processEngine = cfg.buildProcessEngine();}

}

留神：内存 H2 数据库在 JVM 重启后会隐没。如果须要永恒保留数据，须要切换为长久化数据库，并相应切换连贯参数。

这样就能够运行了。在 IDEA 中最简略的办法是右键点击类文件，抉择Run ‘HolidayRequest.main()’：

胜利运行，应该能够看到对于引擎启动与创立数据库表构造的提醒日志：

这样就失去了一个启动可用的流程引擎。接下来为它提供一个流程！

咱们要构建的流程是一个非常简单的销假流程。在 Flowable 术语中，咱们将其称为一个 流程定义 (process definition)。一个 流程定义 能够启动多个 流程实例 (process instance)。 流程定义 能够看做是反复执行流程的蓝图。在这个例子中，流程定义 定义了销假的各个步骤，而一个 流程实例 对应某个雇员提出的一个销假申请。

咱们要应用的流程定义为：

为了明确起见，阐明一下几个要点：

启动流程须要提供一些信息，例如雇员名字、销假时长以及阐明。。
左侧的圆圈叫做 启动事件(start event)。这是一个流程实例的终点。
第一个矩形是一个 用户工作(user task)。这是流程中人类用户操作的步骤。在这个例子中，经理须要批准或驳回申请。
取决于经理的决定，排他网关 (exclusive gateway) (带叉的菱形) 会将流程实例路由至批准或驳回门路。
如果批准，则须要将申请注册至某个内部零碎，并跟着另一个用户工作，将经理的决定告诉给申请人。
如果驳回，则为雇员发送一封邮件告诉他。

留神：一般来说，这样的 流程定义 应用可视化建模工具建设，如 Flowable Designer(Eclipse)或 Flowable Web Modeler(Web 利用)。IDEA 没有官网提供的可视化插件，可选插件为 Flowable BPMN visualizer。

将上面的 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="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="SendRejectionMail"/>
    <sequenceFlow sourceRef="sendRejectionMail" targetRef="rejectEnd"/>

    <endEvent id="approveEnd"/>

    <endEvent id="rejectEnd"/>

  </process>

</definitions>

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

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

来到 排他网关 (带有 X 的菱形) 的程序流 很特地：都以 表达式 (expression) 的模式定义了 条件 (condition)。当流程实例的执行达到这个网关时，会计算条件，并应用第一个计算为true 的程序流。这就是排他的含意：只抉择一个。

这里用作条件的 表达式 为 ”$ {approved}”，这是 ${approved == true}的简写。变量’approved’被称作 流程变量(process variable)。

当初咱们曾经有了流程 BPMN 2.0 XML 文件，下来须要将它 ’ 部署(deploy)’ 到引擎中。

将流程定义部署至 Flowable 引擎，须要应用 RepositoryService，其能够从ProcessEngine 对象获取。应用 RepositoryService，能够通过 XML 文件的门路创立一个新的部署(Deployment)，并调用 deploy() 办法理论执行：

RepositoryService repositoryService = processEngine.getRepositoryService();
Deployment deployment = repositoryService.createDeployment()
  .addClasspathResource("holiday-request.bpmn20.xml")
  .deploy();

咱们当初能够通过 API 查问验证流程定义曾经部署在引擎中。通过 RepositoryService 创立的 ProcessDefinitionQuery 对象实现。

ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
  .deploymentId(deployment.getId())
  .singleResult();
System.out.println("Found process definition :" + processDefinition.getName());

当初曾经在流程引擎中部署了流程定义，因而能够应用这个 流程定义 作为“蓝图”启动 流程实例。

要启动流程实例，须要提供一些初始化 流程变量。一般来说，能够通过出现给用户的表单，或者在流程由其余零碎主动触发时通过 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。

<process id="holidayRequest" name="Holiday Request" isExecutable="true">

RuntimeService runtimeService = processEngine.getRuntimeService();

Map<String, Object> variables = new HashMap<String, Object>();
variables.put("employee", employee);
variables.put("nrOfHolidays", nrOfHolidays);
variables.put("description", description);
ProcessInstance processInstance =
  runtimeService.startProcessInstanceByKey("holidayRequest", variables);

在流程实例启动后，会创立一个 执行 (execution)，并将其放在启动事件上。从这里开始，这个执行沿着程序流挪动到经理审批的用户工作，并执行用户工作行为。这个行为将在数据库中创立一个工作，该工作能够之后应用查问找到。用户工作是一个 期待状态(wait state)，引擎会进行执行，返回 API 调用处。

咱们还没有为用户工作配置办理人。咱们想将第一个工作指派给 ” 经理 (managers)” 组，而第二个用户工作指派给销假申请的提交人。因而须要为第一个工作增加candidateGroups 属性，批改流程 xml 配置文件：

<userTask id="approveTask" name="Approve or reject request" flowable:candidateGroups="managers"/>

并如下所示为第二个工作增加 assignee 属性。请留神咱们没有像下面的’managers’一样应用动态值，而是应用一个流程变量动静指派。这个流程变量是在流程实例启动时传递的：

<userTask id="holidayApprovedTask" name="Holiday approved" flowable:assignee="${employee}"/>

要取得理论的工作列表，须要通过 TaskService 创立一个TaskQuery。咱们配置这个查问只返回’managers’组的工作：

TaskService taskService = processEngine.getTaskService();
List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup("managers").list();
System.out.println("You have" + tasks.size() + "tasks:");
for (int i=0; i<tasks.size(); i++) {System.out.println((i+1) + ")" + tasks.get(i).getName());
}

能够应用工作 Id 获取特定流程实例的变量，并在屏幕上显示理论的申请：

System.out.println("Which task would you like to complete?");
int taskIndex = Integer.valueOf(scanner.nextLine());
Task task = tasks.get(taskIndex - 1);
Map<String, Object> processVariables = taskService.getVariables(task.getId());
System.out.println(processVariables.get("employee") + "wants" +
    processVariables.get("nrOfHolidays") + "of holidays. Do you approve this?");

运行后果像上面这样：

经理当初就能够 实现工作 了。在事实中，这通常意味着由用户提交一个表单。表单中的数据作为 流程变量 传递。在这里，咱们在实现工作时传递带有’approved’变量（这个名字很重要，因为之后会在程序流的条件中应用！）的 map 来模仿：

boolean approved = scanner.nextLine().toLowerCase().equals("y");
variables = new HashMap<String, Object>();
variables.put("approved", approved);
taskService.complete(task.getId(), variables);

当初工作实现，并会在来到排他网关的两条门路中，基于’approved’流程变量抉择一条。

代码还缺了一块：咱们还没有实现申请通过后执行的主动逻辑。在 BPMN 2.0 XML 中，这是一个 服务工作(service task)：

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

在事实中，这个逻辑能够做任何事件：向某个零碎发动一个 HTTP REST 服务调用，或调用某个应用了好几十年的零碎中的遗留代码。咱们不会在这里实现理论的逻辑，而只是简略的日志记录流程。

创立一个新的 JAVA 类，CallExternalSystemDelegate作为类名。让这个类实现 org.flowable.engine.delegate.JavaDelegate 接口，并实现 execute 办法：

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"));
    }
}

当执行达到 服务工作 时，会初始化并调用 BPMN 2.0 XML 中所援用的类。

当初执行这个例子的时候，就会显示出日志信息，阐明曾经执行了自定义逻辑：

留神：如果呈现“org.flowable.common.engine.api.FlowableException: couldn’t instantiate class CallExternalSystemDelegate”的报错，阐明包门路未指定正确，在 xml 文件中，依据本人 CallExternalSystemDelegate 类的理论门路批改:
<serviceTask id="externalSystemCall" name="Enter holidays in external system"
                    flowable:class="CallExternalSystemDelegate"/>

Flowable 能够主动存储所有流程实例的数据。

例如，如果心愿显示流程实例曾经执行的工夫，就能够从 ProcessEngine 获取 HistoryService，并创立 历史流动 (historical activities) 的查问。在上面的代码片段中，能够看到咱们增加了一些额定的过滤条件：

只抉择一个特定流程实例的流动
只抉择已实现的流动

后果依照完结工夫排序，代表其执行程序。

HistoryService historyService = processEngine.getHistoryService();
List<HistoricActivityInstance> activities =
  historyService.createHistoricActivityInstanceQuery()
   .processInstanceId(processInstance.getId())
   .finished()
   .orderByHistoricActivityInstanceEndTime().asc()
   .list();

for (HistoricActivityInstance activity : activities) {System.out.println(activity.getActivityId() + "took"
    + activity.getDurationInMillis() + "milliseconds");
}

再次运行例子，能够看到控制台中显示：

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

关于bpmn:Flowable实战1启动第一个完整流程

一、前言：

二、意识 Flowable

三、残缺实例

1. 创立我的项目

2. 创立流程引擎

3. 创立流程定义文件

4. 部署流程定义

5. 启动流程实例

6. 查问与实现工作

7. 实现 JavaDelegate

8. 应用历史数据

9. 小结