关于activiti流程通过、驳回、会签、转办、中止、挂起等核心操作功能的封装

http://blog.csdn.net/aochuanguying/article/details/7594197

[java] view plain copy print ?  

1. package com.famousPro.process.service.impl;  
3. import java.util.ArrayList;  
4. import java.util.HashMap;  
5. import java.util.List;  
6. import java.util.Map;  
8. import org.activiti.engine.FormService;  
9. import org.activiti.engine.HistoryService;  
10. import org.activiti.engine.RepositoryService;  
11. import org.activiti.engine.RuntimeService;  
12. import org.activiti.engine.TaskService;  
13. import org.activiti.engine.history.HistoricActivityInstance;  
14. import org.activiti.engine.impl.RepositoryServiceImpl;  
15. import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;  
16. import org.activiti.engine.impl.persistence.entity.TaskEntity;  
17. import org.activiti.engine.impl.pvm.PvmTransition;  
18. import org.activiti.engine.impl.pvm.process.ActivityImpl;  
19. import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;  
20. import org.activiti.engine.impl.pvm.process.TransitionImpl;  
21. import org.activiti.engine.runtime.ProcessInstance;  
22. import org.activiti.engine.task.Task;  
24. import com.famousPro.common.service.impl.BaseServiceImp;  
25. import com.famousPro.common.util.IDGenerator;  
26. import com.famousPro.common.util.StringUtil;  
27. import com.famousPro.process.service.ProcessCoreService;  
28. import com.famousPro.process.service.ProcessOtherService;  
30. /**
31.  * 流程操作核心类
    
32.  * 此核心类主要处理：流程通过、驳回、会签、转办、中止、挂起等核心操作
    
33.  * 
34.  * @author wangfuwei
35.  * 
36.  */
37. publicclass ProcessCoreServiceImpl extends BaseServiceImp implements
38.         ProcessCoreService {  
39. protected RepositoryService repositoryService;  
41. protected RuntimeService runtimeService;  
43. protected TaskService taskService;  
45. protected FormService formService;  
47. protected HistoryService historyService;  
49. protected ProcessOtherService processOtherService;  
51. /**
52.      * 根据当前任务ID，查询可以驳回的任务节点
53.      * 
54.      * @param taskId
55.      *            当前任务ID
56.      */
57. public List  findBackAvtivity(String taskId)  throws Exception {  
58.         List  rtnList =  null ;  
59. if (processOtherService.isJointTask(taskId)) {// 会签任务节点，不允许驳回
60.             rtnList = new ArrayList ();  
61.         } else {  
62.             rtnList = iteratorBackActivity(taskId, findActivitiImpl(taskId,  
63. null), new ArrayList (),  
64. new ArrayList ());  
65.         }  
66. return reverList(rtnList);  
67.     }  
69. /**
70.      * 审批通过(驳回直接跳回功能需后续扩展)
71.      * 
72.      * @param taskId
73.      *            当前任务ID
74.      * @param variables
75.      *            流程存储参数
76.      * @throws Exception
77.      */
78. publicvoid passProcess(String taskId, Map <string, object> variables)  
79. throws Exception {  
80.         List  tasks = taskService.createTaskQuery().parentTaskId(taskId)  
81.                 .taskDescription("jointProcess").list();  
82. for (Task task : tasks) {// 级联结束本节点发起的会签任务
83.             commitProcess(task.getId(), null, null);  
84.         }  
85.         commitProcess(taskId, variables, null);  
86.     }  
88. /**
89.      * 驳回流程
90.      * 
91.      * @param taskId
92.      *            当前任务ID
93.      * @param activityId
94.      *            驳回节点ID
95.      * @param variables
96.      *            流程存储参数
97.      * @throws Exception
98.      */
99. publicvoid backProcess(String taskId, String activityId,  
100.             Map <string, object> variables)  throws  Exception {  
101. if (StringUtil.isNull(activityId)) {  
102. thrownew Exception("驳回目标节点ID为空！");  
103.         }  
105. // 查询本节点发起的会签任务，并结束
106.         List  tasks = taskService.createTaskQuery().parentTaskId(taskId)  
107.                 .taskDescription("jointProcess").list();  
108. for (Task task : tasks) {  
109.             commitProcess(task.getId(), null, null);  
110.         }  
112. // 查找所有并行任务节点，同时驳回
113.         List  taskList = findTaskListByKey(findProcessInstanceByTaskId(  
114.                 taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());  
115. for (Task task : taskList) {  
116.             commitProcess(task.getId(), variables, activityId);  
117.         }  
118.     }  
120. /**
121.      * 取回流程
122.      * 
123.      * @param taskId
124.      *            当前任务ID
125.      * @param activityId
126.      *            取回节点ID
127.      * @throws Exception
128.      */
129. publicvoid callBackProcess(String taskId, String activityId)  
130. throws Exception {  
131. if (StringUtil.isNull(activityId)) {  
132. thrownew Exception("目标节点ID为空！");  
133.         }  
135. // 查找所有并行任务节点，同时取回
136.         List  taskList = findTaskListByKey(findProcessInstanceByTaskId(  
137.                 taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());  
138. for (Task task : taskList) {  
139.             commitProcess(task.getId(), null, activityId);  
140.         }  
141.     }  
143. /**
144.      * 中止流程(特权人直接审批通过等)
145.      * 
146.      * @param taskId
147.      */
148. publicvoid endProcess(String taskId) throws Exception {  
149.         ActivityImpl endActivity = findActivitiImpl(taskId, "end");  
150.         commitProcess(taskId, null, endActivity.getId());  
151.     }  
153. /**
154.      * 会签操作
155.      * 
156.      * @param taskId
157.      *            当前任务ID
158.      * @param userCodes
159.      *            会签人账号集合
160.      * @throws Exception
161.      */
162. publicvoid jointProcess(String taskId, List  userCodes)  
163. throws Exception {  
164. for (String userCode : userCodes) {  
165.             TaskEntity task = (TaskEntity) taskService.newTask(IDGenerator  
166.                     .generateID());  
167.             task.setAssignee(userCode);  
168.             task.setName(findTaskById(taskId).getName() + "-会签");  
169.             task.setProcessDefinitionId(findProcessDefinitionEntityByTaskId(  
170.                     taskId).getId());  
171.             task.setProcessInstanceId(findProcessInstanceByTaskId(taskId)  
172.                     .getId());  
173.             task.setParentTaskId(taskId);  
174.             task.setDescription("jointProcess");  
175.             taskService.saveTask(task);  
176.         }  
177.     }  
179. /**
180.      * 转办流程
181.      * 
182.      * @param taskId
183.      *            当前任务节点ID
184.      * @param userCode
185.      *            被转办人Code
186.      */
187. publicvoid transferAssignee(String taskId, String userCode) {  
188.         taskService.setAssignee(taskId, userCode);  
189.     }  
191. /**
192.      * ***************************************************************************************************************************************************
     
193.      * ************************************************以下为流程会签操作核心逻辑******************************************************************************
     
194.      * ***************************************************************************************************************************************************
     
195.      */
197. /**
198.      * ***************************************************************************************************************************************************
     
199.      * ************************************************以上为流程会签操作核心逻辑******************************************************************************
     
200.      * ***************************************************************************************************************************************************
     
201.      */
203. /**
204.      * ***************************************************************************************************************************************************
     
205.      * ************************************************以下为流程转向操作核心逻辑******************************************************************************
     
206.      * ***************************************************************************************************************************************************
     
207.      */
209. /**
210.      * @param taskId
211.      *            当前任务ID
212.      * @param variables
213.      *            流程变量
214.      * @param activityId
215.      *            流程转向执行任务节点ID
     
216.      *            此参数为空，默认为提交操作
217.      * @throws Exception
218.      */
219. privatevoid commitProcess(String taskId, Map <string, object> variables,  
220.             String activityId) throws Exception {  
221. if (variables == null) {  
222.             variables = new HashMap <string, object>();  
223.         }  
224. // 跳转节点为空，默认提交操作
225. if (StringUtil.isNull(activityId)) {  
226.             taskService.complete(taskId, variables);  
227.         } else {// 流程转向操作
228.             turnTransition(taskId, activityId, variables);  
229.         }  
230.     }  
232. /**
233.      * 清空指定活动节点流向
234.      * 
235.      * @param activityImpl
236.      *            活动节点
237.      * @return 节点流向集合
238.      */
239. private List  clearTransition(ActivityImpl activityImpl) {  
240. // 存储当前节点所有流向临时变量
241.         List  oriPvmTransitionList =  new  ArrayList ();  
242. // 获取当前节点所有流向，存储到临时变量，然后清空
243.         List  pvmTransitionList = activityImpl  
244.                 .getOutgoingTransitions();  
245. for (PvmTransition pvmTransition : pvmTransitionList) {  
246.             oriPvmTransitionList.add(pvmTransition);  
247.         }  
248.         pvmTransitionList.clear();  
250. return oriPvmTransitionList;  
251.     }  
253. /**
254.      * 还原指定活动节点流向
255.      * 
256.      * @param activityImpl
257.      *            活动节点
258.      * @param oriPvmTransitionList
259.      *            原有节点流向集合
260.      */
261. privatevoid restoreTransition(ActivityImpl activityImpl,  
262.             List  oriPvmTransitionList) {  
263. // 清空现有流向
264.         List  pvmTransitionList = activityImpl  
265.                 .getOutgoingTransitions();  
266.         pvmTransitionList.clear();  
267. // 还原以前流向
268. for (PvmTransition pvmTransition : oriPvmTransitionList) {  
269.             pvmTransitionList.add(pvmTransition);  
270.         }  
271.     }  
273. /**
274.      * 流程转向操作
275.      * 
276.      * @param taskId
277.      *            当前任务ID
278.      * @param activityId
279.      *            目标节点任务ID
280.      * @param variables
281.      *            流程变量
282.      * @throws Exception
283.      */
284. privatevoid turnTransition(String taskId, String activityId,  
285.             Map <string, object> variables)  throws  Exception {  
286. // 当前节点
287.         ActivityImpl currActivity = findActivitiImpl(taskId, null);  
288. // 清空当前流向
289.         List  oriPvmTransitionList = clearTransition(currActivity);  
291. // 创建新流向
292.         TransitionImpl newTransition = currActivity.createOutgoingTransition();  
293. // 目标节点
294.         ActivityImpl pointActivity = findActivitiImpl(taskId, activityId);  
295. // 设置新流向的目标节点
296.         newTransition.setDestination(pointActivity);  
298. // 执行转向任务
299.         taskService.complete(taskId, variables);  
300. // 删除目标节点新流入
301.         pointActivity.getIncomingTransitions().remove(newTransition);  
303. // 还原以前流向
304.         restoreTransition(currActivity, oriPvmTransitionList);  
305.     }  
307. /**
308.      * ***************************************************************************************************************************************************
     
309.      * ************************************************以上为流程转向操作核心逻辑******************************************************************************
     
310.      * ***************************************************************************************************************************************************
     
311.      */
313. /**
314.      * ***************************************************************************************************************************************************
     
315.      * ************************************************以下为查询流程驳回节点核心逻辑***************************************************************************
     
316.      * ***************************************************************************************************************************************************
     
317.      */
319. /**
320.      * 迭代循环流程树结构，查询当前节点可驳回的任务节点
321.      * 
322.      * @param taskId
323.      *            当前任务ID
324.      * @param currActivity
325.      *            当前活动节点
326.      * @param rtnList
327.      *            存储回退节点集合
328.      * @param tempList
329.      *            临时存储节点集合（存储一次迭代过程中的同级userTask节点）
330.      * @return 回退节点集合
331.      */
332. private List  iteratorBackActivity(String taskId,  
333.             ActivityImpl currActivity, List  rtnList,  
334.             List  tempList)  throws  Exception {  
335. // 查询流程定义，生成流程树结构
336.         ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);  
338. // 当前节点的流入来源
339.         List  incomingTransitions = currActivity  
340.                 .getIncomingTransitions();  
341. // 条件分支节点集合，userTask节点遍历完毕，迭代遍历此集合，查询条件分支对应的userTask节点
342.         List  exclusiveGateways =  new  ArrayList ();  
343. // 并行节点集合，userTask节点遍历完毕，迭代遍历此集合，查询并行节点对应的userTask节点
344.         List  parallelGateways =  new  ArrayList ();  
345. // 遍历当前节点所有流入路径
346. for (PvmTransition pvmTransition : incomingTransitions) {  
347.             TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
348.             ActivityImpl activityImpl = transitionImpl.getSource();  
349.             String type = (String) activityImpl.getProperty("type");  
350. /**
351.              * 并行节点配置要求：
     
352.              * 必须成对出现，且要求分别配置节点ID为:XXX_start(开始)，XXX_end(结束)
353.              */
354. if ("parallelGateway".equals(type)) {// 并行路线
355.                 String gatewayId = activityImpl.getId();  
356.                 String gatewayType = gatewayId.substring(gatewayId  
357.                         .lastIndexOf("_") + 1);  
358. if ("START".equals(gatewayType.toUpperCase())) {// 并行起点，停止递归
359. return rtnList;  
360.                 } else {// 并行终点，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点
361.                     parallelGateways.add(activityImpl);  
362.                 }  
363.             } elseif ("startEvent".equals(type)) {// 开始节点，停止递归
364. return rtnList;  
365.             } elseif ("userTask".equals(type)) {// 用户任务
366.                 tempList.add(activityImpl);  
367.             } elseif ("exclusiveGateway".equals(type)) {// 分支路线，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点
368.                 currActivity = transitionImpl.getSource();  
369.                 exclusiveGateways.add(currActivity);  
370.             }  
371.         }  
373. /**
374.          * 迭代条件分支集合，查询对应的userTask节点
375.          */
376. for (ActivityImpl activityImpl : exclusiveGateways) {  
377.             iteratorBackActivity(taskId, activityImpl, rtnList, tempList);  
378.         }  
380. /**
381.          * 迭代并行集合，查询对应的userTask节点
382.          */
383. for (ActivityImpl activityImpl : parallelGateways) {  
384.             iteratorBackActivity(taskId, activityImpl, rtnList, tempList);  
385.         }  
387. /**
388.          * 根据同级userTask集合，过滤最近发生的节点
389.          */
390.         currActivity = filterNewestActivity(processInstance, tempList);  
391. if (currActivity != null) {  
392. // 查询当前节点的流向是否为并行终点，并获取并行起点ID
393.             String id = findParallelGatewayId(currActivity);  
394. if (StringUtil.isNull(id)) {// 并行起点ID为空，此节点流向不是并行终点，符合驳回条件，存储此节点
395.                 rtnList.add(currActivity);  
396.             } else {// 根据并行起点ID查询当前节点，然后迭代查询其对应的userTask任务节点
397.                 currActivity = findActivitiImpl(taskId, id);  
398.             }  
400. // 清空本次迭代临时集合
401.             tempList.clear();  
402. // 执行下次迭代
403.             iteratorBackActivity(taskId, currActivity, rtnList, tempList);  
404.         }  
405. return rtnList;  
406.     }  
408. /**
409.      * 反向排序list集合，便于驳回节点按顺序显示
410.      * 
411.      * @param list
412.      * @return
413.      */
414. private List  reverList(List  list) {  
415.         List  rtnList =  new  ArrayList ();  
416. // 由于迭代出现重复数据，排除重复
417. for (int i = list.size(); i > 0; i--) {  
418. if (!rtnList.contains(list.get(i - 1)))  
419.                 rtnList.add(list.get(i - 1));  
420.         }  
421. return rtnList;  
422.     }  
424. /**
425.      * 根据当前节点，查询输出流向是否为并行终点，如果为并行终点，则拼装对应的并行起点ID
426.      * 
427.      * @param activityImpl
428.      *            当前节点
429.      * @return
430.      */
431. private String findParallelGatewayId(ActivityImpl activityImpl) {  
432.         List  incomingTransitions = activityImpl  
433.                 .getOutgoingTransitions();  
434. for (PvmTransition pvmTransition : incomingTransitions) {  
435.             TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
436.             activityImpl = transitionImpl.getDestination();  
437.             String type = (String) activityImpl.getProperty("type");  
438. if ("parallelGateway".equals(type)) {// 并行路线
439.                 String gatewayId = activityImpl.getId();  
440.                 String gatewayType = gatewayId.substring(gatewayId  
441.                         .lastIndexOf("_") + 1);  
442. if ("END".equals(gatewayType.toUpperCase())) {  
443. return gatewayId.substring(0, gatewayId.lastIndexOf("_"))  
444.                             + "_start";  
445.                 }  
446.             }  
447.         }  
448. returnnull;  
449.     }  
451. /**
452.      * 根据流入任务集合，查询最近一次的流入任务节点
453.      * 
454.      * @param processInstance
455.      *            流程实例
456.      * @param tempList
457.      *            流入任务集合
458.      * @return
459.      */
460. private ActivityImpl filterNewestActivity(ProcessInstance processInstance,  
461.             List  tempList) {  
462. while (tempList.size() > 0) {  
463.             ActivityImpl activity_1 = tempList.get(0);  
464.             HistoricActivityInstance activityInstance_1 = findHistoricUserTask(  
465.                     processInstance, activity_1.getId());  
466. if (activityInstance_1 == null) {  
467.                 tempList.remove(activity_1);  
468. continue;  
469.             }  
471. if (tempList.size() > 1) {  
472.                 ActivityImpl activity_2 = tempList.get(1);  
473.                 HistoricActivityInstance activityInstance_2 = findHistoricUserTask(  
474.                         processInstance, activity_2.getId());  
475. if (activityInstance_2 == null) {  
476.                     tempList.remove(activity_2);  
477. continue;  
478.                 }  
480. if (activityInstance_1.getEndTime().before(  
481.                         activityInstance_2.getEndTime())) {  
482.                     tempList.remove(activity_1);  
483.                 } else {  
484.                     tempList.remove(activity_2);  
485.                 }  
486.             } else {  
487. break;  
488.             }  
489.         }  
490. if (tempList.size() > 0) {  
491. return tempList.get(0);  
492.         }  
493. returnnull;  
494.     }  
496. /**
497.      * 查询指定任务节点的最新记录
498.      * 
499.      * @param processInstance
500.      *            流程实例
501.      * @param activityId
502.      * @return
503.      */
504. private HistoricActivityInstance findHistoricUserTask(  
505.             ProcessInstance processInstance, String activityId) {  
506.         HistoricActivityInstance rtnVal = null;  
507. // 查询当前流程实例审批结束的历史节点
508.         List  historicActivityInstances = historyService  
509.                 .createHistoricActivityInstanceQuery().activityType("userTask")  
510.                 .processInstanceId(processInstance.getId()).activityId(  
511.                         activityId).finished()  
512.                 .orderByHistoricActivityInstanceEndTime().desc().list();  
513. if (historicActivityInstances.size() > 0) {  
514.             rtnVal = historicActivityInstances.get(0);  
515.         }  
517. return rtnVal;  
518.     }  
520. /**
521.      * *******************************************************************************************************
     
522.      * ********************************以上为查询流程驳回节点核心逻辑***********************************************
     
523.      * ********************************************************************************************************
     
524.      */
526. /**
527.      * ********************************************************************************
     
528.      * **********************以下为activiti 核心service
529.      * set方法***************************
     
530.      * *********************************************************************************
     
531.      */
532. publicvoid setFormService(FormService formService) {  
533. this.formService = formService;  
534.     }  
536. publicvoid setHistoryService(HistoryService historyService) {  
537. this.historyService = historyService;  
538.     }  
540. publicvoid setRepositoryService(RepositoryService repositoryService) {  
541. this.repositoryService = repositoryService;  
542.     }  
544. publicvoid setRuntimeService(RuntimeService runtimeService) {  
545. this.runtimeService = runtimeService;  
546.     }  
548. publicvoid setTaskService(TaskService taskService) {  
549. this.taskService = taskService;  
550.     }  
552. /**
553.      * ********************************************************************************
     
554.      * **********************以上为activiti 核心service
555.      * set方法***************************
     
556.      * *********************************************************************************
     
557.      */
559. /**
560.      * ********************************************************************************
     
561.      * **********************以下为根据 任务节点ID 获取流程各对象查询方法**********************
     
562.      * *********************************************************************************
     
563.      */
565. publicvoid setProcessOtherService(ProcessOtherService processOtherService) {  
566. this.processOtherService = processOtherService;  
567.     }  
569. /**
570.      * 根据任务ID获得任务实例
571.      * 
572.      * @param taskId
573.      *            任务ID
574.      * @return
575.      * @throws Exception
576.      */
577. private TaskEntity findTaskById(String taskId) throws Exception {  
578.         TaskEntity task = (TaskEntity) taskService.createTaskQuery().taskId(  
579.                 taskId).singleResult();  
580. if (task == null) {  
581. thrownew Exception("任务实例未找到!");  
582.         }  
583. return task;  
584.     }  
586. /**
587.      * 根据流程实例ID和任务key值查询所有同级任务集合
588.      * 
589.      * @param processInstanceId
590.      * @param key
591.      * @return
592.      */
593. private List  findTaskListByKey(String processInstanceId, String key) {  
594. return taskService.createTaskQuery().processInstanceId(  
595.                 processInstanceId).taskDefinitionKey(key).list();  
596.     }  
598. /**
599.      * 根据任务ID获取对应的流程实例
600.      * 
601.      * @param taskId
602.      *            任务ID
603.      * @return
604.      * @throws Exception
605.      */
606. private ProcessInstance findProcessInstanceByTaskId(String taskId)  
607. throws Exception {  
608. // 找到流程实例
609.         ProcessInstance processInstance = runtimeService  
610.                 .createProcessInstanceQuery().processInstanceId(  
611.                         findTaskById(taskId).getProcessInstanceId())  
612.                 .singleResult();  
613. if (processInstance == null) {  
614. thrownew Exception("流程实例未找到!");  
615.         }  
616. return processInstance;  
617.     }  
619. /**
620.      * 根据任务ID获取流程定义
621.      * 
622.      * @param taskId
623.      *            任务ID
624.      * @return
625.      * @throws Exception
626.      */
627. private ProcessDefinitionEntity findProcessDefinitionEntityByTaskId(  
628.             String taskId) throws Exception {  
629. // 取得流程定义
630.         ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)  
631.                 .getDeployedProcessDefinition(findTaskById(taskId)  
632.                         .getProcessDefinitionId());  
634. if (processDefinition == null) {  
635. thrownew Exception("流程定义未找到!");  
636.         }  
638. return processDefinition;  
639.     }  
641. /**
642.      * 根据任务ID和节点ID获取活动节点 
     
643.      * 
644.      * @param taskId
645.      *            任务ID
646.      * @param activityId
647.      *            活动节点ID 
     
648.      *            如果为null或""，则默认查询当前活动节点 
     
649.      *            如果为"end"，则查询结束节点 
     
650.      * 
651.      * @return
652.      * @throws Exception
653.      */
654. private ActivityImpl findActivitiImpl(String taskId, String activityId)  
655. throws Exception {  
656. // 取得流程定义
657.         ProcessDefinitionEntity processDefinition = findProcessDefinitionEntityByTaskId(taskId);  
659. // 获取当前活动节点ID
660. if (StringUtil.isNull(activityId)) {  
661.             activityId = findTaskById(taskId).getTaskDefinitionKey();  
662.         }  
664. // 根据流程定义，获取该流程实例的结束节点
665. if (activityId.toUpperCase().equals("END")) {  
666. for (ActivityImpl activityImpl : processDefinition.getActivities()) {  
667.                 List  pvmTransitionList = activityImpl  
668.                         .getOutgoingTransitions();  
669. if (pvmTransitionList.isEmpty()) {  
670. return activityImpl;  
671.                 }  
672.             }  
673.         }  
675. // 根据节点ID，获取对应的活动节点
676.         ActivityImpl activityImpl = ((ProcessDefinitionImpl) processDefinition)  
677.                 .findActivity(activityId);  
679. return activityImpl;  
680.     }  
682. /**
683.      * ********************************************************************************
     
684.      * **********************以上为根据 任务节点ID 获取流程各对象查询方法**********************
     
685.      * *********************************************************************************
     
686.      */
687. }