Activiti 工作流引擎 详解

1、Activiti工作流概述

1.1、工作流概述

工作流(Workflow)，就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的过程，从而实现某个预期的业务目标，或者促使此目标的实现”。

1.2、工作流系统

一个软件系统中具有工作流的功能，我们把它称为工作流系统，一个系统中工作流的功能是什么？就是对系统的业务流程进行自动化管理，所以工作流是建立在业务流程的基础上，所以一个软件的系统核心根本上还是系统的业务流程，工作流只是协助进行业务流程管理。即使没有工作流业务系统也可以开发运行，只不过有了工作流可以更好的管理业务流程，提高系统的可扩展性。

1.3、Activiti概述

Activiti是一个工作流引擎， activiti可以将业务系统中复杂的业务流程抽取出来，使用专门的建模语言BPMN2.0进行定义，业务流程按照预先定义的流程进行执行，实现了系统的流程由activiti进行管理，减少业务系统由于流程变更进行系统升级改造的工作量，从而提高系统的健壮性，同时也减少了系统开发维护成本。

1.4、BPM

BPM即业务流程管理，是一种规范化的构造端到端的业务流程，以持续的提高组织业务效率。

idea插件安装：https://plugins.jetbrains.com/plugin/7429-actibpm/versions

将下载的jar包插件直接整到idea当中，在settings当中的插件当中，导入本地插件，导入插件之后重启idea即可。

2、Activiti工作流环境搭建

首先还是构建一个maven项目，之后导入依赖，这里就包括了activiti所需要的依赖包，以及junti测试包、mysql驱动包、连接池包。在进行使用的时候只需要对数据库驱动包的版本进行调整即可。

<properties>
    <slf4j.version>1.6.6slf4j.version>
    <log4j.version>1.2.12log4j.version>
    <activiti.version>7.0.0.Beta1activiti.version>
properties>
<dependencies>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-engineartifactId>
        <version>${activiti.version}version>
    dependency>
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-springartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-modelartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-converterartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-json-converterartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activitigroupId>
        <artifactId>activiti-bpmn-layoutartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>org.activiti.cloudgroupId>
        <artifactId>activiti-cloud-services-apiartifactId>
        <version>${activiti.version}version>
    dependency>
    
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.40version>
    dependency>
    
    <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatisartifactId>
        <version>3.4.5version>
    dependency>
    
    <dependency>
        <groupId>commons-dbcpgroupId>
        <artifactId>commons-dbcpartifactId>
        <version>1.4version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>
    
    <dependency>
        <groupId>log4jgroupId>
        <artifactId>log4jartifactId>
        <version>${log4j.version}version>
    dependency>
    <dependency>
        <groupId>org.slf4jgroupId>
        <artifactId>slf4j-apiartifactId>
        <version>${slf4j.version}version>
    dependency>
    <dependency>
        <groupId>org.slf4jgroupId>
        <artifactId>slf4j-log4j12artifactId>
        <version>${slf4j.version}version>
    dependency>
dependencies>

在这里使用log4j日志包，可以对日志进行配置，直接在resources下创建log4j.properties

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE debug info warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE
# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n
# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=f:\act\activiti.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r[%15.15t] %-5p %30.30c %x - %m\n

添加activiti配置文件，使用activiti提供的默认方式来创建mysql的表。默认方式是在 resources 下创建 activiti.cfg.xml 文件，注意：默认方式目录和文件名不能修改，因为activiti的源码中已经设置，到固定的目录读取固定文件名的文件。默认要在在activiti.cfg.xml中bean的名字叫processEngineConfiguration，名字不可修改，在这里直接连接到本地数据库activiti这个库。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contex
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
    
    
    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        <property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///activiti"/>
        <property name="jdbcUsername" value="root"/>
        <property name="jdbcPassword" value="root"/>
        
        <property name="databaseSchemaUpdate" value="true"/>
    bean>
beans>

当然了除了直接配置这个数据库的信息之外，还可以通过数据源的方式来进行配置。

	 
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///activiti" />
        <property name="username" value="root" />
        <property name="password" value="root" />
        <property name="maxActive" value="3" />
        <property name="maxIdle" value="1" />
    bean>

    <bean id="processEngineConfiguration"
          class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
        
        <property name="dataSource" ref="dataSource" />
        
        <property name="databaseSchemaUpdate" value="true"/>
    bean>

创建一个测试类，调用activiti的工具类，生成acitivti需要的数据库表。直接使用activiti提供的工具类ProcessEngines，会默认读取classpath下的activiti.cfg.xml文件，读取其中的数据库配置，创建 ProcessEngine，在创建ProcessEngine 时会自动创建表。代码执行完成之后在数据库当中进行查看对应的表是否都创建出来了。

    @Test
    public void testCreateDbTable() {
        //使用classpath下的activiti.cfg.xml中的配置创建processEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        System.out.println(processEngine);
        // 而除了使用默认配置进行创建工作流引擎对象，还可以通过自定义的方式进行创建。
        // 自定义配置文件名
        ProcessEngineConfiguration processEngineConfigurationFromResource = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml");
        // 自定义配置文件名 bean对象id
        ProcessEngineConfiguration processEngineConfigurationFromResource1 = ProcessEngineConfiguration.createProcessEngineConfigurationFromResource("activiti.cfg.xml", "processEngineConfiguration");
    }

