Activiti回退与跳转节点

最新推荐文章于 2025-09-14 03:43:41 发布
原创 最新推荐文章于 2025-09-14 03:43:41 发布 · 2.3k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Activiti #java

本文档介绍了如何在Activiti6.0的审批流程中实现当审批不通过时，回退到上一个节点或用户指定的节点的功能，包括查询历史节点、修改流程方向并完成任务撤销操作。

Activiti6.0中审批不通过时回退到上一个节点/指定节点

在当前做的这个审批流中，需要增加一个审批不通过时回退节点的功能，因为当前系统需求还没有特别明确这部分，所以我就先写了以下两种回退情况：

1.回退到上一个节点

 /**
     * 撤回到上一个节点
     * @param processInstanceId
     * @param nowUserId
     */
    @Override
    @Transactional
    public void revoke(String processInstanceId, String nowUserId) {
        //获取待执行的任务节点
        Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
        if(task == null){
           // throw new Exception("sorry,the process is not started or has finished, cannot be withdrawn");
            System.out.println("sorry,the process is not started or has finished, cannot be withdrawn");
        }
        //通过processInstanceId查询历史节点
        List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInstanceId)
                .orderByTaskCreateTime()
                .asc()
                .list();
        String myTaskId = null;
        HistoricTaskInstance myTask = null;
        //找到当前运行的节点
        HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
        ProcInstance procInstance = procInstanceMapper.selectById(processInstance.getBusinessKey()).get(0);
        SysUser startUser = sysUserService.selectUserById(procInstance.getUserId());
        List<SysUser> currUsers = findCurrUsers(task, startUser);
        System.out.println("----------- =-= -------currUser-----------------------"+currUsers.get(0).getUserId());
        System.out.println("------ =-= ------nowUserId--------------------------"+nowUserId);
        for (HistoricTaskInstance hti : htiList) {
            //判断一下当前的用户是否为当前任务的审批负责人 ， 感觉后面通过权限赋予也可以不加这个判断
            //if (currUsers.get(0).getUserId().equals(nowUserId)&& hti.getId().equals(task.getId())) {
            if ( currUsers.get(0).getUserId().toString().equals(nowUserId)&&hti.getId().equals(task.getId())) {
                myTaskId = hti.getId();  //当前任务id
                myTask = hti;
                break;
            }
        }
        if (null == myTaskId) {
            //throw new Exception("该任务非当前用户提交，无法撤回");
            System.out.println("该任务非当前用户提交，无法撤回~~!!");
        }
        String processDefinitionId = myTask.getProcessDefinitionId();
        //获取流程模型
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
        String myActivityId = null;
        //查询已经完成的流程节点，查询到上一条已完成的节点，则跳出循环
        List<HistoricActivityInstance> haiList = historyService.createHistoricActivityInstanceQuery()
                .executionId(myTask.getExecutionId())
                .finished()
                .orderByHistoricActivityInstanceStartTime()
                .desc()
                .list();
        System.out.println("---------------the latest finished---------------"+haiList.get(0));
        myActivityId = haiList.get(0).getActivityId();
//        for (HistoricActivityInstance hai : haiList) {
//            if (myTaskId.equals(hai.getTaskId())) {
//                myActivityId = hai.getActivityId();
//                break;
//            }
//        }
        //最近一个已完成节点的 FlowNode
        FlowNode myFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(myActivityId);
        //原本的活动方向
        Execution execution = runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();
        String activityId = execution.getActivityId();
        FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(activityId);
        //记录原活动方向
        List<SequenceFlow> oriSequenceFlows = new ArrayList<SequenceFlow>();
        oriSequenceFlows.addAll(flowNode.getOutgoingFlows());
        //清理活动方向
        flowNode.getOutgoingFlows().clear();
        //建立新方向
        List<SequenceFlow> newSequenceFlowList = new ArrayList<SequenceFlow>();
        SequenceFlow newSequenceFlow = new SequenceFlow();
        newSequenceFlow.setId("newSequenceFlowId"+" WITHDRAW: "+nowtime());
        //新方向的源头---当前节点
        newSequenceFlow.setSourceFlowElement(flowNode);
        //新方向的目标---上一个已完成节点
        newSequenceFlow.setTargetFlowElement(myFlowNode);
        newSequenceFlowList.add(newSequenceFlow);
        flowNode.setOutgoingFlows(newSequenceFlowList);

        Authentication.setAuthenticatedUserId(nowUserId);
        taskService.addComment(task.getId(), task.getProcessInstanceId(), "撤回");
        //完成任务
        taskService.complete(task.getId());
        //恢复原方向
        flowNode.setOutgoingFlows(oriSequenceFlows);
        System.out.println("------------------withdraw successfully！！----------------------------");
        logger.info("退回成功！");
    }

