注意
本文最后更新于 2023-12-13，文中内容可能已过时。
流程设计思路
两种流程设计方式
垂直拓展
废话不多说，直接代码演示
工作接口 Work
1
2
3
4
5
|
public interface Work {
void work();
}
|
三个实现类
1
2
3
4
5
6
7
|
public class Work1 implements Work {
@Override
public void work() {
System.out.println("work 1 ");
}
}
|
1
2
3
4
5
6
7
|
public class Work2 implements Work {
@Override
public void work() {
System.out.println("work 2 ");
}
}
|
1
2
3
4
5
6
7
|
public class Work3 implements Work {
@Override
public void work() {
System.out.println("work 3 ");
}
}
|
然后用一个服务类（其实就是一个包装类）来封装了 Work 的实现，想要获取 Work 的实现就只能通过这个服务类，这也是垂直设计的精髓。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
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();
}
}
}
|
流程执行时
1
2
3
4
5
6
7
8
9
10
|
public class FlowTodo {
public static void main(String[] args) {
WorkService ws = new WorkService();
ws.run("1");
ws.run("2");
ws.run("3");
}
}
|
输出
1
2
3
|
work 1
work 2
work 3
|
水平拓展
复用上面的 Work 接口，创建一个流程执行抽象类，这个抽象类中并不包含具体的 Work 实现，而是定义了抽象方法，让子类去实现，而且我们可以自定义添加步骤，删除步骤，非常灵活，
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public abstract class FlowAbstract {
/**
* 执行流程
*/
public void execute() {
// 获取工作方法
getWork().work();
// 灵活添加其他步骤
// other work 1
// other work 2
}
public abstract Work getWork();
}
|
流程实现类
1
2
3
4
5
6
7
8
9
10
11
|
public class FlowWork1 extends FlowAbstract implements Work {
@Override
public Work getWork() {
return this;
}
@Override
public void work() {
System.out.println("Work 1111 ");
}
}
|
1
2
3
4
5
6
7
8
9
10
11
|
public class FlowWork2 extends FlowAbstract implements Work {
@Override
public Work getWork() {
return this;
}
@Override
public void work() {
System.out.println("Work 2222 ");
}
}
|
1
2
3
4
5
6
7
8
9
10
11
|
public class FlowWork3 extends FlowAbstract implements Work {
@Override
public Work getWork() {
return this;
}
@Override
public void work() {
System.out.println("Work 333 ");
}
}
|
最后简单测试
1
2
3
4
5
6
7
8
9
10
11
12
|
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();
}
}
|
输出
1
2
3
|
Work 1111
Work 2222
Work 333
|
总结
在日常工作中，我们下意识就会选择垂直拓展的方式，这会导致我们的代码一层套一层，有非常多层级的嵌套，让我们不能一眼看到实际的业务流程是什么样的，代码看起来非常难受，水平拓展的方式就能让我们一眼看到流程执行的具体步骤，而且灵活性更高，拓展起来非常地方便。是一种更好的选择。
Spring 的源码中也是大量采用水平拓展的方式，比如 SpringMVC 中DispatcherServlet的处理流程，
小虾米