activiti代码实现驳回

已于 2022-11-05 20:37:57 修改
阅读量3k 收藏 15
点赞数 3
分类专栏： activiti Java 文章标签： java
于 2022-11-05 10:41:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37539286/article/details/127700582
版权
1. acitiviti5流程图实现驳回

在这里插入图片描述
rejectProcess.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="rejectProcess" name="驳回流程测试" isExecutable="true">
    <startEvent id="startevent1" name="Start"></startEvent>
    <endEvent id="endevent1" name="End"></endEvent>
    <userTask id="applySubmit" name="申请人提交" activiti:assignee="${applySubmit}"></userTask>
    <userTask id="check" name="审批" activiti:assignee="${check}"></userTask>
    <sequenceFlow id="flow1" sourceRef="startevent1" targetRef="applySubmit"></sequenceFlow>
    <sequenceFlow id="flow2" sourceRef="applySubmit" targetRef="check">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${applySubmitPass}]]></conditionExpression>
    </sequenceFlow>
    <sequenceFlow id="flow3" sourceRef="check" targetRef="endevent1">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${checkPass}]]></conditionExpression>
    </sequenceFlow>
    <sequenceFlow id="flow4" name="驳回" sourceRef="check" targetRef="applySubmit">
      <conditionExpression xsi:type="tFormalExpression"><![CDATA[${checkReject}]]></conditionExpression>
    </sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_rejectProcess">
    <bpmndi:BPMNPlane bpmnElement="rejectProcess" id="BPMNPlane_rejectProcess">
      <bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="70.0" y="200.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="550.0" y="200.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="applySubmit" id="BPMNShape_applySubmit">
        <omgdc:Bounds height="55.0" width="105.0" x="180.0" y="190.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="check" id="BPMNShape_check">
        <omgdc:Bounds height="55.0" width="105.0" x="360.0" y="190.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
        <omgdi:waypoint x="105.0" y="217.0"></omgdi:waypoint>
        <omgdi:waypoint x="180.0" y="217.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
        <omgdi:waypoint x="285.0" y="217.0"></omgdi:waypoint>
        <omgdi:waypoint x="360.0" y="217.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
        <omgdi:waypoint x="465.0" y="217.0"></omgdi:waypoint>
        <omgdi:waypoint x="550.0" y="217.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow4" id="BPMNEdge_flow4">
        <omgdi:waypoint x="412.0" y="190.0"></omgdi:waypoint>
        <omgdi:waypoint x="412.0" y="144.0"></omgdi:waypoint>
        <omgdi:waypoint x="232.0" y="144.0"></omgdi:waypoint>
        <omgdi:waypoint x="232.0" y="190.0"></omgdi:waypoint>
        <bpmndi:BPMNLabel>
          <omgdc:Bounds height="14.0" width="100.0" x="420.0" y="171.0"></omgdc:Bounds>
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>
2. 测试
@Slf4j
public class TestAutoSubmit {
    /**
     * 部署流程
     */
    @Test
    public void deployProcessDefinition() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        // 获取流程定义与部署相关Service
        Deployment deployment = processEngine.getRepositoryService()
                // 创建一个部署对象
                .createDeployment()
                .name("驳回流程测试")
                // 加载资源文件
                .addClasspathResource("processes/rejectProcess.bpmn")
                .addClasspathResource("processes/rejectProcess.png")
                // 完成部署
                .deploy();
        log.info(deployment.getId());
        log.info(deployment.getName());
    }
     /**
     * 启动流程实例
     */
    @Test
    public void startProcessInstance() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        Map<String, Object> varMap = new HashMap<>();
        varMap.put("applySubmit", "张三");
        ProcessInstance processInstance = processEngine.getRuntimeService()
                .startProcessInstanceByKey("autoSubmit", "autoSubmit", varMap);
        log.info(processInstance.getId());
        log.info(processInstance.getProcessDefinitionId());
        taskQuery();
    }
     /**
     * 申请人提交审批节点
     */
    @Test
    public void doApplySubmitTask() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Map<String, Object> varMap = new HashMap<>();
        varMap.put("applySubmitPass", true);
        varMap.put("check", "李四");
        taskService.complete("7509", varMap);
        taskQuery();
    }
  /**
     * 审批节点，驳回
     */
    @Test
    public void doCheckRejectTask() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        Map<String, Object> varMap = new HashMap<>();
        varMap.put("checkReject", true);
        varMap.put("checkPass", false);
        taskService.complete("7509", varMap);
        taskQuery();
    }
  /**
     * 查询待办任务
     */
    @Test
    public void taskQuery() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        List<Task> list = processEngine.getTaskService().createTaskQuery()
                // 筛选 multiMeetingApprove 流程
                .processDefinitionKey("rejectProcess")
                .list();
        list.forEach(task -> {
            log.info("流程实例id:{}, 任务处理人:{}, 任务名:{}, 任务定义Key:{}, 任务id:{}", task.getProcessInstanceId(), task.getAssignee(), task.getName(), task.getTaskDefinitionKey(), task.getId());
        });
        if (list.isEmpty()) {
            log.info("没有代办任务了，流程结束");
        }
    }
