Flowable

最新推荐文章于 2024-10-12 11:19:31 发布

DirLin

最新推荐文章于 2024-10-12 11:19:31 发布

阅读量2.4k

点赞数 6

分类专栏： flowable 文章标签： java junit

本文链接：https://blog.csdn.net/m0_52255127/article/details/129237838

版权

flowable 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Flowable 工作流

一、Flowable

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

在这里插入图片描述

二、Flowable基础

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

1. 创建maven项目，并引入依赖

    <dependencies>
<!--        Flowable流程引擎。使我们可以创建一个ProcessEngine流程引擎对象，并访问Flowable API-->
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-engine</artifactId>
            <version>6.3.0</version>
        </dependency>
<!--        一个是MySQL的数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
<!--        引入测试包，进行简单例子编写-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

2. 例子

package com.jyyy.FlowableTest;

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

public class Demo01 {

    @Test
    public void demoProcessEngine(){

        // 1. 获取processEngine配置对象
        ProcessEngineConfiguration configuration = new StandaloneProcessEngineConfiguration();

        // 2. 配置processEngine
        configuration.setJdbcDriver("com.mysql.cj.jdbc.Driver");
        configuration.setJdbcUsername("root");
        configuration.setJdbcPassword("root");
        // nullCatalogMeansCurrent=true务必加上不然可能会报错
        // Caused by: java.sql.SQLSyntaxErrorException: Table 'flowable-learn.act_id_user' doesn't exist
        configuration.setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn?serverTimezone=UTC&nullCatalogMeansCurrent=true");
        // 如果数据库中的表结构不在则新建
        configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

        // 3. 构建processEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();

    }

}

3. 日志和表结构

日志：slf4j

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

slf4j配置文件
在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

30张数据表

引用博客Flowable 数据库表结构说明、Flowable 数据字典说明

4. 部署流程定义

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

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

流程定义

在这里插入图片描述 流程定义说明

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

在src/main/resources创建holiday-request.bpmn20.xml

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="请假流程" isExecutable="true">

        <!-- 开始事件-->
        <startEvent id="startEvent"/>
        <!-- 顺序流程 sourceRef：源头，approveTask：指向-->
        <sequenceFlow sourceRef="startEvent" targetRef="approveTask"/>

        <!-- 用户任务-->
        <userTask id="approveTask" name="同意或者拒绝请假"/>
        <!--顺序流程-->
        <sequenceFlow sourceRef="approveTask" targetRef="decision"/>

        <!--排它网关-->
        <exclusiveGateway id="decision"/>
        <!--网关流程一-->
        <sequenceFlow sourceRef="decision" targetRef="externalSystemCall">
            <!--conditionExpression:条件表达式-->
            <!--${approved}:判断approved是否为true则成立-->
            <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"/>

        <!--flowable:class="org.flowable.SendRejectionMail：处理发送邮件的操作-->
        <serviceTask id="sendRejectionMail" name="发送拒绝邮件"
                     flowable:class="org.flowable.SendRejectionMail"/>
        <sequenceFlow sourceRef="sendRejectionMail" targetRef="rejectEnd"/>

        <!--endEvent：流程解锁-->
        <endEvent id="approveEnd"/>

        <endEvent id="rejectEnd"/>
    </process>

</definitions>

部署

在这里插入图片描述

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


    ProcessEngineConfiguration configuration;

    @Before
    public void before(){
        // 1. 获取processEngine配置对象
        configuration = new StandaloneProcessEngineConfiguration();

        // 2. 配置processEngine
        configuration.setJdbcDriver("com.mysql.cj.jdbc.Driver");
        configuration.setJdbcUsername("root");
        configuration.setJdbcPassword("root");
        // nullCatalogMeansCurrent=true务必加上不然可能会报错
        // Caused by: java.sql.SQLSyntaxErrorException: Table 'flowable-learn.act_id_user' doesn't exist
        configuration.setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn?serverTimezone=UTC&nullCatalogMeansCurrent=true");
        // 如果数据库中的表结构不在则新建
        configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

        // 3. 构建processEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();
    }

    /**
     * 部署流程
     */
    @Test
    public void testDeploy(){

        // 1. 获取 ProcessEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();

        // 2. 获取RepositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();

        // 3. 完成流程的部署操作
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("holiday-request.bpmn20.xml") // 管理要部署的流程文件
                .name("请假流程")	//这里定义的是department表的数据
                .deploy();

        System.out.println("deploy.getId()："+deploy.getId());
        System.out.println("deploy.getName()："+deploy.getName());

    }

