手写工作流设计模式，针对常见的工作流步骤流转，减少过多的if/else，提升编程思维-编程知识

需求

这一年下来，写两次工作流流转，总结下经验。
第一次写的时候，只找到用模版设计模式包裹一下，每个方法都做隔离，但是在具体分支实现的时候，if/else 满屏分，而且因为要针对不同情况，重复代码很多，但是if/else的条件又不一样，搞得我没办法用设计模式修改，想过用工厂模式重构。

一是没时间，二是工厂模式和策略模式基本上都用不来，
首先，工厂模式一定是if else分支较多，并且入参明确、固定。
策略模式也是不同的方法，实现不同的业务，入参明确、固定。
它们两者都不适合参数多一个少一个的情况，用起来只能说恶心自己。
并且由于设计模式的方法过多，时常debug需要嵌套跳转好几轮代码，就比较恶心。

这一年，闲下来我都会重构部分重复的代码，比如if else过多用设计模式优化，优化下来的感受是，没感觉可读性有多提高，反而感觉代码可读性变差了，有些案例的设计模式，很多情况没考虑到，比如较多重复代码，直接复用interface default里的方法，给我直观的体验是其他人来看这个代码，不太好理解。

还不如if else来的直接。

反正只要在if else上注释写清楚，管什么可读性。
在这里插入图片描述

设计模式做不到事

举个例子，当有个非常恶心的业务，需要在两层for循环里写if else，continue关键字是你贴心侍卫，常伴汝身。
你必须用continue它，艹，这个东西用设计模式就不合理，只能复用一些代码，放到一个方法里面去，什么两层for循环里，写个四五百行if else，调试都要好几天，我不知道要是业务出现变动，这个代码后面还怎么改。

新奇的思路

再次遇到工作流，吃过一次亏，不能走老路。
我选择网上冲浪，翻阅资料，最终找到一篇好用例子。
什么都没说，直接上项目，擦，一用才知道里面有坑。

原案例

定义流程节点
首先定义一个抽象类ProcessNode，表示工作流中的一个节点：

public abstract class ProcessNode {private String nodeName; // 节点名称private List<ProcessNode> nextNodes; // 后继节点private boolean isEndNode; // 是否为结束节点public ProcessNode(String nodeName) {this.nodeName = nodeName;this.nextNodes = new ArrayList<>();this.isEndNode = false;}public String getNodeName() {return nodeName;}public void setNodeName(String nodeName) {this.nodeName = nodeName;}public List<ProcessNode> getNextNodes() {return nextNodes;}public void setNextNodes(List<ProcessNode> nextNodes) {this.nextNodes = nextNodes;}public boolean isEndNode() {return isEndNode;}public void setEndNode(boolean endNode) {isEndNode = endNode;}
}

其中，nodeName表示节点名称，nextNodes表示后继节点，isEndNode表示是否为结束节点。
接着，定义两个子类StartNode和EndNode，分别表示工作流的起始节点和结束节点：

public class StartNode extends ProcessNode {public StartNode() {super("Start");}
}

public class EndNode extends ProcessNode {public EndNode() {super("End");setEndNode(true);}
}

定义流程实例
定义一个ProcessInstance类，表示一次工作流的执行实例：

public class ProcessInstance {private ProcessNode currentNode; // 当前节点public ProcessInstance(ProcessNode startNode) {this.currentNode = startNode;}public ProcessNode getCurrentNode() {return currentNode;}public void setCurrentNode(ProcessNode currentNode) {this.currentNode = currentNode;}
}

其中，currentNode表示当前执行到的节点。
执行工作流
定义一个ProcessEngine类，表示工作流引擎。该类包括以下方法：
addNodes：添加节点
run：执行工作流
代码如下：