生成的表说明：

表分类	表名	解释
一般数据
	[ACT_GE_BYTEARRAY]	通用的流程定义和流程资源
	[ACT_GE_PROPERTY]	系统相关属性
流程历史记录
	[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_RE_DEPLOYMENT]	部署单元信息
	[ACT_RE_MODEL]	模型信息
	[ACT_RE_PROCDEF]	已部署的流程定义
运行实例表
	[ACT_RU_EVENT_SUBSCR]	运行时事件
	[ACT_RU_EXECUTION]	运行时流程执行实例
	[ACT_RU_IDENTITYLINK]	运行时用户关系信息，存储任务节点与参与者的相关信息
	[ACT_RU_JOB]	运行时作业
	[ACT_RU_TASK]	运行时任务
	[ACT_RU_VARIABLE]	运行时变量表

3、Activiti 类、配置文件之间的关系

3.1、activiti.cfg.xml

activiti的引擎配置文件，包括：ProcessEngineConfiguration的定义、数据源定义、事务管理器等，此文件其实就是一个spring配置文件。

3.2、流程引擎配置类

流程引擎的配置类（ProcessEngineConfiguration），通过ProcessEngineConfiguration可以创建工作流引擎ProceccEngine，常用的两种方法如下：

3.2.1、StandaloneProcessEngineConfiguration

使用StandaloneProcessEngineConfigurationActiviti可以单独运行，来创建ProcessEngine，Activiti会自己处理事务。配置文件方式：通常在activiti.cfg.xml配置文件中定义一个id为 processEngineConfiguration 的bean，见环境搭建模块，就是使用这种方式进行配置的。

3.2.2、SpringProcessEngineConfiguration

通过org.activiti.spring.SpringProcessEngineConfiguration 与Spring整合。

3.3、Servcie服务接口

Service是工作流引擎提供用于进行工作流部署、执行、管理的服务接口，我们使用这些接口可以就是操作服务对应的数据表，并且在这里通过processEngine对象get对应的service就可以获取到service对象了。

service名称	service作用	功能描述
RepositoryService	activiti的资源管理类	activiti的资源管理类，提供了管理和控制流程发布包和流程定义的操作。使用工作流建模工具设计的业务流程图需要使用此service将流程定义文件的内容部署到计算机
RuntimeService	activiti的流程运行管理类	Activiti的流程运行管理类。可以从这个服务类中获取很多关于流程执行相关的信息
TaskService	activiti的任务管理类	Activiti的任务管理类。可以从这个类中获取任务的信息。
HistoryService	activiti的历史管理类	Activiti的历史管理类，可以查询历史信息，执行流程时，引擎会保存很多数据（根据配置），比如流程实例启动时间，任务的参与者， 完成任务的时间，每个流程实例的执行路径，等等。 这个服务主要通过查询功能来获得这些数据。
ManagerService	activiti的引擎管理类	Activiti的引擎管理类，提供了对 Activiti 流程引擎的管理和维护功能，这些功能不在工作流驱动的应用程序中使用，主要用于 Activiti 系统的日常维护。

4、流程的创建与操作

4.1、流程图的绘制

在之前就已经安装好了bpmn的插件，到这里就可以直接新建一个bpmn文件用来绘制流程图了，简单的绘制一个请假审批的一个流程，对每个流程设置一下id和name。

这里还可以将这个流程到处一张png图片文件，当然了，直接截图也是可以的，这里只是做一个简单的记录，首先将bpmn文件后缀改成xml，之后选中该文件，使用ctrl+shift+alt+u快捷键（或者右键文件选择Diagrams->show bpmn 2.0 designer）就可以通过流程图的形式打开文件了，之后将该流程图进行到处即可

4.2、流程的部署

将上面在设计器中定义的流程部署到activiti数据库中，就是流程定义部署。

4.2.1、单个文件部署方式

    @Test
    public void devo() {
        // 创建流程对象
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 获取service对象
        RepositoryService repositoryService = processEngine.getRepositoryService();
        // 流程部署 设置名字 将bpmn和png部署进去
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("bpmn/leave.bpmn")
                .addClasspathResource("bpmn/leave.png")
                .name("请假流程")
                .deploy();
        System.out.println("id = " + deploy.getId());
        System.out.println("name = " + deploy.getName());
    }

之后直接启动这个测试方法进行流程部署，可以观察日志，整个部署的过程当中总共操作了三张表

• act_re_deployment 流程定义部署表，每部署一次增加一条记录
• act_re_procdef 流程定义表，部署每个新的流程定义都会在这张表中增加一条记录
• act_ge_bytearray 流程资源表

