码迷，mamicode.com
首页 > 其他好文 > 详细

Activiti学习记录(五)

时间：2018-07-12 20:13:19      阅读：205      评论：0      收藏：0      [点我收藏+]

标签：tde   var   NPU   ssi   其他   经理   3.1   key   links   

1.排他网关

技术分享图片

说明：

1) 一个排他网关对应一个以上的顺序流

2) 由排他网关流出的顺序流都有个conditionExpression元素，在内部维护返回boolean类型的决策结果。

3) 决策网关只会返回一条结果。当流程执行到排他网关时，流程引擎会自动检索网关出口，从上到下检索如果发现第一条决策结果为true或者没有设置条件的(默认为成立)，则流出。

4) 如果没有任何一个出口符合条件，则抛出异常

使用流程变量，设置连线的条件，并按照连线的条件执行工作流，如果没有条件符合的条件，则以默认的连线离开。例如

技术分享图片

则执行连线：

技术分享图片

如果使用流程变量设置

技术分享图片

则执行连线：

 技术分享图片

2.并行网关

说明：

1） 一个流程中流程实例只有1个，执行对象有多个

2） 并行网关的功能是基于进入和外出的顺序流的：

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

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

3） 并行网关的进入和外出都是使用相同节点标识

4） 如果同一个并行网关有多个进入和多个外出顺序流， 它就同时具有分支和汇聚功能。 这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。

5） 并行网关不会解析条件。 即使顺序流中定义了条件，也会被忽略。

6）并行网关不需要是“平衡的”（比如， 对应并行网关的进入和外出节点数目不一定相等）。如图中标示是合法的：

 

技术分享图片

3.开始活动节点

流程图：

技术分享图片

3.1部署流程定义+启动流程实例+查询流程实例+查询历史流程实例

    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    
    /**
     * 部署流程定义
     */
    @Test
    public void deployProcessDefinition() {
        InputStream inputStream = this.getClass().getResourceAsStream("start.bpmn");
        InputStream inputStreamPic = this.getClass().getResourceAsStream("start.png");
        Deployment deploy = processEngine.getRepositoryService().createDeployment().name("开始节点")
                     .addInputStream("start.bpmn", inputStream)
                     .addInputStream("start.png", inputStreamPic)
                     .deploy();
        System.out.println("部署ID:"+deploy.getId());
        System.out.println("部署名称:"+deploy.getName());
    }
    
    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        String processDefinitionKey = "start";
        ProcessInstance startProcessInstanceByKey = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey);
        System.out.println("流程实例ID:"+startProcessInstanceByKey.getId());
        System.out.println("流程定义ID:"+startProcessInstanceByKey.getProcessDefinitionId());
        /**判断流程是否接受,查询正在执行的执行对象表**/
        ProcessInstance pi = processEngine.getRuntimeService()
                     .createProcessInstanceQuery()
                     .processInstanceId(startProcessInstanceByKey.getId())
                     .singleResult();
        //说明流程实例结束了
        if (pi == null) {
            /**查询历史，获取流程的相关信息**/
            HistoricProcessInstance hpi = processEngine.getHistoryService()
                         .createHistoricProcessInstanceQuery()
                         .processInstanceId(startProcessInstanceByKey.getId())
                         .singleResult();
            System.out.println(hpi.getId()+"   "+hpi.getStartTime()+"   "+hpi.getEndTime());
        }
        
    }
}

1）：结束节点没有出口

2）：其他节点有一个或多个出口。

如果有一个出口，则代表是一个单线流程；

如果有多个出口，则代表是开启并发流程。

 4.接收任务

接收任务是一个简单任务，它会等待对应消息的到达。 当前，官方只实现了这个任务的java语义。 当流程达到接收任务，流程状态会保存到数据库中。

在任务创建后，意味着流程会进入等待状态， 直到引擎接收了一个特定的消息， 这会触发流程穿过接收任务继续执行。

流程图：

技术分享图片技术分享图片

 

4.1 部署流程定义+启动流程实例

 

