akka – acteur DSL

| |

DSL simple acteur

Pour créer des acteurs simples sans créer de nouvelle classe, vous pouvez utiliser :

import akka.actor.ActorDSL._
import akka.actor.ActorSystem
 
implicit val system = ActorSystem("demo")

val a = actor(new Act {
  become {
    case "hello" ⇒ sender() ! "hi"
  }
})

Changement de contexte

Les deux types de sortie possibles d’un context.become (remplacement ou ajout du nouveau comportement) sont proposés séparément afin de permettre une notation sans problème des messages reçus imbriqués :

val a = actor(new Act {
  become { // this will replace the initial (empty) behavior
    case "info" ⇒ sender() ! "A"
    case "switch" ⇒
      becomeStacked { // this will stack upon the "A" behavior
        case "info"   ⇒ sender() ! "B"
        case "switch" ⇒ unbecome() // return to the "A" behavior
      }
    case "lobotomize" ⇒ unbecome() // OH NOES: Actor.emptyBehavior
  }
})

La gestion du cycle de vie

Les hooks de cycle de vie sont également disponibles en tant qu’éléments DSL, avec des appels ultérieurs aux méthodes indiquées ci-dessous remplaçant le contenu des hooks respectifs :

val a = actor(new Act {
  whenStarting { testActor ! "started" }
  whenStopping { testActor ! "stopped" }
})

Ceci est suffisant si le cycle de vie logique de l’acteur correspond aux cycles de redémarrage (c’est-à-dire si Stop est exécuté avant un redémarrage et si Start est démarré après). Si ce n’est pas ce que vous voulez, utilisez les deux crochets suivants :

val a = actor(new Act {
  become {
    case "die" ⇒ throw new Exception
  }
  whenFailing { case m @ (cause, msg) ⇒ testActor ! m }
  whenRestarted { cause ⇒ testActor ! cause }
})

Acteurs imbriqués

Il est également possible d’avoir des acteurs imbriqués, par ex.

// here we pass in the ActorRefFactory explicitly as an example
val a = actor(system, "fred")(new Act {
  val b = actor("barney")(new Act {
    whenStarting { context.parent ! ("hello from " + self.path) }
  })
  become {
    case x ⇒ testActor ! x
  }
})

À vue

Il est également possible d’attribuer une stratégie de surveillance à ces acteurs qui comprend :

superviseWith(OneForOneStrategy() {
  case e: Exception if e.getMessage == "hello" ⇒ Stop
  case _: Exception                            ⇒ Resume
})

Prise en charge de la cachette

Enfin et surtout, il y a un peu de magie pratique qui détermine si la classe d’exécution du sous-type d’acteur spécifié de manière statique étend la propriété RequiresMessageQueue via la propriété stash (c’est une manière compliquée de dire qu’un nouvel acte avec stash ne fonctionnerait pas, puisque le type supprimé au moment de l’exécution n’est qu’un sous-type anonyme d’Act. Le but est d’utiliser automatiquement le type de boîte aux lettres basé sur deque approprié requis pour Stash. Si vous souhaitez utiliser cette magie, développez simplement ActWithStash :

val a = actor(new ActWithStash {
  become {
    case 1 ⇒ stash()
    case 2 ⇒
      testActor ! 2; unstashAll(); becomeStacked {
        case 1 ⇒ testActor ! 1; unbecome()
      }
  }
})
Previous

Des chercheurs montrent que les outils publicitaires de Facebook peuvent cibler un seul utilisateur

La FIA dévoile le calendrier 2022 de Formule 1 avec 23 courses et abandonne la Chine

Next

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.