流程引擎基础知识

流程引擎基础知识

    • 流程部署
    • 流程取消部署
    • 流程发起
    • 流程取回
    • 流程作废
    • 流程委托
    • 流程流转
    • 常用流程表介绍
    • 备注

流程部署

1.后台直接导入bpmn

        /*
         *流程部署源代码
         */
   public void deploy() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        repositoryService.createDeployment().addClasspathResource("test.bpmn").name("谁家女儿郎").deploy();
    }

2.前端画模型

       /**
	 * 创建模型
	 */
	@RequestMapping("/create")
	public Result<String> create(@RequestBody ModelDTO dto, HttpServletRequest request, HttpServletResponse response) {
		Result<String> result = new Result<String>();
		try {
			String modelId = actModelService.save(dto.getName(), dto.getKey(), dto.getDescription());
			result.setResult(modelId);
		    //response.sendRedirect(request.getContextPath() + "/modeler.html?modelId=" + modelId);
		} catch (Exception e) {
			e.printStackTrace();
			log.error("新建流程失败！");
		}
		return result;
	}

   public String save(String name, String key, String description) throws UnsupportedEncodingException {
        //新建一个空模型
        Model model = repositoryService.newModel();

        //metaInfo信息
        ObjectNode metaInfo = objectMapper.createObjectNode();
        metaInfo.put(ModelDataJsonConstants.MODEL_NAME, name);
        metaInfo.put(ModelDataJsonConstants.MODEL_DESCRIPTION, description);
        metaInfo.put(ModelDataJsonConstants.MODEL_REVISION, model.getVersion());

        model.setKey(key);
        model.setName(name);
        model.setMetaInfo(metaInfo.toString());

        repositoryService.saveModel(model);

        ObjectNode editorNode = objectMapper.createObjectNode();
        editorNode.put("id", "canvas");
        editorNode.put("resourceId", "canvas");
        ObjectNode stencilset = objectMapper.createObjectNode();
        stencilset.put("namespace", "http://b3mn.org/stencilset/bpmn2.0#");
        editorNode.set("stencilset", stencilset);
        repositoryService.addModelEditorSource(model.getId(), editorNode.toString().getBytes("utf-8"));
        return model.getId();
    }

	/**
	 * 流程部署
	 * @param id
	 * @return
	 */
	@GetMapping("deploy/{id}")
	public Result deploy(@PathVariable("id") String id) {
		actModelService.deploy(id);
		return Result.OK("流程发布成功");
	}


    public void deploy(String id) {
        try {
            Model model = repositoryService.getModel(id);
            BpmnJsonConverter jsonConverter = new BpmnJsonConverter();
            JsonNode editorNode = new ObjectMapper().readTree(repositoryService.getModelEditorSource(model.getId()));
            BpmnModel bpmnModel = jsonConverter.convertToBpmnModel(editorNode);
            BpmnXMLConverter xmlConverter = new BpmnXMLConverter();
            byte[] bpmnBytes = xmlConverter.convertToXML(bpmnModel);

            String processName = model.getName();
            if (!StringUtils.endsWith(processName, ".bpmn20.xml")){
                processName += ".bpmn20.xml";
            }

            ByteArrayInputStream in = new ByteArrayInputStream(bpmnBytes);
            Deployment deployment = repositoryService.createDeployment().name(model.getName()).addInputStream(processName, in).deploy();

            List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().deploymentId(deployment.getId()).list();
            if (list.size() == 0){
                throw new JeecgBootException("流程定义为空");
            }
        } catch (Exception e) {
            throw new JeecgBootException(e);
        }
    }

流程取消部署

1.后台直接导入bpmn

    @GetMapping("/caceldeploy")
    @ApiOperation(notes = "取消部署", value = "取消部署")
    public void caceldeploy(String deployId) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = processEngine.getRepositoryService();
        repositoryService.deleteDeployment(deployId, true);
    }

2.前端画模型

/**
	 * 删除流程设计模型
	 * @param ids
	 * @return
	 */
	@GetMapping(value = "/delete")
	public Result delete(@RequestParam(name = "ids", required = true) String ids) {
		if(CommonRandomUtil.isNotEmpty(ids)) {
			for (String id : Arrays.asList(ids.split(","))) {
				actModelService.delete(id);   //直接删除流程设计模型
			}
		}
		return Result.OK("流程删除成功");
	}

//备注：需实现repositoryService的void deleteDeployment(String deploymentId)的接口

流程发起