注意
act_re_deployment: 流程定义部署表，每部署一次就增加一条记录
在这里插入图片描述 act_re_procdef ：流程定义表，部署每个新的流程定义都会在这张表中增加一条记录
act_ge_bytearray ：流程资源表，流程部署的 bpmn文件和png图片会保存在该表中

在这里插入图片描述

5. 查询和删除流程定义信息


ProcessEngineConfiguration configuration;

    @Before
    public void before(){
        // 1. 获取processEngine配置对象
        configuration = new StandaloneProcessEngineConfiguration();

        // 2. 配置processEngine
        configuration.setJdbcDriver("com.mysql.cj.jdbc.Driver");
        configuration.setJdbcUsername("root");
        configuration.setJdbcPassword("root");
        // nullCatalogMeansCurrent=true务必加上不然可能会报错
        // Caused by: java.sql.SQLSyntaxErrorException: Table 'flowable-learn.act_id_user' doesn't exist
        configuration.setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn?serverTimezone=UTC&nullCatalogMeansCurrent=true");
        // 如果数据库中的表结构不在则新建
        configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

        // 3. 构建processEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();
    }

    @Test
    public void testDeployQuery(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .deploymentId("1")
                .singleResult();

        System.out.println("processDefinition.getDeploymentId() = " + processDefinition.getDeploymentId());
        System.out.println("processDefinition.getName() = " + processDefinition.getName());
        System.out.println("processDefinition.getDescription() = " + processDefinition.getDescription());
        System.out.println("processDefinition.getId() = " + processDefinition.getId());


    }

    @Test
    public  void testDeployDelete(){
        ProcessEngine processEngine = configuration.buildProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        // 第一个参数是id，第二个参数是流程下的任务和流程是否一并删除
        repositoryService.deleteDeployment("1",true);
    }

6. 启动流程实例

ProcessEngineConfiguration configuration;

    @Before
    public void before(){
        // 1. 获取processEngine配置对象
        configuration = new StandaloneProcessEngineConfiguration();

        // 2. 配置processEngine
        configuration.setJdbcDriver("com.mysql.cj.jdbc.Driver");
        configuration.setJdbcUsername("root");
        configuration.setJdbcPassword("root");
        // nullCatalogMeansCurrent=true务必加上不然可能会报错
        // Caused by: java.sql.SQLSyntaxErrorException: Table 'flowable-learn.act_id_user' doesn't exist
        configuration.setJdbcUrl("jdbc:mysql://localhost:3306/flowable-learn?serverTimezone=UTC&nullCatalogMeansCurrent=true");
        // 如果数据库中的表结构不在则新建
        configuration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

        // 3. 构建processEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();
    }

	 /**
     * 启动流程实例
     */
    @Test
    public void testProcessRun(){

        // 获取流程引擎对象
        ProcessEngine processEngine = configuration.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());
    }

启动流程实例涉及到的表结构：

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

7. 查看任务

上面员工发起了一个请假流程，接下来就会流转到总经理这儿来处理，之前我们没有指定经理这的处理人，我们可以加一个

在这里插入图片描述

/**
     * 查看任务
     */
    @Test
    public void testQueryTask(){

        // 获取流程引擎对象
        ProcessEngine processEngine = configuration.buildProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey("holidayRequest")
                .taskAssignee("list")
                .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());
        }

8.完成任务

在此处我们直接解决掉这个请假，然后会走发送拒绝邮件的流程，这块我们需要用到JavaDelegate来触发。

在这里插入图片描述

定义Java类SendRejectionMail

package com.jyyy.flowableDemo.flowable;

import org.flowable.engine.delegate.DelegateExecution;
import org.flowable.engine.delegate.JavaDelegate;

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

完成任务

    /**
     * 完成任务
     */
    @Test
    public void testCompleteTask(){
        // 获取流程引擎对象
        ProcessEngine processEngine = configuration.buildProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holidayRequest")
                .taskAssignee("list")
                .singleResult();
        // 添加流程变量
        Map<String,Object> variables = new HashMap<>();
        variables.put("approved",false); // 拒绝请假
        // 完成任务
        taskService.complete(task.getId(),variables);
    }

9. 查看历史信息

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

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

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

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

    @Test
    public void testHistory(){

        ProcessEngine processEngine = configuration.buildProcessEngine();
        HistoryService historyService = processEngine.getHistoryService();
        List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery()
                .processDefinitionId("holidayRequest:1:17503")
                .finished() // 查询已经完成的历史记录
                .orderByHistoricActivityInstanceEndTime().asc() // 定义排序字段级方式
                .list();

        for (HistoricActivityInstance historicActivityInstance : list) {
            System.out.println(historicActivityInstance.getActivityName()+":"+historicActivityInstance.getAssignee()+":"
                    +historicActivityInstance.getActivityId()+":"+historicActivityInstance.getDurationInMillis()+"毫秒");
        }
    }

