JBPM流程复制功能实现

最新推荐文章于 2021-11-04 16:49:23 发布
最新推荐文章于 2021-11-04 16:49:23 发布
阅读量186 收藏
点赞数
分类专栏： JBPM 文章标签： JBPM 流程实例拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pdd7531/article/details/84519287
版权
公司产品一直用JBPM作为流程驱动核心，之前的主要应用场景为数据审批等变动较小的业务范围，今年新开发了产品模块，用JBPM来驱动协同项目，实现多人协同工作的需求，在WBS分解项目时无法做到确保项目运行过程中不会变动，所以出现了项目运行过程中需要能动态改变流程定义并保证之前已经运行过的项目节点数据不会丢失的需求。
在网上搜索了很多，没有发现类似的流程实例拷贝的功能，自己试着实现了一个版本，当然有诸多限制，譬如已完成节点不可编辑，不可删除，否则流程无法正确流至上个流程实例的当前节点。
数据库中增加了流程过程描述表，主要字段为主流程实例ID，项目ID，流程任务ID，项目任务ID，以及任务的outCome。流程运行过程中，完成任务操作时往这张表中增加记录，记录流程运行过程。
实例拷贝主要分为六步，一、根据项目ID获取最新流程定义。二、根据最新流程定义获取上个版本流程定义。三、根据上个版本流程定义获取上个版本的流程实例。四、根据上个版本流程实例抽取出上个版本中已经运行的任务的描述，包括任务关联数据，任务走向等。五、开始最新流程实例，递归寻找当前任务，从上个版本的任务描述中拷贝关联数据以及确定任务走向。六、清理上个版本流程数据。
实现的重点是要考虑分支，子流程等复杂元素，特变是嵌套分支，嵌套子流程等也要能完美运行通过，主要的业务是在抽取历史任务数据以及递归推动最新流程，绑定历史任务数据的地方。代码的编写过程中，也运用了一些JBMP的源码知识，譬如控制执行先后顺序参开了ExecutionImpl的performAtomicOperation的模式，匹配历史任务时采用了责任链模式，将历史任务按照执行顺序组织成责任链模式，匹配成功后跳过已匹配的任务。
附上关键代码： 

public abstract class EDMAtomicOperation implements Serializable {

	//serialVersionUID is

	private static final long serialVersionUID = 1L;

	public static final EDMAtomicOperation GET_LATEST_PDID = new GetLatestPdIdOperation();
	public static final EDMAtomicOperation GET_LAST_VERSION_PDID = new GetLastVersionPdIdOperation();
	public static final EDMAtomicOperation GET_LAST_VERSION_PIID = new GetLastVersionPiIdOperation();
	public static final EDMAtomicOperation GET_LAST_VERSION_TASKDESC = new GetLastVersionTaskDescOperation();
	public static final EDMAtomicOperation COPY_PROCESS = new CopyProcessDataOperation();
	public static final EDMAtomicOperation CLEAN_OLD_PROCESS = new CleanOldProcessOperation();


	public abstract void perform(ProcessCourserImpl processCourse);
}



public interface ProcessCourser {

	public void sign();

	public String getErrorMessage();
}



public class ProcessCourserImpl implements ProcessCourser,Serializable{

	//serialVersionUID is

	private static final long serialVersionUID = -3239018905632135241L;

	public ProcessCourserImpl(String projectId, ProcessCourseTool processCourseTool, String userShowName){
		this.projectId = projectId;
		this.processCourseTool = processCourseTool;
		this.userShowName = userShowName;
	}

	/**
	 *@Function Name:  sign
	 *@Description:   开始工作
	 *@Date Created:  2013-12-24 下午04:46:35
	 *@Author:  Pan Duan Duan
	 *@Last Modified:     ,  Date Modified: 
	 */
	@Override
	public void sign() {
		//如果还未获取最新流程定义
		if("".equals(latestPdId)){
			performAtomicOperation(EDMAtomicOperation.GET_LATEST_PDID);
		}
	}

	/**
	 *@Function Name:  performAtomicOperation
	 *@Description: @param operation 
	 *@Date Created:  2013-12-25 上午08:34:54
	 *@Author:  Pan Duan Duan 执行操作
	 *@Last Modified:     ,  Date Modified: 
	 */
	public synchronized void performAtomicOperation(EDMAtomicOperation operation) {
		performAtomicOperationSync(operation);
	}

