Javascript AOP库

您使用哪个Javascript AOP库，以及它的主要功能是什么？

以下是我到目前为止发现的内容：

• 的实现，干净的语法，很好用，这篇文章很好地介绍了为什么/如何使用给定的代码，支持介绍，但有bug
• Dojo在中似乎有一个很好的内置实现，是如何使用它的一个很好的介绍
• jQuery有一个插件，语法更粗糙，在javascript对象中传递对象和方法
• 使用更粗糙的语法（需要将切入点类型作为参数传递给单个方法）

正如我所说，dotvoid的代码不起作用。 我纠正了一点，得到了一些似乎效果更好的东西：

InvalidAspect = new Error("Missing a valid aspect. Aspect is not a function.");
InvalidObject = new Error("Missing valid object or an array of valid objects.");
InvalidMethod = new Error("Missing valid method to apply aspect on.");

function doBefore(beforeFunc,func){
    return function(){
        beforeFunc.apply(this,arguments);
        return func.apply(this,arguments);
    };  
}

function doAfter(func, afterFunc){
    return function(){
        var res = func.apply(this,arguments);
        afterFunc.apply(this,arguments);
        return res;   
    };
}

Aspects = function(){};
Aspects.prototype={
    _addIntroduction : function(intro, obj){
         for (var m in intro.prototype) {
              obj.prototype[m] = intro.prototype[m];
            }
        },

    addIntroduction : function(aspect, objs){
        var oType = typeof(objs);

        if (typeof(aspect) != 'function')
        throw(InvalidAspect);

        if (oType == 'function'){
            this._addIntroduction(aspect, objs);
        }
        else if (oType == 'object'){
            for (var n = 0; n < objs.length; n++){
                this._addIntroduction(aspect, objs[n]);
            }
        }
        else{
            throw InvalidObject;
        }
    },

    addBefore : function(aspect, obj, funcs){
          var fType = typeof(funcs);

          if (typeof(aspect) != 'function')
            throw(InvalidAspect);

          if (fType != 'object')
            funcs = Array(funcs);

          for (var n = 0; n < funcs.length; n++){
            var fName = funcs[n];
            var old = obj.prototype[fName];

            if (!old)
              throw InvalidMethod;

            var res = doBefore(aspect,old)
            obj.prototype[fName] = res;
        }
    },

    addAfter : function(aspect, obj, funcs) {
          if (typeof(aspect) != 'function')
            throw InvalidAspect;

          if (typeof(funcs) != 'object')
            funcs = Array(funcs);

          for (var n = 0; n < funcs.length; n++)
          {
            var fName = funcs[n];
            var old = obj.prototype[fName];

            if (!old)
              throw InvalidMethod;

            var res = doAfter(old,aspect);
            obj.prototype[fName] = res;
          }
        },

    addAround : function(aspect, obj, funcs){
          if (typeof(aspect) != 'function')
            throw InvalidAspect;

          if (typeof(funcs) != 'object')
            funcs = Array(funcs);

          for (var n = 0; n < funcs.length; n++)
          {
            var fName = funcs[n];
            var old = obj.prototype[fName];
            if (!old)
              throw InvalidMethod;

            var res = aspect(old);
            obj.prototype[fName] = res;
          }

          return true;
        }
}

InvalidAspect=新错误（“缺少有效方面。方面不是函数”）；
InvalidObject=新错误（“缺少有效对象或有效对象数组”）；
InvalidMethod=新错误（“缺少应用方面的有效方法。”）；
函数doBefore（beforeFunc，func）{
返回函数（）{
beforeFunc.apply（这个，参数）；
返回函数apply（这是参数）；
};  
}
函数doAfter（func，afterFunc）{
返回函数（）{
var res=func.apply（这是参数）；
afterFunc.apply（这个，参数）；
返回res；
};
}
方面=函数（）{}；
原型={
_补充介绍：功能（简介，obj）{
for（简介原型中的var m）{
对象原型[m]=简介原型[m]；
}
},
附加介绍：功能（方面，objs）{
var-oType=typeof（objs）；
if（类型（方面）！=“功能”）
投掷（残疾人专用）；
if（oType=='function'）{
这是额外的介绍（方面，objs）；
}
else if（oType=='object'）{
对于（var n=0；n

你看过来自的

meld.js

和

aop.js

吗 ?

SpringSource在那里提供了AOP功能，此外还为高级Javascript程序员提供了许多其他有用的东西

---

免责声明：我为SpringSource工作。

基于dotvoid解决方案，我为自己的项目需要创建了自己的JS AOP版本。 我基本上希望最小化方面设置成本，因此我在 功能。原型

Function.prototype.applyBefore = function (aspect, targetFuncNames) {
....
}

我还需要支持aync回调，例如支持某些方法的身份验证和授权。 例如：

var authenticateAspect = function (error, success, context, args) {
    logger.log('authenticate (applyBefore async) aspect is being called');
    var request = $.ajax({
        url: "http://localhost/BlogWeb/api/user/authenticate",
        type: "GET",
        data: { username:'jeff', pwd:'jeff' },
        success: function (data) {
            if (data) {
                success();
            } else {
                error();
            }
        },
        error: error
    });
    return request;
};

Person.applyBefore(authenticateAspect, 'sendNotification');

var p1 = new Person();

p1.sendNotification();

为了实现这一点，我需要运行安全机制，并在成功时继续，或者在失败时停止执行

var invalidAspect = new Error("Missing a valid aspect. Aspect is not a function."),
    invalidMethod = new Error("Missing valid method to apply aspect on.");

///Parameters: aspect - defines the methods we want call before or/and 
///             after each method call ob target obejct
///            targetFuncNames - target function names to apply aspects
///Return: it should return a new object with all aspects setup on target object
Function.prototype.applyBefore = function (aspect, targetFuncNames) {
    if (typeof (aspect) != 'function')
        throw invalidAspect;

    if (typeof (targetFuncNames) != 'object')
        targetFuncNames = Array(targetFuncNames);

    var targetObj = this;
    //error handling function

    // Copy the properties over onto the new prototype
    for (var i = 0, len = targetFuncNames.length; i < len; i++) {
        var funcName = targetFuncNames[i];
        var targetFunc = targetObj.prototype[funcName];

        if (!targetFunc)
            throw invalidMethod;


        targetObj.prototype[funcName] = function () {
            var self = this, args = arguments;
            var success = function() {
                return targetFunc.apply(self, args);
            };
            var error = function () {
                logger.log('applyBefore aspect failed to pass');
                //log the error and throw new error
                throw new Error('applyBefore aspect failed to pass');
            };

            var aspectResult = aspect.apply(null, Array.prototype.concat([error, success, self], args));
            return aspectResult;
        };
    }
};

var invalidAspect=新错误（“缺少有效方面。方面不是函数”），
invalidMethod=新错误（“缺少应用方面的有效方法。”）；
///Parameters:aspect-定义我们希望在或/和之前调用的方法
///在每个方法调用ob target obejct之后
///targetFuncNames—应用特性的目标函数名
///返回：它应该返回一个新对象，并在目标对象上设置了所有方面
Function.prototype.applyBefore=函数（方面，targetFuncNames）{
if（类型（方面）！=“功能”）
投伤残票；
if（typeof（targetFuncNames）！='object'）
targetFuncNames=数组（targetFuncNames）；
var targetObj=此；
//错误处理功能
//将属性复制到新原型上
对于（var i=0，len=targetFuncNames.length；i

---

完整的实现可以在

中找到，代码在Internet Explorer中是否工作