flowable动态创建多级流程模板

发布时间 2023-05-23 09:15:23作者: 多喝灬丶烫水

flowable动态创建多级流程模板

  1. 引入Maven依赖

    <dependency>
        <groupId>org.flowable</groupId>
        <artifactId>flowable-spring-boot-starter</artifactId>
        <version>6.6.0</version>
    </dependency>
    
  2. 动态创建流程节点工具类

    /**
     * 动态创建流程节点
     */
    @Slf4j
    @Component
    @RequiredArgsConstructor
    public class FlowableBpmnHandler {
        /**
         * 创建开始节点信息
         *
         * @return
         */
        public static FlowElement createStartFlowElement(String id, String name) {
            StartEvent startEvent = new StartEvent();
            startEvent.setId(id);
            startEvent.setName(name);
            return startEvent;
        }
    
        /**
         * 创建结束节点信息
         *
         * @param id
         * @param name
         * @return
         */
        public static FlowElement createEndFlowElement(String id, String name) {
            EndEvent endEvent = new EndEvent();
            endEvent.setId(id);
            endEvent.setName(name);
            return endEvent;
        }
    
        /**
         * 循环创建普通任务节点信息
         *
         * @param processEntity 流程实体
         * @return
         */
        public static List<UserTask> createCommonUserTask(ProcessEntity processEntity) {
            List<ProcessNode> processNodes = processEntity.getProcessNodeList();
            List<UserTask> userTaskList = Lists.newLinkedList();
            for (int i = 0; i < processNodes.size(); i++) {
                ProcessNode node = processNodes.get(i);
                node.setNodeId(UUIDHelper.randomUUID());
                node.setNodeLevel(i + 1);
                UserTask userTask = new UserTask();
                userTask.setId(TypeEnum.getProcessKey(processEntity.getType()) + "_task_" + node.getNodeId());
                userTask.setCategory(String.valueOf(i + 1));
                userTask.setDocumentation(i == processNodes.size() - 1 ? "true" : "false");
                userTask.setName(node.getNodeName());
                userTaskList.add(userTask);
            }
            return userTaskList;
        }
    
    
        /**
         * 创建排它网关节点
         *
         * @return
         */
        public static ExclusiveGateway createExclusiveGateway(Integer i) {
            ExclusiveGateway gateway = new ExclusiveGateway();
            gateway.setName("getaway_name_" + i);
            gateway.setId("getaway_id_" + i);
            return gateway;
        }
    }
    
  3. 动态创建流程模板工具类

    /**
     * 动态创建流程模板
     *
     * @author ll
     * @date 2023/04/19 14:28
     **/
    @Slf4j
    @Component
    public class DynamicProcessDefinition {
        @Resource
        private RepositoryService repositoryService;
    
    
        public String createProcessDefinition(ProcessEntity processEntity) {
            //数据校验:传入的数据节点字段:流程配置id、节点id、节点顺序、节点描述
            List<ProcessNode> nodeList = processEntity.getProcessNodeList();
            if (CollUtil.isEmpty(nodeList)) {
                throw new RuntimeException("流程节点不能少于一个,请配置发起人节点和至少一个审批节点");
            }
    
    
            BpmnModel bpmnModel = new BpmnModel();
            Process process = new Process();
            bpmnModel.addProcess(process);
    
            // 流程标识
            process.setId(TypeEnum.getProcessKey(processEntity.getType()));
            process.setName(TypeEnum.getProcessKey(processEntity.getType()));
            //开始事件
            FlowElement startEvent = FlowableBpmnHandler.createStartFlowElement("start", "开始");
            process.addFlowElement(startEvent);
            //结束事件--任务正常完成
            FlowElement endEvent = FlowableBpmnHandler.createEndFlowElement("end", "结束");
            process.addFlowElement(endEvent);
            //创建用户节点任务
            List<UserTask> userTaskList = FlowableBpmnHandler.createCommonUserTask(processEntity);
            //构建流程模板
            buildProcessTemplate(process, startEvent, endEvent, userTaskList);
            //该流程的流程xml字符串
            //BpmnXMLConverter bpmnXMLConverter = new BpmnXMLConverter();
            //byte[] convertToXML = bpmnXMLConverter.convertToXML(bpmnModel);
            //String bytes = new String(convertToXML);
            //log.info("该流程的流程xml为:{}", bytes);
            // 创建一个新的部署
            Deployment deploy = repositoryService.createDeployment().key(TypeEnum.getProcessKey(processEntity.getType()))
                    .name(TypeEnum.getProcessKey(processEntity.getType()))
                    .addBpmnModel(TypeEnum.getProcessKey(processEntity.getType()) + ".bpmn", bpmnModel)
                    .deploy();
            log.info("部署id:{}", deploy.getId());
            return deploy.getId();
        }
    
        /**
         * 构建流程模板
         *
         * @param process
         * @param startEvent
         * @param endEvent
         * @param userTaskList
         * @return void
         * @author ll
         * @date 2023/04/24 08:53
         */
        private void buildProcessTemplate(Process process, FlowElement startEvent, FlowElement endEvent, List<UserTask> userTaskList) {
            for (int i = 0; i < userTaskList.size(); i++) {
                //用户任务
                UserTask userTask = userTaskList.get(i);
                process.addFlowElement(userTask);
                //创建排它网关节点
                ExclusiveGateway exclusiveGateway = FlowableBpmnHandler.createExclusiveGateway(i);
                process.addFlowElement(exclusiveGateway);
                //开始事件到第一个节点
                if (i == 0) {
                    // 开始节点到第一级节点
                    SequenceFlow startSequenceFlow = new SequenceFlow(startEvent.getId(), userTask.getId());
                    process.addFlowElement(startSequenceFlow);
                }
                //用户任务到网关节点
                SequenceFlow sequenceFlow = new SequenceFlow(userTask.getId(), exclusiveGateway.getId());
                sequenceFlow.setName(userTask.getName() + "_开始审批");
                process.addFlowElement(sequenceFlow);
                //同意:取下一步用户任务的节点id,可能为结束节点或者用户任务节点
                String nextUserTaskId = endEvent.getId();
                if (userTaskList.size() - i > 1) {
                    nextUserTaskId = userTaskList.get(i + 1).getId();
                }
                SequenceFlow sequenceFlowAgree = new SequenceFlow(exclusiveGateway.getId(), nextUserTaskId);
                sequenceFlowAgree.setConditionExpression("${auditResult}");
                sequenceFlowAgree.setName("同意");
                process.addFlowElement(sequenceFlowAgree);
                //不同意:回退到上一步,取上一步的节点id
                String preUserTaskId = userTaskList.get(0).getId();
                if (i != 0) {
                    preUserTaskId = userTaskList.get(i - 1).getId();
                }
                SequenceFlow sequenceFlowRefuse = new SequenceFlow(exclusiveGateway.getId(), preUserTaskId);
                sequenceFlowRefuse.setConditionExpression("${!auditResult}");
                sequenceFlowRefuse.setName("拒绝");
                process.addFlowElement(sequenceFlowRefuse);
            }
        }
    }
    
  4. 保存流程配置模板的接口

    @Resource
    private DynamicProcessDefinition dynamicProcessDefinition;
    @RequestMapping("/save")
    public Result<String> save(@RequestBody ProcessEntity processEntity) {
        return dynamicProcessDefinition.createProcessDefinition(processEntity);;
    }
    
  5. 开启流程接口

    
        @RequestMapping("/start")
        public String start(@RequestBody AuditData auditData) {
                    //业务自己定义key
            String businessKey = auditData.getBusinessKey();
            //流程定义key
            String processKey = auditData.getType();
    
            // 判断是否启动流程
            boolean isStartProcess = null != runtimeService.createProcessInstanceQuery()
                    .processDefinitionKey(processKey)
                    .processInstanceBusinessKey(businessKey)
                    .singleResult();
            if (!isStartProcess) {
                //记录开启流程的用户
                HashMap<String, Object> variable = Maps.newHashMap();
                //启动流程
                ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processKey, businessKey, variable);
                log.info("启动流程实例成功:processInstanceId={}", processInstance.getId());
    
            }
            return !isStartProcess ? "流程启动成功" : "流程启动失败";
    
        }