在这里插入图片描述

三、Flowable流程设计器

mysql每个流程的_Name则是在这定义的（流程文件里）

1. Eclipse Designer

2. Flowable UI应用

在这里插入图片描述

四、Flowable基础表结构

部署看RE，GE运行看RU，结束后看HI

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

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

在这里插入图片描述

五、重要接口或类讲解

1. ProcessEngine讲解

1.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()方法，里面的核心代码为：

在这里插入图片描述

1.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/flow?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="root" />
        <property name="databaseSchemaUpdate" value="true" />
        <property name="asyncExecutorActivate" value="false" />
    </bean>
</beans>

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

package com.jyyy.FlowableTest;

import org.flowable.engine.ProcessEngine;
import org.flowable.engine.ProcessEngines;
import org.junit.Test;

public class Demo02 {

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

也可使用自定义名称的配置文件

   @Test
    public void processEngine(){
        ProcessEngineConfiguration configuration =
                ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("flowable.cfg.xml");

        ProcessEngine processEngine = configuration.buildProcessEngine();

        System.out.println("processEngine = " + processEngine);

    }

2. Service服务接口

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

在这里插入图片描述

2.1 Service创建方式

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

3.2 Service总览

在这里插入图片描述 RepositoryService

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

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

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

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

RuntimeService

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

TaskService

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

HistoryService

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

ManagementService

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

六、图标介绍

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

1.1 事件图标

在Flowable中的事件图标启动事件，边界事件,中间事件和结束事件.

在这里插入图片描述

1.2 活动(任务)图标

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

在这里插入图片描述

1.3 结构图标

结构图标可以看做是整个流程活动的结构，一个流程中可以包括子流程。常见的结构有：

在这里插入图片描述

1.4 网关图标

网关用来处理决策，有几种常用网关需要了解

在这里插入图片描述

七、按流程分析表

1.1 流程部署详解

1.1.1 代码

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

/**
     * 部署流程
     */
    @Test
    public void testDeploy(){

        // 1. 获取 ProcessEngine对象
        ProcessEngine processEngine = configuration.buildProcessEngine();

        // 2. 获取RepositoryService
        RepositoryService repositoryService = processEngine.getRepositoryService();

        // 3. 完成流程的部署操作
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("holiday-request.bpmn20.xml") // 管理要部署的流程文件
                .name("请假流程")
                .deploy();

        System.out.println("deploy.getId()："+deploy.getId());
        System.out.println("deploy.getName()："+deploy.getName());

    }

1.1.2 部署涉及表结构

部署ID表：act_re_deployment：一次部署操作就会生成一张表结构
在这里插入图片描述

部署资源表：act_ge_bytearray：有多少资源旧会生成几条记录

这里xml文件有绘制图坐标的情况下才会生成PNG

在这里插入图片描述

流程表：act_re_procdef

在这里插入图片描述这里得NAME_是xml里得name

在这里插入图片描述

注意

业务流程定义数据表。此表和ACT_RE_DEPLOYMENT是多对一的关系，即，一个部署的bar包里可能包含多个流程定义文件，每个流程定义文件都会有一条记录在ACT_RE_PROCDEF表内，每个流程定义的数据，都会对于ACT_GE_BYTEARRAY表内的一个资源文件和PNG图片文件。和ACT_GE_BYTEARRAY的关联是通过程序用ACT_GE_BYTEARRAY.NAME与ACT_RE_PROCDEF.NAME_完成的

1.1.3 挂起和激活

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

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

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

1.2. 启动流程实例详解

1.2.1 代码

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

/**
    /**
     * 启动流程实例
     */
    @Test
    public void testProcessRun(){

        // 获取流程引擎对象
        ProcessEngine processEngine = configuration.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());
    }

1.2.2 启动流程实例后涉及的表

当我们启动了一个流程实例后，会在ACT_RU_*对应的表结构中操作,运行时实例涉及的表结构共10张：

ACT_RU_DEADLETTER_JOB 正在运行的任务表
ACT_RU_EVENT_SUBSCR 运行时事件
ACT_RU_EXECUTION 运行时流程执行实例
ACT_RU_HISTORY_JOB 历史作业表
ACT_RU_IDENTITYLINK 运行时用户关系信息
ACT_RU_JOB 运行时作业表
ACT_RU_SUSPENDED_JOB 暂停作业表
ACT_RU_TASK 运行时任务表
ACT_RU_TIMER_JOB 定时作业表
ACT_RU_VARIABLE 运行时变量表

&emsp;启动一个流程实例的时候涉及到的表有

