activiti 选人的实现

时间  2019-12-12
标签 activiti 选人 实现 繁體版
原文   原文链接

activiti默认是不带有选人的功能的，它默认的是在调用complete 方法的时候自动根据下一个节点的 assignee属性或者candidate属性 设置下一节点的候选人或者 assginee。 

因为项目的缘由咱们须要实如今上一个节点提交的时候设置就要从几个候选审批人员中选择一个或者几个审批人员，下面的代码写了个Junit 的demo。 



java

Java代码   收藏代码
  1. package test.java.org.activiti.designer.test;  
  2.   
  3. import static org.junit.Assert.*;  
  4.   
  5. import java.util.ArrayList;  
  6. import java.util.Collection;  
  7. import java.util.HashMap;  
  8. import java.util.List;  
  9. import java.util.Map;  
  10. import java.io.FileInputStream;  
  11.   
  12. import org.activiti.bpmn.model.BpmnModel;  
  13. import org.activiti.bpmn.model.FlowElement;  
  14. import org.activiti.bpmn.model.Process;  
  15. import org.activiti.bpmn.model.SequenceFlow;  
  16. import org.activiti.engine.IdentityService;  
  17. import org.activiti.engine.RepositoryService;  
  18. import org.activiti.engine.RuntimeService;  
  19. import org.activiti.engine.TaskService;  
  20. import org.activiti.engine.impl.persistence.entity.TaskEntity;  
  21. import org.activiti.engine.runtime.ProcessInstance;  
  22. import org.activiti.engine.task.Task;  
  23. import org.activiti.engine.test.ActivitiRule;  
  24. import org.junit.Rule;  
  25. import org.junit.Test;  
  26.   
  27. public class ProcessTest {  
  28.   
  29.     private String filename = "E:\\workspace4.3\\kft-activiti-demo-no-maven\\resources\\diagrams\\test2.bpmn";  
  30.   
  31.     @Rule  
  32.     public ActivitiRule activitiRule = new ActivitiRule();  
  33.     static RuntimeService runtimeService;  
  34.     static TaskService taskService;  
  35.     static IdentityService identityService;  
  36.       
  37.     static RepositoryService repositoryService;  
  38.       
  39.       
  40.     //流程定义编号  
  41.     private String processDefinitionId ;  
  42.     //任务编号  
  43.     //private String taskId;  
  44.     //流程实例号  
  45.     private String processInstanceId;  
  46.     @Test  
  47.     public void mainTest() throws Exception {  
  48.           
  49.         repositoryService = activitiRule.getRepositoryService();      
  50.         runtimeService = activitiRule.getRuntimeService();  
  51.         taskService = activitiRule.getTaskService();  
  52.   
  53.         ProcessTest ptm = new ProcessTest();  
  54.         //这里有个问题，runtimeService.startProcessInstanceByKey 这个方法直接就把流程流转到任务用户去了，没通过选人的操做  
  55.         //这里就变通一下处理，提交到一个无所谓的人，而后在调用方法修改这我的。  
  56.         String taskId;  
  57.         //返回的usertask的id  
  58.         taskId = ptm.startProcess();  
  59.         //**********流程启动成功  
  60.         //流程在第一个审批人哪里  
  61.         //taskId = ptm.getNextNodeId(1,"feng");  
  62.         //选人  
  63.         List<String> userList= ptm.getNextTaskUserByTaskId(taskId);  
  64.         //设置审批人  
  65.         ptm.setApproveUser(taskId, "feng");  
  66.   
  67.         taskId = ptm.getNextNodeId(1,"feng");  
  68.           
  69.         //第一个审批人提交流程  feng 为当前节点审批人，xiaozhang 为设置的下一节点审批人  
  70.         ptm.completeByAssignee("feng","xiaozhang");  
  71.         //************第一我的审批成功  
  72.           
  73.   
  74.   
  75.         taskId = ptm.getNextNodeId(1,"xiaozhang");  
  76.         //选人  
  77.         userList= ptm.getNextTaskUserByTaskId(taskId);  
  78.         //第一个审批人提交流程  
  79.         ptm.completeByAssignee("xiaozhang","xiaoming");  
  80.   
  81.         ptm.getNextNodeId(1,"xiaoming");  
  82.           
  83.         //第二个审批人提交流程  
  84.         ptm.completeByAssignee("xiaoming","xiangwang");  
  85.         //************第二我的审批成功  
  86.   
  87.   
  88.   
  89.     }  
  90.     //启动流程  
  91.     public String startProcess() throws Exception {  
  92.           
  93.         repositoryService.createDeployment().addInputStream("test2.bpmn20.xml",new FileInputStream(filename)).deploy();  
  94.         Map<String, Object> variableMap = new HashMap<String, Object>();  
  95.         variableMap.put("name", "Activiti");  
  96.           
  97.           
  98.         //启动流程  
  99.         ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("test2", variableMap);  
  100.   
  101.         processDefinitionId = processInstance.getProcessDefinitionId();  
  102.         processInstance.getId();  
  103.         List<TaskEntity> tList =  ((org.activiti.engine.impl.persistence.entity.ExecutionEntity) processInstance).getTasks();  
  104.           
  105.         this.setProcessInstanceId( processInstance.getId() );  
  106.           
  107.         this.setProcessDefinitionId(processDefinitionId);  
  108.           
  109.         if(tList.size()!=1) {  
  110.             System.err.println("start节点的输出路由不能有多个");  
  111.         }  
  112.         return tList.get(0).getId();  
  113.   
  114.     }  
  115.   
  116.     public void queryProcessInstance() {  
  117.         List<ProcessInstance> instanceList = runtimeService  
  118.                 .createProcessInstanceQuery().processDefinitionKey("test")  
  119.                 .list();  
  120.         //查询 流程实例  
  121.         for (ProcessInstance queryProcessInstance : instanceList) {  
  122.             queryProcessInstance.getActivityId();  
  123.               
  124.             System.out.print("-----queryProcessInstance:"+queryProcessInstance.getActivityId());  
  125.               
  126.             assertEquals(false, queryProcessInstance.isEnded());  
  127.             System.out.println("id " + queryProcessInstance.getId()  
  128.                     + ", ended=" + queryProcessInstance.isEnded()+",ProcessDefinitionId="+queryProcessInstance.getProcessDefinitionId());  
  129.         }  
  130.     }  
  131.     //根据assignee来查询用户  
  132.     public void queryTask(String assignee) {  
  133.         //startProcessInstance();  
  134.           
  135.         // taskService.createTaskQuery().taskCandidateGroup("sales").singleResult();  
  136.           
  137.         Task task= taskService.createTaskQuery().taskAssignee(assignee).singleResult();  
  138.           
  139.           
  140.         System.out.println("审批人为【"+assignee+"】的任务有：任务编号为【" + task.getId() + "】"+ task.getTaskDefinitionKey());  
  141.   
  142.     }  
  143.     /**  
  144.      *   
  145.      * @param queryType  查询类型1 根据 assignee 查询  2 根据candidateuser查询  
  146.      * @param str  
  147.      */  
  148.     public String getNextNodeId(int queryType,String str) {  
  149.           
  150.           
  151.         Task task = null;  
  152.         if(queryType==1) {  
  153.             task = taskService.createTaskQuery().taskAssignee(str).singleResult();  
  154.         }else if(queryType==2){  
  155.             task = taskService.createTaskQuery().taskCandidateUser(str).singleResult();  
  156.   
  157.         }else if(queryType==3){  
  158.             task = taskService.createTaskQuery().taskCandidateGroup(str).singleResult();  
  159.   
  160.         }  
  161.           
  162.         List<FlowElement> list = getNextNode(task.getId());  
  163.           
  164.           
  165.         if(task==null) {  
  166.             return null;  
  167.         }  
  168.           
  169.           
  170.         for(FlowElement e :list) {  
  171.             //((org.activiti.bpmn.model.UserTask) e)  
  172.         }  
  173.           
  174.         return task.getId();  
  175.               
  176.     }  
  177.     /** 
  178.      * 获取流程的下一个节点 且要通过规则引擎判断后的节点 
  179.      * @param taskId 
  180.      * @return 
  181.      */  
  182.     private List<FlowElement> getNextNode(String taskId) {  
  183.           
  184.         Task task = null;  
  185.         task = taskService.createTaskQuery().taskId(taskId).singleResult();  
  186.         if(task==null) {  
  187.             return null;  
  188.         }  
  189.         List<FlowElement> list = new ArrayList<FlowElement>();  
  190.           
  191.         ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();  
  192.           
  193.         //当前活动节点  
  194.         String activitiId = processInstance.getActivityId();  
  195.           
  196.         System.out.println("当前节点是【"+activitiId+"】");  
  197.   
  198.         //pmmnModel 遍历节点须要它  
  199.         BpmnModel bpmnModel =  repositoryService.getBpmnModel(task.getProcessDefinitionId());  
  200.   
  201.         List<Process> processList = bpmnModel.getProcesses();  
  202.           
  203.         //循环多个物理流程  
  204.         for(Process process:processList) {  
  205.               
  206.             //返回该流程的全部任务，事件  
  207.             Collection<FlowElement> cColl = process.getFlowElements();  
  208.             //遍历节点  
  209.             for(FlowElement f :cColl) {  
  210.                   
  211.                   
  212.                 //若是改节点是当前节点 者 输出该节点的下一个节点  
  213.                 if(f.getId().equals(activitiId)) {  
  214.                   
  215.                     List<SequenceFlow>  sequenceFlowList = new ArrayList<SequenceFlow>();  
  216.                     //经过反射来判断是哪一种类型  
  217.                     if(f instanceof org.activiti.bpmn.model.StartEvent) {  
  218.                         //开始事件的输出路由  
  219.                         sequenceFlowList    = ((org.activiti.bpmn.model.StartEvent) f).getOutgoingFlows();  
  220.                     }else if(f instanceof org.activiti.bpmn.model.UserTask) {  
  221.                           
  222.                         sequenceFlowList    = ((org.activiti.bpmn.model.UserTask) f).getOutgoingFlows();  
  223.                           
  224.                           
  225.                         for(SequenceFlow sf :sequenceFlowList)  {  
  226.                               
  227.                             String targetRef = sf.getTargetRef();  
  228.                             FlowElement ref = process.getFlowElement(targetRef);  
  229.                               
  230.                         //  nextActivitiIdList.add(ref.getId());  
  231.                               
  232.                             list.add(ref);  
  233.                         }  
  234.                           
  235.                     }else if(f instanceof org.activiti.bpmn.model.SequenceFlow) {  
  236.                       
  237.                           
  238.                     }else if(f instanceof org.activiti.bpmn.model.EndEvent) {  
  239.                         sequenceFlowList    = ((org.activiti.bpmn.model.EndEvent) f).getOutgoingFlows();  
  240.                     }  
  241.                     break;  
  242.                 }   
  243.                       
  244.             }  
  245.               
  246.         }     
  247.         return list;  
  248.     }   
  249.     //流程流转到下一步  
  250.     public void completeByAssignee(String assignee,String nextUser) throws Exception {  
  251.           
  252.         HashMap<String,Object> map = new HashMap<String,Object>();  
  253.           
  254.         map.put("nextUser", nextUser);  
  255.         Task task = taskService.createTaskQuery().taskAssignee(assignee).singleResult();  
  256.         taskService.complete(task.getId(),map);  
  257.         System.out.println("完成任务 编号为【" + task.getId() + "】,名称为【"+task.getName()+"】的任务");  
  258.     }  
  259.     /** 
  260.      * 设置某个节点的审批人员 
  261.      * @param taskId 
  262.      * @param user 
  263.      */  
  264.     public void setApproveUser(String taskId,String user) {  
  265.         Task task = taskService.createTaskQuery().taskId(taskId).singleResult();  
  266.         task.setAssignee(user);  
  267.         taskService.saveTask(task);  
  268.     }  
  269.   
  270.     /** 
  271.      * 取下一个节点的审批人 
  272.      * @param taskId 
  273.      * @return 
  274.      */  
  275.     public List<String> getNextTaskUserByTaskId(String taskId) {  
  276.         List<String> list = new ArrayList<String>();  
  277.           
  278.         List<FlowElement> fList = getNextNode(taskId);  
  279.           
  280.           
  281.         for(FlowElement u:fList){  
  282.               
  283.             String str =  ((org.activiti.bpmn.model.UserTask) u).getAssignee();   
  284.             list.add(str);  
  285.         }  
  286.         return list ;  
  287.     }  
  288.       
  289.     /** 
  290.      * 找当前节点的候选审批人  供流程实例start后调用 
  291.      * @param taskId 
  292.      * @return 
  293.      */  
  294.     public List<String> getThisTaskUser(String taskId) {  
  295.         List<String> list = new ArrayList<String>();  
  296.         Task task = taskService.createTaskQuery().taskId(taskId).singleResult();  
  297.         String taskUser = task.getAssignee();  
  298.           
  299.         //*****************************根据taskUser的配置到本身的表里面去找数据  
  300.           
  301.         list.add(taskUser);  
  302.         return list ;  
  303.     }  
  304.     public String getProcessDefinitionId() {  
  305.         return processDefinitionId;  
  306.     }  
  307.   
  308.     public void setProcessDefinitionId(String processDefinitionId) {  
  309.         this.processDefinitionId = processDefinitionId;  
  310.     }  
  311.   
  312.     public String getProcessInstanceId() {  
  313.         return processInstanceId;  
  314.     }  
  315.   
  316.     public void setProcessInstanceId(String processInstanceId) {  
  317.         this.processInstanceId = processInstanceId;  
  318.     }  
  319. }  


