AOP广泛用在日志，性能统计，安全审计，事务管理等地方，极大地减小了程序员对这些杂务的关注，同时获得了更好的处理一致性和重构的灵活性。
尽管动态语言有着非常有利于实现AOP的特性，但到目前为止，Javascirpt领域还没有很好的AOP实现。Dojo 1.7在这方面迈开了第一步。准确地讲，从dojo 1.0开始就曾有过这方面的尝试，但不知为何后来这个特性并没有包含在后面的版本里。关于dojo AOP，玉观音（Eugene Lazutkin）的博客AOP aspect of JavaScript with Dojo是互联网上找得到的几乎惟一的文章，尽管那篇文章只是关于dojo 1.0的陈年旧事，但仍值得一看，因为它解释了一些AOP的概念。
现在，让我们尝鲜一试Dojo 1.7的aspect特性。我们依然采用动态注入dojo的方式。我特别喜爱这种方式，因为除了firebug和firefox之外，我们并不需要动用其它开发工具。
首先打开www.tianya.cn的任一论坛网页，参照如何向网页动态注入dojo这篇文章（以下简称动文），将dojo注入到该网页。我们的示例中的dojo还只是1.6版本（在本文写作时候，2011.10.4），所以这个dojo中并不包含aspect特性。aspect特性由文件aspect.js引入，目前可以通过http://svn.dojotoolkit.org/src/dojo/trunk/aspect.js来得到。
我的第一想法是，同时向该网页也注入aspect.js文件。我们在“动文”中使用的示例代码中有一个loadModule的函数，我们可以用它来向网页的<head>部分插入这个aspect.js文件。试验结果是，dojo的loader不允许跨域注入js文件（请见dojo is not defined一文)。
看来只有直接通过firebug控制台引入aspect了。查看aspect.js源代码，发现它并没有依赖到其它dojo模块，只是使用了AMD的加载语法和define函数。因此，我们可以轻易地将它的有效代码从aspect.js中剥离出来：
var aspect = function(){
"use strict";
function advise(dispatcher, type, advice, receiveArguments){
var previous = dispatcher[type];
var around = type == "around";
var signal;
if(around){
var advised = advice(function(){
return previous.advice(this, arguments);
});
signal = {
remove: function(){
signal.cancelled = true;
},
advice: function(target, args){
return signal.cancelled ?
previous.advice(target, args) : // cancelled, skip to next one
advised.apply(target, args); // called the advised function
}
};
}else{
// create the remove handler
signal = {
remove: function(){
var previous = signal.previous;
var next = signal.next;
if(!next && !previous){
delete dispatcher[type];
}else{
if(previous){
previous.next = next;
}else{
dispatcher[type] = next;
}
if(next){
next.previous = previous;
}
}
},
advice: advice,
receiveArguments: receiveArguments
};
}
if(previous && !around){
if(type == "after"){
// add the listener to the end of the list
var next = previous;
while(next){
previous = next;
next = next.next;
}
previous.next = signal;
signal.previous = previous;
}else if(type == "before"){
// add to beginning
dispatcher[type] = signal;
signal.next = previous;
previous.previous = signal;
}
}else{
// around or first one just replaces
dispatcher[type] = signal;
}
return signal;
}
function aspect(type){
return function(target, methodName, advice, receiveArguments){
var existing = target[methodName], dispatcher;
if(!existing || existing.target != target){
// no dispatcher in place
dispatcher = target[methodName] = function(){
// before advice
var args = arguments;
var before = dispatcher.before;
while(before){
args = before.advice.apply(this, args) || args;
before = before.next;
}
// around advice
if(dispatcher.around){
var results = dispatcher.around.advice(this, args);
}
// after advice
var after = dispatcher.after;
while(after){
results = after.receiveArguments ? after.advice.apply(this, args) || results :
after.advice.call(this, results);
after = after.next;
}
return results;
};
if(existing){
dispatcher.around = {advice: function(target, args){
return existing.apply(target, args);
}};
}
dispatcher.target = target;
}
var results = advise((dispatcher || existing), type, advice, receiveArguments);
advice = null;
return results;
};
}
return {
before: aspect("before"),
around: aspect("around"),
after: aspect("after")
};
}();这段代码与aspect.js的主要区别是，我们将原来代码中的匿名函数直接执行（第109句），并将结果赋给了变量aspect.
代码很简洁，也只实现了三个方法，before, after和around。而advise是个内部函数，用来完成织入的工作。
接下来我们在firebug控制台中运行上面的代码，并查看注入后的结果：
>>>console.dir(aspect);
这时如果看到它列出三个方法before, after, around，则现在aspect的特性可用了。
让我们利用aspect来做些有意义的事情。作为一个经验丰富的C/C++程序员，我常常使用一些API工具来探究别人的程序是如何运行的，有着什么样的callstack。比如Very Sleepy就是这一样款好用的工作。它通过从可执行代码中抽取调试符号信息和对这些API进行包装，从而得到代码运行的callstack和每个函数执行的时间。刚刚开始接触到Java，尤其是Javascript时，这一点曾经让我苦恼。现在有了aspect.js,看看我们能否弥补这一缺撼。
发行到internet上的javascript代码无一例外地都要进行压缩(shrink/minify)，有的还进行了混淆(Obfuscator)。但正如dll的导出函数总是有一个名字一样，javascript代码为了能够跨脚本引用对象和函数，一般这些名字不会被替换和混淆，也就是说，我们是有可能暴露和追踪一批公用函数的使用的。
请看下面的代码：
function weave(target){
for (var x in target){
if (!dojo.isFunction(target[x])){
console.log(x, target[x]);
continue;
}
aspect.around(target, x, function(oFun){
log("trying to advise ", x);
if (!oFun.funcName)
oFun.funcName = x;
return function(){
var start = new Date().getTime();
console.log(">>>", oFun.funcName);
var results = oFun.apply(this, arguments); // call the original
var end = new Date().getTime();
console.log("<<<", oFun.funcName, " take", (end - start) + " ms");
return results;
};
});
};
}获取javascript函数的函数名没有标准的和放之四海皆准的方法。一般会在被调用函数内部使用arguments.callee.name来获取该函数的名字，但它有两个缺点，第一，如果脚本声明了”use strict”，则不使用这一方法；另外，在我们的应用场景里这根本就不可行。好在我们可以在织入时让函数自己带着这个名字。Javascript中函数即对象！（这一技巧我们已经在
Javascript中的变量中使用过，用来构造函数中的静态变量）这就是第9～10行所做的工作。
现在，让我们准备hook住网页中的函数吧。查看tianya的脚本，你会发现它有一个叫__global的名字空间，里面有一些函数：
>>> weave(__global);
当然我们也可以将window对象的所有函数都加上advice。现在，点击关注作者的那个图标，看看控制台有些什么样的输出：
Aha，依次调用了isOnline, getCookieTempTime, getCookie等函数。
结论：
dojo的aspect特性实现了before, after 和around三种advice。通过AOP我们可以在Javascript中完成stack trace, performance profiling，loging等功能。利用本文介绍的技术，我们还可以追踪他人的网站上使用的Javascript，甚至将经过minify过的script还原。