Activiti任务的处理以及进阶使用

1.什么是流程实例

流程实例（ProcessInstance）代表流程定义的执行实例
一个流程实例包括所有的运行节点Task，所以我们一般使用来了解当前流程的进度信息

taskService.createTaskQuery()
                .processDefinitionKey(key)

例如：用户或者程序安装流程定义的内容发起了一个流程，这个就是一个流程实例
在这里插入图片描述

2.业务管理

如果我们要将我们的流程实例和业务数据关联，这时我们需要使用到Activiti中预留的**BusinessKey(业务标识)**来关联
在这里插入图片描述

2.1启动实例，并给流程实例启动start时添加businessKey

/**
* 启动流程实例，添加businessKey
*/
@Test
public void test01(){
// 1.获取ProcessEngine对象
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2.获取RuntimeService对象
RuntimeService runtimeService = processEngine.getRuntimeService();
// 3.启动流程实例
ProcessInstance instance = runtimeService
.startProcessInstanceByKey("evection", "1001");
// 4.输出processInstance相关属性
System.out.println("businessKey = "+instance.getBusinessKey());
}

在这里插入图片描述

2.2流程的挂起与激活

**目的：**在实际场景中可能由于流程变更需要将当前运行的流程暂停而不是删除，流程暂停后将不能继续执行。

2.21全部流程挂起

该流程定义下的所有流程实例全部暂停

/**
* 全部流程挂起实例与激活
*/
@Test
public void test02(){
// 1.获取ProcessEngine对象
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 2.获取RepositoryService对象
RepositoryService repositoryService = engine.getRepositoryService();
// 3.查询流程定义的对象
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
               .processDefinitionKey("evection")
               .singleResult();
// 4.获取当前流程定义的状态
boolean suspended = processDefinition.isSuspended();
String id = processDefinition.getId();
// 5.如果挂起就激活，如果激活就挂起
if(suspended){
// 表示当前定义的流程状态是 挂起的
repositoryService.activateProcessDefinitionById(
id // 流程定义的id
,true // 是否激活
,null // 激活时间
);
System.out.println("流程定义：" + id + ",已激活");
}else{
// 非挂起状态，激活状态 那么需要挂起流程定义
repositoryService.suspendProcessDefinitionById(
id // 流程id
,true // 是否挂起
,null // 挂起时间
);
System.out.println("流程定义：" + id + ",已挂起");
}
}
然后再去操作对于的流程实例会抛异常信息
我们再将挂起的流程转变为

核心就在于：根据RepositoryService.createProcessDefinitionQuery().processDefinitionKey(“流程实例”)——>得到流程定义的对象。然后根据这个对象获取当前状态——>根据状态进行激活与挂起

在这里插入图片描述

2.22单个实例的挂起

操作流程实例对象，针对单个流程执行挂起操作，某个流程实例挂起则此流程不再继续执行，当前流程定义的其他流程实例是不受干扰的。完成该流程实例的当前任务会抛异常

/**
* 单个流程实例挂起与激活
*/
@Test
public void test03(){
// 1.获取ProcessEngine对象
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 2.获取RuntimeService
RuntimeService runtimeService = engine.getRuntimeService();
// 3.获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
              .processInstanceId("25001")
              .singleResult();
// 4.获取相关的状态操作
boolean suspended = processInstance.isSuspended();
String id = processInstance.getId();
if(suspended){
// 挂起--》激活
runtimeService.activateProcessInstanceById(id);
System.out.println("流程定义：" + id + "，已激活");
}else{
// 激活--》挂起
runtimeService.suspendProcessInstanceById(id);
System.out.println("流程定义：" + id + "，已挂起");
  }
}

在这里插入图片描述

3.任务分配

3.1简单手动填充任务分配

这样耦合太高了，如果指定的人离职了得重新对图进行操作，而不是代码解决（Assiginee）
在这里插入图片描述

3.2表达式分配

在Activiti中支持使用UEL表达式，UEL表达式是Java EE6 规范的一部分， UEL(Unified Expression
Language) 即统一表达式语音， Activiti支持两种UEL表达式： UEL-value 和UEL-method

变量语法：
${assignee0}
在这里插入图片描述
部署流程到数据库中
主要使用利用deploy()

/**
* 先将新定义的流程部署到Activiti中数据库中
*/
@Test
public void test01(){
// 1.获取ProcessEngine对象
ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
// 2.获取RepositoryService进行部署操作
RepositoryService service = engine.getRepositoryService();
// 3.使用RepositoryService进行部署操作
Deployment deploy = service.createDeployment()
                .addClasspathResource("bpmn/evection-uel.bpmn") // 添加bpmn资源
                .addClasspathResource("bpmn/evection-uel.png") // 添加png资源
                .name("出差申请流程-UEL")
                .deploy();// 部署流程
// 4.输出流程部署的信息
System.out.println("流程部署的id:" + deploy.getId());
System.out.println("流程部署的名称：" + deploy.getName());
}

