//责任链
//结果
class Responese {
private sss: string;
constructor(sss: string) {
this.sss = sss;
YBLog.log("结果", this.sss);
}
}
//请求
class Request {
private myLevel: number = 0;
public setLevel(myLevel: number) {
this.myLevel = myLevel;
}
public getLevel(): number {
return this.myLevel;
}
}
abstract class Handler {
private nextHandler: Handler = null;
protected abstract getHandleLevel(): number; //本身 和 子可以访问
protected abstract Icando(request: Request): Responese; //本身 和 子可以访问
setNextHandler(nextHandler: Handler) { //
this.nextHandler = nextHandler;
}
public handlerMessage(request: Request): Responese {
if (this.getHandleLevel() == request.getLevel()) { //能处理的。
return this.Icando(request);
} else { //不能处理的。
if (this.nextHandler != null) {
this.nextHandler.handlerMessage(request); //一层一层往下传递
} else {
return null;
}
}
}
}
class aaa extends Handler {
getHandleLevel() {
YBLog.log("Test", "aaa 我的等级是1");
return 1;
};
Icando(request: Request): Responese {
return new Responese("aaa 事实上我处理了")
};
}
class bbb extends Handler {
getHandleLevel() {
YBLog.log("Test", "bbb 我的等级是2");
return 2;
};
Icando(request: Request): Responese {
return new Responese("bbb 事实上我处理了")
};
}
let a: Handler = new aaa();
let b: Handler = new bbb();
a.setNextHandler(b);
let request: Request = new Request();
request.setLevel(2);
let rp:Responese = a.handlerMessage(request);
// Test aaa 我的等级是1
// Test bbb 我的等级是2
// 结果 bbb 事实上我处理了
一优点：请求和处理区分，解耦之后好像灵活了。
二缺点：性能不好，有点递归的意思。