实现flowable 相邻节点审批人是同一人自动审批功能

已于 2024-05-10 14:42:05 修改
阅读量1.4k 收藏 10
点赞数 11
文章标签： java 开发语言 web
于 2024-05-10 14:39:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shi851806957/article/details/138663540
版权

 问题背景

ao审批的效率是老生常谈的问题，流程图设计的部分节点是按角色或岗位配置的，最终审批的路径会出现相邻节点是重复的审批人，导致同一个审批人需要审批好几次才能推动整个流转进程，由此要设计一个功能：相邻节点是同一人，只需要一次审批便可完成相邻节点的跳过功能。

功能图例如下：

张三同学只需要一次审批操作就可以流转节点直接走到李四的节点位置。

方案有多种设计：例如有可以在流程设计器中画各种条件网关，也可以在userTask属性上配置跳过表达式等等，但是这些改造都有局限性，那就是在流程发布之前就得完全知道节点上配置的人员信息，而且对流程图入侵比较大，并不是一个通用解决方案。

推荐方法：

采用全局监听器

配置全局监听器
/**
 * @description: 全局监听器
 **/
@Configuration
public class FlowableGlobListenerConfing implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private SpringProcessEngineConfiguration configuration;

    @Autowired
    private GlobalTaskCreateListener globalTaskCreateListener;


    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        FlowableEventDispatcher eventDispatcher = configuration.getEventDispatcher();
        eventDispatcher.addEventListener(globalTaskCreateListener, FlowableEngineEventType.TASK_CREATED);//监听task任务创建
    }
}

/**
 *实现监听器功能
 */
@Component
public class GlobalTaskCreateListener extends AbstractFlowableEngineEventListener {

    protected Logger logger = LoggerFactory.getLogger(this.getClass());

    @Resource
    TaskService taskService;

    @Resource
    HistoryService historyService;

    @Resource
    private RepositoryService repositoryService;

    @Resource
    private RuntimeService runtimeService;


    /**
     * 线程共享变量
     */
    static ThreadLocal<Object> threadLocal = new ThreadLocal<>();

    @Override
    public void onEvent(FlowableEvent flowableEvent) {
        try {
            logger.info("Flowable处理事件：{}", Optional.ofNullable(flowableEvent).map(FlowableEvent::getType).map(FlowableEventType::name).orElse(null));
            super.onEvent(flowableEvent);
        } catch (Exception e) {
            logger.error("Flowable事件处理失败！", e);
        } finally {
            threadLocal.remove();
        }
    }