public class ProcessEngine {private Map<String, ProcessNode> nodes; // 节点列表public ProcessEngine() {this.nodes = new HashMap<>();}/*** 添加节点*/public void addNodes(ProcessNode... processNodes) {for (ProcessNode node : processNodes) {nodes.put(node.getNodeName(), node);}}/*** 执行工作流*/public void run(ProcessInstance instance) {while (!instance.getCurrentNode().isEndNode()) {ProcessNode currentNode = instance.getCurrentNode();List<ProcessNode> nextNodes = currentNode.getNextNodes();if (nextNodes.isEmpty()) {throw new RuntimeException("No next node found.");} else if (nextNodes.size() == 1) {instance.setCurrentNode(nextNodes.get(0));} else {throw new RuntimeException("Multiple next nodes found.");}}}
}

测试
使用以下代码测试上述工作流引擎的功能：

public static void main(String[] args) {ProcessNode startNode = new StartNode();ProcessNode approveNode = new ProcessNode("Approve");ProcessNode endNode = new EndNode();startNode.setNextNodes(Arrays.asList(approveNode));approveNode.setNextNodes(Arrays.asList(endNode));ProcessEngine engine = new ProcessEngine();engine.addNodes(startNode, approveNode, endNode);ProcessInstance instance = new ProcessInstance(startNode);engine.run(instance);System.out.println("流程执行完成。");
}

运行结果为：
流程执行完成。

填坑

这个案例没考虑到每个Node都是一个function，它需要一个执行function，处理业务逻辑。
怎么玩呢？
使用Function<T, R>特性

public class EndNode extends ProcessNode {public EndNode() {super("End");setEndNode(true);System.out.println("执行end的任务");}public Object executeMethod(Integer languageId, Function<Integer, Object> function) {return function.apply(languageId);}
}

用这种方式把参数传递进去，并业务流转。
然后结合模版模式，把每个abstract的function看做Node，这样就能按照工作流一个方法执行完，执行下一个方法。

public abstract class TestTemplate {abstract Object handler(Integer languageId);// ...
}

第二点，这里缺少一个上一个方法流转结束，返回结果参数作为下一个方法的入参，这里没处理好，这样就会导致某个业务节点失败，回退到上一个节点，取不到入参的问题。

两种解决思路

第一种就是这些返回结果参数，一定要做数据库保存，到进入下一个节点，那这个流转入参就可以删除；

第二种
使用全局Map，并且不使用单例模式，bean注入，而是new Object。（这个不建议）

我们把ProcessEngine的Run方法改到template里面来，

public abstract class TestTemplate {abstract Object handler(Integer languageId);// ...public void init(Integer languageId) {ProcessNode startNode = new StartNode();ProcessNode endNode = new EndNode();startNode.setNextNodes(Arrays.asList(endNode));ProcessEngine engine = new ProcessEngine();engine.addNodes(startNode, endNode);ProcessInstance instance = new ProcessInstance(startNode);run(languageId, instance);}/*** 执行工作流*/private void run(Integer languageId, ProcessInstance instance) {String queryJson = StringConstant.Symbol.BLANK;while (!instance.getCurrentNode().isEndNode()) {ProcessNode currentNode = instance.getCurrentNode();List<ProcessNode> nextNodes = currentNode.getNextNodes();if (nextNodes.isEmpty()) {throw new RuntimeException("No next node found.");}if (nextNodes.size() != 1) {throw new RuntimeException("Multiple next nodes found.");}instance.setCurrentNode(nextNodes.get(0));if (currentNode instanceof StartNode) {StartNode startNode = (StartNode) currentNode;Object obj = startNode.executeMethod(languageId, this::handler);queryJson = JacksonUtil.writeJson(obj);} else if (currentNode instanceof EndNode) {EndNode endNode = (EndNode) currentNode;Object params = new Object();if(StringUtils.isNotBlank(queryJson)) {params = JacksonUtil.readJson(queryJson, Object.class);} else {// 从数据库读取上次function的结果参数}Object obj = endNode.executeMethod(params, this::handler);queryJson = JacksonUtil.writeJson(obj);}// 以此类推 ...}}
}