act_re_deployment 和 act_re_procdef一对多关系，一次部署在流程部署表生成一条记录，但一次部署可以部署多个流程定义，每个流程定义在流程定义表生成一条记录。每一个流程定义在act_ge_bytearray会存在两个资源记录，bpmn和png。

4.2.2、使用压缩包的方式

    @Test
    public void devoZip(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("bpmn/leave.zip");
        ZipInputStream zipInputStream = new ZipInputStream(inputStream);
        Deployment deploy = repositoryService.createDeployment().addZipInputStream(zipInputStream).deploy();
        System.out.println("id = " + deploy.getId());
        System.out.println("name = " + deploy.getName());
    }

4.3、开始流程

启动一个流程表示发起一个新的请假申请，这就相当于java类与java对象的关系，类定义好后需要new创建一个对象使用，当然可以new多个对象。对于请出差申请流程，发起一个请假申请单需要启动一个流程实例，请假申请单发起请假也需要启动一个流程实例。

    @Test
    public void start(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 根据流程id启动流程
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("myLeave");
        System.out.println("流程id = " + instance.getProcessDefinitionId());
        System.out.println("实例id = " + instance.getId());
        System.out.println("活动id = " + instance.getActivityId());
    }

4.4、任务查询

流程启动后，任务的负责人就可以查询自己当前需要处理的任务，查询出来的任务都是该用户的待办任务。

    @Test
    public void findTask(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        List<Task> list = taskService.createTaskQuery().processDefinitionKey("myLeave").taskAssignee("yueyue").list();
        for (Task task : list){
            System.out.println("流程id = " + task.getProcessInstanceId());
            System.out.println("任务id = " + task.getId());
            System.out.println("任务负责人 = " + task.getAssignee());
            System.out.println("任务名称 = " + task.getName());
        }
    }

而对应的查询语句也是：根据流程的Key以及负责人去task当中查询任务。

SELECT DISTINCT RES.* FROM ACT_RU_TASK RES INNER JOIN ACT_RE_PROCDEF D ON RES.PROC_DEF_ID_ = D.ID_ 
WHERE RES.ASSIGNEE_ = 'yueyue' AND D.KEY_ = 'myLeave' ORDER BY RES.ID_ ASC LIMIT 2147483647 OFFSET 0 

4.5、任务推动

在前面我们可以获取到负责人所有的任务，并且可以获取到相对应的任务id，这里只需要获取id进行推动流程即可。

    @Test
    public void next(){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        taskService.complete("2505");
        // 获取单个流程数据进行操作，替换掉上面的2505
        // Task task = taskService.createTaskQuery().processDefinitionKey("myLeave").taskAssignee("zhangsan").singleResult();
        // taskService.complete(task.getId());
        System.out.println("任务完成");
    }

任务推动之后还是和查询任务一致的查询语句获取当前负责人的数据，也可以直接查看 act_ru_task这张表的流程数据推动了没，而之前的流程会保存在 act_hi_taskinst 这张表当中。而这里对后续的几个流程的推动也是相同的道理，就不继续进行流程推动了，当最后一步的流程走完之后，整个流程已经结束，在act_ru_task这张表就不会存在当前这个流程的数据了。

4.6、流程定义信息查询

查询流程相关信息，包含流程定义，流程部署，流程定义版本

    @Test
    public void processInfo() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        List<ProcessDefinition> list = processDefinitionQuery.processDefinitionKey("myLeave").orderByProcessDefinitionVersion().desc().list();
        for (ProcessDefinition definition : list) {
            System.out.println("id = " + definition.getId());
            System.out.println("name = " + definition.getName());
            System.out.println("key = " + definition.getKey());
            System.out.println("version = " + definition.getVersion());
        }
    }

4.7、流程删除

    @Test
    public void deleteProcess() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        repositoryService.deleteDeployment("1");
        // 如果该流程定义下存在已经运行的流程，使用普通删除报错，可用级联删除方法将流程及相关记录全部删除。
        // 先删除没有完成流程节点，最后就可以完全删除流程定义信息
        // repositoryService.deleteDeployment("1", true);
    }

4.8、下载资源文件

首先可以知道资源文件存在 act_ge_bytearray 这张表当中，而对于流程的数据bpmn和png文件的DEPLOYMENT_ID这个字段是相同的，因此只需要获取到这个id就能得到相对应的数据，这个id如何获取呢？在前面4.6获取流程信息当中就可以获取到这个id，因此把之前获取全部改为获取单个，就能拿到这个id了。而后续根据repositoryService来进行获取需要两个参数，一个就是这个id，另外一个就是文件的路径，文件的路径可以在 act_re_procdef 当中进行获取。

    @Test
    public void getBolb() throws IOException {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        ProcessDefinitionQuery processDefinitionQuery = repositoryService.createProcessDefinitionQuery();
        ProcessDefinition definition = processDefinitionQuery.processDefinitionKey("myLeave").orderByProcessDefinitionVersion().desc().singleResult();

        // 获取流程id 文件名
        String deploymentId = definition.getDeploymentId();
        String diagramResourceName = definition.getDiagramResourceName();
        String resourceName = definition.getResourceName();

        // 得到input流
        InputStream pngInput = repositoryService.getResourceAsStream(deploymentId, diagramResourceName);
        InputStream bpmnInput = repositoryService.getResourceAsStream(deploymentId, resourceName);

        File pngFile = new File("d:/leave.png");
        File bpmnFile = new File("d:/leave.bpmn");

        FileOutputStream pngOutputStream = new FileOutputStream(pngFile);
        FileOutputStream bpmnOutputStream = new FileOutputStream(bpmnFile);

        // 输入输出转换
        IOUtils.copy(pngInput, pngOutputStream);
        IOUtils.copy(bpmnInput, bpmnOutputStream);

        pngInput.close();
        pngOutputStream.close();
        bpmnInput.close();
        bpmnOutputStream.close();
    }