2.回退到当前审批用户指定的节点
先查询一下当前流程实例的历史Activity表：

 /**
     * 展示历史Activity表
     * @param proInstanceId
     * @return
     */
    @Override
    @Transactional
    public List hisActInst(String proInstanceId){
        HistoricProcessInstance instance = historyService.createHistoricProcessInstanceQuery().processInstanceBusinessKey(proInstanceId).singleResult();
        String processInstanceId = instance.getId();
        //获取待执行的任务节点
        Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
        if(task == null){
            // throw new Exception("sorry,the process is not started or has finished, cannot be withdrawn");
            System.out.println("sorry,the process is not started or has finished, cannot be withdrawn");
        }
        //通过processInstanceId查询历史节点
        List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInstanceId)
                .orderByTaskCreateTime()
                .asc()
                .list();
        String myTaskId = null;
        HistoricTaskInstance myTask = null;
        //找到当前运行的节点
        HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
        ProcInstance procInstance = procInstanceMapper.selectById(processInstance.getBusinessKey()).get(0);
        SysUser startUser = sysUserService.selectUserById(procInstance.getUserId());
        List<SysUser> currUsers = findCurrUsers(task, startUser);
        for (HistoricTaskInstance hti : htiList) {
            //判断一下当前的用户是否为当前任务的审批负责人 ， 感觉后面通过权限赋予也可以不加这个判断
            //if (currUsers.get(0).getUserId().equals(nowUserId)&& hti.getId().equals(task.getId())) {
            if ( hti.getId().equals(task.getId())) {
                myTaskId = hti.getId();  //当前任务id
                myTask = hti;
                break;
            }
        }
        if (null == myTaskId) {
            //throw new Exception("该任务非当前用户提交，无法撤回");
            System.out.println("该任务非当前用户提交，无法撤回~~!!");
        }
        List<HistoricActivityInstance> haiList = historyService.createHistoricActivityInstanceQuery()
                .executionId(myTask.getExecutionId())
                .finished()
                .orderByHistoricActivityInstanceStartTime()
                .desc()
                .list();
        return haiList;
    }

在根据获取到的目标回退节点的ActivityId进行回退操作：

