scala-trait实现AOP编程

步骤1：声明表示基本动作方法的模块Taction

//声明表示基本动作方法的模块Taction
trait TAction {
def doAction
}

　步骤2：定义一下加入了前置处理和后置处理的特征TBeforeAfter

trait TBeforeAfter extends TAction {
abstract override  def doAction {
  //doAction的前置处理
  println("/entry before-action")
  super.doAction
  //doAction的后置处理
  println("/exit after-action")
  }
}

通过上面的abstract override def doAction {}语句来覆盖虚方法。具体来说这当中的super.doAction是关键，他调用了TAction的doAction方法。其原理是，由于doAction是虚方法，所以实际被执行的是被调用的实体类中所定义的方法。、

步骤3：实现实际执行的实体类RealAction

class RealAction extends TAction {
  def doAction = {
    println("** real action done!! **")
  }
}

测试

object TestTrait {
  def main(args : Array[String]) : Unit = {

val act1 = new RealAction with TBeforeAfter
act1.doAction

val act2 = new RealAction with TBeforeAfter with TTwiceAction
act2.doAction

val act3 = new RealAction with TTwiceAction with TBeforeAfter
act3.doAction

  }
}

/entry before-action
** real action done!! **
/exit after-action

接着为他定义一下别的方面，然后将这些方面加入到同一对象的方法中。接着定义一个将源方法执行两遍的方面。

　

trait TTwiceAction extends TAction {
  abstract override def doAction {
    for (i <- 1 to 2){
      super.doAction
      println("==>NO. " + i)
    }
  }
}

下面，将TBeforeAfter和TtwiceAction混合在一起后执行一下。

/entry before-action
** real action done!! **
/exit after-action
==>NO. 1
/entry before-action
** real action done!! **
/exit after-action
==>NO. 2

伴随着原来方法的before/after动作一起各自执行了两次。接着将混入顺序颠倒后再试一下。

/entry before-action
** real action done!! **
==>NO. 1
** real action done!! **
==>NO. 2
/exit after-action

这样执行后，原来的实现方法被循环执行了两次，但是before/after则在循环以外整体只执行了一次。这是根据with语句定义的顺序来执行的，知道了这原理之后也就没有什么奇怪的了。Scala特性的如此混入顺序是和AspectJ的方面以及Spring的interceptor相同的。