标签：
步骤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相同的。
标签：
原文地址：http://www.cnblogs.com/ilinuxer/p/5167607.html