3. 去除驳回连线，代码实现驳回

在这里插入图片描述

import org.activiti.bpmn.model.BpmnModel;
import org.activiti.bpmn.model.FlowNode;
import org.activiti.bpmn.model.SequenceFlow;
import org.activiti.bpmn.model.UserTask;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.impl.RepositoryServiceImpl;
import org.activiti.engine.impl.identity.Authentication;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.pvm.PvmTransition;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.process.TransitionImpl;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.task.Task;
import org.apache.commons.lang3.ObjectUtils;
    /**
     * 往回跳转到任意节点
     *
     * @param taskId      任务id
     * @param varMap      流程变量
     * @param destTaskKey 跳转的目标任务节点key
     * @apiNote 这里使用的是activiti5中 pvm包API，activiti6没有，不兼容
     */
    public void rollBackToAnyTask(String taskId, Map<String, Object> varMap, String destTaskKey) {
        //查询当前流程实例的待办任务
        List<Task> taskList = taskService.createTaskQuery().taskId(taskId).list();
        if (taskList == null || taskList.size() == 0) {
            throw new ActivitiException("任务已经执行完成，无法跳转处理");
        }

        Task task = taskList.get(0);
        // 取得当前执行对象
        ExecutionEntity executionEntity = (ExecutionEntity) runtimeService.createExecutionQuery()
                .executionId(task.getExecutionId())
                .singleResult();
        //流程定义对象
        ProcessDefinitionEntity processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
                .getDeployedProcessDefinition(executionEntity.getProcessDefinitionId());
        //流程变量
        Map<String, Object> variables = executionEntity.getProcessVariables();
        if (varMap != null) {
            variables.putAll(varMap);
        }

        //当前活动节点
        ActivityImpl currActivityImpl = processDefinitionEntity.findActivity(executionEntity.getActivityId());
        //目标活动节点
        ActivityImpl nextActivityImpl = processDefinitionEntity.findActivity(destTaskKey);

        //目标活动节点 不能是 当前活动节点
        if (currActivityImpl != null && nextActivityImpl != currActivityImpl) {
            //所有的出口连线集合
            List<PvmTransition> pvmTransitions = currActivityImpl.getOutgoingTransitions();
            List<PvmTransition> oriPvmTransitions = new ArrayList<>();
            oriPvmTransitions.addAll(pvmTransitions);

            //清除所有出口连线
            pvmTransitions.clear();

            //建立新的出口连线
            TransitionImpl tImpl = currActivityImpl.createOutgoingTransition();
            tImpl.setDestination(nextActivityImpl);


            taskService.complete(task.getId(), variables);
            //完成任务会新增历史任务记录，根据需要删除
//                historyService.deleteHistoricTaskInstance(task.getId());

            //删除新的出口
            currActivityImpl.getOutgoingTransitions().remove(tImpl);

            //恢复之前的所有出口
            pvmTransitions.addAll(oriPvmTransitions);
        }
    }
