Activiti+Springboot跳转到任意节点

以你之姓@ 2022-05-16 08:44 213阅读 0赞

[参考链接：Activiti工作流几种驳回方式的实现与比较][Activiti]

## 1.TaskFlowControlService 方法类 ##

package com.epf.activiti.service;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    import org.activiti.engine.HistoryService;
    import org.activiti.engine.ManagementService;
    import org.activiti.engine.RepositoryService;
    import org.activiti.engine.RuntimeService;
    import org.activiti.engine.TaskService;
    import org.activiti.engine.history.HistoricTaskInstance;
    import org.activiti.engine.impl.RepositoryServiceImpl;
    import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
    import org.activiti.engine.impl.pvm.PvmActivity;
    import org.activiti.engine.impl.pvm.PvmTransition;
    import org.activiti.engine.impl.pvm.process.ActivityImpl;
    import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;
    import org.activiti.engine.impl.pvm.process.TransitionImpl;
    import org.activiti.engine.runtime.ProcessInstance;
    import org.activiti.engine.task.Task;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /** * * <code>TaskFlowControlService</code> (节点自由跳转) * @author zhouxib * @version V1.0 * @date 2018 2018年8月18日 下午1:51:12 */
    @Component
    public class TaskFlowControlService {
        @Autowired
        private  TaskService  taskService  ;
    
    
        @Autowired
        private ManagementService managementService;
    
        @Autowired
        private HistoryService historyService;
    
        @Autowired
        private RuntimeService runtimeService;
    
        @Autowired
        private RepositoryService repositoryService;
    
         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"; 
             }  
         }  
    
    
         /** * 工作流自由跳转 * @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(); 
         } 
    
    }

## 2.重写的Command接口 ##

/** * com.epf.activiti.service * * ver date author * ────────────────────────────────── * 2018年8月18日 GZEPF * * Copyright (c) 2018, gomai. */
    
    package com.epf.activiti.service;
    
    import org.activiti.engine.impl.interceptor.Command;
    import org.activiti.engine.impl.interceptor.CommandContext;
    import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
    import org.activiti.engine.impl.pvm.process.ActivityImpl;
    import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;
    
    /** * * @author GZEPF * @version * @date 2018年8月18日 下午2:48:21 */
     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; 
         }  
    
     }

## 3.案例：驳回至第一个环节 ##

@RequestMapping("runbackStater")
    public R runbackStater(String processInstanceId){
        //1.获取需要跳转的流程环节processid
        List<HistoricTaskInstance> historicTaskInstance= historyService.createHistoricTaskInstanceQuery().processInstanceId(processInstanceId).orderByTaskCreateTime().asc().list();
        if(historicTaskInstance!=null && historicTaskInstance.size()>0){
            //2.跳转到指定节点
            taskFlowControlService.taskRollback(historicTaskInstance.get(0).getId());
            return R.ok("操作成功！");
        }else{
            return R.error("操作失败！");
        }
    
    
    }

[Activiti]: http://www.php361.com/index.php?c=index&a=view&id=3490