补-设计模式之责任链模式(十一)

2022-10-28 本文已影响0人 3d0829501918

小明是一家公司的员工，因明天有事，需要进行请假，可批假的领导有部门负责人、副总经理、总经理等。请2天以下部门负责人可以直接处理，如果请4天以下的副总经理可以处理，请6天以下就需要总经理处理。这也是一个设计模式的体现，那就是责任链模式。

责任链模式（Chain of Responsibility）使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系，将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。（注：责任链模式也叫职责链模式）

抽象处理者（Handler）角色
定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
具体处理者（Concrete Handler）角色
实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
客户类（Client）角色
创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

类图

抽象处理者

public abstract class Handler {

protected Handler successor;

public void setSuccessor(Handler successor) {
    this.successor = successor;
}

public abstract void HandleRequest (int request) ;

}

具体处理者

public class ConcreteHandler1 extends  Handler {

@Override
public void HandleRequest(int request) {
    if (request >= 0 && request <10) {
        System.out.println("ConcreteHandler1处理请求"+request);
    } else if (successor != null) {
        // 让下一个负责人继续处理
        successor.HandleRequest(request);
    }
}
}

public class ConcreteHandler2 extends Handler {
    @Override
    public void HandleRequest(int request) {
         if (request >= 10 && request<20) {
             System.out.println("ConcreteHandler2处理请求："+request);
         } else if (successor !=null) {
             successor.HandleRequest(request);
         }
    }
}

public class ConcreteHandler3 extends  Handler {
      @Override
      public void HandleRequest(int request) {
          if (request >=20 && request<30) {
             System.out.println("ConcreteHandler3处理请求："+request);
          } else if (successor !=null) {
            successor.HandleRequest(request);
          }
       }
}

测试类

  public class HandlerTest {

     public static void main(String[] args) {
           Handler h1 = new ConcreteHandler1();
           Handler h2 = new ConcreteHandler2();
           Handler h3 = new ConcreteHandler3();
           h1.setSuccessor(h2);
           h2.setSuccessor(h3);

           int[] requests = {2,5,14,22,18,3,27,20};
           for (int request:requests) {
              h1.HandleRequest(request);
           }
      }
}

测试结果

ConcreteHandler1处理请求2
ConcreteHandler1处理请求5
ConcreteHandler2处理请求：14
ConcreteHandler3处理请求：22
ConcreteHandler2处理请求：18
ConcreteHandler1处理请求3
ConcreteHandler3处理请求：27
ConcreteHandler3处理请求：20

优点

责任链中的对象并不知道链的结构，结果是责任链可简化对象的相互连接，它们仅需要一个指向下一个解决者的引用，而无需保持对象中所有情况都对接收者引用。这也就打打降低了耦合度。
责任链模式比较灵活，可以随时增加或者修改处理一个请求的结构，增加了对象指派职责的灵活性。
责任分担，每个类只需要处理自己的工作，不该处理传递给下一个对象完成，明确各类的责任方位，符合类的单一职责原则。
避免在一个类中使用众多的if或者ifelse语句。

缺点

一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。这就很糟糕啦，需要事先考虑全面。
在对于比较长的职责链，请求处理可能涉及多个处理对象，系统性能将会受到一定影响。
职责链建立合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于责任链的错误设置导致系统出错，如可能会造成循环调用。

在计算机软硬件中也有相关例子，如总线网中数据报传送，每台计算机根据目标地址是否同自己的地址相同来决定是否接收；还有异常处理中，处理程序根据异常的类型决定自己是否处理该异常；还有 Struts2 的拦截器、JSP 和 Servlet 的 Filter 等，所有这些，如果用责任链模式都能很好解决。

假设小明想请1天假期的故事

领导抽象类

public abstract  class Leader {

     private Leader next;
     public void setNext(Leader next)
     {
         this.next=next;
     }
     public Leader getNext()
    {
         return next;
    }
    //处理请求的方法
   public abstract void handleRequest(int LeaveDays);
}

部门负责人实现类

  public class DepartmentsLeade extends  Leader {
  @Override
  public void handleRequest(int leaveDays) {
      if (leaveDays <=2) {
         System.out.println("部门领导批准您请假" + leaveDays + "天。");
      } else {
          if(null != getNext()) {
             getNext().handleRequest(leaveDays);
          } else {
            System.out.println("请假天数太多，没有人批准该假条！");
         }
     }
  }
}

副经理实现类

public class DeputyManagerLeader extends  Leader {

  @Override
  public void handleRequest(int leaveDays) {
       if (leaveDays <=4) {
            System.out.println("副经理领导批准您请假" + leaveDays + "天。");
       } else {
       if (getNext() != null) {
          getNext().handleRequest(leaveDays);
       } else { 
         System.out.println("请假天数太多，没有人批准该假条！");
       }
       }
 }
}
public class ManagerLeader extends  Leader {
    @Override
    public void handleRequest(int leaveDays) {
        if (leaveDays <=6) {
            System.out.println("经理领导批准您请假" + leaveDays + "天。");
         } else {
              if(null != getNext()) {
                 getNext().handleRequest(leaveDays);
              } else {
                 System.out.println("请假天数太多，没有人批准该假条！");
              }
         }

    }
}

测试类

public class Test {

public static void main(String[] args) {

    Leader leader1 = new DepartmentsLeade();
    Leader leader2 = new DeputyManagerLeader();
    Leader leader3 = new ManagerLeader();

    leader1.setNext(leader2);
    leader2.setNext(leader3);

    leader1.handleRequest(1);

}
}

测试结果

部门领导批准您请假1天。

小明最后成功请了一天假期，看来设计模式无处不在呀。

补-设计模式之责任链模式(十一)

猜你喜欢

热点阅读