/**
     * ReceiceTask任务，机器自动完成的任务
     * 只会在act_ru_execution表中产生一条数据
     * @throws Exception
     */
    
    @Test
    public void testExecution() throws Exception {
        // 1 发布流程
        InputStream inputStreamBpmn = this.getClass().getResourceAsStream("receiveTask.bpmn");
        InputStream inputStreamPng = this.getClass().getResourceAsStream("receiveTask.png");
        processEngine.getRepositoryService()//
                        .createDeployment()//
                        .addInputStream("receiveTask.bpmn", inputStreamBpmn)//
                        .addInputStream("receiveTask.png", inputStreamPng)//
                        .deploy();
        
        // 2 启动流程
        ProcessInstance pi = processEngine.getRuntimeService()//
                            .startProcessInstanceByKey("receiveTaskDemo");
        System.out.println("pid:" + pi.getId());
        String pid = pi.getId();
        
        // 3查询是否有一个执行对象在描述”汇总当日销售额“
        Execution e1 = processEngine.getRuntimeService()//
                        .createExecutionQuery()//
                        .processInstanceId(pid)//
                        .activityId("汇总当日销售额")//
                        .singleResult();

        // 4执行一堆逻辑，并设置流程变量
        Map<String,Object> vars = new HashMap<String, Object>();
        vars.put("当日销售额", 10000);
        //  5流程向后执行一步：往后推移e1,使用signal给流程引擎信号，告诉他当前任务已经完成了，可以往后执行
        processEngine.getRuntimeService()
                .signal(e1.getId(),vars);
        
        // 6判断当前流程是否在”给老板发短信“节点
        Execution e2 = processEngine.getRuntimeService()//
                        .createExecutionQuery()//
                        .processInstanceId(pid)//
                        .activityId("给总经理发短信")//
                        .singleResult();
        
        // 7获取流程变量
        Integer money = (Integer) processEngine.getRuntimeService()//
                                .getVariable(e2.getId(), "当日销售额");
        System.out.println("老板，今天赚了" +money);
        // 8向后执行一步：任务完成，往后推移”给老板发短信“任务
        processEngine.getRuntimeService()//
                .signal(e2.getId());
        
        
        // 9查询流程状态
        pi = processEngine.getRuntimeService()//
                        .createProcessInstanceQuery()//
                        .processInstanceId(pid)//
                        .singleResult();
        if(pi==null){
                System.out.println("流程正常执行！！！，已经结束了");
        }
    }

 

说明：

1） 当前任务（一般指机器自动完成，但需要耗费一定时间的工作）完成后，向后推移流程，可以调用runtimeService.signal(executionId)，传递接收执行对象的id。

5. 用户任务（userTask，即用户操作的任务）

5.1 个人任务

5.1.1 流程图

技术分享图片

5.1.2 分配个人任务方式一（直接指定办理人）

 

流程图中任务节点的配置

 

技术分享图片

 

测试代码：

    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    /**
     * 部署流程定义
     */
    @Test
    public void deployProcessDefinition() {
        InputStream inputStream = this.getClass().getResourceAsStream("personalTask.bpmn");
        InputStream inputStreamPic = this.getClass().getResourceAsStream("personalTask.png");
        Deployment deploy = processEngine.getRepositoryService().createDeployment().name("个人任务")
                     .addInputStream("personalTask.bpmn", inputStream)
                     .addInputStream("personalTask.png", inputStreamPic)
                     .deploy();
        System.out.println("部署ID:"+deploy.getId());
        System.out.println("部署名称:"+deploy.getName());
    }
    /**
     * 启动流程实例,设置流程变量+获取流程变量+向后执行一步
     */
    @Test
    public void startProcessInstance() {
        String processDefinitionKey = "personTask";
        ProcessInstance startProcessInstanceByKey = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey);
        System.out.println("流程实例ID:"+startProcessInstanceByKey.getId());
        System.out.println("流程定义ID:"+startProcessInstanceByKey.getProcessDefinitionId());
    }
    /**
     * 查询个人任务
     */
    @Test
    public void findMyProcess() {
        String assignee = "张三丰";
        List<Task> list = processEngine.getTaskService().createTaskQuery().taskAssignee(assignee).list();
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                System.out.println("任务ID:"+task.getId());
                System.out.println("任务名称:"+task.getName());
                System.out.println("任务创建时间:"+task.getCreateTime());
                System.out.println("任务办理人:"+task.getAssignee());
                System.out.println("流程实例ID:"+task.getProcessInstanceId());
                System.out.println("执行对象ID:"+task.getExecutionId());
                System.out.println("流程定义ID:"+task.getProcessDefinitionId());
            }
        }
    }
    /**
     * 完成个人任务
     */
    @Test
    public void completMyProcess() {
        String taskId = "5304";
        Map<String, Object> map = new HashMap<>();
        processEngine.getTaskService().complete(taskId);
    }
}

