Activiti进阶（十一）——分配组任务的三种方式

转载地址:http://blog.csdn.net/zjx86320?viewmode=contents

权声明：本文为博主原创文章，未经博主允许不得转载。

     上一篇博客我们讲了分配个人任务的三种方式，这篇博客我们来介绍一下分配组任务的三种方式。


     一、流程图


                                           

                                            图一  分配组任务的三种方式  



     二、分配组任务方式一：直接指定办理人


     1.在任务节点设置办理人


     


     2.测试代码

 

[java] view plain copy
  1. package cn.gome.m_groupTask;  
  2.   
  3. import java.io.InputStream;  
  4. import java.util.HashMap;  
  5. import java.util.List;  
  6. import java.util.Map;  
  7.   
  8. import org.activiti.engine.ProcessEngine;  
  9. import org.activiti.engine.ProcessEngines;  
  10. import org.activiti.engine.history.HistoricIdentityLink;  
  11. import org.activiti.engine.repository.Deployment;  
  12. import org.activiti.engine.runtime.ProcessInstance;  
  13. import org.activiti.engine.task.IdentityLink;  
  14. import org.activiti.engine.task.Task;  
  15. import org.junit.Test;  
  16.   
  17. public class TaskTest {  
  18.   
  19.     // 流程引擎对象  
  20.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
  21.   
  22.     /**部署流程定义+启动流程实例：3905*/  
  23.     @Test  
  24.     public void deployementAndStartProcess() {  
  25.         //1.发布流程  
  26.         InputStream inputStreamBpmn = this.getClass().getResourceAsStream(  
  27.                 "task.bpmn");  
  28.         InputStream inputStreamPng = this.getClass().getResourceAsStream(  
  29.                 "task.png");  
  30.         processEngine.getRepositoryService()//  
  31.                 .createDeployment()//  
  32.                 .addInputStream("task.bpmn", inputStreamBpmn)//  
  33.                 .addInputStream("task.png", inputStreamPng)//  
  34.                 .deploy();  
  35.         //2.启动流程  
  36.         ProcessInstance pi = processEngine.getRuntimeService()//  
  37.                 .startProcessInstanceByKey("task");  
  38.         System.out.println("pid:" + pi.getId());  
  39.   
  40.     }  
  41.   
  42.     /**查询我的个人任务,没有执行结果*/  
  43.     @Test  
  44.     public void findPersonalTaskList() {  
  45.         // 任务办理人  
  46.         String assignee = "小A";  
  47.         List<Task> list = processEngine.getTaskService()//  
  48.                 .createTaskQuery()//  
  49.                 .taskAssignee(assignee)// 个人任务的查询  
  50.                 .list();  
  51.         if (list != null && list.size() > 0) {  
  52.             for (Task task : list) {  
  53.                 System.out.println("任务ID：" + task.getId());  
  54.                 System.out.println("任务的办理人：" + task.getAssignee());  
  55.                 System.out.println("任务名称：" + task.getName());  
  56.                 System.out.println("任务的创建时间：" + task.getCreateTime());  
  57.                 System.out.println("流程实例ID：" + task.getProcessInstanceId());  
  58.                 System.out.println("#######################################");  
  59.             }  
  60.         }  
  61.     }  
  62.   
  63.     /**查询组任务*/  
  64.     @Test  
  65.     public void findGroupTaskList() {  
  66.         // 任务办理人  
  67.         String candidateUser = "小A";  
  68.         List<Task> list = processEngine.getTaskService()//  
  69.                 .createTaskQuery()//  
  70.                 .taskCandidateUser(candidateUser)// 参与者，组任务查询  
  71.                 .list();  
  72.         if (list != null && list.size() > 0) {  
  73.             for (Task task : list) {  
  74.                 System.out.println("任务ID：" + task.getId());  
  75.                 System.out.println("任务的办理人：" + task.getAssignee());  
  76.                 System.out.println("任务名称：" + task.getName());  
  77.                 System.out.println("任务的创建时间：" + task.getCreateTime());  
  78.                 System.out.println("流程实例ID：" + task.getProcessInstanceId());  
  79.                 System.out.println("#######################################");  
  80.             }  
  81.         }  
  82.     }  
  83.   
  84.     /**完成任务*/  
  85.     @Test  
  86.     public void completeTask() {  
  87.         // 任务ID  
  88.         String taskId = "3708";  
  89.         processEngine.getTaskService()//  
  90.                 .complete(taskId);  
  91.         System.out.println("完成任务：" + taskId);  
  92.     }  
  93.   
  94.     /**查询正在执行的组任务列表*/  
  95.     @Test  
  96.     public void findGroupCandidate() {  
  97.         // 任务ID  
  98.         String taskId = "3708";  
  99.         List<IdentityLink> list = processEngine.getTaskService()//  
  100.                 .getIdentityLinksForTask(taskId);  
  101.         if (list != null && list.size() > 0) {  
  102.             for (IdentityLink identityLink : list) {  
  103.                 System.out.println("任务ID：" + identityLink.getTaskId());  
  104.                 System.out.println("流程实例ID："  
  105.                         + identityLink.getProcessInstanceId());  
  106.                 System.out.println("用户ID：" + identityLink.getUserId());  
  107.                 System.out.println("工作流角色ID：" + identityLink.getGroupId());  
  108.                 System.out.println("#########################################");  
  109.             }  
  110.         }  
  111.     }  
  112.   
  113.     /**查询历史的组任务列表*/  
  114.     @Test  
  115.     public void findHistoryGroupCandidate() {  
  116.         // 流程实例ID  
  117.         String processInstanceId = "3705";  
  118.         List<HistoricIdentityLink> list = processEngine.getHistoryService()  
  119.                 .getHistoricIdentityLinksForProcessInstance(processInstanceId);  
  120.         if (list != null && list.size() > 0) {  
  121.             for (HistoricIdentityLink identityLink : list) {  
  122.                 System.out.println("任务ID：" + identityLink.getTaskId());  
  123.                 System.out.println("流程实例ID："  
  124.                         + identityLink.getProcessInstanceId());  
  125.                 System.out.println("用户ID：" + identityLink.getUserId());  
  126.                 System.out.println("工作流角色ID：" + identityLink.getGroupId());  
  127.                 System.out.println("#########################################");  
  128.             }  
  129.         }  
  130.     }  
  131. }  


     说明：

 

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

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

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

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


           三、分配组任务方式二：使用流程变量


     1.在任务节点设置变量

     


     2.测试代码

 

