java - Akka Java FSM 示例

Question

请注意:我是一名 Java 开发人员，不了解 Scala(很遗憾)。我会问答案中提供的任何代码示例都将使用 Akka 的 Java API。

我正在尝试使用 Akka FSM API 对以下 super 简单状态机进行建模。实际上，我的机器要复杂得多，但这个问题的答案可以让我推断出我的实际 FSM。

所以我有 2 个状态:Off和 On .你可以去Off -> On通过调用 SomeObject#powerOn(<someArguments>) 打开机器电源.你可以从On -> Off通过调用 SomeObject#powerOff(<someArguments>) 关闭机器电源.

我想知道我需要哪些参与者和支持类来实现这个 FSM。我相信代表 FSM 的 Actor 必须延长 AbstractFSM .但是什么类代表这两个州？哪些代码公开并实现了 powerOn(...)和 powerOff(...)状态转换？一个有效的 Java 示例，甚至只是 Java 伪代码，对我来说都会有很长的路要走。

Answer 1

我认为我们可以比 FSM 文档 (http://doc.akka.io/docs/akka/snapshot/java/lambda-fsm.html) 中的 copypasta 做得更好。首先，让我们稍微探讨一下您的用例。

您有两个触发器(或事件或信号)——powerOn 和 powerOff。您希望将这些信号发送到一个 Actor 并让它改变状态，其中两个有意义的状态是 On 和 Off。

现在，严格来说 FSM 需要一个额外的组件:您希望在转换时采取的操作。

FSM:
State (S) x Event (E) -> Action (A), State (S')

Read: "When in state S, if signal E is received, produce action A and advance to state S'"

您不需要一个 Action ，但是不能直接检查或直接修改 Actor。所有的变更和确认都是通过异步消息传递发生的。

在您的示例中，它没有提供对转换执行的任何操作，您基本上有一个无操作的状态机。 Action 发生，状态转换没有副作用，而且状态是不可见的，所以一台工作的机器和一台坏掉的机器是一样的。由于这一切都是异步发生的，所以您甚至不知道损坏的东西何时完成。

所以请允许我稍微扩展一下您的合约，并在您的 FSM 定义中包含以下操作:

 When in Off, if powerOn is received, advance state to On and respond to the caller with the new state
 When in On, if powerOff is received, advance state to Off and respond to the caller with the new state

现在我们也许能够构建一个实际可测试的 FSM。

让我们为您的两个信号定义一对类。 (AbstractFSM DSL 期望在类上匹配):

public static class PowerOn {}
public static class PowerOff {}

让我们为您的两个状态定义一对枚举:

 enum LightswitchState { on, off }

让我们定义一个 AbstractFSM Actor ( http://doc.akka.io/japi/akka/2.3.8/akka/actor/AbstractFSM.html )。扩展 AbstractFSM 允许我们使用与上述类似的 FSM 定义链来定义参与者，而不是直接在 onReceive() 方法中定义消息行为。它为这些定义提供了一个不错的小型 DSL，并且(有点奇怪)期望在静态初始化程序中设置这些定义。

不过，绕个弯路:AbstractFSM 定义了两个泛型，用于提供编译时类型检查。

S 是我们希望使用的状态类型的基础，而 D 是数据类型的基础。如果您正在构建一个 FSM 来保存和修改数据(可能是电灯开关的功率计？)，您将构建一个单独的类来保存此数据，而不是尝试向 AbstractFSM 的子类添加新成员。由于我们没有数据，让我们定义一个虚拟类，这样您就可以看到它是如何传递的:

public static class NoDataItsJustALightswitch {}

因此，有了这个，我们就可以构建我们的 actor 类了。

public class Lightswitch extends AbstractFSM<LightswitchState, NoDataItsJustALightswitch> {
    {  //static initializer
        startWith(off, new NoDataItsJustALightswitch()); //okay, we're saying that when a new Lightswitch is born, it'll be in the off state and have a new NoDataItsJustALightswitch() object as data

        //our first FSM definition
        when(off,                                //when in off,
            matchEvent(PowerOn.class,            //if we receive a PowerOn message,
                NoDataItsJustALightswitch.class, //and have data of this type,
                (powerOn, noData) ->             //we'll handle it using this function:
                    goTo(on)                     //go to the on state,
                        .replying(on);           //and reply to the sender that we went to the on state
            )
        );

        //our second FSM definition
        when(on, 
            matchEvent(PowerOff.class, 
                NoDataItsJustALightswitch.class, 
                (powerOn, noData) -> {
                    goTo(off)
                        .replying(off);
                    //here you could use multiline functions,
                    //and use the contents of the event (powerOn) or data (noData) to make decisions, alter content of the state, etc.
                }
            )
        );

        initialize(); //boilerplate
    }
}

我敢肯定您在想:我该如何使用它？!因此，让我们使用直接的 JUnit 和 Akka Testkit for java 为您制作一个测试工具:

public class LightswitchTest { 
    @Test public void testLightswitch() {
        ActorSystem system = ActorSystem.create("lightswitchtest");//should make this static if you're going to test a lot of things, actor systems are a bit expensive
        new JavaTestKit(system) {{ //there's that static initializer again
            ActorRef lightswitch = system.actorOf(Props.create(Lightswitch.class)); //here is our lightswitch. It's an actor ref, a reference to an actor that will be created on 
                                                                                    //our behalf of type Lightswitch. We can't, as mentioned earlier, actually touch the instance 
                                                                                    //of Lightswitch, but we can send messages to it via this reference.

            lightswitch.tell(    //using the reference to our actor, tell it
                new PowerOn(),   //to "Power On," using our message type
                getRef());       //and giving it an actor to call back (in this case, the JavaTestKit itself)

            //because it is asynchronous, the tell will return immediately. Somewhere off in the distance, on another thread, our lightbulb is receiving its message

            expectMsgEquals(LightswitchState.on);   //we block until the lightbulb sends us back a message with its current state ("on.")
                                                     //If our actor is broken, this call will timeout and fail.

            lightswitch.tell(new PowerOff(), getRef());

            expectMsgEquals(LightswitchState.off);   

            system.stop(lightswitch); //switch works, kill the instance, leave the system up for further use
        }};
    }
}

这就是您:一个 FSM 电灯开关。老实说，这个微不足道的例子并没有真正展示 FSM 的强大功能，因为一个无数据的例子可以作为一组“成为/不成为”行为来执行，在一半没有泛型或 lambda 的 LoC 中。 IMO 更具可读性。

PS 考虑学习 Scala，如果只是为了能够阅读其他人的代码! Atomic Sc​​ala 这本书的前半部分可在线免费获取。

PPS 如果您真正想要的只是一个可组合的状态机，我维护 Pulleys ，一个基于纯 java 状态图的状态机引擎。多年来它一直在发展(很多 XML 和旧模式，没有 DI 集成)但如果你真的想将状态机的实现与输入和输出分离，那里可能会有一些灵感。