在实验阶段，我们定义了三个结构，分别是流程图结构，流程节点结构和流程边结构。这三个结构构造的流程在行为上，通过测试，可以得出基本是可以满足流程的基本需求的。那么，我们就可以开始进入实际的开发工作中，来完善这一抽象的实现。
​

如何与业务耦合

完善抽象首先需要考虑的点是如何与业务耦合，即，这样的数据结构，我们该应用到业务场景中呢？通用流程的抽象我们已经做完了，现在就需要让这个抽象跟业务耦合。
我首先想到了两种思路：

1. 在业务表里面添加控制字段，用来标识该业务进展到了哪个阶段
2. 建一个单独的表来存储流程流转的历史

​

首先，第一种思路存在的问题是，无法知道历史的流转，如果同一个业务行参与了不同的流程，那么很难通过建字段的方式来维护不同的流程。第二种的思路，每次都需要从整个流转里面获取当前业务在流程中的最新情况，实际上是比较消耗性能的。所以综合两种思路，最终选择采取建一个历史流转表存储流转情况，再建一个业务当前阶段表来存储当前阶段，从而作为缓存而存在。
​

需要建立哪些数据库表

也就是说，我们现在一共需要五个表

1. 流程表
2. 流程节点表
3. 流程边表
4. 流程历史流转表
5. 业务流程当前历史节点表

​

流程表的基础结构如下：

CREATE TABLE IF NOT EXISTS process_tree
(id             bigint PRIMARY KEY   DEFAULT random_id(), --记录标识name           varchar(64)  NOT NULL DEFAULT '--',        --流程名desc           text         NOT NULL DEFAULT '0',        --流程描述
);

流程节点表的基础结构如下：

CREATE TABLE IF NOT EXISTS process_node
(id             bigint PRIMARY KEY   DEFAULT random_id(), --记录标识process_id     bigint      NOT NULL DEFAULT '0',         --流程idnode_name      varchar(64)  NOT NULL DEFAULT '--',       --节点名node_type      text         NOT NULL DEFAULT '0',        --节点类型process_start  boolean      NOT NULL DEFAULT 'F',        --开始节点process_end    boolean      NOT NULL DEFAULT 'F',        --结束节点
);

流程边表的基础结构如下：

CREATE TABLE IF NOT EXISTS process_side
(id             bigint PRIMARY KEY   DEFAULT random_id(), --记录标识desc           text         NOT NULL DEFAULT '--',       --边描述process_id     bigint      NOT NULL DEFAULT '0',         --流程idfrom_node_id   bigint      NOT NULL DEFAULT '0',         --出度节点to_node_id     bigint      NOT NULL DEFAULT '0',         --入度节点side_type      varchar(64) NOT NULL DEFAULT '--',        --边类型
);

业务在流程中的发展历史表：

CREATE TABLE IF NOT EXISTS process_dev_history
(id             bigint PRIMARY KEY   DEFAULT random_id(), --记录标识business_id    bigint      NOT NULL DEFAULT '0',         --业务idprocess_id     bigint      NOT NULL DEFAULT '0',         --流程idcur_node_id    bigint      NOT NULL DEFAULT '0',         --当前节点idcur_node_sta   integer     NOT NULL DEFAULT '0',         --当前节点状态from_node_id   bigint      NOT NULL DEFAULT '0',         --出度节点（如果有）to_node_id     bigint      NOT NULL DEFAULT '0',         --入度节点（如果有）side_id        bigint      NOT NULL DEFAULT '0',         --边idfather_dev_id  bigint      NOT NULL DEFAULT '0',         --从哪个id传过来的begin_time     bigint      NOT NULL DEFAULT '0',         --开始时间update_time    bigint      NOT NULL DEFAULT '0',         --更新时间end_time       bigint      NOT NULL DEFAULT '0',         --结束时间
);

业务的当前历史节点表：

CREATE TABLE IF NOT EXISTS process_business_cursta
(id             bigint PRIMARY KEY   DEFAULT random_id(), --记录标识process_name   varchar(64) NOT NULL DEFAULT '--',        --流程名business_id    bigint      NOT NULL DEFAULT '0',         --业务idcur_history_id varchar(1000) NOT NULL DEFAULT '0',       --当前历史id列表
);

需要实现的基础逻辑

有了数据表和生成的流程结构，现在我们需要考虑如何将业务串起来。即，我们需要提供哪些方法？
下面我列出了最基础的方法。

• 获取流程的当前节点情况
• 判断某流程的当前节点是否可以流转到下一个节点
• 获取整个流程的结构
• 获取当前流程已经走过的节点生成树
• 进入到流程
• 流程转换
• 获取某个节点的所有下级节点
• 修改当前流程点
• 获取某个历史节点的所有下级节点的id

