activiti学习（二十五）——多实例任务节点的跳转（退回、自由跳转功能）

最新推荐文章于 2024-07-31 10:17:32 发布
最新推荐文章于 2024-07-31 10:17:32 发布
阅读量5.3k 收藏 27
点赞数 6
分类专栏： Activiti
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sadoshi/article/details/106940888
版权

概述

相比普通任务节点跳转，多实例任务的跳转要考虑更多的因素，主要是因为多实例任务包含了父execution和子execution，子execution又有其对应的task，另外还有控制多实例任务的内置变量。这几个特殊点是处理多实例任务跳转的难点。关于普通节点跳转的处理，请参考前文《activiti学习（二十二）——常规任务节点跳转（退回、自由跳转功能）》

 

解决思路

与常规节点跳转相比，多实例任务有几个棘手的地方：

1、多实例任务存在父execution和子execution的情况，执行跳转时，必须删除子execution；

2、并行多实例任务存在多个task，进行跳转时，必须把多个task都删除；

3、因为并行多实例任务创建子execution的判断与流程变量有关，因此跳转时必须清除原来的流程变量；

我们的跳转命令必须解决以上三个问题。

 

具体实现

这里简单写一个命令类供各位参考。

import java.util.List;
import java.util.Map;

import org.activiti.engine.delegate.TaskListener;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.context.Context;
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.persistence.entity.ExecutionEntityManager;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntityManager;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.runtime.AtomicOperation;

public class MultiInstanceJumpCmd implements Command {

	private String taskId;
	private Map<String, Object> variables;
	private String desActivityId;
	private String scActivityId;

	public MultiInstanceJumpCmd(String taskId, Map<String, Object> variables, String scActivityId, String desActivityId) {
		this.taskId = taskId;
		this.variables = variables;
		this.desActivityId = desActivityId;
		this.scActivityId = scActivityId;
	}

	public Object execute(CommandContext commandContext) {
		TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
		TaskEntity taskEntity = taskEntityManager.findTaskById(taskId);
		ExecutionEntity parentExecutionEntity = taskEntity.getProcessInstance();
		String processDefinitionId = parentExecutionEntity.getProcessDefinitionId();
		ProcessDefinitionEntity processDefinitionEntity = Context.getProcessEngineConfiguration().getDeploymentManager()
				.findDeployedProcessDefinitionById(processDefinitionId);
		ActivityImpl curActivityImpl = processDefinitionEntity.findActivity(scActivityId);
		
		// 设置流程变量
		parentExecutionEntity.setVariables(variables);
		parentExecutionEntity.setExecutions(null);
		parentExecutionEntity.setActivity(curActivityImpl);
		parentExecutionEntity.setEventSource(curActivityImpl);
		parentExecutionEntity.setActive(true);
		// 触发全局事件转发器TASK_COMPLETED事件
		if (Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
			Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(ActivitiEventBuilder
					.createEntityWithVariablesEvent(ActivitiEventType.TASK_COMPLETED, this, variables, false));
		}

		// 删除任务
		List<TaskEntity> taskList = taskEntityManager.findTasksByProcessInstanceId(parentExecutionEntity.getProcessInstanceId());
		for(TaskEntity taskEntity1 : taskList) {
			taskEntity1.fireEvent(TaskListener.EVENTNAME_COMPLETE);
			taskEntityManager.deleteTask(taskEntity1, TaskEntity.DELETE_REASON_COMPLETED, false);	
		}

		ExecutionEntityManager executionEntityManager = Context.getCommandContext().getExecutionEntityManager();
		List<ExecutionEntity> childExecutionList = executionEntityManager.findChildExecutionsByParentExecutionId(parentExecutionEntity.getId());
		for(ExecutionEntity executionEntityChild : childExecutionList) {
			List<ExecutionEntity> childExecutionList1 = executionEntityManager.findChildExecutionsByParentExecutionId(executionEntityChild.getId());
			for(ExecutionEntity executionEntityChild1 : childExecutionList1) {
				executionEntityChild1.remove();
				Context.getCommandContext().getHistoryManager().recordActivityEnd(executionEntityChild1);
			}
			executionEntityChild.remove();
			Context.getCommandContext().getHistoryManager().recordActivityEnd(executionEntityChild);
		}
		
		commandContext.getIdentityLinkEntityManager().deleteIdentityLinksByProcInstance(parentExecutionEntity.getId());
		ActivityImpl desActivityimpl = processDefinitionEntity.findActivity(desActivityId);	
		
		parentExecutionEntity.removeVariable("nrOfInstances");
		parentExecutionEntity.removeVariable("nrOfActiveInstances");
		parentExecutionEntity.removeVariable("nrOfCompletedInstances");
		parentExecutionEntity.removeVariable("loopCounter");
		
		parentExecutionEntity.setActivity(desActivityimpl);
		parentExecutionEntity.performOperation(AtomicOperation.TRANSITION_CREATE_SCOPE);

		return null;
	}
}