/**
     * 回退到指定节点处
     * @param processInstanceId
     * @param nowUserId
     * @param tarActivityId
     * @return
     */
    @Override
    @Transactional
    public void rollBackToSpec(String processInstanceId, String nowUserId, String tarActivityId) {
        //获取待执行的任务节点
        Task task = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
        if(task == null){
            // throw new Exception("sorry,the process is not started or has finished, cannot be withdrawn");
            System.out.println("sorry,the process is not started or has finished, cannot be withdrawn");
        }
        //通过processInstanceId查询历史节点
        List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
                .processInstanceId(processInstanceId)
                .orderByTaskCreateTime()
                .asc()
                .list();
        String myTaskId = null;
        HistoricTaskInstance myTask = null;
        //找到当前运行的节点
        HistoricProcessInstance processInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
        ProcInstance procInstance = procInstanceMapper.selectById(processInstance.getBusinessKey()).get(0);
        SysUser startUser = sysUserService.selectUserById(procInstance.getUserId());
        List<SysUser> currUsers = findCurrUsers(task, startUser);
        System.out.println("----------- =-= -------currUser-----------------------"+currUsers.get(0).getUserId());
        System.out.println("------ =-= ------nowUserId--------------------------"+nowUserId);
        for (HistoricTaskInstance hti : htiList) {
            //判断一下当前的用户是否为当前任务的审批负责人 ， 感觉后面通过权限赋予也可以不加这个判断
            //if (currUsers.get(0).getUserId().equals(nowUserId)&& hti.getId().equals(task.getId())) {
            if ( currUsers.get(0).getUserId().toString().equals(nowUserId)&&hti.getId().equals(task.getId())) {
                myTaskId = hti.getId();  //当前任务id
                myTask = hti;
                break;
            }
        }
        if (null == myTaskId) {
            //throw new Exception("该任务非当前用户提交，无法撤回");
            System.out.println("该任务非当前用户提交，无法撤回~~!!");
        }
        String processDefinitionId = myTask.getProcessDefinitionId();
        //获取流程模型
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
//        String myActivityId = null;
        //查询已经完成的流程节点，查询到上一条已完成的节点，则跳出循环
//        List<HistoricActivityInstance> haiList = historyService.createHistoricActivityInstanceQuery()
//                .executionId(myTask.getExecutionId())
//                .finished()
//                .orderByHistoricActivityInstanceStartTime()
//                .desc()
//                .list();
//        System.out.println("---------------the latest finished---------------"+haiList.get(0));
//        myActivityId = haiList.get(0).getActivityId();
        //想要回退到的节点位置
        System.out.println(tarActivityId);
        FlowNode myFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(tarActivityId);
        //原本的活动方向
        Execution execution = runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();
        String activityId = execution.getActivityId();
        FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(activityId);
        //记录原活动方向
        List<SequenceFlow> oriSequenceFlows = new ArrayList<SequenceFlow>();
        oriSequenceFlows.addAll(flowNode.getOutgoingFlows());
        //清理活动方向
        flowNode.getOutgoingFlows().clear();
        //建立新方向
        List<SequenceFlow> newSequenceFlowList = new ArrayList<SequenceFlow>();
        SequenceFlow newSequenceFlow = new SequenceFlow();
        newSequenceFlow.setId("newSequenceFlowId"+" ROLLBACK: "+nowtime());
        //新方向的源头---当前节点
        newSequenceFlow.setSourceFlowElement(flowNode);
        System.out.println("--------------new flow-----------------"+flowNode);
        //新方向的目标---要回退的节点
        System.out.println("--------------target flow-----------------"+myFlowNode);
        newSequenceFlow.setTargetFlowElement(myFlowNode);
        newSequenceFlowList.add(newSequenceFlow);
        flowNode.setOutgoingFlows(newSequenceFlowList);

        Authentication.setAuthenticatedUserId(nowUserId);
        taskService.addComment(task.getId(), task.getProcessInstanceId(), "回退");
        //完成任务
        System.out.println("========================完成任务====================");
        taskService.complete(task.getId());

        //恢复原方向
        flowNode.setOutgoingFlows(oriSequenceFlows);
        System.out.println("------------------RollBack successfully！！----------------------------");
        logger.info("退回成功！");
        //将退回完成后的当前节点的task返回
//        HistoricActivityInstance historicActivityInstance = historyService.createHistoricActivityInstanceQuery().activityId(tarActivityId).singleResult();
//
//        return historicActivityInstance.getTaskId();
    }