4. activiti5中Command模式驳回
package com.yl.activiti.service;

import org.activiti.engine.ActivitiException;
import org.activiti.engine.TaskService;
import org.activiti.engine.delegate.ExecutionListener;
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.TaskServiceImpl;
import org.activiti.engine.impl.context.Context;
import org.activiti.engine.impl.identity.Authentication;
import org.activiti.engine.impl.interceptor.Command;
import org.activiti.engine.impl.interceptor.CommandContext;
import org.activiti.engine.impl.interceptor.CommandExecutor;
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;
import org.activiti.engine.impl.pvm.process.ScopeImpl;
import org.activiti.engine.task.IdentityLinkType;

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

/**
 * activiti5中 常规任务节点跳转
 *
 * @author liuxubo
 * @date 2022/10/25 23:20
 */
public class CommonJumpCmd implements Command {
	/**
	 * 任务id
	 */
	private String taskId;
	/**
	 * 流程变量
	 */
	private Map<String, Object> variables;
	/**
	 * taskKey名
	 */
	private String desActivityId;

	/**
	 * 构造器
	 * @param taskId		  任务id
	 * @param variables		  流程变量
	 * @param desActivityId   taskKey名
	 */
	public CommonJumpCmd(String taskId, Map<String, Object> variables, String desActivityId) {
		this.taskId = taskId;
		this.variables = variables;
		this.desActivityId = desActivityId;
	}

	@Override
	public Object execute(CommandContext commandContext) {
		//获取任务实例管理类
		TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
		//获取当前任务实例
		TaskEntity taskEntity = taskEntityManager.findTaskById(taskId);

		//获取当前节点的执行实例
		ExecutionEntity executionEntity = taskEntity.getExecution();
		// 设置流程变量
		executionEntity.setVariables(variables);
 
		// 触发执行监听器complete事件
		taskEntity.fireEvent(TaskListener.EVENTNAME_COMPLETE);
 
		// 触发全局事件转发器TASK_COMPLETED事件
		if (Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
			Context.getProcessEngineConfiguration().getEventDispatcher()
					.dispatchEvent(ActivitiEventBuilder.createEntityWithVariablesEvent(ActivitiEventType.TASK_COMPLETED, this, variables, false));
		}
 
		// 添加act_ru_identitylink表记录。常规流程实例id与执行id相同
		if (Authentication.getAuthenticatedUserId() != null && executionEntity.getProcessInstanceId() != null) {
			executionEntity.involveUser(Authentication.getAuthenticatedUserId(), IdentityLinkType.PARTICIPANT);
		}
 
		// 删除任务
		// deleteTask(String taskId, String deleteReason, boolean cascade), 判断taskId对应的TaskEntity的executionId是否为空，非空则抛出异常，导致无法删除任务
		taskEntityManager.deleteTask(taskEntity, TaskEntity.DELETE_REASON_COMPLETED, false);
 
		//触发执行监听器end事件  获取当前活动节点对应的执行监听器并触发end事件，进而会调用内置的记录监听器。如果漏了这一步骤，会影响历史表记录
		ScopeImpl scope = executionEntity.getActivity();
		List<ExecutionListener> exectionListeners = scope.getExecutionListeners("end");
		for(ExecutionListener listener : exectionListeners) {
			executionEntity.setEventName("end");
			executionEntity.setEventSource(scope);
			try {
				listener.notify(executionEntity);
			} catch (Exception e) {
				throw new ActivitiException(e.getMessage());
			}
		}

		//获取流程定义id
		String processDefinitionId = executionEntity.getProcessDefinitionId();
		ProcessDefinitionEntity processDefinitionEntity = Context.getProcessEngineConfiguration().getDeploymentManager()
				.findDeployedProcessDefinitionById(processDefinitionId);

		ActivityImpl desActivityimpl = processDefinitionEntity.findActivity(desActivityId);
		//设置执行实例的当前活动节点为目标节点
		executionEntity.executeActivity(desActivityimpl);
 
		return null;
	}