* ACT_RU_EXECUTION 运行时流程执行实例 
* ACT_RU_IDENTITYLINK 运行时用户关系信息 
* ACT_RU_TASK  运行时任务表 
* ACT_RU_VARIABLE  运行时变量表

ACT_RU_EXECUTION表结构
在这里插入图片描述

在这里插入图片描述
ACT_RU_TASK 运行时任务表

在这里插入图片描述

ACT_RU_VARIABLE 运行时变量表

在这里插入图片描述

ACT_RU_IDENTITYLINK 运行时用户关系信息

在这里插入图片描述

1.3、处理流程详解

1.3.1 代码

上面的流程已经流转到了list这个用户这里，然后可以开始审批了,审批完成后，就删除zhangsan的task生成一条总经理的task

// 获取流程引擎对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionId("holidayRequest")
                .taskAssignee("list")
                .singleResult();
        // 添加流程变量
        Map<String,Object> variables = new HashMap<>();
        variables.put("approved",false); // 拒绝请假
        // 完成任务
        taskService.complete(task.getId(),variables);

1.3.2 正常处理流程中涉及到的表结构

ACT_RU_EXECUTION 运行时流程执行实例
ACT_RU_IDENTITYLINK 运行时用户关系信息
ACT_RU_TASK 运行时任务表
ACT_RU_VARIABLE 运行时变量表

ACT_RU_EXECUTION 运行时流程执行实例
起点到任务一，起点到任务二，启动到结束
当任务一完成，删除起点到任务一，新增起点到任务二

ACT_RU_TASK 运行时任务表 :会新生成一条记录

在这里插入图片描述

ACT_RU_VARIABLE 运行时变量表:会记录新的流程变量

在这里插入图片描述 IDENTITYLINK中会记录每次流程操作的信息

在这里插入图片描述
流程变量数据，及时key 相同，但是属于不同的流程实例相互间也是隔离的

在这里插入图片描述

1.4 完成流程详解

1.4.1 代码

ProcessEngine processEngine = cfg.buildProcessEngine();
TaskService taskService = processEngine.getTaskService();
Task task = taskService.createTaskQuery()
    .processDefinitionId("holidayRequest")
    .taskAssignee("lisi")
    .singleResult();
// 添加流程变量
Map<String,Object> variables = new HashMap<>();
variables.put("approved",false); // 拒绝请假
// 完成任务
taskService.complete(task.getId(),variables);

1.4.2 相关表信息

清空

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

ACT_HI_ACTINST 历史的活动实例

记录所有经过的节点
在这里插入图片描述
ACT_HI_IDENTITYLINK 历史的流程运行过程中用户关系历史的流程实例

ACT_HI_PROCINST 历史的流程实例

完成一条流程只有一条数据
在这里插入图片描述
ACT_HI_TASKINST 历史的任务实例

用户任务

在这里插入图片描述
ACT_HI_VARINST
历史变量

八、任务分配与流程变量

1.1 固定分配

固定分配就是我们前面介绍的，在绘制流程图或者直接在流程文件中通过Assignee来指定的方式

在这里插入图片描述

1.2 表达式分配

Flowable使用UEL进行表达式解析。UEL代表Unified Expression Language，是EE6规范的一部分.Flowable支持两种UEL表达式： UEL-value 和UEL-method

1.2.1 值表达式

值表达式 Value expression: 解析为一个值。默认情况下，所有流程变量都可以使用。（若使用Spring）所有的Spring bean也可以用在表达式里。例如

${myVar}
${myBean.myProperty}

案例讲解：

流程图中指定

在这里插入图片描述

部署流程后，在启动流程实例时候绑定表达式对应的值

/**
     * 启动流程实例
     */
    @Test
    public void testRunProcess(){

        // 获取流程引擎对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 启动流程实例通过 RuntimeService 对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 设置 assignee 的取值
        Map<String,Object> variables = new HashMap<>();
        variables.put("assignee0","张三") ;
        variables.put("assignee1","李四"); 
        // 启动流程实例，第一个参数是流程定义的id
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceById("MyHolidayUI:1:4", variables);// 启动流程实例
        // 输出相关的流程实例信息
        System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());
        System.out.println("流程实例的ID：" + processInstance.getId());
        System.out.println("当前活动的ID：" + processInstance.getActivityId());
    }

在流程变量表中我们可以看到对应的流程变量信息

在这里插入图片描述
同时在Task表中，可以看到流程当前的分配人是张三，说明UEL表达式被解析了

在这里插入图片描述

1.2.2 方法表达式

方法表达式 Method expression: 调用一个方法，可以带或不带参数。**当调用不带参数的方法时，要确保在方法名后添加空括号（以避免与值表达式混淆）。**传递的参数可以是字面值(literal value)，也可以是表达式，它们会被自动解析。例如：