    /**
     * //相邻节点是同一审批人需要跳过执行。
     * @param event
     */
    @Override
    protected void taskCreated(FlowableEngineEntityEvent event) {
        logger.info("Flowable处理事件-taskCreated:{}", JSON.toJSONString(event));

            UserTask flowElementLod = null;
            //前置节点：incomingFlows
            List<SequenceFlow> incomingFlows = flowElement.getIncomingFlows();
            logger.info("处理前置节点开始: {}", JSON.toJSONString(incomingFlows));
            if(incomingFlows.size()==1 && incomingFlows.get(0).getSourceFlowElement() instanceof ExclusiveGateway){
                logger.info("前置为网关节点");
                ExclusiveGateway exclusiveGateway = (ExclusiveGateway) incomingFlows.get(0).getSourceFlowElement();
                List<SequenceFlow> incomingFlows1 = exclusiveGateway.getIncomingFlows();
                flowElementLod = (UserTask)process.getFlowElement(incomingFlows1.get(0).getSourceRef());
            }else if (incomingFlows.size()==1 && incomingFlows.get(0).getSourceFlowElement() instanceof UserTask){
                logger.info("前置为单节点");
                flowElementLod = (UserTask)process.getFlowElement(incomingFlows.get(0).getSourceRef());
            }else if (incomingFlows.size() > 1 ){
                logger.info("前置为多节点");
                List<Comment> processInstanceComments = taskService.getProcessInstanceComments(processInstanceId);
                String taskId = processInstanceComments.get(0).getTaskId();
                if (entity.getAssignee().equals(taskId) && (ProcessActionEnum.CARE_OF_PASS.name().equals(processInstanceComments.get(0).getType()) || ProcessActionEnum.PASS.name().equals(processInstanceComments.get(0).getType()))){
                    skipFunction(entity, processInstanceId);
                }
                //前置节点和当前节点不一致 不需要做跳过业务逻辑
                return;
            }

            Map<String, List<ExtensionAttribute>> attributes = flowElementLod.getAttributes();
            ExtensionAttribute userType = attributes.get("userType").get(0);
            ExtensionAttribute handleMode = flowElementLod.getAttributes().get("handleMode").get(0);

            checkBeforeUserNode(flowElementLod, userType, handleMode, variables, entity, processInstanceId);
        }

    }

    /**
     * 校验前置节点 与 当前节点是否一致
     *
     */
    private void checkBeforeUserNode(UserTask flowElementLod, ExtensionAttribute userType, ExtensionAttribute handleMode, Map<String, Object> variables, TaskEntity entity, String processInstanceId ){
        if (UserTypeEnums.assignee.name().equals(userType.getValue()) && ProcessConstant.MULTIPLEUNITE_ONE.equals(handleMode.getValue())){
            List<Comment> processInstanceComments = taskService.getProcessInstanceComments(processInstanceId);
            //或签节点
            if (ObjectUtils.isNotEmpty(threadLocal.get()) ){
                String assigneeId = (String)threadLocal.get();
                if (assigneeId.equals(entity.getAssignee())){
                    skipFunction(entity,processInstanceId);
                }
            }else if (ObjectUtils.isEmpty(threadLocal.get()) && CollectionUtils.isNotEmpty(processInstanceComments)){
                if (ProcessActionEnum.REJECT.name().equals(processInstanceComments.get(0).getType())){
                    return;
                }
                List<Comment> collect = processInstanceComments.stream().filter(x -> ProcessActionEnum.PASS.name().equals(x.getType()) || ProcessActionEnum.CARE_OF_PASS.name().equals(x.getType())).collect(toList());
                if (collect.get(0).getUserId().equals(entity.getAssignee())){
                    skipFunction(entity,processInstanceId);
                }

            }
        }else if (UserTypeEnums.assignee.name().equals(userType.getValue()) && ProcessConstant.MULTIPLEUNITE_ALL.equals(handleMode.getValue())){
            //会签节点
            if (checkAssigneeList(flowElementLod, variables).contains(entity.getAssignee())){
                skipFunction(entity,processInstanceId);
            }
        }else  if(UserTypeEnums.assigneeInitiator.name().equals(userType.getValue())){
            if (entity.getAssignee().equals(checkAssignee(flowElementLod, variables))){
                skipFunction(entity,processInstanceId);
            }
        }else if (UserTypeEnums.departmentLeader.name().equals(userType.getValue()) || UserTypeEnums.assigneePerDepartment.name().equals(userType.getValue())){
            if (entity.getAssignee().equals(checkAssignee(flowElementLod, variables))){
                skipFunction(entity,processInstanceId);
            }
        }else if (UserTypeEnums.assignee.name().equals(userType.getValue()) && ProcessConstant.SOLO.equals(handleMode.getValue())){
            if (entity.getAssignee().equals(checkAssignee(flowElementLod, variables))){
                skipFunction(entity,processInstanceId);
            }
        }else if (UserTypeEnums.customDefine.name().equals(userType.getValue()) && ProcessConstant.MULIIPLE_UNITE_ALL.equals(handleMode.getValue())){
            Map<String, Object> variablesTemp = customExportVariableMap(variables);
            if (variablesTemp == null){
                variablesTemp = variables;
            }
            if (checkAssigneeList(flowElementLod, variablesTemp).contains(entity.getAssignee())){
                skipFunction(entity,processInstanceId);
            }
        }
    }

    /**
     * 发起人自选获取自选节点内容
     *
     */
    public Map<String, Object> customExportVariableMap(Map<String, Object> variables){
        List<JSONObject> variablesList = JSON.parseArray((String) variables.get("variables"), JSONObject.class);
        if (variablesList == null){
            return null;
        }
        Map<String, Object> variableTemp = new HashMap<>();
        for (JSONObject variable : variablesList) {
            variableTemp.put((String)variable.get("name"),variable.get("value"));
        }
        return variableTemp;
    }

    /**
     * 执行自动跳过方法
     * @param entity 任务
     * @param processInstanceId 实例ID
     */
    private void skipFunction(TaskEntity entity, String processInstanceId){
        logger.info("task_skip开始：processInstanceId={}, taskId为: {}", processInstanceId, entity.getId());
        // 1、添加跳过节点意见
        Authentication.setAuthenticatedUserId(entity.getAssignee());
        taskService.addComment(entity.getId(), processInstanceId, ProcessActionEnum.SKIP.name(), "");

        //在连续相邻节点审批 ：使用线程变量 存储上一节点审批人
        threadLocal.set(entity.getAssignee());

        //2、完成审批
        taskService.complete(entity.getId());


    }

    /**
     * 获取单节点审批人
     * @param flowElementLod 任务
     * @param variables 变量
     * @return 处理人
     */
    private String checkAssignee(UserTask flowElementLod, Map<String, Object> variables){
        String assignee = flowElementLod.getAssignee();
        Matcher regexMatcher = REGEX_PATTERN.matcher(assignee);
        regexMatcher.find();
        String variable = regexMatcher.group(1);
        return (String)variables.get(variable);
    }

    /**
     * 获取assigneeList
     * @param flowElementLod 任务
     * @param variables 变量
     * @return 处理人
     */
    private List<String> checkAssigneeList(UserTask flowElementLod, Map<String, Object> variables){
        String inputDataItem = flowElementLod.getLoopCharacteristics().getInputDataItem();
        Object o = variables.get(inputDataItem);
        return (List<String>)o;
    }
}

