Flowable实战（一）启动第一个完整流程

Flowable实战（一）启动第一个完整流程

一、前言：

  发现网上关于Flowable的资料基本都是浅尝辄止，对如何构建一个企业级的流程应用说明很少，所以写个实战系列，希望对大家和自己，都有所帮助。

二、认识Flowable

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

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

  Flowable是Activiti的fork，即Flowable源自Activiti。

所以可以看到，Flowable很多设计与实现，与Activiti是相同的。

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

三、完整实例

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

  下面的例子内容来源于官网教程，已经看过的同学可以直接跳过到下一节内容。

  我们将构建的例子是一个简单的请假(holiday request)流程：

• 雇员(employee)申请几天的假期
• 经理(manager)批准或驳回申请
• 我们会模拟将申请注册到某个外部系统，并给雇员发送结果邮件

1.创建项目

  打开IDEA，通过File -> New -> Project... -> Maven 创建一个新的Maven项目

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

  这样就建立了空的Maven项目。

2.创建流程引擎

  为项目添加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()' ：

  成功运行，应该可以看到关于引擎启动与创建数据库表结构的提示日志：

  这样就得到了一个启动可用的流程引擎。

接下来为它提供一个流程！

3.创建流程定义文件

  我们要构建的流程是一个非常简单的请假流程。

在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)'到引擎中。

4.部署流程定义

  将流程定义部署至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());

5.启动流程实例

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

  要启动流程实例，需要提供一些初始化流程变量。

一般来说，可以通过呈现给用户的表单，或者在流程由其他系统自动触发时通过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调用处。

6.查询与完成任务

  我们还没有为用户任务配置办理人。

我们想将第一个任务指派给"经理(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’流程变量选择一条。

7.实现JavaDelegate

  代码还缺了一块：我们还没有实现申请通过后执行的自动逻辑。

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

8.使用历史数据

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

}

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

9.小结

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