import akka.actor.{Actor, ActorRef}

class DatabaseServiceActor extends Actor {
  // 这里是数据库服务的逻辑

  override def receive: Receive = {
    case message => // 处理其他actor发送过来的消息
  }
}

import akka.actor.{Actor, ActorRef, Identify, ActorIdentity, Props}

class DatabaseServiceLookupActor extends Actor {
  val databaseServicePath = "/user/databaseService" // 共享服务actor的路径

  override def preStart(): Unit = {
    context.actorSelection(databaseServicePath) ! Identify("databaseService")
  }

  override def receive: Receive = {
    case ActorIdentity("databaseService", Some(databaseServiceActor)) =>
      // 接收到Identify的响应，获取到共享服务actor的引用
      context.become(ready(databaseServiceActor))
    case ActorIdentity("databaseService", None) =>
      // 共享服务actor未找到
      println("Database service not available")
    case _ =>
      // 处理其他消息
  }

  def ready(databaseServiceActor: ActorRef): Receive = {
    case message => // 使用共享服务actor的引用处理消息
  }
}

object DatabaseServiceLookupActor {
  def props: Props = Props(new DatabaseServiceLookupActor)
}

import akka.actor.{ActorSystem, ExtendedActorSystem, Extension, ExtensionId, ExtensionIdProvider}

class DatabaseServiceExtensionImpl(system: ExtendedActorSystem) extends Extension {
  // 这里是数据库服务的初始化逻辑
  val databaseServiceActor: ActorRef = system.actorOf(DatabaseServiceActor.props, "databaseService")
}

object DatabaseServiceExtension extends ExtensionId[DatabaseServiceExtensionImpl] with ExtensionIdProvider {
  override def lookup: DatabaseServiceExtension.type = DatabaseServiceExtension // 实例化扩展对象的方法
  override def createExtension(system: ExtendedActorSystem): DatabaseServiceExtensionImpl =
    new DatabaseServiceExtensionImpl(system)

  override def get(system: ActorSystem): DatabaseServiceExtensionImpl = super.get(system)
}

val system = ActorSystem("mySystem")

val databaseService = DatabaseServiceExtension(system).databaseServiceActor