设计模式.责任链模式 Responsibility Pattern

定义

责任链模式是一种对象的行为模式。

在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

场景

1. 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
2. 你想在不明确指定接受者的情况下，想过个对象中的一个提交一个请求。
3. 可处理一个请求的对象集合应该被动态指定。

类图

 

说明：责任链的类图不是固定的，只需要体现是使用链式结构来处理数据即可。

方法：

1. 构建责任处理链
2. 处理方法需要满足一定的条件才进行处理
3. 如果不满足条件则使用下一次Handler来处理，如果有下一个Handler。否则返回
4. 责任链重要的是处理的条件的边界的划分

实现

	Handler接口
public interface Handler {
    //处理接口，Params只是一个参数的实体类
    public void handle(Params param);
    /*
     * 设置下一个责任链
     * 这种方式是链表类型，也有使用数组方式，使用下标进设置处理顺序
     */
    public void setHandler(Handler handler);
}
	Handler抽象类
public abstract class AbstractHandler implements Handler {
    //存储下一个节点的指针
    private Handler nextHandler;
    public void handle(Params param) {
       if(checkCondition(param)){ //如果符合条件就执行自己的方法
          exec(param);
       }else if(nextHandler != null){//不符合条件就判断NextHandler是否为空
           nextHandler.handle(param);
       }else{//直到最后也没找到一个符合条件的Handler来处理
           System.out.println("没有合适Handler来处理 ：" + param.getAccount());
       }
    }
    public void setHandler(Handler handler) {
      this.nextHandler = handler;
    }
    /**
     * 根据条件判断是否需要改Handler来处理
     */
    public abstract boolean checkCondition(Params param);
    /**
     * 进行处理的逻辑
     */
    public abstract void exec(Params param);
}
	具体处理类
public class MyHandler1 extends AbstractHandler {
    public boolean checkCondition(Params param) {
        return param != null && param.getAccount() < 1000;
    }
    public void exec(Params param) {
        System.out.println("Handler1 处理 ：" + param.getAccount());
    }
}
	具体处理类
public class MyHandler2 extends AbstractHandler {
    public boolean checkCondition(Params param) {
        return param != null 
            && param.getAccount() >= 1000 
            && param.getAccount() < 3000;
    }
    public void exec(Params param) {
        System.out.println("Handler2 处理 ：" + param.getAccount());
    }
}
	调用示例
public class Test1 {
    public static void main(String[] args) {
        Handler h1 = new MyHandler1();
        Handler h2 = new MyHandler2();
        
        //构建责任链
        h1.setHandler(h2);
        
        //执行操作
        Params param = new Params();
        param.setAccount(10000d);
        h1.handle(param );
    }
}

适用场景

1. 请求和处理解耦

2. 处理联调可以扩展自定义方法

3. 部分不需要了解全部的处理逻辑，从代码层面做了分离

4. 性能会受到影响，特别是链比较长的时候，因此需要控制链的最大节点数量，一般通过在handler中设置一个最大的节点数量，在setNext()方法中判断是否已经超过了阀值，超过则不允许该链建立，避免超过超长链无意识破坏系统性能

5. 最佳应用场景：有多个对象可以处理同一个请求时，比如：多级请求，请假/加薪等审批流程