	/**
	 *@Function Name:  performAtomicOperationSync
	 *@Description: @param operation 
	 *@Date Created:  2013-12-25 上午08:35:02
	 *@Author:  Pan Duan Duan 以同步的方式执行操作
	 *@Last Modified:     ,  Date Modified: 
	 */
	private void performAtomicOperationSync(EDMAtomicOperation operation) {
		//初始化
		if (atomicOperations==null) {
			atomicOperations = new LinkedList<EDMAtomicOperation>();
			atomicOperations.offer(operation);
			while (! atomicOperations.isEmpty()) {
				EDMAtomicOperation atomicOperation = atomicOperations.poll();
				atomicOperation.perform(this);
			}
		}else {
		      atomicOperations.offer(operation);
	    }
	}


public class CopyProcessDataOperation extends EDMAtomicOperation {

	Logger	log	= Logger.getLogger(this.getClass().getName());
	//serialVersionUID is

	private static final long serialVersionUID = -6126577335188267494L;

	@Override
	public void perform(ProcessCourserImpl processCourse) {
		log.warn("Copy Process Step 5: copy old process info to the new one");
		//最新流程定义
		String latestPdId = processCourse.getLatestPdId();
		//得到当前用户显示名称
		String userShowName = processCourse.getUserShowName();
		String latestPiId = processCourse.getProcessCourseTool().getProcessInstanceTool().startProcessInstance(latestPdId,userShowName);
		//上个版本流程任务描述集合
		List<EDMTaskDesc> lastTaskDescs = processCourse.getTaskDescs();
		if(null != lastTaskDescs && lastTaskDescs.size() > 0){
			processFlow(latestPiId,processCourse);
		}
		processCourse.performAtomicOperation(EDMAtomicOperation.CLEAN_OLD_PROCESS);
	}

	/**
	 *@Function Name:  processFlow
	 *@Description: @param latestProcessInstance
	 *@Description: @param processCourse 
	 *@Date Created:  2013-12-26 上午09:26:54
	 *@Author:  Pan Duan Duan 驱动流程 复制数据
	 *@Last Modified:     ,  Date Modified: 
	 */
	private void processFlow(String latestPiId,
			ProcessCourserImpl processCourse) {

		//当前流程主流程ID
		String mainPiId = latestPiId;
		//
		ProcessInstanceTool processInstanceTool = processCourse.getProcessCourseTool().getProcessInstanceTool();
		//当前任务集合
		List<Task> currentTasks = new ArrayList<Task>();
		while(currentTasks.isEmpty()){
			//获取最新流程的当前任务集合
			getNextTaskByPiId(mainPiId, currentTasks, processInstanceTool);
			//已完成任务集合
			List<Task> completedTask = new ArrayList<Task>();
			for(Task currentTask : currentTasks){
				//完成任务 拷贝任务数据
				boolean completed = complateCurrentTask(currentTask,processInstanceTool,processCourse,mainPiId);
				if(completed){
					completedTask.add(currentTask);
				}
			}
			//移除已经完成的任务 推动流程
			for(Task tempTask : completedTask){
				currentTasks.remove(tempTask);
			}
		}
		//
	}

	/**
	 *@param processCourse 
	 * @Function Name:  complateCurrentTask
	 *@Description: @param currentTask
	 *@Description: @param processInstanceTool 
	 *@Date Created:  2013-12-26 上午11:05:06
	 *@Author:  Pan Duan Duan 完成当前任务
	 *@Last Modified:     ,  Date Modified: 
	 */
	private boolean complateCurrentTask(Task currentTask,
			ProcessInstanceTool processInstanceTool, ProcessCourserImpl processCourse, String mainPiId) {
		//流程引擎
		ProcessEngine processEngine = processInstanceTool.getProcessEngine();
		//得到流程实例Service
		ExecutionService executionService = processEngine.getExecutionService();
		//得到taskService
		TaskService taskService = processEngine.getTaskService();
		//返回结果
		boolean flag = false;
		//
		try{
			//获取任务ID
			String taskId = currentTask.getId();
			//得到executionId
			String executionId = currentTask.getExecutionId();
			//得到流程实例
			Execution execution = executionService.findExecutionById(executionId);
			//得到主线流程
			execution = processInstanceTool.findMainExecution(execution);
			//获取项目任务ID
			String prjTaskId = processInstanceTool.getTaskDataIdByProcessTaskId(taskId);
			//复制任务数据
			EDMTaskDesc copyedTaskDesc = processCourse.getTaskDescs().get(0).doCopy(prjTaskId, processInstanceTool);
			//获取新的变量ID
			if(null != copyedTaskDesc){
				String newVariableId = copyedTaskDesc.getNewVariableId();
				//获取新变量实例
				EdmTaskVariable edmTaskVariable = processInstanceTool.getEdmTaskVariableById(newVariableId);
				//获取任务执行人
				String taskOperator = edmTaskVariable.getOperator();
				//转化为登录名称
				taskOperator = processInstanceTool.getUserLoginNameByShowName(taskOperator);
				//注入流程任务中
				processEngine.execute(new TaskDelegateCmd(taskId, taskOperator));
				//保存任务变量
				executionService.createVariable(execution.getId(), taskId, edmTaskVariable, true);
				//得到任务流向
				String outCome = copyedTaskDesc.getOutCome();
				//完成任务
				taskService.completeTask(taskId,outCome);
				//保存执行过程
				processCourse.getProcessCourseTool().saveTaskCourse(mainPiId, processCourse.getProjectId(), taskId, copyedTaskDesc.getPrjTaskId(), outCome);
				//修改任务状态
				processCourse.getProcessCourseTool().changePrjTaskState(copyedTaskDesc.getPrjTaskId(), ProjectState.STATE_COMPLETED);
				flag = true;
			}
		}catch (Exception e) {
			e.printStackTrace();
		}
		return flag;
	}

