Activiti

cuiyaonan2000

已于 2023-11-10 17:28:45 修改

阅读量816

点赞数

分类专栏：杂项文章标签： Activiti

于 2023-11-10 16:07:40 首次发布

本文链接：https://blog.csdn.net/cuiyaonan2000/article/details/134329008

版权

杂项专栏收录该内容

12 篇文章

订阅专栏

序言

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

历史版本的整合方式与基于springboot的整合方式有差异,而且不方便,故此基于spring-boot的方式整合Activiti7

为什么使用工作流引擎，能实现业务流程改变，不用修改代码，流程还能自动推进？

我们先来说说为什么流程改变，不用修改代码：我们的工作流引擎都实现了一个规范，这个规范要求我们的流程管理与状态字段无关，始终都是读取业务流程图的下一个节点。当业务更新的时候我们只需要更新业务流程图就行了。这就实现了业务流程改变，不用修改代码。
再来说说流程自动推进，这个原理就更简单了，就拿上面的请假模型来说，工作流引擎会用一张表来记录当前处在的节点。当填写完请假单后肯定是要轮到部门经理来审批了，所以我们一旦完成了请假单填写那么这条记录将会被从这张表删除掉，并且会把下一个节点部门经理的信息插入到这张表中，当我们用部门经理的信息去这张表中查询的时候就能查出部门经理相关的审批的信息了，以此类推，这样层层递进，就实现了流程的自动递交了。

参考资料:

Open Source Business Automation | Activiti ---官网
https://activiti.gitbook.io/activiti-7-developers-guide/getting-started --官网 readme
Activiti入门_activiti-explorer-CSDN博客 ----非常详细,通读一遍轻松应用activiti

BPMN

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

BPMN（Business Process Model AndNotation）即业务流程模型和符号，是一套标准的业务流程建模符号，使用 BPMN 提供的符号可以创建业务流程。Activit 就是使用 BPMN 进行流程建模、流程执行管理的

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

BPMN2.0 的基本符号主要包含

事件 Event

开始：表示一个流程的开始
中间：发生的开始和结束事件之间，影响处理的流程
结束：表示该过程结束

活动 Activities

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

网关 GateWay

用于表示流程的分支与合并，有几种常用网关需要了解(这个就是我们的流程判断条件cuiyaonan2000@163.com)：

排他网关：只有一条路径会被选择
并行网关：所有路径会被同时选择
包容网关：可以同时执行多条线路，也可以在网关上设置条件
事件网关：专门为中间捕获事件设置的，允许设置多个输出流指向多个不同的中间捕获事件。当流程执行到事件网关后，流程处于等待状态，需要等待抛出事件才能将等待状态转换为活动状态。----即只会激活后面对应的事件处理任务cuiyoanna2000@163.com

流向 Flow

流是连接两个流程节点的连线，常见的流向包含以下几种：
顺序流：用一个带实心箭头的实心线表示，用于指定活动执行的顺序
信息流：用一条带箭头的虚线表示，用于描述两个独立的业务参与者（业务实体/业务角色）之间发送和接受的消息流动
关联：用一根带有线箭头的点线表示，用于将相关的数据、文本和其他人工信息与流对象联系起来。用于展示活动的输入和输出

总结

总的来说我们整合Activiti其实就是创建一个业务流程,Activiti加载该业务流程,然后我们创建一个该流程的实例,创建的时候同时关联我们的业务信息, 每个节点我们需要在业务代码中调用Activiti接口来告诉Activiti该节点完成了.可以去通知下一个节点来操作了(这里怎么通知呢,一般是我们自己写代码去查询,根据我们传给Activiti的角色信息,角色信息也可以在创建业务流程中注入进去cuiyaonan2000@163.com)

Activiti 流程

第一步：引入依赖并初始化数据库

既然activiti是一个框架，那么我们肯定是需要引入对应的jar包坐标的，具体参考代码中的。

第二步：通过工具绘画流程图

使用 activiti 流程建模工具(activity-designer)定义业务流程(.bpmn 文件).bpmn 文件就是业务流程定义文件，通过 xml 定义业务流程。

第三步：流程定义部署;

向 activiti 部署业务流程定义（.bpmn 文件），使用 activiti 提供的 api 向 activiti 中部署.bpmn 文件，通俗来讲，就是让activiti认识要使用的流程

第四步：启动一个流程实例（ProcessInstance）

