flowable的Task使用

ReceiveTask
UserTask
ServiceTask
ScriptTask

ReceiveTask

执行到这个ReceiveTask会停下来，需要人工触发一下，才会继续执行

 ClassPathResource classPathResource = new ClassPathResource("processes/ReceiveTaskDemo.bpmn20.xml");
        String filename = classPathResource.getFilename();
        
        // 部署
        Deployment deploy = repositoryService.createDeployment()
                .name("deployment的name")
                .category("category")
                .key("key字段")
                .addInputStream(filename, classPathResource.getInputStream()).deploy();

开启流程定义：

    Authentication.setAuthenticatedUserId("ww");
        ProcessInstance receiveTaskDemo = runtimeService.startProcessInstanceByKey("ReceiveTaskDemo");

得到流程实例 ReceiveTask ，然后trigger

   // 得到这个 ReceiveTask
        List<Execution> list = runtimeService.createExecutionQuery().activityId("send_to_boss").list();

        for (Execution execution : list) {
            // 触发 ReceiveTask
            runtimeService.trigger(execution.getId());
        }

UserTask

设置单个用户

直接指定处理人：硬编码，直接写死
必须要人处理的任务：存在在act_ru_task表中

      // UserTask 存在  act_ru_task

                List<Task> list = taskService.createTaskQuery().taskAssignee("cc").list();
                for (Task task : list) {
                    //  处理掉   或者  交给别人处理
//                    taskService.complete(task.getId());

                    // 为某一个task 设置 处理人
                    taskService.setAssignee(task.getId(),"zs");

                }
            }

通过变量引用
在这里插入图片描述

启动流程实例的时候设置 ${manager} 变量的值

 HashMap<String, Object> map = new HashMap<>();
map.put("manager","ww");
// map传递变量进去
runtimeService.startProcessInstanceByKey("UserTaskDemo", map);

监听器设置
利用监听器，在任务创建的时候设置处理人
在这里插入图片描述

在这里插入图片描述
监听器设置 task 处理人
监听器实现 TaskListener接口：

package com.cj.listener;

import org.flowable.task.service.delegate.DelegateTask;
import org.flowable.task.service.delegate.TaskListener;

public class MyTaskListener implements TaskListener {

    // 任务被创建的时候，这个方法会被触发
    @Override
    public void notify(DelegateTask delegateTask) {
        // 相当于任务的代理
        // 设置任务处理人
        delegateTask.setAssignee("zl");
    }
}

设置为流程发起人
在这里插入图片描述
给UserTask设置处理人的时候，设置为变量，，变量的名称就是发起人设置的变量 initiator

在流程启动的时候，指定流程发起人：

        // 指定发起人
        Authentication.setAuthenticatedUserId("cc");
//        identityService.setAuthenticatedUserId("cc");
        runtimeService.startProcessInstanceByKey("UserTaskDemo");

设置多个用户

指定候选人
在这里插入图片描述
当一个UserTask 有多个用户可以处理的时候，，在act_ru_task 的 assignee 字段为null，，
候选人在 act_ru_identitylink type为candidate。。。记录了任务由哪些人处理

        // 根据候选人查询任务   act_ru_identitylink
        List<Task> list = taskService.createTaskQuery().taskCandidateUser("cc").list();
        for (Task task : list) {
//            System.out.println(task.getIdentityLinks());
            System.out.println(task);
        }

根据流程的id 查询流程参与者：

   // 根据流程实例  查找对应的  执行用户
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId("7dac8e6f-97a2-11ed-a9c5-f0b61e94ce8e").singleResult();
        List<IdentityLink> list = runtimeService.getIdentityLinksForProcessInstance(processInstance.getId());
        for (IdentityLink identityLink : list) {
            System.out.println(identityLink.getUserId());
        }

act_ru_identitylink : 记录了每个任务的候选人，，，，和每一个流程的参与人

认领任务：
已经被认领的任务，，不能再次被认领，，如果你认领了之后又不想去处理，可以使用委派的方式，交给其他人处理

     // 根据候选人查询任务   act_ru_identitylink
        List<Task> list = taskService.createTaskQuery().taskCandidateUser("cc").list();
        for (Task task : list) {
            // 查到任务还需要认领任务，，， 认领的本质就是 act_ru_task 的 assignee 设置值
            // 认领任务
            taskService.claim(task.getId(),"ls");
        }

 // 委派给其他人
 taskService.setAssignee(task.getId(),"ls");
 // 完成任务
 taskService.complete(task.getId());

