作为 Java FSM 示例

Question

请注意：我是一名 Java 开发人员，没有任何 Scala 的应用知识（很遗憾）。我会问答案中提供的任何代码示例都将使用 Akka 的 Java API.

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

所以我有 2 个状态：Off 和 On。您可以通过调用 SomeObject#powerOn(<someArguments>) 打开机器电源来返回 Off -> On。您可以通过调用 SomeObject#powerOff(<someArguments>).

关闭机器电源从 On -> Off 开始

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

Answer 1

我了解 Scala 中的 Actors。
这个 Java 开始代码可能会帮助你，继续：

是的，从 AbstractFSM 扩展您的 SimpleFSM。
该州是 AbstractFSM 中的一个 enum。
您的 <someArguments> 可以是 AbstractFSM
中的 Data 部分您的 powerOn 和 powerOff 是演员 Messages/Events。状态切换在转换部分

// states
enum State {
  Off, On
}

enum Uninitialized implements Data {
  Uninitialized
}

public class SimpleFSM extends AbstractFSM<State, Data> {
    {
        // fsm body
        startWith(Off, Uninitialized);

        // transitions
        when(Off,
            matchEvent(... .class ...,
            (... Variable Names ...) ->
              goTo(On).using(...) ); // powerOn(<someArguments>)

        when(On,
            matchEvent(... .class ...,
            (... Variable Names ...) ->
              goTo(Off).using(...) ); // powerOff(<someArguments>)

        initialize();

    }
}

实际工作项目见

Scala and Java 8 with Lambda Template for a Akka AbstractFSM

Answer 2

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

您有两个触发器（或事件或信号）-- 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'"

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

在您的示例中，它没有提供在转换时执行的操作，您基本上有一个状态机，它是一个空操作。动作发生，状态转换没有副作用，而且状态是不可见的，所以一台工作的机器和一台坏掉的机器是一样的。由于这一切都是异步发生的，你甚至不知道什么时候坏掉的。

所以请允许我稍微扩展一下您的合约，并在您的 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。

让我们为您的两个信号定义一对 classes。（AbstractFSM DSL 期望在 class 上匹配）：

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 来保存和修改数据（可能是电灯开关的功率计？），您将构建一个单独的 class 来保存此数据，而不是尝试向您的子[添加新成员] =60=] 的 AbstractFSM。由于我们没有数据，让我们定义一个虚拟的 class 这样您就可以看到它是如何传递的：

public static class NoDataItsJustALightswitch {}

所以，有了这个，我们就可以构建我们的 actor class。

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
    }
}

我确定您在想：我该如何使用它？！因此，让我们为 java:

使用直接的 JUnit 和 Akka Testkit 为您制作一个测试工具

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 的强大功能，因为一个无数据的例子可以作为一组 "become/unbecome" 行为来执行，在一半没有泛型或 lambda 的 LoC 中。 IMO 更具可读性。

PS考虑学习Scala，如果只是为了能够阅读别人的代码！ Atomic Scala 这本书的前半部分可在线免费获得。

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

作为 Java FSM 示例

Akka Java FSM by Example

java

akka

actor

fsm