【设计模式】——行为型模式——职责链模式

职责链模式

行为特征很明显，谁做什么很清楚

一个请求可以有多个对象处理

动机

奖学金审批机制，一层一层向上

或者树形结构

或者环形结构

定义

1. 对象行为型模式
2. 避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求

结构

抽象处理者：自己聚合自己，链式，下一个还是自己

具体处理者：实现抽象处理者，通常有个判断来处理请求

分析

1. 将请求的处理者组织成一条链，让请求沿着链传递
2. 客户端无需关心请求处理细节以及请求的传递——发送者和请求者解耦
3. 链是客户自己建造的
4. 新增处理者要更改客户端和重新建链

实例

Leader类

public abstract class Leader
{
   protected String name;
   protected Leader successor;
   public Leader(String name)
   {
      this.name=name;
   }
   public void setSuccessor(Leader successor)
   {
      this.successor=successor;
   }
   public abstract void handleRequest(LeaveRequest request);
}

LeaveRequest类

public class LeaveRequest
{
   private String leaveName;
   private int leaveDays;
   
   public LeaveRequest(String leaveName,int leaveDays)
   {
      this.leaveName=leaveName;
      this.leaveDays=leaveDays;
   }
   
   public void setLeaveName(String leaveName) {
      this.leaveName = leaveName; 
   }

   public void setLeaveDays(int leaveDays) {
      this.leaveDays = leaveDays; 
   }

   public String getLeaveName() {
      return (this.leaveName); 
   }

   public int getLeaveDays() {
      return (this.leaveDays); 
   }  
}

Director类

public class Director extends Leader
{
   public Director(String name)
   {
      super(name);
   }
   public void handleRequest(LeaveRequest request)
   {
      if(request.getLeaveDays()<3)
      {
         System.out.println("主任" + name + "审批员工" + request.getLeaveName() + "的请假条，请假天数为" + request.getLeaveDays() + "天。");
      }
      else
      {
         if(this.successor!=null)
         {
            this.successor.handleRequest(request);
         }
      }
   }
}

相似的不重复

Client类

public class Client
{
   public static void main(String args[])
   {
      Leader objDirector,objManager,objGeneralManager;
      //Leader objDirector,objManager,objGeneralManager,objViceGeneralManager;
      
      objDirector=new Director("王明");
      objManager=new Manager("赵强");
      objGeneralManager=new GeneralManager("李波");
      //objViceGeneralManager=new ViceGeneralManager("肖红");
      
      objDirector.setSuccessor(objManager);
      //objManager.setSuccessor(objViceGeneralManager);
      objManager.setSuccessor(objGeneralManager);
      //objViceGeneralManager.setSuccessor(objGeneralManager);
         
      LeaveRequest lr1=new LeaveRequest("张三",2);
      objDirector.handleRequest(lr1);
         
      LeaveRequest lr2=new LeaveRequest("李四",5);
      objDirector.handleRequest(lr2);
      
      LeaveRequest lr3=new LeaveRequest("王五",15);
      objDirector.handleRequest(lr3);
                  
      LeaveRequest lr4=new LeaveRequest("赵六",35);
      objDirector.handleRequest(lr4);          
   }
}

运行结果

优点

1. 降低系统的耦合度
2. 简化对象之间的相互连接
3. 给对象职责分配带来更多的灵活性
4. 增加一个新的具体者时无需修改原有系统代码

缺点

1. 不能保证请求一定会被处理
2. 系统性能会收到影响，调试不方便
3. 可能会循环调用

适用场景

1. 多个对象处理同一个请求，具体哪个可以运行时再确定
2. 不明确指定接收者的情况下，可以向多个对象发送请求
3. 动态指定一组对象处理请求