责任链模式

责任链模式的优点在于
将请求的发送者和接受者解藕
可以简化你的对象，因为它不需要知道链的结构
通过改变链内的成员或调动他们的次序，允许你动态的新增或删除责任。
看以下情景：
我们都知道，在学校里，每个学员都有这样的请求：不去开班会，离校，退学。而每种请求必须由不同的人来处理。
那么我们就可以写这样的一个类来处理这样的请求。
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);
}
}
}
把这些关系，交由客户程序（学员）来维护，增加了灵活度，假如有个学员提出的是"退学"的请求，如果他知道，这种请求只要导员或者校长才能处理，那么就可以直接跳过班长，老师了。也就是说它可以根据学员的情况动态的增加或删除某个处理者。
总结：
将请求的发送者和接受者解藕 //对于任何学员提出的新请求，都无须修改现有类，做的只
//是扩展
可以简化你的对象，因为它不需要知道链的结构 //只要设置各个处理者的下一个处理者是
//谁即可，学员无须知道各个处理者可以处理什么，请求会被处理者链处理
通过改变链内的成员或调动他们的次序，允许你动态的新增或删除责任。 //客户程序可以根
//据自己的需求来决定处理者链

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