由于产品提出不通过网关进行审批驳回操作，进而有发起人主动召回。

@Transactional
@Override
public void recall(String processInstanceId, String taskId) {
    logger.debug("召回目标任务id：{}",taskId);
    if (iProcessService.ended(processInstanceId)) {
        throw new TaskOperationException("召回失败，流程已完结！");
    }
    //召回目标任务
    HistoricTaskInstance historicTaskInstance = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
    if (ObjectUtils.isEmpty(historicTaskInstance)) {
        throw new TaskOperationException("召回失败，未找到对应的流程实例！");
    }

    //当前任务
    TaskEntity activeTask = taskNodeUtil.getActiveTask(processInstanceId);
    if (historicTaskInstance.getTaskDefinitionKey().equalsIgnoreCase(activeTask.getTaskDefinitionKey())) {
        throw new TaskOperationException("召回失败，该任务已被召回！");
    }
    logger.debug("当前任务名称：{}，id:{}",activeTask.getName(),activeTask.getId());
    //获取召回目标任务的下级任务列表
    List<String> nextTaskDefinitionKeys = taskNodeUtil.getNextTaskDefinitionKeys(taskId);
    logger.debug("召回目标任务的下一步任务定义key：{}",nextTaskDefinitionKeys);
    String taskDefinitionKey = activeTask.getTaskDefinitionKey();
    logger.debug("当前任务定义key:{}",taskDefinitionKey);

    //如果召回目标任务的下级任务不为被召回的任务
    if (!nextTaskDefinitionKeys.contains(taskDefinitionKey)) {
        throw new TaskOperationException("召回失败，下一环节已处理！");
    }
    String assignee = activeTask.getAssignee();
    logger.debug("当前任务申领人：{}",assignee);
    if (ObjectUtils.isNotEmpty(assignee)) {
        throw new TaskOperationException("召回失败，下一环节已锁定！");
    }
    //召回目标任务申领人与召回操作人是否一致
    if (!historicTaskInstance.getAssignee().equalsIgnoreCase(processUserUtils.getUserCode())) {
        throw new TaskOperationException("召回失败，无召回权限！");
    }
    taskRollBack(activeTask.getId(),taskId);
}

/**
 * 任务召回
 * @param activeTaskId 当前激活任务id
 * @param rollBackTaskId 回滚目标任务id
 */
@Transactional
public void taskRollBack(String activeTaskId,String rollBackTaskId) {
    try {
        logger.debug("回滚任务id：{}",activeTaskId);
        //获取回滚目标任务信息
        HistoricTaskInstance rollBackTaskInstance = historyService.createHistoricTaskInstanceQuery().taskId(rollBackTaskId).singleResult();
        String assignee = rollBackTaskInstance.getAssignee();
        String processInstanceId = rollBackTaskInstance.getProcessInstanceId();
        Map<String, Object> variables;
        // 取得当前任务
        HistoricTaskInstance currTask = historyService
                .createHistoricTaskInstanceQuery().taskId(activeTaskId)
                .singleResult();
        // 取得流程实例
        ProcessInstance instance = runtimeService
                .createProcessInstanceQuery()
                .processInstanceId(currTask.getProcessInstanceId())
                .singleResult();
        if (instance == null) {
            throw new TaskOperationException("流程已经结束！");
            //流程结束
        }
        variables = instance.getProcessVariables();
        // 取得流程定义
        ProcessDefinitionEntity definition = (ProcessDefinitionEntity) (processEngine.getRepositoryService().getProcessDefinition(currTask
                .getProcessDefinitionId()));

        if (definition == null) {
            log.error("未找到对应的流程定义");
            throw new ProcessDefinitionException("未找到对应的流程定义！");
            
        }
        // 取得上一步活动
        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.complete(task.getId(), variables);
            historyService.deleteHistoricTaskInstance(task.getId());
        }
        // 恢复方向
        for (TransitionImpl transitionImpl : newTransitions) {
            currActivity.getOutgoingTransitions().remove(transitionImpl);
        }
        for (PvmTransition pvmTransition : oriPvmTransitionList) {
            pvmTransitionList.add(pvmTransition);
        }

        actInstDao.delete(activeTaskId);
        if (ObjectUtils.isNotEmpty(assignee)) {
            TaskEntity activeTask = getActiveTask(processInstanceId);
            //指定回归目标任务申领人
            taskService.claim(activeTask.getId(), assignee);
        }
        return;
    } catch (Exception e) {
        logger.error("流程召回异常",e);
        throw new ProcessInstanceException("流程召回异常！");
    }
}