RollbackTaskCmd

最新推荐文章于 2023-09-06 14:52:10 发布
最新推荐文章于 2023-09-06 14:52:10 发布
阅读量413 收藏
点赞数
分类专栏： 记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38441551/article/details/94622134
版权 
package com.pty.workflow.service.extend;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import org.activiti.bpmn.model.ExclusiveGateway;
import org.activiti.bpmn.model.FlowElement;
import org.activiti.bpmn.model.FlowNode;
import org.activiti.bpmn.model.Process;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.bpmn.model.StartEvent;
import org.activiti.bpmn.model.UserTask;
import org.activiti.engine.HistoryService;
import org.activiti.engine.delegate.event.ActivitiEventDispatcher;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.impl.cmd.NeedsActiveTaskCmd;
import org.activiti.engine.impl.context.Context;
import org.activiti.engine.impl.interceptor.CommandContext;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.HistoricIdentityLinkEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.task.Task;

import com.pty.workflow.api.RollbackPosition;

import lombok.extern.slf4j.Slf4j;

@Slf4j
/* @Service */
public class RollbackTaskCmd extends NeedsActiveTaskCmd<Void> {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1264547749014497759L;

	private RollbackPosition _position;

	private String _designatedNodeId;
	
	private String _exeNodeId;

	public RollbackTaskCmd(String taskId, RollbackPosition position, String exeNodeId,String... designatedNodeId) {
		super(taskId);
		_position = position;
		_exeNodeId = exeNodeId;
		if (designatedNodeId.length > 0) {
			_designatedNodeId = designatedNodeId[0];
		}
	}

	@Override
	protected Void execute(CommandContext commandContext, TaskEntity task) {

		ActivitiEventDispatcher eventDispatcher = Context.getProcessEngineConfiguration().getEventDispatcher();
		// TODO(liubo): 增加退回的enum
		if (eventDispatcher.isEnabled()) {
			eventDispatcher
					.dispatchEvent(ActivitiEventBuilder.createEntityEvent(ActivitiEventType.TASK_COMPLETED, task));
		}

		if (task.getExecutionId() != null) {
			ExecutionEntity executionEntity = commandContext.getExecutionEntityManager()
					.findExecutionById(task.getExecutionId());
			if (_position.equals(RollbackPosition.START)) {
				rollback2Start(commandContext, task, executionEntity);
			} else if (_position.equals(RollbackPosition.PREVIOUS)) {
				rollback2Previous(commandContext, task, executionEntity);
			} else if (_position.equals(RollbackPosition.DESIGNATED)) {
				rollback2Designated(commandContext, task, executionEntity,_exeNodeId);
			}
			// Context.getAgenda().planTriggerExecutionOperation(executionEntity);
		}
		return null;
	}

	// 退回到流程初始的任务节点
	private void rollback2Start(CommandContext commandContext, TaskEntity task, ExecutionEntity executionEntity) {
		// TODO(liubo): 设置creator
		String creator=this.getProcessCreator(task, commandContext);
		task.setVariable("creator", this.getProcessCreator(task, commandContext));
		List<TaskEntity> tasks = commandContext.getTaskEntityManager().findTasksByExecutionId(task.getExecutionId());
		tasks.forEach(taskEntity -> {
			// commandContext.getTaskEntityManager().delete(taskEntity);
			commandContext.getTaskEntityManager().deleteTask(taskEntity, null, false);
		});
		Process process = Context.getProcessEngineConfiguration().getRepositoryService()
				.getBpmnModel(task.getProcessDefinitionId()).getMainProcess();
		String firstUserTaskNode = process.findFlowElementsOfType(StartEvent.class).get(0).getOutgoingFlows().get(0)
				.getTargetRef();
		task.fireEvent("rollback");
		executionEntity.removeTask(task);
		executionEntity.executeActivity(executionEntity.getProcessDefinition().findActivity(firstUserTaskNode));
	}

