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

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

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
    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. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/haore147/p/5213575.html