简单工作流（后端部分-spring boot，顺便优化了下ui）

整个项目我丢到github上去了，需要copy的可以直接去github
https://github.com/liaoyuecai/demo
前端部分目录在：/react/antd-pro-demo/src/pages/workflow
后端部分目录在：/java/spring-boot-demo/src/main/java/com/demo/workflow

我这边用的JPA做持久化，如果是mybatis的话需要修改一下持久化层，代码整个拷贝的话直接运行一下sql文件改下配置就行，有bug或者问题的话欢迎留言

前端效果如下：

目前用的前端脚手架是react  antd-pro 如果改成vue的需要改改代码，后端部分需要新增两个表，我用的mysql

DROP TABLE IF EXISTS `workflow_record`;
CREATE TABLE `workflow_record` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `workflow_name` varchar(20) NOT NULL COMMENT '流程名称',
  `workflow_nodes` text NOT NULL COMMENT '流程图形节点',
  `status` smallint(1) DEFAULT '1' COMMENT '状态 0禁用1启用',
  `workflow_status` smallint(1)  NOT NULL COMMENT '流程状态 0草稿 1发布',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `create_by` int(11) NOT NULL COMMENT '创建人',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `update_by` int(11) DEFAULT NULL COMMENT '修改人',
  `deleted` smallint(1) DEFAULT '0' COMMENT '删除状态',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COMMENT='流程表';

DROP TABLE IF EXISTS `workflow_node`;
CREATE TABLE `workflow_node` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `workflow_id` int(11) NOT NULL   COMMENT '流程id',
  `parent_id` int(11)  COMMENT '上级节点',
  `child_workflow_id` int(11)  COMMENT '子流程id，当节点为子流程节点时生效',
  `if_return` int(11)  COMMENT '是否可以回退',
  `if_condition` int(1)  COMMENT '判断条件：当上级节点为决策节点时，字段值0为假，1为真',
  `node_name` varchar(20) NOT NULL COMMENT '节点名称',
  `node_type` smallint(2) NOT NULL COMMENT '节点类型 1开始，2结束，3任务节点，4子流程节点，5决策节点',
  `deleted` smallint(1) DEFAULT '0' COMMENT '删除状态',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COMMENT='流程节点表';

代码部分其他都比较简单，就是流程保存的时候，需要拆分节点做一些验证，我也没有做的很严格，简单验证了一下
 

 @Override
    @Transactional
    public WorkflowRecord save(ApiHttpRequest<WorkflowRecord> request) {
        Integer id = request.getData().getId();
        WorkflowRecord record = super.save(request);
        if (record.getWorkflowStatus() == 0)
            return record;
        if (id != null) {
            nodeRepository.updateDeletedByWorkflowId(id);
        }
        Map<Integer, WorkflowSaveNode> map = JsonUtils.toMap(record.getWorkflowNodes(), new TypeToken<Map<Integer, WorkflowSaveNode>>() {
        }.getType());
        Collection<WorkflowSaveNode> nodes = map.values();
        Map<Integer, Integer> parentsMap = new HashMap<>();
        Map<Integer, WorkflowNode> nodeMap = new HashMap<>();
        List<WorkflowNode> list = new ArrayList<>();
        AtomicReference<Integer> startNode = new AtomicReference<>();
        nodes.forEach(n -> {
            switch (n.getType()) {
                case 1, 2, 3, 4, 5:
                    if (n.getType() == 1) {
                        if (startNode.get() != null)
                            throw new GlobalException(ErrorCode.PARAMS_ERROR_WORKFLOW_NODE_ERROR);
                        startNode.set(n.getKey());
                    }
                    WorkflowNode node = new WorkflowNode();
                    node.setWorkflowId(record.getId());
                    node.setNodeName(n.getName());
                    node.setNodeType(n.getType());
                    node.setChildWorkflowId(n.getChildWorkflowId());
                    node.setDeleted(0);
                    node.setIfCondition(n.isIfCondition() ? 1 : 0);
                    node.setIfReturn(n.isIfReturn() ? 1 : 0);
                    list.add(node);
                    nodeMap.put(n.getKey(), node);
                    break;
                case 6:
                    if (n.getStartNode() == null || n.getEndNode() == null) {
                        throw new GlobalException(ErrorCode.PARAMS_ERROR_WORKFLOW_NODE_ERROR);
                    }
                    parentsMap.put(n.getEndNode(), n.getStartNode());
                    break;
            }
        });
        if (startNode.get() == null) throw new GlobalException(ErrorCode.PARAMS_ERROR_WORKFLOW_NODE_ERROR);
        //先保存生成节点id
        nodeRepository.saveAll(list);
        //校验决策节点下属节点是否符合一真一假规则，决策节点下连接节点应为2个，2个节点应为一真一假
        Map<Integer, Integer> ifNodeValue = new HashMap<>();
        Map<Integer, Integer> ifNodeNumber = new HashMap<>();

        nodeMap.keySet().forEach(key -> {
            WorkflowNode node = nodeMap.get(key);
            //开始节点不允许有上级节点
            if (node.getNodeType() == 1 && parentsMap.containsKey(key))
                throw new GlobalException(ErrorCode.PARAMS_ERROR_WORKFLOW_NODE_ERROR);
            if (node.getNodeType() != 1 && node.getNodeType() != 6) {
                if (parentsMap.containsKey(key)) {
                    WorkflowNode parent = nodeMap.get(parentsMap.get(key));
                    if (parent == null) throw new GlobalException(ErrorCode.PARAMS_ERROR_WORKFLOW_NODE_ERROR);
                    node.setParentId(parent.getId());
                    //决策节点
                    if (parent.getNodeType().equals(5)) {
                        if (!ifNodeValue.containsKey(parent.getId())) {
                            ifNodeValue.put(parent.getId(), 0);
                            ifNodeNumber.put(parent.getId(), 0);
                        }
                        ifNodeValue.put(parent.getId(), ifNodeValue.get(parent.getId()) + node.getIfCondition());
                        ifNodeNumber.put(parent.getId(), ifNodeNumber.get(parent.getId()) + 1);
                    }
                } else {
                    throw new GlobalException(ErrorCode.PARAMS_ERROR_WORKFLOW_NODE_ERROR);
                }
            }
        });
        ifNodeValue.keySet().forEach(key -> {
            if (!ifNodeValue.get(key).equals(1) || !ifNodeNumber.get(key).equals(2))
                throw new GlobalException(ErrorCode.PARAMS_ERROR_WORKFLOW_NODE_ERROR);
        });
        //保存父节点id
        nodeRepository.saveAll(list);
        return record;
    }