[java] view plain copy
  1. public class TaskTest {  
  2.       
  3.     //流程引擎对象  
  4.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
  5.       
  6.     /**部署流程定义+启动流程实例*/  
  7.     @Test  
  8.     public void deployementAndStartProcess(){  
  9.         InputStream inputStreamBpmn = this.getClass().getResourceAsStream("task.bpmn");  
  10.         InputStream inputStreampng = this.getClass().getResourceAsStream("task.png");  
  11.         //部署流程定义  
  12.         Deployment deployment = processEngine.getRepositoryService()//  
  13.                         .createDeployment()//创建部署对象  
  14.                         .addInputStream("task.bpmn", inputStreamBpmn)//部署加载资源文件  
  15.                         .addInputStream("task.png", inputStreampng)//  
  16.                         .deploy();  
  17.         System.out.println("部署ID："+deployment.getId());  
  18.         //启动流程实例  
  19.         /** 
  20.          * 启动流程实例的同时，设置流程变量，使用流程变量的方式设置下一个任务的办理人 
  21.          *       流程变量的名称，就是在task.bpmn中定义activiti:candidateUsers="#{userIDs}"的userIDs 
  22.          *       流程变量的值，就是任务的办理人（组任务） 
  23.          */  
  24.         Map<String, Object> variables = new HashMap<String, Object>();  
  25.         variables.put("userIDs", "大大,中中,小小");  
  26.         ProcessInstance pi = processEngine.getRuntimeService()//  
  27.                             .startProcessInstanceByKey("task",variables);//使用流程定义的key的最新版本启动流程  
  28.         System.out.println("流程实例ID："+pi.getId());  
  29.         System.out.println("流程定义的ID："+pi.getProcessDefinitionId());  
  30.     }  
  31.       
  32.     /**查询我的个人任务*/  
  33.     @Test  
  34.     public void findPersonalTaskList(){  
  35.         //任务办理人  
  36.         String assignee = "小A";  
  37.         List<Task> list = processEngine.getTaskService()//  
  38.                         .createTaskQuery()//  
  39.                         .taskAssignee(assignee)//个人任务的查询  
  40.                         .list();  
  41.         if(list!=null && list.size()>0){  
  42.             for(Task task:list){  
  43.                 System.out.println("任务ID："+task.getId());  
  44.                 System.out.println("任务的办理人："+task.getAssignee());  
  45.                 System.out.println("任务名称："+task.getName());  
  46.                 System.out.println("任务的创建时间："+task.getCreateTime());  
  47.                 System.out.println("流程实例ID："+task.getProcessInstanceId());  
  48.                 System.out.println("#######################################");  
  49.             }  
  50.         }  
  51.     }  
  52.       
  53.     /**查询组任务*/  
  54.     @Test  
  55.     public void findGroupTaskList(){  
  56.         //任务办理人  
  57.         String candidateUser = "小A";  
  58.         List<Task> list = processEngine.getTaskService()//  
  59.                         .createTaskQuery()//  
  60.                         .taskCandidateUser(candidateUser)//参与者，组任务查询  
  61.                         .list();  
  62.         if(list!=null && list.size()>0){  
  63.             for(Task task:list){  
  64.                 System.out.println("任务ID："+task.getId());  
  65.                 System.out.println("任务的办理人："+task.getAssignee());  
  66.                 System.out.println("任务名称："+task.getName());  
  67.                 System.out.println("任务的创建时间："+task.getCreateTime());  
  68.                 System.out.println("流程实例ID："+task.getProcessInstanceId());  
  69.                 System.out.println("#######################################");  
  70.             }  
  71.         }  
  72.     }  
  73.       
  74.     /**完成任务*/  
  75.     @Test  
  76.     public void completeTask(){  
  77.         //任务ID  
  78.         String taskId = "5909";  
  79.         processEngine.getTaskService()//  
  80.                         .complete(taskId);  
  81.         System.out.println("完成任务："+taskId);  
  82.     }  
  83.       
  84.     /**查询正在执行的组任务列表*/  
  85.     @Test  
  86.     public void findGroupCandidate(){  
  87.         //任务ID  
  88.         String taskId = "5909";  
  89.         List<IdentityLink> list = processEngine.getTaskService()//  
  90.                         .getIdentityLinksForTask(taskId);  
  91.   
  92.         if(list!=null && list.size()>0){  
  93.             for(IdentityLink identityLink:list){  
  94.                 System.out.println("任务ID："+identityLink.getTaskId());  
  95.                 System.out.println("流程实例ID："+identityLink.getProcessInstanceId());  
  96.                 System.out.println("用户ID："+identityLink.getUserId());  
  97.                 System.out.println("工作流角色ID："+identityLink.getGroupId());  
  98.                 System.out.println("#########################################");  
  99.             }  
  100.         }  
  101.     }  
  102.       
  103.     /**查询历史的组任务列表*/  
  104.     @Test  
  105.     public void findHistoryGroupCandidate(){  
  106.         //流程实例ID  
  107.         String processInstanceId = "5905";  
  108.         List<HistoricIdentityLink> list = processEngine.getHistoryService()  
  109.                         .getHistoricIdentityLinksForProcessInstance(processInstanceId);  
  110.         if(list!=null && list.size()>0){  
  111.             for(HistoricIdentityLink identityLink:list){  
  112.                 System.out.println("任务ID："+identityLink.getTaskId());  
  113.                 System.out.println("流程实例ID："+identityLink.getProcessInstanceId());  
  114.                 System.out.println("用户ID："+identityLink.getUserId());  
  115.                 System.out.println("工作流角色ID："+identityLink.getGroupId());  
  116.                 System.out.println("#########################################");  
  117.             }  
  118.         }  
  119.     }     
  120. }  


             四、分配组任务方式三：使用类


     1.编写类

 

