为了防止被“杀”了祭天,学点设计模式,并总结下还是有必要的。
一:理解
- 在责任链模式中,对象通过对另一个对象的引用而连接形成一条链。调用方的请求可以在链上传递,直到找到满足要求的处理对象,或者走完整个链。
- 责任链将调用方和服务方进行解耦,调用方无需知道服务方内部的逻辑。
- Tomcat的过滤器链FilterChain中使用了责任链模式。
二:例子
你是个富二代。
你爸给了你5个亿让你玩投资。
虽然你贵为富二代,不过一下子给你5个亿,你还是略略有点触不及防的。
于是,你开始满世界的招管理人员辅助你投资,准备大干一番。
准备大干一番你还叫来了程序员小菜帮你抽象一下投资工资的员工管理问题。
小菜上来就是一顿敲。
为了对员工的行为进行约束,他首先新建了一个抽象经理类Manager。
Manager类中只有一个方法handleInvestment,即处理投资。
@Data
public abstract class Manager {
public abstract void handleInvestment(long amount);
}
接着,小菜新建了不同级别的经理,有一级,二级,三级管理人员,当然你是最高级别的经理。
他们都继承自Manager抽象类。他们处理投资的方法各不一样,为了方便举例,只输出一句话。
// 一级经理
public class AManager extends Manager {
@Override
public void handleInvestment(long amount) {
System.out.println("一级已经处理");
}
}
// 二级经理
public class BManager extends Manager {
@Override
public void handleInvestment(long amount) {
System.out.println("二级经理已经处理");
}
}
// 三级经理
public class CManager extends Manager {
@Override
public void handleInvestment(long amount) {
System.out.println("三级经理已经处理");
}
}
// 你,最高级经理
public class You extends Manager {
@Override
public void handleInvestment(long amount) {
System.out.println("厂长亲自处理");
}
}
作为一个大公司,你不希望所有的投资都直接找你谈,你只谈大项目,于是你规定:
- 投资金额小于等于一万元,一级经理直接处理。
- 投资金额在一万元到十万元之间,二级经理直接处理。
- 投资金额在十万元到一百万元之间,三级经理直接处理。
- 投资金额超过一百万元,你亲自处理。
于是,小菜写了以下的测试代码:
public class Client {
public static void main(String[] args) {
Manager aManager = new AManager();
Manager bManager = new BManager();
Manager cManager = new CManager();
Manager you = new You();
int amount = 99999;
if (amount <= 10000) {
aManager.handleInvestment(amount);
} else if (amount <= 100000) {
bManager.handleInvestment(amount);
} else if (amount <= 1000000) {
cManager.handleInvestment(amount);
} else {
you.handleInvestment(amount);
}
}
}
输入/输出:
二级经理已经处理
投资公司顺利地开起来了,你也很开心。
一段时间之后,创业者们纷纷反映很难可以找到对接的经理。
因为创业者需要根据自己项目所需的金额,找到对应的投资人。
创业者在发起请求之前,需要在一堆if else中找到符合要求的经理。
作为高富帅,你觉得让投资者自己了解整个游戏规则,并且徜徉在if else的海洋里,翻过山和大海才能得到投资,很符合你高贵的身份。
然而,毕竟是第一次开公司,你还是决定让创业者们更方便一些。
你决定对公司做出调整,有以下两个方案:
- 专门设立一个咨询类接受投资者的请求,咨询类根据投资金额,将投资请求提交到对应的经理。
- 所有投资直接找一级经理。如果一级经理无权处理,往上申请,直到向你申请为止。
小菜惊讶于你竟然会产生这样的想法,表示book思议。
book思议然而在你的淫威下,小菜开始重构代码。
小菜认为,方案一需要多招至少一名员工,你那么大方,是肯定不会同意的。
于是,他决定尝试使用责任链模式来重构这个程序。
因为不同等级的经理有关联关系,并且调用呈链式关系,即一级到二级,二级到更上级,直到最上级。
小菜首先抽象出Manager类,Manager中有一个superior属性,该属性表示的是当前对象的上级。
superior也属于Manager类,因为经理的上级仍旧是一个经理。
@Data
public abstract class Manager {
private Manager superior;
public abstract void handleInvestment(long amount);
}
接着,小菜新建了一级经理,二级经理,三级经理和你对应的类。
// 一级经理
public class AManager extends Manager {
@Override
public void handleInvestment(long amount) {
if (amount <= 10000) {
System.out.println("一级经理已经处理");
return;
}
getSuperior().handleInvestment(amount);
}
}
// 二级经理
public class BManager extends Manager {
@Override
public void handleInvestment(long amount) {
if (amount <= 100000) {
System.out.println("二级经理已经处理");
return;
}
getSuperior().handleInvestment(amount);
}
}
// 三级经理
public class CManager extends Manager {
@Override
public void handleInvestment(long amount) {
if (amount <= 1000000) {
System.out.println("三级经理已经处理");
return;
}
getSuperior().handleInvestment(amount);
}
}
// 你,最高级经理
public class You extends Manager {
@Override
public void handleInvestment(long amount) {
System.out.println("厂长亲自处理");
}
}
和之前不同的是,当经理受到投资请求时,如果投资金额处于自己可处理范围内,则直接处理,return。
如果无权处理,则提交上级进行处理。
小菜写了一段测试代码:
public class Client {
public static void main(String[] args) {
Manager aManager = new AManager();
Manager bManager = new BManager();
Manager cManager = new CManager();
Manager you = new You();
aManager.setSuperior(bManager);
bManager.setSuperior(cManager);
cManager.setSuperior(you);
aManager.handleInvestment(9999);
aManager.handleInvestment(99999);
aManager.handleInvestment(999999);
aManager.handleInvestment(9999999);
}
}
输入/输出:
一级经理已经处理
二级经理已经处理
三级经理已经处理
厂长亲自处理
在经过责任链模式重构之后,整个投资过程变得很清晰,创业者无需再了解你司内部的逻辑,专心创业即可。
在例子中,责任链是单向的,即从下往上。
也可以构建双向责任链模式,请求者可以把请求发到链上的任意对象,再根据是否满足条件开始在链上传递。
小菜将重构后的代码给你看,你很开心。
当你得知这个模式叫责任链模式之后,你顿时觉得自己的投资公司非常有责任。
小菜也体验了一把有bear来的感觉。
有bear来
三:再理解
- 例子中通过在类中加入对上级的引用来构建调用链,其实也可以用额外的数据结构来保存这条链。事实上,Tomcat的FilterChain就用额外的数组来保存的。
- 责任链模式简化了很多if else逻辑,在需要扩展的时候,只需在链上加入新对象即可。
网友评论