1.启动流程，后台导入bpmn

   @GetMapping("/startProcessInstanceByKey")
    @ApiOperation(notes = "创建流程实例", value = "创建流程实例")
    public Result<?> startProcessInstanceByKey(String processDefinitionKey, String businessKey, String initiator) {
        Map<String, Object> map = new HashMap<>();
        map.put("name", "deng");
        map.put("reason", "等天黑");
        //设置流程发起人
        identityService.setAuthenticatedUserId("deng");
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey, businessKey, map);
        return Result.OK("等天黑");

    }

2.流程改造后的启动流程

	/**
	 * 启动流程
	 * @param userId
	 * @param businessKey
	 * @param variables
	 * @param extActProcessForm
	 * @return
	 * @throws BpmException
	 */
	private ProcessInstance startWorkflow(String userId, String businessKey, Map<String, Object> variables, ExtActProcessForm extActProcessForm) throws BpmException{
		// 设置流程发起人
		identityService.setAuthenticatedUserId(userId);
		variables.put(WorkFlowGlobals.BPM_FORM_BUSINESSKEY, businessKey);
		variables.put(WorkFlowGlobals.BPM_FORM_TYPE, extActProcessForm.getFormType());
		variables.put(WorkFlowGlobals.BPM_BIZ_TITLE, BpmUtil.getContent(variables,extActProcessForm.getTitleExp()));
		variables.put(WorkFlowGlobals.BPM_PROC_DEAL_STYLE, ProcDealStyleEnum.toEnum(extActProcessForm.getFormDealStyle()).getCode());
		//根据流程id查询流程信息
		ExtActProcess extActProcess = extActProcessMapper.selectById(extActProcessForm.getProcessId());
		
		//获取最新发布的流程定义-----------------核心代码1
		ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey(extActProcess.getProcessKey()).latestVersion().singleResult();
		//update-begin--Author:zhoujf  Date:20180727 for：流程未发布流程提交异常处理
		if(processDefinition==null){
			throw new BpmException("流程未发布，请先发布流程！");
		}
		String formUrl = (String)variables.get(WorkFlowGlobals.BPM_FORM_CONTENT_URL);
		String formUrlM = (String)variables.get(WorkFlowGlobals.BPM_FORM_CONTENT_URL_MOBILE);
		formUrl = BpmUtil.getNodeUrl(variables, formUrl, businessKey);
		formUrlM = BpmUtil.getNodeUrl(variables, formUrlM, businessKey);
		variables.put(WorkFlowGlobals.BPM_FORM_CONTENT_URL, formUrl);
		variables.put(WorkFlowGlobals.BPM_FORM_CONTENT_URL_MOBILE, formUrlM);

		//根据流程id和部署id查询流程部署节点
//		List<ExtActProcessNodeDeployment> nodeList = new ArrayList<ExtActProcessNodeDeployment>();
//		LambdaQueryWrapper<ExtActProcessNodeDeployment> queryWrapper = new LambdaQueryWrapper<ExtActProcessNodeDeployment>();
//		queryWrapper.eq(ExtActProcessNodeDeployment::getProcessId, extActProcessForm.getProcessId());
//		queryWrapper.eq(ExtActProcessNodeDeployment::getDeploymentId, processDefinition.getDeploymentId());
//		nodeList = extActProcessNodeDeploymentService.list(queryWrapper);
//		if(nodeList!=null&&nodeList.size()>0){
//			for(ExtActProcessNodeDeployment node:nodeList){
//				if(oConvertUtils.isNotEmpty(node.getModelAndView())){
//					variables.put(node.getProcessNodeCode()+":"+WorkFlowGlobals.SUFFIX_BPM_FORM_URL, node.getModelAndView());
//				}
//				if(oConvertUtils.isNotEmpty(node.getModelAndViewMobile())){
//					variables.put(node.getProcessNodeCode()+":"+WorkFlowGlobals.SUFFIX_BPM_FORM_URL_MOBILE, node.getModelAndViewMobile());
//				}
//			}
//		}

         //创建流程实例------------------------------------------------核心代码2
		ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(extActProcess.getProcessKey(), businessKey, variables);
		if(processInstance==null||oConvertUtils.isEmpty(processInstance.getProcessInstanceId())){
			return null;
		}
		//将流程实例ID存在流程变量里面 ----------------------------------核心代码3
		runtimeService.setVariable(processInstance.getProcessInstanceId(), WorkFlowGlobals.JG_LOCAL_PROCESS_ID, processInstance.getProcessInstanceId());
		return processInstance;
	}

流程取回

