开发一个功能性代码带来的思考

前言

最近客户端要在之前的一个功能上重新开发一个新的分支功能，这些功能涉及到需要操作本地文件，并且这个功能的部分逻辑可能也需要在别的地方共用。
回头看了一下之前写的代码，一个方法里，堆了很多代码。如果要进行抽离，工作量比较大，而且需要先理解整个代码流程的逻辑以及各个路径实际对应的意思。即便有一些方法进行了抽离，但是这些方法实际上也很有局限性。

解决方案

可以采用组件化链路的思路，来进行开发对应的功能
如何设计组件化链路？
因为并不是服务端，需要涉及过多的逻辑，所以简单写了一个框架，方便后续扩展和维护，解决之前的痛点。

每一个节点都是独立的操作，用一个context贯穿所有node，并且每一个node都拥有一个优先级，在加载完所有的节点后，对这些节点进行排序，然后按顺序执行。
如果有新的节点，则可以通过优先级的方式来进行穿插到整个链路中，保证了时序性。

// 节点
public abstract class ProcessNode {
    // 全局优先级
    private static int gPriority = 10000;

    private int priority = 0;

    protected PackContext context;

    public ProcessNode(PackContext context) {
        this.context = context;
        // 每次构造节点，自增
        gPriority += 100;
        priority = gPriority;
    }

    public int getPriority() {
        return priority;
    }

    protected abstract void run(PackContext context) throws Exception;

    public void exec() throws Exception {
        run(context);
    }
}
// node执行
public class NodeExcutor {

    private List<ProcessNode> nodes = Lists.newArrayList();

    public NodeExcutor(Context context) {
        nodes.add(ProcessNode(context));
        nodes.add(ProcessNode(context));
        // 节点排序
        Collections.sort(nodes, Comparator.comparingInt(ProcessNode::getPriority));
    }
    // 执行节点任务
    public void exec() throws Exception {
        for (ProcessNode node : nodes) {
            node.exec();
        }
    }
}
// 启动
public boolean main(Params params) {
    try {
        // 参数转换成对象
        Context context = getContext(params);
        new NodeExcutor(context).exec();
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

当有类似的功能的时候，可以单独开放一个接口，同样加载自己需要的节点以及增加自己额外的逻辑节点，方便逻辑的抽离和代码的整洁性。