	// 退回到上一个任务节点
	private void rollback2Previous(CommandContext commandContext, TaskEntity task, ExecutionEntity executionEntity) {
		commandContext.getTaskEntityManager().deleteTask(task, null, false);
		// HistoryManager historyManager = commandContext.getHistoryManager();
		// historyManager.recordTaskEnd(taskId, "shareniu-jump");
		Process process = Context.getProcessEngineConfiguration().getRepositoryService()
				.getBpmnModel(task.getProcessDefinitionId()).getMainProcess();
		List<FlowElement> prevNode = getPrevousNode(task, process);
		
		
		List<Task> list = Context.getProcessEngineConfiguration().getTaskService().createTaskQuery()
				.processInstanceId(task.getProcessInstanceId()).list();
		if (list.size() >= 2) {
			for (Task task2 : list) {
				if (!task2.getId().equals(task.getId())) {
					commandContext.getTaskEntityManager().deleteTask((TaskEntity) task2, null, false);
				}
			}

		}
		prevNode.stream().forEach(node -> {
			if (node == null) {
				throw new RuntimeException("前置任务节点未找到");
			}
			if (((FlowNode) node).getIncomingFlows().stream().anyMatch(ele -> {
				String s=ele.getSourceRef();
				return StartEvent.class.isAssignableFrom(process.getFlowElement(ele.getSourceRef()).getClass());
			})) {
				task.setVariable("creator", this.getProcessCreator(task, commandContext));
			}
			// TODO(liubo):如果退回的是第一个任务节点，将creator注入
			task.fireEvent("rollback");
			executionEntity.removeTask(task);
			
	        /*String processDefinitionId = task.getProcessDefinitionId();
	        ProcessDefinitionEntity processDefinitionEntity = new GetDeploymentProcessDefinitionCmd(processDefinitionId).execute(commandContext);
	        ActivityImpl activityImpl = processDefinitionEntity.findActivity(task.getTaskDefinitionKey());
	         Map<String, Object> currMap = activityImpl.getProperties();
	         if (currMap.containsKey("multiInstance")) { // 删除当前多实例任务
	        	// executionEntity= task.getExecution().getParent().getParent(); //taskEntity.getExecution();
	        this.deleteExecution(task);
	        }
	         
	         executionEntity.setProcessInstance(executionEntity);
	         executionEntity.setProcessDefinitionId(historicActivityInstanceEntity.getProcessDefinitionId());
	         executionEntity.setActivity(targetActivity);
	         executionEntity.setActive(false);
	         executionEntity.setConcurrent(false);
	         executionEntity.setCachedEntityState(0);*/

	        

			executionEntity.executeActivity(executionEntity.getProcessDefinition().findActivity(node.getId()));
		});
	}
	