启动一个流程实例表示开始一次业务流程的运行，比如员工请假流程部署完成，如果张三要请假就可以启动一个流程实例，如果李四要请假也启动一个流程实例，两个流程的执行互相不影响，就好比定义一个java类，实例化两个对象一样，部署的流程就好比java类，启动一个流程实例就好比new一个java对象

第五步：用户查询待办任务(Task)

因为现在系统的业务流程已经交给 activiti 管理，通过 activiti 就可以查询当前流程执行到哪了，当前用户需要办理什么任务了，这些 activiti帮我们管理了。实际上我们学习activiti也只是学习它的API怎么使用，因为很多功能activiti都已经封装好了，我们会调用就行了

第六步：用户办理任务

用户查询待办任务后，就可以办理某个任务，如果这个任务办理完成还需要其它用户办理，比如请假单创建后由部门经理审核，这个过程也是由 activiti 帮我们完成了，不需要我们在代码中硬编码指定下一个任务办理人了

第七步：流程结束

当任务办理完成没有下一个任务节点了，这个流程实例就完成了。

Activiti7 操作指南

数据库支持

Activiti 运行必须要有数据库的支持，支持的数据库有：mysql、oracle、postgres、mssql、db2、h2

Activiti环境

我们直接在当前项目：guigu-oa-parent做Activiti入门讲解

引入依赖

<!--引入activiti的springboot启动器 -->
<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-spring-boot-starter</artifactId>
    <version>7.1.0.M6</version>
    <exclusions>
        <exclusion>
            <artifactId>mybatis</artifactId>
            <groupId>org.mybatis</groupId>
        </exclusion>
    </exclusions>
</dependency>

说明：Activiti7与SpringBoot整合后，默认集成了SpringSecurity安全框架，当前我们项目已经集成过了SpringSecurity，后续案例设置审批人时都必须是系统用户，Activiti框架会检查用户是否存在，否则会出现异常，后续大家可以在案例中测试。

添加配置

数据源项目已经添加，只需要如下配置即可

spring:    
    activiti:
      #    false:默认，数据库表不变，但是如果版本不对或者缺失表会抛出异常（生产使用）
      #    true:表不存在，自动创建（开发使用）
      #    create_drop: 启动时创建，关闭时删除表（测试使用）
      #    drop_create: 启动时删除表,在创建表（不需要手动关闭引擎）
      database-schema-update: true
      #监测历史表是否存在，activities7默认不开启历史表
      db-history-used: true
      #none：不保存任何历史数据，流程中这是最高效的
      #activity：只保存流程实例和流程行为
      #audit：除了activity，还保存全部的流程任务以及其属性，audit为history默认值
      #full：除了audit、还保存其他全部流程相关的细节数据，包括一些流程参数
      history-level: full
      #校验流程文件，默认校验resources下的process文件夹的流程文件
      check-process-definitions: true

启动项目

启动项目，即可生成项目数据库表

数据库表介绍

Activiti 的运行支持必须要有这 25 张表的支持，主要是在业务流程运行过程中，记录参与流程的用户主体，用户组信息，以及流程的定义，流程执行时的信息，和流程的历史信息等等

1、表的命名规则和作用

观察创建的表，我们发现 Activiti 的表都以 act_ 开头，紧接着是表示表的用途的两个字母标识，也和 Activiti 所提供的服务的 API 对应：

ACT_RE：RE 表示 repository，这个前缀的表包含了流程定义和流程静态资源（图片、规则、等等）
ACT_RU：RU 表示 runtime，这些表运行时，会包含流程实例、任务、变量、异步任务等流程业务进行中的数据。Activiti 只在流程实例执行过程中保存这些数据，在流程结束时就会删除这些记录。这样表就可以一直保持很小的体积，并且速度很快
ACT_HI：HI 表示 history，这些表包含一些历史数据，比如历史流程实例、变量、任务等等
ACT_GE：GE 表示 general，通用数据

Activiti常用Service服务接口

RepositoryService

Activiti 的资源管理类，该服务负责部署流程定义，管理流程资源。在使用 Activiti 时，一开始需要先完成流程部署，即将使用建模工具设计的业务流程图通过 RepositoryService 进行部署

RuntimeService

Activiti 的流程运行管理类，用于开始一个新的流程实例，获取关于流程执行的相关信息。流程定义用于确定一个流程中的结构和各个节点间行为，而流程实例则是对应的流程定义的一个执行，可以理解为 Java 中类和对象的关系

TaskService