并且这里使用到的IOUtils工具类是apache提供的，需要引入新的依赖

        <dependency>
            <groupId>commons-iogroupId>
            <artifactId>commons-ioartifactId>
            <version>2.6version>
        dependency>

4.9、流程历史信息的查看

即使流程定义已经删除了，流程执行的历史信息通过前面的分析，依然保存在activiti的act_hi_*相关的表中。所以我们还是可以查询流程执行的历史信息，可以通过HistoryService来查看相关的历史记录。

    @Test
    public void findHistroy() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        HistoryService historyService = processEngine.getHistoryService();
        // 设置查询条件进行查询
        List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery()
                .orderByHistoricActivityInstanceStartTime().asc()
                .processInstanceId("2501").list();
        for (HistoricActivityInstance historiy : list) {
            System.out.println("activiti id = " + historiy.getActivityId());
            System.out.println("activiti name = " + historiy.getActivityName());
            System.out.println("process definition id = " + historiy.getProcessDefinitionId());
            System.out.println("process instance id = " + historiy.getProcessInstanceId());
            System.out.println("start time = " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(historiy.getStartTime()));
            System.out.println("===============================================");
        }
    }

4.10、给流程实例添加Businesskey（业务标识）

启动流程实例时，指定的businesskey，就会在act_ru_execution #流程实例的执行表中存储businesskey。
Businesskey：业务标识，通常为业务表的主键，业务标识和流程实例一一对应。业务标识来源于业务系统。存储业务标识就是根据业务标识来关联查询业务系统的数据。

    @Test
    public void addLeaveKey() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        ProcessInstance myLevel = runtimeService.startProcessInstanceByKey("myLevel", "1001");
        System.out.println(myLevel.getBusinessKey());
    }

4.11、流程的挂起与激活

4.11.1、全部流程实例挂起

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

    @Test
    public void suspendAll() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();

        ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().processDefinitionKey("myLevel").singleResult();
        // 是否暂停
        boolean suspended = definition.isSuspended();
        String id = definition.getId();
        if (suspended) {
            repositoryService.activateProcessDefinitionById(id, true, null);
            System.out.println("id = " + id + " 激活");
        } else {
            repositoryService.suspendProcessDefinitionById(id, true, null);
            System.out.println("id = " + id + " 挂起");
        }
    }

4.11.2、单个流程实例挂起

操作流程实例对象，针对单个流程执行挂起操作，某个流程实例挂起则此流程不再继续执行，完成该流程实例的当前任务将报异常。

    @Test
    public void suspendOne() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();

        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId("12501").singleResult();
        boolean suspended = processInstance.isSuspended();
        String id = processInstance.getId();

        if (suspended) {
            runtimeService.activateProcessInstanceById(id);
            System.out.println("id = " + id + " 激活");
        } else {
            runtimeService.suspendProcessInstanceById(id);
            System.out.println("id = " + id + " 挂起");
        }
    }

4.11.3、流程实例推动

在前面我们对一个整个的流程以及单个流程进行了激活和挂起操作，之后可以编写一段代码来进行推动流程操作，主要是用来当流程被挂起后流程还能否被继续推动。很显然，当挂起的流程去进行流程推动是不允许推动流程的，必须是流程是激活状态下才能够被推动。

    @Test
    public void complate() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery().processInstanceId("12501").taskAssignee("yueyue").singleResult();
        System.out.println("id = " + task.getId());
        System.out.println("name = " + task.getName());
        System.out.println("assignee = " + task.getAssignee());
        taskService.complete(task.getId());
    }

5、个人任务

5.1、分配任务负责人

5.1.1、固定负责人

在进行业务流程建模时指定固定的任务负责人，直接在bpmn当中指定assignee

5.1.2、表达式分配

由于固定分配方式，任务只管一步一步执行任务，执行到每一个任务将按照 bpmn 的配置去分配任 务负责人。和前面一样进行指定，使用${变量名}的方式进行指定。而指定之后的这些变量在流程启动的时候可以通过一个map对象来进行赋值。

    @Test
    public void start() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        // 根据流程id启动流程
        Map<String, Object> map = new HashMap();
        map.put("assignee", "huangyueyue");
        map.put("director", "yueyueniao");
        map.put("manager", "zhangsan");
        ProcessInstance instance = runtimeService.startProcessInstanceByKey("myLeaveUel", map);
    }

