流程设计思路

两种流程设计方式

• 在水平方向进行拓展，设计抽象的执行流程，有新的流程就在流程里加方法

• 在垂直方向进行拓展，说白了就是加层

垂直拓展

废话不多说，直接代码演示

工作接口 Work

public interface Work {

    void work();

}

三个实现类

public class Work1 implements Work {

    @Override
    public void work() {
        System.out.println("work 1 ");
    }
}

public class Work2 implements Work {

    @Override
    public void work() {
        System.out.println("work 2 ");
    }
}

public class Work3 implements Work {

    @Override
    public void work() {
        System.out.println("work 3 ");
    }
}

然后用一个服务类（其实就是一个包装类）来封装了 Work 的实现，想要获取 Work 的实现就只能通过这个服务类，这也是垂直设计的精髓。

public class WorkService {

    private Work work;


    /**
     * 封装 Work 接口的所有实现
     * Runs a specific work based on the given type.
     *
     * @param type the type of work to be executed
     */
    public void run(String type) {
        if (type.equals("1")) {
            new Work1().work();
        }else if (type.equals("2")) {
            new Work2().work();
        }else if (type.equals("3")) {
            new Work3().work();
        }

    }

}

流程执行时

public class FlowTodo {

    public static void main(String[] args) {
        WorkService ws = new WorkService();
        ws.run("1");
        ws.run("2");
        ws.run("3");
    }

}

输出

work 1 
work 2 
work 3 

水平拓展

复用上面的 Work 接口，创建一个流程执行抽象类，这个抽象类中并不包含具体的 Work 实现，而是定义了抽象方法，让子类去实现，而且我们可以自定义添加步骤，删除步骤，非常灵活，

public abstract class FlowAbstract {

    /**
     * 执行流程
     */
    public void execute() {

        // 获取工作方法
        getWork().work();
        // 灵活添加其他步骤
        // other work 1
        // other work 2

    }

    public abstract Work getWork();

}

流程实现类

public class FlowWork1 extends FlowAbstract implements Work {
    @Override
    public Work getWork() {
        return this;
    }

    @Override
    public void work() {
        System.out.println("Work 1111 ");
    }
}

public class FlowWork2 extends FlowAbstract implements Work {
    @Override
    public Work getWork() {
        return this;
    }

    @Override
    public void work() {
        System.out.println("Work 2222 ");
    }
}

public class FlowWork3 extends FlowAbstract implements Work {
    @Override
    public Work getWork() {
        return this;
    }

    @Override
    public void work() {
        System.out.println("Work 333 ");
    }
}

最后简单测试

public class FlowTodo {

    public static void main(String[] args) {
        FlowWork1 flowWork1 = new FlowWork1();
        flowWork1.execute();
        FlowWork2 flowWork2 = new FlowWork2();
        flowWork2.execute();
        FlowWork3 flowWork3 = new FlowWork3();
        flowWork3.execute();
    }

}

输出

Work 1111 
Work 2222 
Work 333 

总结

在日常工作中，我们下意识就会选择垂直拓展的方式，这会导致我们的代码一层套一层，有非常多层级的嵌套，让我们不能一眼看到实际的业务流程是什么样的，代码看起来非常难受，水平拓展的方式就能让我们一眼看到流程执行的具体步骤，而且灵活性更高，拓展起来非常地方便。是一种更好的选择。

Spring 的源码中也是大量采用水平拓展的方式，比如 SpringMVC 中 DispatcherServlet 的处理流程，