一、定义

定义 : 为了避免请求的发送者和接收者之间的耦合关系，使多个接受对象都有机会处理请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。责任链模式是一种对象行为型模式。

由定义上可以看出，责任链模式就是将一堆可以处理请求的对象连成一条链，然后一个一个试着处理请求。

二、责任链模式的结构

image

在责任链模式结构图中包含如下几个角色：

Handler（抽象处理者）：定义一个处理请求的接口，一般为抽象类，请求处理方法为抽象方法，不同的具体处理者实现具体的请求处理。因为每一个处理者的下家还是一个处理者，因此在抽象处理者中定义了一个抽象处理者类型的对象，作为其对下家的引用。通过该引用，处理者可以连成一条链。

ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。

三、经典模式的实现

1.定义AbstractHandler（抽象处理者），使子类形成一条链

public abstract class AbstractHandler {
    private AbstractHandler handler;

    public abstract void handleRequest(String condition);

    public AbstractHandler getHandler() {
        return handler;
    }

    public void setHandler(AbstractHandler handler) {
        this.handler = handler;
    }
}

2.创建若干个ConcreteHandler（具体处理者）继承AbstractHandler，在当前处理者对象无法处理时，将执行权传给下一个处理者对象

public class ConcreteHandlerA extends AbstractHandler {

    @Override
    public void handleRequest(String condition) {
        if (condition.equals("A")) {
            System.out.println("ConcreteHandlerA处理");
        } else {
            System.out.println("ConcreteHandlerA不处理，由其他的Handler处理");
            super.getHandler().handleRequest(condition);
        }
    }
}

public class ConcreteHandlerB extends AbstractHandler {

    @Override
    public void handleRequest(String condition) {
        if (condition.equals("B")) {
            System.out.println("ConcreteHandlerB处理");
        } else {
            System.out.println("ConcreteHandlerB不处理，由其他的Handler处理");
            super.getHandler().handleRequest(condition);
        }
    }
}

public class ConcreteHandlerZ extends AbstractHandler {
    @Override
    public void handleRequest(String condition) {
        //一般是最后一个处理者
        System.out.println("ConcreteHandlerZ处理");
    }
}

3.创建ChainClient（测试类）

public class ChainClient {

    public static void main(String[] args) {
        AbstractHandler handlerA = new ConcreteHandlerA();
        AbstractHandler handlerB = new ConcreteHandlerB();
        AbstractHandler handlerZ = new ConcreteHandlerZ();
        // 如A处理不掉转交给B
        handlerA.setHandler(handlerB);
        handlerB.setHandler(handlerZ);
        handlerA.handleRequest("Z");
    }
}

4.运行效果

----------------------handleRequest("A")-------------------------
ConcreteHandlerA处理
----------------------handleRequest("B")-------------------------
ConcreteHandlerA不处理，由其他的Handler处理
ConcreteHandlerB处理
----------------------handleRequest("Z")-------------------------
ConcreteHandlerA不处理，由其他的Handler处理
ConcreteHandlerB不处理，由其他的Handler处理
ConcreteHandlerZ处理

纯与不纯

• 纯：一个纯的责任链模式要求：

1.一个具体处理者对象只能在“处理请求”和“转发请求”中两选一。

2. 一个请求必须被某一个处理者对象所接收，不能出现某个请求未被任何一个处理者对象处理的情况。

• 不纯：在一个不纯的责任链模式中则允许：

1. 一个请求应该被所有的对象处理，直到某一个处理失败。（例如下面分析校验模块）
2. 或者一个具体处理者处理完某请求后其后继处理者可以继续处理该请求。（dubbo filter）
3. 或者一个请求可以最终不被任何处理者对象所接收。

纯的责任链模式的实际例子很难找到，一般看到的例子均是不纯的责任链模式的实现。

不纯的实现案列

背景：最近在梳理一块业务，目前面临的一个问题是数据入库前需要做很多校验操作，例如：

1. 查询数据库判断数据是不是已经存在;
2. rpc调用别的服务判断某个字段是都有效
3. 等等

如果所有校验代码写在一个方法中感觉太臃肿，可读性太差，不易扩展。现在准备使用不纯的责任链模式重构一版本。根据不同的校验条件抽出来不同的校验类。
既然是校验操作，所有的校验组成一条链，请求挨个校验，直到有一个校验失败，或者全部校验成功才会终止。

1.定义Verify（抽象处理者，使子类形成一条链

public interface Verify {

    Message doVerity(AddForm form);

}

2.创建若干个Verify实现者（具体处理者）继承AbstractHandler，在当前处理者处理成功后，继续往下处理

@Service
@Order(1)
public class VerifyA implements Verify {
    @Override
    Message doVerity(AddForm form) {
        //执行自己的校验逻辑
        boolean isPass = xxxxxA();
        if (isPass) {
            return Message.ok();
        } else {
            return Message.error(RstStatus.invalidParameter, "校验不通过的原因");
        }
    }
}

@Service
@Order(2)
public class VerifyB implements Verify {
    @Override
    Message doVerity(AddForm form) {
        //执行自己的校验逻辑
        boolean isPass = xxxxxB();
        if (isPass) {
            return Message.ok();
        } else {
            return Message.error(RstStatus.invalidParameter, "校验不通过的原因");
        }
    }
}

             VerifyC
             VerifyD
              ...

3.spring 环境下调用责任链

 /**
     * IOC 自动组成所有实现类的调用链
     * 实现类可通过@Order进行排序
     * **/
    @Resource
    private List<Verify> verifyList;

    public Message isParamValid(AddForm addForm) {
        if (CollectionUtils.isEmpty(verifyList)) {
            return Message.ok();
        }
        for (Verify verify : verifyList) {
            Message message = verify.doVerity(addForm);
            //校验通过继续循环
            if (RstStatus.ok.getCode() == message.getCode()) {
                continue;
            }
            //失败直接返回
            return message;
        }
    }

好处

• 在给对象分派职责时，职责链可以给我们更多的灵活性，可以通过在运行时对该链进行动态的增加或修改来增加或改变处理一个请求的职责。
• 弱化了发出请求的人和处理请求的人之间的关系
  发出请求的人只需要向第一个具体的处理者发送请求，然后就可以不用管了，处理者会在责任链上自己寻找处理的方法。
  这样就解耦了处理者和请求者之间的关系。
• 可以动态的改变责任链
  责任链还有的好处就是可以动态的改变责任，删除或者添加或者改变顺序。