在这里就存在一个问题，我这的idea的版本是2018版的，发现修改后的bpmn文件保存不了数据，在xml文件和bpmn文件直接切来切去，还是无法解决，索性就直接修改xml文件了，对应的xml文件如下：

    <userTask activiti:assignee="${assignee}" activiti:exclusive="false" id="_3" name="请假申请"/>
    <userTask activiti:assignee="${director}" activiti:exclusive="true" id="_4" name="主管审批"/>
    <userTask activiti:assignee="${manager}" activiti:exclusive="true" id="_5" name="经理审批"/>

5.1.3、监听器分配

任务监听器的Event的选项包含：

• Create：任务创建后触发
• Assignment：任务分配后触发
• Delete：任务完成后触发
• All：所有事件发生都触发

定义任务监听类，且类必须实现 org.activiti.engine.delegate.TaskListener 接口

public class MyTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
        if (delegateTask.getName().equals("请假申请") &&
                delegateTask.getEventName().equals("create")) {
            //这里指定任务负责人
            delegateTask.setAssignee("黄阅阅");
        }
    }
}

这个流程是直接对请假申请流程添加了一个监听器，在这里对监听器指定对应的class，并且在监听器执行的时候进行设置负责人。而监听器对应的xml文件如下：

	<userTask activiti:exclusive="true" id="_3" name="请假申请">
		 <extensionElements>
			<activiti:taskListener class="com.lzq.listener.MyTaskListener" event="all"/>
		extensionElements>
	userTask>

5.2、查询任务

在前面就已经可以通过流程key和负责人就可以查询出这个人负责的流程单，而实际应用时，查询待办任务可能要显示出业务系统的一些相关信息。这里可以通过 businessKey（业务标识 ）关联查询业务系统的数据。

    @Test
    public void findProcessInstance() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Task task = taskService.createTaskQuery()
                .processDefinitionKey("myLeave")
                .taskAssignee("yueyue")
                .singleResult();
        String processInstanceId = task.getProcessInstanceId();
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                .processInstanceId(processInstanceId)
                .singleResult();
        String businessKey = processInstance.getBusinessKey();
        System.out.println("businessKey==" + businessKey);
    }

5.3、任务推动

在之前可以通过TaskService这个类的complate方法推动任务的流动，而在这里我们还需要对当前用户是否拥有推动该流程的权限，只需要先通过查询当前负责人的所有流程进行判断即可。有该流程即可推动，反之无法推动流程。

    @Test
    public void completTask() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery()
                .taskId("15005")
                .taskAssignee("yueyue")
                .singleResult();
        if (task != null) {
            taskService.complete("15005");
            System.out.println("完成任务");
        }
    }

6、流程变量与组任务

6.1、流程变量概述

6.2.1、流程变量是什么

流程变量在 activiti 中是一个非常重要的角色，流程运转有时需要靠流程变量，业务系统和 activiti 结合时少不了流程变量，流程变量就是 activiti 在管理工作流时根据管理需要而设置的变量。

虽然流程变量中可以存储业务数据可以通过activiti的api查询流程变量从而实现 查询业务数据，但是不建议这样使用，因为业务数据查询由业务系统负责，activiti设置流程变量是为了流程执行需要而创建

**6.1.2、流程变量作用域

流程变量的作用域可以是一个流程实例，或一个任务，或一个执行实例

1. global变量

   • 流程变量的默认作用域是流程实例。当一个流程变量的作用域为流程实例时，可以称为 global 变量
   • global 变量中变量名不允许重复，设置相同名称的变量，后设置的值会覆盖前设置的变量值。

2. local变量

   • 任务和执行实例仅仅是针对一个任务和一个执行实例范围，范围没有流程实例大， 称为 local 变量。
   • Local 变量由于在不同的任务或不同的执行实例中，作用域互不影响，变量名可以相同没有影响。
   • Local 变量名也可以和 global 变量名相同，没有影响。

6.2、使用Global变量控制流程

还是和前面的整个流程一样，现在对流程的分支进行控制，通过流程变量来进行控制，当天数大于或等于三天还需要通过经理审批，反之直接通过主管审批就结束了整个流程。

这里的话使用的UEL表达式使用的是uel-method来进行赋值，所以在这里需要一个实体类来进行值的给予，先定义一个类。该类当中必须包含这个day变量，也就是在bpmn文件当中指定的变量，以及该类必须实例化。并且加上getset方法。

public class Leave implements Serializable {
    private Double day;
}

6.2.1、启动流程时设置变量