上层要支撑起基本的创建业务流程，业务流程的流转，获取业务流程的状态等等工作，所以在真正实施的过程中还需要根据相应的场景去新增基础方法。
​

下面，给出目前已知需要实现方法的实现代码：

1. 获取流程的当前节点情况

@Override
public List<ProcessDevHistory> getCurDevNode(String processName, Long businessId) {String sql = "select b.*\n" +"from process_business_cursta as a\n" +"         left join process_dev_history as b on string_to_array(b.id::varchar,',') <@ string_to_array(a.cur_history_id,',')\n" +"where a.process_name = :process_name\n" +"  and a.business_id = :business_id;";Map<String, Object> params = new HashMap<>();params.put("process_name", processName);params.put("business_id", businessId);List<ProcessDevHistory> processDevHistories = new ArrayList<>();List<Map<String,Object>> tmp = namedParameterJdbcTemplate.queryForList(sql, params);for (Map<String,Object> tmpA : tmp){processDevHistories.add(Json.toObject(Json.toJson(tmpA),ProcessDevHistory.class));}return processDevHistories;
}

2. 判断某流程的当前节点是否可以流转到下一个节点

@Override
public Boolean checkCirculation(Long historyId) {ProcessDevHistory processDevHistory = processDevHistoryRepository.findProcessDevHistoryById(historyId);if (Objects.nonNull(processDevHistory)) {// TODO: 2022/1/10 检查当前节点的情况，是否结束，只有上一个状态结束了才能接着往下走if (processDevHistory.getCurNodeSta().equals(2)) {return true;}}return false;
}@Override
public Boolean checkCirculation(String processName, Long business) {List<ProcessDevHistory> processDevHistories = getCurDevNode(processName, business);int flag = 0;for (ProcessDevHistory processDevHistory : processDevHistories){if (Objects.nonNull(processDevHistory)) {// TODO: 2022/1/10 检查当前节点的情况，是否结束，只有上一个状态结束了才能接着往下走if (!processDevHistory.getCurNodeSta().equals(2)) {flag = 1;break;}}}if (flag == 0){return true;}return false;
}

3. 获取整个流程的结构

@Override
public CcsProcessTree getTotalProcessTree(String processName) {String sql = "select tree.name as name,tree.description as description, node.*\n" +"from process_tree as tree\n" +"         left join process_node as node on tree.id = node.process_id\n" +"where tree.name = :name;";Map<String, Object> params = new HashMap<>();params.put("name", processName);List<Map<String, Object>> nodes = namedParameterJdbcTemplate.queryForList(sql, params);String sql1 = "select side.*\n" +"from process_tree as tree left join process_side as side on tree.id = side.process_id\n" +"where tree.name = :name;";List<Map<String, Object>> sides = namedParameterJdbcTemplate.queryForList(sql1, params);CcsProcessTree ccsProcessTree = GenerateProcessUtil.generateTree(nodes, sides);return ccsProcessTree;
}

4. 获取当前流程已经走过的节点生成树

@Override
public CcsProcessTree getCurProcessTree(String processName, Long businessId) {String sql = "select tre.description as description, his.*\n" +"from process_dev_history as his\n" +"         left join process_tree as tre on his.process_id = tre.id\n" +"where tre.name = :name\n" +"  and his.business_id = :business_id;";Map<String, Object> params = new HashMap<>();params.put("name", processName);params.put("business_id", businessId);List<Map<String, Object>> nodeSides = namedParameterJdbcTemplate.queryForList(sql, params);String sql1 = "select tree.name as name,tree.description as description, node.*\n" +"from process_tree as tree\n" +"         left join process_node as node on tree.id = node.process_id\n" +"where tree.name = :name;";List<Map<String, Object>> nodes = namedParameterJdbcTemplate.queryForList(sql1, params);return GenerateProcessUtil.generateCurTree(nodeSides, nodes);
}

5. 进入到流程

@Override
public Boolean beginProcess(String processName, Long businessId) {String sql = "select node.*\n" +"from process_tree as tree\n" +"         left join process_node as node on tree.id = node.process_id\n" +"where tree.name = :name and node.process_start = true;";Map<String, Object> params = new HashMap<>();params.put("name", processName);List<Map<String,Object>> tmp = namedParameterJdbcTemplate.queryForList(sql, params);ProcessNode processNode = Json.toObject(Json.toJson(tmp.get(0)),ProcessNode.class);if (Objects.nonNull(processNode)) {ProcessDevHistory processDevHistory = new ProcessDevHistory();Long time = DatetimeUtil.getTimestampOfDatetime(LocalDateTime.now());processDevHistory.setBeginTime(time);processDevHistory.setBusinessId(businessId);processDevHistory.setCurNodeId(processNode.getId());processDevHistory.setProcessId(processNode.getProcessId());processDevHistory.setCurNodeSta(0);processDevHistory.setUpdateTime(time);Long hisId = processDevHistoryRepository.save(processDevHistory);changeCurProcessHistoryIds(processName, businessId, hisId + "");return true;}return false;
}

6. 流程转换

@Override
public Boolean convertProcess(String processName, Long businessId, Long historyId) {ProcessDevHistory processDevHistory = processDevHistoryRepository.findProcessDevHistoryById(historyId);if (Objects.nonNull(processDevHistory)) {// TODO: 2022/1/11 判断是否能转换if (GenerateProcessNode.NodeState.getInfo(processDevHistory.getCurNodeSta()).equals("end")) {// TODO: 2022/1/11 可以转换到下一步// TODO: 2022/1/11 判断下一步是否存在，即父节点为自己的ProcessDevHistory condition = new ProcessDevHistory();condition.setFatherDevId(historyId);List<ProcessDevHistory> processDevHistories = processDevHistoryRepository.findAllByCondition(condition);if (processDevHistories.size() == 0) {// TODO: 2022/1/11 下一步不存在，创建下一步// TODO: 2022/1/11 需要解决下一步有多个的情况List<ProcessSide> nextProcessSides = getAllChildrenProcessSide(processDevHistory.getCurNodeId());// TODO: 2022/1/11 下一步可能有多个Long time = DatetimeUtil.getTimestampOfDatetime(LocalDateTime.now());List<ProcessDevHistory> processDevHistoryList = new ArrayList<>();for (ProcessSide nextProcessSide : nextProcessSides) {ProcessDevHistory devHistory = new ProcessDevHistory();devHistory.setFatherDevId(historyId);devHistory.setBeginTime(time);devHistory.setUpdateTime(time);devHistory.setProcessId(processDevHistory.getProcessId());devHistory.setToNodeId(nextProcessSide.getToNodeId());devHistory.setFromNodeId(processDevHistory.getCurNodeId());devHistory.setSideId(nextProcessSide.getId());devHistory.setBusinessId(businessId);devHistory.setCurNodeId(nextProcessSide.getToNodeId());devHistory.setCurNodeSta(0);processDevHistoryList.add(devHistory);}processDevHistoryRepository.saveAll(processDevHistoryList);changeCurProcessHistoryIds(processName, businessId, ArrayStrUtil.llist2Str(getChildrenHis(historyId), ","));return true;} else {return false;}} else {// TODO: 2022/1/11 不能转换到下一步return false;}}return false;
}

7. 获取某个节点的所有下级节点

@Override
public List<ProcessSide> getAllChildrenProcessSide(Long processNodeId) {ProcessSide processSideCondition = new ProcessSide();processSideCondition.setFromNodeId(processNodeId);return processSideRepository.findAllByCondition(processSideCondition);
}

8. 修改当前流程点

@Override
public Boolean changeCurProcessHistoryIds(String processName, Long businessId, String hisIds) {// TODO: 2022/1/11 修改当前流程表ProcessBusinessCursta processBusinessCurstaCondition = new ProcessBusinessCursta();processBusinessCurstaCondition.setBusinessId(businessId);processBusinessCurstaCondition.setProcessName(processName);ProcessBusinessCursta processBusinessCursta = findProcessBusinessCurstaByCondition(processBusinessCurstaCondition);if (Objects.nonNull(processBusinessCursta)){ProcessBusinessCursta processBusinessCursta1 = new ProcessBusinessCursta();processBusinessCursta1.setCurHistoryId(hisIds);update(processBusinessCurstaCondition, processBusinessCursta1);}else {processBusinessCurstaCondition.setCurHistoryId(hisIds);save(processBusinessCurstaCondition);}return true;
}

9. 获取某个历史节点的所有下级节点的id

@Override
public List<Long> getChildrenHis(Long historyId) {ProcessDevHistory condition = new ProcessDevHistory();condition.setFatherDevId(historyId);List<ProcessDevHistory> processDevHistories = processDevHistoryRepository.findAllByCondition(condition);List<Long> ans = new ArrayList<>();for (ProcessDevHistory processDevHistory : processDevHistories) {ans.add(processDevHistory.getId());}return ans;
}

有了这些基本的方法，就可以到项目中去实际拆分一个业务流程为业务+流程的方式，进行处理了。