//Chain of responsibility
//result
class Responese {
private sss: string;
constructor(sss: string) {
this.sss = sss;
YBLog.log("Result", this.sss);
}
}
//request
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; // itself and child can access
protected abstract Icando(request: Request): Responese; // itself and child can access
setNextHandler (nextHandler: Handler) {//
this.nextHandler = nextHandler;
}
public handlerMessage(request: Request): Responese {
if (this.getHandleLevel() == request.getLevel()) {//Can handle it.
return this.Icando(request);
} else {//Can not be processed.
if (this.nextHandler != null) {
this.nextHandler.handlerMessage(request); //pass down layer by layer
} else {
return null;
}
}
}
}
class aaa extends Handler {
getHandleLevel () {
YBLog.log("Test", "aaa my level is 1");
return 1;
};
Icando(request: Request): Responese {
return new Responese("aaa I actually handled it")
};
}
class bbb extends Handler {
getHandleLevel () {
YBLog.log("Test", "bbb my level is 2");
return 2;
};
Icando(request: Request): Responese {
return new Responese("bbb I actually handled it")
};
}
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 my level is 1
// Test bbb, my level is 2
// As a result, bbb, I actually handled it
One advantage: the request and processing are distinguished, and it seems to be flexible after decoupling.
Two disadvantages: poor performance, a bit recursive.