在启动流程时设置流程变量，变量的作用域是整个流程实例。通过Map设置流程变量，map中可以设置多个变量，这个key就是流程变量的名字。后续通过TaskService的compele方法来进行推动流程实例的代码就不给出了，直接获取taskid进行推动，查看流程的走向。

    @Test
    public void startSet() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Leave leave = new Leave();
        leave.setDay(4d);
        Map map = new HashMap();
        map.put("leave", leave);
        map.put("assignee", "yueyueniao");
        map.put("director", "张三");
        map.put("manager", "黄阅阅");
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("myLeaveGlabal", map);
    }

6.2.2、任务办理时设置变量

在完成任务时设置流程变量，该流程变量只有在该任务完成后其它结点才可使用该变量，它的作用域是整个流程实例，如果设置的流程变量的key在流程实例中已存在相同的名字则后设置的变量替换前边设置的变量。这样对前面6.2.1的代码当中往map对象当中添加leave的代码注掉。

    @Test
    public void complete() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Leave leave = new Leave();
        leave.setDay(4d);
        Map map = new HashMap();
        map.put("leave", leave);
        Task task = taskService.createTaskQuery().processDefinitionKeyLike("myLeaveGlabal").taskAssignee("张三").singleResult();
        if (task != null) {
            taskService.complete(task.getId(), map);
        }
    }

6.2.3、通过当前流程实例设置

通过流程实例id设置全局变量，该流程实例必须未执行完成。

    @Test
    public void setGlobalVariableByExecutionId() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Leave leave = new Leave();
        leave.setDay(4d);
        runtimeService.setVariable("75001", "leave", leave);
    }

6.2.4、通过当前任务设置

    @Test
    public void setGlobalVariableByTaskId() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Leave leave = new Leave();
        leave.setDay(4d);
        taskService.setVariable("75001", "leave", leave);
    }

6.3、组任务办理流程

• 查询组任务
  指定候选人，查询该候选人当前的待办任务。候选人不能立即办理任务。

• 拾取任务
  该组任务的所有候选人都能拾取。将候选人的组任务，变成个人任务。原来候选人就变成了该任务的负责人。如果拾取后不想办理该任务，需要将已经拾取的个人任务归还到组里边，将个人任务变成了组任务。

• 、查询个人任务
  查询方式同个人任务部分，根据assignee查询用户负责的个人任务。

• 办理个人任务

首先创建一个bpmn文件，在user当中可以对candidateUsers进行设置多个人员，之间用都好进行隔开，而对应的xml如下：

    <userTask activiti:candidateUsers="zhangsan,lisi" activiti:exclusive="true" id="_3" name="申请-group"/>
    <userTask activiti:candidateUsers="wangwu,zhaoliu" activiti:exclusive="true" id="_4" name="审核-group"/>

之后将该bpmn进行部署，并且启动任务。

6.3.1、查询组任务

根据候选人查询组任务，可以看到这个task在act_ru_task这张表当中的assignee却是一个null，也就是该用户虽然可以查询出该任务，却无法对该任务进行处理。

    @Test
    public void findGroup() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        List<Task> list = taskService.createTaskQuery().processDefinitionKey("myLeaveGroup").taskCandidateUser("zhangsan").list();
        for (Task task : list) {
            System.out.println("instance id = " + task.getProcessInstanceId());
            System.out.println("id = " + task.getId());
            System.out.println("assignee = " + task.getAssignee());
            System.out.println("name = " + task.getName());
        }
    }

6.3.2、拾取组任务

候选人员拾取组任务后该任务变为自己的个人任务。用户拾取任务之后，对应的act_ru_task表对应的行数据的assignee就会变成相对应的人员。

    @Test
    public void getTask() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        Task task = taskService.createTaskQuery().taskId("87505").taskCandidateUser("zhangsan").singleResult();
        if (task != null) {
            taskService.claim("87505", "zhangsan");
            System.out.println("用户拾取");
        }
    }

6.3.3、归还组任务

直接通过assignee进行查询，查询到数据再将assignee置空也就表示归还了任务。同理任务的交接就不用设置为空了，直接设置给另一个用户即可。

    @Test
    public void returnTask() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        Task task = taskService.createTaskQuery().taskId("87505").taskAssignee("zhangsan").singleResult();
        if (task != null) {
            taskService.setAssignee("87505", null);
            System.out.println("用户归还");
        }
    }

7、网关

7.1、排他网关

排他网关，用来在流程中实现决策。 当流程执行到这个网关，所有分支都会判断条件是否为true，如果为true则执行该分支，注意：排他网关只会选择一个为true的分支执行。如果有两个分支条件都为true，排他网关会选择id值较小的一条分支去执行。

在这里对A流程后设置一个排他网关进行流程分支，这两条分支线也就对应两个uel表达式进行判断，而后就可以直接把这个流程进行部署，部署之后在启动流程的时候就给这个day进行设置值，直接进行推动流程，查看流程的流转。

    @Test
    public void startSet() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();
        Leave leave = new Leave();
        leave.setDay(-4d);
        Map map = new HashMap();
        map.put("leave", leave);
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("gateway-pt", map);
    }

    @Test
    public void compete() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Task task = taskService.createTaskQuery().processDefinitionKey("gateway-pt").taskAssignee("张三").singleResult();
        if (task != null) {
            taskService.complete(task.getId());
        }
    }

