构建一个Flowable命令行应用

官网链接

[(https://flowable.com/open-source/docs/bpmn/ch02-GettingStarted/#building-a-command-line-application)]

简介

Flowable是Activity5.0的一个分支，本身是用kava开发的一个业务流程引擎，可以用来部署BPMN2.0标准流程定义。

案例

员工(employee)发出请假的请求
管理者(manager)同意或拒绝请假请求
我们会模拟把请求注册到外部的系统，发送邮件来通知流程的结果

其中，左边的圈圈是一个开始事件（start event），第一个长方形是用户任务（user task），中间的菱形是一个排他网关（exclusive gateway），对应的xml文件holiday-request.bpmn20.xml放在

src/main/resources目录下。

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

java项目中的配置

pom文件

<?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.happen</groupId>

    <artifactId>holidayrequest</artifactId>

    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <dependency>

            <groupId>org.flowable</groupId>

            <artifactId>flowable-engine</artifactId>

            <version>6.6.0</version>

        </dependency>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>8.0.21</version>

        </dependency>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-api</artifactId>

            <version>1.7.30</version>

        </dependency>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-log4j12</artifactId>

            <version>1.7.30</version>

        </dependency>

    </dependencies>

    <properties>

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

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

    </properties>

</project>

flowable使用了log4j作为debug工具，需要在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

主函数在HolidayRequest类下

import org.flowable.engine.*;

import org.flowable.engine.history.HistoricActivityInstance;

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

import org.flowable.engine.repository.Deployment;

import org.flowable.engine.repository.ProcessDefinition;

import org.flowable.engine.runtime.ProcessInstance;

import org.flowable.task.api.Task;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Scanner;

public class HolidayRequest {

    public static void main(String[] args) {

        // 配置一个StandaloneProcessEngine，连接数据库

        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()

                .setJdbcUrl("jdbc:mysql://localhost:3306/holiday_request?useUnicode=true&characterEncoding=utf8&autoReconnect=true&serverTimezone=GMT%2B8")

                .setJdbcUsername("root")

                .setJdbcPassword("WHP199617whp")

                .setJdbcDriver("com.mysql.cj.jdbc.Driver")

                // 数据表不存在的时候，自动生成

                .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

        // 工作引擎

        ProcessEngine processEngine = cfg.buildProcessEngine();

        // 读取一个工作流并部署

        RepositoryService repositoryService = processEngine.getRepositoryService();

        Deployment deployment = repositoryService.createDeployment()

                .addClasspathResource("holiday-request.bpmn20.xml")

                .deploy();

        // 创建一个查询，尝试读取工作流的名字

        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()

                .deploymentId(deployment.getId())

                .singleResult();

        System.out.println("Found process definition : " + processDefinition.getName());

        // 提交一个流程

        RuntimeService runtimeService = processEngine.getRuntimeService();

        Map<String, Object> variables = new HashMap<String, Object>();

        variables.put("employee", "happen");

        variables.put("nrOfHolidays", 12);

        variables.put("description", "go home");

        // 使用key开启一个流程

        ProcessInstance processInstance =

                runtimeService.startProcessInstanceByKey("holidayRequest", variables);

        // manager查询过程

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

        }

        Scanner scanner= new Scanner(System.in);

        // manager处理请求

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

        boolean approved = scanner.nextLine().toLowerCase().equals("y");

        variables = new HashMap<String, Object>();

        variables.put("approved", approved);

        taskService.complete(task.getId(), variables);

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

        }

    }

}

其中，manager如果批准，在xml流程中的表述如下：

<serviceTask id="externalSystemCall" name="Enter holidays in external system"

             flowable:class="org.flowable.CallExternalSystemDelegate"/>

<sequenceFlow sourceRef="externalSystemCall" targetRef="holidayApprovedTask"/>

其中的org.flowable.CallExternalSystemDelegate类需要我们自己编写，这是需要执行的步骤，我们简单的打印下：

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工作流首先需要一个标准的BPMN2.0文件，文件中需要指明每个process、startEvent、userTask、exclusiveGateway等的id，并通过sequenceFlow指明流向，需要保存的变量可以为${approved}的形式，如果需要具体执行什么任务，通过serviceTask标签的flowable:class类指明调用的类实现功能，比如发邮件、http请求等。在命令行应用中使用时，首先需要一个StandaloneProcessEngineConfiguration实例配置连接的数据库，然后生成对应的引擎ProcessEngine，之后使用对应的service执行具体的任务。