责任链模式

责任链模式的优点在于
将请求的发送者和接受者解藕
可以简化你的对象，因为它不需要知道链的结构
通过改变链内的成员或调动他们的次序，允许你动态的新增或删除责任。
看以下情景：
我们都知道，在学校里，每个学员都有这样的请求：不去开班会，离校，退学。而每种请求必须由不同的人来处理。
那么我们就可以写这样的一个类来处理这样的请求。
public class HandlerWithoutPattern {
private String name; //处理者的名字

public HandlerWithoutPattern(String name) {
this.name = name;
}

public void handleRequest(String request) {
if ("班长".equals(name)) {
if ("不去开班会".equals(request)) {
System.out.println(name + "可以处 理" + request + ",给于批准");
} else {
System.out.println(name + "不处理" + request+"这种请求");
}
} else if ("导员".equals(name)) {
if ("离校".equals(request)) {
System.out.println(name + "可以处理" + request + ",给于批准");
} else {
System.out.println(name + "不处理" + request + "这种请求");
}
} else if ("校长".equals(name)) {
if ("退学".equals(request)) {
System.out.println(name + "可以处理" + request + ",给于批准");
} else {
System.out.println(name + "不处理" + request + "这种请求");
}
}else{
System.out.println("没有专人可以处理这个请求");
}
}
}

那么对于学员类，它是处理请求类的使用者，也就是它的客户程序。那么就有：
public class XueYuan {
private String name;

    public XueYuan(String name){
   this.name=name;
    }
    public static void main(String[] args) {
     HandlerWithoutPattern banzhang=new HandlerWithoutPattern("班长");
     HandlerWithoutPattern daoyuan=new HandlerWithoutPattern("导员");
     HandlerWithoutPattern xiaozhang=new HandlerWithoutPattern("校长");
//将请求给不同的人以便能够得到处理，因为客户程序不知道这些请求具体哪个
           //人能够处理，于是它便把请求一一的交给处理者
banzhang.handleRequest("不去开班会");
daoyuan.handleRequest("不去开班会");
xiaozhang.handleRequest("不去开班会");

//banzhang.handleRequest("离校");
//daoyuan.handleRequest("离校");
//xiaozhang.handleRequest("离校");

//banzhang.handleRequest("退学");
//daoyuan.handleRequest("退学");
//xiaozhang.handleRequest("退学");  
  }
}

问题来了，对于现有的HandlerWithoutPattern类，它只能处理以上三种请求。假如有一天，其中的某个学员提出了不同的请求，他要求处理“请假不去上课”的请求。
那么对于写HandlerWithoutPattern类的人必须修改它写的类以满足这个学员的要求。于是，你不得不打开代码重新增加一段
else if ("老师".equals(name)) {
if ("请假不去上课".equals(request)) {
System.out.println(name + "可以处理" + request + ",给于批准");
} else {
System.out.println(name + "不处理" + request + "这种请求");
}
}

