设计模式--责任链模式

1. 责任链模式： 避免请求接受者和发送者耦合在一起，让多个对象都可以接受请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

2. 客户端和处理者都没有对方的明确信息，处理者也不知道责任链中的结构。责任链可以简化对象的相互连接，他们只保存一个指向其后续处理者的引用。客户提交请求后，请求沿着链往下传递直到有一个请求处理者处理为止。

3. 在责任链模式中我们可以随时随地的增加或者更改一个处理者，甚至可以更改处理者的顺序，增加了系统的灵活性。但是有可能导致某些请求得不到处理，它会被放置在链末端，这个即是责任链模式的优点也是责任链模式的缺点。

4. 责任链模式UML图

   

5. handler:抽象的处理者，定义了一个处理请求的方法，所有的处理者都必须实现该抽象类。

6. ConcreteHandler具体处理者，处理它所负责的请求，同时也可以访问它的后继者。如果它能够处理该请求则进行处理，否则将请求传递给它的后继者。client：客户端

7. 责任链模式的代码实现

   1. 创建一个请求类

      /**
       * 请假请求类
       */
      public class LeaveRequest {
      
          private String name;
          private Integer dayNum;
          private String reason;
      
          public LeaveRequest(String name, Integer dayNum, String reason) {
              this.name = name;
              this.dayNum = dayNum;
              this.reason = reason;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public Integer getDayNum() {
              return dayNum;
          }
      
          public void setDayNum(Integer dayNum) {
              this.dayNum = dayNum;
          }
      
          public String getReason() {
              return reason;
          }
      
          public void setReason(String reason) {
              this.reason = reason;
          }
      
      }
      
      

   2. 创建一个抽象处理类

      /**
       * 请假请求处理抽象类
       */
      public abstract class AbstractBoss {
      
          String bossName;  //职位
      
          AbstractBoss nextBoss; //下一个节点
      
          public AbstractBoss(String bossName) {
              this.bossName = bossName;
          }
      
          public void setNextBoss(AbstractBoss nextBoss) {
              this.nextBoss = nextBoss;
          }
      
          //处理请求
          public abstract void handler(LeaveRequest leaveRequest);
      
      }
      

   3. 创建两个具体处理者类

      /**
       * 组长
       */
      public class GroupBoss extends AbstractBoss {
      
          public GroupBoss(String bossName) {
              super(bossName);
          }
      
          @Override
          public void handler(LeaveRequest leaveRequest) {
              if(leaveRequest.getDayNum() <= 1){
                  System.out.println("组长批准" + leaveRequest.getName() + "请假，原因："+leaveRequest.getReason() +
                          ", 请假天数： "+leaveRequest.getDayNum());
              } else if(null != nextBoss){
                  this.nextBoss.handler(leaveRequest);
              } else {
      
              }
          }
      }
      
      

      /**
       * 经理
       */
      public class ManagerBoss extends AbstractBoss {
      
          public ManagerBoss(String bossName) {
              super(bossName);
          }
      
          @Override
          public void handler(LeaveRequest leaveRequest) {
              if(leaveRequest.getDayNum() <= 3){
                  System.out.println("经理批准" + leaveRequest.getName() + "请假，原因："+leaveRequest.getReason() +
                          ", 请假天数： "+leaveRequest.getDayNum());
              } else if(null != nextBoss){
                  this.nextBoss.handler(leaveRequest);
              } else {
      
              }
          }
      }
      

   4. 创建一个测试类

      public class Test {
          public static void main(String[] args) {
              AbstractBoss boss = new GroupBoss("组长张三");
      
              AbstractBoss manager = new ManagerBoss("李四经理");
              boss.setNextBoss(manager);
              LeaveRequest request = new LeaveRequest("小张", 1, "逛街");
      
      
              boss.handler(request);
          }
      }
      

8. 责任链模式的优点

   1. 降低耦合度，将请求的发送者和处理者解耦
   2. 简化了对象，使得对象不需要知道链的结构
   3. 增强给对象指派责任的灵活性。通过改变链内的成员或调动他们的次序，允许动态的增加或者删除责任
   4. 增加新的请求处理类很方便

9. 责任链模式的缺点

   1. 不能保证请求一定会被处理
   2. 系统性能将受到一定的影响，并且在代码调试的时候不太方便，可能会造成循环调用
   3. 不容易观察运行时的特征

10. JDK中使用的地方