在其他参与者之间共享一个参与者

Question

我有一个AKKA模型，有一个主管演员，他创造了许多儿童演员。子参与者将处理一个事件并将消息发送到另一个服务（例如Kafka topic）。

目前，我有一个静态共享类，它在子参与者之间共享以发送消息，但在参与者模型中，我认为最好使用参与者来实现这一目的。

我想知道我如何才能创造一个演员，儿童演员可以分享它。如果supervisor actor创建了MessagePublisher actor，那么孩子们能找到一个将消息发送给它的角色吗？

非常感谢。

Answer 1

根据用例的不同，您可以在顶层创建共享的Actor，也可以作为您的主管的子Actor。然后，您只需使用消息或构造函数将ActorRef传递给主管/子参与者，并将其保持为Actor内部状态。

下面的代码应该对其进行说明（它是Scala，但将其转换为Java应该非常容易）。

package test

import akka.actor.Actor.Receive
import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import akka.stream.ActorMaterializer

object TestClass extends App {

    implicit val system = ActorSystem( "ActorSystem" )

    implicit val executor = system.dispatcher

    implicit val materializer = ActorMaterializer( )

    //Option 1 Create as top level actor and pass to supervisor with init message
    val sharedActor: ActorRef = system.actorOf( Props[ SharedActor ] )

    val supervisor: ActorRef = system.actorOf( Props[ SupervisorActor ] )
    supervisor ! InitWithSharedActor( sharedActor )

    supervisor ! "NoArgsChild"
    supervisor ! "ArgsChild"

    class SupervisorActor extends Actor {
            private var sharedActor: Option[ ActorRef ] = None

            override def preStart( ) = {
                    //Option 2 Init as child actor of supervisor
                    println( "Start Supervisor" )
                    sharedActor = Some( context.actorOf( Props[ SharedActor ] ) )
            }

            override def receive: Receive = {
                    case InitWithSharedActor( sa ) =>
                            sharedActor = Some( sa )
                    case "NoArgsChild" =>
                            //Pass to child actor in init msg
                            sharedActor.foreach( sa => context.actorOf( Props[ ChildActor ] ) ! InitWithSharedActor( sa ) )
                    case "ArgsChild" =>
                            //Pass to child with constructor
                            sharedActor.foreach( sa => context.actorOf( Props( new ChildActorWithArgs( sa ) ) ) )
            }
    }

    class SharedActor extends Actor {

            override def preStart( ) = {
                    println( "Start Shared Actor" )
            }

            override def receive: Receive = {
                    case _ =>
            }
    }

    class ChildActor extends Actor {
            private var sharedActor: Option[ ActorRef ] = None

            override def preStart( ) = {
                    println( "Start NoArg Child Actor" )
            }

            override def receive: Receive = {
                    case InitWithSharedActor( sa ) => sharedActor = Some( sa )
            }
    }

    class ChildActorWithArgs( sharedActor: ActorRef ) extends Actor {

            override def preStart( ) = {
                    println( "Start WithArg Child Actor" )
            }

            override def receive: Receive = {
                    case _ =>
            }
    }

    case class InitWithSharedActor( sharedActor: ActorRef )

}