	/*public void deleteExecution(TaskEntity taskEntity) {
		// 删除未处理任务信息
          List<TaskEntity> taskEntities = Context.getCommandContext().getTaskEntityManager().findTasksByProcessInstanceId(taskEntity.getProcessInstanceId());
		for (TaskEntity taskEntity2 : taskEntities) {
		List<VariableInstanceEntity> varLis = Context.getCommandContext().getVariableInstanceEntityManager().findVariableInstancesByExecutionId(taskEntity2.getExecutionId());
		for (VariableInstanceEntity variableInstanceEntity : varLis) {
		Context.getCommandContext().getVariableInstanceEntityManager().delete(variableInstanceEntity);
		}
		Context.getCommandContext().getExecutionEntityManager().delete(taskEntity2.getExecution());
		}
// 获取多实例同节点处理任务
		HistoricTaskInstanceQueryImpl historicTaskInstanceQueryImpl = new HistoricTaskInstanceQueryImpl();
		 historicTaskInstanceQueryImpl.taskDefinitionKey(taskEntity.getTaskDefinitionKey());
		 historicTaskInstanceQueryImpl.processInstanceId(taskEntity.getProcessInstanceId());
		 historicTaskInstanceQueryImpl.setFirstResult(0);
		 historicTaskInstanceQueryImpl.setMaxResults(999);
		 historicTaskInstanceQueryImpl.orderByTaskCreateTime().asc();
		 List<HistoricTaskInstance> historicTaskInstanceList = (List<HistoricTaskInstance>) Context.getCommandContext()
		 .getHistoricTaskInstanceEntityManager().findHistoricTaskInstancesByQueryCriteria(historicTaskInstanceQueryImpl);
		 if (historicTaskInstanceList != null && historicTaskInstanceList.size() > 0) {
		for (HistoricTaskInstance historicTaskInstance : historicTaskInstanceList) {
		ExecutionEntity executionEntity = Context.getCommandContext().getExecutionEntityManager().findExecutionById(historicTaskInstance.getExecutionId());
		if(executionEntity != null) { 
		List<VariableInstanceEntity> hisVarLis = Context.getCommandContext().getVariableInstanceEntityManager().findVariableInstancesByExecutionId(executionEntity.getId());
		for (VariableInstanceEntity variableInstanceEntity : hisVarLis) {
		Context.getCommandContext().getVariableInstanceEntityManager().delete(variableInstanceEntity);
}
		 Context.getCommandContext().getExecutionEntityManager().delete(executionEntity);
		}
		}
		 }
		// 删除多实例父节点信息
		ExecutionEntity parent = Context.getCommandContext().getExecutionEntityManager().findExecutionById(taskEntity.getExecution().getParentId());
		List<VariableInstanceEntity> varLis = Context.getCommandContext().getVariableInstanceEntityManager().findVariableInstancesByExecutionId(parent.getId());
		for (VariableInstanceEntity variableInstanceEntity : varLis) {
		Context.getCommandContext().getVariableInstanceEntityManager().delete(variableInstanceEntity);
		}
		Context.getCommandContext().getExecutionEntityManager().delete(parent);
		    }
		
		 public void deleteExecution(ExecutionEntity executionEntity) {
		Context.getCommandContext().getExecutionEntityManager().delete(executionEntity);
		    }
*/
	private void rollback2Designated(CommandContext commandContext, TaskEntity task, ExecutionEntity executionEntity, String _exeNodeId) {

		commandContext.getTaskEntityManager().deleteTask(task, null, false);
		// HistoryManager historyManager = commandContext.getHistoryManager();
		// historyManager.recordTaskEnd(taskId, "shareniu-jump");
		Process process = Context.getProcessEngineConfiguration().getRepositoryService()
				.getBpmnModel(task.getProcessDefinitionId()).getMainProcess();
		//List<FlowElement> prevNode = getPrevousNode(task, process);
		FlowNode sss = (FlowNode)process.getFlowElement(_exeNodeId);
		List<FlowNode> prevNode =new ArrayList<FlowNode>();
		prevNode.add(sss);
		prevNode.stream().forEach(node -> {
			if (node == null) {
				throw new RuntimeException("前置任务节点未找到");
			}
			if (((FlowNode) node).getIncomingFlows().stream().anyMatch(ele -> {
				String s=ele.getSourceRef();
				return StartEvent.class.isAssignableFrom(process.getFlowElement(ele.getSourceRef()).getClass());
			})) {
				task.setVariable("creator", this.getProcessCreator(task, commandContext));
			}
			// TODO(liubo):如果退回的是第一个任务节点，将creator注入
			task.fireEvent("rollback");
			executionEntity.removeTask(task);
			
	        /*String processDefinitionId = task.getProcessDefinitionId();
	        ProcessDefinitionEntity processDefinitionEntity = new GetDeploymentProcessDefinitionCmd(processDefinitionId).execute(commandContext);
	        ActivityImpl activityImpl = processDefinitionEntity.findActivity(task.getTaskDefinitionKey());
	         Map<String, Object> currMap = activityImpl.getProperties();
	         if (currMap.containsKey("multiInstance")) { // 删除当前多实例任务
	        	// executionEntity= task.getExecution().getParent().getParent(); //taskEntity.getExecution();
	        this.deleteExecution(task);
	        }
	         
	         executionEntity.setProcessInstance(executionEntity);
	         executionEntity.setProcessDefinitionId(historicActivityInstanceEntity.getProcessDefinitionId());
	         executionEntity.setActivity(targetActivity);
	         executionEntity.setActive(false);
	         executionEntity.setConcurrent(false);
	         executionEntity.setCachedEntityState(0);*/
			executionEntity.executeActivity(executionEntity.getProcessDefinition().findActivity(node.getId()));
		});
		//throw new RuntimeException("暂不支持退回到任一指定节点");
	}

