将Scala中的trait行为组合到Akka的receive方法中

Question

考虑这两个特征:

trait Poked extends Actor {
  override def receive = {
    case Poke(port, x) => ReceivePoke(port, x)
  }
  def ReceivePoke(port: String, x: Any)
}
trait Peeked extends Actor {
  override def receive = {
    case Peek(port) => ReceivePeek(port)
  }
  def ReceivePeek(port: String)
}

现在考虑我可以创建一个新的Actor来实现这两个特性:

val peekedpoked = actorRef(new Actor extends Poked with Peeked)

如何编写接收处理程序?也就是说，接收器应该类似于下面的代码，尽管是"自动生成的"(也就是说，所有的特征都应该组成):

def receive = (Poked.receive: Receive) orElse (Peeked.receive: Receive) orElse ...

Answer 1

您可以使用super[T]来引用特定超类/trait的成员。

例如:

trait IntActor extends Actor {
    def receive = {
        case i: Int => println("Int!")
    }
}
trait StringActor extends Actor {
    def receive = {
        case s: String => println("String!")
    }
}
class IntOrString extends Actor with IntActor with StringActor {
    override def receive = super[IntActor].receive orElse super[StringActor].receive
}
val a = actorOf[IntOrString].start
a ! 5 //prints Int!
a ! "Hello" //prints String!

编辑:

作为对Hugo评论的回应，这里有一个解决方案，它允许您组合mixins而无需手动将它们的接收连接在一起。从本质上讲，它涉及一个具有可变List[Receive]的基本trait，每个混合trait调用一个方法来将自己的receive添加到列表中。

trait ComposableActor extends Actor {
  private var receives: List[Receive] = List()
  protected def registerReceive(receive: Receive) {
    receives = receive :: receives
  }
  def receive = receives reduce {_ orElse _}
}
trait IntActor extends ComposableActor {
  registerReceive {
    case i: Int => println("Int!")
  }
}
trait StringActor extends ComposableActor {
  registerReceive {
    case s: String => println("String!")
  }
}
val a = actorOf(new ComposableActor with IntActor with StringActor).start
a ! 5 //prints Int!
a ! "test" //prints String!

唯一要记住的是，接收的顺序不应该是重要的，因为您将无法轻松预测哪个是链中的第一个，尽管您可以通过使用可变哈希映射而不是列表来解决这个问题。

Answer 2

您可以在基actor类和链接收的定义中使用空Receive。Akka 2.0-M2样品:

import akka.actor.Actor
import akka.actor.Props
import akka.event.Logging
import akka.actor.ActorSystem
class Logger extends Actor {
  val log = Logging(context.system, this)
  override def receive = new Receive {
    def apply(any: Any) = {}
    def isDefinedAt(any: Any) = false
  }
}
trait Errors extends Logger {
  override def receive = super.receive orElse {
    case "error" => log.info("received error")
  }
}
trait Warns extends Logger {
  override def receive = super.receive orElse {
    case "warn" => log.info("received warn")
  }
}
object Main extends App {
  val system = ActorSystem("mysystem")
  val actor = system.actorOf(Props(new Logger with Errors with Warns), name = "logger")
  actor ! "error"
  actor ! "warn"
}