Activiti 的任务管理类，用于处理业务运行中的各种任务，例如查询分给用户或组的任务、创建新的任务、分配任务、确定和完成一个任务

HistoryService

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

ManagementService

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

Idear安装插件

代码实例

添加流程

packagecom.atguigu;

importorg.activiti.engine.RepositoryService;
importorg.activiti.engine.repository.Deployment;
importorg.junit.Test;
importorg.junit.runner.RunWith;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.boot.test.context.SpringBootTest;
importorg.springframework.test.context.junit4.SpringRunner;


@RunWith(SpringRunner.class)
@SpringBootTest
publicclassProcessTest {

    @Autowired
    privateRepositoryServicerepositoryService;

    @Test
    publicvoiddeployProcess() {
        // 流程部署
        Deploymentdeploy=repositoryService.createDeployment()
                .addClasspathResource("process/qingjia.bpmn20.xml")
                .addClasspathResource("process/qingjia.png")
                .name("请假申请流程")
                .deploy();
        System.out.println(deploy.getId());
        System.out.println(deploy.getName());
    }
}





//打包部署
@Test
publicvoiddeployProcessByZip() {
    // 定义zip输入流
    InputStreaminputStream=this
            .getClass()
            .getClassLoader()
            .getResourceAsStream(
                    "process/qingjia.zip");
    ZipInputStreamzipInputStream=newZipInputStream(inputStream);

    // 流程部署
    Deploymentdeployment=repositoryService.createDeployment()
            .addZipInputStream(zipInputStream)
            .name("请假申请流程")
            .deploy();
    System.out.println("流程部署id："+deployment.getId());
    System.out.println("流程部署名称："+deployment.getName());
}

创建流程实例

//创建实例

@Autowired
privateRuntimeServiceruntimeService;

@Test
publicvoidstartUpProcess() {
    //创建流程实例,我们需要知道流程定义的key
    ProcessInstanceprocessInstance=runtimeService.startProcessInstanceByKey("qingjia");
    //输出实例的相关信息
    System.out.println("流程定义id："+processInstance.getProcessDefinitionId());
    System.out.println("流程实例id："+processInstance.getId());
    System.out.println("当前活动Id："+processInstance.getActivityId());
}




-------------------------------

//查询尚未被完成的实例相关信息

/**
流程实例id:一个流程只有一个,标识这个流程

任务id:流程每进行到某个节点,就会给这个节点分配一个任务id

输出结果如下：

流程实例id：d969f534-825e-11ed-95b4-7c57581a7819 任务id：d96c3f28-825e-11ed-95b4-7c57581a7819 任务负责人：zhangsan 任务名称：张三审批
*/

@Autowired
privateTaskServicetaskService;

/**
* 查询当前个人待执行的任务
*/
@Test
publicvoidfindPendingTaskList() {
    //任务负责人
    Stringassignee="zhangsan";
    List<Task>list=taskService.createTaskQuery()
            .taskAssignee(assignee)//只查询该任务负责人的任务
            .list();
    for (Tasktask : list) {
        System.out.println("流程实例id："+task.getProcessInstanceId());
        System.out.println("任务id："+task.getId());
        System.out.println("任务负责人："+task.getAssignee());
        System.out.println("任务名称："+task.getName());
    }
}





------------------------------------

//查询已经完成的实例
@Autowired
privateHistoryServicehistoryService;

/**
* 查询已处理历史任务
*/
@Test
publicvoidfindProcessedTaskList() {
    //张三已处理过的历史任务
    List<HistoricTaskInstance>list=historyService.createHistoricTaskInstanceQuery().taskAssignee("zhangsan").finished().list();
    for (HistoricTaskInstancehistoricTaskInstance : list) {
        System.out.println("流程实例id："+historicTaskInstance.getProcessInstanceId());
        System.out.println("任务id："+historicTaskInstance.getId());
        System.out.println("任务负责人："+historicTaskInstance.getAssignee());
        System.out.println("任务名称："+historicTaskInstance.getName());
    }
}

通知Activiti任务完成

/**
* 完成任务
*/
@Test
publicvoidcompletTask(){
    Tasktask=taskService.createTaskQuery()
            .taskAssignee("zhangsan")  //要查询的负责人
            .singleResult();//返回一条

    //完成任务,参数：任务id
    taskService.complete(task.getId());
}

其它额外信息查询