然后我们对流程实例关联UEL表达式
它会创建在我们的act_variable变量表中，利用Runtimeservice在调用startProcessInstanceByKey指定一个map变量里面存放UEL表达式

@Test
public void test02(){
// 获取流程引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 获取RuntimeService对象
RuntimeService runtimeService = processEngine.getRuntimeService();
// 设置 assignee 的取值，
Map<String,Object> map = new HashMap<>();
map.put("assignee0","张三");
map.put("assignee1","李四");
map.put("assignee2","王五");
map.put("assignee3","赵财务");
// 创建流程实例
runtimeService.startProcessInstanceByKey("evection-uel",map);
}

在这里插入图片描述

3.3业务方法分配UEL-method

userBean 是 spring 容器中的一个 bean，表示调用该 bean 的 getUserId()方法
在这里插入图片描述

3.4监听器分配

可以使用监听器来完成很多Activiti的流程业务。
我们在此处使用监听器来完成负责人的指定，那么我们在流程设计的时候就不需要指定assignee
Event选项

如何给流程图指定一个监听器?
对于任务task有四种场景：

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

  <userTask id="usertask1" name="创建请假单">
      <extensionElements>
        <activiti:taskListener event="create" class="com.bobo.activiti.listener.MyTaskListener"></activiti:taskListener>
      </extensionElements>
    </userTask>

然后接下来我们定义一个监听类
当前task的name满足为创建请假单，就给这个当前任务赋值负责人

package com.bobo.activiti.listener;

import org.activiti.engine.delegate.DelegateTask;
import org.activiti.engine.delegate.TaskListener;

public class MyTaskListener implements TaskListener {
    @Override
    public void notify(DelegateTask delegateTask) {
       if("创建请假单".equals(delegateTask.getName())
        && "create".equals(delegateTask.getEventName())){
            System.out.println("测试");
            // 指定任务的负责人
            delegateTask.setAssignee("张三-Listener");
        }

    }
}

工作流测试类

/**
     * 1.将流程部署到Activiti数据库中
     */
    @Test
    public void test01() {
        //1.获取ProcessEngine对象
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        //2.得到RepositoryService
        RepositoryService service = engine.getRepositoryService();
        //3.进行部署操作
        Deployment deploy = service.createDeployment()
                .addClasspathResource("activiti/evection-listener.bpmn20.xml") //添加bpmn资源
                .addClasspathResource("activiti/listener.png")
                .name("出差申请listener")
                .deploy();
        //4.输出流程部署的信息
        System.out.println("流程部署的id：" + deploy.getId());
        System.out.println("流程部署的名称：" + deploy.getName());
    }

    /**
     * 2.执行引擎
     */
    @Test
    public void test02() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //得到RuntimeService对象
        RuntimeService runtimeService = processEngine.getRuntimeService();
        //执行流程实例
        runtimeService.startProcessInstanceByKey("evection-listener");
    }

3.5查看用户是否有权限

思路：TaskService根据任务id和负责人查询任务是否存在即可，或者可以根据流定义的id查询当前执行到的任务是否存在，如果存在就将其执行

/**
     * 完成任务，判断用户是否有权限
     */
    @Test
    public void completeTask(){
         //1.任务id
        String taskId="10002";
        //2.任务负责人
        String assingee="张三";
        //3.获取ProcessEngine
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        //4.创建TaskService
        TaskService taskService = processEngine.getTaskService();
        //5.完成任务前需要校验负责人是否可以完成当前任务
        Task task = taskService.createTaskQuery()
                .taskId(taskId)
                .taskAssignee(assingee)
                .singleResult();
        if(task!=null){
            taskService.complete(taskId);
            System.out.println("完成任务");
        }
    }

4.查询任务

4.1查询任务负责人的待办任务

// 查询当前个人待执行的任务
@Test
public void findPersonalTaskList() {
  // 流程定义key
  String processDefinitionKey = "myEvection1";
  // 任务负责人
  String assignee = "张三";
  // 获取TaskService
TaskService taskService = processEngine.getTaskService();
List<Task> taskList = taskService.createTaskQuery()
                      .processDefinitionKey(processDefinitionKey)
                      .includeProcessVariables()
                      .taskAssignee(assignee)
                      .list();
for (Task task : taskList) {
System.out.println("----------------------------");
System.out.println("流程实例id： " + task.getProcessInstanceId());
System.out.println("任务id： " + task.getId());
System.out.println("任务负责人： " + task.getAssignee());
System.out.println("任务名称： " + task.getName());
 }
}

