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

需求

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

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

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

还不如if else来的直接。

反正只要在if else上注释写清楚,管什么可读性。
手写工作流设计模式,针对常见的工作流步骤流转,减少过多的if/else,提升编程思维_第1张图片

设计模式做不到事

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

新奇的思路

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

原案例

  1. 定义流程节点
    首先定义一个抽象类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);
    }
}
  1. 定义流程实例
    定义一个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特性

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);
			}
			// 以此类推 ...
        }
    }
}

以上,就是今天的内容。

你可能感兴趣的:(设计模式,JAVA,spring,boot,java)