使编程更有灵活性-责任链模式
模式简介
定义：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
使用场景
多个对象可以处理同一请求，但由哪个对象处理则在运行时动态决定。
在请求处理者不明确的情况下向多个对象中的一个提交一个请求。
需要动态指定一组对象处理请求。
简单实现
Leader抽象类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package ChainOfResponsMode;
public abstract class Leader {
protected Leader nextHandler;//上一级领导处理者
//处理报账请求
public final void handlerRequest(int money){
if(money <= limit()){
handler(money);
}else{
if(null!=nextHandler){
nextHandler.handlerRequest(money);
}
}
}
//自身能批复的额度权限
public abstract int limit();
//处理报账行为
public abstract void handler(int m);
}
|
组长类
1
2
3
4
5
6
7
8
9
|
public class GroupLeader extends Leader {
public int limit() {
return 1000;
}
public void handler(int m) {
System.out.println("组长批复"+m+"元");
}
}
|
主管类
1
2
3
4
5
6
7
8
9
10
11
|
package ChainOfResponsMode;
public class Director extends Leader {
public int limit() {
return 5000;
}
public void handler(int m) {
System.out.println("主管批复"+m+"元");
}
}
|
经理类
1
2
3
4
5
6
7
8
9
10
11
|
package ChainOfResponsMode;
public class Manager extends Leader {
public int limit() {
return 10000;
}
public void handler(int m) {
System.out.println("经理批复"+m+"元");
}
}
|
老板类
1
2
3
4
5
6
7
8
9
10
11
|
package ChainOfResponsMode;
public class Boss extends Leader {
public int limit() {
return Integer.MAX_VALUE;
}
public void handler(int m) {
System.out.println("老板批复"+m+"元");
}
}
|
**
**
测试类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package ChainOfResponsMode;
public class Client {
public static void main(String[] args) {
GroupLeader groupLeader=new GroupLeader();
Director director=new Director();
Manager manager=new Manager();
Boss boss=new Boss();
//设置责任链
groupLeader.nextHandler=director;
director.nextHandler=manager;
manager.nextHandler=boss;
//发起报账申请
groupLeader.handlerRequest(5000);
}
}
|
执行结果
总结
优点：
可以对请求者和处理者关系解耦，提高代码的灵活性。
缺点：
最大缺点是对链中请求处理者的遍历，如果处理者太多那么遍历必定会影响性能，特别是在一些递归调用中，要慎重。