如何在Akka Actor中实现receive（）

Question

I am in the process of converting Akka UntypedActors in Java code to their Scala equivalent.

However, I am having trouble understanding how to correctly implement the receive() abstract method. The ScalaDoc is a little confusing and most of the examples I see just involve String messages!

My Actor can support multiple message types and this is my solution so far:

override def receive = {
    case message if message.isInstanceOf[ClassOne] => {
        // do something after message.asInstanceOf[ClassOne]
      }
    case message if message.isInstanceOf[ClassTwo] => {
      // do something after message.asInstanceOf[ClassTwo]
    }        
    case message => unhandled(message)
  }

Is there a better way to achieve the above?

Answer 1

override def receive = {
  case c: ClassOne =>
      // do something after message.asInstanceOf[ClassOne]
  case c: ClassTwo =>
  // do something after message.asInstanceOf[ClassTwo]
  case message => unhandled(message)
}

If you're using case classes, you can get more sophisticated.

case class ClassOne(x: Int, y: String)
case class ClassTwo(a: Int, b: Option[ClassOne])

override def receive = {
  case ClassOne(x, y) =>
      println(s"Received $x and $y")
  case ClassTwo(a, Some(ClassOne(x, y)) if a == 42 =>
      // do something
  case ClassTwo(a, None) =>
  case c @ ClassOne(_, "foo") => // only match if y == "foo", now c is your instance of ClassOne
}    

All sorts of fun stuff.

Answer 2

receive 's type is really just a PartialFunction[Any,Unit] , which means you can use Scala's pattern match expressions - in fact, you're already doing it, just not entirely succinctly . A terser equivalent that would also let you handle the type of the match for each case:

def receive = {
    case classOneMessage : ClassOne => {
        // do something
      }
    case classTwoMessage : ClassTwo => {
      // do something 
    }        
    case _ => someCustomLogicHereOtherWiseThereWillBeASilentFailure 
              //you can, but you don't really need to define this case - in Akka 
              //the standard way to go if you want to process unknown messages
              //within *this* actor, is to override the Actor#unhandled(Any) 
              //method instead
  }

Read the tour article , and the already-linked tutorial for more info on pattern matching, especially in the context of using the feature together with case classes - this pattern is applied regularly when working with Akka, for example here in the Akka manual when handling the ActorIdentity case class .

Answer 3

receive is a regular partial function in Scala. You can write something like this in your case:

  case class Example(number: Int, text: String)

  override def receive = {
    case message: ClassOne =>
      // do something with ClassOne instance
    case message: ClassTwo =>
      // do something with ClassTwo instance
    case Example(n, t) =>
      println(t * n)
    case Example(n, t) if n > 10 =>
      println("special case")
  }

You don't have to include a special case for unhandled messages unless your application logic requires you to handle all possible messages.

First two cases just match by type of a message and subtypes will be matched as well. Last one not only matches the type Example but also "deconstructs" it using pattern matching.