5.1.3 分配个人任务方式二（使用流程变量）

 流程图中任务节点的配置

 技术分享图片

测试代码

 

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    /**
     * 部署流程定义
     */
    @Test
    public void deployProcessDefinition() {
        InputStream inputStream = this.getClass().getResourceAsStream("personalTask.bpmn");
        InputStream inputStreamPic = this.getClass().getResourceAsStream("personalTask.png");
        Deployment deploy = processEngine.getRepositoryService().createDeployment().name("个人任务")
                     .addInputStream("personalTask.bpmn", inputStream)
                     .addInputStream("personalTask.png", inputStreamPic)
                     .deploy();
        System.out.println("部署ID:"+deploy.getId());
        System.out.println("部署名称:"+deploy.getName());
    }
    /**
     * 启动流程实例,设置流程变量+获取流程变量+向后执行一步
     */
    @Test
    public void startProcessInstance() {
        String processDefinitionKey = "personTask";
        Map<String, Object> variables = new HashMap<>();
        variables.put("userId", "周芷若");
        ProcessInstance startProcessInstanceByKey = processEngine.getRuntimeService()
                                                                 .startProcessInstanceByKey(processDefinitionKey,variables);//在启动实例时，设置流程变量
        System.out.println("流程实例ID:"+startProcessInstanceByKey.getId());
        System.out.println("流程定义ID:"+startProcessInstanceByKey.getProcessDefinitionId());
    }
    /**
     * 查询个人任务
     */
    @Test
    public void findMyProcess() {
        String assignee = "张三丰";
        List<Task> list = processEngine.getTaskService().createTaskQuery().taskAssignee(assignee).list();
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                System.out.println("任务ID:"+task.getId());
                System.out.println("任务名称:"+task.getName());
                System.out.println("任务创建时间:"+task.getCreateTime());
                System.out.println("任务办理人:"+task.getAssignee());
                System.out.println("流程实例ID:"+task.getProcessInstanceId());
                System.out.println("执行对象ID:"+task.getExecutionId());
                System.out.println("流程定义ID:"+task.getProcessDefinitionId());
            }
        }
    }
    /**
     * 完成个人任务
     */
    @Test
    public void completMyProcess() {
        String taskId = "5605";
        Map<String, Object> map = new HashMap<>();
        processEngine.getTaskService().complete(taskId);
    }

 

5.1.4 分配个人任务方式三（使用类）

 

 1.流程图中任务节点的配置

技术分享图片

技术分享图片

2.TaskListenerImpl类，用来设置任务的办理人

    /**
     * 用来指定任务的办理人
     */
    @Override
    public void notify(DelegateTask delegateTask) {
        // TODO Auto-generated method stub
        //指定个人任务的办理人，也可以指定组任务的办理人
        //个人任务通过类去查询数据库,将下一个任务的办理人查询获取，然后通过setAssignee()方法指定任务的办理人
        delegateTask.setAssignee("灭绝师太");

    }

3.测试代码

 

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    /**
     * 部署流程定义
     */
    @Test
    public void deployProcessDefinition() {
        InputStream inputStream = this.getClass().getResourceAsStream("personalTask.bpmn");
        InputStream inputStreamPic = this.getClass().getResourceAsStream("personalTask.png");
        Deployment deploy = processEngine.getRepositoryService().createDeployment().name("个人任务")
                     .addInputStream("personalTask.bpmn", inputStream)
                     .addInputStream("personalTask.png", inputStreamPic)
                     .deploy();
        System.out.println("部署ID:"+deploy.getId());
        System.out.println("部署名称:"+deploy.getName());
    }
    /**
     * 启动流程实例,设置流程变量+获取流程变量+向后执行一步
     */
    @Test
    public void startProcessInstance() {
        String processDefinitionKey = "personTask";
        /*Map<String, Object> variables = new HashMap<>();
        variables.put("userId", "周芷若");*/
        ProcessInstance startProcessInstanceByKey = processEngine.getRuntimeService()
                                                                 .startProcessInstanceByKey(processDefinitionKey);//在启动实例时，设置流程变量
        System.out.println("流程实例ID:"+startProcessInstanceByKey.getId());
        System.out.println("流程定义ID:"+startProcessInstanceByKey.getProcessDefinitionId());
    }

　　 /**可以分配个人任务从一个人到另一个人(认领任务)**/
    @Test
    public void setAssigneeTask() {
        //任务ID
        String taskId = "6104";
        //指定的办理人
        String userId = "张翠山";
        processEngine.getTaskService()
                     .setAssignee(taskId, userId);
    }

 

