在其他演员之间共享一个演员答案

【问题标题】：Sharing an actor among other actors在其他演员之间共享一个演员
【发布时间】：2016-10-20 08:14:42
【问题描述】：

我有一个 AKKA 模型，其中有一个主管 Actor，它创建了许多子 Actor。子 Actor 将处理一个事件并将消息发送到另一个服务（例如 Kafka 主题）。

目前我有一个静态共享类，它在子 Actor 之间共享以发送消息，但在 Actor 模型中，我认为为此目的使用一个 Actor 会更好。

我想知道如何创建一个子演员可以共享的演员。如果主管actor创建MessagePublisheractor，孩子们能找到发送消息给它吗？

谢谢

【问题讨论】：

标签： akka actor

【解决方案1】：

根据用例，您可以在顶层创建共享Actor，也可以将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 )

}

【讨论】：