${printer.print()}
${myBean.addNewOrder('orderName')}
${myBean.doSomething(myVar, execution)}

myBean是Spring容器中的个Bean对象，表示调用的是bean的addNewOrder方法

1.3 监听器分配

可以使用监听器来完成很多Flowable的流程业务。
我们在此处使用监听器来完成负责人的指定，那么我们在流程设计的时候就不需要指定assignee
或者发送信息

1.3.1 创建自定义监听器

/**
 * 自定义的监听器
 */
public class MyTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        System.out.println("监听器触发了：" + delegateTask.getName());
        if("提交请假流程".equals(delegateTask.getName()) &&
                "create".equals(delegateTask.getEventName())){
            // 指定任务的负责人
            delegateTask.setAssignee("小明");
        }else {
            delegateTask.setAssignee("小张");
        }
    }
}

然后在FlowableUI中关联对应的监听器

create:任务创建后触发
assignment:任务分配后触发
Delete:任务完成后触发
All：所有事件都触发

在这里插入图片描述
启动流程就可以看到我们监听器分配的处理人

2.1 流程变量

流程实例按步骤执行时，需要使用一些数据。在Flowable中，这些数据称作变量(variable)，并会存储在数据库中。变量可以用在表达式中（例如在排他网关中用于选择正确的出口路径），也可以在Java服务任务(service task)中用于调用外部服务（例如为服务调用提供输入或结果存储），等等。

所有的startProcessInstanceXXX方法都有一个可选参数，用于在流程实例创建及启动时设置变量。例如，在RuntimeService中：

ProcessInstance startProcessInstanceByKey(String processDefinitionKey, Map<String, Object> variables);

emsp; 也可以在流程执行中加入变量。例如，(RuntimeService):

void setVariable(String executionId, String variableName, Object value);
void setVariableLocal(String executionId, String variableName, Object value);
void setVariables(String executionId, Map<String, ? extends Object> variables);
void setVariablesLocal(String executionId, Map<String, ? extends Object> variables);

在这里插入图片描述

2.1.1 全局变量

流程变量的默认作用域是流程实例。当一个流程变量的作用域为流程实例时，可以称为 global 变量

注意：如： Global变量：userId（变量名）、zhangsan（变量值）

global 变量中变量名不允许重复，设置相同名称的变量，后设置的值会覆盖前设置的变量值。

2.1.2 局部变量

任务和执行实例仅仅是针对一个任务和一个执行实例范围，范围没有流程实例大，称为 local 变量。

Local 变量由于在不同的任务或不同的执行实例中，作用域互不影响，变量名可以相同没有影响。Local 变量名也可以和 global 变量名相同，没有影响。

2.1.3 案例讲解

需求：员工创建出差申请单，由部门经理审核，部门经理申请通过后3天以下由财务直接申批，3天以上先由总经理审批，总经理审批通过后再由财务审批。

在这里插入图片描述
连接先设置条件

在这里插入图片描述

部署流程