7.2、并行网关

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

1. fork分支：并行后的所有外出顺序流，为每个顺序流都创建一个并发分支。

2. join汇聚：所有到达并行网关，在此等待的进入分支， 直到所有进入顺序流的分支都到达以后， 流程就会通过汇聚网关。

并行网关的测试代码和前面排他网关的代码基本一致，在首先进行部署之后启动流程，给流程设置一个天数，而之后推动任务之后，首先进入到并行网关，这里并不会进行判断，这里的意思是表示B和C都可以进行对该任务流程进行操作，并且只有到B和C都做了相关的操作流程才会继续往后流转，后面接的排他网关直接通过最开始设置的值再进行判断做流程的流转。

7.3、包含网关

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

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

和之前的网关一样进行部署推动流程，可以发现在进入到包含网关的时候，网关会对条件进行判断再进行流转。二里面的包含又相当于并行网关，当并行的流程都执行完成之后再由包含网关进行汇聚。之后走排他网关进行判断流转。

7.4、事件网关

事件网关允许根据事件判断流向。网关的每个外出顺序流都要连接到一个中间捕获事件。 当流程到达一个基于事件网关，网关会进入等待状态：会暂停执行。与此同时，会为每个外出顺序流创建相对的事件订阅。

事件网关的外出顺序流和普通顺序流不同，这些顺序流不会真的"执行"， 相反它们让流程引擎去决定执行到事件网关的流程需要订阅哪些事件。 要考虑以下条件：

1. 事件网关必须有两条或以上外出顺序流；
2. 事件网关后，只能使用intermediateCatchEvent类型（activiti不支持基于事件网关后连接ReceiveTask）
3. 连接到事件网关的中间捕获事件必须只有一个入口顺序流。

8、SpringBoot 整合 Activiti

直接快速初始化一个springboot项目，再直接导入所需要的以来即可

        <dependency>
            <groupId>org.activitigroupId>
            <artifactId>activiti-spring-boot-starterartifactId>
            <version>7.0.0.Beta2version>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.18version>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>

修改配置文件，这里还是使用properties，用yml的话修改对应的 格式即可。

spring.datasource.url=jdbc:mysql:///activiti?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
#1.flase：默认值。activiti在启动时，对比数据库表中保存的版本，如果没有表或者版本不匹配，将抛出异常
#2.true： activiti会对数据库中所有表进行更新操作。如果表不存在，则自动创建
#3.create_drop： 在activiti启动时创建表，在关闭时删除表（必须手动关闭引擎，才能删除表）
#4.drop-create： 在activiti启动时删除原来的旧表，然后在创建新表（不需要手动关闭引擎）
spring.activiti.database-schema-update=true
#检测历史表是否存在 activiti7默认没有开启数据库历史记录 启动数据库历史记录
spring.activiti.db-history-used=true
#记录历史等级 可配置的历史级别有none, activity, audit, full
#none：不保存任何的历史数据，因此，在流程执行过程中，这是最高效的。
#activity：级别高于none，保存流程实例与流程行为，其他数据不保存。
#audit：除activity级别会保存的数据外，还会保存全部的流程任务及其属性。audit为history的默认值。
#full：保存历史数据的最高级别，除了会保存audit级别的数据外，还会保存其他全部流程相关的细节数据，包括一些流程参数等。
spring.activiti.history-level=full
#校验流程文件，默认校验resources下的processes文件夹里的流程文件
spring.activiti.check-process-definitions=false

在Activiti7与SpringBoot整合后，默认情况下，集成了SpringSecurity安全框架，这样我们就要去准备SpringSecurity整合进来的相关用户权限配置信息，添加一个SecurityUtil类，用来获取当前用户。

package com.lzq.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.context.SecurityContextImpl;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Component;

import java.util.Collection;

/**
 * @author huangyueyueniao
 * @version 1.0
 * @date 2022-01-06 20:39
 */
@Component
public class SecurityUtil {
    private Logger logger = LoggerFactory.getLogger(SecurityUtil.class);

    @Autowired
    @Qualifier("myUserDetailsService")
    private UserDetailsService userDetailsService;

    public void logInAs(String username) {
        UserDetails user = userDetailsService.loadUserByUsername(username);

        if (user == null) {
            throw new IllegalStateException("User " + username + " doesn't exist, please provide a valid user");
        }
        logger.info("> Logged in as: " + username);

        SecurityContextHolder.setContext(
                new SecurityContextImpl(
                        new Authentication() {
                            @Override
                            public Collection<? extends GrantedAuthority> getAuthorities() {
                                return user.getAuthorities();
                            }

                            @Override
                            public Object getCredentials() {
                                return user.getPassword();
                            }

                            @Override
                            public Object getDetails() {
                                return user;
                            }

                            @Override
                            public Object getPrincipal() {
                                return user;
                            }

                            @Override
                            public boolean isAuthenticated() {
                                return true;
                            }

                            @Override
                            public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
                            }

                            @Override
                            public String getName() {
                                return user.getUsername();
                            }
                        }));
        org.activiti.engine.impl.identity.Authentication.setAuthenticatedUserId(username);
    }
}

