责任链模式介绍
责任链模式：为了降低请求发出者与处理者之间的耦合，使多个处理者都能有机会处理该请求，我们把这些处理者全部联成一个链，每个处理者是一个节点，把请求从链一端开始顺序执行，最终找到可以处理请求的节点，接受到请求的节点可以选择处理或者交给下一个节点去处理。
举例描述
举个栗子（假设面试是层层筛选这种方式）：Android程序员出去公司面试，首先来了个Android Leader先面试，水平不够直接让回去了，通过就进入下一轮技术总监的面试；技术总监面试之后，如果不通过也直接让回去了，通过之后进入部门主管面试；主管面试完不通过也是直接让回去，通过之后就进入最后一轮老板的面试；老板面试没通过也让回去了，凉凉，面试通过之后就可以顺利入职了。
这里我们抽象一下这个场景，每个程序员都有个技能Level，每个领导都有筛选得Level标准和上级。
抽象出一个程序猿不管是Android还是H5、iOS
/**
* 求职者
*/
abstract public class Programer {
/**
* 技能水平
* @return
*/
abstract int getLevel();
/**
* 获取面试结果
*/
abstract String result();
/**
* 设置面试结果
*/
abstract void setResult(String result);
}
实现一个Android程序猿：
public class AndroidDeveloper extends Programer {
private int level = 0;
private String result = "未知";
public AndroidDeveloper(int level) {
this.level = level;
}
@Override
int getLevel() {
return level;
}
@Override
String result() {
return result;
}
@Override
public void setResult(String result) {
this.result = result;
}
}
面试者先提取一个抽象接口，面试的行为：
/**
* 面试行为
*/
public interface InterViewer {
void interView(Programer programer);
}
实现一个统一称为领导的类
abstract public class Leader implements InterViewer {
public int requestLevel; //要求程序员的技术水平
public Leader superLeader; //上级领导是谁
public Leader(int requestLevel) {
this.requestLevel = requestLevel;
}
public void setSuperLeader(Leader superLeader) {
this.superLeader = superLeader;
}
}
实现几个领导
Android大佬：
public class AndroidLeader extends Leader {
public AndroidLeader(int requestLevel) {
super(requestLevel);
}
@Override
public void interView(Programer programer) {
//程序猿水平不符合要求的水平pass, 符合的话进入下一轮面试
if (programer.getLevel() < requestLevel){
System.out.println("AndroidLeader：pass");
//被pass掉需要给个结果吧
programer.setResult("AndroidLeader: not good pass !!!");
} else {
System.out.println("AndroidLeader: ok");
if (superLeader != null){
//合格之后交给下一轮面试官处理
superLeader.interView(programer);
}
}
}
}
CTO大佬：
public class CTOLeader extends Leader {
public CTOLeader(int requestLevel) {
super(requestLevel);
}
@Override
public void interView(Programer programer) {
if (programer.getLevel() < requestLevel){
System.out.println("CTOLeader：pass");
programer.setResult("CTOLeader: not good pass !!!");
} else {
System.out.println("CTOLeader: ok");
if (superLeader != null){
superLeader.interView(programer);
}
}
}
}
部门主管大佬：
public class MajorLeader extends Leader {
public MajorLeader(int requestLevel) {
super(requestLevel);
}
@Override
public void interView(Programer programer) {
if (programer.getLevel() < requestLevel){
System.out.println("MajorLeader：pass");
programer.setResult("MajorLeader: not good pass !!!");
} else {
System.out.println("MajorLeader: ok");
if (superLeader != null){
superLeader.interView(programer);
}
}
}
}
大Boss：
public class BossLeader extends Leader {
public BossLeader(int requestLevel) {
super(requestLevel);
}
@Override
public void interView(Programer programer) {
if (programer.getLevel() < requestLevel){
System.out.println("BossLeader：pass");
programer.setResult("BossLeader: not good pass !!!");
} else {
System.out.println("BossLeader: ok");
programer.setResult("BossLeader: congratulation, come here !");
if (superLeader != null){
superLeader.interView(programer);
}
}
}
}
测试一下：
//来了个Android程序猿
Programer programer = new AndroidDeveloper(5);
//一脸懵逼不知道面试咋样呢
System.out.println("result = " + programer.result());
//前面这么多大佬都等着跟他面试
Leader leader = new AndroidLeader(4);
Leader cto = new CTOLeader(5);
Leader major = new MajorLeader(6);
Leader boss = new BossLeader(7);
//设置上级关系，boss没有上级，了解一下
leader.setSuperLeader(cto);
cto.setSuperLeader(major);
major.setSuperLeader(boss);
//个Android领导来面试了，不说了啊
leader.interView(programer);
//面试完了，结果出来了
System.out.println("result = " + programer.result());
这个Android程序猿技能Level为5，没能通过部门主管的要求，sorry，凉凉。
result = 未知
AndroidLeader: ok
CTOLeader: ok
MajorLeader：pass
result = MajorLeader: not good pass !!!
换个Level为8的Android程序猿面试看看：
result = 未知
AndroidLeader: ok
CTOLeader: ok
MajorLeader: ok
BossLeader: ok
result = BossLeader: congratulation, come here !
顺利拿到offer，走上人生巅峰。
总结
1、请求发起者与请求处理者之间解耦，发起者并不知道后面会有哪些处理者，也不知道到哪个处理者会处理请求，同样的处理者也不用关心发起者是谁，到达解耦得目的。
2、新增一个处理者只需要添加一个对象，并添加到链上即可，符合Java开闭原则。
3、每个处理者只需要按着自己的需求去选择处理或者不处理请求，某个节点的处理逻辑方便修改。
4、这种模式如果节点过多的话，每次请求都会循环调用多层，导致性能比较低。
