针对电信领域中状态机开发、执行和消息/信号传递的本地语言（无FSM生成工具）支持的建议。这些状态机可能非常复杂。
我已经考虑了Erlang，但希望得到反馈、建议、教程指针、特别是基于Java的框架的替代方案。也许Scala?
仅限开源。我不需要与UML或正则表达式相关的解决方案。
由于这是为实现电信协议而做的，因此FSMs可能不是简单的。有许多状态、许多转换、基于信号，输入约束/保护。动态实例化将是一个加分项。选择语句是不可行的，它很快嵌套成无法使用的形式。它只比if/else好一点。
我更喜欢不依赖图形设计；格式FSM描述应该是人类可读/可编辑/可管理的。
--
我决定专注于C++的基于Actor的解决方案
例如，Theron框架提供了一个起点http://theron.ashtonmason.net/，为避免在基于FSM的事件处理程序中使用选择语句，这个C++ FSM模板框架看起来很有用http://satsky.spb.ru/articles/fsm/fsmEng.php
trait State {
def changeState(message: Any): State
}
trait FSM extends Actor {
var state: State
def processMessage(message: Any) {
state = state.changeState(message)
}
override def act() {
loop {
react {
case m: Any => processMessage(m)
}
}
}
}
这是非常基础的代码，但由于我不知道更多的要求，所以这是我能想到的最多的。状态的优点是每个状态都是在一个类中自包含的。
import scala.util.regexp._
import scala.util.automata._
// The goal of this object below is to create a class, MyChar, which will
// be the domain of the tokens used for transitions in the DFA. They could
// be integers, enumerations or even a set of case classes and objects. For
// this particular code, it's just Char.
object MyLang extends WordExp {
type _regexpT = RegExp
type _labelT = MyChar
case class MyChar(c:Char) extends Label
}
// We now need to import the types we defined, as well as any classes we
// created extending Label.
import MyLang._
// We also need an instance (singleton, in this case) of WordBerrySethi,
// which will convert the regular expression into an automatum. Notice the
// language being used is MyLang.
object MyBerrySethi extends WordBerrySethi {
override val lang = MyLang
}
// Last, a function which takes an input in the language we defined,
// and traverses the DFA, returning whether we are at a sink state or
// not. For other uses it will probably make more sense to test against
// both sink states and final states.
def matchDet(pat: DetWordAutom[MyChar], seq: Seq[Char]): Boolean =
!pat.isSink((0 /: seq) ((state, c) => pat.next(state, MyChar(c))))
// This converts a regular expression to a DFA, with using an intermediary NFA
def compile(pat: MyLang._regexpT) =
new SubsetConstruction(MyBerrySethi.automatonFrom(pat, 100000)).determinize
// Defines a "?" function, since it isn't provided by the library
def Quest(rs: _regexpT*) = Alt(Eps, Sequ(rs: _*)) // Quest(pat) = Eps|pat = (pat)?
// And now, the algorithm proper. It splits the string into words
// converts each character into Letter[MyChar[Char]],
// produce the regular expression desired for each word using Quest and Sequ,
// then the final regular expression by using Sequ with each subexpression.
def words(s : String) = s.split("\\W+")
def wordToRegex(w : String) : Seq[MyLang._regexpT] = w.map(c => Letter(MyChar(c)))
def wordRegex(w : String) = Quest(wordToRegex(w) reduceRight ((a,b) => Sequ(a, Quest(b))))
def phraseRegex(s : String) = Sequ(words(s).map(w => wordRegex(w)) : _*)
// This takes a list of strings, produce a DFA for each, and returns a list of
// of tuples formed by DFA and string.
def regexList(l : List[String]) = l.map(s => compile(phraseRegex(s)) -> s)
// The main function takes a list of strings, and returns a function that will
// traverse each DFA, and return all strings associated with DFAs that did not
// end up in a sink state.
def regexSearcher(l : List[String]) = {
val r = regexList(l)
(s : String) => r.filter(t => matchDet(t._1, s)).map(_._2)
}
状态模式（使用Java枚举）是我们在电信应用中使用的模式，但我们使用小型有限状态机：
public class Controller{
private State itsState = State.IDLE;
public void setState(State aState){
itsState = aState;
}
public void action1(){
itsState.action1(this);
}
public void action2(){
itsState.action2(this);
}
public void doAction1(){
// code
}
public void doAction2(){
// code
}
}
public enum State{
IDLE{
@Override
public void action1(Controller aCtx){
aCtx.doAction1();
aCtx.setState(State.STATE1);
}
},
STATE1{
@Override
public void action2(Controller aCtx){
aCtx.doAction2();
aCtx.setState(State.IDLE);
}
},
public void action1(Controller aCtx){
throw new IllegalStateException();
}
public void action2(Controller aCtx){
throw new IllegalStateException();
}
}
我几乎想不出有哪种语言实现FSM是不重要的。也许this one。
...
if (currentState == STATE0 && event == EVENT0) return STATE1;
if (currentState == STATE1 && event == EVENT0) return STATE2;
...
有 case 语句的任何语言都应该很容易实现FSM。你选择的语言应该基于有限状态机需要做什么。
例如，您指出需要在电信开发中执行此操作并提到消息。我会查看支持分布式消息传递的系统/语言。Erlang 可以做到这一点，我相信几乎所有其他常见语言都通过语言的 API /库支持此功能。