模式

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。 使用不同的名称很容易，也可以使用自己的宏，或者只使用标准代码设置功能。 变换的优势！ 因为它与标准代码不同，所以在转换发生时很容易阅读和识别。