	/**
	 *@Function Name:  getNextTaskByPiId
	 *@Description: @param hisPiId
	 *@Description: @param processEngine
	 *@Description: @return 得到下一个任务
	 *@Date Created:  2013-7-24 下午02:48:15
	 *@Author:  Pan Duan Duan
	 *@Last Modified:     ,  Date Modified: 
	 */
	public void getNextTaskByPiId(String mainPiId,  List<Task> tasks, ProcessInstanceTool processInstanceTool) {

		ProcessEngine processEngine = processInstanceTool.getProcessEngine();
		//任务Serveice
		TaskService taskService = processEngine.getTaskService();
		//流程实例Service
		ExecutionService executionService = processEngine.getExecutionService();
		//HistoryService
		HistoryService historyService = processEngine.getHistoryService();
		RepositoryService repositoryService = processEngine.getRepositoryService();
		//得到流程实例
		Execution excution = executionService.findExecutionById(mainPiId);
		//寻找主流程当前任务
		List<Task> taskList = taskService.createTaskQuery().processInstanceId(mainPiId).list();
		if(null != taskList && taskList.size() > 0)
		{
			tasks.addAll(taskList);
		}
		//尋找 分支 当前任务
		Collection<? extends Execution> executions = excution.getExecutions();
		if(executions.size() > 0)
		{
			for(Execution branchExecution : executions){
				getNextTaskByPiId(branchExecution.getId(), tasks, processInstanceTool);
			}
		}
		//寻找子流程
		String subExecutionId = null;
		ExecutionImpl executionImpl = (ExecutionImpl) excution;
		//得到activityName
		String activityName = executionImpl.getActivityName();
		if(null != activityName){
			//获取主线流程
			String mainBranchExecutionId = processInstanceTool.getProcessInstanceService().getMainPiIdByBranchPiId(excution.getId());
			//根据当前流程 得到所有父子流程集合
			List<Map<String,Object>> processInfos = processInstanceTool.getProcessInstanceIds(mainBranchExecutionId);
			for(Map<String,Object> processInfo : processInfos){
				String piId = CommonTools.Obj2String(processInfo.get("PIID"));
				//得到流程实例
				HistoryProcessInstance hisPi = historyService.createHistoryProcessInstanceQuery().processInstanceId(piId).uniqueResult();
				if(null != hisPi){
					//得到流程定义
					ProcessDefinition pd = repositoryService.createProcessDefinitionQuery().processDefinitionId(hisPi.getProcessDefinitionId()).uniqueResult();
					//得到流程定义名称
					String pdName = pd.getName();
					//得到流程定义
					if(activityName.equals(pdName)){
						subExecutionId = piId;
						break;
					}
				}
			}
			if(null != subExecutionId){
				getNextTaskByPiId(subExecutionId, tasks, processInstanceTool);
			}
		}
	}

}


public class GetLastVersionTaskDescOperation extends EDMAtomicOperation{

	Logger	log	= Logger.getLogger(this.getClass().getName());
	//serialVersionUID is

	private static final long serialVersionUID = 1665471796593388193L;