/**
* 查询流程定义
*/
@Test
publicvoidfindProcessDefinitionList(){
    List<ProcessDefinition>definitionList=repositoryService.createProcessDefinitionQuery()
            .orderByProcessDefinitionVersion()
            .desc()
            .list();
    //输出流程定义信息
    for (ProcessDefinitionprocessDefinition : definitionList) {
        System.out.println("流程定义 id="+processDefinition.getId());
        System.out.println("流程定义 name="+processDefinition.getName());
        System.out.println("流程定义 key="+processDefinition.getKey());
        System.out.println("流程定义 Version="+processDefinition.getVersion());
        System.out.println("流程部署ID ="+processDefinition.getDeploymentId());
    }
}

/**
* 删除流程定义
*/
publicvoiddeleteDeployment() {
    //部署id
    StringdeploymentId="82e3bc6b-81da-11ed-8e03-7c57581a7819";
    //删除流程定义，如果该流程定义已有流程实例启动则删除时出错
    repositoryService.deleteDeployment(deploymentId);
    //设置true 级联删除流程定义，即使该流程有流程实例启动也可以删除，设置为false非级别删除方式
    //repositoryService.deleteDeployment(deploymentId, true);
}

流程实例关联业务信息

比如我们填写一个请假单，一定会有一个请假单的唯一标识，我们通常使用这个标识来关联activiti，这个标识在activiti中称为businesskey

BusinessKey：业务标识，通常为业务的主键，业务标识和流程标识一一对应，业务标识来源于业务系统，存储业务标识就是根据业务标识来关联查询业务系统的数据

/**
* 启动流程实例，添加businessKey
*/
@Test
publicvoidstartUpProcessAddBusinessKey(){
    StringbusinessKey="1";
    // 启动流程实例，指定业务标识businessKey，也就是请假申请单id
    ProcessInstanceprocessInstance=runtimeService.
            startProcessInstanceByKey("qingjia",businessKey);
    // 输出
    System.out.println("业务id:"+processInstance.getBusinessKey());
}

挂起，激活流程实例

某些情况可能由于流程变更需要将当前运行的流程暂停而不是直接删除，流程暂停后将不会执行

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



@Test
publicvoidsuspendProcessInstance() {
    ProcessDefinitionqingjia=repositoryService.createProcessDefinitionQuery().processDefinitionKey("qingjia").singleResult();
    // 获取到当前流程定义是否为暂停状态 suspended方法为true是暂停的，suspended方法为false是运行的
    booleansuspended=qingjia.isSuspended();
    if (suspended) {
        // 暂定,那就可以激活
        // 参数1:流程定义的id  参数2:是否激活    参数3:时间点
        repositoryService.activateProcessDefinitionById(qingjia.getId(), true, null);
        System.out.println("流程定义:"+qingjia.getId() +"激活");
    } else {
        repositoryService.suspendProcessDefinitionById(qingjia.getId(), true, null);
        System.out.println("流程定义:"+qingjia.getId() +"挂起");
    }
}




-----------------------------------------------

//单个流程实例挂起

@Test
publicvoidSingleSuspendProcessInstance() {
    StringprocessInstanceId="8bdff984-ab53-11ed-9b17-f8e43b734677";
    ProcessInstanceprocessInstance=runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
    //获取到当前流程定义是否为暂停状态   suspended方法为true代表为暂停   false就是运行的
    booleansuspended=processInstance.isSuspended();
    if (suspended) {
        runtimeService.activateProcessInstanceById(processInstanceId);
        System.out.println("流程实例:"+processInstanceId+"激活");
    } else {
        runtimeService.suspendProcessInstanceById(processInstanceId);
        System.out.println("流程实例:"+processInstanceId+"挂起");
    }
}

任务分配控制

固定分配

在前面进行业务流程建模时指定固定的任务负责人，如：Assignee：zhangsan/lisi

如图：

assignee1 这个变量是 activiti 的一个流程变量

我们启动流程实例，这个启动实例的方法跟之前的方法基本一致,唯一的不同是在启动时,添加了一个参数

@Test
publicvoiddeployProcess01() {
    // 流程部署
    Deploymentdeploy=repositoryService.createDeployment()
        .addClasspathResource("process/jiaban01.bpmn20.xml")
        .name("加班申请流程")
        .deploy();
    System.out.println(deploy.getId());
    System.out.println(deploy.getName());
}

