Activiti工作流几种驳回方式的实现与比较

最近公司做的一个项目要实现工作流程的收回，驳回等操作，而采用的工作流引擎并不支持驳回功能，这个项目恰好就我和一个实习生一块做，所以这个问题就落到我的头上来解决了。。。

客户提出的要求是驳回时要记录日志，但是审批意见之类的需要清除掉，收回时不记录日志，审批意见同样清除。

百度了一下，总结了5个解决方案：

第一种是清除当前任务的出口，实现回到上一步的功能。

根据任务ID获取当前的任务节点，进而获取流程实例，然后取到流程的定义，找到当前活动的节点与上一步活动的节点，然后清除当前活动的出口，将上一步活动的出口作为最新的活动节点。

第二种是直接将当前的activiti引擎更换为第三方的支持退会驳回的引擎。

第三种是自己编译activiti引擎，加入退回，驳回功能。

第四种是直接操作数据库，使用历史任务替换正在进行的任务。

第五种是直接实现Command接口，实现工作流程可以任意跳转。

因为时间紧急所以直接将3.编译activiti引擎给pass掉了，本来项目是接手的离职员工的项目，更换流程引擎可能会引起其他的问题，此计划暂放。

最后在1、4、5之间决定了采用第一种，代码如下

 public String rollBackWorkFlow(String taskId) {
         try {
             Map<String, Object> variables;
             // 取得当前任务.当前任务节点
             HistoricTaskInstance currTask = historyService
                     .createHistoricTaskInstanceQuery().taskId(taskId)
                     .singleResult();
             // 取得流程实例，流程实例
             ProcessInstance instance = runtimeService
                     .createProcessInstanceQuery()
                     .processInstanceId(currTask.getProcessInstanceId())
                     .singleResult();
             if (instance == null) {
              logger.info("流程结束");
              logger.error("出错啦！流程已经结束");
                 return "ERROR";
             }
             variables = instance.getProcessVariables();
             // 取得流程定义
             ProcessDefinitionEntity definition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
                     .getDeployedProcessDefinition(currTask
                             .getProcessDefinitionId());
             if (definition == null) {
                 logger.info("流程定义未找到");
                 logger.error("出错啦！流程定义未找到");
                 return "ERROR";
             }
             // 取得上一步活动
             ActivityImpl currActivity = ((ProcessDefinitionImpl) definition)
                     .findActivity(currTask.getTaskDefinitionKey());

             //也就是节点间的连线
             List<PvmTransition> nextTransitionList = currActivity
                     .getIncomingTransitions();
             // 清除当前活动的出口
             List<PvmTransition> oriPvmTransitionList = new ArrayList<PvmTransition>();
             //新建一个节点连线关系集合

             List<PvmTransition> pvmTransitionList = currActivity
                     .getOutgoingTransitions();
             //
             for (PvmTransition pvmTransition : pvmTransitionList) {
                 oriPvmTransitionList.add(pvmTransition);
             }
             pvmTransitionList.clear();

             // 建立新出口
             List<TransitionImpl> newTransitions = new ArrayList<TransitionImpl>();
             for (PvmTransition nextTransition : nextTransitionList) {
                 PvmActivity nextActivity = nextTransition.getSource();
                 ActivityImpl nextActivityImpl = ((ProcessDefinitionImpl) definition)
                         .findActivity(nextActivity.getId());
                 TransitionImpl newTransition = currActivity
                         .createOutgoingTransition();
                 newTransition.setDestination(nextActivityImpl);
                 newTransitions.add(newTransition);
             }
             // 完成任务
             List<Task> tasks = taskService.createTaskQuery()
                     .processInstanceId(instance.getId())
                     .taskDefinitionKey(currTask.getTaskDefinitionKey()).list();
             for (Task task : tasks) {
                 taskService.claim(task.getId(), task.getAssignee());
                 taskService.complete(task.getId(), variables);
                 historyService.deleteHistoricTaskInstance(task.getId());
             }
             // 恢复方向
             for (TransitionImpl transitionImpl : newTransitions) {
                 currActivity.getOutgoingTransitions().remove(transitionImpl);
             }
             for (PvmTransition pvmTransition : oriPvmTransitionList) {
                 pvmTransitionList.add(pvmTransition);
             }
             logger.info("OK");
             logger.info("流程结束");
             return "SUCCESS";
         } catch (Exception e) {
             logger.error("失败",e);
             return "ERROR";
         }
     }

原本一切按计划进行着，但不知为什么在taskService.complete(task.getId(), variables);完成任务这一步，一直报错误，debug了好久也没有找到错误，无奈之下，采用4、5两种方式结合先将流程跳转到上一个人，然后在操作数据库清除掉一些不必要的数据。代码如下

 /**
      * 工作流*跳转
      * @param taskId 要跳转到的节点名称
      * @return
      */
     public String taskRollback(String taskId){
         //根据要跳转的任务ID获取其任务
         HistoricTaskInstance hisTask = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
         String taskAssignee = hisTask.getAssignee();
         //进而获取流程实例
         ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(hisTask.getProcessInstanceId()).singleResult();
         //取得流程定义
         ProcessDefinitionEntity definition = (ProcessDefinitionEntity) repositoryService.getProcessDefinition(hisTask.getProcessDefinitionId());
         //获取历史任务的Activity
         ActivityImpl hisActivity = definition.findActivity(hisTask.getTaskDefinitionKey());
         //实现跳转
         managementService.executeCommand(new JumpCmd(instance.getId(), hisActivity.getId()));
         return hisTask.getProcessInstanceId();
     }