关联 businessKey

在 activiti 实际应用时，查询待办任务可能要显示出业务系统的一些相关信息。
1.比如：查询待审批出差任务列表需要将出差单的日期、出差天数等信息显示出来。
出差天数等信息在业务系统中存在，而并没有在 activiti 数据库中存在，所以是无法通过 activiti 的 api
查询到出差天数等信息。
2.实现：
在查询待办任务时，通过 businessKey（业务标识）关联查询业务系统的出差单表，查询出出差天数等
信息。

@Test
public void findProcessInstance(){
// 1.获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2.获取TaskService
TaskService taskService = processEngine.getTaskService();
// 3.获取RuntimeService
RuntimeService runtimeService = processEngine.getRuntimeService();
// 4.查询流程定义的对象
Task task = taskService.createTaskQuery()
          .processDefinitionKey("myEvection1")
          .taskAssignee("张三")
          .singleResult();
// 5.使用task对象获取流程实例id
String processInstanceId = task.getProcessInstanceId();
// 6.使用实例id，获取流程实例对象
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery()
                 .processInstanceId(processInstanceId)
                 .singleResult();
// 7.使用processInstance，得到 businessKey
String businessKey = processInstance.getBusinessKey();
System.out.println("businessKey=="+businessKey);

4.2办理任务权限判断

在实际应用中，完成任务前需要校验任务的负责人是否具有该任务的办理权限。

@Test
public void completTask() {
//任务id
String taskId = "15005";
// 任务负责人
String assingee = "张三";
//获取processEngine
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 创建TaskService
TaskService taskService = processEngine.getTaskService();
// 完成任务前，需要校验该负责人可以完成当前任务
// 校验方法：
// 根据任务id和任务负责人查询当前任务，如果查到该用户有权限，就完成
Task task = taskService.createTaskQuery()
.taskId(taskId)
.taskAssignee(assingee)
.singleResult();
if(task != null){
taskService.complete(taskId);
System.out.println("完成任务");
}
}

4.流程变量

场景：在出差申请流程流转时如果出差天数大于 3 天则由总经理审核，否则由人事直接审核，出差天数就可以设置为流程变量，在流程流转时使用

4.1流程变量类型

如果将 pojo 存储到流程变量中，必须实现序列化接口 serializable，为了防止由于新增字段无法反序列化，需要生成 serialVersionUID。
在这里插入图片描述

4.2代码演示

Pojo实体类

package com.bobo.activiti.pojo;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * 出差申请的POJO对象
 */
@Data
public class Evection implements Serializable {

    private long id; //流程id

    private String evectionName; //流程名字


    /**
     * 出差的天数
     */
    private double num;

    private Date beginDate;

    private Date endDate;

    private String destination; //目的地

    private String reson; //理由
}

package com.bobo.activiti.test;

import com.bobo.activiti.pojo.Evection;
import org.activiti.engine.*;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;

import java.util.HashMap;
import java.util.Map;

public class Test05Variable {

    @Test
    public void test01() {
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = engine.getRepositoryService();
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("activiti/evection-variable.bpmn20.xml")
                .addClasspathResource("activiti/variable.png")
                .name("出差申请流程-流程变量")
                .deploy();//部署流程
        System.out.println("流程部署的id:" + deploy.getId());
        System.out.println("流程部署的名称：" + deploy.getName());
    }

    /**
     * 2.启动流程，设置流程变量
     * task任务里面就有一行这样的数据
     */
    @Test
    public void test02() {
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = engine.getRuntimeService();
        //流程key
        String key = "evection-variable";
        //创建变量集合
        Map<String, Object> variables = new HashMap<String, Object>();
        //创建出差对象
        Evection evection = new Evection();
        //设置出差天数
        evection.setNum(4d);
        //将流程变量注入到集合中
        variables.put("evection", evection);
        //设置assignee
        variables.put("assignee0", "张三");
        variables.put("assignee1", "李四");
        variables.put("assignee2", "王五");
        variables.put("assignee3", "赵财务");

        //执行流程实例
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key, variables);
        //输出信息
        System.out.println("获取流程实例名称：" + processInstance.getName());
        System.out.println("流程定义ID：" + processInstance.getProcessDefinitionId());

    }

    /**
     * 完成任务
     */
    @Test
    public void test03() {
        String key = "evection-variable";
        String assignee = "李四";
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key) //流程定义的id
                .taskAssignee(assignee) //设置任务的人
                .singleResult();//单个执行

        if (task != null) {
            taskService.complete(task.getId());
            System.out.println("任务执行完成...");
        }
        System.out.println("任务为空");
    }

    /**
     * 启动流程实例，设置流程变量
     */
    @Test
    public void test04() {
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = engine.getRuntimeService();
// 流程定义key
        String key = "evection-variable";
// 创建变量集合
        Map<String, Object> variables = new HashMap<String, Object>();
// 设置assignee的取值
        variables.put("assignee0", "张三1");
        variables.put("assignee1", "李四1");
        variables.put("assignee2", "王五1");
        variables.put("assignee3", "赵财务1");
        ProcessInstance processInstance =
                runtimeService.startProcessInstanceByKey(key, variables);
// 输出信息
        System.out.println("获取流程实例名称：" + processInstance.getName());
        System.out.println("流程定义ID：" + processInstance.getProcessDefinitionId());
    }

    /**
     * 完成任务
     */
    @Test
    public void test05(){
        String key="evection-variable";
        String assignee="李四1";
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        //得到单个任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key) //流程定义的key
                .taskAssignee(assignee) //任务的人
                .singleResult();

        Map<String,Object> variables=new HashMap<String, Object>();
        //创建出差对象
        Evection evection = new Evection();
        evection.setNum(4d);
        //将对象注入到流程变量的map中
        variables.put("evection",evection);

        if(task!=null){
            taskService.complete(task.getId(),variables);
            System.out.println("任务执行完成...");
        }
        System.out.println("任务为空");

    }
}