	/*private List<FlowNode> getPrevousNode(TaskEntity task, Process process) {
		
		ProcessDefinitionEntity processDefinitionEntity = null;

		String id = null;

		TaskDefinition taskDef = null;
		String type = null;
		Map<String, Object> map = new HashMap<String, Object>();
		// 获取流程实例Id信息
		TaskService taskService = Context.getProcessEngineConfiguration().getTaskService();
		Task Task = Context.getProcessEngineConfiguration().getTaskService().createTaskQuery().taskId(taskId)
				.singleResult();
		String processInstanceId = Context.getProcessEngineConfiguration().getTaskService().createTaskQuery()
				.taskId(taskId).singleResult().getProcessInstanceId();
		String executionId = Context.getProcessEngineConfiguration().getTaskService().createTaskQuery().taskId(taskId)
				.singleResult().getExecutionId();
		// 获取流程发布Id信息
		String definitionId = Context.getProcessEngineConfiguration().getRuntimeService().createProcessInstanceQuery()
				.processInstanceId(processInstanceId).singleResult().getProcessDefinitionId();

		processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) Context
				.getProcessEngineConfiguration().getRepositoryService()).getDeployedProcessDefinition(definitionId);

		List<Execution> execution = Context.getProcessEngineConfiguration().getRuntimeService().createExecutionQuery()
				.executionId(executionId).list();
		if (execution.size() == 1) {
			// execution.getActivityId();
			// 当前流程节点Id信息
			String activitiId = execution.get(0).getActivityId();

			// 获取流程所有节点信息
			List<ActivityImpl> activitiList = processDefinitionEntity.getActivities();

			// 遍历所有节点信息
			for (ActivityImpl activityImpl : activitiList) {
				id = activityImpl.getId();

				// 找到当前节点信息
				if (activitiId.equals(id)) {

					// 判断上一个节点信息是 什么类型
					map = lastNodeType(activityImpl, activityImpl.getId(), processInstanceId);

					break;
				}
			}
		} else {

		}

		if (map.get("type") != null && map.get("type").equals("parallelGateway")) {
			List<FlowNode> flowNodes = new ArrayList<FlowNode>();

			String activityId = (String) map.get("activityId");
			FlowNode node = (FlowNode) process.getFlowElement(activityId);
			List<SequenceFlow> list = node.getIncomingFlows();
			for (SequenceFlow sequenceFlow : list) {
				FlowElement flowElement = process.getFlowElement(sequenceFlow.getSourceRef());
				FlowNode flowNode = (FlowNode) flowElement;
				flowNodes.add(flowNode);
			}

			return flowNodes;
		} else if (map.get("type").equals("userTask")) {
			List<FlowNode> flowNodes = new ArrayList<FlowNode>();
			List<HistoricActivityInstance> taskHis = Context.getProcessEngineConfiguration().getHistoryService()
					.createHistoricActivityInstanceQuery().executionId(task.getExecutionId()).finished()
					.orderByHistoricActivityInstanceEndTime().desc().list();

			FlowNode flowNode = (FlowNode) process.getFlowElement(taskHis.get(0).getActivityId());
			flowNodes.add(flowNode);
			return flowNodes;
		} else{
			List<FlowNode> flowNodes = new ArrayList<FlowNode>();
			List<HistoricActivityInstance> taskHis3 = Context.getProcessEngineConfiguration().getHistoryService()
					.createHistoricActivityInstanceQuery().executionId(task.getExecutionId()).finished()
					.orderByHistoricActivityInstanceEndTime().desc().list();
			FlowNode flowNode = (FlowNode) process.getFlowElement(taskHis3.get(0).getActivityId());
			flowNodes.add(flowNode);
			return flowNodes;

		}

	}*/

