对于activity引擎的并行流程的驳回问题

最新推荐文章于 2024-05-14 16:37:28 发布
最新推荐文章于 2024-05-14 16:37:28 发布
阅读量3k 收藏 1
点赞数 1
分类专栏： activity流程引擎 文章标签： activity引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jeamsy/article/details/99680863
版权

并行网关

并行网关的流程图

需求背景

在这里插入图片描述
要求：需要实现A驳回到B;C驳回到D,同时消掉AB段的待办，E驳回到D

在这里插入图片描述
要求：B->A;C/D->H 并且消除A/B的待办；E到H，并消除A/B的待办；F/G->H

java代码实现

// 驳回操作
List<ActivityImpl> listAct = findBackAvtivity(task.getId());
if (listAct != null && listAct.size() > 0) {
	String backActId = listAct.get(listAct.size()-1).getId();
	String type1 = (String)listAct.get(listAct.size()-1).getOutgoingTransitions().get(0).getDestination().getProperty("type");
	if ("parallelGateway".equals(listAct.get(listAct.size()-1).getOutgoingTransitions().get(0).getDestination().getProperty("type"))) {
		for (ActivityImpl act : listAct) {
			String type = (String) act.getOutgoingTransitions().get(0).getDestination().getProperty("type");   
            if ("parallelGateway".equals(type)) {
            	// 并行路线 
            	String gatewayId=act.getOutgoingTransitions().get(0).getDestination().getId();//并行网关的前一节点判断，并行网关id必须以_start结尾
                String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 1);
                if (gatewayType.toUpperCase().contains("START")){
                	backActId = act.getId();
                	variables.put("gatType", "parallelGateway");//对于并行网关第一个节点退回做判断参数
                }
            }else{
            	type = (String) act.getIncomingTransitions().get(0).getDestination().getProperty("type");
            	if ("parallelGateway".equals(type)) {
	            	// 并行路线 
	            	String gatewayId=act.getIncomingTransitions().get(0).getDestination().getId();//并行网关的后一节点判断，如果网关已经结束，则退回上一节点
	                String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 1);  
	                if (gatewayType.toUpperCase().contains("END")){
	                	backActId = listAct.get(listAct.size()-1).getId();
	                }
            	}
            }
		}
	}else if("inclusiveGateway".equals(listAct.get(listAct.size()-1).getOutgoingTransitions().get(0).getDestination().getProperty("type"))){
		for (ActivityImpl act : listAct) {
			String type = (String) act.getOutgoingTransitions().get(0).getDestination().getProperty("type");
			List<PvmTransition> outgoingTransitions = act.getOutgoingTransitions().get(0).getDestination().getOutgoingTransitions();
			//包含网关里含有并行网关
			for(PvmTransition transition : outgoingTransitions){
				if("inclusiveGateway".equals(transition.getDestination().getProperty("type"))){
					type = "inclusiveGateway";break;
				}
			}
			if ("inclusiveGateway".equals(type)) {
				// 并行路线
				String gatewayId=act.getOutgoingTransitions().get(0).getDestination().getId();//包含网关的前一节点判断，并行网关id必须以_start结尾
				String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 1);
				if (gatewayType.toUpperCase().contains("START")){
					backActId = act.getId();
					variables.put("gatType", "inclusiveGateway");//对于包含网关第一个节点退回做判断参数
				}
			}else if("inclusiveGateway".equals(type)){
				variables.put("gatType", "inclusiveGateway");//对于包含网关第一个节点退回做判断参数
			}else{
				type = (String) act.getIncomingTransitions().get(0).getDestination().getProperty("type");
				if ("inclusiveGateway".equals(type)) {
					// 并行路线
					String gatewayId=act.getIncomingTransitions().get(0).getDestination().getId();//包含网关的后一节点判断，如果网关已经结束，则退回上一节点
					String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 1);
					if (gatewayType.toUpperCase().contains("END")){
						backActId = listAct.get(listAct.size()-1).getId();
					}
				}
			}
		}
	}
	this.backProcess(taskId, backActId, variables);
} else {
	this.backProcess(taskId, lastActKey, variables);
}

/** 
 * 根据当前任务ID，查询可以驳回的任务节点 
 */  
public List<ActivityImpl> findBackAvtivity(String taskId) throws Exception {  
    List<ActivityImpl> rtnList = null;  
    rtnList = iteratorBackActivity(taskId, findActivitiImpl(taskId, null), new ArrayList<ActivityImpl>(), new ArrayList<ActivityImpl>());  
    return reverList(rtnList);  
}