local变量的使用

package com.bobo.activiti.test;

import com.bobo.activiti.pojo.Evection;
import org.activiti.engine.*;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;

import java.util.HashMap;
import java.util.Map;

public class Test06Variable {

    @Test
    public void test01() {
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = engine.getRepositoryService();
        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("activiti/evection-variable.bpmn20.xml")
                .addClasspathResource("activiti/variable.png")
                .name("出差申请流程-流程变量")
                .deploy();//部署流程
        System.out.println("流程部署的id:" + deploy.getId());
        System.out.println("流程部署的名称：" + deploy.getName());
    }

    /**
     * 2.启动流程，设置流程变量
     * task任务里面就有一行这样的数据
     */
    @Test
    public void test02() {
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = engine.getRuntimeService();
        //流程key
        String key = "evection-variable";
        //创建变量集合
        Map<String, Object> variables = new HashMap<String, Object>();
        //创建出差对象
        Evection evection = new Evection();
        //设置出差天数
        evection.setNum(4d);
        //将流程变量注入到集合中
        variables.put("evection", evection);
        //设置assignee
        variables.put("assignee0", "张三");
        variables.put("assignee1", "李四");
        variables.put("assignee2", "王五");
        variables.put("assignee3", "赵财务");

        //执行流程实例
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(key, variables);
        //输出信息
        System.out.println("获取流程实例名称：" + processInstance.getName());
        System.out.println("流程定义ID：" + processInstance.getProcessDefinitionId());

    }

    /**
     * 完成任务
     */
    @Test
    public void test03() {
        String key = "evection-variable";
        String assignee = "李四";
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key) //流程定义的id
                .taskAssignee(assignee) //设置任务的人
                .singleResult();//单个执行

        if (task != null) {
            taskService.complete(task.getId());
            System.out.println("任务执行完成...");
        }
        System.out.println("任务为空");
    }

    /**
     * 启动流程实例，设置流程变量
     */
    @Test
    public void test04() {
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = engine.getRuntimeService();
// 流程定义key
        String key = "evection-variable";
// 创建变量集合
        Map<String, Object> variables = new HashMap<String, Object>();
// 设置assignee的取值
        variables.put("assignee0", "张三1");
        variables.put("assignee1", "李四1");
        variables.put("assignee2", "王五1");
        variables.put("assignee3", "赵财务1");
        ProcessInstance processInstance =
                runtimeService.startProcessInstanceByKey(key, variables);
// 输出信息
        System.out.println("获取流程实例名称：" + processInstance.getName());
        System.out.println("流程定义ID：" + processInstance.getProcessDefinitionId());
    }

    /**
     * 完成任务后绑定流程变量，而不是在启动流程实例的时候指定
     */
    @Test
    public void test05() {
        String key = "evection-variable";
        String assignee = "李四1";
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        //得到单个任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key) //流程定义的key
                .taskAssignee(assignee) //任务的人
                .singleResult();

        Map<String, Object> variables = new HashMap<String, Object>();
        //创建出差对象
        Evection evection = new Evection();
        evection.setNum(4d);
        //将对象注入到流程变量的map中
        variables.put("evection", evection);

        if (task != null) {
            taskService.complete(task.getId(), variables);
            System.out.println("任务执行完成...");
        }
        System.out.println("任务为空");

    }

    /**
     * 变量与变量之间是隔离的，任务办理的时候完成——>设置local流程变量，只在当前运行的流程实例使用
     */
    @Test
    public void completTask(){
        //1.定义流程的定义id和执行的人
        String key="evection-variable";
        String assignee="王五";
        //2.得到TaskService
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        //3.定义流程变量
        HashMap<String, Object> map = new HashMap<String, Object>();
        Evection evection = new Evection();
        evection.setNum(4d);
        map.put("evection",evection);
        //4.得到任务实例
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(assignee)
                .singleResult();
        //5.设置local变量
        taskService.setVariablesLocal(task.getId(),map);
        //6.执行任务
        if (task != null) {
            taskService.complete(task.getId());
            System.out.println("任务执行完成...");
        }

    }
}

