AOP应用比较广泛,在如今最为火热spring框架中,里面就用到了DI(依赖注入)和AOP(面向切面编程),那么js中可以通过什么方法来是实现AOP呢

AOP的特点是什么,为什么要使用它呢?很简单,它的主要思想是将一些与核心业务逻辑模块无关的功能分离开来,比如,我们经常会使用到日志统计,安全控制,异常处理,为了在保证到主业务的纯净和程序的高内聚,我们通过将一些附加的功能模块"动态植入"到逻辑模块中

下面我向大家介绍一下如何通过Function.prototype来实现AOP编程

 
  1. //业务主模块

  2. var myFun = function(){

  3. console.log("执行业务逻辑");

  4. }

  5.  
  6. //业务主模块预处理

  7. Function.prototype.before = function(fn){

  8. var _this=this;

  9. return function(){

  10. fn.apply(this,arguments);

  11. return _this.apply(this,arguments)

  12. }

  13. }

  14.  
  15. //业务主模块后处理

  16.  
  17. Function.prototype.after = function(fn){

  18. var _this = this;

  19. return function(){

  20. var result = _this.apply(this, arguments);

  21. fn.apply(this,arguments)

  22. return result;

  23. }

  24. }

  25.  
  26. var fun = myFun.before(function(){

  27.  
  28. console.log("模块的预处理");

  29.  
  30. }).after(function(){

  31.  
  32. console.log("模块的后处理");

  33.  
  34. });

  35.  
  36. fun();

  37.  

 

代码分析:

//业务主模块
var myFun = function(){
    console.log("执行业务逻辑");
}

//业务主模块预处理
Function.prototype.before = function(fn){
    var _this=this;   //用于保存调用before方法的实例对象,此处的this指向了myFun
    return function(){  //把对函数的预处理与函数一封装在一个函数中,并返回,用于调用after函数.
        fn.apply(this,arguments);  //用于执行对模块的预处理函数fn
        return _this.apply(this,arguments)  //返回 myFun函数
    }
}

//业务主模块后处理

Function.prototype.after = function(fn){
    var _this = this;  //此处的this指向before函数返回的函数,并使用_this存储下来(也就是上面蓝色标记的函数代码)
    return function(){ //再次把before函数返回的函数与对函数的后处理封装在一个函数中,并返回
        var result = _this.apply(this, arguments);  //执行before函数的返回函数,返回值就是(return                                                                                                                                _this.apply(this,arguments)返回的值)
        fn.apply(this,arguments)  //用于执行对模块的后处理函数fn
        return result;
    }
}

var fun =  myFun.before(function(){
    
    console.log("模块的预处理");

}).after(function(){

    console.log("模块的后处理");

}); // 

fun();

 

 

总结:

可能有点绕来绕去的,但是只要仔细思考,你一定会体会到其中的巧妙之处,简而言之,就是把一个对函数的预处理封装在一个before函数中,并把预处理函数和原函数返回,作为一个函数来对after的调用(因为Function上的prototype方法,所有的函数都可以调用).