Akka - Diễn viên dịch vụ thông thường: Xác định hoặc gia hạn

Question

Giả sử tôi có một số diễn viên lớp dịch vụ diễn viên khác thường được sử dụng. Ví dụ, một dịch vụ đăng ký lưu trữ và lấy đối tượng miền:

case class DomainObject(id: UUID) 

class Registry extends akka.actor.Actor { 
    def receive: Receive = { 
    case o: DomainObject => store(o) // save or update object 

    case id: UUID => sender ! retrieve(id) // retrieve object and send it back 
    } 
} 

Tôi không muốn để vượt qua một cách rõ ràng thể hiện của registry như vào tất cả các diễn viên có thể sử dụng nó. Thay vì nó, tôi muốn họ có thể bằng cách nào đó 'xác định' nó.

Đối với điều này tôi có thể nghĩ ra hai giải pháp:

1. Identify thông điệp: mỗi diễn viên sử dụng registry biết tên diễn viên đăng ký từ một số cấu hình và có khả năng gửi tin nhắn xác định với nó. Sau AgentIdentity thông điệp được nhận lại chúng ta là tốt để đi:

   val registryName = ... // some name 
   val registryId = ... // some id 
   var registry = _ 
   
   def preStart() { 
       context.actorSelection(registryName) ! Identify(registryId) 
   } 
   
   def receive: Receive = { 
       case ActorIdentity(`registryId`, ref) => registry = ref 
   } 
   

   tôi không thích cách này bởi vì ngay sau khi sử dụng diễn viên khởi động có một giai đoạn khi chúng ta không biết nếu có một đăng ký trong hệ thống et tất cả và do đó không biết chúng ta sẽ có thể hoạt động hay không.

2. Tiện ích mở rộng Akka: Tôi có thể tạo tiện ích mở rộng:

   a. tạo thể hiện của tác nhân Đăng ký trong Hệ thống diễn viên được bật khi khởi tạo;

   b. trả về tác nhân này cho người dùng cần nó thông qua một số phương pháp trong phần mở rộng.

   object RegistryKey extends ExtensionKey[RegistryExtension] 
   
   class RegistryExtesion(system: ExtendedActorSystem) extends RegistryKey { 
       val registry = system.actorOf(Props[Registry], "registry") 
   } 
   

Câu hỏi đặt ra là: phương pháp nào là tốt hơn và được Akka Extesions thể được sử dụng cho điều này ở tất cả?

Answer 1

Tôi nghĩ ý tưởng tiện ích mở rộng là một ý tưởng tốt miễn là diễn viên đăng ký của bạn luôn ở trong cùng một ActorSystem.

Ngoài ra, sử dụng actorSelection (chuyển thể từ Remote Lookup):

class RegistryClient extends Actor { 
    val path = "/path/to/registry/actor" 
    context.setReceiveTimeout(3.seconds) 

    def sendIdentifyRequest(): Unit = 
    context.actorSelection(path) ! Identify(path) 

    def receive = { 
    case ActorIdentity(`path`, Some(ref)) ⇒ 
     context.setReceiveTimeout(Duration.Undefined) 
     context.become(active(ref)) 
    case ActorIdentity(`path`, None) ⇒ 
     throw new RuntimeException("Registry not found") 
    case ReceiveTimeout ⇒ sendIdentifyRequest() 
    } 

    def active(registry: ActorRef): Actor.Receive = { 
    // use the registry 
    } 
} 

này sẽ làm việc cho các diễn viên từ xa hoặc địa phương.

Hãy xem giải pháp tiện ích. Actors are created asynchronously. Do đó, hàm tạo mở rộng của bạn sẽ không thành công khi gọi actorOf nếu tác nhân không khởi tạo được.

Nếu bạn muốn biết chắc chắn rằng diễn viên không khởi tạo được thì một cách để biết là ask tác nhân mà nó sẽ trả lời và Await một phản hồi. Await sẽ ném TimeoutException nếu tác nhân không trả lời.

class RegistryExtension(system: ExtendedActorSystem) extends Extension { 
    val registry = system.actorOf(Props[Registry], "registry") 
    implicit val timeout: Timeout = Timeout(500.millis) 
    val f = registry ? "ping" // Registry should case "ping" => "pong" 
    Await.result(f, 500.millis) // Will throw a TimeoutException if registry fails 
           // to respond 
} 

TimeoutException sẽ bị ném khi bạn gọi RegistryExtension(system).registry lần đầu tiên.

Answer 2

Làm thế nào về Cake Pattern hoặc thư viện Dependency Injection chẳng hạn như subcut.

Derek Wyatt đề cập DI trong cuốn sách của ông 'Akka Concurrency' thay vì sử dụng quá nhiều actorFor để tìm kiếm diễn viên: http://www.artima.com/forums/flat.jsp?forum=289&thread=347118