设计模式实例学习-责任链模式

设计模式实例学习-责任链模式

原创博客，转载请注明出处：
http://blog.csdn.net/u011035622/article/details/49853515

---

定义

概念定义：

（行为模式）

    使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连接成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
    我自己的理解定义：多个处理器对象之间权利存在上下级关系，当提交事件给处理器进行处理时，会交给最底下等级的处理器，它会根据事件的等级决定处理器是否有权利处理，没有的话就将事件提交到上一级的处理器，直到有人处理消费掉该事件。

角色职责

• 抽象处理器基类

• 具体处理器类

     如上定义所描述，会有多个处理器，不同处理器的处理权利不同或者说是能力不同，事件会提交给处理器后，处理器对事件等级进行判断，不能处理的事件会提交给上一级的处理器，直到找到能够处理该事件的处理器直接将事件消费。
  

• 事件提交者接口

• 具体事件提交者

     事件会有不同的等级，提交给处理器时处理器依据等级判断处理。
  

---

实例分析

场景描述

　　有三个请求事件，分别是请求参加班级春游，申请请假，申请奖学金。提交申请给班长，班长的上级是辅导员，辅导员的上级是校长。同学们只需将事件提交给班长，班长根据自己的能力处理，没有权利处理的请求就提交给辅导员，辅导员也是如此，辅导员无法处理的就提交给校长。

代码实现及讲解

• 抽象处理器基类 Handler.java

  public abstract class Handler {
  public final static int MONITOR_REQUEST = 1;
  public final static int INSTRUCTOR_REQUEST = 2;
  public final static int PRINCIPAL_REQUEST = 3;
  
  private int level = 0;//等级
  private Handler parentHandler;//比自己高一级的Handler
  
  public Handler(int level) {
      this.level = level;
  }
  
  public final void HandleMessage(ISomethingReq request){
      if(request.getRequestLevel() == this.level){
          this.response(request);
      }else {
          if(null != parentHandler){
              System.out.println("决定不了，上报给我的上级");
              parentHandler.HandleMessage(request);
          }else {
              System.out.println("已到顶级，无人能处理。");
          }
      }
  }
  //设置父处理器
  public void setParentHandler(Handler parentHandler){
      this.parentHandler = parentHandler;
  }
  protected abstract void response(ISomethingReq request);
  }

  • [x] 构造方法：定义自己的等级。
  • [x] HandleMessage：对事件进行处理
  • [x] setParentHandler：设置自己的上级处理器
  • [x] response：抽象的处理方法由具体类去实现

-

• 具体处理器类

MonitorHandler.java 班长处理器

public class MonitorHandler extends Handler {

    public MonitorHandler() {
        super(MONITOR_REQUEST);
    }

    @Override
    protected void response(ISomethingReq request) {
        System.out.println(request.getRequest() + "\n班长表示同意。");
    }
}

InstructorHandler.java 辅导员处理器

public class InstructorHandler extends Handler{

    public InstructorHandler() {
        super(INSTRUCTOR_REQUEST);
    }

    @Override
    protected void response(ISomethingReq request) {
        System.out.println(request.getRequest() + "\n辅导员表示同意。");
    }
}

PrincipalHandler.java 校长处理器

public class PrincipalHandler extends Handler{

    public PrincipalHandler() {
        super(PRINCIPAL_REQUEST);
    }

    @Override
    protected void response(ISomethingReq request) {
        System.out.println(request.getRequest() + "\n校长表示同意。");
    }
}

• 事件提交接口 ISomethingReq.java

public interface ISomethingReq {
    int getRequestLevel();
    String getRequest();
}

• [x] getRequestLevel：获取事件请求的等级

• [x] getRequest：获取请求内容

• 具体事件提交接口 SomethingReq.java

public class SomethingReq implements ISomethingReq{
    //定义请求的等级
    private int level = 0;

    private String request = "";

    public SomethingReq(int level, String request) {
        this.level = level;
        this.request = request;
    }

    @Override
    public int getRequestLevel() {
        return level;
    }

    @Override
    public String getRequest() {
        return this.request;
    }

}

• [x] 构造方法中定义请求等级及请求内容。

• [x] 实现接口中的两个方法，说明参考接口类。

• 场景类

package chainOfResponsibility;

public class Main {
    public static void main(String[] args) {
        MonitorHandler mHandler = new MonitorHandler();//班长
        InstructorHandler iHandler = new InstructorHandler();//辅导员
        PrincipalHandler pHandler = new PrincipalHandler();//校长
        //建立父级关系
        mHandler.setParentHandler(iHandler);
        iHandler.setParentHandler(pHandler);
        //实例化事件
        SomethingReq CYReq = new SomethingReq(1, "我想参加班级春游。");
        SomethingReq QJReq = new SomethingReq(2, "我要请假一天不上课。");
        SomethingReq JXJReq = new SomethingReq(3, "我要申请国家励志奖学金。");
        //将事件提交给班长进行处理
        mHandler.HandleMessage(CYReq);
        System.out.println("---------------------");
        mHandler.HandleMessage(QJReq);
        System.out.println("---------------------");
        mHandler.HandleMessage(JXJReq);
    }
}

输出：

我想参加班级春游。
班长表示同意。
---------------------
决定不了，上报给我的上级
我要请假一天不上课。
辅导员表示同意。
---------------------
决定不了，上报给我的上级
决定不了，上报给我的上级
我要申请国家励志奖学金。
校长表示同意。

　　第一个事件班级春游，因为参加班级春游是班长可以决定的，班长直接将事件消费，不用提交到父级处理器。
　　第二个事件请假，班长不能审批，需要辅导员的审批才能通过，因此提交到辅导员处理器消费事件。
　　第三个事件奖学金申请，提交事件给班长，班长接受事件后没有权利处理，提交给班长的父级，即辅导员，辅导员也没办法处理，继续提交给辅导员的父级，即校长，校长能够审核，因此在校长处理器中将事件消费了。

---

责任链模式的优缺点

优点

　　将事件请求和处理分开，请求者不需要知道谁是处理器，不需要了解处理器的内部实现。两者解耦，提高了系统的灵活性。

缺点

　　因为处理器传递时需要一级一级的往上传递事件，当处理器等级比较多时可能导致事件传递上耗时，引起性能问题（但一般比较少），具体情况具体分析。