定义
责任链模式是一种行为型模式，其定义为：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
优点：
- 降低了对象之间的耦合
- 增强了系统的可扩展性
- 对象指责指派比较灵活，当工作流程改变时，可以动态改变调动次序，也可以新增或者删除请求处理类
相较于if else 的优势：
- if else会造成代码臃肿
- 耦合度高，当我们要继续添加条件判断时，只能新增if else，同时，条件判定的顺序也是写死的，修改顺序比较麻烦
缺点：
- 不能保证每一个请求都能得到处理
- 错误的职责定义可能造成循环调用
代码实例
场景：生活中遇到的工作审批流，小王请假，根据请假天数，由不同的级别领导处理小王的请假请求，这样的一个请求经过多个处理器构成的责任链，直到处理成功。
抽象处理器类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
public abstract class AbstractHandler {
protected AbstractHandler nextHandler;
public static AbstractHandler link(AbstractHandler firstHandler, AbstractHandler... handleChain) {
AbstractHandler head = firstHandler;
for (AbstractHandler nextHandler : handleChain) {
head.nextHandler = nextHandler;
head = nextHandler;
}
return firstHandler;
}
public abstract boolean process(ReqTypeEnum type);
public boolean nextProcess(ReqTypeEnum type) {
if (nextHandler == null) {
return true;
} else {
return nextHandler.process(type);
}
}
}
|
请假的策略枚举
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
public enum ReqTypeEnum {
ONE("三天假以内", 0),
TWO("三天到五天", 1),
THREE("五天以上", 2);
private static final Integer level0 = 1;
private static final Integer level1 = 3;
private static final Integer level2 = 5;
private String desc;
private Integer code;
ReqTypeEnum(String desc, Integer code) {
this.desc = desc;
this.code = code;
}
public static ReqTypeEnum getEnumByDays(Integer days) {
if (days >= level0 && days <= level1) {
return ONE;
} else if (days <= level2) {
return TWO;
} else {
return THREE;
}
}
}
|
Leader处理类
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class Leader extends AbstractHandler {
@Override
public boolean process(ReqTypeEnum type) {
if (ReqTypeEnum.ONE.equals(type)) {
System.out.println("开发经理处理！");
return true; } else {
return nextProcess(type);
}
}
}
|
Manager处理类
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class Manager extends AbstractHandler {
@Override
public boolean process(ReqTypeEnum type) {
if (ReqTypeEnum.TWO.equals(type)) {
System.out.println("部门经理处理！");
return true; } else {
return nextProcess(type);
}
}
}
|
Boss处理类
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class Boss extends AbstractHandler {
@Override
public boolean process(ReqTypeEnum type) {
if (ReqTypeEnum.THREE.equals(type)) {
System.out.println("老板处理！");
return true; } else {
return nextProcess(type);
}
}
}
|
执行类
我是傻逼1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class ChainRespTest {
public static void main(String[] args) {
AbstractHandler boss = new Boss();
AbstractHandler leader = new Leader();
AbstractHandler manager = new Manager();
AbstractHandler firstHandler = AbstractHandler.link(leader, boss, manager);
firstHandler.process(ReqTypeEnum.getEnumByDays(1));
firstHandler.process(ReqTypeEnum.getEnumByDays(6));
firstHandler.process(ReqTypeEnum.getEnumByDays(5));
}
}
|
运行效果
