activiti学习（二十八）——加签

最新推荐文章于 2026-05-14 06:31:25 发布
原创 最新推荐文章于 2026-05-14 06:31:25 发布 · 1.2w 阅读 · 51 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Activiti

当前文章被收录于：

Activiti
28 篇文章 264 人学习
订阅专栏 查看详情

开发板推荐：天空星STM32F407VET6开发板

超高性价比 STM32主控 | 超高主频 | 一板兼容百芯 | 比赛神器 | 沉金彩色丝印

点击查看

概述

加签本质上就是让多实例任务增加一个处理任务和新增处理人。在业务流程中常有一种情况是，如果A审批，那么直接通过，如果是B审批，则还需要C审批才能通过。后一类情况就特别适合使用加签。另外在转他人处理的问题上，普通任务节点可以通过自由跳转到本节点实现，但多实例任务中这样处理会导致该任务节点所有处理人重新开始处理任务，所以多实例任务的转他人处理不适合用自由跳转，更适合通过加签去实现。

 

实现

串行多实例任务加签

直接上源码

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.TaskEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntityManager;

public class SequenceContersignCmd implements Command {

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

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

	public Object execute(CommandContext commandContext) {
		TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
		TaskEntity taskEntity = taskEntityManager.findTaskById(taskId);
		ExecutionEntity executionEntity = taskEntity.getExecution();
		
		//多实例任务总数加一
		Integer nrOfInstances = (Integer)executionEntity.getVariable("nrOfInstances");
		executionEntity.setVariable("nrOfInstances", nrOfInstances + 1);
		
		// 设置流程变量
		executionEntity.setVariables(variables);

		return null;
	}
}

串行多实例的加签非常简单，只需要调整任务总数变量nrOfInstances加一即可。因为串行多实例任务每个时刻最多只会有一个活动实例，所以当前活动实例数恒定是一，nrOfActiveInstances不用变。执行这个命令类，即可

 

并行多实例加签

import java.util.Date;
import java.util.Map;

import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
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.TaskEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntityManager;

public class ParallelContersign implements Command {

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

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

	public Object execute(CommandContext commandContext) {
		ProcessEngineConfigurationImpl pec = commandContext.getProcessEngineConfiguration();
		TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
		TaskEntity taskEntity = taskEntityManager.findTaskById(taskId);
		ExecutionEntity executionEntity = taskEntity.getExecution();

		// 设置流程变量
		executionEntity.setVariables(variables);

		ExecutionEntity parentExecutionEntity = executionEntity.getParent();
		ExecutionEntity newExecutionEntity = parentExecutionEntity.createExecution();
		newExecutionEntity.setActive(true);
		newExecutionEntity.setConcurrent(true);
		newExecutionEntity.setScope(false);
		TaskEntity newTaskEntity = new TaskEntity();
		newTaskEntity.setCreateTime(new Date());
		newTaskEntity.setTaskDefinition(taskEntity.getTaskDefinition());
		newTaskEntity.setProcessDefinitionId(taskEntity.getProcessDefinitionId());
		newTaskEntity.setTaskDefinitionKey(taskEntity.getTaskDefinitionKey());
		newTaskEntity.setProcessInstanceId(taskEntity.getProcessInstanceId());
		newTaskEntity.setExecutionId(newExecutionEntity.getId());
		newTaskEntity.setName(taskEntity.getName());
		newTaskEntity.setId(pec.getIdGenerator().getNextId());
		newTaskEntity.setExecution(newExecutionEntity);
		pec.getTaskService().saveTask(newTaskEntity);

		Integer nrOfInstances = (Integer)executionEntity.getVariable("nrOfInstances");
		Integer nrOfActiveInstances = (Integer)executionEntity.getVariable("nrOfActiveInstances");
		executionEntity.setVariable("nrOfInstances", nrOfInstances + 1);
		executionEntity.setVariable("nrOfActiveInstances", nrOfActiveInstances + 1);
		newExecutionEntity.setVariableLocal("loopCounter", nrOfInstances);
		
		return null;
	}
}

并行多实例的加签复杂一些，主要是并行多实例任务需要我们手动新建execution和对应的task。24-25行获取当前taskId对应的execution，30行再获取其父execution。31-34行通过父execution创建子execution并为其设置属性。35-45行新建task并设置其属性，最后进行保存。49行增加任务总数变量nrOfInstances，50行增加活动实例数，51行设置execution的局部变量loopCounter，loopCounter变量其实就是类似一个index，作为多实例任务的序列号。

 

转他人处理

文章开头提到了转他人处理的问题。这里准备以实例进行说明如何通过加签实现转他人处理。

