Can an actor have multiple addresses?

Question

Say I wish to model a physical individual with an actor. Such an individual has multiple aliases (all unique), ie email address, social security number, passport number etc.

I want to merge all data associated with any alias.

example

Transaction - ID

#1 - A,B
#2 - B,C
#3 - D

If I assign the actor address by ID, I should have only 2 actors, the first has 3 different addresses (A,B,C) and containing transactions #1 and #2. The second with address D (but not limited to only D) with transaction #3.

#1, #2 - A,B,C   [Actor 1]
#3 - D           [Actor 2]

Additionally, if transaction #4 should arrive with IDs [C,D], I will be left with 1 actor containing all transactions and all aliases (A,B,C,D).

#1,#2,#3,#4 - A,B,C,D   [Actor 1]

Can an actor have multiple addresses, or is there an alternative idiomatic pattern to combine actors?

Answer 1

An actor has only one address.

But you can model each alias as an actor which forwards messages to a target.

An example of this would be along the lines of (in Scala, untyped/classic Akka... things like constructor parameters, Props instances etc. omitted for brevity)

object AliasActor {
  case class AliasFor(ref: ActorRef)
}

class AliasActor extends Actor {
  import AliasActor.AliasFor

  override def receive: Receive = {
    case AliasFor(ref) =>
      // If there's some state associated with this alias that should be forwarded, forward it here
      context.become(aliased(ref))
  }

  def aliased(ref: ActorRef): Receive = {
     case AliasFor(ref) =>
       ()  // Explicitly ignore this message (could log, etc.)

     case msg =>
       ref ! msg
  }
}

IOW, each alias is itself an actor where once it's told which actor it's an alias for, it forwards any message it receives to that actor, thus making a send to the alias equivalent to the send to what it's an alias for (at the cost of some indirection).

You may find cluster sharding a better fit than working with actor addresses, even in the single node case.

In general, there cannot be a general way to combine 2 actors. You have to design their protocol to allow the state of one to be incorporated into the other (or the state of both to be incorporated into a new actor) and then have one forward to the other (or have both forward to the new actor).