Akka에서는 StdIn에서 읽는 것과 같이 메소드 호출을 차단하는 것을 어떻게 관리합니까?

Question

스칼라와 AKKA 패턴을 사용하기 시작했습니다.이 코드를 작성했지만 작동하지 않고 이유를 모르겠습니다 ...

사용자를 읽는 작은 프로젝트를 만들었습니다. 콘솔로부터의 입력. 이 사용자가 '키워드'를 작성하면 keyWord Actor (Child)가이를 해석하고 Console Actor (Grand 부모)와 통신합니다.

조치 액터는 방송하고 더 많은 작업을 수행하는 데 사용됩니다.

콘솔 액터에서 'rename'명령을 입력 할 때, 나는 Actor 액터와 그 이후에 keyWord Actor에 입력하고 Rename Method에 입력합니다.하지만 그 이후에는 아무 것도 입력하지 않았습니다. 메서드를 호출합니다.

도와 주시겠습니까?

틀린 설명을 본 사람은 저에게 해결 방법을 알려주지 마십시오. :)

감사합니다.

홈페이지

import ConsoleActor._ 
import akka.actor.ActorSystem 

object Main extends App { 
    val system = ActorSystem("My-Little-IRC") 

    val consoleActor = system.actorOf(ConsoleActor.props, "consoleActor") 

    consoleActor ! ReadConsoleInput 
    system.terminate() 
} 

consoleActor

import ActionActor.TreatInputUser 
import akka.actor.{Actor, Props} 

import scala.io.StdIn 

object ConsoleActor { 

    case class ReadConsoleInput() 
    case class StopLoop() 
    case class Rename() 
    case class WhoIAm() 
    def props = Props[ConsoleActor] 
} 

class ConsoleActor() extends Actor { 
    val keyWordActor = context.actorOf(KeyWordActor.props(this.self), "keyWordActor") 

    val actionActor = context.actorOf(ActionActor.props(keyWordActor), "actionActor") 

    var currentUser: String = "" 
    var loop: Boolean = true; 

    import ConsoleActor._ 

    def isValidString(str: String): Boolean = { 
    var isValid: Boolean = false 

    if (str != null && !str.trim().isEmpty) 
     isValid = true 

    isValid 
    } 

    def initiatePresentation() = { 
    println("Hi ! Who are you ?") 
    currentUser = StdIn.readLine() 
    println(s"Nice to meet you ${currentUser}, I'm your console app !") 

    } 

    def receive = { 
    case ReadConsoleInput => { 
     initiatePresentation 
     var value = "" 
     while (loop) { 
     println("Yes ?") 
     value = StdIn.readLine() 
     if (isValidString(value)) { 
      actionActor ! TreatInputUser(value) 

     } 
     } 
    } 

    case StopLoop => { 
     println("stop Loooop !") 
     loop = false 
    } 
    case Rename => { 
     println(s"${currentUser} was a good name ! Which is your new name ?") 
     currentUser = StdIn.readLine() 
     println(s"Nice to meet you -again- ${currentUser}") 
    } 
    case WhoIAm =>{ 
     println(s"I'm ${currentUser}") 
    } 
    } 
} 

actionActor

import ActionActor.TreatInputUser 

import akka.actor.{Actor, ActorRef, Props} 
import akka.util.Timeout 
import scala.concurrent.duration._ 
import akka.pattern.ask 

import scala.concurrent.Await 


object ActionActor { 
    case class TreatInputUser(string: String) 
    def props(keyWordActor: ActorRef) = Props(new ActionActor(keyWordActor)) 
} 

class ActionActor(keyWordActor: ActorRef) extends Actor { 
    import KeyWordActor._ 

    def receive = { 
    case TreatInputUser(string) => { 
     implicit val timeout = Timeout(5 seconds) 
     var isKeyWord = keyWordActor ? IsKeyWord(string) 
     val isKeyWordResult = Await.result(isKeyWord, timeout.duration).asInstanceOf[ Boolean ] 
     println(isKeyWordResult) 
     if (isKeyWordResult) { 
     keyWordActor ! HandleKeyWord(string) 
     } 
     else { 
     println("bla bla bla") 
     } 
    } 
    } 
} 

키워드 배우

import ConsoleActor.{Rename, StopLoop, WhoIAm} 
import akka.actor.{Actor, ActorRef, Props} 

object KeyWordActor { 
    case class IsKeyWord(key : String) 
    case class HandleKeyWord(key : String) 

    def props(consoleActor: ActorRef) = Props(new KeyWordActor(consoleActor)) 
} 


class KeyWordActor(consoleActor: ActorRef) extends Actor { 

    import KeyWordActor._ 

    val KeysWord : Map[ String,()=> Any] = Map("rename" -> renameFunction, "stop" -> stopFunction, "42" -> uselessfunction, "john doe ?" -> AmIJohnDoe) 

    def renameFunction() = { 
    println("here") 
    consoleActor ! Rename 
    } 

    def stopFunction() = { 
    consoleActor ! StopLoop 
    } 

    def uselessfunction() = { 
    println("useless") 
    } 

    def AmIJohnDoe() ={ 
    consoleActor ! WhoIAm 
    } 

    def receive = { 
    case IsKeyWord(key) => { 
     sender ! KeysWord.contains(key.toLowerCase) 
    } 
    case HandleKeyWord(key) => { 
     if (KeysWord.contains(key.toLowerCase)) { 
     KeysWord(key.toLowerCase)() 
     } 
    } 
    } 
} 

Answer 1

receive 방법으로 차단하면 안됩니다. (while 루프로) 작성한대로 초기 ReadConsoleInput 메시지는 처리가 완료되지 않으며 이후의 모든 메시지 (예 : StopLoop)는 액터 메일함에 영원히 남습니다. 당신은 선택적으로 (반대 그냥 계속 예에 Main 클래스를 읽기 위해) 다음 하나의 접근 방식은 변경 될 수 StdIn에서 읽을해야하는 경우

당신의 ConsoleActor 그래서이 ReadConsoleInput 메시지를 수신 할 때, 그냥 StdIn.readLine을하려고해야 번으로 입력 한 다음 결과를 ActionActor으로 전달하십시오. StdIn.readLine 호출 자체도 차단되므로 비동기 적으로 수행해야합니다. 은 "pipe"패턴은 여기에 유용 : 사용자가 콘솔에서 줄을 입력 완료 할 때마다 ActionActor가 TreatInputUser 메시지가 나타납니다 동안

import akka.pattern.pipe 
import scala.concurrent.Future 

//... 

def receive = { 
    case ReadConsoleInput => 
    import context.dispatcher //provide a thread pool to do async work 
    Future(StdIn.readLine()) //read a line of input asynchronously 
     .filter(isValidString) //only continue if line is valid 
     .map(TreatInputUser) //wrap the (valid) String in a message 
     .pipeTo(actionActor) //forward it 
    case Rename => ... 
} 

이 방법은 ConsoleActor 즉시 다시 새 메시지를 처리하는 데 사용할 수 있습니다.

Await 대신에 ActionActor 안에 동일한 패턴을 적용 할 수 있습니다.

메시지를 계속 보낼 수 있도록 루프를 닫으려면 behaviour을 사용하여 두 개의 StdIn.readLine 호출이 간섭하지 않는지 확인하십시오.