activiti工作流,驳回问题详细解析(尤其会签的驳回问题)

本文介绍如何使用Activiti框架实现复杂的工作流需求,包括任意节点流转与会签功能,特别是针对会签驳回的处理。作者分享了具体的代码实现细节及关键逻辑判断。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

最近因为项目需要,所以研究了一下工作流,然而,我们都知道,国外的工作流框架,是不支持驳回问题的!这是其一!第二!项目的工作流要实现任意节点的流转,这也是国外工作流框架所不具备的!因此,国外的工作流框架是没有一个可以真正满足我们的业务要求的,然而国内的工作流架构,我也没有听说过哪个可以支持中国式工作流!因此,在技术选型上面选择了相对比较火的activiti框架!当时我们的原则就是尽可能的不改变框架,而实现我们的业务逻辑,因为,工作流这一大模块是本屌全权负责,就研究了一通!本项目实现了工作流节点的任意流转,工作流回退(包含会签),等等一系列操作,至于研究会签问题的辛酸泪就不在多说,本节也不多说其他功能,主要说工作流回退,特别强调会签回退,以及网上一些会签回退的问题!
本屌在研究工作流的时候,曾参考csdn上某一位同志的博客(点击蓝色文字可以进入),但是在使用的时候,发现会签是有一些问题的,所以对代码进行了一些调整,验证完美实现会签驳回
另外,在上代码之前一定声明一点,大家一定注意我在完成任务的时候,进行了一系类的逻辑判断,此判断尤其重要,关系到会签是否真正的没有问题,曾经我出现过会签驳回之后审批会出现多条记录的情况,因此,希望大家一定要看仔细代码,最后:声明一点,前面已经说了,本屌参考了一篇博客,说明出处,因此有雷同代码,不要疑惑和纠结!废话不在多少,直接上代码!
下面为核心代码,但是会签的时候在审批要注意,在核心代码之后我会贴出我对会签审批的处理
    /**
     * 
     * @param taskId 任务id
     * @param msg 批注
     * @param endActivityId 结束节点的activitiyId
     * @throws Exception
     */
    public void turnBackNew(String taskId, String msg, String endActivityId) throws Exception {
        Map<String, Object> variables;
        // 取得当前任务
        HistoricTaskInstance currTask = historyService
                .createHistoricTaskInstanceQuery().taskId(taskId)
                .singleResult();
        // 取得流程实例
        ProcessInstance instance = runtimeService
                .createProcessInstanceQuery()
                .processInstanceId(currTask.getProcessInstanceId())
                .singleResult();
        if (instance == null) {
            throw new RuntimeException("流程已结束");
        }
        variables = instance.getProcessVariables();
        // 取得流程定义
        ProcessDefinitionEntity definition = (ProcessDefinitionEntity) ((RepositoryServiceImpl) repositoryService)
                .getDeployedProcessDefinition(currTask
                        .getProcessDefinitionId());
        if (definition == null) {
            throw new RuntimeException("流程定义未找到");
        }
        // 取得上一步活动
        ActivityImpl currActivity = ((ProcessDefinitionImpl) definition)
                .findActivity(currTask.getTaskDefinitionKey());
        List<ActivityImpl> rtnList = new ArrayList<>();
        List<ActivityImpl> tempList = new ArrayList<>();
        List<ActivityImpl> activities = iteratorBackActivity(
                taskId,
                currActivity,
                rtnList,
                tempList
        );
        if (activities == null || activities.size() <= 0) throw new RuntimeException("没有可以选择的驳回节点!");
        List<Task> list = taskService.createTaskQuery().processInstanceId(instance.getId()).list();
        for (Task task : list) {
            if (!task.getId().equals(taskId)) {
                task.setAssignee("排除标记");
                commitProcess(task.getId(), null, endActivityId);
            }
        }
        turnTransition(taskId, activities.get(0).getId(), null);
    }

    /**
     * @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 (activityId == null || activityId.equals("")) {
            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);
    }

    /**
     * 迭代循环流程树结构,查询当前节点可驳回的任务节点
     *
     * @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 (id == null || id.equals("")) {// 并行起点ID为空,此节点流向不是并行终点,符合驳回条件,存储此节点
                rtnList.add(currActivity);
            } else {// 根据并行起点ID查询当前节点,然后迭代查询其对应的userTask任务节点
                currActivity = findActivitiImpl(taskId, id);
            }

            // 清空本次迭代临时集合
            tempList.clear();
            // 执行下次迭代
            iteratorBackActivity(taskId, currActivity, rtnList, tempList);
        }
        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;
    }

    /**
     * 根据任务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 (activityId == null || "".equals(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;
    }

    /**
     * 根据任务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获得任务实例
     *
     * @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获取对应的流程实例
     *
     * @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;
    }
下面尤其重要的说明一点,会签在提交的时候,一定要如我之判定,否则,会在多次驳回的时候,出现多条记录,流程混乱的问题
public void submitTask(ProjectWorkflowRequest param, String userCode, String username, User user) throws Exception {
        String s = WorkflowReflectionLog.refectCompare(projectService.getProjectByProjectId(projectService.getNewestProjectIdByApplicationId(param.getProject().getTab1().getApplicationProjectId())), param.getProject());// 此段为本屌用反射记录的审批人修改的内容的日志(为我项目专属所有,大家删掉就好)
        //  if (true) throw new RuntimeException();
        projectService.applicationSubmit(param.getProject(), user);// 此段是为了满足甲方需求,记录的历史,大家删掉就好
        Task task = taskService.createTaskQuery().taskId(param.getTaskId()).singleResult();// 获取当前任务
        String processInstanceId = task.getProcessInstanceId();
        taskService.addComment(param.getTaskId(), processInstanceId, param.getMsg());// 添加任务批注
        taskService.setVariableLocal(param.getTaskId(), "projectId", param.getProject().getTab1().getProjectId());// 此段也是为了记录历史而诞生,大家可以删掉
        if (s != null) taskService.setVariableLocal(param.getTaskId(), "log", s);// 大家可以删掉
        runtimeService.setVariables(task.getExecutionId(), new HashMap() {{
            this.put("LAST_USER", userCode);
            this.put("LAST_USER_NAME", username);
        }});// 大家可以删掉

        runtimeService.setVariable(processInstanceId, "LAST_USER", username);// 大家可以删掉
// 因为前台标记驳回还是通过还是终止流程,分别用0,1,2标识,所以,你就当是三种情况,通过驳回,终止
        if ("1".equals(param.getFlag())) {// 通过
            switch (param.getType()) {
                case 1: {
                    String sid = task.getTaskDefinitionKey();// 获取当前任务的activitiyId
                    List<Task> list = taskService.createTaskQuery().processInstanceId(task.getProcessInstanceId()).list();// 获取当前流程的所有未完成任务
                    if (list.size() == 1) {// 如果只剩一个任务,可能是普通任务,可能是会签任务
                        if (
                                "sid-71E0BFA1-AD56-45D6-907E-D4B61F445D84".equals(sid) ||
                                        "sid-9795199D-77F0-4F34-A0D6-E388525FA8BE".equals(sid) ||
                                        "sid-6340E7E8-2BA1-4B2F-B7CF-19FE31412E58".equals(sid)) {// 如果是会签,则提交到下一个审批节点(并行网关之后的第一个节点)
//工作流任意流转,流转到下一个审批节点,因为我的会签里面包含三个节点,所以经过activitiyId来判定是不是这三个节点,如果是,则任意流转节点,如果不是,则正常完成任务,注意:工作流程图确定之后,每个节点的activityId是永恒不变的!因此,才可以做此判定
                            commitProcess(task.getId(), null, "sid-C6334E47-F8A8-430C-9A35-FA98CFD0C405");
                        } else if (
                                "sid-62D73895-5AB3-4818-8795-D8CCCDB59CE6".equals(sid) ||
                                        "sid-CFDED207-B694-478A-AE94-3DFFD486E77F".equals(sid) ||
                                        "sid-7A523F96-9F43-4C2C-979F-06B7BC9656B6".equals(sid)
                                ) else taskService.complete(task.getId());// 如果不是会签的3个节点则直接审批
                    } else {
                        commitProcess(task.getId(), null, "sid-404150FC-8E2D-4582-9CFB-BC9FF43F09E1");
                    }
                }
                break;
                case 2: {
                    Map<String, Object> variables = new HashMap<>();
                    variables.put("a", param.getU1());
                    variables.put("b", param.getU2());
                    taskService.complete(param.getTaskId(), variables);
                }
                break;
                case 3: {
                    Map<String, Object> variables = new HashMap<>();
                    variables.put("flag", param.getFlag1());
                    taskService.complete(param.getTaskId(), variables);
                }
                break;
            }

        } else if ("0".equals(param.getFlag())) {// 拒绝 // // TODO: 2017/11/8 0008
            turnBackNew(param.getTaskId(), param.getMsg(), "sid-404150FC-8E2D-4582-9CFB-BC9FF43F09E1");
        } else if ("2".equals(param.getFlag())) {// 终止流程
            endProcess(param.getTaskId(), "sid-404150FC-8E2D-4582-9CFB-BC9FF43F09E1");
        }
    }
<think>嗯,用户这次明确询问Activiti工作流的使用教程和实现示例。从历史记录看,用户之前得到的回答主要集中在快速排序算法,但当前需求已经转向工作流引擎技术,需要完全调整知识范围。用户提供的站内引用很有价值。[^1]展示了SpringBoot+Vue+Activiti的全栈项目,包含在线编辑器、表单集成等关键功能;[^2]则聚焦于代码层面的配置和API调用。这两份材料恰好覆盖了从架构设计到具体实现的完整链路。用户可能是Java后端开发者,正在评估如何将Activiti集成到SpringBoot项目中。ta的提问方式("教程/示例")表明需要实操指导而非理论概念,且引用的资料里包含钉钉集成等企业级功能,暗示用户可能在开发商业OA系统。核心响应策略应分为三层:首先用最小化示例建立认知(配置文件+启动流程),再通过权限审批等高频场景深化理解,最后补充企业实践注意事项。特别注意要区分"基本用法"和"进阶技巧",因为用户引用[^1]提到的"驳回到任意节点"等属于高级特性。需要警惕两个技术细节:一是BPMN文件路径配置容易出错,二是SpringBoot版本与Activiti的兼容性。在代码示例中必须明确标注文件位置,并建议使用6.x以上Activiti版本。对于快速发起流程的两种方式(是否自动完成任务),用户引用[^2]的4.1/4.2章节已经给出模式,需强调事务管理的重要性。企业集成部分虽然用户未明说,但引用的钉钉通知功能值得展开。考虑到大多数企业需要审批提醒,准备补充NotificationListener的编写要点。审批环节的"或签"特性容易引发生产环境bug,将单列注意事项提醒。</think> 好的,了解!Activiti 是一个轻量级的 Java 工作流引擎,非常适合于 SpringBoot 集成。以下是一个结合你提供的引用信息和工作流核心概念的 **Activiti 7.x + SpringBoot 配置与基础实现教程/示例**,包含关键配置、核心流程操作和最佳实践提示。 --- ### 一、核心依赖与配置 #### 1. Maven 依赖 (`pom.xml`) 集成 Activiti 7.x Spring Boot Starter。参考[^2]。 ```xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <!-- Activiti 核心 Starter --> <dependency> <groupId>org.activiti</groupId> <artifactId>activiti-spring-boot-starter</artifactId> <version>7.1.0.M6</version> <!-- 使用最新稳定版本 --> </dependency> <!-- (可选) Activiti 模型器 (在线流程图设计器) --> <dependency> <groupId>org.activiti</groupId> <artifactId>activiti-cloud-modeling</artifactId> <version>7.1.0.M6</version> </dependency> </dependencies> ``` #### 2. 数据库配置 (`application.properties`) Activiti 需要数据库存储流程定义、实例、任务等数据。参考[^2]。 ```properties # 数据源配置 (示例使用 MySQL) spring.datasource.url=jdbc:mysql://localhost:3306/activiti_db?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC spring.datasource.username=root spring.datasource.password=yourpassword spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver # Activiti 表结构策略: update - 自动更新表结构; create-drop - 启动时创建,关闭时删除; validate - 仅校验 spring.activiti.database-schema-update=update # 是否在启动时自动部署 classpath:processes/ 下的 BPMN 文件 spring.activiti.check-process-definitions=true # 指定 BPMN 文件位置 (可选,默认也是 processes/) spring.activiti.process-definition-location-prefix=classpath:/processes/ ``` ### 二、流程定义 (`BPMN 2.0` 文件) 1. 在 `src/main/resources/processes/` 下创建 BPMN 文件,如 `simple-approval.bpmn20.xml`。参考[^1][^2]。 2. 可以使用在线编辑器(如集成 `activiti-cloud-modeling`)、桌面工具 `Activiti Modeler` 或 IntelliJ IDEA 插件(推荐)绘制流程图。 3. **简单审批流程示例要素 (`simple-approval.bpmn20.xml`):** * **启动事件 (`Start Event`):** 流程入口。 * **用户任务 (`User Task`):** * `员工提交申请 (employeeSubmit)`:申请者任务。 * `主管审批 (managerApproval)`:主管审批任务。设置任务候选人/组(如 `activiti:candidateGroups="manager"`) * `人事归档 (hrArchive)`:归档任务。 * **排他网关 (`Exclusive Gateway`):** 根据条件路由流程。 * **序列流 (`Sequence Flow`):** 连接节点,可设置条件表达式(如 `${approved == true}`)。 * **结束事件 (`End Event`):** 流程结束。 ### 三、核心 Service 方法示例 (基于 Activiti `RuntimeService` & `TaskService`) ```java @Service public class ActivitiService { @Autowired private RuntimeService runtimeService; // 流程运行管理 @Autowired private TaskService taskService; // 任务管理 @Autowired private RepositoryService repositoryService; // 流程定义管理 /** * 1. 启动流程实例 (直接跳过第一个任务) - 参考[^2] 4.1 * @param processDefinitionKey 流程定义Key (BPMN中定义的) * @param businessKey 关联的业务ID (例如: 请假单ID、报销单ID) * @param variables 启动流程携带的变量 * @return 流程实例ID */ public String startProcessInstance(String processDefinitionKey, String businessKey, Map<String, Object> variables) { ProcessInstance instance = runtimeService.startProcessInstanceByKey(processDefinitionKey, businessKey, variables); return instance.getId(); } /** * 2. 启动流程实例并自动完成第一个用户任务 (如提交申请) - 参考[^2] 4.2 * 适用场景:发起申请同时即完成提交操作。 * @param processDefinitionKey 流程定义Key * @param businessKey 关联的业务ID * @param variables 包含表单数据、审批人信息等 * @return 流程实例ID 和 后续任务的TaskId (通常是第一个审批节点) */ public Map<String, String> startAndSubmitFirstTask(String processDefinitionKey, String businessKey, Map<String, Object> variables) { // 启动流程,但做提交(任务在第一个节点) ProcessInstance instance = runtimeService.startProcessInstanceByKey(processDefinitionKey, businessKey, variables); // 获取当前任务(即第一个节点任务) Task currentTask = taskService.createTaskQuery().processInstanceId(instance.getId()).singleResult(); // 带上变量完成该任务(模拟提交操作) taskService.complete(currentTask.getId(), variables); // 获取完成后可能的下一任务 (如审批任务) List<Task> nextTasks = taskService.createTaskQuery().processInstanceId(instance.getId()).list(); Map<String, String> result = new HashMap<>(); result.put("processInstanceId", instance.getId()); if (!nextTasks.isEmpty()) { // 假设简单流程下一步是审批 result.put("nextTaskId", nextTasks.get(0).getId()); } return result; } /** * 3. 审批/完成任务 (核心:任务ID + 审批决定 + 审批意见 + 新变量) - 参考[^2] 4.3 * @param taskId 当前待完成任务的ID * @param approveResult 审批结果 (e.g., "approved" / "rejected") * @param comment 审批意见 (可选) * @param newVariables 完成任务时传递的新变量 (如后续处理需要的数据) */ public void completeTask(String taskId, String approveResult, String comment, Map<String, Object> newVariables) { if (newVariables == null) { newVariables = new HashMap<>(); } newVariables.put("approved", "approved".equals(approveResult)); // 设置流程变量 // 添加审批意见(可选) if (StringUtils.isNotEmpty(comment)) { taskService.addComment(taskId, null, comment); // 添加全局流程注释 } // 完成任务, 携带新变量 taskService.complete(taskId, newVariables); } /** * 4. 查询我发起的流程实例 - 参考[^2] 4.4 * @param userId 发起人ID * @return 我发起的流程实例列表 */ public List<HistoricProcessInstance> getMyStartedProcesses(String userId) { return historyService.createHistoricProcessInstanceQuery() .startedBy(userId) .orderByProcessInstanceStartTime().desc() .list(); } /** * 5. 查询我的待办任务 (根据候选人用户/组查询) - 参考[^2] 4.7 * @param userId 当前用户ID * @param groupIds 当前用户所属的角色/组ID列表 * @return 我的待办任务列表 */ public List<Task> getMyTodoTasks(String userId, List<String> groupIds) { return taskService.createTaskQuery() .taskCandidateOrAssigned(userId) // 既可以是候选人也可是签收人 .taskCandidateGroupIn(groupIds) // 候选组匹配 .orderByTaskCreateTime().desc() .list(); } } ``` ### 四、Controller 示例 ```java @RestController @RequestMapping("/process") public class ProcessController { @Autowired private ActivitiService activitiService; // 1. 发起一个请假申请流程 (启动并提交) @PostMapping("/leave/start") public Map<String, String> startLeaveProcess(@RequestParam String employeeId, @RequestBody LeaveRequest leaveRequest) { Map<String, Object> variables = new HashMap<>(); variables.put("leaveType", leaveRequest.getType()); variables.put("days", leaveRequest.getDays()); variables.put("reason", leaveRequest.getReason()); variables.put("submitter", employeeId); // 设置提交人 // 假设业务Key为"LEAVE_" + 时间戳 (实际应该用数据库生成的ID) String businessKey = "LEAVE_" + System.currentTimeMillis(); return activitiService.startAndSubmitFirstTask("leave_process", businessKey, variables); } // 2. 处理审批任务 @PostMapping("/task/complete/{taskId}") public void completeTask(@PathVariable String taskId, @RequestParam String approvalResult, @RequestParam(required = false) String comment) { Map<String, Object> variables = new HashMap<>(); // 如果需要向下传递变量, 可以在这里添加 activitiService.completeTask(taskId, approvalResult, comment, variables); } // 3. 查看我的待办 @GetMapping("/my/tasks") public List<Task> getMyTasks(@RequestParam String userId, @RequestParam List<String> groupIds) { // 假设前端传递了用户的角色ID列表 return activitiService.getMyTodoTasks(userId, groupIds); } } ``` ### 五、关键点与最佳实践 1. **业务 `Key` 关联:** * 流程实例启动时务必通过 `businessKey` 参数关联具体的业务实体(如请假单ID、订单号)[^1]。 * 后续所有操作(查询、审批)都依赖这个关联。 `HistoricProcessInstance` 中的 `businessKey` 用于反向查找业务数据。 2. **流程变量 (`Variables`) 管理:** * 启动时变量 (`startProcessInstanceByKey` 参数):传递表单数据、申请人等。 * 任务完成时变量 (`taskService.complete(taskId, variables)` 参数):传递审批结果、决定路由走向。 * 流程变量存储在 `ACT_RU_VARIABLE` / `ACT_HI_VARINST` 表中,谨慎传递大对象,通常只传递必要数据和业务ID。 3. **候选人(`Candidate`) vs 签收人(`Assignee`):** * **候选用户/组 (`CandidateUser/CandidateGroup`):** 任务可以由列表中的任何人签收后处理(或签/会签)。`taskService.claim(taskId, userId)` 进行签收。 * **办理人 (`Assignee`):** 任务直接指定给具体的人处理。 * 建议在 BPMN 设计时使用候选组(如 `"manager"`),在 Service 方法中根据用户所属组进行查询[^1][^2]。签收操作通常在任务详情页处理。 4. **监听器 (`Listeners`):** * **执行监听器/任务监听器 (`ExecutionListener/TaskListener`):** 用于自动化处理逻辑: * 任务创建/完成时自动通知(如邮件、钉钉[^1])。 * 自动计算变量。 * 记录审计日志。 * **优点:** 解耦业务逻辑与流程处理主代码。 5. **异步处理 (`Async`):** * Activiti 自动处理流程任务的异步执行(通过 `AsyncExecutor`)。 * 耗时操作(如生成报表、调用远程服务)应放在流程之外的异步服务中,以避免阻塞流程引擎线程。 6. **集成自定义表单:** * 流程定义文件 (`BPMN`) 本身只描述任务节点和路由,包含特定表单UI。 * 引用中的 **“工作流表单可平滑的接入自定义表单”** 指: * 在任务节点关联一个表单定义ID `activiti:formKey="form-approve"`。 * 在应用中根据 `formKey` 动态渲染对应业务表单UI。表单提交数据就是 `completeTask` 的 `variables`。 * 表单设计器生成表单配置和动态渲染引擎是关键。这是 **“[^1]”** 项目的重点之一。 7. **高级流程控制:** * **驳回到任意节点:** 使用 `runtimeService.createChangeActivityStateBuilder()` 接口实现流程跳转[^1]。 * **挂起/激活:** `runtimeService.suspendProcessInstanceById(processInstanceId)` / `runtimeService.activateProcessInstanceById(processInstanceId)`。 * **委托:** `taskService.delegateTask(taskId, newAssigneeUserId)`。 --- ###
评论 42
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值