/**
	 * 我发起的流程，流程追回按钮，流程取回
	 * 流程追回：删除流程实例，启动表单单据保留，
	 *
	 * @param
	 * @return
	 */
	@PostMapping(value = "/callBackProcess")
	public Result<Map<String, Object>> callBackProcess(@RequestBody HashMap<String, String> map,
													   HttpServletRequest request) {
		Result<Map<String, Object>> result = new Result<Map<String, Object>>();
		try {
			//添加评定业务流程取回时重置表数据功能
			String processInstanceId1 = map.get("processInstanceId");
			//Map<String, Object> flowDataByProcInstId = extActFlowDataService.getFlowDataByProcInstId(processInstanceId1);
			//extActFlowDataService.updateFormDataById((String) flowDataByProcInstId.get("formDataId"));

			String processInstanceId = oConvertUtils.getString(map.get("processInstanceId"));
			ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
			runtimeService.setVariable(pi.getProcessInstanceId(), WorkFlowGlobals.BPM_STATUS, WorkFlowGlobals.PROCESS_CALLBACKPROCESS_STATUS);
			runtimeService.deleteProcessInstance(processInstanceId, "发起人流程追回");
			result.success("追回成功");
		} catch (Exception e) {
			e.printStackTrace();
			result.error500("追回失败");
		}
		return result;
	}

流程作废

	/**
	 * 我发起的流程，作废按钮
	 *
	 * @param
	 * @return
	 */
	@PostMapping(value = "/invalidProcess")
	public Result<Map<String, Object>> invalidProcess(@RequestBody HashMap<String, String> map,
													  HttpServletRequest request) {
		Result<Map<String, Object>> result = new Result<Map<String, Object>>();
		try {
			String processInstanceId = oConvertUtils.getString(map.get("processInstanceId"));
			ProcessInstance pi = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
			runtimeService.setVariable(pi.getProcessInstanceId(), WorkFlowGlobals.BPM_STATUS, WorkFlowGlobals.PROCESS_INVALIDPROCESS_STATUS);
			runtimeService.deleteProcessInstance(processInstanceId, "发起人流程作废");
			result.success("作废成功");
		} catch (Exception e) {
			e.printStackTrace();
			result.error500("作废失败");
		}
		return result;
	}

流程委托

/**
	 * 委托
	 *
	 * @param
	 * @return
	 */
	@PostMapping(value = "/taskEntrust111")
	public Result<Map<String, Object>> taskEntrust111(@RequestBody HashMap<String, String> map,
													  HttpServletRequest request) {
		Result<Map<String, Object>> result = new Result<Map<String, Object>>();
		try {
			String taskId = oConvertUtils.getString(map.get("taskId"));
			//委托要改成批量委托taskId用逗号分隔
			List<String> list = Arrays.asList(taskId.split(","));
			for (String s : list) {
				String taskAssignee = oConvertUtils.getString(map.get("taskAssignee"));
				Task task = taskService.createTaskQuery().taskId(s).active().singleResult();
				//判断任务是否签收没有签收需要进行签收
				if (oConvertUtils.isEmpty(task.getAssignee())) {
					String userId = JwtUtil.getUserNameByToken(request);
					taskService.claim(s, userId);
				}
				taskService.delegateTask(task.getId(), taskAssignee);
			}
			result.success("委托成功");
		} catch (Exception e) {
			e.printStackTrace();
			result.error500("委托失败");
		}
		return result;
	}

流程流转

