如何从Akka非Actor类获取ActorSystem中已有Actor的引用？

在Akka里，非Actor类要和已有的Actor通信，核心是拿到目标Actor的ActorRef——毕竟这是Akka中安全通信的唯一入口。下面是几个靠谱的实现方式：

1. 通过ActorSystem的actorSelection查找引用 #

这是最直接的方式，如果你知道目标Actor的完整路径，就可以通过ActorSystem来定位它：

首先，你需要在非Actor类中持有ActorSystem的实例（可以通过构造注入、全局引用等方式拿到），然后用Actor的绝对路径创建ActorSelection，再通过resolveOne方法异步获取ActorRef：

// 假设你的ActorSystem叫mySystem，目标Actor的路径是akka://mySystem/user/TargetActor
val actorSelection = mySystem.actorSelection("akka://mySystem/user/TargetActor")
// 调用resolveOne，设置超时时间（比如5秒）
val actorRefFuture: Future[ActorRef] = actorSelection.resolveOne(5.seconds)

// 处理Future，拿到ActorRef后就可以发消息了
actorRefFuture.onComplete {
  case Success(ref) => ref ! "Hello from non-Actor class"
  case Failure(ex) => println(s"Failed to get ActorRef: ${ex.getMessage}")
}

⚠️ 注意：actorSelection是基于路径的查找，所以要确保路径准确——用户创建的Actor默认都在user路径下。另外，resolveOne是异步操作，需要处理Future的成功/失败场景。

2. 提前将ActorRef注入到非Actor类 #

这是更推荐的方式，因为它避免了路径查找的不确定性（比如Actor重启后路径变化、路径写错等问题）。

在创建非Actor类的时候，直接把目标Actor的ActorRef作为构造参数传进去，或者通过setter方法注入：

// 非Actor类的定义
class NonActorService(targetActor: ActorRef) {
  def sendMessage(msg: String): Unit = {
    targetActor ! msg
  }
}

// 在创建NonActorService的时候，传入已经存在的ActorRef
val targetActor: ActorRef = mySystem.actorOf(Props[TargetActor], "TargetActor")
val nonActorService = new NonActorService(targetActor)

// 直接调用发消息
nonActorService.sendMessage("Hello via injected ActorRef")

这种方式的优势是直接、可靠，ActorRef是不可变且线程安全的，可以安全地在非Actor类中持有和使用。

3. 利用Akka Extension全局存储ActorRef #

如果你的非Actor类是全局使用的，或者需要在多个地方获取同一个Actor的引用，可以用Akka的Extension机制来全局存储ActorRef：

首先定义一个自定义Extension：

object TargetActorExtension extends ExtensionId[TargetActorExtension] with ExtensionIdProvider {
  override def createExtension(system: ExtendedActorSystem): TargetActorExtension =
    new TargetActorExtension(system)

  override def lookup(): ExtensionId[_ <: Extension] = this
}

class TargetActorExtension(system: ExtendedActorSystem) extends Extension {
  private var targetActorRef: Option[ActorRef] = None

  def setTargetActor(ref: ActorRef): Unit = {
    targetActorRef = Some(ref)
  }

  def getTargetActor: Option[ActorRef] = targetActorRef
}

然后在创建目标Actor的时候，把它的ActorRef存入Extension：

val targetActor = mySystem.actorOf(Props[TargetActor], "TargetActor")
TargetActorExtension(mySystem).setTargetActor(targetActor)

最后在非Actor类中，通过Extension获取引用：

class NonActorGlobalService(system: ActorSystem) {
  def sendMessage(msg: String): Unit = {
    TargetActorExtension(system).getTargetActor match {
      case Some(ref) => ref ! msg
      case None => println("Target Actor not initialized yet")
    }
  }
}

这种方式适合需要全局共享Actor引用的场景，但要注意确保Actor在Extension设置完成后再被访问。

内容的提问来源于stack exchange，提问作者rkabhishek