/**
* 启动流程实例
*/
@Test
publicvoidstartUpProcess01() {
    Map<String, Object>variables=newHashMap<>();
    variables.put("assignee1","zhangsan");
    variables.put("assignee2","lisi");
    //创建流程实例,我们需要知道流程定义的key
    ProcessInstanceprocessInstance=runtimeService.startProcessInstanceByKey("qingjia01", variables);
    //输出实例的相关信息
    System.out.println("流程定义id："+processInstance.getProcessDefinitionId());
    System.out.println("流程实例id："+processInstance.getId());
}

表达式分配

activiti使用UEL表达式，UEL是java EE6规范的一部分,UEL即统一表达式语言，activiti支持两个UEL表达式：UEL-value和UEL-method。

userBean 是 spring 容器中的一个 bean，表示调用该 bean 的 getUsername(int id)方法。

经理审批：${userBean.getUsername(1)}

人事审批：${userBean.getUsername(2)}

packagecom.atguigu.process.bean;

importorg.springframework.stereotype.Component;

@Component
publicclassUserBean {

    publicStringgetUsername(intid) {
        if(id==1) {
            return"zhangsan";
        }
        if(id==2) {
            return"lisi";
        }
        return"admin";
    }
}

部署与启动

@Test
publicvoiddeployProcess02() {
    // 流程部署
    Deploymentdeploy=repositoryService.createDeployment()
        .addClasspathResource("process/jiaban02.bpmn20.xml")
        .name("加班申请流程")
        .deploy();
    System.out.println(deploy.getId());
    System.out.println(deploy.getName());
}

/**
* 启动流程实例
*/
@Test
publicvoidstartUpProcess02() {
    //创建流程实例,我们需要知道流程定义的key
    ProcessInstanceprocessInstance=runtimeService.startProcessInstanceByKey("qingjia02");
    //输出实例的相关信息
    System.out.println("流程定义id："+processInstance.getProcessDefinitionId());
    System.out.println("流程实例id："+processInstance.getId());
}

启动流程实例，就会调用bean方法，参数为：1，经理审批后，接着调用bean方法，参数为：2

监听器分配

使用监听器的方式来指定负责人，那么在流程设计时就不需要指定assignee。

任务监听器是发生对应的任务相关事件时执行自定义 java 逻辑或表达式

Event的选项包含：

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

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

packagecom.atguigu.process.bean;

importorg.activiti.engine.delegate.DelegateTask;
importorg.activiti.engine.delegate.TaskListener;

publicclassMyTaskListenerimplementsTaskListener {

    @Override
    publicvoidnotify(DelegateTaskdelegateTask) {
        if(delegateTask.getName().equals("经理审批")){
            //这里指定任务负责人
            delegateTask.setAssignee("zhangsan");
        } elseif(delegateTask.getName().equals("人事审批")){
            //这里指定任务负责人
            delegateTask.setAssignee("lisi");
        }
    }
}

经理审批与人事审批，都设置一样的监听即可

部署与测试

@Test
public void deployProcess03() {
    // 流程部署
    Deployment deploy = repositoryService.createDeployment()
            .addClasspathResource("process/jiaban03.bpmn20.xml")
            .name("加班申请流程")
            .deploy();
    System.out.println(deploy.getId());
    System.out.println(deploy.getName());
}
 
/**
 * 启动流程实例
 */
@Test
public void startUpProcess03() {
    //创建流程实例,我们需要知道流程定义的key
    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("jiaban03");
    //输出实例的相关信息
    System.out.println("流程定义id：" + processInstance.getProcessDefinitionId());
    System.out.println("流程实例id：" + processInstance.getId());
}

启动流程实例，就会调用MyTaskListener监听方法

流程变量

什么是流程变量?
流程变量在 activiti 中是一个非常重要的角色，流程运转有时需要靠流程变量，业务系统和 activiti结合时少不了流程变量，流程变量就是 activiti 在管理工作流时根据管理需要而设置的变量。比如：在请假申请流程流转时如果请假天数大于2 天则由总经理审核，否则由部门经理直接审核，请假天数就可以设置为流程变量，在流程流转时使用。

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

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

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

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

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

流程变量的使用方法
通过UEL表达式使用流程变量

之前我们也使用过UEL表达式来设置任务处理人，例如${assignee1}，activiti获取UEL表达式的值，即流程变量assignee1的值，将值作为任务的负责人进行任务分配2、我们也可以在任务和任务间的连线上使用UEL表达式，决定流程走向比如${ day > 2 }和${day <= 2}，day就是一个流程变量名称，UEL表达式的执行结果是布尔类型----------注意这里就是网关设置条件的方式cuiyaonan2000@163.com

设置globa变量

