• 模式
    • Ask
    • Transform

    模式

    Ask

    Ask模式允许actor将actor发送到actor系统之外。 该值作为Future传递。

    让我们来看看它是如何工作的：

    1. extern crate riker_patterns;
    3. use riker_patterns::ask;
    5. struct MyActor;
    7. impl Actor for MyActor {
    8.     type Msg = u32;
    10.     fn receive(&mut self,
    11.                 ctx: &Context<Self::Msg>,
    12.                 msg: Self::Msg,
    13.                 sender: ActorRef<Self::Msg>) {
    15.         // sender is the Ask, waiting to a message to be sent back to it
    16.         sender.try_tell(msg * 2, Some(ctx.myself()));
    17.     }
    18. }
    20. fn main() {
    21.     let model: DefaultModel<u32> = DefaultModel::new();
    22.     let sys = ActorSystem::new(&model).unwrap();
    24.     let props = MyActor::props();
    25.     let my_actor = sys.actor_of(props, "my-actor");
    27.     // ask returns a future that automatically is driven
    28.     // to completion by the system.
    29.     let res = ask(&sys, &my_actor, 100);
    31.     // the result future can be passed to a library or fuction that
    32.     // expects a future, or it can be extracted locally using `block_on`.
    34.     let res = block_on(res).unwrap();
    35.     println!("The result value is: {}", res);
    36. }

    在背后，Ask设置了一个临时的中级 Actor，该 Actor在问的一生中生活。其他 Actor将此临时 Actor视为发件人，并可以向其发送消息。当临时询问者收到一条消息时，它会完成未完成的 Future，并自行停止清理。

    当您拥有在actor系统之外运行的应用程序的一部分时，或者在另一个actor系统中，例如服务于API请求的Web服务器（例如Hyper）时，Ask特别有用。然后可以将生成的 Future链接为 Future堆栈的一部分。

    Transform

    变换使得基于其当前状态的 Actor行为更容易被推理。由于参与者维持状态，并且确实是主要关注点，因此能够基于该状态以不同方式处理消息非常重要。 Transform模式通过为每个状态专用接收函数来分离消息处理。这节省了过多的匹配以处理几种可能的状态，即处理行为在状态改变时而不是在每个消息接收时被抢占。

    信息 : 如果你熟悉JVM上的Akka，变换就像变成了。

    1. #[macro_use]
    2. extern crate riker_patterns;
    4. use riker_patterns::ask;
    6. #[derive(Clone, Debug)]
    7. enum MyMsg {
    8.     SetPassword(String), // password
    9.     Authenticate(String), // password
    10. }
    12. impl Into<ActorMsg<MyMsg>> for MyMsg {
    13.     fn into(self) -> ActorMsg<MyMsg> {
    14.         ActorMsg::User(self)
    15.     }
    16. }
    18. struct UserActor {
    19.     username: String,
    20.     password: Option<String>,
    22.     // rec field is required to store current method to be used
    23.     rec: Receive<UserActor, MyMsg>,
    24. }
    26. impl UserActor {
    27.     fn actor(username: String) -> BoxActor<MyMsg> {
    28.         let actor = UserActor {
    29.             username,
    30.             password: None,
    31.             rec: Self::created, // <-- set initial method to `created` stated
    32.         };
    34.         Box::new(actor)
    35.     }
    37.     fn props(username: String) -> BoxActorProd<MyMsg> {
    38.         Props::new_args(Box::new(UserActor::actor), username)
    39.     }
    41.     /// Receive method for this actor when it is in a created state
    42.     /// i.e. password has not yet been set.
    43.     fn created(&mut self,
    44.                 ctx: &Context<MyMsg>,
    45.                 msg: MyMsg,
    46.                 sender: Option<ActorRef<MyMsg>>) {
    48.         match msg {
    49.             MyMsg::SetPassword(passwd) => {
    50.                 self.password = Some(passwd);
    52.                 // send back a result to sender
    53.                 // e.g. `sender.try_tell(Ok, None);`
    55.                 // transform behavior to active state
    56.                 transform!(self, UserActor::active);
    57.             }
    58.             MyMsg::Authenticate(passwd) => {
    59.                 // `MyMsg::Authenticate` is invalid since no user password
    60.                 // has been set.
    61.                 // Signal that this is an error for the current state
    62.                 self.probe.as_ref().unwrap().0.event(ProbeMsg::Err);
    63.             }
    64.         }
    65.     }
    67.     /// Receive method for this actor when a password has been set
    68.     /// and the user account is now active.
    69.     fn active(&mut self,
    70.                 ctx: &Context<MyMsg>,
    71.                 msg: MyMsg,
    72.                 sender: Option<ActorRef<MyMsg>>) {
    74.         match msg {
    75.             MyMsg::Authenticate(passwd) => {
    76.                 // send back an authentication result to sender
    77.                 // e.g. `sender.try_tell(Ok, None);`
    79.                 // signal that this is correct
    80.                 self.probe.as_ref().unwrap().0.event(ProbeMsg::Ok);
    81.             }
    82.             MyMsg::SetPassword(passwd) => {
    83.                 // set a new password
    84.                 self.password = Some(passwd);
    85.             }
    86.         }
    87.     }
    88. }
    90. impl Actor for UserActor {
    91.     type Msg = MyMsg;
    93.     fn receive(&mut self,
    94.                 ctx: &Context<Self::Msg>,
    95.                 msg: Self::Msg,
    96.                 sender: Option<ActorRef<Self::Msg>>) {
    98.         // just call the currently set transform function
    99.         (self.rec)(self, ctx, msg, sender)
    100.     }
    101. }

    注意 : 改造！ 宏期望将self上当前接收函数的字段名称命名为rec。 使用不同的名称很容易，也可以使用自己的宏，或者只使用标准代码设置功能。 变换的优势！ 因为它与标准代码不同，所以在转换发生时很容易阅读和识别。