Camunda如何获取（预取）下一审批节点

最新推荐文章于 2023-08-23 13:53:29 发布
最新推荐文章于 2023-08-23 13:53:29 发布
阅读量8.8k 收藏 27
点赞数 11
分类专栏： Camunda 文章标签： Camunda 获取下一审批节点 预取
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skayliu/article/details/122914671
版权

        在实际业务使用过程中，存在需要当前审批人指定或可修改下一审批节点的审批人（单个或多个），这时候就先要获取到下一审批节点，然后在提交时给引擎传递相应的变量，达到用户指定下一节点审批人的目标。

         模型如下图所示 ：      

        模型定义文件：

<?xml version="1.0" encoding="UTF-8"?>
<bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" xmlns:modeler="http://camunda.org/schema/modeler/1.0" id="Definitions_15civpn" targetNamespace="http://bpmn.io/schema/bpmn" exporter="Camunda Modeler" exporterVersion="4.12.0" modeler:executionPlatform="Camunda Platform" modeler:executionPlatformVersion="7.15.0">
  <bpmn:process id="Process_1fh6max" name="Process_1fh6max" isExecutable="true">
    <bpmn:startEvent id="StartEvent_1" name="开始" camunda:initiator="starter">
      <bpmn:outgoing>Flow_1lqot0o</bpmn:outgoing>
    </bpmn:startEvent>
    <bpmn:sequenceFlow id="Flow_1lqot0o" sourceRef="StartEvent_1" targetRef="Activity_0ykvu3n" />
    <bpmn:sequenceFlow id="Flow_0yuchf0" sourceRef="Activity_0ykvu3n" targetRef="Gateway_0q33ny1" />
    <bpmn:endEvent id="Event_1uhis39" name="结束">
      <bpmn:incoming>Flow_18thiqs</bpmn:incoming>
    </bpmn:endEvent>
    <bpmn:sequenceFlow id="Flow_0qdzfen" sourceRef="Activity_0unwnbp" targetRef="Activity_1hhna5n" />
    <bpmn:userTask id="Activity_0ykvu3n" name="提交" camunda:assignee="${starter}">
      <bpmn:incoming>Flow_1lqot0o</bpmn:incoming>
      <bpmn:outgoing>Flow_0yuchf0</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:userTask id="Activity_0unwnbp" name="并审" camunda:assignee="${assignee}">
      <bpmn:incoming>Flow_11k93to</bpmn:incoming>
      <bpmn:outgoing>Flow_0qdzfen</bpmn:outgoing>
      <bpmn:multiInstanceLoopCharacteristics camunda:collection="assigneeList" camunda:elementVariable="assignee">
        <bpmn:completionCondition xsi:type="bpmn:tFormalExpression">${nrOfCompletedInstances==1}</bpmn:completionCondition>
      </bpmn:multiInstanceLoopCharacteristics>
    </bpmn:userTask>
    <bpmn:sequenceFlow id="Flow_1xbjwul" sourceRef="Activity_1hhna5n" targetRef="Gateway_0cizqsj" />
    <bpmn:userTask id="Activity_1hhna5n" name="审批1" camunda:assignee="bx4">
      <bpmn:incoming>Flow_0qdzfen</bpmn:incoming>
      <bpmn:outgoing>Flow_1xbjwul</bpmn:outgoing>
    </bpmn:userTask>
    <bpmn:exclusiveGateway id="Gateway_0q33ny1" default="Flow_0njpgjv">
      <bpmn:incoming>Flow_0yuchf0</bpmn:incoming>
      <bpmn:outgoing>Flow_11k93to</bpmn:outgoing>
      <bpmn:outgoing>Flow_0njpgjv</bpmn:outgoing>
    </bpmn:exclusiveGateway>
    <bpmn:sequenceFlow id="Flow_11k93to" name="金额大于等于1000" sourceRef="Gateway_0q33ny1" targetRef="Activity_0unwnbp">
      <bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">${amount &gt;= 1000}</bpmn:conditionExpression>
    </bpmn:sequenceFlow>
    <bpmn:sequenceFlow id="Flow_0njpgjv" name="金额小于1000" sourceRef="Gateway_0q33ny1" targetRef="Activity_0bsco2a" />
    <bpmn:exclusiveGateway id="Gateway_0cizqsj">
      <bpmn:incoming>Flow_0uawe9o</bpmn:incoming>
      <bpmn:incoming>Flow_1xbjwul</bpmn:incoming>
      <bpmn:outgoing>Flow_18thiqs</bpmn:outgoing>
    </bpmn:exclusiveGateway>
    <bpmn:sequenceFlow id="Flow_0uawe9o" sourceRef="Activity_0bsco2a" targetRef="Gateway_0cizqsj" />
    <bpmn:sequenceFlow id="Flow_18thiqs" sourceRef="Gateway_0cizqsj" targetRef="Event_1uhis39" />
    <bpmn:userTask id="Activity_0bsco2a" name="审批2" camunda:assignee="bx5">
      <bpmn:incoming>Flow_0njpgjv</bpmn:incoming>
      <bpmn:outgoing>Flow_0uawe9o</bpmn:outgoing>
    </bpmn:userTask>
  </bpmn:process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_1">
    <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_1fh6max">
      <bpmndi:BPMNEdge id="Flow_1lqot0o_di" bpmnElement="Flow_1lqot0o">
        <di:waypoint x="215" y="227" />
        <di:waypoint x="270" y="227" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_0yuchf0_di" bpmnElement="Flow_0yuchf0">
        <di:waypoint x="370" y="227" />
        <di:waypoint x="415" y="227" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_0qdzfen_di" bpmnElement="Flow_0qdzfen">
        <di:waypoint x="680" y="120" />
        <di:waypoint x="730" y="120" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_1xbjwul_di" bpmnElement="Flow_1xbjwul">
        <di:waypoint x="830" y="120" />
        <di:waypoint x="890" y="120" />
        <di:waypoint x="890" y="202" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_11k93to_di" bpmnElement="Flow_11k93to">
        <di:waypoint x="440" y="202" />
        <di:waypoint x="440" y="120" />
        <di:waypoint x="580" y="120" />
        <bpmndi:BPMNLabel>
          <dc:Bounds x="411" y="143" width="90" height="14" />
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_0njpgjv_di" bpmnElement="Flow_0njpgjv">
        <di:waypoint x="440" y="252" />
        <di:waypoint x="440" y="340" />
        <di:waypoint x="630" y="340" />
        <bpmndi:BPMNLabel>
          <dc:Bounds x="422" y="293" width="68" height="14" />
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_0uawe9o_di" bpmnElement="Flow_0uawe9o">
        <di:waypoint x="730" y="340" />
        <di:waypoint x="890" y="340" />
        <di:waypoint x="890" y="252" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_18thiqs_di" bpmnElement="Flow_18thiqs">
        <di:waypoint x="915" y="227" />
        <di:waypoint x="1002" y="227" />
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNShape id="_BPMNShape_StartEvent_2" bpmnElement="StartEvent_1">
        <dc:Bounds x="179" y="209" width="36" height="36" />
        <bpmndi:BPMNLabel>
          <dc:Bounds x="186" y="252" width="22" height="14" />
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_0aylr2v_di" bpmnElement="Activity_0ykvu3n">
        <dc:Bounds x="270" y="187" width="100" height="80" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Gateway_0q33ny1_di" bpmnElement="Gateway_0q33ny1" isMarkerVisible="true">
        <dc:Bounds x="415" y="202" width="50" height="50" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Event_1uhis39_di" bpmnElement="Event_1uhis39">
        <dc:Bounds x="1002" y="209" width="36" height="36" />
        <bpmndi:BPMNLabel>
          <dc:Bounds x="1009" y="252" width="22" height="14" />
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Gateway_0cizqsj_di" bpmnElement="Gateway_0cizqsj" isMarkerVisible="true">
        <dc:Bounds x="865" y="202" width="50" height="50" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_05lgeta_di" bpmnElement="Activity_1hhna5n">
        <dc:Bounds x="730" y="80" width="100" height="80" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_177sc21_di" bpmnElement="Activity_0unwnbp">
        <dc:Bounds x="580" y="80" width="100" height="80" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_1czfbnk_di" bpmnElement="Activity_0bsco2a">
        <dc:Bounds x="630" y="300" width="100" height="80" />
      </bpmndi:BPMNShape>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</bpmn:definitions>

        发起流程：