	@Override
	public void perform(ProcessCourserImpl processCourse) {
		log.warn("Copy Process Step 4: get the last version flow task description");
		//获取上个版本的 流程实例ID
		String lastVersionPiId = processCourse.getLastVersionPiId();
		if(!"".equals(lastVersionPiId)){
			List<EDMTaskDesc> taskDescs = getLastVersionTaskDesc(lastVersionPiId,processCourse);
			//组织责任链
			organizeTaskChain(taskDescs);
			processCourse.setTaskDescs(taskDescs);
		}
		processCourse.performAtomicOperation(EDMAtomicOperation.COPY_PROCESS);
	}

	/**
	 *@Function Name:  organizeTaskChain
	 *@Description: @param taskDesc 
	 *@Date Created:  2013-12-26 上午10:23:30
	 *@Author:  Pan Duan Duan 组织责任链
	 *@Last Modified:     ,  Date Modified: 
	 */
	private void organizeTaskChain(List<EDMTaskDesc> taskDescs) {
		int taskDescSize = taskDescs.size();
		if(taskDescSize > 0){
			//临时变量
			EDMTaskDesc tempTaskDesc = taskDescs.get(taskDescSize - 1);
			//遍历循环
			for(int index = taskDescSize - 2; index >= 0; index--){
				EDMTaskDesc taskDesc = taskDescs.get(index);
				taskDesc.setNextEDMTaskDesc(tempTaskDesc);
				tempTaskDesc = taskDesc;
			}

		}

	}

	/**
	 *@Function Name:  getLastVersionTaskDesc
	 *@Description: @param lastVersionPiId
	 *@Description: @param processCourse
	 *@Description: @return  获取上个版本的任务描述
	 *@Date Created:  2013-12-25 上午11:27:22
	 *@Author:  Pan Duan Duan
	 *@Last Modified:     ,  Date Modified: 
	 */
	private List<EDMTaskDesc> getLastVersionTaskDesc(
			String lastVersionPiId, ProcessCourserImpl processCourse) {

		List<EDMTaskDesc> retVal = new ArrayList<EDMTaskDesc>();
		ProcessInstanceTool processInstanceTool = processCourse.getProcessCourseTool().getProcessInstanceTool();
		ProcessEngine processEngine = processInstanceTool.getProcessEngine();
		//获取流程历史服务
		HistoryService historyService = processEngine.getHistoryService();
		//获取父子流程集合
		List<Map<String, Object>> processIdDescs = processCourse.getProcessCourseTool().getProcessInstanceTool().getProcessInstanceService().getProcessInstanceIds(lastVersionPiId);
		//遍历获取已完成任务集合
		Set<String> processInstanceIds = new HashSet<String>();
		//加入主流程
		processInstanceIds.add(lastVersionPiId);
		for(Map<String, Object> processDescMap : processIdDescs){
			//得到流程ID
			String piId = CommonTools.Obj2String(processDescMap.get("PIID"));
			processInstanceIds.add(piId);
		}
		for(String piId : processInstanceIds){
			//得到历史流程
			HistoryProcessInstance historyProcessInstance = historyService.createHistoryProcessInstanceQuery().processInstanceId(piId).uniqueResult();
			//得到历史流程定义
			String hisPdId = historyProcessInstance.getProcessDefinitionId();
			//获取任务表单描述
			XmlFormReader formReader = processEngine.execute(new GetFormReaderCommand(hisPdId));
			List<HistoryActivityInstance> historyActivityInstances = historyService.createHistoryActivityInstanceQuery().processInstanceId(piId).list();;
			//遍历任务集合
			for(HistoryActivityInstance hisAci : historyActivityInstances){
				//过滤掉正在进行的 以及非正常任务节点
				if(hisAci.getEndTime() == null || ((HistoryActivityInstanceImpl)hisAci).getType().equals("sub-process")){
					continue;
				}
				//强转为实现类
				HistoryActivityInstanceImpl hisAcImpl = (HistoryActivityInstanceImpl) hisAci;
				XmlForm xmlForm = formReader.getFormByName(hisAcImpl.getActivityName());
				//获取历史任务ID
				String taskId = processInstanceTool.getTaskIdByHaiImplId(String.valueOf(hisAcImpl.getDbid()));
				//获取历史变量值
				String hisVariId = CommonTools.Obj2String(historyService.getVariable(piId, taskId));
				//存储
				EDMTaskDesc edmTaskDesc = new EDMTaskDesc();
				edmTaskDesc.setHisTaskId(taskId);
				edmTaskDesc.setVariableId(hisVariId);
				edmTaskDesc.setPrjTaskId(xmlForm == null ? "" : xmlForm.getId());
				retVal.add(edmTaskDesc);
			}
		}
		//增加outCome并排序
		retVal = appendOutCome(retVal,processCourse);
		return retVal;
	}