首先创建命令类TransferToOtherCmd.java

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.activiti.engine.TaskService;
import org.activiti.engine.impl.bpmn.behavior.SequentialMultiInstanceBehavior;
import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
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.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;

public class TransferToOtherCmd implements Command {

	private String taskId;
	private Map<String, Object> variables;
	private String assignee;

	public TransferToOtherCmd(String taskId, Map<String, Object> variables, String assignee) {
		this.taskId = taskId;
		this.variables = variables;
		this.assignee = assignee;
	}

	public Object execute(CommandContext commandContext) {
		ProcessEngineConfigurationImpl pec = commandContext.getProcessEngineConfiguration();
		TaskService taskService = pec.getTaskService();
		TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
		TaskEntity taskEntity = taskEntityManager.findTaskById(taskId);
		ExecutionEntity executionEntity = taskEntity.getExecution();
		String processDefinitionId = executionEntity.getProcessDefinitionId();
		ProcessDefinitionEntity processDefinitionEntity = Context.getProcessEngineConfiguration().getDeploymentManager()
				.findDeployedProcessDefinitionById(processDefinitionId);
		ActivityImpl curActivityImpl = processDefinitionEntity.findActivity(taskEntity.getName());

		List<String> assigneeList = (List<String>) executionEntity.getVariable("assigneeList");
		
		if (curActivityImpl.getActivityBehavior() instanceof SequentialMultiInstanceBehavior) {
			Integer nrOfInstances = (Integer) executionEntity.getVariable("nrOfInstances");
			Integer loopCounter = (Integer) executionEntity.getVariable("loopCounter");
			executionEntity.setVariableLocal("nrOfInstances", nrOfInstances + 1);
			List<String> newAssigneeList = new ArrayList<String>();
			
			int i=0;
			for(; i<loopCounter + 1; i++) {
				newAssigneeList.add(assigneeList.get(i));
			}
			newAssigneeList.add(assignee);
			for(; i<assigneeList.size(); i++) {
				newAssigneeList.add(assigneeList.get(i));
			}
			newAssigneeList.addAll(assigneeList);
			executionEntity.setVariable("assigneeList", newAssigneeList);
		} else {
			ExecutionEntity parentExecutionEntity = executionEntity.getParent();
			ExecutionEntity newExecutionEntity = parentExecutionEntity.createExecution();
			newExecutionEntity.setActive(true);
			newExecutionEntity.setConcurrent(true);
			newExecutionEntity.setScope(false);
			TaskEntity newTaskEntity = new TaskEntity();
			newTaskEntity.setCreateTime(new Date());
			newTaskEntity.setTaskDefinition(taskEntity.getTaskDefinition());
			newTaskEntity.setProcessDefinitionId(taskEntity.getProcessDefinitionId());
			newTaskEntity.setTaskDefinitionKey(taskEntity.getTaskDefinitionKey());
			newTaskEntity.setProcessInstanceId(taskEntity.getProcessInstanceId());
			newTaskEntity.setExecutionId(newExecutionEntity.getId());
			newTaskEntity.setName(taskEntity.getName());
			newTaskEntity.setId(pec.getIdGenerator().getNextId());
			newTaskEntity.setExecution(newExecutionEntity);
			newTaskEntity.setAssignee(assignee);
			pec.getTaskService().saveTask(newTaskEntity);

			Integer nrOfInstances = (Integer) executionEntity.getVariable("nrOfInstances");
			Integer nrOfActiveInstances = (Integer) executionEntity.getVariable("nrOfActiveInstances");
			executionEntity.setVariable("nrOfInstances", nrOfInstances + 1);
			executionEntity.setVariable("nrOfActiveInstances", nrOfActiveInstances + 1);
			newExecutionEntity.setVariableLocal("loopCounter", nrOfInstances);
		}
		// 设置流程变量
		executionEntity.setVariables(variables);
		
		taskService.complete(taskId);

		return null;
	}
}

类的属性assignee表示转给谁处理。这个转他人处理类基本融合了串行多实例和并行多实例加签的代码。这里假设多实例任务的collection属性为assigneeList，那么流程变量assigneeList的列表里面放置的是多实例任务的处理人。49-58行为串行多实例任务添加处理人。如果把转发目标处理人加到assigneeList尾部，那么任务提交后，下一个处理人不是目标处理人。例如我们原来指定张三、李四、王五作为三个处理人，张三处理的时候转给赵六去处理，如果把赵六加到assigneeList尾部，那么张三提交转他人处理后，下一个是李四处理，赵六放到最后了！而我们的预期应该是张三转赵六处理，张三提交后下一个处理人应该是赵六。所以要把赵六插到assigneeList中张三后面才对。如果张三是第一个人，那赵六就应该插在第一个元素后面。并行多实例则不需要这样做，只需要在75行对任务设置对应的处理人即可。最后在87行提交当前任务。