	private List<FlowElement> getPrevousNode(TaskEntity task, Process process) {
		/*List<HistoricActivityInstance> historyActivitys = Context.getProcessEngineConfiguration().getHistoryService()
				.createNativeHistoricActivityInstanceQuery("").list();*/
		
		List<HistoricActivityInstance> taskHis = Context.getProcessEngineConfiguration().getHistoryService()
				.createHistoricActivityInstanceQuery().processInstanceId(task.getProcessInstanceId()).finished()
				.orderByHistoricActivityInstanceEndTime().desc().list();
		
		List<HistoricActivityInstance> taskHis1 = Context.getProcessEngineConfiguration().getHistoryService()
				.createHistoricActivityInstanceQuery().processInstanceId(task.getProcessInstanceId()).finished()
				.orderByHistoricActivityInstanceEndTime().desc().list();
		HistoricActivityInstance maxExecuteElement = taskHis.stream().filter(activity->{
			FlowElement ele = process.getFlowElement(activity.getActivityId());
			if (ele == null) {
				return false;
			}
			if (!(ele instanceof FlowNode)) {
				return false;
			}
			if (activity.getActivityType().equals("exclusiveGateway")) {
				return false;
			}
			return true;
		}).max((a, b)->{
			return a.getEndTime().compareTo(b.getEndTime());
		}).get();
		List<SequenceFlow> list2=new ArrayList<>();
		List<FlowElement> listFlowElement=new ArrayList<FlowElement>();
		if (maxExecuteElement.getActivityType().equals("userTask")) {
			FlowNode node = (FlowNode)process.getFlowElement(maxExecuteElement.getActivityId());
			List<SequenceFlow> list=node.getOutgoingFlows();
			
			for (SequenceFlow sequenceFlow : list) {
				
				String targetRef=sequenceFlow.getTargetRef();
				FlowNode node2 = (FlowNode) process.getFlowElement(targetRef);
				
				String name=node2.getName();
				/*if(name==null){
					list2=node2.getIncomingFlows();
					for (SequenceFlow sequenceFlow2 : list2) {
						FlowElement flowElement=process.getFlowElement(sequenceFlow2.getSourceRef());
						listFlowElement.add(flowElement);
					}
				}else{
					FlowElement  flowElement =process.getFlowElement(maxExecuteElement.getActivityId());
					listFlowElement.add(flowElement);
				}*/
				FlowElement  flowElement =process.getFlowElement(maxExecuteElement.getActivityId());
				listFlowElement.add(flowElement);
			}
			
			return listFlowElement;
			//return Arrays.asList(process.getFlowElement(maxExecuteElement.getActivityId()));
		} else if (maxExecuteElement.getActivityType().equals("parallelGateway")) {
			FlowNode node = (FlowNode)process.getFlowElement(maxExecuteElement.getActivityId());
			return node.getIncomingFlows().stream().map(sequence->{
				return process.getFlowElement(sequence.getSourceRef());
			}).collect(Collectors.toList());
		} else {
			return new ArrayList<FlowElement>();
		}
	}
	