@Test
public void deploy(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    RepositoryService repositoryService = processEngine.getRepositoryService();
    Deployment deploy = repositoryService.createDeployment()
        .addClasspathResource("出差申请单.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());
}

启动流程实例：并且指定全局流程变量

/**
     * 在启动流程实例的时候设置流程变量
     */
    @Test
    public void runProcess(){
        // 获取流程引擎对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 启动流程实例通过 RuntimeService 对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 设置流程变量
        Map<String,Object> variables = new HashMap<>();
        // 设置assignee的取值
        variables.put("assignee0","张三");
        variables.put("assignee1","李四");
        variables.put("assignee2","王五");
        variables.put("assignee3","赵财务");
        // 启动流程实例，第一个参数是流程定义的id
        ProcessInstance processInstance = runtimeService
                .startProcessInstanceById("evection:1:4",variables);// 启动流程实例
        // 输出相关的流程实例信息
        System.out.println("流程定义的ID：" + processInstance.getProcessDefinitionId());
        System.out.println("流程实例的ID：" + processInstance.getId());
        System.out.println("当前活动的ID：" + processInstance.getActivityId());

    }

完成Task任务，同时也可以指定流程变量

/**
     * 完成任务时指定流程变量
     */
    @Test
    public void completeTask(){

        // 获取流程引擎对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionId("evection:1:4")
                .taskAssignee("李四")
                .singleResult();
        // 添加流程变量
        Map<String, Object> map = task.getProcessVariables();
        map.put("num",4);

        // 完成任务
        taskService.complete(task.getId(),map);
    }

当然我们也可以在处理流程之外通过Task编号来修改流程变量

/**
     * 通过当前任务设置
     */
    @Test
    public void currentTask(){
        //   当前待办任务id
        //  获取processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionId("evection:1:4")
                .taskAssignee("王五")
                .singleResult();
        // 添加流程变量
        Map<String, Object> map = task.getProcessVariables();
        map.put("num",1);
        //  一次设置多个值 设置局部变量
        taskService.setVariables(task.getId(), map);
    }

九、候选人和候选人组

1.1 候选人

1.1 .1 定义流程图

定义流程图，同时指定候选人，多个候选人会通过,连接
在这里插入图片描述

在这里插入图片描述

1.1.2 部署和启动流程实例

部署流程，并且在启动流程实例的时候对UEL表达式赋值

    /**
     * 部署流程
     */
    @Test
    public void deploy(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("请假流程-候选人.bpmn20.xml")
                .name("请求流程-候选人")
                .deploy();
        System.out.println("deploy.getId() = " + deploy.getId());
        System.out.println(deploy.getName());
    }

    /**
     * 启动流程实例
     */
    @Test
    public void runProcess(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 给流程定义中的UEL表达式赋值
        Map<String,Object> variables = new HashMap<>();
        variables.put("candidate1","张三");
        variables.put("candidate2","李四");
        variables.put("candidate3","王五");
        runtimeService.startProcessInstanceById("holiday-candidate:1:4",variables);
    }

在对应的表结构中我们可以看到流程变量已经有了，但是对于的Task的Assignee还是为空。

在这里插入图片描述

1.1.3 任务的查询

   /**
     * 根据登录的用户查询对应的可以拾取的任务
     *
     */
    @Test
    public void queryTaskCandidate(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        List<Task> list = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-candidate:1:4")
                .taskCandidateUser("李四") # 注意
                .list();
        for (Task task : list) {
            System.out.println("task.getId() = " + task.getId());
            System.out.println("task.getName() = " + task.getName());
        }
    }

1.1.4 任务的拾取

知道了我有可拾取的任务后，拾取任务。

/**
     * 拾取任务
     *    一个候选人拾取了这个任务之后其他的用户就没有办法拾取这个任务了
     *    所以如果一个用户拾取了任务之后又不想处理了，那么可以退还
     */
    @Test
    public void claimTaskCandidate(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-candidate:1:4")
                .taskCandidateUser("李四")
                .singleResult();
        if(task != null){
            // 拾取对应的任务
            taskService.claim(task.getId(),"李四");
            System.out.println("任务拾取成功");
        }
    }

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oDMU2q9K-1677561990524)(img\image-20220325103624344.png)]$

1.1.5 任务的归还

拾取任务后不想操作那么就归还任务

    /**
     * 退还任务
     *    一个候选人拾取了这个任务之后其他的用户就没有办法拾取这个任务了
     *    所以如果一个用户拾取了任务之后又不想处理了，那么可以退还
     */
    @Test
    public void unclaimTaskCandidate(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-candidate:1:4")
                .taskAssignee("张三")
                .singleResult();
        if(task != null){
            // 拾取对应的任务
            taskService.unclaim(task.getId());
            System.out.println("归还拾取成功");
        }
    }

1.1.6 任务的交接

拾取任务后如果不想操作也不想归还可以直接交接给另外一个人来处理

   /**
     * 任务的交接
     *    如果我获取了任务，但是不想执行，那么我可以把这个任务交接给其他的用户
     */
    @Test
    public void taskCandidate(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-candidate:1:4")
                .taskAssignee("李四")
                .singleResult();
        if(task != null){
            // 任务的交接
            taskService.setAssignee(task.getId(),"王五");
            System.out.println("任务交接给了王五");
        }
    }

1.1.7 任务的完成

正常的任务处理

   /**
     * 完成任务
     */
    @Test
    public void completeTask(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-candidate:1:4")
                .taskAssignee("王五")
                .singleResult();
        if(task != null){
            // 完成任务
            taskService.complete(task.getId());
            System.out.println("完成Task");
        }
    }

1.2 候选人组

当候选人很多的情况下，我们可以分组来处理。先创建组，然后把用户分配到这个组中。

1.2.1 管理用户和组

当用户更新时，更新一下这个表
我们需要先单独维护用户信息。后台对应的表结构是ACT_ID_USER.

   /**
     * 维护用户
     */
    @Test
    public void createUser(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 通过 IdentityService 完成相关的用户和组的管理
        IdentityService identityService = processEngine.getIdentityService();
        User user = identityService.newUser("田佳");
        user.setFirstName("田");
        user.setLastName("jia");
        user.setEmail("tianjia@qq.com");
        identityService.saveUser(user);
    }

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vFFAWKm1-1677565397623)(img\image-20220325110324815.png)]$

1.2.2 Group管理

