第16章　责任链模式 16.1 古代妇女的枷锁——“三从四德” 中国古代对妇女制定了“三从四德”的道德规范，“三从”是指“未嫁从父、既嫁从夫、夫死从子”。也就是说，一位女性在结婚之前要听从于父亲，结婚之后要听从于丈夫，如果丈夫死了还要听从于儿子。举例来说，如果一位女性要出去逛街，在她出嫁前必须征得父亲的同意，出嫁之后必须获得丈夫的许可，那丈夫死了怎么办？那就得问问儿子是否允许自己出去逛街。估计你接下来马上要问：“要是没有儿子怎么办？”那就请示小叔子、侄子等。在父系社会中，妇女只占从属地位，现在想想中国古代的妇女还是挺悲惨的，连逛街都要多番请示。作为父亲、丈夫或儿子，只有两种选择：要不承担起责任来，允许她或不允许她逛街；要不就让她请示下一个人，这是整个社会体系的约束，应用到我们项目中就是业务规则。下面来看如何通过程序来实现“三从”，需求很简单：通过程序描述一下古代妇女的“三从”制度。好，我们先来看类图，如图16-1所示。  图16-1 妇女“三从”类图 类图非常简单，IHandler是三个有决策权对象的接口，IWomen是女性的代码，其实现也非常简单，IWomen如代码清单16-1所示。 代码清单16-1 女性接口 public interface IWomen {      //获得个人状况      public int getType();      //获得个人请示，你要干什么？出去逛街？约会?还是看电影？      public String getRequest(); } 女性接口仅两个方法，一个是取得当前的个人状况getType，通过返回值决定是结婚了还是没结婚、丈夫是否在世等，另外一个方法getRequest是要请示的内容，要出去逛街还是吃饭，其实现类如代码清单16-2所示。 代码清单16-2 古代妇女 public class Women implements IWomen{      /*       * 通过一个int类型的参数来描述妇女的个人状况       * 1--未出嫁       * 2--出嫁       * 3--夫死       */      private int type=0;      //妇女的请示      private String request = "";      //构造函数传递过来请求      public Women(int _type,String _request){              this.type = _type;              this.request = _request;      }      //获得自己的状况      public int getType(){              return this.type;      }      //获得妇女的请求      public String getRequest(){              return this.request;      } } 我们使用数字来代表女性的不同状态：1是未结婚；2是已经结婚的，而且丈夫健在；3是丈夫去世了。从整个设计上分析，有处理权的人（如父亲、丈夫、儿子）才是设计的核心，他们是要处理这些请求的，我们来看有处理权的人员接口IHandler，如代码清单16-3所示。 代码清单16-3 有处理权的人员接口 public interface IHandler {      //一个女性（女儿、妻子或者母亲）要求逛街，你要处理这个请求      public void HandleMessage(IWomen women); } 非常简单，有处理权的人对妇女的请求进行处理，分别有三个实现类，在女儿没有出嫁之前父亲是有决定权的，其实现类如代码清单16-4所示。 代码清单16-4 父亲类 public class Father implements IHandler {      //未出嫁的女儿来请示父亲      public void HandleMessage(IWomen women) {              System.out.println("女儿的请示是："+women.getRequest());              System.out.println("父亲的答复是:同意");      } } 在女性出嫁后，丈夫有决定权，如代码清单16-5所示。 代码清单16-5 丈夫类 public class Husband implements IHandler {      //妻子向丈夫请示      public void HandleMessage(IWomen women) {              System.out.println("妻子的请示是："+women.getRequest());              System.out.println("丈夫的答复是：同意");      } } 在女性丧偶后，对母亲提出的请求儿子有决定权，如代码清单16-6所示。 代码清单16-6 儿子类 public class Son implements IHandler {      //母亲向儿子请示      public void HandleMessage(IWomen women) {              System.out.println("母亲的请示是："+women.getRequest());              System.out.println("儿子的答复是：同意");      } } 以上三个实现类非常简单，只有一个方法，处理女儿、妻子、母亲提出的请求，我们来模拟一下一个古代妇女出去逛街是如何请示的，如代码清单16-7所示。 代码清单16-7 场景类 public class Client {      public static void main(String[] args) {              //随机挑选几个女性              Random rand = new Random();              ArrayList<IWomen> arrayList = new ArrayList();              for(int i=0;i<5;i++){                      arrayList.add(new Women(rand.nextInt(4),"我要出去逛街"));              }              //定义三个请示对象              IHandler father = new Father();              IHandler husband = new Husband();              IHandler son = new Son();              for(IWomen women:arrayList){                      if(women.getType() ==1){ //未结婚少女，请示父亲                             System.out.println("\n--------女儿向父亲请示-------");                             father.HandleMessage(women);                      }else if(women.getType() ==2){  //已婚少妇，请示丈夫                             System.out.println("\n--------妻子向丈夫请示-------");                             husband.HandleMessage(women);                      }else if(women.getType() == 3){ //母亲请示儿子                             System.out.println("\n--------母亲向儿子请示-------");                             son.HandleMessage(women);                      }else{                             //暂时什么也不做                      }              }      } } 首先是通过随机方法产生了5个古代妇女的对象，然后看她们是如何就逛街这件事去请示的，运行结果如下所示（由于是随机的，您看到的结果可能和这里有所不同）： --------女儿向父亲请示------- 女儿的请示是：我要出去逛街 父亲的答复是：同意 --------母亲向儿子请示------- 母亲的请示是：我要出去逛街 儿子的答复是：同意 --------妻子向丈夫请示------- 妻子的请示是：我要出去逛街 丈夫的答复是：同意 --------女儿向父亲请示------- 女儿的请示是：我要出去逛街 父亲的答复是：同意 “三从四德”的旧社会规范已经完整地表现出来了，你看谁向谁请示都定义出来了，但是你是不是发现这个程序写得有点不舒服？有点别扭？有点想重构它的感觉？那就对了！这段代码有以下几个问题： ● 职责界定不清晰 对女儿提出的请示，应该在父亲类中做出决定，父亲有责任、有义务处理女儿的请示，因此Father类应该是知道女儿的请求自己处理，而不是在Client类中进行组装出来，也就是说原本应该是父亲这个类做的事情抛给了其他类进行处理，不应该是这样的。 ● 代码臃肿 我们在Client类中写了if...else的判断条件，而且能随着能处理该类型的请示人员越多，if...else的判断就越多，想想看，臃肿的条件判断还怎么有可读性？！ ● 耦合过重 这是什么意思呢，我们要根据Women的type来决定使用IHandler的那个实现类来处理请求。有一个问题是：如果IHandler的实现类继续扩展怎么办？修改Client类？与开闭原则违背了！ ● 异常情况欠考虑 妻子只能向丈夫请示吗？如果妻子（比如一个现代女性穿越到古代了，不懂什么“三从四德”）向自己的父亲请示了，父亲应该做何处理？我们的程序上可没有体现出来，逻辑失败了！ 既然有这么多的问题，那我们要想办法来解决这些问题，我们先来分析一下需求，女性提出一个请示，必然要获得一个答复，甭管是同意还是不同意，总之是要一个答复的，而且这个答复是唯一的，不能说是父亲作出一个决断，而丈夫也作出了一个决断，也即是请示传递出去，必然有一个唯一的处理人给出唯一的答复，OK，分析完毕，收工，重新设计，我们可以抽象成这样一个结构，女性的请求先发送到父亲类，父亲类一看是自己要处理的，就作出回应处理，如果女儿已经出嫁了，那就要把这个请求转发到女婿来处理，那女婿一旦去天国报道了，那就由儿子来处理这个请求，类似于如图16-2所示的顺序处理图。  图16-2 女性请示的顺序处理图 父亲、丈夫、儿子每个节点有两个选择：要么承担责任，做出回应；要么把请求转发到后序环节。结构分析得已经很清楚了，那我们看怎么来实现这个功能，类图重新修正，如图16-3所示。  图16-3 顺序处理的类图 从类图上看，三个实现类Father、Husband、Son只要实现构造函数和父类中的抽象方法response就可以了，具体由谁处理女性提出的请求，都已经转移到了Handler抽象类中，我们来看Handler怎么实现，如代码清单16-8所示。 代码清单16-8 修改后的Handler类 public abstract class Handler {      public final static int FATHER_LEVEL_REQUEST = 1;      public final static  int HUSBAND_LEVEL_REQUEST = 2;      public final static  int SON_LEVEL_REQUEST = 3;      //能处理的级别      private int level =0;            //责任传递，下一个人责任人是谁      private Handler nextHandler;      //每个类都要说明一下自己能处理哪些请求      public Handler(int _level){              this.level = _level;      }      //一个女性（女儿、妻子或者是母亲）要求逛街，你要处理这个请求      public final void HandleMessage(IWomen women){              if(women.getType() == this.level){                     this.response(women);              }else{                     if(this.nextHandler != null){  //有后续环节，才把请求往后递送                           this.nextHandler.HandleMessage(women);                     }else{ //已经没有后续处理人了，不用处理了                           System.out.println("---没地方请示了，按不同意处理---\n");                     }              }      }      /*       * 如果不属于你处理的请求，你应该让她找下一个环节的人，如女儿出嫁了，       * 还向父亲请示是否可以逛街，那父亲就应该告诉女儿，应该找丈夫请示       */      public void setNext(Handler _handler){              this.nextHandler = _handler;      }      //有请示那当然要回应      protected abstract void response(IWomen women); } 方法比较长，但是还是比较简单的，读者有没有看到，其实在这里也用到模板方法模式，在模板方法中判断请求的级别和当前能够处理的级别，如果相同则调用基本方法，做出反馈；如果不相等，则传递到下一个环节，由下一环节做出回应，如果已经达到环节结尾，则直接做不同意处理。基本方法response需要各个实现类实现，每个实现类只要实现两个职责：一是定义自己能够处理的等级级别；二是对请求做出回应，我们首先来看首节点Father类，如代码清单16-9所示。 代码清单16-9 父亲类 public class Father extends Handler {      //父亲只处理女儿的请求      public Father(){              super(Handler.FATHER_LEVEL_REQUEST);      }      //父亲的答复      protected void response(IWomen women) {              System.out.println("--------女儿向父亲请示-------");              System.out.println(women.getRequest());              System.out.println("父亲的答复是:同意\n");      } } 丈夫类定义自己能处理的等级为2的请示，如代码清单16-10所示。 代码清单16-10 丈夫类 public class Husband extends Handler {      //丈夫只处理妻子的请求      public Husband(){              super(Handler.HUSBAND_LEVEL_REQUEST);      }      //丈夫请示的答复      protected void response(IWomen women) {              System.out.println("--------妻子向丈夫请示-------");              System.out.println(women.getRequest());              System.out.println("丈夫的答复是：同意\n");      } } 儿子类只能处理等级为3的请示，如代码清单16-11所示。 代码清单16-11 儿子类 public class Son extends Handler {      //儿子只处理母亲的请求      public Son(){              super(Handler.SON_LEVEL_REQUEST);      }      //儿子的答复      protected void response(IWomen women) {              System.out.println("--------母亲向儿子请示-------");              System.out.println(women.getRequest());              System.out.println("儿子的答复是：同意\n");      } } 这三个类都很简单，构造方法是必须实现的，父类框定子类必须有一个显式构造函数，子类不实现编译不通过。通过构造方法我们设置了各个类能处理的请求类型，Father只能处理请求类型为1（也就是女儿）的请求；Husband只能处理请求类型类为2（也就是妻子）的请求，儿子只能处理请求类型为3（也就是母亲）的请求，那如果请求类型为4的该如何处理呢？在Handler中我们已经判断了，如何没有相应的处理者（也就是没有下一环节），则视为不同意。 Women类的接口没有任何变化，请参考图16-1所示。 实现类稍微有些变化，如代码清单16-12所示。 代码清单16-12 女性类 public class Women implements IWomen{      /*       * 通过一个int类型的参数来描述妇女的个人状况       * 1--未出嫁       * 2--出嫁       * 3--夫死       */      private int type=0;      //妇女的请示      private String request = "";      //构造函数传递过来请求      public Women(int _type,String _request){              this.type = _type;                       //为了便于显示，在这里做了点处理              switch(this.type){              case 1:                          this.request = "女儿的请求是：" + _request;                          break;              case 2:                          this.request = "妻子的请求是：" + _request;                          break;              case 3:                          this.request = "母亲的请求是：" + _request;              }      }      //获得自己的状况      public int getType(){              return this.type;      }      //获得妇女的请求      public String getRequest(){              return this.request;      } } 为了展示结果清晰一点，Women类做了一些改变，如粗体部分所示。我们再来看Client类是怎么描述古代这一个礼节的，如代码清单16-13所示。 代码清单16-13 场景类 public class Client {      public static void main(String[] args) {              //随机挑选几个女性              Random rand = new Random();              ArrayList<IWomen> arrayList = new ArrayList();              for(int i=0;i<5;i++){                     arrayList.add(new Women(rand.nextInt(4),"我要出去逛街"));              }              //定义三个请示对象              Handler father = new Father();              Handler husband = new Husband();              Handler son = new Son();              //设置请示顺序              father.setNext(husband);              husband.setNext(son);              for(IWomen women:arrayList){                     father.HandleMessage(women);              }      } } 在Client中设置请求的传递顺序，先向父亲请示，不是父亲应该解决的问题，则由父亲传递到丈夫类解决，若不是丈夫类解决的问题则传递到儿子类解决，最终的结果必然有一个返回，其运行结果如下所示。 --------妻子向丈夫请示------- 妻子的请求是：我要出去逛街 丈夫的答复是：同意 --------女儿向父亲请示------- 女儿的请求是：我要出去逛街 父亲的答复是：同意 --------母亲向儿子请示------- 母亲的请求是：我要出去逛街 儿子的答复是：同意 --------妻子向丈夫请示------- 妻子的请求是：我要出去逛街 丈夫的答复是：同意 --------母亲向儿子请示------- 母亲的请求是：我要出去逛街 儿子的答复是：同意 结果也正确，业务调用类Client也不用去做判断到底是需要谁去处理，而且Handler抽象类的子类可以继续增加下去，只需要扩展传递链而已，调用类可以不用了解变化过程，甚至是谁在处理这个请求都不用知道。在这种模式下，即使现代社会的一个小太妹穿越到古代（例如掉入时空隧道，或者时空突然扭转，甚至是突然魔法显灵），对“三从四德”没有任何了解也可以自由地应付，反正只要请示父亲就可以了，该父亲处理就父亲处理，不该父亲处理就往下传递。这就是责任链模式。