En ce Acteurs Scala Acteurs Akka: Une instance Pour appeler des méthodes sur

Question

Récemment, je commutation des acteurs de la scala à AKKA acteurs, mais on a remarqué que les acteurs utilisent AKKA ActorRef au lieu de l'objet par exemple:

val actorRef: ActorRef = Actor.actorOf(new MyActor)

J'essayé:

val myActor = new MyActor
val actorRef: ActorRef = Actor.actorOf(x)

... pour avoir à la fois: 1) ActorRef pour envoyer des messages et 2) MyActor aux méthodes d'appel sur
. Mais je suis:

akka.actor.ActorInitializationException: ActorRef for instance of actor [MyActor] is not in scope.

Alors ma question est: Comment puis-je obtenir une instance (d'un certain type) sur lequel je peux appeler ActorRef comme des méthodes telles que ! et aussi les méthodes de l'instance MyActor

Answer 1

Ce que vous faites est un terrible idée. Il suffit donc arrêter dès maintenant, pas loin du clavier, et accédez à la Documentation Akka Akka et lire sur les acteurs.

Considérez ceci:

class YourActor extends Actor {
  var mutableStuff = ...
  def receive = {
    case _ =>
      // mess with mutableStuff
  }
  def publicMethod = // mess with mutableStuff
}

Maintenant, configurez votre système et commencer à envoyer des messages et appeler cette méthode à partir d'autres threads. Boom!

Vous faites précisément ce que le modèle et Akka Acteur aide vous empêchez. Vous êtes en fait plier en quatre pour briser ce qu'ils ont déjà fixés :) Ils ne vous laissera pas le faire.

Maintenant, vous pouvez tester l'unité en accédant à des méthodes directement, mais vous avez besoin d'un TestActorRef pour cela. Alors que vous lisez les documents, lisez la section sur les essais.

Answer 2

Le mieux que je peux avec ce qui suit est, très sale:
Est-il possible de mieux?

import akka.actor._

trait ActorCom {
  var actorRefForInitialization: ActorRef = _
  lazy val actorRef: ActorRef = actorRefForInitialization
  def ?(message: Any)(implicit channel: UntypedChannel = NullChannel, timeout: Actor.Timeout = Actor.defaultTimeout) = actorRef ? message
  def !(msg: Any)(implicit sender: UntypedChannel) = actorRef ! msg
  def start = actorRef.start
}

object AkkaActorFactory {
  def apply[A <: Actor](newInstance: => A with ActorCom): A with ActorCom = {
    var instance: Option[A with ActorCom] = None
    val actorRef = Actor.actorOf({
      instance = Some(newInstance)
      instance.get
    })
    instance.get.actorRefForInitialization = actorRef
    instance.get.actorRef // touch lazy val in ActorCom, to make it equal to actorRef and then its fixed (immutable)
    instance.get
  }
}

class MyActor extends Actor {
  def receive = {
    case "test1" => println("good")
    case "test2" => println("fine")
    case _       => println("bad")
  }
  def sendTestMsg2Myself = self ! "test2"
}

val myActor = AkkaActorFactory(newInstance = new MyActor with ActorCom)
myActor.start
myActor ! "test1"
myActor.sendTestMsg2Myself // example for calling methods on MyActor-instance
myActor ! PoisonPill