Scala for Backend Engineering & Functional Programming · Leçon

Conception de systèmes d’acteurs

Apprenez à concevoir et à mettre en œuvre des hiérarchies d’acteurs, à définir leurs comportements et à envoyer ou recevoir des messages.

Conception de systèmes d’acteurs est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.

Concevoir des systèmes d’acteurs : introduction

Bienvenue dans la leçon 2 ! Dans la leçon précédente, nous avons étudié les notions de base du modèle d’acteurs d’Akka. Maintenant, approfondissons la conception des systèmes d’acteurs Akka.

Un système d’acteurs bien conçu est robuste, évolutif et facile à maintenir. Nous verrons comment structurer vos acteurs, définir leurs comportements et leur permettre de communiquer efficacement.

Comprendre les hiérarchies d’acteurs

Les acteurs Akka sont organisés selon une hiérarchie arborescente, à la manière d’un système de fichiers. Chaque acteur, à l’exception de l’acteur « racine », a un parent.

Relation parent-enfant : un acteur qui crée un autre acteur devient son parent.
Supervision : cette hiérarchie est essentielle à la tolérance aux pannes d’Akka. Les parents sont responsables de la supervision de leurs enfants (nous approfondirons ce point dans la prochaine leçon !).
Adressage fondé sur le chemin : chaque acteur possède un chemin unique qui reflète sa position dans la hiérarchie, comme /user/parentActor/childActor.

Configurer votre ActorSystem

L’ActorSystem est le point d’entrée de toutes les applications Akka. Il gère les ressources nécessaires aux acteurs, notamment les pools de threads et les planificateurs.

Vous le créez une seule fois par application, puis vous l’utilisez pour créer vos acteurs de premier niveau. Il sert de conteneur pour toute votre application d’acteurs.

Essayez d’exécuter ce code simple pour créer un ActorSystem :

import akka.actor.ActorSystem

object AkkaSystemApp {
  def main(args: Array[String]): Unit = {
    // Create an ActorSystem with a unique name
    val system = ActorSystem("MyFirstActorSystem")
    println("ActorSystem created: " + system.name)

    // Remember to terminate the system when done!
    system.terminate()
  }
}

Définir le comportement d’un acteur

Le comportement d’un acteur détermine sa réaction aux différents messages. En Scala, vous le définissez en étendant le trait Actor et en implémentant la méthode receive.

La méthode receive est une fonction partielle qui associe les messages entrants à des actions précises.
Chaque acteur traite les messages un par un, séquentiellement, ce qui garantit la sécurité des threads pour son état interne.

ActorRef : l’adresse de l’acteur

Vous n’interagissez pas directement avec les instances d’acteurs. À la place, vous envoyez des messages à un ActorRef. Considérez ActorRef comme l’adresse postale d’un acteur.

C’est une référence qui représente un acteur précis au sein du système.
Les messages envoyés à un ActorRef sont placés dans la boîte aux lettres de l’acteur.
Vous obtenez un ActorRef lorsque vous créez un acteur à l’aide de actorOf.

Envoyer des messages aux acteurs

La principale façon dont les acteurs communiquent consiste à s’envoyer des messages. La manière la plus courante d’envoyer un message consiste à utiliser la méthode ! (prononcée « tell »).

receiverActorRef ! "Your message here"

La méthode tell est asynchrone et fonctionne selon le principe « envoyer et oublier ». Elle envoie le message sans attendre de réponse.

Combinons maintenant la création d’un acteur et l’envoi de messages à celui-ci :

import akka.actor.{Actor, ActorRef, Props, ActorSystem}

// 1. Define the actor's behavior
class GreeterActor extends Actor {
  def receive = {
    case "hello" => println(s"Greeter: Hello from ${self.path.name}!")
    case msg: String => println(s"Greeter: Received message: '$msg'")
    case _ => println("Greeter: Received something unexpected!")
  }
}

object SimpleActorApp {
  def main(args: Array[String]): Unit = {
    // 2. Create the ActorSystem
    val system = ActorSystem("GreeterSystem")

    // 3. Create a top-level actor and get its ActorRef
    val greeter: ActorRef = system.actorOf(Props[GreeterActor], "myGreeter")
    
    // 4. Send messages to the actor using '!'
    greeter ! "hello"
    greeter ! "How are you doing today?"
    greeter ! 123 // This will match the _ case

    // Give actors time to process messages, then terminate
    Thread.sleep(1000)
    system.terminate()
  }
}

Créer des acteurs enfants