	/**
	 * 常规任务节点跳转
	 * @param taskService
	 */
	public void jump(TaskService taskService) {
		TaskServiceImpl taskServiceImpl = (TaskServiceImpl)taskService;
		CommandExecutor commandExecutor = taskServiceImpl.getCommandExecutor();
		commandExecutor.execute(this);
	}
}
5.activiti6Command模式驳回
package com.yl.activiti.service;

import org.activiti.bpmn.model.FlowElement;
import org.activiti.bpmn.model.Process;
import org.activiti.engine.ManagementService;
import org.activiti.engine.impl.history.HistoryManager;
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;
import org.activiti.engine.impl.util.ProcessDefinitionUtil;

/**
 * activiti6中 常规任务节点跳转
 *
 * @author liuxubo
 * @date 2022/10/26 23:39
 */
public class JumpAnyWhereCmd implements Command {
    /**
     * 任务ID
     */
    private String taskId;
    /**
     * 目标任务节点key
     */
    private String destTaskKey;

    /**
     *
     * @param taskId        任务ID
     * @param destTaskKey   目标任务节点key
     */
    public JumpAnyWhereCmd(String taskId, String destTaskKey) {
        this.taskId = taskId;
        this.destTaskKey = destTaskKey;
    }

    /**
     * 执行
     * @param commandContext
     * @return
     */
    public Object execute(CommandContext commandContext) {
        //获取任务实例管理类
        TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
        //获取当前任务实例
        TaskEntity currentTask = taskEntityManager.findById(taskId);

        //获取当前节点的执行实例
        ExecutionEntity execution = currentTask.getExecution();

        //获取流程定义id
        String processDefinitionId = execution.getProcessDefinitionId();
        //获取目标节点
        Process process = ProcessDefinitionUtil.getProcess(processDefinitionId);
        FlowElement flowElement = process.getFlowElement(destTaskKey);

        //获取历史管理
        HistoryManager historyManager = commandContext.getHistoryManager();

        //通知当前活动结束(更新act_hi_actinst)
        historyManager.recordActivityEnd(execution, "jump to userTask1");
        //通知任务节点结束(更新act_hi_taskinst)
        historyManager.recordTaskEnd(taskId, "jump to userTask1");
        //删除正在执行的当前任务
        taskEntityManager.delete(taskId);

        //此时设置执行实例的当前活动节点为目标节点
        execution.setCurrentFlowElement(flowElement);

        //向operations中压入继续流程的操作类
        commandContext.getAgenda().planContinueProcessOperation(execution);

        return null;
    }

