AOP(面向切面編程)中的「通知」是切面的具體實現,分為 before(前置通知)、after(後置通知)與 around(環繞通知)。用過 Spring 的同學對此想必不陌生,但在 JS 中,AOP 卻是一個被嚴重忽視的技術點。事實上,善用 AOP 能有效改善 JS 代碼邏輯——前端框架 dojo 與 yui3 便將 AOP 提升至自定義事件的內在機制,源碼中隨處可見,得益於這種抽象,dojo 的自定義事件變得異常強大靈活。
dojo 中 AOP 的實現在 dojo/aspect 模塊裡,主要有三個方法:before、after、around。本文將帶領大家一步步實現 around 方法。
要實現環繞通知,最直觀的做法是利用回調(callback):
advice = function(originalFunc){
console.log("before function");
originalFunc();
console.log("after function");
}
var obj = {
foo: function(){ console.log('foo'); }
}
advice(obj.foo)
輸出:
before function
foo
after function
看似簡單,但這也未免太粗糙了——起碼下次調用 obj.foo 也應該是同樣的效果,而不是乾巴巴的一個 "foo"。為此我們需要引入閉包:
advice = function(originalFunc){
return function() {
console.log("before function");
originalFunc();
console.log("after function");
}
}
var obj = {
foo: function(){ console.log(this.name); },
name: "obj"
}
obj.foo = advice(obj.foo)
obj.foo()
輸出:
before function
after function
看似達到了環繞效果,但 this.name 卻不見了——作用域出了問題。
在 advice 返回的閉包中,我們還要處理作用域問題,於是引入 call:
keepContext = function() {
return obj['foo'].call(obj);
}
obj.foo = advice(keepContext);

糟糕,這下變成了死循環!因為 obj.foo 已經被重新賦值,call 又指向了 advice 包裝後的函數。
var exist = obj.foo;
keepContext = function() {
return exist.call(obj);
}
obj.foo = advice(keepContext);
obj.foo();
輸出:
before function
obj
after function
世界終於美好了。但這一坨代碼實在有點 low,我們來做點抽象的升華。
function around(obj, prop, advice){
var exist = obj[prop];
var advised = advice(function(){
return exist.call(obj, arguments);
});
obj[prop] = advised;
}
advice = function(originalFunc){
return function() {
console.log("before function");
originalFunc();
console.log("after function");
}
}
var obj = {
foo: function(){ console.log(this.name); },
name: "obj"
}
around(obj, 'foo', advice);
obj.foo();
around 方法將處理過程與具體對象解耦;advice 只要按以下格式書寫,就能達到 around 的效果:
advice = function(originalFunc){
return function() {
//before
originalFunc();
//after
}
}
那麼問題來了:如果不小心多調用了一次 around 該怎麼辦?我們可以讓 around 返回一個帶有 remove 方法的句柄,就像綁定/移除事件那樣,消除重複的綁定:
function around(obj, prop, advice){
var exist = obj[prop];
var previous = function(){
return exist.apply(obj, arguments);
};
var advised = advice(previous);
obj[prop] = advised;
return {
remove: function(){
obj[prop] = exist;
advice = null;
previous = null;
exist = null;
obj = null;
}
}
}
然而直接這樣寫會導致結果錯亂甚至報錯。這時我們需要閉包的力量來妥善管理狀態:
function around(obj, prop, advice){
var exist = obj[prop];
var previous = function(){
return exist.apply(obj, arguments);
};
var advised = advice(previous);
obj[prop] = function(){
//當調用remove後,advised為空
//利用閉包的作用域鏈可訪問到advised與previous變量
return advised ? advised.apply(obj, arguments) : previous.apply(obj, arguments);
};
return {
remove: function(){
//利用閉包作用域鏈,將advised置空,執行時便不會進入本次around
advised = null;
advice = null;
}
}
}
var count = 1;
advice = function(originalFunc){
var current = count++;
return function() {
console.log("before function " + current);
originalFunc.apply(this, arguments);
console.log("after function " + current);
}
}
var obj = {
foo: function(arg){ console.log(this.name + " and " + arg); },
name: "obj"
}
h1 = around(obj, 'foo', advice);
h2 = around(obj, 'foo', advice);
obj.foo('hello world');
h1.remove();
obj.foo('hello world');
h2.remove();
obj.foo('hello world');
輸出:
before function 2
before function 1
obj and hello world
after function 1
after function 2
before function 2
obj and hello world
after function 2
obj and hello world
至此,環繞通知的實現大功告成。