[java] view plain copy
  1. public class TaskListenerImpl implements TaskListener {  
  2.   
  3.     /** 
  4.      * 可以设置任务的办理人（个人组人和组任务） 
  5.      */  
  6.     @Override  
  7.     public void notify(DelegateTask delegateTask) {  
  8.         //指定组任务  
  9.         delegateTask.addCandidateUser("孙悟空");  
  10.         delegateTask.addCandidateUser("猪八戒");  
  11.     }  
  12.   
  13. }  


     2.设置任务监听

     


     3.测试代码

 

[java] view plain copy
  1. public class TaskTest {  
  2.       
  3.     //流程引擎对象  
  4.     ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();  
  5.       
  6.     /**部署流程定义+启动流程实例*/  
  7.     @Test  
  8.     public void deployementAndStartProcess(){  
  9.         InputStream inputStreamBpmn = this.getClass().getResourceAsStream("task.bpmn");  
  10.         InputStream inputStreampng = this.getClass().getResourceAsStream("task.png");  
  11.         //部署流程定义  
  12.         Deployment deployment = processEngine.getRepositoryService()//  
  13.                             .createDeployment()//创建部署对象  
  14.                             .addInputStream("task.bpmn", inputStreamBpmn)//部署加载资源文件  
  15.                             .addInputStream("task.png", inputStreampng)//  
  16.                             .deploy();  
  17.         System.out.println("部署ID："+deployment.getId());  
  18.         //启动流程实例  
  19.           
  20.         ProcessInstance pi = processEngine.getRuntimeService()//  
  21.                             .startProcessInstanceByKey("task");//使用流程定义的key的最新版本启动流程  
  22.         System.out.println("流程实例ID："+pi.getId());  
  23.         System.out.println("流程定义的ID："+pi.getProcessDefinitionId());  
  24.     }  
  25.       
  26.     /**查询我的个人任务*/  
  27.     @Test  
  28.     public void findPersonalTaskList(){  
  29.         //任务办理人  
  30.         String assignee = "唐僧";  
  31.         List<Task> list = processEngine.getTaskService()//  
  32.                         .createTaskQuery()//  
  33.                         .taskAssignee(assignee)//个人任务的查询  
  34.                         .list();  
  35.         if(list!=null && list.size()>0){  
  36.             for(Task task:list){  
  37.                 System.out.println("任务ID："+task.getId());  
  38.                 System.out.println("任务的办理人："+task.getAssignee());  
  39.                 System.out.println("任务名称："+task.getName());  
  40.                 System.out.println("任务的创建时间："+task.getCreateTime());  
  41.                 System.out.println("流程实例ID："+task.getProcessInstanceId());  
  42.                 System.out.println("#######################################");  
  43.             }  
  44.         }  
  45.     }  
  46.       
  47.     /**查询组任务*/  
  48.     @Test  
  49.     public void findGroupTaskList(){  
  50.         //任务办理人  
  51.         String candidateUser = "猪八戒";  
  52.         List<Task> list = processEngine.getTaskService()//  
  53.                         .createTaskQuery()//  
  54.                         .taskCandidateUser(candidateUser)//参与者，组任务查询  
  55.                         .list();  
  56.         if(list!=null && list.size()>0){  
  57.             for(Task task:list){  
  58.                 System.out.println("任务ID："+task.getId());  
  59.                 System.out.println("任务的办理人："+task.getAssignee());  
  60.                 System.out.println("任务名称："+task.getName());  
  61.                 System.out.println("任务的创建时间："+task.getCreateTime());  
  62.                 System.out.println("流程实例ID："+task.getProcessInstanceId());  
  63.                 System.out.println("#######################################");  
  64.             }  
  65.         }  
  66.     }  
  67.       
  68.     /**完成任务*/  
  69.     @Test  
  70.     public void completeTask(){  
  71.         //任务ID  
  72.         String taskId = "6308";  
  73.         processEngine.getTaskService()//  
  74.                         .complete(taskId);  
  75.         System.out.println("完成任务："+taskId);  
  76.     }  
  77.       
  78.     /**查询正在执行的组任务列表*/  
  79.     @Test  
  80.     public void findGroupCandidate(){  
  81.         //任务ID  
  82.         String taskId = "5909";  
  83.         List<IdentityLink> list = processEngine.getTaskService()//  
  84.                         .getIdentityLinksForTask(taskId);  
  85.         if(list!=null && list.size()>0){  
  86.             for(IdentityLink identityLink:list){  
  87.                 System.out.println("任务ID："+identityLink.getTaskId());  
  88.                 System.out.println("流程实例ID："+identityLink.getProcessInstanceId());  
  89.                 System.out.println("用户ID："+identityLink.getUserId());  
  90.                 System.out.println("工作流角色ID："+identityLink.getGroupId());  
  91.                 System.out.println("#########################################");  
  92.             }  
  93.         }  
  94.     }  
  95.       
  96.     /**查询历史的组任务列表*/  
  97.     @Test  
  98.     public void findHistoryGroupCandidate(){  
  99.         //流程实例ID  
  100.         String processInstanceId = "5905";  
  101.         List<HistoricIdentityLink> list = processEngine.getHistoryService()  
  102.                         .getHistoricIdentityLinksForProcessInstance(processInstanceId);  
  103.         if(list!=null && list.size()>0){  
  104.             for(HistoricIdentityLink identityLink:list){  
  105.                 System.out.println("任务ID："+identityLink.getTaskId());  
  106.                 System.out.println("流程实例ID："+identityLink.getProcessInstanceId());  
  107.                 System.out.println("用户ID："+identityLink.getUserId());  
  108.                 System.out.println("工作流角色ID："+identityLink.getGroupId());  
  109.                 System.out.println("#########################################");  
  110.             }  
  111.         }  
  112.     }  
  113.       
  114.     /**将组任务指定个人任务(拾取任务)*/  
  115.     @Test  
  116.     public void claim(){  
  117.         //任务ID  
  118.         String taskId = "6308";  
  119.         //个人任务的办理人  
  120.         String userId = "唐僧";  
  121.         processEngine.getTaskService()//  
  122.                     .claim(taskId, userId);  
  123.     }  
  124.       
  125.     /**将个人任务再回退到组任务（前提：之前这个任务是组任务）*/  
  126.     @Test  
  127.     public void setAssignee(){  
  128.         //任务ID  
  129.         String taskId = "6308";  
  130.         processEngine.getTaskService()//  
  131.                         .setAssignee(taskId, null);  
  132.     }  
  133.       
  134.     /**向组任务中添加成员*/  
  135.     @Test  
  136.     public void addGroupUser(){  
  137.         //任务ID  
  138.         String taskId = "6308";  
  139.         //新增组任务的成员  
  140.         String userId = "如来";  
  141.         processEngine.getTaskService()//  
  142.                     .addCandidateUser(taskId, userId);  
  143.     }  
  144.       
  145.     /**向组任务中删除成员*/  
  146.     @Test  
  147.     public void deleteGroupUser(){  
  148.         //任务ID  
  149.         String taskId = "6308";  
  150.         //新增组任务的成员  
  151.         String userId = "猪八戒";  
  152.         processEngine.getTaskService()//  
  153.                     .deleteCandidateUser(taskId, userId);  
  154.     }  
  155. }  


           总结：

     以上就是分配组任务的三种方式，和分配个人任务相对应，同样有三种方式，与个人任务的操作相比，组任务操

作增加了组任务分配个人任务（认领任务），个人任务分配给组任务，以及向组任务添加人员和向组任务删除人员的

操作。

posted @ 2017-03-21 16:31  albert_think  阅读(2340)  评论(0)  编辑  收藏  举报