/**
	 * 提交流程处理
	 *
	 * @param map
	 * @param request
	 * @return
	 */
	@PostMapping(value = "processComplete")
	public Result<Object> processComplete(@RequestBody HashMap<String, String> map,
										  HttpServletRequest request) {
		Long startTime = System.currentTimeMillis();
		log.debug("进入方法processComplete内，当前时间戳{}" + startTime);
		Result<Object> result = new Result<Object>();
		try {
			//监听通过request取到参数的信息的处理
			request.setAttribute("data", map);
			String taskId = oConvertUtils.getString(map.get("taskId"));
			//下一节点名称
			String nextnode = oConvertUtils.getString(map.get("nextnode"));
			//下一步节点的数目（小心歧义）
			Integer nextCodeCount = oConvertUtils.getInt(map.get("nextCodeCount"));
//		String way = oConvertUtils.getString(request.getParameter("way"));
//		ProcessHandle processHandle = activitiService.getProcessHandle(taskId);
			//模式类型（单/多分支模式/驳回模式）
			String model = oConvertUtils.getString(map.get("processModel"));
			//下一步操作人
			String nextUser = oConvertUtils.getString(map.get("nextUserId"));
			//驳回时选择驳回到哪一节点
			String rejectNode = oConvertUtils.getString(map.get("rejectModelNode"));

			String accomplishFlag = "";
			if (map.get("accomplishFlag") != null) {
				accomplishFlag = oConvertUtils.getString(map.get("accomplishFlag"));
			}


			//TODO 流程变量参数
//		Map<String, Object> varmap = var.getVariableMap(processHandle.getTpProcesspros());
			Map<String, Object> varmap = new HashMap<String, Object>();
			Task task = activitiService.getTask(taskId);
			if (task == null) {
				return Result.error("该节点为首节点,无法驳回");
			}
			String processInstanceId = task.getProcessInstanceId();
			runtimeService.setVariable(processInstanceId, WorkFlowGlobals.BPM_STATUS, WorkFlowGlobals.BPM_BUS_STATUS_2);
			runtimeService.setVariable(processInstanceId, "tenantId", request.getHeader("tenant_id"));
			List<String> nextUserList = Arrays.asList(nextUser.split(","));
			if (nextUserList != null && nextUserList.size() > 0) {
				runtimeService.setVariable(processInstanceId, "nextUser", nextUserList.get(0));
			}

			if (!"1".equals(model) && !"2".equals(model)) {
				// 取得所有历史任务按时间降序排序
				List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
						.processInstanceId(processInstanceId)
						.orderByTaskCreateTime()
						.desc()
						.list();
				//查出离现在第二近的上一节点处理人
				String assignee = "";
				int i = 0;
				for (HistoricTaskInstance historicTaskInstance : htiList) {
					if (historicTaskInstance.getTaskDefinitionKey().equals(rejectNode)) {
						assignee = historicTaskInstance.getAssignee();
						i++;
						if (i == 2) {
							break;
						}
					}
				}
				runtimeService.setVariable(processInstanceId, "rejectNextBy", assignee);
			}
			boolean bflag = this.checkUserTaskIsHuiQian(taskId, nextnode);

			if (bflag) {
				varmap.put(WorkFlowGlobals.ASSIGNEE_USER_ID_LIST, nextUser);
				runtimeService.setVariable(processInstanceId, WorkFlowGlobals.ASSIGNEE_USER_ID_LIST, nextUser);
				if (!"".equals(accomplishFlag)) {
					varmap.put("accomplish_flag", accomplishFlag);
				}
			}
			//判断是否是委托任务，被委托人先解决委托
			if (StringUtils.isNotBlank(task.getOwner())) {
				DelegationState delegationState = task.getDelegationState();
				switch (delegationState) {
					case PENDING:
						taskService.resolveTask(taskId);
						break;
					case RESOLVED:
						//委托任务已经完成
						break;

					default:
						//不是委托任务
						break;
				}
			}

			String rejectDescription = "";
			if ("1".equals(model)) {
				//---update-begin-----autor:zhoujf------date:20190927-------for:并行网关停滞不前问题--------
				//判断是否是并行网关
				boolean isParallelGateway = this.checkParallelGateway(task.getProcessDefinitionId(), nextnode);
				//单分支模式
				if ("end".equals(nextnode)) {
					if (nextCodeCount == 1 || isParallelGateway) {
						taskService.complete(taskId, varmap);
					} else {
						activitiService.goProcessTaskNode(taskId, nextnode, varmap);
					}
				} else {
					//多分支模式
					if (nextCodeCount == 1 || isParallelGateway) {
						taskService.complete(taskId, varmap);
					} else {
						activitiService.goProcessTaskNode(taskId, nextnode, varmap);
					}
					//---update-end-----autor:zhoujf------date:20190927-------for:并行网关停滞不前问题--------
					//如果下个节点不是会签节点，动态指派下一步处理人
					if (!bflag) {
						//会签情况下，该SQL会报错
						String nextTskId = activitiService.getTaskIdByProins(processInstanceId, nextnode);
						//---update-begin-----autor:scott------date:20190925-------for:TASK #3188 下一步节点不是任务节点的情况下，不走指派逻辑不然报错。比如：下一步是个网关--------
						if (oConvertUtils.isNotEmpty(nextUser) && oConvertUtils.isNotEmpty(nextTskId)) {
							//---update-end-----autor:scott------date:20190925-------for:TASK #3188 下一步节点不是任务节点的情况下，不走指派逻辑不然报错。比如：下一步是个网关--------
							if (nextUser.indexOf(",") < 0) {
								//指定单个执行人
								taskService.setAssignee(nextTskId, nextUser);
							} else {
								//---update-begin-----autor:scott------date:20190925-------for:TASK #3187 【疑似BUG】 出差申请 下一步操作人 选择多个
								//指定多人
								taskService.setAssignee(nextTskId, null);
								for (String userid : nextUser.split(",")) {
									if (oConvertUtils.isNotEmpty(userid)) {
										taskService.addCandidateUser(nextTskId, userid);
									}
								}
								//---update-end-----autor:scott------date:20190925-------for:TASK #3187 【疑似BUG】 出差申请 下一步操作人 选择多个
							}
						}
					} else {
						runtimeService.setVariable(processInstanceId, "assigneeUserIdList", nextUser);
					}
				}
			} else if ("2".equals(model)) {
				//多分支模式
				taskService.complete(taskId, varmap);
			} else {
				runtimeService.setVariable(processInstanceId, WorkFlowGlobals.BPM_STATUS, WorkFlowGlobals.PROCESS_REJECTPROCESS_STATUS);
				//驳回模式
				activitiService.goProcessTaskNode(taskId, rejectNode, varmap);
				String nextTskId = activitiService.getTaskIdByProins(processInstanceId, rejectNode);
				// 取得所有历史任务按时间降序排序
				List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
						.processInstanceId(processInstanceId)
						.orderByTaskCreateTime()
						.desc()
						.list();
				//查出离现在第二近的上一节点处理人
				String assignee = "";
				int i = 0;
				for (HistoricTaskInstance historicTaskInstance : htiList) {
					if (historicTaskInstance.getTaskDefinitionKey().equals(rejectNode)) {
						assignee = historicTaskInstance.getAssignee();
						i++;
						if (i == 2) {
							break;
						}
					}
				}
//				runtimeService.setVariable(processInstanceId,"rejectNextBy",assignee);
				//TODO  这行代码替换了下面注释的部分
				try {
					taskService.setAssignee(nextTskId, assignee);
				} catch (ActivitiIllegalArgumentException e) {
					log.info("taskId is null");
				}

//				if(oConvertUtils.isNotEmpty(nextUser)){
//					if(nextUser.indexOf(",") < 0){
//						//指定单个执行人
//						taskService.setAssignee(nextTskId,nextUser);
//					}else{
//						//指定多人
//						taskService.setAssignee(nextTskId,null);
//						//---update-begin-----autor:scott------date:20190930------for:TASK #3187 【疑似BUG】 出差申请 下一步操作人 选择多个
//						for (String userid : nextUser.split(",")) {
//							if (oConvertUtils.isNotEmpty(userid)) {
//								taskService.addCandidateUser(nextTskId, userid);
//							}
//						}
//						//---update-end-----autor:scott------date:20190930-------for:TASK #3187 【疑似BUG】 出差申请 下一步操作人 选择多个
//					}
//				}

				//TODO  流程委托、驳回 日志问题
				Task nexttask = activitiService.getTask(nextTskId);
				//---update-begin-----autor:scott------date:20191203------for:驳回人显示真实名字，不显示账号
				String assigneeUserName = task.getAssignee();
				LoginUser loginUser = sysBaseAPI.getUserByName(task.getAssignee());
				if (loginUser != null) {
					assigneeUserName = loginUser.getRealname();
				}
				//---update-end-----autor:scott------date:20191203------for:驳回人显示真实名字，不显示账号

				rejectDescription = assigneeUserName + "驳回任务 〔" + task.getName() + "〕 →〔" + nexttask.getName() + "〕 ";
//				List<HistoricTaskInstance>  hiTaskInstList = historyService.createHistoricTaskInstanceQuery().taskId(taskId).list();
//				ActHiTaskinst actHiTaskinst = this.systemService.get(ActHiTaskinst.class, taskId);
//				actHiTaskinst.setDescription(rejectDescription);
//				actHiTaskinst.setDeleteReason(rejectDescription);
//				this.systemService.saveOrUpdate(actHiTaskinst);
				// 流程委托、驳回 日志问题
			}

			String username = JwtUtil.getUserNameByToken(request);
			LoginUser user = sysBaseAPI.getUserByName(username);
			// 任务抄送处理
			String ccUserNames = oConvertUtils.getString(map.get("ccUserIds"));
			//任务抄送记录
			taskCc(ccUserNames, task, username);

			//每个task节点执行完成后，处理审批日志
			ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();

			String reason = oConvertUtils.getString(map.get("reason"));
			ExtActBpmLog bpmlog = new ExtActBpmLog();
			if (processInstance != null) {
				bpmlog.setBusinessKey(processInstance.getBusinessKey());
				bpmlog.setProcName(processInstance.getName());
			}
//			bpmlog.setOpStatus(opStatus);
			bpmlog.setOpTime(new Date());
//			bpmlog.setOpType(WorkFlowGlobals.BPM_OP_TYPE_1);
			bpmlog.setOpUserId(username);
			if (user != null) {
				bpmlog.setOpUserName(user.getRealname());
			}
			bpmlog.setProcInstId(processInstanceId);
			if (oConvertUtils.isNotEmpty(rejectDescription)) {
				reason = reason + "       『 " + rejectDescription + " 』";
			}
			bpmlog.setRemarks(reason);
			bpmlog.setTaskDefKey(task.getTaskDefinitionKey());
			bpmlog.setTaskId(taskId);
			bpmlog.setTaskName(task.getName());
			extActBpmLogService.save(bpmlog);
			//保存附件
			String fileList = oConvertUtils.getString(map.get("fileList"));
			saveBpmFiles(bpmlog.getId(), fileList);
		} catch (BpmException e) {
			result.error500("任务执行失败:" + e.getMessage());
			e.printStackTrace();
		} catch (ActivitiException e) {
			result.error500("任务执行失败:" + e.getMessage());
			e.printStackTrace();
			Object actObj = e.getCause();
			if (actObj != null) {
				Throwable throwable = (Throwable) actObj;
				if (throwable.getCause() != null && throwable.getCause() instanceof BpmException) {
					result.error500("任务执行失败:" + throwable.getCause().getMessage());
				}
			}
		} catch (Exception e) {
			result.error500("任务执行失败:" + e.getMessage());
			e.printStackTrace();
			Object actObj = e.getCause();
			if (actObj != null) {
				Throwable throwable = (Throwable) actObj;
				if (throwable.getCause() != null && throwable.getCause() instanceof BpmException) {
					result.error500("任务执行失败:" + throwable.getCause().getMessage());
				}
			}
		}
		Long endTime = System.currentTimeMillis();
		log.debug("方法processComplete结束前，当前时间戳{}" + endTime);
		log.debug("耗时(毫秒):{}", endTime - startTime);

		return result;
	}

