`
fackyou200
  • 浏览: 308486 次
  • 性别: Icon_minigender_1
  • 来自: 山西太原
社区版块
存档分类
最新评论

Activiti之流程通过、驳回、会签、转办、中止、挂起等核心操作封装(Activiti5.9)

 
阅读更多

转:http://blog.csdn.net/rosten/article/details/38300267

 

    package com.famousPro.process.service.impl;  
      
    import java.util.ArrayList;  
    import java.util.HashMap;  
    import java.util.List;  
    import java.util.Map;  
      
    import org.activiti.engine.FormService;  
    import org.activiti.engine.HistoryService;  
    import org.activiti.engine.RepositoryService;  
    import org.activiti.engine.RuntimeService;  
    import org.activiti.engine.TaskService;  
    import org.activiti.engine.history.HistoricActivityInstance;  
    import org.activiti.engine.impl.RepositoryServiceImpl;  
    import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;  
    import org.activiti.engine.impl.persistence.entity.TaskEntity;  
    import org.activiti.engine.impl.pvm.PvmTransition;  
    import org.activiti.engine.impl.pvm.process.ActivityImpl;  
    import org.activiti.engine.impl.pvm.process.ProcessDefinitionImpl;  
    import org.activiti.engine.impl.pvm.process.TransitionImpl;  
    import org.activiti.engine.runtime.ProcessInstance;  
    import org.activiti.engine.task.Task;  
      
    import com.famousPro.common.service.impl.BaseServiceImp;  
    import com.famousPro.common.util.IDGenerator;  
    import com.famousPro.common.util.StringUtil;  
    import com.famousPro.process.service.ProcessCoreService;  
    import com.famousPro.process.service.ProcessOtherService;  
      
    /** 
     * 流程操作核心类<br> 
     * 此核心类主要处理:流程通过、驳回、会签、转办、中止、挂起等核心操作<br> 
     *  
     * @author wangfuwei 
     *  
     */  
    public class ProcessCoreServiceImpl extends BaseServiceImp implements  
            ProcessCoreService {  
        protected RepositoryService repositoryService;  
      
        protected RuntimeService runtimeService;  
      
        protected TaskService taskService;  
      
        protected FormService formService;  
      
        protected HistoryService historyService;  
      
        protected ProcessOtherService processOtherService;  
      
        /** 
         * 根据当前任务ID,查询可以驳回的任务节点 
         *  
         * @param taskId 
         *            当前任务ID 
         */  
        public List<ActivityImpl> findBackAvtivity(String taskId) throws Exception {  
            List<ActivityImpl> rtnList = null;  
            if (processOtherService.isJointTask(taskId)) {// 会签任务节点,不允许驳回  
                rtnList = new ArrayList<ActivityImpl>();  
            } else {  
                rtnList = iteratorBackActivity(taskId, findActivitiImpl(taskId,  
                        null), new ArrayList<ActivityImpl>(),  
                        new ArrayList<ActivityImpl>());  
            }  
            return reverList(rtnList);  
        }  
      
        /** 
         * 审批通过(驳回直接跳回功能需后续扩展) 
         *  
         * @param taskId 
         *            当前任务ID 
         * @param variables 
         *            流程存储参数 
         * @throws Exception 
         */  
        public void passProcess(String taskId, Map<String, Object> variables)  
                throws Exception {  
            List<Task> tasks = taskService.createTaskQuery().parentTaskId(taskId)  
                    .taskDescription("jointProcess").list();  
            for (Task task : tasks) {// 级联结束本节点发起的会签任务  
                commitProcess(task.getId(), null, null);  
            }  
            commitProcess(taskId, variables, null);  
        }  
      
        /** 
         * 驳回流程 
         *  
         * @param taskId 
         *            当前任务ID 
         * @param activityId 
         *            驳回节点ID 
         * @param variables 
         *            流程存储参数 
         * @throws Exception 
         */  
        public void backProcess(String taskId, String activityId,  
                Map<String, Object> variables) throws Exception {  
            if (StringUtil.isNull(activityId)) {  
                throw new Exception("驳回目标节点ID为空!");  
            }  
      
            // 查询本节点发起的会签任务,并结束  
            List<Task> tasks = taskService.createTaskQuery().parentTaskId(taskId)  
                    .taskDescription("jointProcess").list();  
            for (Task task : tasks) {  
                commitProcess(task.getId(), null, null);  
            }  
      
            // 查找所有并行任务节点,同时驳回  
            List<Task> taskList = findTaskListByKey(findProcessInstanceByTaskId(  
                    taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());  
            for (Task task : taskList) {  
                commitProcess(task.getId(), variables, activityId);  
            }  
        }  
      
        /** 
         * 取回流程 
         *  
         * @param taskId 
         *            当前任务ID 
         * @param activityId 
         *            取回节点ID 
         * @throws Exception 
         */  
        public void callBackProcess(String taskId, String activityId)  
                throws Exception {  
            if (StringUtil.isNull(activityId)) {  
                throw new Exception("目标节点ID为空!");  
            }  
      
            // 查找所有并行任务节点,同时取回  
            List<Task> taskList = findTaskListByKey(findProcessInstanceByTaskId(  
                    taskId).getId(), findTaskById(taskId).getTaskDefinitionKey());  
            for (Task task : taskList) {  
                commitProcess(task.getId(), null, activityId);  
            }  
        }  
      
        /** 
         * 中止流程(特权人直接审批通过等) 
         *  
         * @param taskId 
         */  
        public void endProcess(String taskId) throws Exception {  
            ActivityImpl endActivity = findActivitiImpl(taskId, "end");  
            commitProcess(taskId, null, endActivity.getId());  
        }  
      
        /** 
         * 会签操作 
         *  
         * @param taskId 
         *            当前任务ID 
         * @param userCodes 
         *            会签人账号集合 
         * @throws Exception 
         */  
        public void jointProcess(String taskId, List<String> userCodes)  
                throws Exception {  
            for (String userCode : userCodes) {  
                TaskEntity task = (TaskEntity) taskService.newTask(IDGenerator  
                        .generateID());  
                task.setAssignee(userCode);  
                task.setName(findTaskById(taskId).getName() + "-会签");  
                task.setProcessDefinitionId(findProcessDefinitionEntityByTaskId(  
                        taskId).getId());  
                task.setProcessInstanceId(findProcessInstanceByTaskId(taskId)  
                        .getId());  
                task.setParentTaskId(taskId);  
                task.setDescription("jointProcess");  
                taskService.saveTask(task);  
            }  
        }  
      
        /** 
         * 转办流程 
         *  
         * @param taskId 
         *            当前任务节点ID 
         * @param userCode 
         *            被转办人Code 
         */  
        public void transferAssignee(String taskId, String userCode) {  
            taskService.setAssignee(taskId, userCode);  
        }  
      
        /** 
         * ***************************************************************************************************************************************************<br> 
         * ************************************************以下为流程会签操作核心逻辑******************************************************************************<br> 
         * ***************************************************************************************************************************************************<br> 
         */  
      
        /** 
         * ***************************************************************************************************************************************************<br> 
         * ************************************************以上为流程会签操作核心逻辑******************************************************************************<br> 
         * ***************************************************************************************************************************************************<br> 
         */  
      
        /** 
         * ***************************************************************************************************************************************************<br> 
         * ************************************************以下为流程转向操作核心逻辑******************************************************************************<br> 
         * ***************************************************************************************************************************************************<br> 
         */  
      
        /** 
         * @param taskId 
         *            当前任务ID 
         * @param variables 
         *            流程变量 
         * @param activityId 
         *            流程转向执行任务节点ID<br> 
         *            此参数为空,默认为提交操作 
         * @throws Exception 
         */  
        private void commitProcess(String taskId, Map<String, Object> variables,  
                String activityId) throws Exception {  
            if (variables == null) {  
                variables = new HashMap<String, Object>();  
            }  
            // 跳转节点为空,默认提交操作  
            if (StringUtil.isNull(activityId)) {  
                taskService.complete(taskId, variables);  
            } else {// 流程转向操作  
                turnTransition(taskId, activityId, variables);  
            }  
        }  
      
        /** 
         * 清空指定活动节点流向 
         *  
         * @param activityImpl 
         *            活动节点 
         * @return 节点流向集合 
         */  
        private List<PvmTransition> clearTransition(ActivityImpl activityImpl) {  
            // 存储当前节点所有流向临时变量  
            List<PvmTransition> oriPvmTransitionList = new ArrayList<PvmTransition>();  
            // 获取当前节点所有流向,存储到临时变量,然后清空  
            List<PvmTransition> pvmTransitionList = activityImpl  
                    .getOutgoingTransitions();  
            for (PvmTransition pvmTransition : pvmTransitionList) {  
                oriPvmTransitionList.add(pvmTransition);  
            }  
            pvmTransitionList.clear();  
      
            return oriPvmTransitionList;  
        }  
      
        /** 
         * 还原指定活动节点流向 
         *  
         * @param activityImpl 
         *            活动节点 
         * @param oriPvmTransitionList 
         *            原有节点流向集合 
         */  
        private void restoreTransition(ActivityImpl activityImpl,  
                List<PvmTransition> oriPvmTransitionList) {  
            // 清空现有流向  
            List<PvmTransition> pvmTransitionList = activityImpl  
                    .getOutgoingTransitions();  
            pvmTransitionList.clear();  
            // 还原以前流向  
            for (PvmTransition pvmTransition : oriPvmTransitionList) {  
                pvmTransitionList.add(pvmTransition);  
            }  
        }  
      
        /** 
         * 流程转向操作 
         *  
         * @param taskId 
         *            当前任务ID 
         * @param activityId 
         *            目标节点任务ID 
         * @param variables 
         *            流程变量 
         * @throws Exception 
         */  
        private void turnTransition(String taskId, String activityId,  
                Map<String, Object> variables) throws Exception {  
            // 当前节点  
            ActivityImpl currActivity = findActivitiImpl(taskId, null);  
            // 清空当前流向  
            List<PvmTransition> oriPvmTransitionList = clearTransition(currActivity);  
      
            // 创建新流向  
            TransitionImpl newTransition = currActivity.createOutgoingTransition();  
            // 目标节点  
            ActivityImpl pointActivity = findActivitiImpl(taskId, activityId);  
            // 设置新流向的目标节点  
            newTransition.setDestination(pointActivity);  
      
            // 执行转向任务  
            taskService.complete(taskId, variables);  
            // 删除目标节点新流入  
            pointActivity.getIncomingTransitions().remove(newTransition);  
      
            // 还原以前流向  
            restoreTransition(currActivity, oriPvmTransitionList);  
        }  
      
        /** 
         * ***************************************************************************************************************************************************<br> 
         * ************************************************以上为流程转向操作核心逻辑******************************************************************************<br> 
         * ***************************************************************************************************************************************************<br> 
         */  
      
        /** 
         * ***************************************************************************************************************************************************<br> 
         * ************************************************以下为查询流程驳回节点核心逻辑***************************************************************************<br> 
         * ***************************************************************************************************************************************************<br> 
         */  
      
        /** 
         * 迭代循环流程树结构,查询当前节点可驳回的任务节点 
         *  
         * @param taskId 
         *            当前任务ID 
         * @param currActivity 
         *            当前活动节点 
         * @param rtnList 
         *            存储回退节点集合 
         * @param tempList 
         *            临时存储节点集合(存储一次迭代过程中的同级userTask节点) 
         * @return 回退节点集合 
         */  
        private List<ActivityImpl> iteratorBackActivity(String taskId,  
                ActivityImpl currActivity, List<ActivityImpl> rtnList,  
                List<ActivityImpl> tempList) throws Exception {  
            // 查询流程定义,生成流程树结构  
            ProcessInstance processInstance = findProcessInstanceByTaskId(taskId);  
      
            // 当前节点的流入来源  
            List<PvmTransition> incomingTransitions = currActivity  
                    .getIncomingTransitions();  
            // 条件分支节点集合,userTask节点遍历完毕,迭代遍历此集合,查询条件分支对应的userTask节点  
            List<ActivityImpl> exclusiveGateways = new ArrayList<ActivityImpl>();  
            // 并行节点集合,userTask节点遍历完毕,迭代遍历此集合,查询并行节点对应的userTask节点  
            List<ActivityImpl> parallelGateways = new ArrayList<ActivityImpl>();  
            // 遍历当前节点所有流入路径  
            for (PvmTransition pvmTransition : incomingTransitions) {  
                TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
                ActivityImpl activityImpl = transitionImpl.getSource();  
                String type = (String) activityImpl.getProperty("type");  
                /** 
                 * 并行节点配置要求:<br> 
                 * 必须成对出现,且要求分别配置节点ID为:XXX_start(开始),XXX_end(结束) 
                 */  
                if ("parallelGateway".equals(type)) {// 并行路线  
                    String gatewayId = activityImpl.getId();  
                    String gatewayType = gatewayId.substring(gatewayId  
                            .lastIndexOf("_") + 1);  
                    if ("START".equals(gatewayType.toUpperCase())) {// 并行起点,停止递归  
                        return rtnList;  
                    } else {// 并行终点,临时存储此节点,本次循环结束,迭代集合,查询对应的userTask节点  
                        parallelGateways.add(activityImpl);  
                    }  
                } else if ("startEvent".equals(type)) {// 开始节点,停止递归  
                    return rtnList;  
                } else if ("userTask".equals(type)) {// 用户任务  
                    tempList.add(activityImpl);  
                } else if ("exclusiveGateway".equals(type)) {// 分支路线,临时存储此节点,本次循环结束,迭代集合,查询对应的userTask节点  
                    currActivity = transitionImpl.getSource();  
                    exclusiveGateways.add(currActivity);  
                }  
            }  
      
            /** 
             * 迭代条件分支集合,查询对应的userTask节点 
             */  
            for (ActivityImpl activityImpl : exclusiveGateways) {  
                iteratorBackActivity(taskId, activityImpl, rtnList, tempList);  
            }  
      
            /** 
             * 迭代并行集合,查询对应的userTask节点 
             */  
            for (ActivityImpl activityImpl : parallelGateways) {  
                iteratorBackActivity(taskId, activityImpl, rtnList, tempList);  
            }  
      
            /** 
             * 根据同级userTask集合,过滤最近发生的节点 
             */  
            currActivity = filterNewestActivity(processInstance, tempList);  
            if (currActivity != null) {  
                // 查询当前节点的流向是否为并行终点,并获取并行起点ID  
                String id = findParallelGatewayId(currActivity);  
                if (StringUtil.isNull(id)) {// 并行起点ID为空,此节点流向不是并行终点,符合驳回条件,存储此节点  
                    rtnList.add(currActivity);  
                } else {// 根据并行起点ID查询当前节点,然后迭代查询其对应的userTask任务节点  
                    currActivity = findActivitiImpl(taskId, id);  
                }  
      
                // 清空本次迭代临时集合  
                tempList.clear();  
                // 执行下次迭代  
                iteratorBackActivity(taskId, currActivity, rtnList, tempList);  
            }  
            return rtnList;  
        }  
      
        /** 
         * 反向排序list集合,便于驳回节点按顺序显示 
         *  
         * @param list 
         * @return 
         */  
        private List<ActivityImpl> reverList(List<ActivityImpl> list) {  
            List<ActivityImpl> rtnList = new ArrayList<ActivityImpl>();  
            // 由于迭代出现重复数据,排除重复  
            for (int i = list.size(); i > 0; i--) {  
                if (!rtnList.contains(list.get(i - 1)))  
                    rtnList.add(list.get(i - 1));  
            }  
            return rtnList;  
        }  
      
        /** 
         * 根据当前节点,查询输出流向是否为并行终点,如果为并行终点,则拼装对应的并行起点ID 
         *  
         * @param activityImpl 
         *            当前节点 
         * @return 
         */  
        private String findParallelGatewayId(ActivityImpl activityImpl) {  
            List<PvmTransition> incomingTransitions = activityImpl  
                    .getOutgoingTransitions();  
            for (PvmTransition pvmTransition : incomingTransitions) {  
                TransitionImpl transitionImpl = (TransitionImpl) pvmTransition;  
                activityImpl = transitionImpl.getDestination();  
                String type = (String) activityImpl.getProperty("type");  
                if ("parallelGateway".equals(type)) {// 并行路线  
                    String gatewayId = activityImpl.getId();  
                    String gatewayType = gatewayId.substring(gatewayId  
                            .lastIndexOf("_") + 1);  
                    if ("END".equals(gatewayType.toUpperCase())) {  
                        return gatewayId.substring(0, gatewayId.lastIndexOf("_"))  
                                + "_start";  
                    }  
                }  
            }  
            return null;  
        }  
      
        /** 
         * 根据流入任务集合,查询最近一次的流入任务节点 
         *  
         * @param processInstance 
         *            流程实例 
         * @param tempList 
         *            流入任务集合 
         * @return 
         */  
        private ActivityImpl filterNewestActivity(ProcessInstance processInstance,  
                List<ActivityImpl> tempList) {  
            while (tempList.size() > 0) {  
                ActivityImpl activity_1 = tempList.get(0);  
                HistoricActivityInstance activityInstance_1 = findHistoricUserTask(  
                        processInstance, activity_1.getId());  
                if (activityInstance_1 == null) {  
                    tempList.remove(activity_1);  
                    continue;  
                }  
      
                if (tempList.size() > 1) {  
                    ActivityImpl activity_2 = tempList.get(1);  
                    HistoricActivityInstance activityInstance_2 = findHistoricUserTask(  
                            processInstance, activity_2.getId());  
                    if (activityInstance_2 == null) {  
                        tempList.remove(activity_2);  
                        continue;  
                    }  
      
                    if (activityInstance_1.getEndTime().before(  
                            activityInstance_2.getEndTime())) {  
                        tempList.remove(activity_1);  
                    } else {  
                        tempList.remove(activity_2);  
                    }  
                } else {  
                    break;  
                }  
            }  
            if (tempList.size() > 0) {  
                return tempList.get(0);  
            }  
            return null;  
        }  
      
        /** 
         * 查询指定任务节点的最新记录 
         *  
         * @param processInstance 
         *            流程实例 
         * @param activityId 
         * @return 
         */  
        private HistoricActivityInstance findHistoricUserTask(  
                ProcessInstance processInstance, String activityId) {  
            HistoricActivityInstance rtnVal = null;  
            // 查询当前流程实例审批结束的历史节点  
            List<HistoricActivityInstance> historicActivityInstances = historyService  
                    .createHistoricActivityInstanceQuery().activityType("userTask")  
                    .processInstanceId(processInstance.getId()).activityId(  
                            activityId).finished()  
                    .orderByHistoricActivityInstanceEndTime().desc().list();  
            if (historicActivityInstances.size() > 0) {  
                rtnVal = historicActivityInstances.get(0);  
            }  
      
            return rtnVal;  
        }  
      
        /** 
         * *******************************************************************************************************<br> 
         * ********************************以上为查询流程驳回节点核心逻辑***********************************************<br> 
         * ********************************************************************************************************<br> 
         */  
      
        /** 
         * ********************************************************************************<br> 
         * **********************以下为activiti 核心service 
         * set方法***************************<br> 
         * *********************************************************************************<br> 
         */  
        public void setFormService(FormService formService) {  
            this.formService = formService;  
        }  
      
        public void setHistoryService(HistoryService historyService) {  
            this.historyService = historyService;  
        }  
      
        public void setRepositoryService(RepositoryService repositoryService) {  
            this.repositoryService = repositoryService;  
        }  
      
        public void setRuntimeService(RuntimeService runtimeService) {  
            this.runtimeService = runtimeService;  
        }  
      
        public void setTaskService(TaskService taskService) {  
            this.taskService = taskService;  
        }  
      
        /** 
         * ********************************************************************************<br> 
         * **********************以上为activiti 核心service 
         * set方法***************************<br> 
         * *********************************************************************************<br> 
         */  
      
        /** 
         * ********************************************************************************<br> 
         * **********************以下为根据 任务节点ID 获取流程各对象查询方法**********************<br> 
         * *********************************************************************************<br> 
         */  
      
        public void setProcessOtherService(ProcessOtherService processOtherService) {  
            this.processOtherService = processOtherService;  
        }  
      
        /** 
         * 根据任务ID获得任务实例 
         *  
         * @param taskId 
         *            任务ID 
         * @return 
         * @throws Exception 
         */  
        private TaskEntity findTaskById(String taskId) throws Exception {  
            TaskEntity task = (TaskEntity) taskService.createTaskQuery().taskId(  
                    taskId).singleResult();  
            if (task == null) {  
                throw new Exception("任务实例未找到!");  
            }  
            return task;  
        }  
      
        /** 
         * 根据流程实例ID和任务key值查询所有同级任务集合 
         *  
         * @param processInstanceId 
         * @param key 
         * @return 
         */  
        private List<Task> findTaskListByKey(String processInstanceId, String key) {  
            return taskService.createTaskQuery().processInstanceId(  
                    processInstanceId).taskDefinitionKey(key).list();  
        }  
      
        /** 
         * 根据任务ID获取对应的流程实例 
         *  
         * @param taskId 
         *            任务ID 
         * @return 
         * @throws Exception 
         */  
        private ProcessInstance findProcessInstanceByTaskId(String taskId)  
                throws Exception {  
            // 找到流程实例  
            ProcessInstance processInstance = runtimeService  
                    .createProcessInstanceQuery().processInstanceId(  
                            findTaskById(taskId).getProcessInstanceId())  
                    .singleResult();  
            if (processInstance == null) {  
                throw new Exception("流程实例未找到!");  
            }  
            return processInstance;  
        }  
      
        /** 
         * 根据任务ID获取流程定义 
         *  
         * @param taskId 
         *            任务ID 
         * @return 
         * @throws Exception 
         */  
        private ProcessDefinitionEntity findProcessDefinitionEntityByTaskId(  
                String taskId) throws Exception {  
            // 取得流程定义  
            ProcessDefinitionEntity processDefinition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)  
                    .getDeployedProcessDefinition(findTaskById(taskId)  
                            .getProcessDefinitionId());  
      
            if (processDefinition == null) {  
                throw new Exception("流程定义未找到!");  
            }  
      
            return processDefinition;  
        }  
      
        /** 
         * 根据任务ID和节点ID获取活动节点 <br> 
         *  
         * @param taskId 
         *            任务ID 
         * @param activityId 
         *            活动节点ID <br> 
         *            如果为null或"",则默认查询当前活动节点 <br> 
         *            如果为"end",则查询结束节点 <br> 
         *  
         * @return 
         * @throws Exception 
         */  
        private ActivityImpl findActivitiImpl(String taskId, String activityId)  
                throws Exception {  
            // 取得流程定义  
            ProcessDefinitionEntity processDefinition = findProcessDefinitionEntityByTaskId(taskId);  
      
            // 获取当前活动节点ID  
            if (StringUtil.isNull(activityId)) {  
                activityId = findTaskById(taskId).getTaskDefinitionKey();  
            }  
      
            // 根据流程定义,获取该流程实例的结束节点  
            if (activityId.toUpperCase().equals("END")) {  
                for (ActivityImpl activityImpl : processDefinition.getActivities()) {  
                    List<PvmTransition> pvmTransitionList = activityImpl  
                            .getOutgoingTransitions();  
                    if (pvmTransitionList.isEmpty()) {  
                        return activityImpl;  
                    }  
                }  
            }  
      
            // 根据节点ID,获取对应的活动节点  
            ActivityImpl activityImpl = ((ProcessDefinitionImpl) processDefinition)  
                    .findActivity(activityId);  
      
            return activityImpl;  
        }  
      
        /** 
         * ********************************************************************************<br> 
         * **********************以上为根据 任务节点ID 获取流程各对象查询方法**********************<br> 
         * *********************************************************************************<br> 
         */  
    }  

 

分享到:
评论

相关推荐

    Activiti-5.4中实现会签

    总的来说,实现Activiti-5.4中的会签功能涉及到流程设计、配置、监听器使用以及代码实现等多个方面。通过理解和掌握这些知识点,你可以灵活地构建适应各种业务场景的并发签名流程,提高企业的协作效率。

    activiti 会签投票统计

    这种方式使得流程可以根据业务需求灵活扩展,而无需修改核心流程逻辑。 5. **流程图**: `voterProcess.png` 文件是流程图,显示了整个会签投票过程的可视化表示。通过此图,可以清晰地看到各个步骤、会签任务的...

    Activiti 5.9 学习笔记(流程发布)

    流程发布后,你可以通过Activiti提供的管理界面或API进行监控和控制,包括查看流程实例、跟踪流程执行路径、干预正在进行的任务等。此外,还可以对已发布的流程进行升级或回滚,以适应业务变化。 ### 6. 源码分析 ...

    Activiti多实例任务实现会签

    总结来说,"Activiti多实例任务实现会签"是通过Activiti引擎和BPMN 2.0的多实例任务特性,构建出一个需要多人同时审批的业务流程,以满足企业中的并行决策需求。开发者需要了解BPMN 2.0的语法,以及如何利用Activiti...

    activiti-5.9

    5.9 版本是 Activiti 的一个重要里程碑,它包含了一系列改进和增强,旨在提供更稳定、高效和易用的流程管理体验。 首先,我们要了解 Activiti 的核心概念。Activiti 是基于 BPMN 2.0(Business Process Model and ...

    activiti取会签人员

    在用activiti的时候经常遇到取会签人员的问题,这个文档解决怎么获取会签人员。

    activiti5.9 请假流程例子 eclipse项目

    【标题】"activiti5.9 请假流程例子 eclipse项目" 在企业级应用开发中,工作流管理系统(Workflow Management System)扮演着至关重要的角色,它能够自动化和管理业务流程,提高工作效率。Activiti 是一个开源的...

    Activiti6-流程跟踪监控图-节点-流程线高亮显示-支持通过、不通过、驳回、退回

    Activiti6-流程跟踪监控图-节点-流程线高亮显示-支持通过、不通过、驳回、退回 支持内容: 已完成节点高亮显示、当前执行中节点红色显示 支持一个节点多条流出线,包括通过、不通过、驳回、退回,按照已执行操作正确...

    activiti5.9的编辑组件activiti-modeler

    标题中的“activiti5.9的编辑组件activiti-modeler”指的是Activiti工作流引擎的一个重要组成部分——Activiti Modeler。Activiti是一个开源的业务流程管理(BPM)和工作流系统,它允许开发者和业务分析师创建、部署...

    activiti流程图查看demo

    这个"activiti流程图查看demo"是一个示例项目,旨在帮助用户理解如何在Activiti中查看和操作流程图。在本篇文章中,我们将深入探讨Activiti的核心概念、流程图的查看方法以及如何利用diagram-viewer工具来实现这一...

    activiti 5.9 postgresql 安装手册

    ### Activiti 5.9 PostgreSQL 安装指南详解 #### 一、概述 Activiti是一款开源的工作流引擎,用于快速开发业务流程应用。其官方提供的示例通常基于H2数据库,但对于生产环境或特定需求场景,用户可能更倾向于使用...

    简单的activiti请假流程

    这个简单的Activiti请假流程项目是一个基础的实践,可以帮助开发者了解Activiti的核心概念和基本操作。通过实践,可以深入理解如何使用Activiti构建和管理业务流程,并为进一步的复杂流程设计和优化打下基础。

    activiti6.0实现流程图片自定义颜色 当前任务为红色,走过的任务为绿色,自定义文字颜色连线文字显示

    在IT行业中,Activiti是一个非常流行的开源工作流引擎,它被广泛用于企业级应用中来管理业务流程。本文将深入探讨如何在Activiti 6.0版本中实现流程图片的自定义颜色功能,以增强流程图的可读性和美观性。 首先,...

    Activiti在线流程设计器

    忙活了一个星期左右,查找各种资料,终于将Activiti的流程设计器分离出来,与SpringMVC,spring整合了起来,先把工程分享出来,等有时间了在慢慢讲解具体的整合步骤。工程下载之后直接可以运行,只需要改一下数据库...

    activiti5.9 表创建

    在本案例中,我们聚焦于"activiti5.9 表创建",这涉及到在Activiti 5.9版本中如何创建和管理数据库表,以及如何进行相关的操作如删除和升级。 首先,让我们深入理解"create"。在Activiti中,当你首次部署或安装时,...

    Activiti5.9 API.chm

    Activiti5.9 API.chm

    Activiti12流程跟踪任务节点和线高亮显示

    流程跟踪任务节点和线高亮显示是Activiti流程跟踪功能的重要组成部分,能够标记流程所走过的节点和线为红色,未走过的节点和线不标记,支持驳回和子流程。 Activiti流程跟踪任务节点和线高亮显示的实现原理是基于...

    Activiti工作流 5.9 案例

    1. **BPMN 2.0支持**:Activiti 5.9全面支持BPMN 2.0标准,这意味着你可以利用各种流程元素,如用户任务、服务任务、并发分支、事件、网关等,构建复杂的工作流程。BPMN 2.0的标准化使得流程定义可以在不同工具和...

    activiti 5.22 退回代码

    activiti在设计的时候没有回退相关的操作,回退是中国特有的特色。这里写一个比较简单的回退。不支持回退到并行网关前面节点,虽然回退到前面节点不会报错 但会导致任务无法结束。使用没有并行网关的回退。

Global site tag (gtag.js) - Google Analytics