在Activiti7官方下载的Example中找到DemoApplicationConfig类，它的作用是为了实现SpringSecurity框架的用户权限的配置，这样我们就可以在系统中使用用户权限信息。

package com.lzq.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author huangyueyue
 * @version 1.0
 * @date 2022-01-06 20:44
 */
@Configuration
public class DemoApplicationConfiguration {
    private Logger logger = LoggerFactory.getLogger(DemoApplicationConfiguration.class);

    @Bean
    public UserDetailsService myUserDetailsService() {
        InMemoryUserDetailsManager inMemoryUserDetailsManager = new InMemoryUserDetailsManager();
        //这里添加用户，后面处理流程时用到的任务负责人，需要添加在这里
        String[][] usersGroupsAndRoles = {
                {"jack", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"rose", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"tom", "password", "ROLE_ACTIVITI_USER", "GROUP_activitiTeam"},
                {"other", "password", "ROLE_ACTIVITI_USER", "GROUP_otherTeam"},
                {"system", "password", "ROLE_ACTIVITI_USER"},
                {"admin", "password", "ROLE_ACTIVITI_ADMIN"},
        };

        for (String[] user : usersGroupsAndRoles) {
            List<String> authoritiesStrings = Arrays.asList(Arrays.copyOfRange(user, 2, user.length));
            logger.info("> Registering new user: " + user[0] + " with the following Authorities[" + authoritiesStrings + "]");
            inMemoryUserDetailsManager.createUser(new User(user[0], passwordEncoder().encode(user[1]),
                    authoritiesStrings.stream().map(s -> new SimpleGrantedAuthority(s)).collect(Collectors.toList())));
        }

        return inMemoryUserDetailsManager;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

在Activiti7当中可以自动部署流程，前提是在resources目录下，创建一个新的目录processes，用来放置bpmn文件，在配置文件当中可以对是否需要进行自动部署（spring.activiti.check-process-definitions=true）进行配置。这里就使用自动部署，在resources下创建对应的一个bpmn文件，并且这里就在给userTask设置人员的地方给定用户组，而在DemoApplicationConfiguration这个类当中也对用户做了组的设置。

<userTask activiti:candidateGroups="activitiTeam" activiti:exclusive="true" id="_3" name="A"/>
<userTask activiti:candidateGroups="activitiTeam" activiti:exclusive="true" id="_4" name="B"/>

最后就是添加一个测试类进行流程的测试，

import com.lzq.utils.SecurityUtil;
import lombok.extern.slf4j.Slf4j;
import org.activiti.api.process.model.ProcessDefinition;
import org.activiti.api.process.model.ProcessInstance;
import org.activiti.api.process.model.builders.ProcessPayloadBuilder;
import org.activiti.api.process.runtime.ProcessRuntime;
import org.activiti.api.runtime.shared.query.Page;
import org.activiti.api.runtime.shared.query.Pageable;
import org.activiti.api.task.model.Task;
import org.activiti.api.task.model.builders.TaskPayloadBuilder;
import org.activiti.api.task.runtime.TaskRuntime;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest
@Slf4j
@RunWith(SpringRunner.class)
public class SpringbootactivitiApplicationTests {

    @Autowired
    private ProcessRuntime processRuntime;

    @Autowired
    private TaskRuntime taskRuntime;

    @Autowired
    private SecurityUtil securityUtil;

	// 获取所有部署了的流程
    @Test
    public void find() {
        securityUtil.logInAs("jack");
        Page<ProcessDefinition> processDefinitionPage = processRuntime.processDefinitions(Pageable.of(0, 10));
        log.info("总条数{}", processDefinitionPage.getTotalItems());
        for (ProcessDefinition processDefinition : processDefinitionPage.getContent()) {
            System.out.println("流程定义：" + processDefinition);
        }
    }

	// 对用户组进行任务的拾取以及任务完成
    @Test
    public void start() {
        securityUtil.logInAs("jack");
        ProcessInstance start = processRuntime.start(ProcessPayloadBuilder.start().withProcessDefinitionKey("springboot-leave").build());
        log.info("流程实例内容：{}", start);
    }

    @Test
    public void doTask() {
        securityUtil.logInAs("tom");
        Page<Task> tasks = taskRuntime.tasks(Pageable.of(0, 10));
        if (tasks != null && tasks.getTotalItems() > 0) {
            for (Task task : tasks.getContent()) {
                taskRuntime.claim(TaskPayloadBuilder.claim().withTaskId(task.getId()).build());
                log.info("任务拾取 {}", task);
                taskRuntime.complete(TaskPayloadBuilder.complete().withTaskId(task.getId()).build());
                log.info("任务完成 {}", task);
            }
        }
    }
}

又是卷的一天！