常用流程表介绍

1.历史节点表—act_hi_actinst
流程历史节点表常用来查询流程走过的节点
在这里插入图片描述

2.历史变量表—act_hi_varinst
流程历史节点表常用来查询流程走到的节点的元数据（业务数据）
在这里插入图片描述

3.运行时任务节点表—act_ru_lask
运行时加点表表明当前流程走到的节点

在这里插入图片描述

4.运行时流程变量数据表—act_ru_variable
运行时加点表表明当前流程走到的节点信息（业务数据）
在这里插入图片描述
5.流程部署信息表—act_re_deployment
流程部署后流程存储的地方—主要字段id（流程部署id）
在这里插入图片描述

6.流程定义数据表—act_re_prodef
流程定义
在这里插入图片描述

7.运行时流程人员表—act_ru_identitylink
每个节点的人员信息
在这里插入图片描述

8.运行时流程实例表—act_ru_execution
关键表，集合了流程实例id,流程定义id，流程节点id，以及业务表id
在这里插入图片描述

9.运行各个表之间的关系
表之间的关系以及字段

备注

流程实例id贯穿运行表，运行表业务字段，历史表，历史表业务字段，流程实例表，属于比较重要的字段

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/12092.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

UML与代码的对应关系

UML与代码的对应关系

五种关系的耦合强弱比较&#xff1a;依赖<关联<聚合<组合<继承 依赖 虚线箭头 可描述为&#xff1a;Uses a 依赖是类的五种关系中耦合最小的一种关系。 因为在生成代码的时候&#xff0c;这两个关系类都不会增加属性。 注意1&#xff1a; Water类的生命期&…
阅读更多...
1676_MIT 6.828 xv6中的CPU alarm_资料翻译整理

