行为型模式：责任链模式
定义：责任链模式(Chain of Responsibility)使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象能够处理它。
类型：行为类模式
考虑以下这样的场景：
责任链，顾名思义，这个责任（请求）层层传递，直到能被正确的承担（处理）
你要去给某公司借款 1 万元，当你来到柜台的时候向柜员发起 "借款 1 万元"的请求时，柜员认为金额太多，处理不了这样的请求，他转交这个请求给他的组长，组长也处理不了这样的请求，那么他接着向经理转交这样的请求。
用 Java 代码表示为：
publicvoidtest(Requestrequest) {
int money = request.getRequestMoney();
if(money<= 1000) {
Clerk.response(request);
}else if(money <= 5000) {
Leader.response(request);
}else if(money <= 10000) {
Manager.response(request);
}
}
代码的业务逻辑就是这样：根据的借款金额来判定谁来处理这个借款请求(request)
· 如果请求借款金额小于 1000 元，那么柜台职员就可以直接处理这个请求(比如签字)
· 如果请求借款金额小于 5000 元但大于 1000 元，那么职员处理不了，该请求转交给组长，组长能够处理这样的请求(比如签字)
· 如果请求借款金额大于 5000 元但小于 10000 元，那么职员和组长都处理不了(没有权限)，那么这个请求就会转交给经理，经理能够处理这样的请求(比如签字)
在编程中，这样处理业务逻辑的方法非常常见，这样的方法非常直观，简单明了，并且也比较容易维护，但是同时它也存在着着问题:
1. 代码臃肿:实际应用中的判定条件通常不是这么简单地判断金额，也许需要复杂的操作，也许需要查询数据库等等，这就会产生许多额外的代码，如果判断条件再比较多的话，那么代码就会大量地堆积在同一个文件中。
2. 耦合度高：如果我们想继续添加处理请求的类，那么就需要添加 else if 的判定条件；另外，这个条件判定的顺序也是写死的。如果想改变顺序，那么也只能修改这个条件语句。
下面就介绍责任链模式：
责任链模式的类图非常简单，如下图：
1. 抽象处理类:主要包含一个指向下一处理类的成员变量 nextHandler 和一个处理请求的方法 handRequest，handRequest 方法的主要思想是，如果满足处理的条件，则有本处理类来进行处理，否则由 nextHandler 来处理。(在抽象类中定义handRequest接口让具体处理类去实现)
2. 具体处理类：具体处理类的主要是对具体的处理逻辑和处理的适用条件进行实现。
了解完责任链的大体思想之后，在看看 Java 代码是如何实现的：
通常每个接收者都包含对另一个接收者的引用。
package design.responsibility;
public class LeaveRequest {
private String name;
private Integer day;
public LeaveRequest(String name, Integer day) {
this.name = name;
this.day = day;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getDay() {
return day;
}
public void setDay(Integer day) {
this.day = day;
}
}
public abstract class Leader {
protected String name;
protected Leader nextLeader;
public Leader(String name) {
this.name = name;
}
public void setNextLeader(Leader nextLeader) {
this.nextLeader = nextLeader;
}
public abstract void handlerequest(LeaveRequest request) ;
}
package design.responsibility;
public class Diector extends Leader {
public Diector(String name) {
super(name);
}
@Override
public void handlerequest(LeaveRequest request) {
if (request.getDay() < 3) {
System.out.println("经理批准");
} else {
this.nextLeader.handlerequest(request);
}
}
}
package design.responsibility;
public class Manager extends Leader {
public Manager(String name) {
super(name);
}
@Override
public void handlerequest(LeaveRequest request) {
if (request.getDay() < 10) {
System.out.println("老总批准");
} else {
this.nextLeader.handlerequest(request);
}
}
}
package design.responsibility;
public class GeneralManager extends Leader {
public GeneralManager(String name) {
super(name);
}
@Override
public void handlerequest(LeaveRequest request) {
if (request.getDay() < 30) {
System.out.println("董事长批准");
} else {
System.out.println("辞职吧");
}
}
}
package design.responsibility;
public class test {
public static void main(String[] args) {
Leader a = new Diector("小王");
Leader b = new Manager("大王");
Leader c = new GeneralManager("王炸");
a.setNextLeader(b);
b.setNextLeader(c);
LeaveRequest leaveRequest = new LeaveRequest("小红", 50);
a.handlerequest(leaveRequest);
}
}
再来理解一遍
责任链模式
顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式基于请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。
在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。
介绍
意图：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。
主要解决：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，
所以职责链将请求的发送者和请求的处理者解耦了。
何时使用：在处理消息的时候以过滤很多道。
如何解决：拦截的类都实现统一接口。
关键代码：Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。
应用实例：
1、红楼梦中的"击鼓传花"。 2、JS 中的事件冒泡。 3、JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。
优点： 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。
缺点： 1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。
使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。
注意事项：在 JAVA WEB 中遇到很多应用。
实现
我们创建抽象类 AbstractLogger，带有详细的日志记录级别。然后我们创建三种类型的记录器，都扩展了 AbstractLogger。每个记录器消息的级别是否属于自己的级别，如果是则相应地打印出来，否则将不打印并把消息传给下一个记录器。
步骤 1
创建抽象的记录器类。
AbstractLogger.java
步骤 2
创建扩展了该记录器类的实体类。
ConsoleLogger.java
ErrorLogger.java
FileLogger.java
步骤 3
创建不同类型的记录器。赋予它们不同的错误级别，并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。
ChainPatternDemo.java
步骤 4
执行程序，输出结果：
Standard Console::Logger: This is an information.
File::Logger: This is an debug level information.
Standard Console::Logger: This is an debug level information.
Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.