	/**
	 *@Function Name:  appendOutCome
	 *@Description: @param retVal
	 *@Description: @return 增加任务流向 以及 排序
	 *@Date Created:  2013-12-26 上午08:23:06
	 *@Author:  Pan Duan Duan
	 *@Last Modified:     ,  Date Modified: 
	 */
	/**
	 *@param processCourse 
	 * @Function Name:  appendOutCome
	 *@Description: @param source
	 *@Description: @return 
	 *@Date Created:  2013-12-26 上午08:27:16
	 *@Author:  Pan Duan Duan
	 *@Last Modified:     ,  Date Modified: 
	 */
	private List<EDMTaskDesc> appendOutCome(List<EDMTaskDesc> source, ProcessCourserImpl processCourse) {
		//返回结果
		List<EDMTaskDesc> desc = new ArrayList<EDMTaskDesc>();
		//获取流程执行过程
		StringBuffer querySql = new StringBuffer();
		querySql.append("SELECT ID,MAIN_PIID,PROJECT_ID,FLOW_TASK_ID,PRJ_TASK_ID,OUTCOME FROM ");
		querySql.append("JBPM4_EDM_COURSE WHERE MAIN_PIID = ? AND PROJECT_ID = ? ORDER BY ID");
		//获取查询结果
		List<Map<String,Object>> queryList = processCourse.getProcessCourseTool().getProcessInstanceTool().getMetaDaoFactory().getJdbcTemplate().
													queryForList(querySql.toString(),new Object[]{processCourse.getLastVersionPiId(),processCourse.getProjectId()});
		//遍历组织
		for(Map<String,Object> dataMap : queryList){
			//流程任务ID
			String flowTaskId = CommonTools.Obj2String(dataMap.get("FLOW_TASK_ID"));
			//任务流向
			String outCome = CommonTools.Obj2String(dataMap.get("OUTCOME"));
			//从sources中寻找
			for(EDMTaskDesc tempTaskDesc : source){
				if(flowTaskId.equals(tempTaskDesc.getHisTaskId())){
					tempTaskDesc.setOutCome(outCome);
					desc.add(tempTaskDesc);
					break;
				}
			}
		}
		return desc;
	}
pdd7531
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Activiti(Flowable) 流程实例克隆解决方案1
08-08
Activiti(Flowable) 流程实例克隆解决方案1
工作流引擎JBPM使用
03-27 834
首先获取单例的processEngine对象 默读取"src目录下的jbpm.cfg.xml"的配置文件  private ProcessEngine processEngine = Configuration.getProcessEngine(); ProcessEngine对象中有一系列的service，这些service是做操作的 一、流程管理 都用的是repositoryServi
activiti工作流流程复制功能的实现
青春没有彩排丶的博客
11-04 1411
记录工作，记录生活。 当前公司业务开发过程中有对activiti工作流流程复制的需求，便查找了一些资料和代码，站在巨人的肩膀上总结一下业务功能的实现逻辑和经验。 开发环境：Spring boot + activiti5.22 /** * 流程复制业务实现 * * @param modelId */ public void flowCopy(String modelId) { if (StringUtils.isBlank(mod
JBPM简析-part1
double123456789的博客
11-10 107
看JBPM4.2的源代码和单元测试用例差不多有些日子了，有了一些自己的心得和体会，一一记录下来和大家分享。错误和不足之处，欢迎大家指出。我的邮箱地址是cndoublehero#gmail.com。     JBPM4.2（以下都简称JBPM了）相关知识介绍：     Hibernate：JBPM使用了hibernate作为其持久层的底层框架。好处就是JBPM可以在多种不同的数据库下运行，坏处就...
MyEclipse6.0下Jbpm流程设计器
03-29
【MyEclipse6.0下Jbpm流程设计器】是一个专为MyEclipse6.0集成的业务流程管理（Business Process Management，BPM）工具，主要用于设计和管理Jbpm流程。Jbpm是一个开源的工作流和业务流程管理平台，它提供了一套完整...
JBPM4.3使用说明.doc
最新发布
09-22
JBPM4.3 使用说明 JBPM4.3 是一个基于工作流程管理的系统，旨在帮助用户更好地管理和自动化...JBPM4.3 是一个功能强大且灵活的工作流程管理系统，提供了许多实用的功能和命令来帮助用户更好地管理和自动化业务流程。
JBPM5 插件安装
07-31
在JBPM5中，插件的安装是扩展系统功能的重要手段，能够帮助用户实现特定的需求，如监控、报表、集成等。本文将详细讲解JBPM5插件的安装过程。 首先，我们需要理解JBPM5的核心组件。JBPM5主要包括工作流引擎、工作流...
jbpm4入门例子
11-30
此外，jbPM4还提供了强大的监控和报表功能，帮助管理员和开发者跟踪流程的执行情况，找出潜在的问题，优化流程效率。你可以查看流程实例的统计信息、任务状态、事件日志等，从而更好地理解和控制业务流程。 总结来...
activiti工作流总结（结合项目流程）
lty13142的博客
08-12 1932
1、新建activiti工具类(ActivitiUtil类和JDJumpTaskCmd类) public class ActivitiUtil { //Activiti中最核心的类，其他的类都是由他而来 private static ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine(); //执行管理，包括启动、推进、删除流程实例等操作 private static RuntimeS
activiti 流程模型复制源码
爱技术、爱生活
09-13 3026
activiti 流程模型复制源码 今天使用框架开发流程时，感觉从头画一个activiti 流程图太麻烦了，随即想到加个流程模型复制功能可以节省大量的开发时间。lets go 。 代码如下： //activiti 流程模型复制 @Transactional(readOnly = false) public Model copy(String id) throws Exce...
Activiti(Flowable)流程克隆（运行时实例克隆）解决方案 一种订单制造中分裂拆单与合并的核心技术实践
知行合一
11-24 4623
Activiti(Flowable)流程克隆（运行时实例克隆）解决方案一种订单制造中分裂与合并的核心技术实践作者：长沙大东家 xiaohelong2005@126.com2017-11-24 20:24 长沙1.  背景订单可视化系统是单位的一套基于业务流程引擎技术的智能制造信息系统，在公司领导的战略部署下，完全自主开发的一套适用于多品种、小批量订单式制造型企业。系统以对订单的全生命周期进行管控。...
jBPM3 vs jBPM4 （转）
a651944226的专栏
08-16 2049
                                                   jBPM3 vs jBPM4 JBoss Goup 目前已经发布了 jBPM4 Alpha1 版本，在版本 4 中最大的变化就是引入 PVM （流程虚拟机）的概念，而引擎内部的调度算法中重要的 Token 机制，在新版中也去掉了，纵观整个代码，变化可以说非常的大，笔者接下来就试着来比较
07-jbpm工作流之根据流程变量分配任务Task
全力付出
07-10 1556
* 任务活动分配  *  1.使用流程变量： assignee="#{manager}" 在Expression设置#{manager}  *  2.使用类处理AssignmentHandler :assignable.setAssignee(userId);  *  3.TaskService.assignTask(taskId,userId); Java Code ： pac
JBPM学习(六)：详解流程图
程序员囧辉
05-03 1万+
最近发现这篇文章挺多人看的，也挺多人有疑问，我很想帮你们解答，但是很无奈，这篇文章只是我当时在自学时看的一个教程的记录，当时对JBPM也没有深入去学习，并且到现在也已经快4年了，这期间我都没用过JBPM，因此JBPM的东西我也忘得差不多了。庆幸的是我把当时看的教程保存了下来，因此如果对此文章有疑问的可以直接看我下面链接的教程。另外，通过我分享的视频大家也能看到这是一个OA教程，我当时刚入门自学Ja...
activiti 如何获取下一步节点
热门推荐
一万年太久 - 只争朝夕
05-04 2万+
ACTIVITI相对于JBPM来说，比较年轻，用的人少，中文方面的资料更少，我根据网上到处找得资料以及看官方文档总结出来了代码，非常不容易啊。废话不多说，直接上代码吧： 首先是根据流程ID获取当前任务： Java代码 List tasks = taskService.createTaskQuery().processInstanceId(proc
揭秘jbpm流程引擎内核设计思想及构架.docx
10-13
作者指出，流程引擎内核是支持流程基本运行的最小结构，但完整的流程引擎还包括诸如状态存储、事件处理、组织适配、时间调度和消息服务等功能。了解引擎内核是理解整个引擎的关键，否则它可能只被视为复杂的结构和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值