使用变量或者监听器处理
在这里插入图片描述

    HashMap<String, Object> map = new HashMap<>();
    map.put("userIds","cc,zs,ww");
    runtimeService.startProcessInstanceByKey("UserTaskDemo", map);

public class MyTaskListener implements TaskListener {

    // 任务被创建的时候，这个方法会被触发
    @Override
    public void notify(DelegateTask delegateTask) {
        // 相当于任务的代理
        // 设置任务处理人
//        delegateTask.setAssignee("zl");
        
        // 监听器设置委托人
        delegateTask.addCandidateUser("zs");
        delegateTask.addCandidateUser("ww");
    }
}

任务回退：
已经认领的任务回退，，，让其他人可以认领

   List<Task> list = taskService.createTaskQuery().taskAssignee("ww").list();
    for (Task task : list) {
        // 回退任务   就是将 assignee 设置为 null
        taskService.setAssignee(task.getId(),null);
        // 认领任务
        taskService.claim(task.getId(),"zs");
    }

添加删除候选人：

  List<Task> list = taskService.createTaskQuery().list();
    for (Task task : list) {
        // 添加候选人  act_ru_identitylink
        taskService.addCandidateUser(task.getId(),"ls");
        // 删除候选人
        taskService.deleteCandidateUser(task.getId(),"ww");
    }

设置执行组：
在这里插入图片描述

在根据用户id查找task的时候，会去 act_id_group找到你的组，，然后去act_ru_identitylink找taskId，找act_ru_task

        List<Task> list = taskService.createTaskQuery().taskCandidateUser("ww").list();
        for (Task task : list) {
            System.out.println(task.getName());
        }

        List<Task> list1 = taskService.createTaskQuery().taskCandidateGroup("manager").list();
        for (Task task : list1) {
            System.out.println(task.getName());
            // 先认领，后执行
            taskService.claim(task.getId(),"ww");
            taskService.complete(task.getId());
        }

候选组通过变量来指定：
xml中指定候选组是变量，，在启动实例的时候，将变量的值设置进去，，那么默认的group就是你设置的值

ServiceTask

服务任务，由系统自动完成的任务

首先定义一个 ServiceTask的监听器类，，，实现JavaDelagate接口，，绘制流程图的时候，配置这个监听器类，，，这个监听器类是自动完成的任务
在这里插入图片描述

package com.cj.serviceTask;

import org.flowable.engine.delegate.DelegateExecution;
import org.flowable.engine.delegate.JavaDelegate;
// 自定义监听器类 ，，，ServiceTask执行到这里的时候，会自动执行该类中的 execute()
public class MyServiceTask01 implements JavaDelegate {
    @Override
    public void execute(DelegateExecution execution) {
        System.out.println("======================");
    }
}

ServiceTask 不会操作 act_ru_task 表

为类设置字段：
在这里插入图片描述

在这里插入图片描述
获取字段值：

package com.cj.serviceTask;
import org.flowable.common.engine.api.delegate.Expression;
import org.flowable.engine.delegate.DelegateExecution;
import org.flowable.engine.delegate.JavaDelegate;
// 自定义监听器类 ，，，ServiceTask执行到这里的时候，会自动执行该类中的 execute()
public class MyServiceTask01 implements JavaDelegate {


    Expression username;
    @Override
    public void execute(DelegateExecution execution) {
        // 获取username的值
        System.out.println("username.getExpressionText() = " + username.getExpressionText());
        System.out.println("username.getValue(execution) = " + username.getValue(execution));
        System.out.println("======================");
    }
}

设置委托表达式

委托表达式类似于监听器类，但是这种表达式，，可以将类注册到spring容器中，，在流程图中可以直接配置 bean的名称

在这里插入图片描述

配置的这个bean，，就是实现了JavaDelegate的类实例

表达式
前面两种，都离不开 JavaDelegate接口，，如果就是一个普通的bean，，其实也可以配置成 ServiceTask的执行类。。。

配置表达式：委托表达式配置的bean必须实现JavaDelegate接口
在这里插入图片描述

@Component
public class MyServiceTask02 {
    public void hello(){
        System.out.println("=============hello=============");
    }
}

在这里插入图片描述
表达式不能传递字段，，，传递字段只能在 JavaDelegate中使用

ScriptTask

脚本任务和 ServiceTask 都是自动执行的，，不同的是，脚本任务的逻辑是通过一些非 java 的脚本语言来实现的

JavaScript

在这里插入图片描述

  @Test
    public void test02(){
        HashMap<String, Object> map = new HashMap<>();
        map.put("a",99);
        map.put("b",1);
        runtimeService.startProcessInstanceByKey("ScriptTaskDemo", map);
    }