这里的设置都是针对业务流程的,即所有的业务流程实例都会被影响cuiyaonan2000@163.com

//启动流程时设置变量
//在启动流程时设置流程变量，变量的作用域是整个流程实例。通过 Map<key,value> 设置流程变量，map 中可以设置多个变量，这个 key 就是流程变量的名字
@Test
publicvoidstartUpProcess() {
    Map<String, Object>variables=newHashMap<>();
    variables.put("assignee1", "zhangsan");
    variables.put("assignee2", "lisi");
    //创建流程实例,我们需要知道流程定义的key
    ProcessInstanceprocessInstance=runtimeService.startProcessInstanceByKey("qingjia", variables);
    //输出实例的相关信息
    System.out.println("流程定义id："+processInstance.getProcessDefinitionId());
    System.out.println("流程实例id："+processInstance.getId());
}


//在任务办理时设置流程变量
//它的作用域是整个流程实例 ，如果设置的流程变量的 key 在流程实例中已存在相同的名字则后设置的变量替换前边设置的变量。
@Test
publicvoidcompletTask() {
    Tasktask=taskService.createTaskQuery()
            .taskAssignee("zhangsan")  //要查询的负责人
            .singleResult();//返回一条

    Map<String, Object>variables=newHashMap<>();
    variables.put("assignee2", "zhao");
    //完成任务,参数：任务id
    taskService.complete(task.getId(), variables);
}


//通过当前流程实例设置
//通过流程实例 id 设置全局变量， 它的作用域是整个流程实例 ，该流程实例必须未执行完成。
@Test
publicvoidprocessInstanceIdSetVariables() {
    Map<String, Object>variables=newHashMap<>();
    variables.put("assignee2", "wang");
    runtimeService.setVariables("1c347a90-82c6-11ed-96ca-7c57581a7819", variables);
}

设置Local变量

//local 流程变量的作用域只在当前任务节点下可用

//任务办理时设置local流程变量，当前运行的流程实例只能在该任务结束前使用，任务结束该变量无法在当前流程实例使用
@Test
publicvoidcompletLocalTask() {
    Tasktask=taskService.createTaskQuery()
            .taskAssignee("zhangsan")  //要查询的负责人
            .singleResult();//返回一条

    // 设置local变量，作用域为该任务
    taskService.setVariableLocal(task.getId(),"assignee2","li");
    // 查看local变量
    System.out.println(taskService.getVariableLocal(task.getId(), "assignee2"));
    //完成任务,参数：任务id
    taskService.complete(task.getId());
}

任务组

任务组就是节点处理人可以有多个,如果其中一个人接收了任务,其他人就不能接收任务了.同时接收人可以不处理该任务,同时把该任务给别人处理

//张三01拾取任务了，张三02就不能拾取了
@Test
publicvoidclaimTask(){
    //拾取任务,即使该用户不是候选人也能拾取(建议拾取时校验是否有资格)
    //校验该用户有没有拾取任务的资格
    Tasktask=taskService.createTaskQuery()
            .taskCandidateUser("zhangsan01")//根据候选人查询
            .singleResult();
    if(task!=null){
        //拾取任务
        taskService.claim(taskId, "zhangsan01");
        System.out.println("任务拾取成功");
    }
}


//归还任务
@Test
publicvoidassigneeToGroupTask() {
    StringtaskId="d96c3f28-825e-11ed-95b4-7c57581a7819";
    // 任务负责人
    StringuserId="zhangsan01";
    // 校验userId是否是taskId的负责人，如果是负责人才可以归还组任务
    Tasktask=taskService
            .createTaskQuery()
            .taskId(taskId)
            .taskAssignee(userId)
            .singleResult();
    if (task!=null) {
        // 如果设置为null，归还组任务,该 任务没有负责人
        taskService.setAssignee(taskId, null);
    }
}



//任务交接
//任务交接，任务负责人将任务交给其它候选人办理该任务
@Test
publicvoidassigneeToCandidateUser() {
    // 当前待办任务
    StringtaskId="d96c3f28-825e-11ed-95b4-7c57581a7819";
    // 校验zhangsan01是否是taskId的负责人，如果是负责人才可以归还组任务
    Tasktask=taskService
            .createTaskQuery()
            .taskId(taskId)
            .taskAssignee("zhangsan01")
            .singleResult();
    if (task!=null) {
        // 将此任务交给其它候选人zhangsan02办理该 任务
        taskService.setAssignee(taskId, "zhangsan02");
    }
}