/** 
 * 迭代循环流程树结构，查询当前节点可驳回的任务节点 
 */  
private List<ActivityImpl> iteratorBackActivity(String taskId,  
        ActivityImpl currActivity, List<ActivityImpl> rtnList,  
        List<ActivityImpl> tempList) throws Exception {  
    ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);  
    List<PvmTransition> incomingTransitions = currActivity.getIncomingTransitions();  
    List<ActivityImpl> exclusiveGateways = new ArrayList<ActivityImpl>();  
    List<ActivityImpl> parallelGateways = new ArrayList<ActivityImpl>();  
    for (PvmTransition pvmTransition : incomingTransitions) {  
        TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
        ActivityImpl activityImpl = transitionImpl.getSource();  
        String type = (String) activityImpl.getProperty("type");
		List<PvmTransition> pvmTransitionList = activityImpl.getIncomingTransitions();
		String floorType = pvmTransitionList.size() > 0 ? (String) pvmTransitionList.get(0).getSource().getProperty("type") : "";
		        if("parallelGateway".equals(floorType)){
		String gatewayId = pvmTransitionList.get(0).getSource().getId();
		String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 1);
		if (gatewayType.toUpperCase().contains("START")) {// 并行起点，停止递归  改为暂存不停止
			parallelGateways.add(activityImpl);break;
		} else {// 并行终点，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点
			parallelGateways.add(activityImpl);
		}
		}else{
		if ("parallelGateway".equals(type)) {// 并行路线
			String gatewayId = activityImpl.getId();
			String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 1);
			if (gatewayType.toUpperCase().contains("START")) {// 并行起点，停止递归  改为暂存不停止
				parallelGateways.add(activityImpl);
			} else {// 并行终点，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点
				parallelGateways.add(activityImpl);
			}
		} else if ("startEvent".equals(type)) {// 开始节点，停止递归
			return rtnList;
		} else if ("userTask".equals(type)) {// 用户任务
			tempList.add(activityImpl);
		} else if ("exclusiveGateway".equals(type)) {// 分支路线，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点
			currActivity = transitionImpl.getSource();
			exclusiveGateways.add(currActivity);
		}else if("inclusiveGateway".equals(type)){// 包含路线
			String gatewayId = activityImpl.getId();
			String gatewayType = gatewayId.substring(gatewayId.lastIndexOf("_") + 1);
			if (gatewayType.toUpperCase().contains("START")) {// 并行起点，停止递归  改为暂存不停止
				parallelGateways.add(activityImpl);
			} else {// 并行终点，临时存储此节点，本次循环结束，迭代集合，查询对应的userTask节点
				parallelGateways.add(activityImpl);
			}
		}
		}
    }
    for (ActivityImpl activityImpl : exclusiveGateways) {  
        iteratorBackActivity(taskId, activityImpl, rtnList, tempList);  
    }  
    for (ActivityImpl activityImpl : parallelGateways) {  
        iteratorBackActivity(taskId, activityImpl, rtnList, tempList);  
    }  
    currActivity = filterNewestActivity(processInstance, tempList);  
    if (currActivity != null) {  
        String id = findParallelGatewayId(currActivity);  
        if (StringUtils.isEmpty(id)) {// 并行起点ID为空，此节点流向不是并行终点，符合驳回条件，存储此节点  
            rtnList.add(currActivity);  
        } else {// 根据并行起点ID查询当前节点，然后迭代查询其对应的userTask任务节点  
            currActivity = findActivitiImpl(taskId, id);  
        }  
        tempList.clear();  
        iteratorBackActivity(taskId, currActivity, rtnList, tempList);  
    }  
    return rtnList;  
}

/** 
 * 根据当前节点，查询输出流向是否为并行终点，如果为并行终点，则拼装对应的并行起点ID 
 */  
private String findParallelGatewayId(ActivityImpl activityImpl) {  
    List<PvmTransition> incomingTransitions = activityImpl  
            .getOutgoingTransitions();  
    for (PvmTransition pvmTransition : incomingTransitions) {  
        TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
        activityImpl = transitionImpl.getDestination();  
        String type = (String) activityImpl.getProperty("type");  
        if ("parallelGateway".equals(type)) {// 并行路线  
            String gatewayId = activityImpl.getId();  
            String gatewayType = gatewayId.substring(gatewayId  
                    .lastIndexOf("_") + 1);  
            if ("END".equals(gatewayType.toUpperCase())) {  
                return gatewayId.substring(0, gatewayId.lastIndexOf("_"))  
                        + "_start";  
            }  
        }  
    }  
    return null;  
}

小结：第一次写这个，没什么经验，网上有关这个的资料不多，大家多多关照