接下来测试一个串行多实例任务的实例，流程图如下：

<?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="串行多实例任务" name="串行多实例任务" isExecutable="true">
    <startEvent id="startevent1" name="Start"></startEvent>
    <userTask id="员工互评" name="员工互评" activiti:assignee="${assignee}">
      <multiInstanceLoopCharacteristics isSequential="true" activiti:collection="assigneeList" activiti:elementVariable="assignee">
        <loopCardinality>3</loopCardinality>
      </multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="flow1" sourceRef="startevent1" targetRef="员工互评"></sequenceFlow>
    <userTask id="领导审核" name="领导审核" activiti:assignee="丁总"></userTask>
    <sequenceFlow id="flow2" sourceRef="员工互评" targetRef="领导审核"></sequenceFlow>
    <endEvent id="endevent1" name="End"></endEvent>
    <sequenceFlow id="flow3" sourceRef="领导审核" targetRef="endevent1"></sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_串行多实例任务">
    <bpmndi:BPMNPlane bpmnElement="串行多实例任务" id="BPMNPlane_串行多实例任务">
      <bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="150.0" y="320.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="员工互评" id="BPMNShape_员工互评">
        <omgdc:Bounds height="55.0" width="105.0" x="230.0" y="310.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="领导审核" id="BPMNShape_领导审核">
        <omgdc:Bounds height="55.0" width="105.0" x="380.0" y="310.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="530.0" y="320.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
        <omgdi:waypoint x="185.0" y="337.0"></omgdi:waypoint>
        <omgdi:waypoint x="230.0" y="337.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
        <omgdi:waypoint x="335.0" y="337.0"></omgdi:waypoint>
        <omgdi:waypoint x="380.0" y="337.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
        <omgdi:waypoint x="485.0" y="337.0"></omgdi:waypoint>
        <omgdi:waypoint x="530.0" y="337.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

我们定义一个简单的串行多实例任务的流程，设定多实例任务数为3，处理人的列表读取流程变量assigneeList。然后我们初始化流程引擎并部署该流程。然后启动流程的时候设置流程变量：

public void startProcessByIdWithVar() {
	RuntimeService runtimeService = pe.getRuntimeService();
	List<String> assigneeList = new ArrayList<String>();
	assigneeList.add("张三");
	assigneeList.add("李四");
	assigneeList.add("王五");
	Map<String, Object> vars = new HashMap<String, Object>();
	vars.put("assigneeList", assigneeList);
	ProcessInstance pi = runtimeService.startProcessInstanceById("串行多实例任务:1:4", vars);
	System.out.println("流程定义ID：" + pi.getProcessInstanceId());
	System.out.println("流程实例ID：" + pi.getId());
}

之后观察数据库表

act_ru_execution表：

act_ru_task表：

act_ru_variable表：

通过act_ru_task表我们看到当前assignee是张三，接下来我们调用写好的TransferToOtherCmd命令：

public void TransferToOther() {
	String taskId = "2513";
	Map<String, Object> variables = new HashMap<String, Object>();
	TransferToOtherCmd TransferToOtherCmd = new TransferToOtherCmd(taskId, variables, "赵六");
	ServiceImpl service = (ServiceImpl)pe.getRepositoryService();
	CommandExecutor commandExecutor = service.getCommandExecutor();
	commandExecutor.execute(TransferToOtherCmd);
}

这个函数根据taskId，调用TransferToOtherCmd命令，把张三的任务提交给赵六。执行后，可以查看act_ru_task表：

此时任务处理人已经变味赵六。

至于并行多实例任务的情况，读者可以自行测试结果。

 

小结：

加签是业务流程中常见的情况，而是否需要用加签来作为转他人处理的手段，读者可以自行斟酌，本文只是抛砖引玉。除了加签之外，有时候可能还会有“减签”的业务情况。减签其实和加签原理差不多，对于串行多实例任务，无非就是减少任务总数变量nrOfInstances，对于并行多实例任务则除了修改任务总数变量nrOfInstances，还要修改活动实例数nrOfActiveInstances，并且被删除任务的loopCount变量以及为被删除任务loopCount大于被删除任务的都要减一，同时还要删除相关execution和task。不过本人暂时没遇到过业务上需要减签的情况。

开发板推荐：天空星STM32F407VET6开发板

