flowable中 processDefinitionkey 和id 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);
    }

Groovy

基于 jvm 的编程语言，，需要 jvm 来跑，，

Juel

juel : java unified expression language 主要在jsp中使用

去执行 bean名字中的 hello() 方法