另外再绘制流程图的时候除了首节点，其他每一个节点要设置listener ，能够设置一个公共的listener 传递不一样的参数代码如： sql

Java代码   收藏代码
  1. package org.activiti.ext;  
  2.   
  3.   
  4. import java.sql.Connection;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7. import java.sql.Statement;  
  8. import java.util.ArrayList;  
  9. import java.util.HashMap;  
  10. import java.util.List;  
  11. import java.util.Map;  
  12.   
  13. import javax.sql.DataSource;  
  14.   
  15. import org.activiti.engine.delegate.DelegateExecution;  
  16. import org.activiti.engine.delegate.DelegateTask;  
  17. import org.activiti.engine.delegate.ExecutionListener;  
  18. import org.activiti.engine.delegate.TaskListener;  
  19. import org.apache.ibatis.annotations.Delete;  
  20. import org.slf4j.Logger;  
  21. import org.slf4j.LoggerFactory;  
  22.   
  23. public class TaskUserQuery implements TaskListener{  
  24.   
  25.       
  26.       /** 
  27.      *  
  28.      */  
  29.     private static final long serialVersionUID = 1L;  
  30.     private static Logger logger = LoggerFactory.getLogger(TaskUserQuery.class);  
  31.   
  32.     protected DataSource dataSource;  
  33.   
  34.       
  35.       
  36.     private org.activiti.engine.impl.el.FixedValue orgLevel ;  
  37.     private org.activiti.engine.impl.el.FixedValue dutyNo ;  
  38.     public DataSource getDataSource() {  
  39.         return dataSource;  
  40.     }  
  41.     public void setDataSource(DataSource dataSource) {  
  42.         this.dataSource = dataSource;  
  43.     }  
  44.     /** 
  45.      * 审批过程当中找人的方法 
  46.      * @param str 组名 
  47.      * @return 
  48.      * @throws SQLException 
  49.      */  
  50.     public String getTaskUser(String str) throws SQLException {  
  51.         logger.debug("-------------------自定义找人----------------------------getTaskUser");  
  52.           
  53.         Connection conn = dataSource.getConnection();  
  54.           
  55.         Statement state = conn.createStatement();  
  56.         String queryTaskUserSql = "select id_ from act_id_user aiu where exists (select 1 from act_id_membership aim where aim.user_id_ = aiu.id_ and  aim.group_id_='"+str+"' )";  
  57.           
  58.         ResultSet rs = state.executeQuery(queryTaskUserSql);  
  59.         rs.next();  
  60.         logger.debug("-------------------自定义找人----------------------------：返回的人是"+rs.getString(1));  
  61.           
  62.         conn.close();  
  63.         state.close();  
  64.         return rs.getString(1);  
  65.           
  66.     }   
  67.       
  68.     public List<String> getTaskUserList(String str) throws SQLException {  
  69.         logger.debug("-------------------自定义找人----------------------------getTaskUserList");  
  70.         List<String> taskUser = new ArrayList<String>();  
  71.           
  72.         Connection conn = dataSource.getConnection();  
  73.           
  74.         Statement state = conn.createStatement();  
  75.         String queryTaskUserSql = "select id_ from act_id_user aiu where exists (select 1 from act_id_membership aim where aim.user_id_ = aiu.id_ and  aim.group_id_='"+str+"' )";  
  76.           
  77.         ResultSet rs = state.executeQuery(queryTaskUserSql);  
  78.         while(rs.next()) {  
  79.             taskUser.add(rs.getString(1));  
  80.         }  
  81.         logger.debug("------------------- 自定义找人----------------------------：返回的人是"+taskUser.toString());  
  82.           
  83.         conn.close();  
  84.         state.close();  
  85.         return taskUser;  
  86.           
  87.     }   
  88.     @Override  
  89.     public void notify(DelegateTask delegateTask) {  
  90.           
  91.           
  92.         Map<String,Object> map = delegateTask.getVariables();  
  93.         String taskId = delegateTask.getId();  
  94.           
  95.         System.out.println("in taskUserQuer class variable is:"+map.toString());  
  96.         System.out.println("in taskUserQuer class taskid is:"+taskId);  
  97.         System.out.println("in taskUserQuer class orgLevel is:"+orgLevel.getExpressionText());  
  98.           
  99.           
  100.           
  101.         String id = delegateTask.getId();  
  102.         String s = delegateTask.getAssignee();  
  103.         //根据流程变量的内容设置下一个节点的审批人  
  104.         delegateTask.setAssignee(map.get("nextUser").toString());  
  105.           
  106.         Map<String,Object> m1 = delegateTask.getExecution().getVariables();  
  107.         Map<String,Object> m2 = delegateTask.getVariablesLocal();  
  108.           
  109.           
  110.           
  111. //      logger.debug("-----------------------------------------id is:"+id);  
  112. //  //  logger.debug("-----------------------------------------arg is:"+dutyNo.getExpressionText());  
  113. //      delegateTask.setAssignee(dutyNo.getExpressionText());  
  114.           
  115.         // TODO Auto-generated method stub  
  116. //      logger.debug("----------------------设置选人 开始--------------------------");  
  117. //      delegateTask.setAssignee("admin");    
  118. //      logger.debug("----------------------设置选人 结束--------------------------");  
  119.     }  
  120.   
  121. }  



整个选人过程的其实比较简单 是：提交流程的时候将下一审批人做为流程变量提交到流程引擎，流程引擎会调用如上代码块的notify 方法（固然须要在usertask上配置 配置下图） ，在notify方法内delegateTask.setAssignee设置下一个节点的审批人 

apache

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程