1676_MIT 6.828 xv6中的CPU alarm_资料翻译整理

全部学习汇总&#xff1a; GreyZhang/g_unix: some basic learning about unix operating system. (github.com) 我觉得看了几个MIT的课程之后让我觉得我的大学四年有点浪费时光&#xff0c;看起来MIT的课程的确是很有饱满度。 这里&#xff0c;再整理一份课程中的作业要求。 …
阅读更多...
JavaWeb03 Cookie和Session

JavaWeb03 Cookie和Session

一个网站怎么证明你来过&#xff1f; 1.首次访问时服务器给客户端一个cookie&#xff0c;下次客户端再次访问会自动携带cookie&#xff0c;注意cookie可以是多个 2.首次访问时服务器登记了客户端一系列信息&#xff0c;下次客户端再进行访问时服务器自动匹配此客户端是否访问…
阅读更多...
【架构设计】如何设计一个几十万在线用户弹幕系统

【架构设计】如何设计一个几十万在线用户弹幕系统

文章目录 一、前言二、项目介绍客户端轮询WebSocket主动推送 三、弹幕初始架构四、弹幕架构演进五、弹幕存储六、弹幕查询七、总结 一、前言 现在无论是直播还是电视剧&#xff0c;我们都可以看到上面慢慢的弹幕&#xff0c;满足十几万用户在线的弹幕系统&#xff0c;我们该如…
阅读更多...
vue3插槽的使用

