设计模式_责任链模式

定义

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.Chain the receiving objects and pass the request along the chain until an object handles it.(使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止)

不认识的单词

coupling : 耦合

sender : 发送者

责任链模式的重点是在“链”上，由一条链去处理相似的请求在链中决定谁来处理这个请求，并返回相应的结果，其通用类图如图16-4所示。

责任链模式的核心在“链”上！ 

例子

    中国古代对妇女制定了“三从四德”的道德规范，“三从”是指“未嫁从父、既嫁从夫、夫 死从子”。也就是说，一位女性在结婚之前要听从于父亲，结婚之后要听从于丈夫，如果丈  夫死了还要听从于儿子。举例来说，如果一位女性要出去逛街，在她出嫁前必须征得父亲的 同意，出嫁之后必须获得丈夫的许可，那丈夫死了怎么办？那就得问问儿子是否允许自己出 去逛街。

最核心的东西★

<span style="font-family:Microsoft YaHei;">public abstract class Handler {
 public final static int FATHER=1;
 public final static int HUSBAND=2;
 public final static int SON=3;
 private int level=0;
 private Handler nextHandler;  //这是重点

 public Handler(int _level){
  this.level=_level;
 } 
 
 public final void HandlerMessage(IWomen women){
  if(women.getType()==this.level){	
   this.response(women);
  }else{
   if(this.nextHandler != null){
    this.nextHandler.HandlerMessage(women);
   }else{
    System.out.println("没有后续，就是不同意");
   }
  }
 }
 
 public void setNext(Handler _nextHandler){
  this.nextHandler=_nextHandler;
  
 }
 
 protected abstract void response(IWomen women);
}</span>

分析Handler类

抽象类，内部三个静态常量，一个当前等级变量，一个自身成员，姑且让我这么说，这样就可以递归调用，将Ｈandler子类串起来，形成一条链。

下面的东西是修修补补，完全依照上面约束而进行。

三个子类

<span style="font-family:Microsoft YaHei;font-size:12px;">public class Father extends Handler {

 public Father() {
  super(Handler.FATHER);
 }

 @Override
 protected void response(IWomen women) {
  System.out.println("女儿向父亲请示:"+women.getRequest());
  System.out.println("父亲答应");
 }
}</span>

<span style="font-family:Microsoft YaHei;font-size:12px;">public class Husband extends Handler{

 public Husband() {
  super(Handler.HUSBAND);
 }

 @Override
 protected void response(IWomen women) {
  System.out.println("妻子的请示:"+women.getRequest());
  System.out.println("丈夫准许了");
 }
}</span>

public class Son extends Handler {

 public Son() {
  super(Handler.SON);
 }

 @Override
 protected void response(IWomen women) {
  System.out.println("母亲的请示是"+women.getRequest());
  System.out.println("儿子准许了");
 }
}

再来设计女性接口和实例

<span style="font-family:Microsoft YaHei;font-size:12px;">public interface IWomen {

 public int getType();

 public String getRequest();

}</span>

<span style="font-family:Microsoft YaHei;font-size:12px;">public class Women implements IWomen {

 /* 0:未出嫁
  * 1:已出嫁
  * 2:丧夫
  */
 private int type=0;
 private String request="";
 
 public Women(int type,String request){
 
  this.type=type;
  this.request=request;
 }
 
 public String getRequest() {
  return this.request;
 }

 public int getType() {
  return this.type;
 }
}</span>

测试

<span style="font-family:Microsoft YaHei;font-size:12px;">public class Client {

 public static void main(String[] args) {
  Random random=new  Random();
  ArrayList<IWomen> list=new ArrayList<IWomen>();
  for(int i=0;i<5;i++){
   list.add(new Women(random.nextInt(4),"我要出去逛街"));
  //产生随机的类型
  }
  Handler father=new Father();
  Handler husband=new Husband();
  Handler son=new Son();
  father.setNext(husband);
   //设置下一个
  husband.setNext(son);
      //设置下一个
  for(IWomen women:list){
          
   father.HandlerMessage(women);  //当然从最高开始
  }
 }
}
/**
 * 重要是"链"，由一条链去处理相似的请求在链中决定谁来处理这个请求
 */</span>

悟 

这个设计模式一个最大的特点就是setNext()方法，可以往后传递从而实现递归一样的循环，如果这个不行，那就给下一个，链式结构的遍历。 "链"，类似于if-else，显然这个设计的更高级，更工整。如果要说扩展性的话，那么还行吧，毕竟一个系统不可能有很长的责任链吧。可以和其他模式联合使用，关键还是场景，需求的问题。

我是菜鸟，我在路上。