重写的Command接口

 public class JumpCmd implements Command<ExecutionEntity>{

     private String processInstanceId;
     private String activityId;
     public static final String REASION_DELETE = "deleted";

     public JumpCmd(String processInstanceId, String activityId) {
         this.processInstanceId = processInstanceId;
         this.activityId = activityId;
     }

     public ExecutionEntity execute(CommandContext commandContext) {
         ExecutionEntity executionEntity = commandContext.getExecutionEntityManager().findExecutionById(processInstanceId);
         executionEntity.destroyScope(REASION_DELETE);
         ProcessDefinitionImpl processDefinition = executionEntity.getProcessDefinition();
         ActivityImpl activity = processDefinition.findActivity(activityId);
         executionEntity.executeActivity(activity);
         return executionEntity;
     }

 }

最后手动清除流程细节信息

 /**
      * 跳转到指定节点，并隐藏处理信息
      *
      * @param lastTaskID
      */
     public String Back(String lastTaskID, String runTtaskId, String back) {
         String msg = "";
         try {
             HistoricTaskInstance hisTask = historyService.createHistoricTaskInstanceQuery().taskId(lastTaskID).singleResult();
             // 判断是否会签
             boolean flag = true;
             ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService).getDeployedProcessDefinition(hisTask.getProcessDefinitionId());
             List<ActivityImpl> activitiList = processDefinitionEntity.getActivities();
             for (ActivityImpl activityImpl : activitiList) {
                 if (activityImpl.getId().equals(hisTask.getTaskDefinitionKey())) {// 找到对应任务
                     Object sign = activityImpl.getProperties().get("multiInstance");// 获取会签标识
                     if (sign != null) {// 会签
                         // 会签暂时不可以退回
                         System.out.println("会签");
                         msg = "会签不可以退回，收回";
                         flag = false;
                         break;
                     }
                 }
             }
             // 不是会签
             if (flag) {
                 // if(back!=null && !back.equals("")){
                 // // //完成当前任务，设置处理信息
                 // HistoricTaskInstance runTask =
                 // historyService.createHistoricTaskInstanceQuery().taskId(runTtaskId).singleResult();
                 // systemService.findUniqueByProperty(TSBaseUser.class,
                 // "userName", runTask.getAssignee()).getRealName();
                 // Map variables = new HashMap();
                 // variables.put("back",
                 // systemService.findUniqueByProperty(TSBaseUser.class,
                 // "userName",
                 // runTask.getAssignee()).getRealName()+"：退回到："+systemService.findUniqueByProperty(TSBaseUser.class,
                 // "userName", hisTask.getAssignee()).getRealName());
                 // taskService.claim(runTask.getId(),
                 // runTask.getAssignee());//领取任务
                 // taskService.complete(runTask.getId(), variables);//完成当前任务
                 // }
                 // 跳转到上一个处理人
                 taskRollback(lastTaskID);
                 // 设置下一步处理人
                 setAssigneeDynamic(hisTask.getProcessInstanceId(), hisTask.getAssignee());
                 // 隐藏签字痕迹，opt=0
                 String sql = "UPDATE ACT_HI_DETAIL SET LONG_='0' where ACT_INST_ID_ = (select ACT_INST_ID_ from ACT_HI_DETAIL where NAME_='taskid' and TEXT_='" + lastTaskID + "') and NAME_='opt'";
                 int i = systemService.getSession().createSQLQuery(sql).executeUpdate();
                 if (i != 1) {
                     logger.error("流程退回/收回隐藏签字意见出现问题，如果没有填写意见或者签字请忽略,流程可能已经出错,请修改ACT_HI_DETAIL表,任务ID：" + lastTaskID);
                 }
                 // 修改业务中的下一步处理人
                 ProcessInstance instance = runtimeService.createProcessInstanceQuery().processInstanceId(hisTask.getProcessInstanceId()).singleResult();

                 String id = instance.getBusinessKey();
                 TSBaseBus base = systemService.getEntity(TSBaseBus.class, id);
                 try {
                     Method getCurrentSteps = base.getClass().getMethod("setCurrentSteps", String.class);
                     Method getCurrentUsers = base.getClass().getMethod("setCurrentUsers", String.class);
                     getCurrentSteps.invoke(base, hisTask.getTaskDefinitionKey());
                     getCurrentUsers.invoke(base, hisTask.getAssignee());
                     TSPrjstatus tSPrjstatus = systemService.get(TSPrjstatus.class, BaseDataConstants.WF_STATE_REBACK);// 修改状态为退回
                     base.setTSPrjstatus(tSPrjstatus);
                 } catch (Exception e) {
                     logger.error("退回/收回时修改业务表中下一步处理人出错", e);
                 }
                 systemService.save(base);
             }
         } catch (Exception e) {
             logger.error("流程退回/收回失败,设置下一步处理人出错,任务ID:" + lastTaskID, e);
             msg = null;
         }
         return msg;
     }

中间一边写一边调试，终于可以实现驳回功能了。但是这样在实现方式上可能会出问题，因为自己操作数据代码，与activiti操作数据的代码，不在一个事物中，很可能出现流程退回去了，签字信息没有被擦除掉。

以后再使用工作流时尽量根据需求选用合适的流程引擎。

（在具体实现上参考了许多人的代码，思想）