设计模式-------职责链模式

一 简介

定义：将能够处理同一类请求的对象连成一条链，使这些对象都有机会处理请求，所提交的请求沿着链传递。从而避免请求的发送者和接受者之间的耦合关系。链上的对象逐个判断是否有能力处理该请求，如果能则就处理，如果不能，则传给链上的下一个对象。直到有一个对象处理它为止。

使用场景：

• Java的异常机制就是一个责任链模式
• 打牌时，轮流出牌
• 接力赛跑
• 请假审批
• 公文审批

包括以下角色：

• 抽象处理者角色(Handler)：定义一个处理请求的接口。接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。
• 具体处理者角色(ConcreteHandler)：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，具体处理者可以访问下家。

二 实例

抽象处理者角色

public abstract class Handler {

   protected  Handler nextHandler;

   public  abstract  void  say();

   public abstract void handleRequest();


   protected   void  setNextHandler(Handler handler){
        this.nextHandler = handler;
    }

    public Handler getNextHandler() {
        return nextHandler;
    }
}

具体处理者（包含3个处理角色）

public class Handler1 extends Handler {
    @Override
    public void say() {
        System.out.println("Handler1");
    }

    @Override
    public void handleRequest() {
      if(this.nextHandler==null){
          System.out.println("由Handler1处理");
      }else {
          this.nextHandler.handleRequest();
      }
    }
}

public class Handler2 extends  Handler {
    @Override
    public void say() {
        System.out.println("Handler2");
    }

    @Override
    public void handleRequest() {
        if(this.nextHandler==null){
            System.out.println("由Handler2处理");
        }else {
            this.nextHandler.handleRequest();
        }
    }
}

public class Handler3 extends Handler {
    @Override
    public void say() {
        System.out.println("Handler3");
    }

    @Override
    public void handleRequest() {   //假设 Handler3 是最高级别的了，后面没有其他的处理者
        System.out.println("Handler3 处理");
    }
}

Demo

public class Demo {
    public static void main(String[] args) {
        Handler handler1 = new Handler1();
        Handler handler2 = new Handler2();
        Handler handler3 = new Handler3();

        System.out.println("-----Handler 1-----");
        handler1.handleRequest();

        System.out.println("-----Handler 2-----");
        handler1.setNextHandler(handler2);
        handler1.handleRequest();

        System.out.println("----Handler  3 -----");
        handler2.setNextHandler(handler3);
        handler1.handleRequest();

        System.out.println("--------Get Handler 1.next --------");
        handler1.getNextHandler().say();
        System.out.println("-------Get Handler 2.next ----");
        handler2.getNextHandler().say();


    }
}

结果：

-----Handler 1-----
由Handler1处理
-----Handler 2-----
由Handler2处理
----Handler  3 -----
Handler3 处理
--------Get Handler 1.next --------
Handler2
-------Get Handler 2.next ----
Handler3

实际应用中，一般还有有一个类来封装责任链，完成责任链的顺序编排，并返回链中的第一个处理者，这样上层逻辑就不再需要设置具体的责任链了，简化了上层逻辑，减少了模块间的耦合，系统也会更灵活。

优点

• 将请求者和处理者分开，两者解耦，提供系统灵活性。

缺点

• 请求都是从链头遍历到链尾，当链很长的时候，性能是个很大的问题。
• 一般我们可以在 Handler 中设置一个最大节点数量，在 setNext 方法中判断是否已经超过最大节点数，超过则不允许继续添加处理者，避免无意识的破坏系统性能。