import scala. concurrent . _
import java. lang . reflect . { Method, InvocationHandler, Proxy }
import scala. concurrent . ExecutionContext . Implicits . global

package object util {
def createProxy [ I ] ( proxee : I,
interfaceClass : Class [ I ] ,
handler : InvocationHandler ) : I = {
Proxy. newProxyInstance (
interfaceClass. getClassLoader ,
Array ( interfaceClass ) ,
handler ) . asInstanceOf [ I ]
}
}

import util. _

abstract class AspectBase ( proxee : AnyRef ) extends InvocationHandler {
protected def invokeProxee ( method : Method,
args : Array [ Object ] ) : AnyRef =
method. invoke ( proxee, args : _* )
}

class ProxyClass
( proxee : AnyRef )
( implicit protected val executionContext : ExecutionContext )
extends AspectBase ( proxee ) {

override def invoke ( proxy : Object,
method : Method,
args : Array [ Object ] ) : AnyRef = {

println ( s «${method.getName} invoked» )

val result = invokeProxee ( method, args )
result match {
case f : Future [ _ ] =>
println ( «Future returned!» )
case _ => ;
}
result
}
}

trait TestTrait {
def someMethod ( x : Long ) : Long
def someOtherMethod ( x : Long ) : Future [ Long ]
}

class TestTraitImpl extends TestTrait {
def someMethod ( x : Long ) = x * 2
def someOtherMethod ( x : Long ) = Future { x * 3 }
}

object Debug extends App {
val t = {
val proxee = new TestTraitImpl ( )
createProxy ( proxee, classOf [ TestTrait ] , new ProxyClass ( proxee ) )
}

t. someMethod ( 1 )
t. someOtherMethod ( 2 )
}