Akka 通过可堆叠行为拦截接收

Akka 和 Scala 新手，请根据需要随意编辑问题，以便清楚地表达我在 Scala 和 Akka 领域的意图。

在展示代码片段之前，这是我想要解决的问题：我本质上想开发一个通用模块，供我的团队在使用 Akka Actor 开发应用程序时使用。我想允许他们混合一个特征，该特征将在运行时扩展他们的接收功能，主要用于日志记录目的。我遇到了编译错误，我很快就会解释。

但首先，以一个简单的 main 为例：

object Test extends App {

   val system = ActorSystem("system")
   val myActor = system.actorOf(Props(new MyActor), "myActor")
   myActor ! "Hello world!"
}

以下是团队成员可能在其应用程序中实现的参与者的示例实现：

class MyActor extends Actor with ActorLogger {

   override def receive: Receive = {
       case msg => {
          log.info("testing ...")
       }
       case _ => throw new RuntimeException("Runtime Ex")
   }
}

这是我如何为它们提供共同特征以供混合的示例：

trait ActorLogger extends Actor {

    val log: DiagnosticLoggingAdapter = Logging(this)

    abstract override def receive: Receive = {

         case msg: Any => {
            if (msg.isInstanceOf[String]) {
              println("enter")
              log.mdc(Map[String, Any]("someKey" -> 123))
              super.receive(msg)
              log.clearMDC()
               println("exit")
            }
          }

         case _ => throw new RuntimeException("Runtime Ex")
    }

}

正如您所看到的，如果消息恰好是字符串，我会尝试将数据添加到 MDC（这是一个基本示例，实际上，我会检查我们自己的某些自定义类型）。

我得到的错误是：

 Error:(29, 16) overriding method receive in trait ActorLogger of type =>   
 MyActor.this.Receive;
 method receive needs `abstract override' modifiers
 override def receive: Receive = {
           ^

这是怎么回事？为了实现这样的目标而放弃可堆叠特征是正确的吗？如果不是，最惯用的方法是什么？

更一般地说，除了“拦截器”模式之外，这里是否还应用了另一种模式？

感谢您的帮助！

无需破解的解决方案akka包裹：

import akka.actor.{Actor, ActorSystem, Props}

trait MyActorExtension extends Actor {

  def receiveExtension: Receive = PartialFunction.empty

}

abstract class MyActor extends MyActorExtension {

  protected def receiveMsg: Receive

  def receive: Receive = receiveExtension orElse receiveMsg

}

trait ActorLogger1 extends MyActor with MyActorExtension {

  abstract override def receiveExtension = {
    case msg =>
      println(s"********** Logging # 1: $msg")
      super.receiveExtension.applyOrElse(msg, receiveMsg)
  }

}

trait ActorLogger2 extends MyActor with MyActorExtension {

  abstract override def receiveExtension = {
    case msg =>
      println(s"########## Logging # 2: $msg")
      super.receiveExtension.applyOrElse(msg, receiveMsg)
  }
}

class SpecificActor extends MyActor with ActorLogger1 with ActorLogger2 {

  def receiveMsg = {
    case someMsg =>
      println(s"SpecificActor: $someMsg")
  }
}

object Test extends App {

  val system = ActorSystem("system")
  val mySpecificActor = system.actorOf(Props(new SpecificActor), "SpecificActor")
  mySpecificActor ! "Hello world!"
}

******记录#1：世界你好！

具体演员：世界你好！