行为型模式：责任链模式

定义：责任链模式(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.

---

一般责任链的模式的缺陷：需要设置每个handler的从属关系，当handler多起来的时候就会很麻烦，需要不断修改，增加扩展困难。

因此，解决方案是维护一个列表，将所有的责任链放在这个集合，通过 不断地遍历这个列表，取出Handler进行doHandle;

首先，写一个chain类

import java.util.List;

public class Chain {

    private List<ChainHandler> handler;

    public Chain(List<ChainHandler> handler) {
        this.handler = handler;
    }
    private int  index = 0;

    public void doIndex(){
        if(index>=handler.size()){
            return;
        }
        handler.get(index++).execte(this);
    }
}

 

再写一个抽象类ChainHandler，给出抽象方法

public abstract class ChainHandler {

    protected abstract  void handleProcess();

    public void execte(Chain chain){
        handleProcess();
        chain.doIndex();
    }
}

写Client类：

import java.util.Arrays;
import java.util.List;

public class ChainClient {

    static class a extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("a  do");
        }
    }

    static class b extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("b  do");
        }
    }


    static class c extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("c  do");
        }
    }


    public static void main(String[] args) {

        List<ChainHandler> list = Arrays.asList(
              new a(),new b(),new c()        );

        Chain chain = new Chain(list);
        chain.doIndex();

    }
}

按照插入序打印：

a do

b do

c do