vue3插槽的使用

插槽就是子组件中的提供给父组件使用的一个占位符&#xff0c;用 表示&#xff0c;父组件可以在这个占位符中填充任何模板代码&#xff0c;如 HTML、组件等&#xff0c;填充的内容会替换子组件的标签。 1.插槽基本使用 子组件SlotComponent.vue <template><div cla…
阅读更多...
逐一解释一下四个 “内存屏障” 是什么

逐一解释一下四个 “内存屏障” 是什么

什么是内存屏障&#xff1f;硬件层⾯&#xff0c;内存屏障分两种&#xff1a;读屏障&#xff08;Load Barrier&#xff09;和写屏障&#xff08;Store Barrier&#xff09;。内存屏障有两个作⽤&#xff1a; 阻⽌屏障两侧的指令重排序&#xff1b;强制把写缓冲区/⾼速缓存中的…
阅读更多...
【软考备战·希赛网每日一练】2023年4月18日

【软考备战·希赛网每日一练】2023年4月18日

文章目录 一、今日成绩二、错题总结第一题第二题第三题 三、知识查缺 题目及解析来源&#xff1a;2023年04月18日软件设计师每日一练 一、今日成绩 二、错题总结 第一题 解析&#xff1a; MTTF&#xff1a;平均无故障时间 MTTR&#xff1a;平均故障修复时间 可用性/可靠性MTTF…
阅读更多...
一觉醒后ChatGPT 被淘汰了

一觉醒后ChatGPT 被淘汰了

OpenAI 的 Andrej Karpathy 都大力宣传&#xff0c;认为 AutoGPT 是 prompt 工程的下一个前沿。 近日&#xff0c;AI 界貌似出现了一种新的趋势&#xff1a;自主人工智能。 这不是空穴来风&#xff0c;最近一个名为 AutoGPT 的研究开始走进大众视野。特斯拉前 AI 总监、刚刚回归…
阅读更多...
zookeeper + kafka集群搭建详解

zookeeper + kafka集群搭建详解

目录 1.消息队列介绍 1.为什么需要消息队列 &#xff08;MO&#xff09; 2.使用消息队列的好处 3.消息队列的两种模式 2.Kafka相关介绍 1.Kafka定义 2.Kafka简介 3. Kafka的特性 3.Kafka系统架构 1. Broker&#xff08;服务器&#xff09; 2. Topic&#xff08;一个队…
阅读更多...
SAR ADC系列25：作业和上机实践

SAR ADC系列25：作业和上机实践

作业&#xff1a; 异步SAR逻辑中VALID信号如何产生&#xff1f;答&#xff1a;OUTP和OUTN与非。单纯通过减小“比较器环路”的延时(t1t22*t32*t4)的方式来提升ADC的转换速率可行吗&#xff1f;为什么&#xff1f;答&#xff1a;不可行&#xff0c;还要考虑CDAC建立的速度&…
阅读更多...
人工智能大模型多场景应用原理解析

人工智能大模型多场景应用原理解析

前言 在上篇文章《人工智能大模型之ChatGPT原理解析》中分享了一些大模型之ChatGPT的核心原理后&#xff0c;收到大量读者的反馈&#xff0c;诸如:在了解了核心原理后想进一步了解未来的发展趋势(比如生成式人工智能和元宇宙能擦出什么样的火花&#xff1f;)&#xff0c;大模型…
阅读更多...
抢鲜发布：Flutter 3.7更新详解

抢鲜发布：Flutter 3.7更新详解

