作为 FSM 的行为

对于非类型化的 Actor，有明确的支持来构建「有限状态机」。在 Akka 类型中不需要支持，因为用行为表示 FSM 很简单。

为了了解如何使用 Akka 类型的 API 来建模 FSM，下面是从「非类型化的 Actor FSM 文档」移植的Buncher示例。它演示了如何：

• 使用不同行为模拟状态
• 通过将行为表示为一种方法，在每个状态下存储数据的模型
• 实现状态超时

FSM 可以接收的事件为 Actor 可以接收的消息类型：

1. interface Event {}
2. static final class SetTarget implements Event {
3. private final ActorRef<Batch> ref;

5. public SetTarget(ActorRef<Batch> ref) {
6. this.ref = ref;
7. }

9. public ActorRef<Batch> getRef() {
10. return ref;
11. }
12. }
13. final class Timeout implements Event {}

15. static final Timeout TIMEOUT = new Timeout();
16. public enum Flush implements Event {
17. FLUSH
18. }
19. static final class Queue implements Event {
20. private final Object obj;

22. public Queue(Object obj) {
23. this.obj = obj;
24. }

26. public Object getObj() {
27. return obj;
28. }
29. }

启动它需要SetTarget，为要传递的Batches设置目标；Queue将添加到内部队列，而Flush将标记突发的结束。

非类型化 FSM 也有一个D（数据）类型参数。Akka 类型化不需要知道这一点，它可以通过将你的行为定义为方法来存储。

1. interface Data {}
2. final class Todo implements Data {
3. private final ActorRef<Batch> target;
4. private final List<Object> queue;

6. public Todo(ActorRef<Batch> target, List<Object> queue) {
7. this.target = target;
8. this.queue = queue;
9. }

11. public ActorRef<Batch> getTarget() {
12. return target;
13. }

15. public List<Object> getQueue() {
16. return queue;
17. }

19. @Override
20. public String toString() {
21. return "Todo{" + "target=" + target + ", queue=" + queue + '}';
22. }

24. public Todo addElement(Object element) {
25. List<Object> nQueue = new LinkedList<>(queue);
26. nQueue.add(element);
27. return new Todo(this.target, nQueue);
28. }

30. public Todo copy(List<Object> queue) {
31. return new Todo(this.target, queue);
32. }

34. public Todo copy(ActorRef<Batch> target) {
35. return new Todo(target, this.queue);
36. }
37. }

每个状态都会变成一种不同的行为。不需要显式goto，因为 Akka 类型已经要求你返回下一个行为。

1. // FSM states represented as behaviors
2. private static Behavior<Event> uninitialized() {
3. return Behaviors.receive(Event.class)
4. .onMessage(
5. SetTarget.class,
6. (context, message) -> idle(new Todo(message.getRef(), Collections.emptyList())))
7. .build();
8. }

10. private static Behavior<Event> idle(Todo data) {
11. return Behaviors.receive(Event.class)
12. .onMessage(Queue.class, (context, message) -> active(data.addElement(message)))
13. .build();
14. }

16. private static Behavior<Event> active(Todo data) {
17. return Behaviors.withTimers(
18. timers -> {
19. // State timeouts done with withTimers
20. timers.startSingleTimer("Timeout", TIMEOUT, Duration.ofSeconds(1));
21. return Behaviors.receive(Event.class)
22. .onMessage(Queue.class, (context, message) -> active(data.addElement(message)))
23. .onMessage(
24. Flush.class,
25. (context, message) -> {
26. data.getTarget().tell(new Batch(data.queue));
27. return idle(data.copy(new ArrayList<>()));
28. })
29. .onMessage(
30. Timeout.class,
31. (context, message) -> {
32. data.getTarget().tell(new Batch(data.queue));
33. return idle(data.copy(new ArrayList<>()));
34. })
35. .build();
36. });
37. }

要设置状态超时，请使用Behaviors.withTimers和startSingleTimer。

以前在onTransition块中所做的任何副作用（side effects）都直接进入行为。

英文原文链接：Behaviors as Finite state machines.