说明：

1） 在类中使用delegateTask.setAssignee(assignee);的方式分配个人任务的办理人，此时张无忌是下一个任务的办理人

2） 通过processEngine.getTaskService().setAssignee(taskId, userId);将个人任务从一个人分配给另一个人，此时张无忌不再是下一个任务的办理人，而换成了周芷若

3） 在开发中，可以将每一个任务的办理人规定好，例如张三的领导是李四，李四的领导是王五，这样张三提交任务，就可以查询出张三的领导是李四，通过类的方式设置下一个任务的办理人

 

5.1.5 总结

个人任务及三种分配方式：

    1：在taskProcess.bpmn中直接写 assignee=“张三丰"

    2：在taskProcess.bpmn中写 assignee=“#{userID}”，变量的值要是String的。

         使用流程变量指定办理人

    3，使用TaskListener接口，要使类实现该接口，在类中定义：

         delegateTask.setAssignee(assignee);// 指定个人任务的办理人

    

 使用任务ID和办理人重新指定办理人：

     processEngine.getTaskService()//

                           .setAssignee(taskId, userId);

 

6 组任务

6.1 流程图

技术分享图片

 

6.2 分配组任务方式一（直接指定办理人）

1.流程图中任务节点的配置

技术分享图片

2.测试代码：

 

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    
    /**
     * 部署流程定义
     */
    @Test
    public void deployProcessDefinition() {
        InputStream inputStream = this.getClass().getResourceAsStream("groupTask.bpmn");
        InputStream inputStream2 = this.getClass().getResourceAsStream("groupTask.png");
        Deployment deploy = processEngine.getRepositoryService().createDeployment().name("组任务")
                     .addInputStream("groupTask.bpmn", inputStream)
                     .addInputStream("groupTask.png", inputStream2)
                     .deploy();
        System.out.println("部署ID:"+deploy.getId());
        System.out.println("部署名称:"+deploy.getName());
        
    }
    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        String processDefinitionKey = "groupTask";
        ProcessInstance startProcessInstanceByKey = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey);
        System.out.println("流程实例ID:"+startProcessInstanceByKey.getId());
        System.out.println("流程定义ID:"+startProcessInstanceByKey.getProcessDefinitionId());
    }
    /**
     * 查询当前人的组任务
     */
    @Test
    public void findMyGroupProcess() {
        String candidateUser = "小A";
        List<Task> list = processEngine.getTaskService().createTaskQuery()
                     .taskCandidateUser(candidateUser)
                     .orderByTaskCreateTime().desc().list();
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                System.out.println("任务ID:"+task.getId());
                System.out.println("任务名称:"+task.getName());
                System.out.println("任务创建时间:"+task.getCreateTime());
                System.out.println("任务办理人:"+task.getAssignee());
                System.out.println("流程实例ID:"+task.getProcessInstanceId());
                System.out.println("执行对象ID:"+task.getExecutionId());
                System.out.println("流程定义ID:"+task.getProcessDefinitionId());
            }
        }

    }
    /**
     * 查询正在执行的组任务办理人表
     */
    @Test
    public void findRunPersonTask() {
        String taskId = "7104";
        List<IdentityLink> list = processEngine.getTaskService()
                     .getIdentityLinksForTask(taskId);
        if (list != null && list.size() > 0) {
            for (IdentityLink identityLink : list) {
                System.out.println(identityLink.getTaskId()+"  "+identityLink.getType()+"  "+identityLink.getUserId()+"  "+identityLink.getProcessInstanceId());
            }
        }
    }
    /**
     * 查询历史的组任务办理人表
     */
    @Test
    public void findHistoryPersonTask() {
        String processInstanceId = "7101";
        List<HistoricIdentityLink> list = processEngine.getHistoryService()
                     .getHistoricIdentityLinksForProcessInstance(processInstanceId);
        if (list != null && list.size() > 0) {
            for (HistoricIdentityLink hil : list) {
                System.out.println(hil.getTaskId()+"  "+hil.getType()+"  "+hil.getUserId()+"  "+hil.getProcessInstanceId());
            }
        }
    }
    /**
     * 拾取任务，将组任务分给个人任务，指定任务的办理人字段
     */
    @Test
    public void claim() {
        String taskId = "7104";
        String userId = "小A";
        //分配个人任务(可以是组任务中的成员，也可以是非组任务的成员)
        processEngine.getTaskService().claim(taskId, userId);
    }
    /**
     * 拾取任务，将个人任务回退到组任务，数据执勤一定是个组任务
     */
    @Test
    public void setAssginee() {
        String taskId = "7104";
        String userId = "大F";
        //分配个人任务(可以是组任务中的成员，也可以是非组任务的成员)
        processEngine.getTaskService().setAssignee(taskId, null);
    }
    /**
     * 向组任务添加成员
     */
    @Test
    public void addGroupUser() {
        String taskId = "7104";
        String userId = "大H"; 
        processEngine.getTaskService().addCandidateUser(taskId, userId);
    }
    /**
     * 向组任务删除成员
     */
    @Test
    public void delGroupUser() {
        String taskId = "7104";
        String userId = "大H"; 
        processEngine.getTaskService().deleteCandidateUser(taskId, userId);
    }
    /**
     * 完成任务
     */
    @Test
    public void completProcessTask() {
        String taskId = "7104";
        processEngine.getTaskService().complete(taskId);
    }

 