超高性价比 STM32主控 | 超高主频 | 一板兼容百芯 | 比赛神器 | 沉金彩色丝印

点击查看
Activiti7笔记（八）activiti加签，转签，会签，任务监听器，添加查询审批意见
一天不写代码难受的博客
04-08 1万+
目录1 加签功能2转签功能3 会签3.1 什么是会签3.2 会签实现流程4 任务监听器4.1 实现5 Activiti添加和查询审批意见 1 加签功能 我们已经定义好一个bump，并且已经将这个流程保存到数据库中，比如申请请假，有个人申请了请假，经理已经审批完成，总经理改审批了，本来应该是总经理审批完成，这个流程就走完了，这个就是我们在bump里面定义好的，但是这个时候，总经理想让董事长知道这个，想看看董事长的看法，所以需要将这个请假申请加签到董事长，这个董事长审批是不在这个bump里面的，这个要知道；
多实例节点加签
weixin_42617164的博客
12-02 2125
activiti加签实现，activiti中命令模式，责任链模式的使用，activiti事务，日志拦截器。 springProcessEngineConfiguration，CommandExecutor，CommandInvoker
基于Multisim的数字逻辑电路仿真：家用电风扇智能控制方案设计与实现
最新发布
weixin_30314813的博客
05-14 640
本文详细介绍了基于Multisim的数字逻辑电路仿真技术，应用于家用电风扇智能控制系统的设计与实现。通过74系列TTL逻辑芯片搭建核心电路，实现风速循环控制、风种模式切换等功能，并结合Multisim仿真环境进行调试优化，为电子爱好者提供了一套完整的智能控制解决方案。
Activiti6---流程加签征询实现
Lv_vI的博客
08-14 3820
文章目录1. 加签2. 征询3. 测试 1. 加签 加签是指当前节点审批完后需要额外再加一个审批人进行审批，额外加的审批用户审批完后流程流转到下一节点。比如正常审批流程为A->B->C，如果B执行了加签动作，那么流程就变为A->B-->D-->C，节点D就是加进来的。 医学上有个万能药叫做安慰剂，没有任何药物作用，可能就是一颗糖果，但患者并不知道，但因患者对医生信任、患者叫自我暗示以及对某种药物疗效的期望等而起到镇痛、镇蘸或缓解症状的作用。为什么提到这个呢，因为加签的方案就是一
activitiy学习 (动态加签，动态流程图，指定节点跳转，指定多人节点跳转)
星空下的博客
02-15 8853
activitiy学习 (动态加签，动态流程图，指定节点跳转，指定多人节点跳转)
Activiti7工作流引擎：进阶篇(十二) 委派(加签)和转交(转签)
人不风流枉少年
12-19 1万+
加签就是委派任务delegateTask，然后去解决任务resolveTask（并不是去真正的去完成任务）。 转签完成后才能完成任务complete。 一：委派任务 A由于某些原因不能处理该任务可以把任务委派给用户B代理，当B决绝完之后再次回到用户A这里，然后由A去完成任务，在这个过程中A是任务的所有者OWNER_，B是该任务的办理人Assignee。A->B->A。 应用场景：这事太大，我做不了主，我先问一下老大delegateTask，如果老大说可以resolveTask我就完成审批..
SpringBoot整合activiti
m0_43399885的博客
01-21 736
大力出奇迹 Author:ymy 困扰了朕半个月的springBoot和activiti的整合，终于弄好了，中间走了很多弯路，虽说其实这个整合很简单，但是但是查找网上资料被误导了很多地方(可能也是因为自己学艺不精没有理解作者的意图)，下面奉上两种springBoot整合activiti的方案。截止2019-8-29可用 1. 不使用starter整合 依赖 <dependency...
【二十三】springboot整合activiti7（1）实战演示篇
weixin_56995925的博客
05-01 1万+
springboot整合activiti7（1）实战演示篇
# SpringBoot 整合 Activiti 工作流框架
不积跬步，无以至千里；不积小流，无以成江海
02-17 4497
SpringBoot 整合 Activiti 工作流框架 Activiti 介绍 Activiti是一个开源的工作流引擎，它实现了BPMN 2.0规范，可以发布设计好的流程定义，并通过api进行流程调度。Activiti 作为一个遵从 Apache 许可的工作流和业务流程管理开源平台，其核心是基于 Java 的超快速、超稳定的 BPMN2.0 流程引擎，强调流程服务的可嵌入性和可扩展性，同时更加强调面向业务人员。 简单来说activiti是一个业务流程管理引擎，会沿着设计者设计好的流程，一步一步的执
mysql查询待办_SpringBoot中引入Activiti并完成基本业务流程
weixin_35541322的博客
01-28 381
ActivitiDB中各个表的作用Activiti的后台是有数据库的支持，所有的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 (图片，规则，等等)。ACT_RU_*: 'RU'表示runtime。 这些运行时的表，包含流程实例，任务，变量，异步任务，等运行中的...
SpringBoot中引入Activiti并完成基本业务流程
Mirage__的博客
01-15 671
Activiti DB中各个表的作用 Activiti的后台是有数据库的支持，所有的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 (图片，规则，等等)。 ACT_RU_*: 'RU'表示runtime。 这些运行时的表，包含流程实例，任务，变量，异...
【二十八】springboot之通过threadLocal+参数解析器实现同session一样保存当前登录信息的功能
weixin_56995925的博客
06-11 2811
springboot之通过threadLocal+参数解析器实现同session一样保存当前登录信息的功能
Java学习路线
zukxu123的博客
09-03 217
文章目录前言一、Java是什么？二、学习路线Java基础一：Java开发介绍二：Java数组三：Java面向对象四：常用基础类五：集合六：IO流七：多线程八：异常九：网络十：反射十一：MySQL使用十二：JDBC连接池十三：Servlet十四：JSP十五：AJAX十六：jQuery十七：BootstrapJava框架十八：Maven十九：Hibernate二十：Spring二十一：Spring MVC二十二：MyBatis二十三：WebService二十四：SVN二十五：ActivitiJava + 云数据
【一】springboot整合swagger
weixin_56995925的博客
08-31 2万+
springboot整合swagger
【三十二】springboot+freemarker实现按模板导出word
weixin_56995925的博客
05-18 1942
springboot+freemarker实现按模板导出word
activity多实例任务加签
congge
06-26 3万+
前言 加签是减签的相反的操作，加签与减签的思路刚好相反，减签是删数据；加签则是添加数据。在一些特殊场景下，需要在某个多实例节点上面动态新增一个审批人员或任务时，就需使用到activity多实例任务加签的功能 加签思路1 根据一级流程实例查找二级流程执行实例 判断二级执行实例是否是多实例任务节点的父级实例 通过两级执行实例创建三级执行实例； 通过二级执行实例获取nrOfInstances并+1 加签思路2 通知新的实例开始执行，并创建相应的数据 执行用户任务行为类，进而创建任务相关的数据 注意：不要触
activity动态加签任意节点
热门推荐
congge
07-04 8万+
前言 设想这么一种场景，一个流程有3级审批，其中第一级审批完毕后本应该到达二级审批的，但是可能觉得这个流程模板设置的不尽合理，需要再在上面增加一级审批人，即变成4级审批，这个需求该怎么做呢？ 按照我们初步的设想，解决办法大概有这么两种思路： 第一，修改流程模板 这是一种大家很容易想到的方法，即重新更新一下流程定义文件，更改审批节点的审批人，所谓直接修改模板。在模板中添加节点以及连线，并修改实例的走向。 第二，修改流程定义对应的缓存数据 即不修改模板，新增的节点与当前需要加签的实例挂钩，关于缓存数据，我们可以
activiti学习（二十七）——涉及并行网关的节点跳转
sadoshi的专栏
07-17 3432
这篇文章不会教大家如何对并行网关后的并行任务进行跳转。关于并行任务的跳转，分享牛大神有他的代码。不过我觉得并行网关分支出来的任务，无论从现实业务还是逻辑实现上，都不应该可以随意跳转。 分享牛的跳转逻辑，无非是把并行分支的execution及其对应task都结束，然后跳转到目标节点上。然而这里其实涉及一些问题。从业务上来讲，某个分支流程，它自己是否要跳转到别的节点，不应该影响平行的其他任务节点，除非有明确的业务要求。从实现逻辑的角度来说，当存在多个并行网关多次分支的流程图中，跳转到某个节点时，到底需要提前结
优雅的实现Activiti动态调整流程（自由跳转、前进、后退、分裂、前加签、后加签等），含范例代码！...
weixin_30865427的博客
12-29 6760
最近对Activiti做了一些深入的研究，对Activiti的流程机制有了些理解，对动态调整流程也有了一些实践方法。现在好好总结一下，一来是对这段时间自己辛苦探索的一个记录，二来也是为后来者指指路~~~如下内容准备采用QA的方式写，很多问题都是当初自己极疑惑的问题，希望能为大家解惑！Q：可以动态调整流程吗？A：可以！可以动态更改流程指向，或者创建新的节点，等等。。。Q: 更改流程还需要注意什么...
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值