	/*private List<FlowElement> getPrevousNode(TaskEntity task, Process process) {
		List<HistoricActivityInstance> historyActivitys = Context.getProcessEngineConfiguration().getHistoryService()
				.createNativeHistoricActivityInstanceQuery().list();
		HistoricActivityInstance maxExecuteElement = historyActivitys.stream().filter(activity->{
			FlowElement ele = process.getFlowElement(activity.getActivityId());
			if (ele == null) {
				return false;
			}
			if (!(ele instanceof FlowNode)) {
				return false;
			}
			if (activity.getActivityType().equals("exclusiveGateway")) {
				return false;
			}
			return true;
		}).max((a, b)->{
			return a.getEndTime().compareTo(b.getEndTime());
		}).get();
		if (maxExecuteElement.getActivityType().equals("userTask")) {
			return Arrays.asList(process.getFlowElement(maxExecuteElement.getActivityId()));
		} else if (maxExecuteElement.getActivityType().equals("parallelGateway")) {
			FlowNode node = (FlowNode)process.getFlowElement(maxExecuteElement.getActivityId());
			return node.getIncomingFlows().stream().map(sequence->{
				return process.getFlowElement(sequence.getSourceRef());
			}).collect(Collectors.toList());
		} else {
			return new ArrayList<FlowElement>();
		}
	}*/
	
	
	/*private Map<String, Object> lastNodeType(ActivityImpl activityImpl, String id, String processInstanceId) {
		PvmActivity ac = null;

		Object s = null;

		// 如果遍历节点为用户任务并且节点不是当前节点信息
		if ("userTask".equals(activityImpl.getProperty("type")) && !id.equals(activityImpl.getId())) {

		} else {
			// 获取节点所有流向线路信息
			List<PvmTransition> outTransitions = activityImpl.getOutgoingTransitions();
			List<PvmTransition> outTransitionsTemp = null;

			List<PvmTransition> incomings = activityImpl.getIncomingTransitions();
			List<PvmTransition> incomingsTemp = null;

			for (PvmTransition pvmTransition : incomings) {
				ac = pvmTransition.getDestination();
				PvmActivity source = pvmTransition.getSource();
				String a = (String) source.getProperty("type");
				if ("exclusiveGateway".equals(source.getProperty("type"))) {
					incomingsTemp = source.getIncomingTransitions();
					if (incomingsTemp.size() == 1) {
						String actId = source.getId();
						Map<String, Object> map = new HashMap<String, Object>();
						map.put("activityId", source.getId());
						map.put("type", "exclusiveGateway");
						return map;
					}

				} else if ("userTask".equals(source.getProperty("type"))) {
					String actId = source.getId();
					Map<String, Object> map = new HashMap<String, Object>();
					map.put("activityId", source.getId());
					map.put("type", "userTask");
					return map;

				} else if ("parallelGateway".equals(source.getProperty("type"))) {
					String actId = source.getId();
					Map<String, Object> map = new HashMap<String, Object>();
					map.put("activityId", source.getId());
					map.put("type", "parallelGateway");
					return map;
				}

			}

		}
		return null;
	}*/

	private String getProcessCreator(TaskEntity task, CommandContext commandContext) {
		List<HistoricIdentityLinkEntity> links = commandContext.getHistoricIdentityLinkEntityManager().findHistoricIdentityLinksByProcessInstanceId(task.getProcessInstanceId());
		/*List<IdentityLinkEntity> links = commandContext.getIdentityLinkEntityManager()
				.findIdentityLinksByProcessInstanceId(task.getProcessInstanceId());*/
		return links.stream().filter(link -> {
			return "starter".equals(link.getType());
		}).findFirst().get().getUserId();
	}