这个类需要为其提供taskId，源节点id、目标节点id。35行获取父execution，36行获取流程定义id。54-58行通过流程定义id获取所有task，并删除之。60-70行删除子execution，之所以会有两个for循环，是因为并行多实例任务的子execution还会再创建子execution作为具体的执行实例。75-78行删除流程变量。81行不能使用普通节点跳转的executionEntity.executeActivity()。这是因为如果目标节点是多实例任务的话，不经过AtomicOperationTransitionCreateScope类，创建的execution会有问题。稍微跟踪一下AtomicOperation.TRANSITION_CREATE_SCOPE对应的AtomicOperationTransitionCreateScope类：

public class AtomicOperationTransitionCreateScope implements AtomicOperation {
  
//......

  public void execute(InterpretableExecution execution) {
    InterpretableExecution propagatingExecution = null;
    ActivityImpl activity = (ActivityImpl) execution.getActivity();
    if (activity.isScope()) {
      propagatingExecution = (InterpretableExecution) execution.createExecution();
      propagatingExecution.setActivity(activity);
      propagatingExecution.setTransition(execution.getTransition());
      execution.setTransition(null);
      execution.setActivity(null);
      execution.setActive(false);
      log.debug("create scope: parent {} continues as execution {}", execution, propagatingExecution);
      propagatingExecution.initialize();

    } else {
      propagatingExecution = execution;
    }

    propagatingExecution.performOperation(AtomicOperation.TRANSITION_NOTIFY_LISTENER_START);
  }
}

对于普通节点，activity.isScope()判断为false，则执行第19行。若目标节点是普通任务节点，那不会有问题。但是目标节点是多实例任务时，会执行9-16行，除了创建一个子execution以外，还让子execution去执行接下来的原子操作。具体情况说起来比较绕口，就以数据库记录来解释方便一点，当通过跳转进入并行多实例任务时，act_ru_execution表如下：

2501是父execution，其id与流程实例id是一致的。12501是上面第9行代码创建出来的execution。12506、12507、12508则是进入并行多实例任务节点后，行为类根据节点配置的属性，创建对应数量的execution，这些execution的父亲是12501。而12506、12507、12508这三个execution，下面都有对应的task，当task完成时，对应的execution会结束。所以如果像普通节点跳转那样调用executionEntity.executeActivity()的话，就不会产生12501这个execution。

 

简单演示

新建流程图multiInstanceJump.bpmn，与普通节点跳转的类似，区别是任务节点全变成了多实例任务。