维护对应的Group信息，后台对应的表结构是ACT_ID_GROUP

    /**
     * 创建用户组
     */
    @Test
    public void createGroup(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        IdentityService identityService = processEngine.getIdentityService();
        // 创建Group对象并指定相关的信息
        Group group = identityService.newGroup("group2");
        group.setName("开发部");
        group.setType("type1");
        // 创建Group对应的表结构数据
        identityService.saveGroup(group);

    }

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9WR6h4gR-1677565397623)(img\image-20220325110408435.png)]$

1.2.3 用户分配组

用户和组是一个多对多的关联关联，我们需要做相关的分配，后台对应的表结构是ACT_ID_MEMBERSHIP

    /**
     * 将用户分配给对应的Group
     */
    @Test
    public void userGroup(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        IdentityService identityService = processEngine.getIdentityService();
        // 根据组的编号找到对应的Group对象
        Group group = identityService.createGroupQuery().groupId("group1").singleResult();
        List<User> list = identityService.createUserQuery().list();
        for (User user : list) {
            // 将用户分配给对应的组
            identityService.createMembership(user.getId(),group.getId());
        }
    }

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-saBupQxp-1677565397624)(img\image-20220325110511848.png)]$

1.2.4 创建流程图

在这里插入图片描述

1.2.5 流程的部署运行

/**
     * 部署流程
     */
    @Test
    public void deploy(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("请假流程-候选人组.bpmn20.xml")
                .name("请求流程-候选人")
                .deploy();
        System.out.println("deploy.getId() = " + deploy.getId());
        System.out.println(deploy.getName());
    }

    /**
     * 启动流程实例
     */
    @Test
    public void runProcess(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        IdentityService identityService = processEngine.getIdentityService();
        Group group = identityService.createGroupQuery().groupId("group1").singleResult();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 给流程定义中的UEL表达式赋值
        Map<String,Object> variables = new HashMap<>();
        // variables.put("g1","group1");
        variables.put("g1",group.getId()); // 给流程定义中的UEL表达式赋值
        runtimeService.startProcessInstanceById("holiday-group:1:17504",variables);
    }

在这里插入图片描述

1.2.4 任务的拾取和完成

/**
     * 根据登录的用户查询对应的可以拾取的任务
     *
     */
    @Test
    public void queryTaskCandidateGroup(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 根据当前登录的用户找到对应的组
        IdentityService identityService = processEngine.getIdentityService();
        // 当前用户所在的组
        Group group = identityService.createGroupQuery().groupMember("邓彪").singleResult();

        TaskService taskService = processEngine.getTaskService();
        List<Task> list = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-group:1:17504")
                .taskCandidateGroup(group.getId())
                .list();
        for (Task task : list) {
            System.out.println("task.getId() = " + task.getId());
            System.out.println("task.getName() = " + task.getName());
        }
    }

    /**
     * 拾取任务
     *    一个候选人拾取了这个任务之后其他的用户就没有办法拾取这个任务了
     *    所以如果一个用户拾取了任务之后又不想处理了，那么可以退还
     */
    @Test
    public void claimTaskCandidate(){
        String userId = "田佳";
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 根据当前登录的用户找到对应的组
        IdentityService identityService = processEngine.getIdentityService();
        // 当前用户所在的组
        Group group = identityService.createGroupQuery().groupMember(userId).singleResult();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-group:1:17504")
                .taskCandidateGroup(group.getId())
                .singleResult();
        if(task != null) {
            // 任务拾取
            taskService.claim(task.getId(),userId);
            System.out.println("任务拾取成功");
        }
    }  
   /**
     * 完成任务
     */
    @Test
    public void completeTask(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-group:1:17504")
                .taskAssignee("邓彪")
                .singleResult();
        if(task != null){
            // 完成任务
            taskService.complete(task.getId());
            System.out.println("完成Task");
        }
    }

十、网关

网关控制流程的流向

1.1 排他网关

选择一个为true的入口去进入，没有设置条件默认为true

排他网关用内部带有’X’图标的标准网关（菱形）表示，'X’图标代表异或的含义。请注意内部没有图标的网关默认为排他网关。BPMN 2.0规范不允许在同一个流程中混合使用有及没有X的菱形标志。

在这里插入图片描述

案例：