本文首发自「慕课网」(imooc.com)&#xff0c;想了解更多IT干货内容&#xff0c;程序员圈内热闻&#xff0c;欢迎关注"慕课网"&#xff01; 作者&#xff1a;CrazyCodeBoy|慕课网讲师 新年伊始&#xff0c;由 Flutter 3.7 正式版来「打头阵」&#xff01;我们与整个…
阅读更多...
Parallels Desktop for Mac 适用于苹果 macOS 的 PD 虚拟机（安装使用详细教程）

Parallels Desktop for Mac 适用于苹果 macOS 的 PD 虚拟机（安装使用详细教程）

简介 Parallels Desktop for Mac 是一款适用于苹果 macOS 操作系统的虚拟机软件&#xff0c;可以让用户在 Mac 上运行 Windows、Linux 等其他操作系统&#xff0c;同时也可以在虚拟机中安装其他软件和应用程序。Parallels Desktop for Mac 还提供了许多实用的功能&#xff0c;…
阅读更多...
【蓝桥杯】数组中存在K倍区间的子数组个数

【蓝桥杯】数组中存在K倍区间的子数组个数

文章目录 前言题目分析算法难度实战1、创建算法2、创建测试用例3、运行测试用例4、测试结果 总结 前言 蓝桥杯全国软件和信息技术专业人才大赛由工业和信息化部人才交流中心主办,每年参赛人数超过30000人。蓝桥杯大赛作为国内领先的全国性 IT 学习赛事&#xff0c;持续有力支撑…
阅读更多...
软件测试员----面试，你准备好了么？

软件测试员----面试，你准备好了么？

最近有机会做一些面试工作&#xff0c;主要负责面试软件测试人员招聘的技术面试。 之前一直是应聘者的角色&#xff0c;经历了不少次的面试之后&#xff0c;多少也积累一点面试的经验&#xff0c;现在发生了角色转变。初次的面试就碰到个工作年限比我长的&#xff0c;也没有时间…
阅读更多...
【jvm系列-04】精通运行时数据区共享区域---堆

【jvm系列-04】精通运行时数据区共享区域---堆

JVM系列整体栏目 内容链接地址【一】初识虚拟机与java虚拟机https://blog.csdn.net/zhenghuishengq/article/details/129544460【二】jvm的类加载子系统以及jclasslib的基本使用https://blog.csdn.net/zhenghuishengq/article/details/129610963【三】运行时私有区域之虚拟机栈…
阅读更多...
罗丹明-聚乙二醇-生物素RB-PEG-Biotin；Biotin-PEG-Rhodamine，PEG2000

罗丹明-聚乙二醇-生物素RB-PEG-Biotin；Biotin-PEG-Rhodamine，PEG2000

RB-PEG-Biotin 罗丹明-聚乙二醇-生物素 中文名称&#xff1a;罗丹明-聚乙二醇-生物素 英文名称&#xff1a;RB-PEG-Biotin 分子量&#xff08;PEG &#xff09;&#xff1a;2000、3400、5000&#xff0c;其他分子量可以定制。 用 途&#xff1a;仅供科研实验使用。 性状&…
阅读更多...
不会注册ChatGPT?4个国内网站让你尽情体验

不会注册ChatGPT?4个国内网站让你尽情体验

最近火出圈的科技新词非“ChatGPT”莫属了。 但是由于ChatGPT注册起来比较困难&#xff0c;我到现在都还学不会如何注册.... 但是&#xff01;世上无难事&#xff01;只要有心人&#xff01; 我千辛万苦终于找到几个ChatGPT平替的网站了。 AI中文智能对话 地址&#xff1a;…
阅读更多...
DPDK入门（环境搭建以及小demo）

DPDK入门（环境搭建以及小demo）

文章目录零、从0开始配置dpdk环境的虚拟机一、dpdk的编译usertool/dpdk-setup.sh二、dpdk需要什么配置来支持1.多队列网卡2.巨页三、解析接收网络数据的过程经历了什么1.物理网卡2.NIC3.内核协议栈4.标准接口层Posix API5. 应用层上述过程发生的拷贝四、DPDK介绍基于上述接收网…
阅读更多...
人人看得懂的AI教程

人人看得懂的AI教程

人人看得懂的AI教程&#xff0c;从0开始入门AI教程&#xff0c;一步一步AI&#xff0c;人工智能学习笔记 现在写书真的方便&#xff0c;闲来无事写了本从0开始学AI的书籍&#xff0c;哈哈 一、基础知识 1.1 人工智能概览 1.2 机器学习 1.3 深度学习 1.4 数据科学 二、编程知…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站