	@Deprecated
	private FlowNode getPrevTaskNode(String processId, FlowElement curNode, Process process,
			HistoryService historyService) {
		if (curNode == null) {
			return null;
		}
		if (!FlowNode.class.isAssignableFrom(curNode.getClass())) {
			return null;
		}
		List<SequenceFlow> sequences = ((FlowNode) curNode).getIncomingFlows();
		for (SequenceFlow seq : sequences) {
			FlowElement ele = process.getFlowElement(seq.getSourceRef());
			if (UserTask.class.isAssignableFrom(ele.getClass())) {
				try {
					HistoricActivityInstance his = historyService.createHistoricActivityInstanceQuery()
							.processDefinitionId(processId).activityId(ele.getId())
							.orderByHistoricActivityInstanceEndTime().desc().singleResult();
					return (FlowNode) ele;
				} catch (Exception ex) {
					log.error("error", ex);
				}
			} else if (ExclusiveGateway.class.isAssignableFrom(ele.getClass())) {
				return getPrevTaskNode(processId, ele, process, historyService);
			}
		}
		return null;
	}

}
李氏程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
activiti6.0驳回到发起人
啦啦啦的博客
07-06 1万+
package com.sn.cloud.activiti6.controller; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletR...
Activiti7工作流引擎：高阶篇(三) CallActivityTask 子流程跳转到父流程
人不风流枉少年
01-15 1893
@Test public void delopyAllBpmn() { ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); processEngine.getRepositoryService() .createDeployment() .addClasspathResource("bpmn/LeaveProcess2.bpmn") ..
普通类获取spring容器里面的类的方法
weixin_38441551的博客
07-19 685
构造函数 get set springutil ptywfruntime @Autowired private ActHiActInstDao actHiActInstDao; //private RollbackTaskCmd rollbackTaskCmd; rollbackTaskCmd=new RollbackTaskCmd(id,actHiActInstDao) cmd //p...
Activiti6+SpringBoot---流程回退-1
Lv_vI的博客
08-13 1653
文章目录1. 概述2. 环境3. 准备测试3.1 设计流程图3.2 Bpmn文件3.3 删除任务自定义3.4 任务跳转自定义3.5 测试类4. 测试结果 1. 概述 流程回退一直以来是个老旧的难题，也一直没有好的解决方法，本文就来详述流程回退的解决办法。首先我们来分析一下不同的流程审批情况，并在对应的节点上实现流程的回退处理，以及应该提供的回退处理，当然我们说的回退不是指通过在流程节点上画一条线回退到想回的节点上。 2. 环境 SpringBoot2.X + activiti6 3. 准备测试 3.1 设计
系列学习 SpringBoot + Activiti7 工作流之第 3 篇 —— 【进阶篇】流程实例、个人任务
流放深圳
06-15 896
查看之前的博客可以点击顶部的【分类专栏】 流程实例 1、什么是流程实例 一个流程实例包括了所有的运行节点。我们可以利用这个对象来了解当前流程实例的进度等信息。例如：用户或程序按照流程定义内容发起一个流程，这就是一个流程实例。 个人理解的流程实例：是具体到某一个流程定义的一个实际例子，叫流程实例。比如公司的请假流程叫做【流程定义】，它规定请假要经过多少人审批。而张三发起的请假申请，是流程实例，是具体的某一个案例，因此叫流程实例。 Activiti 工作流系统如何与我们实际业务整合呢？ 比如...
Activiti6.0（十）任务处理人变更（改派）、自由跳转（回退）
清茶的博客
02-10 8218
目录 一、前言 二、改派实现 三、自由跳转实现 思路1 思路2 一、前言 流程流转时，某个环节的任务处理人变更（即改派）是一种非常常见的需求，本来任务处理人可能是A，但是A因为有事处理不了，管理员需要将该单子改派给B临时处理下。 在中国式流程中，流程的回退也是必不可少的，流程流转到某个环节时，处理人一看：咦 这填的都是啥玩意儿，根本不符合要求，想直接打回给上一环节或者走过的任意...
Activiti实现同意/拒绝/退回
qq2389835815的博客
03-17 6691
1.基本概念 ProcessDefinition 流程定义,流程图以xml格式保存在.bpmn文件,由RepositoryService管理. ProcessInstance/Execution 流程实例,每次申请按流程图走一遍,由RuntimeService管理. Task 任务,一次审批动作,由TaskService管理. 2.整合spring https://www.cnblogs.com/...
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...
activiti5 工作流的回退功能
一个码农的专栏
02-15 2万+
activiti5 工作流 本身不提供回退，按网络的说法，外国人的回退也是要在流程图设计里面画出来的，可惜在中国各种各样的需求，肯定是需要实现的。在实现回退的功能上看了网络上面的方法，都是直接修改分支表的节点ID或者通过设置节点的下节点来实现回退和跳跃等需求，可惜都只支持单线流程，一旦有并行，包容网关，外嵌，内嵌子流程就无法成功了，还会出现不可控的错误。         为了实现这些情况，只好自
回退备份 2019.2.12
weixin_38441551的博客
02-12 196
package com.pty.workflow.service.extend; import java.util.List; import org.activiti.bpmn.model.ExclusiveGateway; import org.activiti.bpmn.model.FlowElement; import org.activiti.bpmn.model.FlowNode; ...
android service 后台执行定时任务
热门推荐
csd_xiaojin的专栏
03-06 3万+
关于service 大家应都知道是android 四大组件之一，用来执行后台任务的。 如果还不太了解service 可以看看郭大神写的Android Service完全解析，关于服务你所需知道的一切，http://blog.csdn.net/guolin_blog/article/details/11952435 同时郭霖郭大神写的《第一行代码》这本书，对于新手，这本书很适合，通俗易懂。我写这
八 退回流程
weixin_38441551的博客
03-11 628
@ApiOperation(value = "退回单据（根据任务id）") @PostMapping(path = "/rollBack") public Response rollBack(@RequestBody WfSubmitVo submitVo) { // workflowService.rollBack(submitVo.getTaskId(),submitVo.ge...
Activiti7工作流引擎：节点动态跳转
最新发布
人不风流枉少年
09-06 2304
一：application.yml spring: datasource: url: jdbc:mysql://localhost:3306/user?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT username: root password: root123 driver-class-name: com.mysql.cj.jdbc.Driver ## Mybatis 配置 mybat
Activiti6.0版本流程撤回、跳转、回退等操作
啦啦啦的博客
07-05 8772
package com.sn.cloud.activiti6.controller; import java.math.BigDecimal; import java.util.HashMap; import java.util.Map; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpS...
ACTIVITI 研究代码 之 模版模式
weixin_34306593的博客
04-20 70
模板方法模式需要开发抽象类和具体子类的设计师之间的协作。一个设计师负责给出一个算法的轮廓和骨架，另一些设计师则负责给出这个算法的各个逻辑步骤。代表这些具体逻辑步骤的方法称做基本方法(primitive method)；而将这些基本方法汇总起来的方法叫做模板方法(template method)，这个设计模式的名字就是从此而来。 在activit中很多地方用到了此模式，用这个模式可以重用业务逻辑。...
activiti 6.0自由跳转
qq_41291856的博客
06-12 1903
Task task = taskService.createTaskQuery() // 创建任务查询 .processInstanceId(自己的ProcessInstanceId) // 根据流程实例id查询 .singleResult(); //获取流程定义 ...
【Activiti】跳转到工作流的任意节点（本例用跳转到上一节点讲解即流程回退）
唐Ian的博客
01-03 2万+
所有用到的service以及实现类都是工作流（Activiti）本身的。public String taskRollback(String taskId){ //根据当前任务ID获取当前任务 HistoricTaskInstance currTask = historyService .createHistoricTaskInstanceQuery()
activiti ProcessInstance（流程实例） 和 Execution（执行流）
DQchat的博客
08-18 1万+
ProcessInstance 流程实例，是主执行流 继承Execution 启动流程，会创建流程实例，此是会在act_ru_execution中保存数据（主流程数据、子流程数据）， 如果只有一个流程分支的话，还会在此表中创建一条子流程数据，会引用主流程数据的id， 如果有多个分支就会创建多个子流程数据 RuntimeService runtimeService = engine.getRu...
有关activiti5的相关API操作
zyn170605的博客
03-08 1042
01_启动流程          //processDefinitionKey：流程定义的KEY;业务id:一般为业务表的id;variables :存放实体类，或其他属性 runtimeService .startProcessInstanceByKey(String processDefinitionKey, String businessKey, Map&lt;Strin...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值