在这里插入图片描述

  /**
     * 部署流程
     */
    @Test
    public void deploy(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("请假流程-排他网关.bpmn20.xml")
                .name("请求流程-排他网关")
                .deploy();
        System.out.println("deploy.getId() = " + deploy.getId());
        System.out.println(deploy.getName());
    }


    /**
     * 启动流程实例
     */
    @Test
    public void setVariables(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 给流程定义中的UEL表达式赋值
        Map<String,Object> variables = new HashMap<>();
        // variables.put("g1","group1");
        variables.put("num",4); // 给流程定义中的UEL表达式赋值
        runtimeService.setVariables("12503",variables);
    }



    /**
     * 完成任务，因为num等于4则走总经理审批
     */
    @Test
    public void completeTask(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                //.processInstanceId("2501")
                .processDefinitionId("holiday-exclusive:1:4")
                .taskAssignee("zhangsan")
                .singleResult();
        if(task != null){
            // 完成任务
            taskService.complete(task.getId());
            System.out.println("完成Task");
        }
    }

如果从网关出去的线所有条件都不满足的情况下会抛出系统异常，

在这里插入图片描述
但是要注意任务没有结束，还是原来的任务，我们可以重置流程变量

    @Test
    public void setVariables(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 给流程定义中的UEL表达式赋值
        Map<String,Object> variables = new HashMap<>();
        // variables.put("g1","group1");
        variables.put("num",4); // 给流程定义中的UEL表达式赋值
        runtimeService.setVariables("12503",variables);
    }

1.2.并行网关

并行网关允许将流程分成多条分支，也可以把多条分支汇聚到一起，并行网关的功能是基于进入和外出顺序流的：

fork分支：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。
join汇聚：所有到达并行网关，在此等待的进入分支，直到所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。

注意，如果同一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能。这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。

与其他网关的主要区别是，并行网关不会解析条件。 即使顺序流中定义了条件，也会被忽略。

案例：
在这里插入图片描述
当我们执行了创建请假单后，到并行网关的位置的时候，在ACT_RU_TASK表中就有两条记录

在这里插入图片描述
然后同时在ACT_RU_EXECUTION中有三条记录，一个任务对应的有两个执行实例

在这里插入图片描述

1.3 包含网关

包含网关可以看做是排他网关和并行网关的结合体。和排他网关一样，你可以在外出顺序流上定义条件，包含网关会解析它们。但是主要的区别是包含网关可以选择多于一条顺序流，这和并行网关一样。

包含网关的功能是基于进入和外出顺序流的：

分支：所有外出顺序流的条件都会被解析，结果为true的顺序流会以并行方式继续执行，会为每个顺序流创建一个分支。
汇聚：所有并行分支到达包含网关，会进入等待状态，直到每个包含流程token的进入顺序流的分支都到达。这是与并行网关的最大不同。换句话说，包含网关只会等待被选中执行了的进入顺序流。在汇聚之后，流程会穿过包含网关继续执行。

在这里插入图片描述
有些一定要执行，有些是选择执行

十一、Flowable整合Springboot

1. 引入依赖

 <!--flowable工作流依赖-->
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-spring-boot-starter</artifactId>
            <version>6.3.0</version>
        </dependency>
        <!--mysql依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.45</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.16</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

2. 配置数据库

# 数据源配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/flowable123?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&nullCatalogMeansCurrent=true
    username: root
    password: root
    hikari:
      minimum-idle: 5
      idle-timeout: 600000
      maximum-pool-size: 10
      auto-commit: true
      pool-name: MyHiKariCP
      max-lifetime: 1800000
      connection-timeout: 30000
      connection-test-query: SELECT 1
flowable:
  async-executor-activate: false #关闭定时任务
  database-schema-update: true
server:
  port: 8082

3.启动项目自动创建表结构

比原来的表要多

4. 自动部署

processes目录下的任何BPMN 2.0流程定义都会被自动部署。创建processes目录，并在其中创建示例流程定义（命名为one-task-process.bpmn20.xml）。

cases目录下的任何CMMN 1.1事例都会被自动部署。

forms目录下的任何Form定义都会被自动部署。

&emsp;在src/resources/process目录下的流程会自动部署，流程定义命名规范为one-task-process.bpmn20.xml

缺点：当已经有一个部署了，再放一个进去就不会部署了

5. 手动部署

    }

    @Test
    void testDeploy(){
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("holiday-request.bpmn20.xml")
                .name("leave")
                .deploy();
        System.out.println("deploy.getId() = " + deploy.getId());
        System.out.println("deploy.getName() = " + deploy.getName());
    }

6.启动流程

    @Test
    void startFlow(){
        Map<String,Object> map = new HashMap<>();
//        map.put("approved",true);
        runtimeService.startProcessInstanceByKey("holidayRequest",map);
    }

7.完成流程

    @Test
    void completeTask(){
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("holidayRequest")
                .taskAssignee("lisi")
                .singleResult();

        Map<String,Object> variables = new HashMap<>();
        variables.put("approved",false); // 拒绝请假
        if (task != null) {
            taskService.complete(task.getId(),variables);
            System.out.println("complete ......");
        }

    }