<?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/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/test">
  <process id="multiInstanceJump" name="MultiInstance Jump" isExecutable="true">
    <startEvent id="startevent1" name="Start"></startEvent>
    <userTask id="usertask1" name="usertask1">
      <multiInstanceLoopCharacteristics isSequential="true">
        <loopCardinality>3</loopCardinality>
      </multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="flow1" sourceRef="startevent1" targetRef="usertask1"></sequenceFlow>
    <userTask id="usertask2" name="usertask2">
      <multiInstanceLoopCharacteristics isSequential="false">
        <loopCardinality>3</loopCardinality>
      </multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="flow2" sourceRef="usertask1" targetRef="usertask2"></sequenceFlow>
    <userTask id="usertask3" name="usertask3">
      <multiInstanceLoopCharacteristics isSequential="true">
        <loopCardinality>3</loopCardinality>
      </multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="flow3" sourceRef="usertask2" targetRef="usertask3"></sequenceFlow>
    <userTask id="usertask4" name="usertask4">
      <multiInstanceLoopCharacteristics isSequential="false">
        <loopCardinality>3</loopCardinality>
      </multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="flow4" sourceRef="usertask3" targetRef="usertask4"></sequenceFlow>
    <endEvent id="endevent2" name="End"></endEvent>
    <sequenceFlow id="flow6" sourceRef="usertask4" targetRef="endevent2"></sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_multiInstanceJump">
    <bpmndi:BPMNPlane bpmnElement="multiInstanceJump" id="BPMNPlane_multiInstanceJump">
      <bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="150.0" y="220.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask1" id="BPMNShape_usertask1">
        <omgdc:Bounds height="55.0" width="105.0" x="230.0" y="210.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask2" id="BPMNShape_usertask2">
        <omgdc:Bounds height="55.0" width="105.0" x="380.0" y="210.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask3" id="BPMNShape_usertask3">
        <omgdc:Bounds height="55.0" width="105.0" x="380.0" y="300.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask4" id="BPMNShape_usertask4">
        <omgdc:Bounds height="55.0" width="105.0" x="230.0" y="300.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="endevent2" id="BPMNShape_endevent2">
        <omgdc:Bounds height="35.0" width="35.0" x="150.0" y="310.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
        <omgdi:waypoint x="185.0" y="237.0"></omgdi:waypoint>
        <omgdi:waypoint x="230.0" y="237.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
        <omgdi:waypoint x="335.0" y="237.0"></omgdi:waypoint>
        <omgdi:waypoint x="380.0" y="237.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
        <omgdi:waypoint x="432.0" y="265.0"></omgdi:waypoint>
        <omgdi:waypoint x="432.0" y="300.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow4" id="BPMNEdge_flow4">
        <omgdi:waypoint x="380.0" y="327.0"></omgdi:waypoint>
        <omgdi:waypoint x="335.0" y="327.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow6" id="BPMNEdge_flow6">
        <omgdi:waypoint x="230.0" y="327.0"></omgdi:waypoint>
        <omgdi:waypoint x="185.0" y="327.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

接下来的部署和启动操作这里略过，不懂的读者请参考前面的文章，已经写过很多次了。其他配置与《activiti学习（二十二）——常规任务节点跳转（退回、自由跳转功能）》基本一致。

启动后查看act_ru_execution表：

userTask1为串行多实例节点。因此这时execution只有2个。

act_ru_task表：

该task对应2503那个execution。

现在我们准备从userTask1跳转到userTask4：

public void multiInstanceJump() {
	String taskId = "2509";
	Map<String, Object> variables = new HashMap<String, Object>();
	String scActivityId = "usertask1";
	String desActivityId = "usertask4";
	MultiInstanceJumpCmd multiInstanceJumpCmd = new MultiInstanceJumpCmd(taskId, variables, scActivityId, desActivityId);
	ServiceImpl service = (ServiceImpl)pe.getRepositoryService();
	CommandExecutor commandExecutor = service.getCommandExecutor();
	commandExecutor.execute(multiInstanceJumpCmd);
}

 执行后查看结果，act_ru_execution表：

 因为userTask4为并行数3的并行多实例节点，因此会有5个execution。