5.组任务

在流程定义中在任务结点的 assignee 固定设置任务负责人，在流程定义时将参与者固定设置在.bpmn
文件中，如果临时任务负责人变更则需要修改流程定义，系统可扩展性差。
针对这种情况可以给任务设置多个候选人，可以从候选人中选择参与者来完成任务。

bpmn20.xml文件：
我们可以看到部门经理的审核人已经设置为 lisi,wangwu 这样的一组候选人，可以使用activiti:candiateUsers=”用户 1,用户 2,用户 3”的这种方式来实现设置一组候选人

5.2组任务办理流程：

a、查询组任务
指定候选人，查询该候选人当前的待办任务。
候选人不能立即办理任务。
b、拾取(claim)任务
该组任务的所有候选人都能拾取。
将候选人的组任务，变成个人任务。原来候选人就变成了该任务的负责人。
如果拾取后不想办理该任务？
需要将已经拾取的个人任务归还到组里边，将个人任务变成了组任务。
c、查询个人任务
查询方式同个人任务部分，根据assignee查询用户负责的个人任务。

<userTask activiti:candidateUsers="lisi,wangwu" activiti:exclusive="true"
id="_3" name="经理审批"/>
d、办理个人任

package com.bobo.activiti.test;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngines;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.junit.Test;

import java.util.List;

public class Test07Group {

    /**
     * 3.根据候选人查询组任务
     */
    @Test
    public void test03() {
        String key = "evection1";
        String candidateUser = "lisi";
        //1.得到TaskService
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        //2.去查询指定条件下所有的Task
        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey(key) //流程定义的key
                .taskCandidateUser(candidateUser) //候选人
                .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());
        }
    }

    /**
     * 候选人：拾取任务
     */
    public void test04(){
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = defaultProcessEngine.getTaskService();
        String key = "evection1";
        String candidateUser = "lisi";
        //拾取任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskCandidateUser(candidateUser)
                .singleResult();
        if(task!=null){
            //可以拾取任务，任务变成自己的任务
            taskService.claim(task.getId(),candidateUser);
            System.out.println("拾取成功");
        }
    }

    /**
     * 完成个人任务
     */
    @Test
    public void test05(){
        String key = "evection-variable";
        String candidateUser = "lisi";
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        //根据流程定义key得到任务
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .singleResult();
        //验证一下任务目前到哪里来了：发现在赵财务
        if(task!=null){
            System.out.println(task.getId()+":"+task.getAssignee());
        }
        //我们完成当前任务
        taskService.complete(task.getId());
        System.out.println("完成任务");
    }

    /**
     * 归还任务
     */
    @Test
    public void test06(){
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        String key = "evection-variable";
        String candidateUser = "lisi";
        //根据流程定义key和用户得到当前的task
        Task task = taskService.createTaskQuery()
                .processDefinitionKey(key)
                .taskAssignee(candidateUser)
                .singleResult();
        if(task!=null){
            //先输出当前任务负责人
            System.out.println(task.getId()+":"+task.getAssignee());
            taskService.setAssignee(task.getId(),null);
        }
    }

    /**
     * 任务交接
     */
    @Test
    public void test07() {
        ProcessEngine engine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = engine.getTaskService();
        String taskId = "75002";
        String userId = "zhangsan";
        Task task = taskService.createTaskQuery()
                .taskId(taskId)
                .taskAssignee(userId)
                .singleResult();
        if (task != null) {
// 设置该任务的新的负责人
            taskService.setAssignee(taskId, "赵六");
        }
    }
}