为了防止被“杀”了祭天，学点设计模式，并总结下还是有必要的。
一：理解
- 在责任链模式中，对象通过对另一个对象的引用而连接形成一条链。调用方的请求可以在链上传递，直到找到满足要求的处理对象，或者走完整个链。
- 责任链将调用方和服务方进行解耦，调用方无需知道服务方内部的逻辑。
- 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思议。
然而在你的淫威下，小菜开始重构代码。
小菜认为，方案一需要多招至少一名员工，你那么大方，是肯定不会同意的。
于是，他决定尝试使用责任链模式来重构这个程序。
因为不同等级的经理有关联关系，并且调用呈链式关系，即一级到二级，二级到更上级，直到最上级。
小菜首先抽象出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来的感觉。
三：再理解
- 例子中通过在类中加入对上级的引用来构建调用链，其实也可以用额外的数据结构来保存这条链。事实上，Tomcat的FilterChain就用额外的数组来保存的。
- 责任链模式简化了很多if else逻辑，在需要扩展的时候，只需在链上加入新对象即可。