act_ru_task表：

 有3个任务，跳转正常。

 

小结

考虑到实际流程中，必然存在普通任务节点，也存在多实例任务节点，因此跳转的命令必须能兼容这两种情况。目前简单测试了一下，该命令能正常进行普通任务节点和多实例任务节点的跳转。此次文章纯属抛砖引玉，读者如果有更好的方法，或者发现命令中存在一些错误，也请给予指正。

sadoshi
关注
专栏目录
Android开发之activiti节点跳转
09-02
总之，通过理解Activiti的工作原理，结合Java Delegate、自定义服务任务、流程变量和事件，可以有效地实现Android开发中的节点跳转，以适应不断变化的业务需求，避免流程设计的过度复杂化。这种灵活性是现代企业级...
activiti工作流任意节点撤回
qq_33200676的博客
11-08 6405
单步回退 在这篇博文的基础上整理了注释，同时做了两步回退，上代码：/** * 多步回退 */ @Test public void rollback() { // 当前任务Id String taskId = "7503"; // 取得当前任务.当前任务节点 HistoricTaskInstance
activiti 流程回撤操作
yf826709699的博客
05-10 3508
回撤原理 ：把原有出口连线 指向回撤的目标 节点，审批过后，再还原原有连线 代码： /** *撤回逻辑 就是把当前节点的 出口连线 指向 要撤回的目标节点（上一步,实际上可以一次回退多步，同时也可以跳转多步） 然后执行任务完成，完成后恢复此节点的出口原有连线 * @param prodId 实例ID * @param taskId 任务ID */ void direction(String prodId,String taskId){ HistoryService .
Activiti 5.0 回退到任意节点
grass2114的专栏
07-31 811
处于并行网关内回退至网关外节点（如2.1回退到1），需考虑2.2是否已经完成，若已完成则不用管，若未完成，则需将2.2任务删除，否则会出现两个单。// 并行回退自动。// 判断回退任务是否在并行任务中。// 获取并行网关下的全部节点。// 获取回退节点的下一个节点。// 获取并行网关的所有入口。//判断是否要删除任务，默认不删除。// 获取回退节点。// 获取回退节点。// 判断下个节点是否为并行网关。
activiti6 回退和跳转到指定节点
weixin_44219955的博客
08-24 4397
java activiti6 回退和跳转
Activiti6.0中审批不通过时回退到上一个节点/指定节点
zmh15927652085的博客
10-12 4848
Activiti6.0中审批不通过时回退到上一个节点/指定节点
Activiti任务退回、任意跳转（任务调度）功能实现及思路（简版）
热门推荐
BUG的博客
04-03 1万+
Activiti任务退回、任意跳转（任务调度）功能实现及思路（简版）原创文章：转载请备注：原创文章地址需求：          1.在当前任务节点退回至上一节点；          2.需要跳过某一个或者几个节点后，指定节点开始继续执行此任务；          3.在流程运行时跳转到任意一节点（有没有执行过都可以跳转);这种解决的思路都是同一种方式：模拟一个需求：nowNode跳转到toNode...
也谈一下Activiti工作流节点的自由跳转
weixin_30646505的博客
12-06 1075
最近在搞openwebflow的工作流节点自由跳转功能，在网上看了一些资料，感觉不是很好，总结原因如下：直接手动调用SqlSession的操作，感觉会漏掉一些重要的初始化操作（如：启动新节点之后加载其用户授权策略，等）；只有往前（往已执行过的节点）跳转的功能，没有往后节点（往还没有执行的节点）跳转的功能；新任务不是追加到已有执行路径上，而是覆盖老任务；那么就自己动手吧！操作流程其实也简单，大概...
Activiti学习文档（二）之画流程图并部署流程
09-18
总结来说，“Activiti学习文档（二）之画流程图并部署流程”会带你走过从设计到实施一个完整流程的整个过程，包括理解BPMN符号、使用工具绘制流程图、编写部署脚本，以及如何在实际环境中运行和管理流程实例。...
Activiti 学习笔记九：并行网关(parallelGateWay)
09-11
并行网关（Parallel Gateway）在 Activiti 流程引擎中扮演着重要的角色，它是流程设计中的一个关键组件，用于实现分支和合并的功能。在本篇学习笔记中，我们将深入探讨并行网关的工作原理、使用场景以及如何在 ...
Activiti 学习例子
08-29
这个“Activiti 学习例子”压缩包很可能是为了帮助用户深入理解Activiti的核心概念、功能以及如何在实际项目中应用。下面，我们将深入探讨Activiti的相关知识点。 1. **什么是Activiti**：Activiti是一个轻量级、...
Activiti工作流使用手册操作文档
05-25
总结来说，Activiti工作流是一个功能强大且灵活的流程管理工具，通过深入学习和实践本操作手册，Java开发者能够熟练掌握其使用，从而提升业务流程的自动化水平和效率。工作流使用.doc文档将提供更详细的步骤和示例，...
Activiti回退与跳转节点
weixin_45817985的博客
09-19 1530
Activiti回退与跳转节点
activiti学习（二十二）——常规任务节点跳转（退回、自由跳转功能）
sadoshi的专栏
06-09 6259
概述 通过前面几篇文章的了解，目前我们已经具备足够的知识进行常规userTask的跳转。在“中国式流程”中，驳回、自由跳转等皆是通过这种改方式实现。可以说这也是玩activiti流程比较重要的一环。 activiti本身没有提供驳回和自由跳转的api，可能在老外的思维里，流程是不存在倒着走，或者随意跳转的，必须严格按照连线去走。我们必须通过自己手动去实现这样的功能。但是比较头疼的问题包括： 如果逐个调用实体管理类修改数据库记录，首先必须彻底摸透流程虚拟机执行情况以及流程运转时数据库变化情况，这个过于复
Activiti如何实现流程的回退
u013604967的博客
06-12 3611
1.概述 编辑 流程回退一直以来是个老旧的难题，也一直没有好的解决方法，本文就来详述流程回退的解决办法。首先我们来分析一下不同的流程审批情况，并在对应的节点上实现流程的回退处理，以及应该提供的回退处理，当然我们说的回退不是指通过在流程节点上画一条线回退到想回的节点上。 回退时，需要解决两种情况：       回退到发起人     回退到上一步及逐步回退 因为回退至任一节点上，...
Activiti流程回退
m0_59047431的博客
10-11 3083
activiti流程回退
可用的activiti工作流退回功能（退回到上一节点）（SQL、存储过程）
博风_刺耳的博客
05-30 6466
可用的activiti工作流退回功能（退回到上一节点）（SQL、存储过程）
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...
activity节点任意跳转（包含单实例、多实例）
weixin_43830468的博客
05-06 2595
实现思路： 处理掉当前的代办节点（也就是删除正在运行的该任务，更新维护历史数据） 跳转到目标节点，并把目标节点作为待办任务节点
activiti候选人和用户任务多实例的区别
最新发布
09-05
在Activiti流程引擎中，候选人用户任务(candidate user task)和多实例(multi-instance task)是两个不同的概念： 1. **候选人用户任务**：候选人用户任务是在流程定义中指定了哪些用户或角色可以处理的任务。当一个流程实例到达包含候选用户任务的位置时，这些用户会收到通知并可以选择是否接受这个任务。每个参与者只能接收并执行一次候选用户任务。 2. **多实例任务**：多实例任务是指在一个流程实例中可以根据某个条件创建多个同类型的子任务实例。这通常用于处理批量操作或者资源分配场景。比如，如果一个审批流程需要对每个订单做决策，就可以用多实例任务来创建一个审批实例针对每一个订单。每个子任务实例都是独立的，并且可以在完成后关闭，而不会影响其他子任务。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值