说明：

1） 小A，小B，小C，小D是组任务的办理人

2） 但是这样分配组任务的办理人不够灵活，因为项目开发中任务的办理人不要放置XML文件中。

3） act_ru_identitylink表存放任务的办理人，包括个人任务和组任务，表示正在执行的任务

4） act_hi_identitylink表存放任务的办理人，包括个人任务和组任务，表示历史任务

区别在于：如果是个人任务TYPE的类型表示participant（参与者）

 如果是组任务TYPE的类型表示candidate（候选者）和participant（参与者）

技术分享图片

6.2 分配个人任务方式二（使用流程变量）

 1.流程图中任务节点的配置

 技术分享图片

2.测试代码

/**
     * 部署流程定义
     */
    @Test
    public void deployProcessDefinition() {
        InputStream inputStream = this.getClass().getResourceAsStream("groupTask.bpmn");
        InputStream inputStream2 = this.getClass().getResourceAsStream("groupTask.png");
        Deployment deploy = processEngine.getRepositoryService().createDeployment().name("组任务")
                     .addInputStream("groupTask.bpmn", inputStream)
                     .addInputStream("groupTask.png", inputStream2)
                     .deploy();
        System.out.println("部署ID:"+deploy.getId());
        System.out.println("部署名称:"+deploy.getName());
        
    }
    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        String processDefinitionKey = "groupTask";
        Map<String, Object> variables = new HashMap<>();
        variables.put("userIds", "大大,中中,小小");
        ProcessInstance startProcessInstanceByKey = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey,variables);
        System.out.println("流程实例ID:"+startProcessInstanceByKey.getId());
        System.out.println("流程定义ID:"+startProcessInstanceByKey.getProcessDefinitionId());
    }
        /**
     * 拾取任务，将组任务分给个人任务，指定任务的办理人字段
     */
    @Test
    public void claim() {
        String taskId = "7805";
        String userId = "大大";
        //分配个人任务(可以是组任务中的成员，也可以是非组任务的成员)
        processEngine.getTaskService().claim(taskId, userId);
    }        
    /**
     * 完成任务
     */
    @Test
    public void completProcessTask() {
        String taskId = "7805";
        processEngine.getTaskService().complete(taskId);
    }

说明：

1） 大大，中中，小小是组任务的办理人

在开发中，可以在页面中指定下一个组任务的办理人，通过流程变量设置下一个任务的办理人

 

6.2 分配个人任务方式三（使用类）

1.流程图中任务节点的配置

技术分享图片

技术分享图片

2.TaskListenerImpl类，用来设置任务的办理人

 

@Override
    public void notify(DelegateTask delegateTask) {
        // TODO Auto-generated method stub
        //组任务：
        delegateTask.addCandidateUser("郭靖");
        delegateTask.addCandidateUser("黄蓉");
    }

 

3.测试代码

 