Jeamsy
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Activiti 学习笔记九：并行网关(parallelGateWay)
09-11
Activiti 学习笔记九：并行网关(parallelGateWay)
flowable流程引擎-核心表分析
06-27
Flowable流程引擎核心表分析 流程引擎的核心表是Flowable流程引擎的基础组件，用于存储流程引擎的各种数据。这些表可以配置为在启动时生成，所有的表都以“act_”开头，沿用了Activiti的传统。 Flowable流程引擎...
Activiti 5.0 回退到任意节点（并行）
编程笔记
12-22 3729
Activiti 5.0 回退到任意节点（并行） 应用场景 ​ 针对activiti中国式需求，实现平行网关回退 解决方案 任意节点回退思路 获取回退节点id，获取当前任务id 保存当前任务节点id流向 清除当前任务节点id流向 将当前任务节点任务流向退回节点id 完成当前节点任务 恢复当前节点流向 针对并行网关 处于并行网关内回退至网关外节点（如2.1回退到1），需考虑2.2是否已经完成，若已完成则不用管，若未完成，则需将2.2任务删除，否则会出现两个单 处于并行网关外回退至网关内节点（如3回退到2
activiti——网关配置
最新发布
专注写bug
05-14 867
文章目录前言网关介绍代码案例测试各项网关排他网关 ExclusiveGateway1、绘制流程图2、编写测试代码并行网关ParallelGateway1、绘制流程图2、编写测试代码包含网关InclusiveGateway1、绘制流程图2、编写测试代码 前言 在activiti工作流中，还有一个组件也很重要，那就是网关，并在许多的流程设计中都会进行使用操作。 网关介绍 常见的网关有以下4种，分别如下所示。 排他网关 ExclusiveGateway 多条分支线路，执行满足条件的一条流程。 当流程执行到这个
activiti之并行网关，驳回
勤奋写代码的人
11-28 2万+
并行网关并不能实现驳回功能
Activiti工作流并行网关驳回在发起问题
qq_48157004的博客
10-11 5552
它记录了人员3（同意），人员4（同意），人员5（同意）三次记录。导致第二次审批时，并行节点有一个同意，就走到了人员7节点。流程从发起人走到并行节点 -> 人员3，和人员4，人员5，人员6是并行。人员3（同意），人员4（同意），人员5（同意），人员6（不同意）回到发起人节点。因为驳回操作会删除其他表记录，删除这几条记录不会因为主键影响报错。流程又开始从发起人走到人员3，人员4，人员5，人员6并行节点。这时会出现一个问题？最后发现问题出现在运行时流程执行实例表( act_ru_execution )
Activity并行网关驳回处理
weixin_44603382的博客
04-29 344
流程发起时需要由A和B共同审批，两人审批都通过之后交由C审批，当C审批驳回后，进入流程修改环节，再次提交后重新由A和B共同审批。第一版本的流程图画法：第一个并行网关分别对应了流出的两条分支A和B，加上一个修改的流入分支；这样的画法是错误的，流程发起后流程只会走到第一个并行网关处，不会走到A和B节点。
【actviti】并行网关驳回问题解决方案
牧xin的博客
11-06 2740
并行的多条支线是一个事务 并行的多线支线内部可以进行驳回 并行不能进行外部向内部的驳回 并行网关成对出现 如图，绿色框内可以看作是并行网关的内部，倘若需要从结案的节点驳回至资料整理则不可实现 想办法中 难受ya ...
springboot-activity6-流程在线设计器.zip
09-03
【标题】"springboot-activity6-流程在线设计器"是一个基于SpringBoot框架的项目，它提供了设计和管理工作流程的功能。这个项目的核心是实现一个在线的流程设计器，让用户可以通过直观的图形界面来创建和编辑流程。 ...
activity启动流程
03-01
activity启动流程
Activity的启动流程
01-31
Activity启动分为很多种情况，这里说的是打开新的应用程序第一个Activity的流程。ActivityManagerService.javaprivatefinalvoidstartProcessLocked(ProcessRecordapp,StringhostingType,StringhostingNameStr){ //...
activiti demo(请假流程，涉及到并行和排他网关等，可以参考当做学习参考代码，如开发环境须谨慎)
04-09
代码中包含了并行 排他网关等，里边只有一个请假流程。能从员工到公司总裁，可以参考一下。 登陆页面:http://127.0.0.1:8080/Activiti-LFP/main.jsp 1.人员组成 员工: zhangsan 默认密码123 lisi wangba 组长 wangba 项目经理 ss szx 项目总监 lyj 人事 ss 公司副总裁 dzt 公司总裁 cc2 管理员 sjb
Activiti6-流程跟踪监控图-节点-流程线高亮显示-支持通过、不通过、驳回、退回
03-25
Activiti6-流程跟踪监控图-节点-流程线高亮显示-支持通过、不通过、驳回、退回 支持内容： 已完成节点高亮显示、当前执行中节点红色显示 支持一个节点多条流出线，包括通过、不通过、驳回、退回，按照已执行操作正确显示高亮流程线
activity6.0-流程图高亮
04-09
在IT行业中，流程图是一种非常重要的工具，它用于可视化地表示业务流程或系统操作的步骤。...在实际应用中，这是一项非常实用且有价值的功能，尤其对于涉及复杂流程的企业来说，它能显著提高工作效率和流程透明度。
activiti工作流的驳回等功能的封装 转
轻耘智科技CTO 尤胜荣 的专栏
07-12 592
       中国人的流程习惯是有来有往，能审批通过就应该能驳回。即可驳回到流程线上任意一节点，而国外的流程引擎思想这点与国内差别很大，为了满足国内的项目需要，就必须对这些流程引擎进行封装或改造。 我们采用的是activiti5.9流程引擎，封装的基本方法如下(代码无法直接运行，仅提供思路)： import java.util.ArrayList; import java.util....
activiti 并行网关中驳回后并行强制结束其他任务
lw670020705的专栏
12-23 2430
需求：并行审批，即同时存在多个任务（使用并行网关），任一任务被驳回， 其他并行任务也需结束掉 使用普通的结束节点，并不会真正结束流程。需要将存在的其他任务默认完成，流程才能结束。 初始流程图如下 优化后： 使用TerminateEndEvent activiti可以自动结束其他任务，避免人为操作，也避免多任务并行时需要递归处理。 ...
activiti并行审批流程驳回（折腾了好几天）
热门推荐
hichinamobile的博客
01-18 2万+
并行审批流程驳回功能，网上提供了方案，但该方案代码复杂并且有再次提交时有问题。并行网关不会计算线路中设置的条件，如果设置了，则会自动忽略。一直卡在这四天的时间，今早继续在《activiti实战》中寻找方案；偶然想到要看看并行网关部分。突然想到...
Activiti驳回至并行网关，增加虚拟节点，后台自动完成
weixin_45716024的博客
05-16 1423
原始需求 如图示例：节点1后面是并行网关，有两个节点，节点4需要驳回至并行网关，这样直接画线是不行的，节点走完后任务就没有了，不会走到节点2和节点3。看到别的文章说是并行网关只能有一个一条线进入。 改变思路，可以在并行网关前边增加一个“”虚拟“”节点，后台判断下一个节点是虚拟节点，就自动完成任务，这样就可以到达并行节点了。 //完成当前任务 actTaskService.complete(qmsZq8dProblem.getAct().getTaskId(), qmsZq8dProblem.getAct
Activiti分支/网格/驳回操作
zhangCheng的博客
05-22 3488
一、概念 任务节点处理完成之后,后面的处理可能需要根据不同的调节走不同的流程(选择一条路径,串行),或者是将任务分发到多个审批人头上（分发到多条流程路径）, 或者在某个任务节点要判断多个人审批之后才能继续执行（多条路径汇聚到一点）。 这种操作就要用到流程分支的概念,一个分支相当于就是一个子流程,有串行流,也有并行流。 二、连线流程 在连线上设置条件,根据条件判断后面的流程走那个分支,这样做的好处在于方便快捷,坏处在于如果所以连线都没有满足条件,则当前流程会异常结束,不会 有异常显示。 步骤: 在bp
activity流程引擎
07-27
活动流程引擎是一种用于管理和执行业务流程的技术。它提供了一个可视化的界面，使用户能够定义和设计业务流程，并且可以自动化执行这些流程。 在一个活动流程引擎中，业务流程被划分为一系列的活动或任务，每个活动都有一个特定的目标和执行条件。用户可以定义活动之间的顺序、逻辑和依赖关系，以及每个活动的输入和输出。 一旦定义好了业务流程，活动流程引擎可以自动化执行这些流程。它会根据预先定义的规则和条件，自动触发适当的活动，并且跟踪和记录每个活动的执行状态和结果。它还可以处理异常情况，并且根据需要进行流程的调整和优化。 活动流程引擎可以应用于各种领域和行业，如工作流管理、订单处理、客户关系管理等。它可以提高业务流程的效率和一致性，减少人工操作和错误，同时也增加了业务流程的灵活性和可扩展性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值