责任链模式：

 

下图为责任链

　　1、定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象

　　      记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止

　　2、模型结构：

　　　　(1)抽象处理者(Handler)：定义一个处理请求的接口，包含抽象处理方法和一个后继连接

　　　　(2)具体处理者(Concrete Handler)：实现抽象处理者的处理方法，判断能否处理本次请求，

　　　　                      如果可以处理请求则处理，否则将该请求转给它的后继者

　　3、优点：

　　　　(1)降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，

　　　　  发送者和接收者也无须拥有对方的明确信息

　　　　(2)增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足“开闭原则”

　　　　(3)增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，

　　　　  也可动态地新增或者删除责任

　　　　(4)简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，

　　　　  不需保持其他所有处理者的引用，这避免了使用众多的分支语句

　　　　(5)责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，

　　　　  明确各类的责任范围，符合类的单一职责原则

注：单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分

　　4、缺点：

　　　　(1)不能保证每个请求一定被处理。由于一个请求没有明确的接收者，

　　　　  所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理

　　　　(2)对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响

　　　　(3)职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，

　　　　  可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用

　　5、适用环境：

　　　　(1)有多个对象可以处理一个请求，哪个对象处理该请求由运行时刻自动确定

　　　　(2)可动态指定一组对象处理请求，或添加新的处理者

　　　　(3)在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求

// 抽象处理者 Handler
abstract class ATeacher {
    // 链式结构，需要包含一个指向下一个 Handler 的对象
    protected aTeacher: ATeacher;
    setTeacher(teacher: ATeacher): void {
        this.aTeacher = teacher;
    }
    getTeacher(): ATeacher {
        return this.aTeacher;
    }
    abstract handler(level: number): void;
}
// 具体处理者 Concrete Handler
class Teacher extends ATeacher {
    private name: string;
    private something: string;
    constructor(name: string, something: string) {
        super();    // Constructors for derived classes must contain a 'super' call
        this.name = name;
        this.something = something
    }
    handler(level: number): void {
        if (level >= 3) {
            console.log("授课老师同意...");
        } else {
            console.log("授课老师无权受理...");
            this.getTeacher().handler(level);
        }
    }
}
class Moniteur extends ATeacher {
    private name: string;
    private something: string;
    constructor(name: string, something: string) {
        super();    // Constructors for derived classes must contain a 'super' call
        this.name = name;
        this.something = something
    }
    handler(level: number): void {
        let flag: boolean = true;   // 设置为同意
        if (level >= 2) {
            if (flag)
                console.log("辅导员同意...");
            else
                console.log("辅导员不同意...");
        } else {
            console.log("辅导员无权受理...");
            this.getTeacher().handler(level);
        }
    }
}
class Directeur extends ATeacher {
    private name: string;
    private something: string;
    constructor(name: string, something: string) {
        super();    // Constructors for derived classes must contain a 'super' call
        this.name = name;
        this.something = something
    }
    handler(level: number): void {
        let flag: boolean = false;  // 设置为不同意
        if (level >= 1) {
            if (flag)
                console.log("主任同意...");
            else
                console.log("主任不同意...");
        } else {
            console.log("主任无权受理...");
            this.getTeacher().handler(level);
        }
    }
}

let stuName1: string = "Lemon";
let thing: string = "Go home";
let teacher1: ATeacher = new Teacher(stuName1, thing);
let teacher2: ATeacher = new Moniteur(stuName1, thing);
let teacher3: ATeacher = new Directeur(stuName1, thing);

teacher1.setTeacher(teacher2);
teacher2.setTeacher(teacher3);
// 授课老师无权受理...
// 辅导员同意...
teacher1.handler(2);

&n