/**
     * 部署流程定义
     */
    @Test
    public void deployProcessDefinition() {
        InputStream inputStream = this.getClass().getResourceAsStream("groupTask.bpmn");
        InputStream inputStream2 = this.getClass().getResourceAsStream("groupTask.png");
        Deployment deploy = processEngine.getRepositoryService().createDeployment().name("组任务")
                     .addInputStream("groupTask.bpmn", inputStream)
                     .addInputStream("groupTask.png", inputStream2)
                     .deploy();
        System.out.println("部署ID:"+deploy.getId());
        System.out.println("部署名称:"+deploy.getName());
        
    }
    /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        String processDefinitionKey = "groupTask";
        /*Map<String, Object> variables = new HashMap<>();
        variables.put("userIds", "大大,中中,小小");*/
        ProcessInstance startProcessInstanceByKey = processEngine.getRuntimeService().startProcessInstanceByKey(processDefinitionKey);
        System.out.println("流程实例ID:"+startProcessInstanceByKey.getId());
        System.out.println("流程定义ID:"+startProcessInstanceByKey.getProcessDefinitionId());
    }
    /**
     * 查询当前人的组任务
     */
    @Test
    public void findMyGroupProcess() {
        String candidateUser = "郭靖";
        List<Task> list = processEngine.getTaskService().createTaskQuery()
                     .taskCandidateUser(candidateUser)
                     .orderByTaskCreateTime().desc().list();
        if (list != null && list.size() > 0) {
            for (Task task : list) {
                System.out.println("任务ID:"+task.getId());
                System.out.println("任务名称:"+task.getName());
                System.out.println("任务创建时间:"+task.getCreateTime());
                System.out.println("任务办理人:"+task.getAssignee());
                System.out.println("流程实例ID:"+task.getProcessInstanceId());
                System.out.println("执行对象ID:"+task.getExecutionId());
                System.out.println("流程定义ID:"+task.getProcessDefinitionId());
            }
        }

    }
        /**
     * 拾取任务，将组任务分给个人任务，指定任务的办理人字段
     */
    @Test
    public void claim() {
        String taskId = "8104";
        String userId = "郭靖";
        //分配个人任务(可以是组任务中的成员，也可以是非组任务的成员)
        processEngine.getTaskService().claim(taskId, userId);
    }  
        /**
     * 完成任务
     */
    @Test
    public void completProcessTask() {
        String taskId = "8104";
        processEngine.getTaskService().complete(taskId);
    }

 

说明：

1） 在类中使用delegateTask.addCandidateUser (userId);的方式分配组任务的办理人，此时孙悟空和猪八戒是下一个任务的办理人。

2） 通过processEngine.getTaskService().claim (taskId, userId);将组任务分配给个人任务，也叫认领任务，即指定某个人去办理这个任务，此时由如来去办理任务。

注意：认领任务的时候，可以是组任务成员中的人，也可以不是组任务成员的人，此时通过Type的类型为participant来指定任务的办理人

3） addCandidateUser()即向组任务添加成员，deleteCandidateUser()即删除组任务的成员。

4） 在开发中，可以将每一个任务的办理人规定好，例如张三的领导是李四和王五，这样张三提交任务，由李四或者王五去查询组任务，可以看到对应张三的申请，李四或王五再通过认领任务（claim）的方式，由某个人去完成这个任务。

 

 

 

 6.2 总结

组任务及三种分配方式：

    1：在taskProcess.bpmn中直接写 candidate-users=“小A,小B,小C,小D"

    2：在taskProcess.bpmn中写 candidate-users =“#{userIDs}”，变量的值要是String的。

         使用流程变量指定办理人

              Map<String, Object> variables = new HashMap<String, Object>();

              variables.put("userIDs", "大大,小小,中中");

    3，使用TaskListener接口，使用类实现该接口，在类中定义：

            //添加组任务的用户

delegateTask.addCandidateUser(userId1);

delegateTask.addCandidateUser(userId2);

组任务分配给个人任务（认领任务）：

     processEngine.getTaskService().claim(taskId, userId);

个人任务分配给组任务：

     processEngine.getTaskService(). setAssignee(taskId, null);

向组任务添加人员：

     processEngine.getTaskService().addCandidateUser(taskId, userId);

向组任务删除人员：

     processEngine.getTaskService().deleteCandidateUser(taskId, userId);

个人任务和组任务存放办理人对应的表：

act_ru_identitylink表存放任务的办理人，包括个人任务和组任务，表示正在执行的任务

act_hi_identitylink表存放任务的办理人，包括个人任务和组任务，表示历史任务

区别在于：如果是个人任务TYPE的类型表示participant（参与者）

 如果是组任务TYPE的类型表示candidate（候选者）和participant（参与者）

 

Activiti学习记录(五)

标签：tde   var   NPU   ssi   其他   经理   3.1   key   links   

原文地址：https://www.cnblogs.com/FanJava/p/9300828.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！