@Test
	public void startProcess() {
		try {
			ProcessRequest processRequest = new ProcessRequest();
			processRequest.setProcessDefKey("Process_1fh6max");
			processRequest.setStarter("bx1");
			AuthenticationService authenticationService = new AuthenticationService();
			String engineName = processEngine.getName();
			UserAuthentication authentication = (UserAuthentication) authenticationService
					.createAuthenticate(engineName, "bx1", null, null);
			logger.info("authentication--------->" + authentication.getName());
			// Authentications.clearCurrent();
			identityService.setAuthenticatedUserId(authentication.getName());
			String processInstanceId = null;
			List<TaskDto> resultList = new ArrayList<TaskDto>();
			Map<String, Object> variables = new HashMap<String, Object>();
			List<String> assigneeList = new ArrayList<>();
			assigneeList.add("bx2");
			assigneeList.add("bx3");
			variables.put("assigneeList", assigneeList);
			//variables.put("starter", processRequest.getStarter());
			variables.put("amount", 1100);
			ProcessInstance processInstance = null;

			ProcessDefinition pd = repositoryService.createProcessDefinitionQuery()
					.processDefinitionKey(processRequest.getProcessDefKey()).latestVersion().singleResult();
			if (pd == null) {
				throw new Exception("流程模型：" + processRequest.getProcessDefKey() + "不存在！");
			}
			if (pd != null && pd.isSuspended()) {
				throw new Exception("流程模型：" + processRequest.getProcessDefKey() + "已挂起，暂无法发起流程！");
			}
			// 流程初始化
			if (StringUtils.isNotBlank(processRequest.getProcessDefKey())) {
				processInstance = runtimeService.startProcessInstanceByKey(processRequest.getProcessDefKey(),
						variables);
			} else {
				processInstance = runtimeService.startProcessInstanceById(processRequest.getProcessDefId(), variables);
			}
			// 创建成功
			if (processInstance != null && StringUtils.isNotBlank(processInstance.getId())) {
				processInstanceId = processInstance.getId();
				List<TaskDto> taskList = simpleGetTasks(processInstanceId);
				logger.info(JSON.toJSONString(taskList));
//				if (taskList != null && taskList.size() == 1) {
//					taskService.complete(taskList.get(0).getId(), variables);
//					taskService.createComment(taskList.get(0).getId(), processInstanceId, "提交流程");
//					resultList = simpleGetTasks(processInstanceId);
//				} else {
//					throw new Exception("获取提交任务失败：" + taskList.size());
//				}
			} else {
				throw new Exception("创建流程实例失败：");
			}
			System.out.println(JSON.toJSONString(resultList));

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

        执行预取：

@Test
	public void simulationNextPath() {
		String userId = "bx1";
		String processInstanceId = "5e46947a-8cd1-11ec-b7ab-8c1645647a47";

		AuthenticationService authenticationService = new AuthenticationService();
		String engineName = processEngine.getName();
		UserAuthentication authentication = (UserAuthentication) authenticationService.createAuthenticate(engineName,
				userId, null, null);
		logger.info("authentication--------->" + authentication.getName());
		identityService.setAuthenticatedUserId(authentication.getName());
		Map<String, Object> condition = runtimeService.getVariables(processInstanceId);
		condition.put("amount", 500);
		System.out.println("condition---->" + JSON.toJSONString(condition));
		List<TaskDefinition> tasks = null;
		try {
			tasks = getNextTaskInfos(processInstanceId, condition);
		} catch (Exception e) {
			e.printStackTrace();
		}
		logger.info("----------->" + JSON.toJSONString(tasks, SerializerFeature.DisableCircularReferenceDetect));
		JSONArray ja = new JSONArray();
		if (!CollectionUtils.isEmpty(tasks)) {
			for (TaskDefinition task : tasks) {
				JSONObject jo = new JSONObject();
				jo.put("key", task.getKey());
				jo.put("name", task.getNameExpression().getExpressionText());
				jo.put("assignment",
						task.getAssigneeExpression() == null ? "" : task.getAssigneeExpression().getExpressionText());
				ja.add(jo);
			}
		}
		System.out.println("----->" + ja.toString());

	}

        预取核心代码：

/**
	 * 获取下一个节点任务信息
	 * 
	 * @param processInstanceId
	 *            流程实例ID
	 * @return 下一个节点信息
	 * @throws Exception
	 */
	public List<TaskDefinition> getNextTaskInfos(String processInstanceId, Map<String, Object> condition)
			throws Exception {
		try {
			ProcessDefinitionEntity processDefinitionEntity = null;
			String id = null;
			// List<TaskDefinition> tasks =
			// null;//会出现java.util.ConcurrentModificationException异常，改成CopyOnWriteArrayList
			List<TaskDefinition> tasks = new CopyOnWriteArrayList<TaskDefinition>();
			// 获取流程发布Id信息
			String definitionId = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId)
					.singleResult().getProcessDefinitionId();
			processDefinitionEntity = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
					.getDeployedProcessDefinition(definitionId);
			ExecutionEntity execution = (ExecutionEntity) runtimeService.createExecutionQuery()
					.executionId(processInstanceId).singleResult();
			// 当前流程节点Id信息
			String activitiId = execution.getActivityId();
			System.out.println("execution----->" + activitiId);
			// 获取流程所有节点信息
			List<ActivityImpl> activitiList = processDefinitionEntity.getActivities();

			JSONArray ja = new JSONArray();
			// 遍历所有节点信息
			for (ActivityImpl activityImpl : activitiList) {
				id = activityImpl.getId();
				System.out.println("id----------->" + id + "----->" + activityImpl.getProperty("type"));
				if (activitiId.equals(id)) {
					// 获取下一个节点信息
					tasks = nextTaskDefinitions(activityImpl, activityImpl.getId(), processInstanceId, condition);
					break;
				}
			}

			return tasks;
		} catch (Exception e) {

			logger.error("operation error", e);
			throw e;
		}
	}

	private List<TaskDefinition> nextTaskDefinitions(ActivityImpl activityImpl, String activityId,
			String processInstanceId, Map<String, Object> condition) {
		try {
			PvmActivity ac = null;
			Object s = null;
			System.out.println("activityImpl.getActivityId()---->"+activityImpl.getActivityId()+"---activityId---------->"+activityId+"--->"+activityImpl.getProperty("type"));
			// List<TaskDefinition> taskDefinitions = new
			// ArrayList<TaskDefinition>();
			// //会出现java.util.ConcurrentModificationException异常，改成CopyOnWriteArrayList
			List<TaskDefinition> taskDefinitions = new CopyOnWriteArrayList<TaskDefinition>();
			// 如果遍历节点为用户任务并且节点不是当前节点信息
			if ("userTask".equals(activityImpl.getProperty("type")) && !activityId.equals(activityImpl.getId())) {
				// 获取该节点下一个节点信息
				TaskDefinition taskDefinition = ((UserTaskActivityBehavior) activityImpl.getActivityBehavior())
						.getTaskDefinition();
				taskDefinitions.add(taskDefinition);
			}else if (activityImpl.getProperty("type").toString().contains("EndEvent") && !activityId.equals(activityImpl.getId())) {
				// 设置结束节点
				TaskDefinition taskDefinition = new TaskDefinition(null);
				ExpressionManager expressionManager = new ExpressionManager();
				taskDefinition.setKey(activityImpl.getId() == null ? "end" : activityImpl.getId());
				String name = activityImpl.getProperty("name") == null ? "结束" : activityImpl.getProperty("name").toString();
				taskDefinition.setNameExpression(expressionManager.createExpression(name));
				taskDefinitions.add(taskDefinition);
			} else if ("multiInstanceBody".equals(activityImpl.getProperty("type")) && !activityId.equals(activityImpl.getId())) {
				// 获取该节点下一个节点信息
				List<ActivityImpl> list = ((ActivityImpl) activityImpl).getActivities();
				for(ActivityImpl act : list){
					//System.out.println("act-------------->"+act.getActivityBehavior().getClass().getTypeName());  
					TaskDefinition taskDefinition = ((UserTaskActivityBehavior) act.getActivityBehavior())
							.getTaskDefinition();
					taskDefinitions.add(taskDefinition);
				}
			} else if ("exclusiveGateway".equals(activityImpl.getProperty("type"))
					|| "inclusiveGateway".equals(activityImpl.getProperty("type"))) {// 当前节点为exclusiveGateway或inclusiveGateway
				List<PvmTransition> outTransitions = activityImpl.getOutgoingTransitions();
				String defaultTransition = (String) activityImpl.getProperty("default");
				if (outTransitions.size() == 1) {
					taskDefinitions.addAll(nextTaskDefinitions((ActivityImpl) outTransitions.get(0).getDestination(),
							activityId, processInstanceId, condition));
				} else if (outTransitions.size() > 1) { // 如果排他网关有多条线路信息
					for (PvmTransition tr1 : outTransitions) {
						ActivityImpl actImpl = (ActivityImpl) tr1.getDestination();
						if (actImpl.getProperty("type").toString().contains("EndEvent")) {
							TaskDefinition taskDefinition = new TaskDefinition(null);
							ExpressionManager expressionManager = new ExpressionManager();
							taskDefinition.setKey(actImpl.getId() == null ? "end" : actImpl.getId());
							String name = actImpl.getProperty("name") == null ? "结束"
									: actImpl.getProperty("name").toString();
							taskDefinition.setNameExpression(expressionManager.createExpression(name));
							taskDefinitions.add(taskDefinition);
							break;
						}
						s = tr1.getProperty("conditionText"); // 获取排他网关线路判断条件信息
						if (null == s) {
							continue;
						}
						// 判断el表达式是否成立
						if (isCondition(condition, StringUtils.trim(s.toString()))) {
							taskDefinitions.addAll(nextTaskDefinitions((ActivityImpl) tr1.getDestination(), activityId,
									processInstanceId, condition));
						}
					}
					if(taskDefinitions.size()==0 && StringUtils.isNotBlank(defaultTransition)){
						for (PvmTransition tr3 : outTransitions) {
							if(defaultTransition.equals(tr3.getId())){
								ActivityImpl actImpl = (ActivityImpl) tr3.getDestination();
								if (actImpl.getProperty("type").toString().contains("EndEvent")) {
									TaskDefinition taskDefinition2 = new TaskDefinition(null);
									ExpressionManager expressionManager2 = new ExpressionManager();
									taskDefinition2.setKey(actImpl.getId() == null ? "end" : actImpl.getId());
									String name2 = actImpl.getProperty("name") == null ? "结束"
											: actImpl.getProperty("name").toString();
									taskDefinition2.setNameExpression(expressionManager2.createExpression(name2));
									taskDefinitions.add(taskDefinition2);
									break;
								}

								taskDefinitions.addAll(nextTaskDefinitions( actImpl,
										activityId, processInstanceId, condition));
								System.out.println("taskDefinitions---333333333--->"+taskDefinitions.size());
							}
						}
					}
				}
			} else if ("parrallelGateway".equals(activityImpl.getProperty("type"))) {
				List<PvmTransition> outTransitions = activityImpl.getOutgoingTransitions();
				for (PvmTransition tr1 : outTransitions) {
					taskDefinitions.addAll(nextTaskDefinitions((ActivityImpl) tr1.getDestination(), activityId,
							processInstanceId, condition));
				}
			} else {
				// 获取节点所有流向线路信息
				List<PvmTransition> outTransitions = activityImpl.getOutgoingTransitions();
				List<PvmTransition> outTransitionsTemp = null;
				for (PvmTransition tr : outTransitions) {
					ac = tr.getDestination(); // 获取线路的终点节点
					System.out.println("ac----------->" + ac.getId() + "------>" + ac.getProperty("type"));
					// 如果流向线路为排他网关或包容网关
					if ("exclusiveGateway".equals(ac.getProperty("type"))
							|| "inclusiveGateway".equals(ac.getProperty("type"))) {
						outTransitionsTemp = ac.getOutgoingTransitions();
						String defaultTransition = (String) ac.getProperty("default");
						// 如果排他网关只有一条线路信息
						if (outTransitionsTemp.size() == 1) {
							taskDefinitions.addAll(
									nextTaskDefinitions((ActivityImpl) outTransitionsTemp.get(0).getDestination(),
											activityId, processInstanceId, condition));
						} else if (outTransitionsTemp.size() > 1) { // 如果排他网关有多条线路信息
							for (PvmTransition tr1 : outTransitionsTemp) {
								ActivityImpl actImpl = (ActivityImpl) tr1.getDestination();
								if (actImpl.getProperty("type").toString().contains("EndEvent")) {
									TaskDefinition taskDefinition2 = new TaskDefinition(null);
									ExpressionManager expressionManager2 = new ExpressionManager();
									taskDefinition2.setKey(actImpl.getId() == null ? "end" : actImpl.getId());
									String name2 = actImpl.getProperty("name") == null ? "结束"
											: actImpl.getProperty("name").toString();
									taskDefinition2.setNameExpression(expressionManager2.createExpression(name2));
									taskDefinitions.add(taskDefinition2);
									break;
								}

								System.out.println("taskDefinitions--1111---->"+taskDefinitions.size());
								s = tr1.getProperty("conditionText"); // 获取排他网关线路判断条件信息
								if (null == s) {
									continue;
								}
								// 判断el表达式是否成立
								if (isCondition(condition, StringUtils.trim(s.toString()))) {
									taskDefinitions.addAll(nextTaskDefinitions(actImpl,activityId, processInstanceId, condition));
								}
								
								System.out.println("taskDefinitions---22222--->"+taskDefinitions.size());
							}
							if(taskDefinitions.size()==0 && StringUtils.isNotBlank(defaultTransition)){
								for (PvmTransition tr3 : outTransitionsTemp) {
									if(defaultTransition.equals(tr3.getId())){
										ActivityImpl actImpl = (ActivityImpl) tr3.getDestination();
										if (actImpl.getProperty("type").toString().contains("EndEvent")) {
											TaskDefinition taskDefinition2 = new TaskDefinition(null);
											ExpressionManager expressionManager2 = new ExpressionManager();
											taskDefinition2.setKey(actImpl.getId() == null ? "end" : actImpl.getId());
											String name2 = actImpl.getProperty("name") == null ? "结束"
													: actImpl.getProperty("name").toString();
											taskDefinition2.setNameExpression(expressionManager2.createExpression(name2));
											taskDefinitions.add(taskDefinition2);
											break;
										}
	
										taskDefinitions.addAll(nextTaskDefinitions( actImpl,
												activityId, processInstanceId, condition));
										System.out.println("taskDefinitions---333333333--->"+taskDefinitions.size());
									}
								}
							}
						}
					} else if ("userTask".equals(ac.getProperty("type"))) {
						taskDefinitions.add(((UserTaskActivityBehavior) ((ActivityImpl) ac).getActivityBehavior())
								.getTaskDefinition());
					} else if ("multiInstanceBody".equals(ac.getProperty("type"))) {
						List<ActivityImpl> list = ((ActivityImpl) ac).getActivities();
						for(ActivityImpl act : list){
							//System.out.println("act-------------->"+act.getActivityBehavior().getClass().getTypeName());  
							TaskDefinition taskDefinition = ((UserTaskActivityBehavior) act.getActivityBehavior())
									.getTaskDefinition();
							taskDefinitions.add(taskDefinition);
						}
					} else if (ac.getProperty("type").toString().contains("EndEvent")) {
						// 设置结束节点
						TaskDefinition taskDefinition = new TaskDefinition(null);
						ExpressionManager expressionManager = new ExpressionManager();
						taskDefinition.setKey(ac.getId() == null ? "end" : ac.getId());
						String name = ac.getProperty("name") == null ? "结束" : ac.getProperty("name").toString();
						taskDefinition.setNameExpression(expressionManager.createExpression(name));
						taskDefinitions.add(taskDefinition);
					} else if ("parrallelGateway".equals(ac.getProperty("type"))) {
						List<PvmTransition> poutTransitions = ac.getOutgoingTransitions();
						for (PvmTransition tr1 : poutTransitions) {
							taskDefinitions.addAll(nextTaskDefinitions((ActivityImpl) tr1.getDestination(), activityId,
									processInstanceId, condition));
						}
					}
				}
			}
			return taskDefinitions;

		} catch (Exception e) {
			logger.error("operation error", e);
			throw e;
		}
	}

	private boolean isCondition(Map<String, Object> condition, String el) {
		try {
			ExpressionFactory factory = new ExpressionFactoryImpl();
			SimpleContext context = new SimpleContext();
			if (condition != null) {
				Iterator<Map.Entry<String, Object>> iterator = condition.entrySet().iterator();
				while (iterator.hasNext()) {
					Map.Entry<String, Object> value = iterator.next();
					context.setVariable(value.getKey(), factory.createValueExpression(value.getValue(), String.class));
				}
			}
			ValueExpression e = factory.createValueExpression(context, el, boolean.class);
			return (Boolean) e.getValue(context);
		} catch (Exception e) {
			logger.error("operation error", e);
			throw e;
		}
	}

        关于分支条件问题，预取时可以传入变量，模拟修改或设置变量，以便根据isCondition来判断分支条件是否成立，如下，该流程实例启动时设置的amount变量为1100，预取时设置为500，获取到的节点为”审批2“，经测试达到预期效果。

PS：预取代码没有进行严格测试，可能存在缺陷或性能问题，欢迎加QQ群：650886724 进行反馈与讨论，谢谢！

 

skayliu
关注
  • 11
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
camunda根据当前任务id获取下一步审批节点
FinelyYang的专栏
06-08 1741
【代码】camunda根据当前任务id获取下一步审批节点。
Activiti Flowable Camunda 钉钉流程设计器 审批流程 流程引擎 兼容 Activiti5 Activiti6 Activiti7 快速开发平台(收费)
java的第一堂课~
02-11 6026
快速开发平台 钉钉 流程设计器 Activiti Flowable Camunda 表单设计器
Camunda获取下一个用户审批节点
qq_39517116的博客
04-16 4153
Camunda获取下一个审批节点
camunda获取下一步流程操作
qq_34480328的博客
01-18 619
camunda获取下一步流程操作
Camunda 工作流节点跳转 - 多实例节点判断和跳转
最新发布
小单的博客专栏
08-23 1828
指令时不会考虑集合，并且不会为附加实例填充集合元素变量，针对这种情况，需要使用下面的处理方法。第2点，基于集合的多实例跳转节点的跳转时，需要在节点Id后追加特定字符串。注：对于目标节点是多实例的节点，如果不在节点Id后面追加框架约定的字符串。在多种工作流引擎中，Camunda框架对流程的处理控制更为强大、灵活。1、单实例节点，或者不是基于集合配置的多实例节点。如果多实例活动是基于集合配置的，则执行。，则不能自动执行触发多实例节点配置的。
camunda和flowable查看生成的xml的api
weixin_43472847的博客
01-28 589
【代码】camunda和flowable查看生成的xml的api。
Camunda_3：主动撤回
hwp_ing的博客
08-22 1284
但是这里对于复杂点的撤回是远远不够的。因为撤回的逻辑是需要判断下一个节点的任务是否执行完成的。而下一节点的可能性非常的多，处理用户节点这种简单的情况，还包括网关，子流程等复杂情况。除此之外，如果当前节点是会签节点，上面通过重启节点的方式来撤回是有问题的。通常的撤回/驳回逻辑如下。3、下一个节点的情况很多，除了用户任务，还包括服务任务，网关，子流程等。（注意获取后一节点所有已经完成的任务需要获取最新的，因为用户之前可能撤回过）这里提供简单的思路，等后面对camunda的学习更加深入后在进行修改调整。
Camunda BPM
12-10
Camunda 流程引擎及应用框架，完整可部署的Tomcat 应用
Linux下一种磁盘节能的预取算法.pdf
09-06
针对这一问题，Linux下的一种磁盘节能预取算法应运而生，它旨在通过优化预取策略来减少磁盘的能源消耗，延长磁盘的休眠时间，进而实现节能目标。 该算法的核心是延迟磁盘的异步预取和合并磁盘I/O操作。传统的预取...
一种基于预取的集群服务器调度算法
01-15
针对集群服务器LARD调度算法只能利用已有缓存的问题, 提出一种基于预取的算法Prefetch_LARD.该算法从Web 访问日志中挖掘页面之间的转移概率, 建立马尔科夫链模型, 在调度请求时利用概率关系提前将下一次可能访问的...
预取技术分析
10-17
预取技术通过提前从内存读取将来可能使用的数据降低内存时延对处理器执行的影响，是一种被广泛应用的提升处理器性能的技术。探讨了当前主流硬件平台的预取技术，分析了现有预取技术的不足并展望了预取技术的发展趋势...
cpu时钟预取实例代码分享
09-15
cpu时钟预取实例代码分享 ...cpu时钟预取是提高程序执行效率的一种重要技术。通过使用 cpu 时钟预取，我们可以提高程序的执行效率，从而提高用户体验。但是，我们也需要考虑到 cpu时钟预取的限制，以确保其正确地使用。
集群下Cholesky分解的核外预取算法
10-22
软件数据预取是一种有效的隐藏存储延迟的技术，通过预取使数据在实际使用之前从硬盘读到缓存中，提高了缓存(cache)的命中率，降低了读取数据的时间。通过设置两个缓冲区来轮流存放本次和下一次读入的数据块,实现访存...
Camunda流程驳回至上一节点
innerpeaceScorpio的博客
11-01 6075
Camunda驳回至上一节点，网上大多都是回退至开始节点，这样逻辑比较简单清晰。但实际使用中，往往需要驳回至上一节点，甚至需要连续驳回多次。流程驳回关键的一步就是获取到要回退到的节点。
Camunda 工作流并行子流程、工作流会签、或签、加签、比例签、跳转节点
justlpf的专栏
08-23 4147
在多个部门进行并行阅办的过程中，只要登记单的状态还不是已归档状态，第二个节点的领导，还可以随时增加阅办的部门（从技术的角度来说，只要子流程节点还是活动状态，就可以随时增加子流程活动节点的实例数）。在一些业务场景中，允许管理员或某个角色对运行中的流程进行节点跳转（或成为调度）操作，也就是可以将流程的任意一个节点设置为一个活动节点（为了保证流程允许的完整性同时会取消当前所有的活动节点）。结合上面的需求和已经画好的流程图，综合来看已经很清楚实现了，并行子流程应对 “多节点为一组” 独立并行流转的场景最为合适。
取消button的点击效果_开始制作第一个游戏（1）（放置点击类游戏）
weixin_39701288的博客
12-06 545
有了前面两个文章的铺垫kylaCpp：关于进入独立游戏的准备​zhuanlan.zhihu.comkylaCpp：关于开始制作游戏的准备​zhuanlan.zhihu.com你现在肯定已经有了做一个游戏方向和准备了。呢我我将带领大家做一个放置类的小游戏，游戏虽小，但是我尽量吧godot的功能给全部展示出来。首先在你喜欢的地方创建一个文件夹，这个文件夹以后就当作你的工作目录。然后打开godot 新建...
camunda使用指南
坚强的泡沫的博客
03-09 9308
参考：Camunda 快速入门、Camunda SpringBoot与进阶内容、camunda中文站、camunda官方英文文档 文章目录使用流程1、下载和安装2、编辑流程3、部署流程使用 Camunda Modeler 部署流程使用Cockpit查看部署结果创建流程实例（发起流程）4、人工任务添加人工任务节点“批准付款”：![image-20210527061148133](https://img-blog.csdnimg.cn/img_convert/635f2b388f8539be6ff74b1d.
activiti根据当前节点获取下一个节点信息
chenfengdejuanlian的专栏
05-04 3万+
在流程中使用监听器判断当前节点是否需要经过，否则跳转到下一个节点，如下图 当提交申请之后，当前提交人为部门负责人，那么部门负责人节点就不需要走了，直接到下一个节点，但是下一个节点是什么并不知道，就可以使用下面的代码获取到下一个节点信息直接跳转到下一个节点。 /** * 获取当前流程的下一个节点 * @param procInstanceId * @return
从Activiti切换到Camunda的5个理由
热门推荐
skayliu的专栏
04-05 4万+
原文：5 Reasons to switch from Activiti to Camunda 最近，Alfresco Activiti的前关键工程师宣布辞去Alfresco的职务。他们Fork了Activiti并开始了他们自己的项目（Flowable）。虽然该项目的成功还有待观察（并且个人而言，我祝愿他们一切顺利），但有一点是明确的：退出公司的人才留下了一个巨大的漏洞，并使平台的未来发展方向受...
openBLAS中预取指令如何预取一部分矩阵并举例
06-01
OpenBLAS中可以使用不同的预取指令来预取一部分矩阵的数据。其中，L1级别的预取指令可以预取矩阵中相邻的一行或一列的数据，L2级别的预取指令可以预取相邻的一块矩阵的数据，L3级别的预取指令可以预取更大的矩阵块的数据。具体来说，可以使用以下函数来实现OpenBLAS中的预取操作： ```c void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc); ``` 其中，M、N、K表示矩阵的维度，A、B、C表示矩阵的数据，alpha、beta表示矩阵乘法的系数，lda、ldb、ldc表示矩阵的存储格式和布局。 举例来说，如果要预取矩阵A的第一行数据，可以使用以下代码： ```c #define L1_CACHE_LINE_SIZE 64 float A[M*K]; float B[K*N]; float C[M*N]; for (int i = 0; i < M; i++) { __builtin_prefetch(&A[i*K], 0, 1); // 预取A的第i行数据 } cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha, A, K, B, N, beta, C, N); ``` 在上面的代码中，__builtin_prefetch函数用于预取矩阵A的第i行数据。这里使用了L1级别的预取指令，第二个参数为0表示预取到L1缓存，第三个参数为1表示预取读取数据后立即触发数据传输，即预取A的下一行数据。需要注意的是，在使用预取指令时，应该根据实际情况进行调整，以避免对性能产生负面影响。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值