activiti工作流节点跳转
qq_35796004的博客
06-27 963
Activiti实现节点跳转主要有两种方法：一是通过自定义跳转命令实现灵活跳转，二是使用官方API修改流程实例。自定义命令需继承Command接口，包含任务删除和目标节点设置逻辑，适合复杂场景；官方API则更简便，适合简单回退操作。关键要注意流程变量传递、多实例任务处理及节点合法性校验。推荐简单场景用官方API，复杂跳转需求采用自定义命令实现。
Activiti 5.0 回退到任意节点
grass2114的专栏
07-31 1602
处于并行网关内回退至网关外节点（如2.1回退到1），需考虑2.2是否已经完成，若已完成则不用管，若未完成，则需将2.2任务删除，否则会出现两个单。// 并行回退自动。// 判断回退任务是否在并行任务中。// 获取并行网关下的全部节点。// 获取回退节点的下一个节点。// 获取并行网关的所有入口。//判断是否要删除任务，默认不删除。// 获取回退节点。// 获取回退节点。// 判断下个节点是否为并行网关。
Activiti流程节点跳过机制：条件表达式与流程变量控制
最新发布
gitblog_00251的博客
09-14 446
在复杂业务流程中，动态跳过某些节点（如审批环节、数据校验步骤）是提升流程效率的关键能力。Activiti/Activiti（基于BPMN 2.0的工作流引擎）通过**条件表达式（Condition Expression）** 与**流程变量（Process Variable）** 的协同控制，实现节点的动态跳过。本文将系统解析两种核心实现方式的技术细节，并通过企业级案例展示最佳实践。 ### 1...
Activiti如何实现流程的回退
u013604967的博客
06-12 3959
1.概述 编辑 流程回退一直以来是个老旧的难题，也一直没有好的解决方法，本文就来详述流程回退的解决办法。首先我们来分析一下不同的流程审批情况，并在对应的节点上实现流程的回退处理，以及应该提供的回退处理，当然我们说的回退不是指通过在流程节点上画一条线回退到想回的节点上。 回退时，需要解决两种情况：       回退到发起人     回退到上一步及逐步回退 因为回退至任一节点上，...
Activiti流程回退
m0_59047431的博客
10-11 3271
activiti流程回退
activiti 5.22 退回代码
09-08
工作流 activiti 5.22 退回代码实现。 activiti在设计的时候没有回退相关的操作，回退是中国特有的特色。这里写一个比较简单的回退。不支持回退到并行网关前面节点，虽然回退到前面节点不会报错 但会导致任务无法结束。使用没有并行网关的回退。
activiti学习之回退实现
wang0907的博客
10-09 5953
1：创建流程 使用 eclipse工作流插件 画图，如下是效果： 也可以直接使用如下的xml: <?xml version="1.0" encoding="UTF-8"?> <definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSch
activiti6 回退和跳转到指定节点
weixin_44219955的博客
08-24 5069
java activiti6 回退和跳转
Activiti 5.0 回退到任意节点（2）
编程笔记
09-14 2348
activiti在每个正在执行的任务都有一个执行器，即ru_task表（数据表act_ru_task，后面介绍到数据表会省略act_）的数据会与ru_execution有相对应的关系，当前的跳转实现就用到这个执行器，俗话说就是鸠占鹊巢的方法。旧版：使用改变节点的去向，然后使用taskService.complete的方法将任务强行回退给指定的节点，然后在恢复节点的去向，这种的如果用在非并行流程其实是没问题的。新版：使用跳转的方式，不会推动进程，改变的最少，需要删除比较多的数据。
activiti6.0节点跳转,回退功能实现
年轻的时候要多吃苦,这样老了吃苦才习惯
08-05 1714
上面是我的流程图大概的样子 1.每个节点设置节点ID 2,我的发起人会在任务提交的时候动态设置执行人为提交的用户ID,这样拒绝的时候使用用户ID就可以查询到任务 3.审批人1会发送一个target到排他网关,网关通过target判断是通过还是拒绝,通过直接到审批人2,拒绝就会把任务发送给发送人,并把当前拒绝的节点ID存储到业务表中, 4.发送人节点收到任务后,通过用户ID查询到任务,然后再设置重新提交任务还是拒绝提交,拒绝提交直接结束,重新提交会把任务通过节点ID指定给上一个节点的人 5.代码 publi.
Activiti6实现自由跳转(可实现回退操作)
taisuiyu6397的博客
04-22 6609
Activiti6实现自由跳转(可实现回退操作) 工作快2年的小白，如有错误，恳请大家批评指点 Activiti实现跳转的方式： 1.流程图配置连线，正常流转 这个是最安全的也是最可靠的 2.直接指定当前流程实例执行所选的环节 先看下流程图 图1：: 如果第2步驳回 那流程应该回到第一步。接下来看代码如何实现: if (“yes”.equals(msg)) { // 批准 map.put(“审批结...
Activiti6.0中审批不通过时回退到上一个节点/指定节点
zmh15927652085的博客
10-12 5631
Activiti6.0中审批不通过时回退到上一个节点/指定节点
Activiti工作流异常退回流程上一个节点
bestwinner的专栏
01-24 925
log.error("工作流接口调用失败-退回到指定节点：errorMessage:{}", cause.getMessage());return Result.error("工作流接口调用失败-退回到指定节点：请稍后再试！log.error("工作流接口内部调用失败:{}", cause.getMessage());return Result.error("找不到要审批的数据");wfAuditDto.setComment("流程异常处置");* 工作流-退回到指定节点。//异常退回流程上一个节点。
ACTIVITI 5.22.0 流程退回上一节点，实现多实例串行与并行退回
热门推荐
10-05 1万+
import java.util.ArrayList; import java.util.Date; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.activiti.engine.history.HistoricActivityIns...
activiti流程回退与流程结束
pscool的博客
11-25 4890
【工作流Activiti7】3、Activiti7 回退与会签 【工作流Activiti7】4、Activiti7 结束/终止流程Activiti-跳转到指定节点、回退ativiti6.0 流程节点自由跳转实现、拒绝/不同意/返回上一节点、流程撤回、跳转、回退等操作（通用实现，亲测可用） - 掘金 activiti6.0源码剖析之节点任意跳转 -简书Activiti回退与跳转节点Activiti7 工作流非原流程终止2020-10-21Activiti会签以及会签驳回activiti学习（二十二）——常规任
【工作流Activiti7】3、Activiti7 回退与会签
wufaqidong1的博客
12-24 7697
多个人同时处理一个任务，这种任务我们称之为会签任务。Activiti实现会签是基于多实例任务，将节点设置成多实例，主要通过在UserTask节点的属性上配置。zhaoliu审批的时候pass传的false，于是流程又走到zhangsan那里，流程重新又走了一遍才全部完成。当zhangsan完成自己的任务后，进入会签环节，于是我们看到当前有3个激活的任务。刚才的例子中没有考虑到审批不通过的情况，接下来我们完善一下，考虑下面的流程。接下来，我们运行上面的代码，回退到上一个节点“部门经理审批”，于是。
Activiti——流程回退和会签
吴声子夜歌的博客
09-12 4154
使用参数启动流程，需要注意的是，启动流程时设置了“pass”参数为true,表示默认通过。当流程通过一个流程节点后，Activiti会记录流程的历史记录，流程的当前活动已经不再是通过的这个节点，如果想做到“毫无痕迹”的回退，那么就需要非常熟悉Activiti的数据库设计，自己编写数据。在图所示的流程中，如果审核任务不通过，就会触发信号边界事件，执行流会进入到补偿处理的任务中，补偿任务主要处理款项申请中实际产生的业务数据（非流程数据），如果没有发生任何的业务数据变化，那么可以不必存在该任务。
【activiti审批手动回退上一任务,处理垃圾数据，不是常规回退】
weixin_43932964的博客
07-03 707
【代码】【activiti审批手动回退上一任务,处理垃圾数据，不是常规回退】
activity跳转回退
qq_17524035的博客
08-15 914
Intent intent = new Intent(getContext(), OtherAccountActivity.class); intent.putExtra("userId",ownId); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK); getContext().sta
Activiti跳转任意节点
07-22
<think>我们正在讨论Activiti工作流引擎中如何实现流程跳转到任意节点的问题。根据引用[3]的内容，Activiti提供了节点跳转的功能，允许从一个节点跳转到另一个节点，即使它们之间没有直接的连线。 在Activiti中，流程的跳转通常通过`RuntimeService`的`createProcessInstanceModification`方法来实现。这允许我们在流程实例运行时修改其执行路径。具体步骤如下： 1. 获取当前流程实例的ID。 2. 使用`RuntimeService`创建一个流程实例修改对象（`ProcessInstanceModificationBuilder`）。 3. 指定要取消的当前活动节点（如果需要）。 4. 指定要跳转到的目标节点（使用节点ID）。 5. 执行修改。 这里有一个简单的代码示例： ```java // 获取RuntimeService RuntimeService runtimeService = ... // 通过流程引擎获取 String processInstanceId = "当前流程实例ID"; String targetNodeId = "目标节点ID"; // 例如：usertask5 // 创建修改 runtimeService.createProcessInstanceModification(processInstanceId) .cancelActivityInstance("当前活动节点实例ID") // 可选，如果当前节点只有一个活动实例，可以通过活动实例ID取消 .startBeforeActivity(targetNodeId) // 跳转到目标节点之前，即启动目标节点 .execute(); ``` 或者，如果我们知道当前的任务ID，我们可以先获取当前的任务，然后获取当前的活动节点实例，再进行跳转。 另一种方法是使用`ActivityInstance`来获取当前的活动节点实例信息，然后进行跳转。 注意：跳转操作需要谨慎，因为它会改变流程的正常路径，可能会影响流程数据的完整性。因此，在执行跳转前，需要确保目标节点是合法的，并且跳转后流程的状态仍然是一致的。 另外，Activiti还提供了通过`Execution`对象进行跳转的方式，例如： ```java List<Execution> executions = runtimeService.createExecutionQuery() .processInstanceId(processInstanceId) .activityId("当前节点ID") // 例如：usertask3 .list(); for (Execution execution : executions) { runtimeService.createChangeActivityStateBuilder() .processInstanceId(processInstanceId) .moveExecutionTo(execution.getId(), targetNodeId) .changeState(); } ``` 以上代码中，我们首先查询到当前正在执行的执行流（execution），然后使用`createChangeActivityStateBuilder`来改变执行流的状态，将其移动到目标节点。 需要注意的是，这些操作都需要在流程实例处于运行状态时进行，并且跳转的目标节点必须在流程定义中存在。 在实际应用中，我们可能需要根据业务需求选择合适的跳转方式，并处理跳转后可能产生的数据变更和后续流程的走向。 §§相关问题§§ 1. Activiti中流程跳转有哪些注意事项？ 2. 如何回退到上一个节点？ 3. Activiti中流程跳转后，流程变量如何处理？</think>在 Activiti 工作流引擎中实现流程跳转到任意节点的功能，可以通过以下两种核心方法实现： ### 方法一：使用 `RuntimeService.createProcessInstanceModification`（推荐） ```java String processInstanceId = "当前流程实例ID"; String targetNodeId = "目标节点ID"; // 如 usertask5 runtimeService.createProcessInstanceModification(processInstanceId) .cancelAllForActivity("当前活动节点ID") // 取消当前节点 .startBeforeActivity(targetNodeId) // 启动目标节点 .execute(); ``` **说明**： 1. `cancelAllForActivity()` 终止当前节点所有实例 2. `startBeforeActivity()` 在目标节点前创建新执行流 3. 适用于 Activiti 5.17+ 版本[^3] ### 方法二：使用 `CommandContext`（底层API） ```java ProcessEngineConfigurationImpl config = (ProcessEngineConfigurationImpl) ProcessEngines.getDefaultProcessEngine().getProcessEngineConfiguration(); config.getCommandExecutor().execute(commandContext -> { ExecutionEntity execution = ...; // 获取当前执行实例 execution.destroyScope("跳转原因"); // 创建新执行路径 ExecutionEntity newExecution = execution.createExecution(); newExecution.setCurrentFlowElement( processDefinition.findActivityElement(targetNodeId) ); // 触发节点进入事件 newExecution.executeActivityBehavior(); return null; }); ``` **说明**： 1. 直接操作执行实例(`ExecutionEntity`) 2. 需要手动处理流程作用域和事件触发 3. 适用于需要深度定制场景[^2] ### 关键注意事项 1. **节点有效性**：目标节点必须在流程定义中存在 2. **变量处理**：跳转后需手动同步流程变量 ```java runtimeService.setVariables(newExecutionId, variablesMap); ``` 3. **事件触发**：自动节点（如ServiceTask）需手动触发`execute()` 4. **历史记录**：跳转操作会生成`ACT_HI_ACTINST`历史记录 5. **并发控制**：多实例场景需遍历所有执行实例 > 重要提示：流程跳转属于高风险操作，会破坏正常流程路径，建议仅在调试或特殊业务场景使用。生产环境应优先考虑通过`BPMN 2.0`规范的`boundary event`或`sequenceFlow`实现合法流转[^1]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

princeAladdin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值