又或者是这个学校规定不给予退学，那么也必须修改HandlerWithoutPattern删除掉这个处理请求。
可以说，只要有学员提出新的请求，那么你就必须修改HandlerWithoutPattern类，也就是说，处理请求的这个地方是易变化。而且对于大量的if else语句，那是相当的难以维护。这也违反了开闭原则了。
那么以下是使用了责任链模式带来的好处，它把这些处理请求各自封装。
//定义一个抽象处理，并有个setNextHandler(Handler successor)方法，设置下一个处理者
public abstract class Handler {
     protected Handler successor;
     protected String name;
     public String getName() {
return name;
}
  //处理请求，由子类完成
public abstract void handleRequest(String request);
  //设置下一个处理请求的人
     public void setNextHandler(Handler successor){
    this.successor=successor;
     }
}
//班长，他可以处理不来开班会的请求，其他请求它不能处理，将转给下一个处理者处理
public class BanZhang extends Handler{
    public BanZhang(String name){
    this.name=name;
    }
public void handleRequest(String request) {
if("不去开班会".equals(request)){
System.out.println(name+"可以处理"+request+",给予批准！");
}else{
System.out.println(name+"不可以处理"+request+"转交给"+successor.getName());
successor.handleRequest(request);
}
}
}
//导员可以处理离校请求，对于其他请求，将交给下一个处理者
public class DaoYuan extends Handler {
    public DaoYuan(String name){
    this.name=name;
    }
public void handleRequest(String request) {
  if("离校".equals(request)){
  System.out.println(name+"可以处理"+request+"给于批准！");
  }
  else{
  System.out.println(name+"不可以处理"+request+"转交给"+successor.getName());
  successor.handleRequest(request);
  }
}
}
//同理，这是校长
public class XiaoZhang extends Handler {
public XiaoZhang(String name){
this.name=name;
}
public void handleRequest(String request) {
if("退学".equals(request)){
  System.out.println(name+"可以处理"+request+"给于批准！");
  }
  else{
  System.out.println(name+"觉的"+request+"是无理请求，不给于批准");
  }
}
}

对于学员类：
public class XueYuan {
private String name;

    public XueYuan(String name){
   this.name=name;
    }
    public static void main(String[] args) {
      Handler banzhang=new BanZhang("班长");
  Handler daoyuan=new DaoYuan("导员");
  Handler xiaozhang=new XiaoZhang("校长");
  banzhang.setNextHandler(daoyuan);  //设置班长的下一个处理者是导员
         daoyuan.setNextHandler(xiaozhang);//设置导员的下一个处理者是校长
  String requests="离校";
          //把请求交给班长即可，如果班长处理不了会一层层往上交
      banzhang.handleRequest(request);                              
         }
    }
}
假如，有一个新学员，它提出了一个新的“请假不去上课”的请求。那么我并不需要修改现有的类，而只要增加一个类，满足这个新学员的需求
public class LaoShi extends Handler {
public LaoShi(String name){
this.name=name;
}
public void handleRequest(String request) {
if("请假不去上课".equals(request)){
  System.out.println(name+"可以处理"+request+"给于批准！");
  }
  else{
  System.out.println(name+"不可以处理"+request+"转交给"+successor.getName());
  successor.handleRequest(request);
  }
}
}

那么对于这个新学员它做的事情：
public class NewXueYuan {
private String name;

    public XueYuan(String name){
   this.name=name;
    }
    public static void main(String[] args) {
      Handler banzhang=new BanZhang("班长");
    Handler laoshi=new XiaoZhang("老师");
  Handler daoyuan=new DaoYuan("导员");
  Handler xiaozhang=new XiaoZhang("校长");
  banzhang.setNextHandler(laoshi);  //设置班长的下一个处理者是老师
          laoshi.setNextHandler(daoyuan);  //设置老师的下一个处理者是导员
       daoyuan.setNextHandler(xiaozhang);//设置导员的下一个处理者是校长
           String request="请假不去上课";
          //把请求交给班长即可，如果班长处理不了会一层层往上交
           banzhang.handleRequ(request);                              
         }
    }
}
把这些关系，交由客户程序（学员）来维护，增加了灵活度，假如有个学员提出的是"退学"的请求，如果他知道，这种请求只要导员或者校长才能处理，那么就可以直接跳过班长，老师了。也就是说它可以根据学员的情况动态的增加或删除某个处理者。
总结：
将请求的发送者和接受者解藕   //对于任何学员提出的新请求，都无须修改现有类，做的只
                             //是扩展
可以简化你的对象，因为它不需要知道链的结构   //只要设置各个处理者的下一个处理者是
               //谁即可，学员无须知道各个处理者可以处理什么，请求会被处理者链处理
通过改变链内的成员或调动他们的次序，允许你动态的新增或删除责任。 //客户程序可以根
              //据自己的需求来决定处理者链

缺点：不易于观察运行时的特征，有碍于除错。
   并不保证请求一定被处理