    /**
     * 跳转任意节点
     * @param managementService
     */
    public void jump(ManagementService managementService){
        managementService.executeCommand(this);
    }

}
分享心得
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
StringUtils字符串工具类
diaolove的博客
02-22 5878
StringUtils类目录 StringUtils类是在 cn.hutool.core.util包下的一个类。 StringUtils中方法的操作对象是java.lang.String类型的对象，是JDK提供的String类型操作方法的补充，并且是null安全的(即如果输入参数String为null则不会抛出NullPointerException，而是做了相应处理，例如，如果输入为null则返回也是null等，具体可以查看源代码)。 StringUtils的源码： package cn.hutool.
工作流activiti 会签 驳回/撤回 问题
weixin_41643546的博客
12-27 6030
工作中用到了activity 进行流程审批。节点用到了会签功能。上线后，发现会签节点驳回/撤回会出现失效，例如会签需要USER1,USER2顺序会签，但是在USER1，用户撤回，并不能撤回到初始节点，而是到了会签下一节点。 所以为了解决这个问题，博主进行可研究。 经研究发现，会签任务是带有子任务的，上图为例： SELECT * FROM ACT_RU_EXECUTION WHERE PROC_INST_ID_ = '2232501'; 正常非会签任务，我们可以认为：PROC_INST_I...
activiti实现请假流程
03-08
该资源是使用activiti的开源插件实现的工作流，方便简单。
Activiti7工作流引擎：审批通过或拒绝流程
最新发布
qq_29477175的博客
06-12 177
Activiti7工作流引擎：审批通过或拒绝流程
Activiti目录（五）驳回、重新发起、取消流程
weixin_45067120的博客
05-27 6147
把Activiti打入你的脑袋，再次通过驳回、取消流程快速打入
Activiti7工作流引擎：进阶篇(十三) 拒绝(直接结束)
人不风流枉少年
12-21 1万+
驳回或者拒绝就是某个审批人不同意你的申请，此时流程就直接结束了。我们可以增加分支条件或者排它网关来完成驳回功能。此方法适用于节点较少的情况。 如果节点较多，每个节点都增加一个排它网关，感觉整个流程的.bpmn文件内容很多，我们当驳回的时候可以直接操作act_ru删除相关数据和act_hi表中完善end_time等。 ...
Activiti工作流驳回操作
weixin_43947205的博客
09-26 2447
activiti工作流高并发下驳回
activiti 实现连续驳回功能
qq_58747711的博客
11-02 1193
activiti 实现连续驳回功能
activiti 5.22 退回代码
09-08
工作流 activiti 5.22 退回代码实现。 activiti在设计的时候没有回退相关的操作，回退是中国特有的特色。这里写一个比较简单的回退。不支持回退到并行网关前面节点，虽然回退到前面节点不会报错 但会导致任务无法...
activiti-demo
03-26
博客还可能涵盖了如何在 Java 代码中与 Activiti 引擎交互，启动流程实例，处理任务，以及查询和管理流程状态。 Activiti 是一个开源的工作流和业务自动化引擎，适用于企业和组织构建灵活、可扩展的业务流程管理...
activitiDemo.zip
11-29
4. **代码实现**：在 Java 代码中，使用 Activiti API 可以实现对工作流的操作，包括启动流程实例、分配任务、完成任务和驳回任务等。驳回操作通常会涉及到 `runtimeService.createProcessInstanceModification()` ...
springboot整合activiti完整demo
05-31
- **流程审批控制**：可以实现接口进行流程审批，例如，根据业务需求添加驳回、转交等功能。 **6. 示例代码详解** DEMO中的代码可能包含了流程的启动、查询、完成任务和指定任务执行人的示例。这些代码提供了对...
activiti流程节点驳回处理方式
我姓谭却弹不死你的博客
06-25 1428
【代码】activiti流程节点驳回处理方式。
activiti工作流,驳回问题详细解析(尤其会签的驳回问题)
热门推荐
zhangpan_soft的博客
12-09 4万+
最近因为项目需要,所以研究了一下工作流,然而,我们都知道,国外的工作流框架,是不支持驳回问题的!这是其一!第二!项目的工作流要实现任意节点的流转,这也是国外工作流框架所不具备的!因此,国外的工作流框架是没有一个可以真正满足我们的业务要求的,然而国内的工作流架构,我也没有听说过哪个可以支持中国式工作流!因此,在技术选型上面选择了相对比较火的activiti框架!当时我们的原则就是尽可能的不改变框架,而
Activiti分支/网格/驳回操作
zhangCheng的博客
05-22 3518
一、概念 任务节点处理完成之后,后面的处理可能需要根据不同的调节走不同的流程(选择一条路径,串行),或者是将任务分发到多个审批人头上（分发到多条流程路径）, 或者在某个任务节点要判断多个人审批之后才能继续执行（多条路径汇聚到一点）。 这种操作就要用到流程分支的概念,一个分支相当于就是一个子流程,有串行流,也有并行流。 二、连线流程 在连线上设置条件,根据条件判断后面的流程走那个分支,这样做的好处在于方便快捷,坏处在于如果所以连线都没有满足条件,则当前流程会异常结束,不会 有异常显示。 步骤: 在bp
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...
Activiti工作流并行网关驳回在发起问题
qq_48157004的博客
10-11 5589
它记录了人员3（同意），人员4（同意），人员5（同意）三次记录。导致第二次审批时，并行节点有一个同意，就走到了人员7节点。流程从发起人走到并行节点 -> 人员3，和人员4，人员5，人员6是并行。人员3（同意），人员4（同意），人员5（同意），人员6（不同意）回到发起人节点。因为驳回操作会删除其他表记录，删除这几条记录不会因为主键影响报错。流程又开始从发起人走到人员3，人员4，人员5，人员6并行节点。这时会出现一个问题？最后发现问题出现在运行时流程执行实例表( act_ru_execution )
activiti 实现驳回功能
zhangkang65的专栏
04-16 3万+
activiti功能上很多时候需要驳回，如请假单领导不同意驳回重写。有多种方式可以实现。一、流程图上任务节点使用assigness或者candidate users动态的指定用户如使用变量${inputuser}如下图所示：在部门审批时判断是不同意，自动回到发起人那里，因为发起人就一个人。如果到部门主管（假设可以多个）一级审核完成后，到总经理审批，总经理审批后不同意回退到部门主管，无法确定是哪一个...
activiti7审批驳回，控制变量无法覆盖，导致无限循环驳回，流程无法结束
qq_21480329的博客
11-13 1500
activiti7审批驳回，控制变量无法覆盖，导致无限循环驳回，流程无法结束
activiti7 驳回 代码
05-20
您好，Activiti 7 中的驳回操作可以通过以下代码实现： ```java public void rejectTask(String taskId) { // 获取当前任务 Task task = taskService.createTaskQuery() .taskId(taskId) .singleResult(); if (task == null) { throw new RuntimeException("任务不存在"); } // 获取当前任务的流程实例 String processInstanceId = task.getProcessInstanceId(); // 获取当前任务的历史任务实例列表 List<HistoricTaskInstance> historicTaskList = historyService.createHistoricTaskInstanceQuery() .processInstanceId(processInstanceId) .orderByHistoricTaskInstanceEndTime() .asc() .list(); // 获取需要驳回到的任务 HistoricTaskInstance targetTask = null; for (int i = 0; i < historicTaskList.size(); i++) { HistoricTaskInstance historicTask = historicTaskList.get(i); if (historicTask.getId().equals(taskId)) { if (i == 0) { throw new RuntimeException("该任务已经是第一个任务，无法驳回"); } targetTask = historicTaskList.get(i - 1); break; } } if (targetTask == null) { throw new RuntimeException("未找到驳回目标任务"); } // 驳回操作 BpmnModel bpmnModel = repositoryService.getBpmnModel(task.getProcessDefinitionId()); Process process = bpmnModel.getProcesses().get(0); FlowNode sourceNode = (FlowNode) process.getFlowElement(task.getTaskDefinitionKey()); FlowNode targetNode = (FlowNode) process.getFlowElement(targetTask.getTaskDefinitionKey()); List<Execution> executionList = runtimeService.createExecutionQuery() .processInstanceId(processInstanceId) .list(); for (Execution execution : executionList) { if (execution instanceof ExecutionEntity) { ExecutionEntity executionEntity = (ExecutionEntity) execution; executionEntity.setCurrentFlowElement(sourceNode); runtimeService.createChangeActivityStateBuilder() .processInstanceId(processInstanceId) .moveExecutionToActivityId(executionEntity.getId(), targetNode.getId()) .changeState(); } } } ``` 该代码实现了将当前任务驳回到上一步任务的操作，具体的实现过程请参考注释。需要注意的是，该代码中使用了 Activiti 7 中的一些 API，如 `BpmnModel`、`FlowNode` 等，如果您之前使用的是 Activiti 6，可能需要进行一些调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值