Les acteurs peuvent créer d’autres acteurs, formant ainsi la hiérarchie dont nous avons parlé. Un acteur parent crée ses acteurs enfants à l’aide de context.actorOf.

context.actorOf : utilisé par un acteur pour créer ses enfants.
system.actorOf : utilisé par l’application pour créer des acteurs de premier niveau (gardiens).

La création d’acteurs enfants aide à organiser votre système, à déléguer les tâches et à isoler les défaillances.

Communication parent-enfant

Les acteurs communiquent en envoyant des messages à l’ActorRef de chacun. Un acteur enfant peut obtenir l’ActorRef de son parent via context.parent. Pour répondre à l’expéditeur d’un message, un acteur peut utiliser sender().

Voyons un exemple dans lequel un parent crée un enfant, lui demande d’effectuer un travail, puis l’enfant signale qu’il a terminé :

import akka.actor.{Actor, ActorRef, Props, ActorSystem}
import scala.concurrent.ExecutionContext.Implicits.global

// Child Actor Definition: Does work and replies to sender
class ChildActor extends Actor {
  def receive = {
    case "work" =>
      println(s"ChildActor (${self.path.name}): Doing work from ${sender().path.name}")
      sender() ! "done" // Reply 'done' to the sender (parent)
  }
}

// Parent Actor Definition: Creates child, sends work, receives reply
class ParentActor extends Actor {
  // Create a child actor when the parent starts
  val child: ActorRef = context.actorOf(Props[ChildActor], "myChild")

  def receive = {
    case "start" =>
      println("ParentActor: Kicking off child's work.")
      child ! "work" // Tell the child to do 'work'
    case "done" =>
      println(s"ParentActor: Child ${sender().path.name} reported 'done'.")
      context.stop(child) // Stop the child actor
      context.stop(self)   // Stop the parent actor
  }
}

object HierarchyApp {
  def main(args: Array[String]): Unit = {
    val system = ActorSystem("HierarchySystem")
    val parent: ActorRef = system.actorOf(Props[ParentActor], "parentActor")
    parent ! "start" // Start the interaction

    // Wait for the system to terminate (actors will stop themselves)
    system.whenTerminated.onComplete(_ => println("ActorSystem terminated."))
  }
}

Arrêter les acteurs proprement

Les acteurs doivent être arrêtés proprement lorsqu’ils ne sont plus nécessaires, afin de libérer les ressources. Vous pouvez arrêter un acteur de plusieurs manières :

context.stop(self) : un acteur s’arrête lui-même.
context.stop(childRef) : un parent arrête l’un de ses enfants.
system.stop(actorRef) : pour les acteurs de premier niveau, même si, généralement, vous arrêtez le système entier.

Lorsqu’un acteur s’arrête, il traite tous les messages présents dans sa boîte aux lettres avant de se terminer. Ses enfants sont également arrêtés de manière récursive.

Vérification rapide : conception d’acteurs

Examinez l’extrait de code d’acteur Akka suivant. Quelle est la bonne manière pour MyChildActor d’envoyer un message à son parent créateur, MyParentActor, si MyParentActor était l’expéditeur du message initial « request » ?

Récapitulatif : concevoir des systèmes d’acteurs

Excellent travail ! Dans cette leçon, nous avons étudié les aspects essentiels de la conception des systèmes d’acteurs Akka :

Les acteurs sont organisés en hiérarchies, essentielles à la supervision et à la structuration.
L’ActorSystem est le point d’entrée de votre application dans Akka.
Vous définissez le comportement des acteurs à l’aide de la méthode receive.
ActorRef est l’adresse utilisée pour envoyer des messages.
Les acteurs communiquent de manière asynchrone à l’aide de la méthode ! (tell).
Les parents créent leurs enfants avec context.actorOf, et les enfants peuvent répondre à l’aide de sender().
Les acteurs peuvent être arrêtés proprement à l’aide de context.stop().

Ensuite, nous étudierons plus en détail les puissantes stratégies de supervision d’Akka et la manière de gérer les défaillances proprement !

Questions Fréquemment Posées

La leçon « Conception de systèmes d’acteurs » est-elle gratuite ?

Oui — le texte complet de « Conception de systèmes d’acteurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Conception de systèmes d’acteurs » ?

Apprenez à concevoir et à mettre en œuvre des hiérarchies d’acteurs, à définir leurs comportements et à envoyer ou recevoir des messages. Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Conception de systèmes d’acteurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Principes fondamentaux du modèle d’acteurs Akka
Conception de systèmes d’acteurs
Supervision et tolérance aux pannes

← Retour à Scala for Backend Engineering & Functional Programming