设计思路： 采用全局监听的方法去控制跳过节点的方法触发，本方法的好处是使用监听器去辅助用户完成相邻节点是同一人审批的功能，历史流程表中都会记录审批日志。

如果有其他问题 请私信联系作者本人

花开富贵呀
关注
25.flowable 流程中的自动跳过
liuwenjun05101的博客
12-20 1万+
项目地址：https://gitee.com/lwj/flowable.git 分支flowable-base 背景：在实际场景中，我们往往会有这样的需求，当流程到达某一个节点的时候，我们让其自动的跳过去，不做任何操作。 如： 1、当当前任务审批的人是空或者空串的时候，如果你不设置跳过，这个任务就会出现无法认领的状态。 2、第一个节点是提交人，本来就是他提交的流程，这个节点我们就没有必要让他还审批...
Flowable 如何设置线自动跳过
liuwenjun05101的博客
11-28 2393
Flowable 如何设置线自动跳过设置启动变量条件设置流程图设置 设置启动变量 variables.put("_ACTIVITI_SKIP_EXPRESSION_ENABLED", true); 条件设置 Map<String, Object> variables = new HashMap<>(); variables.put("input", "right"); variables.put("skipLeft", true); variables.put("skipRight
【flowable】超时自动审批通过当前节点
m0_47542011的博客
07-19 702
个人思考了一下，如果用定时器启动事件的话，有可能会出现已经到了用户设置的截止时间，但是定时器任务还没有启动，造成了超时之后还可以审批，如果用定时器边界事件的话，可以在用户设置的截止时间时，判断当前节点剩余的审批活动，并且一次性的自动审批通过，不过可能也会有一个小弊端，如果服务器正好在那个时间段挂断的话，就没办法达到自动审批通过的功能了，这个我后续再想一下可以怎么改比较好。监听器的代码大概如下，大家可以根据自己的实际业务来修改，逻辑基本上是一样的，代码实现方式有不同而已。完成了以上步骤后可以编写代码了；
Activiti中如何跳过（自动处理）第一步的提交任务？（转载）
weixin_30247159的博客
03-28 3371
在Activiti流程设计中，为了使流程展示的更加完善，经常会将流程图的第一步任务设计成“提交任务”，例如： 申请人启动流程后，流程就会到达“提交任务”，而“提交任务”的办理人还是该申请人，这个时候就需要通过代码跳过（自动处理）该任务节点，让流程流转到下一任务节点。有两种方法可以处理这个问题。 第一种方式：在启动流程后，获取当前流程实例申请人的待办任务，并执行当前流程实例的下一步...
申请人和审批人重复，怎么处理？
m0_46913535的博客
05-19 1772
申请人和审批人重复，怎么处理？ 1，如果重复，重复的审批节点自动执行，注意，不是自动跳过，而是让程序自动执行，执行完成后直接到后面节点待办。 2，业务方的需求各不一样：有些业务方的需求，是跳过/自动执行；而有一些业务方的需求，是要求不能跳过/不能自动执行。 思考思路： 那么跳过/自动执行，作为一个功能，给这个功能增加一个开关。从而实现功能性的个性化配置方案，由流程管理员去个性化配置即可。 那么，由于每个业务都有N个流程，所以针对一个流程，是否开通或关闭【跳过/自动执行】功能，是从整个流程的所有节点
flowable 获取下一个节点，并基于芋道api获取节点审批人
最新发布
m0_46401243的博客
07-25 767
根据底层代码，可以找到整个的节点流转，一点点获取到下一个节点的activityId,并打算根据activityId,获取到当前节点的审批人列表，if(sequenceFlow.getConditionExpression().equals("最开始想法是想做一个，如果当前节点与下一个节点审批人相同情况下，自动审批这个功能，所以想法在这个节点找下个节点的审批人，判断是不是登录人，写一半发现实际我要做的业务好像不用这么麻烦，先记录一下吧。{pass==1}也就是审批通过的情况，其它的还没写。
FLOWABLE 流程中的自动跳过
Gblfy_Blog
07-08 4666
FLOWABLE 流程中的自动跳过
Flowable流程审批使用
qq_40774600的博客
07-01 6646
流程审批Flowable使用
java activiti 同一节点多人审批，一人通过即可
方圆师兄
12-28 1万+
一、画图 申请人Main-config / Assignee：#{username} 第二节点的 部门主管和部门副主管 Candidate users 为#{usernames} 二、部署流程 把.pbmn结尾和.png结尾的两个文件打包成.zip结尾的压缩文件，然后把打包完成的zip文件放到resources资源包下边 //demo1.启动运行进行部署流程 @Test public void demo1() { RepositorySer...
发起人和审批人是同一个，不想自动审批通过怎么办？
h2498864708的博客
06-04 170
2、当两个相邻审批节点是同一个人，且第二个审批节点字段权限全部都不可写，那么这个审批节点会自动通过。1、当发起人，跟审批人是同一个人，且审批节点的字段权限全部都不可写，那么这个审批节点会自动通过。如果要设置不自动通过，那么就在对应的节点，勾选任意字段可写。3、设置了限时自动通过。
flowableDemo
10-10
简单的流程实现，可以运行。开发环境是idea,用的工作流flowable6.2.1
enterprise-flowable:工作流，包含：单人审批、多人审批、流程分支、指定退回、流程图展示
04-13
开发者可以使用Flowable的API或服务任务来实现审批逻辑。 3. **多人审批**： 多人审批涉及多个参与者共同完成一个任务。Flowable支持并行和串行的用户任务，例如，可以通过多实例（Parallel Multi-instance）和...
flowable高亮流程已执行节点及连线.txt
06-17
flowable高亮流程已执行节点及连线，包含6.4.1版本以及6.4.1之前版本的不同处理方法
【JAVA+flowable】工作流 完成任务代码 及扩展节点审核人（实现多级部门主管 审核等）详解【JAVA+springboot】
qq_27246521的博客
06-04 353
flowable工作流【JAVA+springboot】 前端传递此参数就可以实现 流程中 审批 更新流程变量参数var。可以看到 complete()方法 传递了流程变量参数var。使用flowable 工作流 完成任务代码 详解。也可以进行更多扩展 实现流程中更新表单内容功能。实现对于流程自定义 动态节点审核人 功能代码。
flowable获取流程节点顺序，预测审批路径
oouuyy的博客
03-31 8298
之前基于flowable为公司开发了套轻量级的OA系统，最近有个需求，要求在正式发起审批前或者流程被驳回后重新发起前预测审批路径，参考了下https://blog.51cto.com/10983441/2501052这篇文章，做了一些修改和补充。 1. 首先拿到BpmnModel，所有流程定义信息都可以通过BpmnModel获取；若流程尚未发起，则用modelId查询最新部署的流程定义数据；若流程已经发起，可以通过流程实例的processDefiitionId查询流程定义的历史数据。 private
flowable多任务实现会签、或签
wangwcy的博客
05-14 4494
做工作流，基本会遇到会签、或签的需求。而flowable是通过多任务方式来实现的。
带你详细了解基于springboot和flowable的开源审批系统
小鲍侃java
06-28 5215
Flowable 项目提供了一套核心的开源业务流程引擎，这些引擎紧凑且高效。它们为开发人员、系统管理员和业务用户提供工作流和业务流程管理 (BPM) 平台。它的核心是一个闪电般快速、久经考验的动态 BPMN 流程引擎，伴随着 DMN 决策表和 CMMN 案例管理引擎，所有这些引擎都是用 Java 编写的。它们是 Apache 2.0 许可的开放源代码，拥有一个承诺社区。所有引擎都可以嵌入在 Java 应用程序中运行，也可以作为服务器、集群和云中的服务运行。
flowable工作流--实操篇
热门推荐
当作记事本用
02-13 1万+
本文通过申请发工资的业务场景来介绍使用工作流的全流程,包括画流程图,设置属性,以及代码编写使用工作流大致分为三步第一步:根据自己的业务画好流程图第二步:设置流程图的属性和变量,保存模型第三步:部署画好的流程图(发布)第四步:根据业务和流程图写一些服务和监听器这里主要介绍以下几个任务的使用1.用户任务的分配和提交2.服务任务的使用3.中间信号捕捉事件的触发4.排他网关的使用5.通过设置流程变量,实现流程的不同流转。
flowable 多人审批
04-28
Flowable 多人审批是指在 Flowable 工作流系统中，一个或多个审批人对同一流程进行审批的过程。具体来说，工作流会将流程分成多个任务，每个任务由一位或多位审批人负责审批，当所有任务都被审批通过后，流程才能完成。 在 Flowable 多人审批中，每个任务由一个或多个候选人负责处理。有两种类型的候选人：候选组和候选人。候选组是一组人员，可以根据组的成员和权限进行任务的分配。而候选人则是指具体的人员，由工作流进行任务的分配。工作流会根据任务的属性和优先级来确定哪些候选人可以处理这个任务。 Flowable 多人审批可以通过多种方式进行，例如：并行审批、串行审批、任意审批等。其中，并行审批是所有审批人同时处理任务，只要有一个人通过就可以进行下一步。串行审批则是按照指定顺序，一个人接一个人地处理任务，必须所有人都通过才能进行下一步。任意审批则是由任意一位审批人通过后才能进行下一步。 总之，Flowable 多人审批提高了审批过程的透明度和效率，可以根据实际需求灵活地定义审批流程，提高组织的管理效率和响应速度。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值