JAVA设计模式之责任链模式

一、责任链模式简介

Chain of Responsibility（CoR）模式也叫职责链模式或者职责连锁模式，是行为模式之一，该模式构造一系列分别担当不同的职责的类的对象来共同完成一个任务，这些类的对象之间像链条一样紧密相连，所以被称作职责链模式。
要实现Chain of Responsibility模式，需要满足该模式的基本条件：

1. 对象链的组织。需要将某任务的所有职责执行对象以链的形式加以组织。
2. 消息或请求的传递。将消息或请求沿着对象链传递，以让处于对象链中的对象得到处理机会。
3. 处于对象链中的对象的职责分配。不同的对象完成不同的职责。
4. 任务的完成。处于对象链的末尾的对象结束任务并停止消息或请求的继续传递。

二、责任链模式的结构

三、责任链模式的角色与职责

Handler ：处理类的抽象父类。
concreteHandler ： 具体的处理类。

四、责任链模式的具体实现

某公司的要求我们对他们的采购申请设计一个应用，要求每个级别的领导所能审批的金额不一样，级别越高金额越大。

1、使用责任链模式

方案设计

类设计

下面我们设计一个采购申请：

// An highlighted block
package design.chain.gys.chain;
public class Purchase {
 private String Type;
 private int Number;
 private double Price;
 public Purchase(String type, int number, double price) {
  super();
  Type = type;
  Number = number;
  Price = price;
 }
 public String getType() {
  return Type;
 }
 public int getNumber() {
  return Number;
 }
 public double getPrice() {
  return Price;
 }
 public double getSum() {
  return Price*Number;
 }
 public void print() {
  System.out.println("需要购买的  ："+getType()+"\n数量 ："+getNumber()+"\n总计 ："+getSum());
 }
}

接着设计一个处理者接口：

// An highlighted block
package design.chain.gys.chain;
public abstract class Handler {
 Handler handler;
 String name;
 public Handler(String name) {
  super();
  this.name = name;
 }
 public abstract void deal(Purchase pur);
 public void setHandler(Handler handler) {
  this.handler=handler;
 }
}

有了处理者接口，我们可以定义四级处理结构：

// An highlighted block
package design.chain.gys.chain;
public class ManagerLeader extends Handler{
 public ManagerLeader(String name) {
  super(name+" ManagerLeader");
 }
 @Override
 public void deal(Purchase pur) {
  // TODO Auto-generated method stub
  if(1000<pur.getSum()&&pur.getSum()<=5000)
   System.out.println("这个单子被 "+this.name+"处理");
  else
  {
   handler.deal(pur);
  }
 }
}

// An highlighted block
package design.chain.gys.chain;
public class GroupLeader extends Handler{
 public GroupLeader(String name) {
  super(name+" GroupLeader");
 }
 @Override
 public void deal(Purchase pur) {
  // TODO Auto-generated method stub
  if(pur.getSum()<=1000)
   System.out.println("这个单子被 "+this.name+"处理");
  else
  {
   handler.deal(pur);
  }
 }
}

// An highlighted block
package design.chain.gys.chain;
public class AreaLeader extends Handler{
 public AreaLeader(String name) {
  super(name+" AreaLeader");
 }
 @Override
 public void deal(Purchase pur) {
  // TODO Auto-generated method stub
  if(5000<pur.getSum()&&pur.getSum()<=20000)
   System.out.println("这个单子被 "+this.name+"处理");
  else
  {
   handler.deal(pur);
  }
 }
}

// An highlighted block
package design.chain.gys.chain;
public class CEOLeader extends Handler{
 public CEOLeader(String name) {
  super(name+" CEOLeader");
 }
 @Override
 public void deal(Purchase pur) {
  // TODO Auto-generated method stub
  if(20000<pur.getSum()&&pur.getSum()<=1000)
   System.out.println("这个单子被 "+this.name+"处理");
  else
  {
   handler.deal(pur);
  }
 }
}

采购申请来了，公司举办篮球赛需要采购篮球和球衣。

// An highlighted block
package design.chain.gys.chain;
public class Test {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Handler Jim=new GroupLeader("Jim");
  Handler Jhon=new ManagerLeader("Jhon");
  Handler Simon=new AreaLeader("Simon");
  Handler Lilei=new CEOLeader("Lilei");
  Jim.setHandler(Jhon);
  Jhon.setHandler(Simon);
  Simon.setHandler(Lilei);
  Lilei.setHandler(Jim);
  Purchase scheme1=new Purchase("篮球", 100, 20);
  Purchase scheme2=new Purchase("篮球服", 100, 150);
  scheme1.print();
  Jim.deal(scheme1);
  System.out.println("---------");
  scheme2.print();
  Simon.deal(scheme2);
 }
}

看看我们的各级领导能不能获得正确的处理流程：

// An highlighted block
需要购买的  ：篮球
数量 ：100
总计 ：2000.0
这个单子被 Jhon ManagerLeader处理
---------
需要购买的  ：篮球服
数量 ：100
总计 ：15000.0
这个单子被 Simon AreaLeader处理

看来相应的各级领导能收到责任内的处理单了。

五、责任链模式的优缺点

1. 优点：

• 将请求的发送者和接收者解耦
• 简化对象，无需知道链的结构
• 可以动态的增加或删减处理请求的类结构

2. 缺点

• 请求从链的开始遍历，对性能有所损耗
• 不能保证请求一定被处理