1、FSM简介
1.1 有限状态机的定义
有限状态机（Finite State Machine，FSM）是一种数学模型，用于描述系统在不同状态下的行为和转移条件。
状态（State）、事件（Event）、动作（Action） State(S) , Event(E) -> Actions (A), State(S’)Event（事件）State（状态）Action（动作）FSM 通常用于编程中，用于实现状态转移和控制流程。
注意：
在任何时刻，FSM 只能处于一种状态。
1.2 Go中的FSM
通过上面关于有限状态机的定义，我们大概知道了状态机是个什么东西，那么Golang中是怎么实现的呢。不用慌，已经有大佬实现好了，只管用就好了。
安装：
go get github.com/looplab/fsm@v1.0.1
github.com/looplab/fsm 2、github.com/looplab/fsm 如何使用
注意：
NewFSMgithub.com/looplab/fsm@v1.0.12.1 fsm 基础使用
这里把官方的例子改了下，感觉官方的例子不是很清晰。代码如下：
package main
import (
"context"
"fmt"
"github.com/looplab/fsm"
)
type Door struct {
Name string
FSM *fsm.FSM
}
func NewDoor(name string) *Door {
d := &Door{
Name: name,
}
d.FSM = fsm.NewFSM(
"closed",
fsm.Events{
{Name: "open", Src: []string{"closed"}, Dst: "open"},
{Name: "close", Src: []string{"open"}, Dst: "closed"},
},
fsm.Callbacks{
"enter_state": func(_ context.Context, e *fsm.Event) { d.enterState(e) },
},
)
return d
}
func (d *Door) enterState(e *fsm.Event) {
fmt.Printf("The door's name:%s , current state:%s\n", d.Name, e.Dst)
}
func main() {
door := NewDoor("测试")
fmt.Printf("fsm current state: %s \n", door.FSM.Current())
err := door.FSM.Event(context.Background(), "open")
if err != nil {
fmt.Println(err)
}
fmt.Printf("fsm current state: %s \n", door.FSM.Current())
err = door.FSM.Event(context.Background(), "close")
if err != nil {
fmt.Println(err)
}
fmt.Printf("fsm current state: %s \n", door.FSM.Current())
}
执行结果：
fsm current state: closed
The door's name:测试 , current state:open
fsm current state: open
The door's name:测试 , current state:closed
fsm current state: closed
EventSrc，Event -> Dst，d.enterStateEventStateSrc->DstAction2.2 fsm 中 Action 何时执行？
d.enterState(e)NewFSM// NewFSM constructs a FSM from events and callbacks.
//
// The events and transitions are specified as a slice of Event structs
// specified as Events. Each Event is mapped to one or more internal
// transitions from Event.Src to Event.Dst.
// Callbacks are added as a map specified as Callbacks where the key is parsed
// as the callback event as follows, and called in the same order:
//
// 1. before_<EVENT> - called before event named <EVENT>
//
// 2. before_event - called before all events
//
// 3. leave_<OLD_STATE> - called before leaving <OLD_STATE>
//
// 4. leave_state - called before leaving all states
//
// 5. enter_<NEW_STATE> - called after entering <NEW_STATE>
//
// 6. enter_state - called after entering all states
//
// 7. after_<EVENT> - called after event named <EVENT>
//
// 8. after_event - called after all events
//
// There are also two short form versions for the most commonly used callbacks.
// They are simply the name of the event or state:
//
// 1. <NEW_STATE> - called after entering <NEW_STATE>
//
// 2. <EVENT> - called after event named <EVENT>
//
// If both a shorthand version and a full version is specified it is undefined
// which version of the callback will end up in the internal map. This is due
// to the pseudo random nature of Go maps. No checking for multiple keys is
// currently performed.
d.enterState(e)called after entering all states2.2.1 完整版书写的Callbacks执行顺序
Callbacks2.2.2 简写版的Callbacks执行顺序
2.2.3 注意事项
Callbacks2.3 较为完整的例子
package main
import (
"context"
"fmt"
"github.com/looplab/fsm"
)
type Door struct {
Name string
FSM *fsm.FSM
}
func NewDoor(name string) *Door {
d := &Door{
Name: name,
}
d.FSM = fsm.NewFSM(
"closed",
fsm.Events{
{Name: "open", Src: []string{"closed"}, Dst: "open"},
{Name: "close", Src: []string{"open"}, Dst: "closed"},
},
fsm.Callbacks{
"before_open": func(_ context.Context, e *fsm.Event) { d.beforeOpen(e) },
"before_event": func(_ context.Context, e *fsm.Event) { d.beforeEvent(e) },
"leave_closed": func(_ context.Context, e *fsm.Event) { d.leaveClosed(e) },
"leave_state": func(_ context.Context, e *fsm.Event) { d.leaveState(e) },
"enter_open": func(_ context.Context, e *fsm.Event) { d.enterOpen(e) },
"enter_state": func(_ context.Context, e *fsm.Event) { d.enterState(e) },
"after_open": func(_ context.Context, e *fsm.Event) { d.afterOpen(e) },
"after_event": func(_ context.Context, e *fsm.Event) { d.afterEvent(e) },
},
)
return d
}
func (d *Door) beforeOpen(e *fsm.Event) {
fmt.Printf("beforeOpen, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
}
func (d *Door) beforeEvent(e *fsm.Event) {
fmt.Printf("beforeEvent, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
}
func (d *Door) leaveClosed(e *fsm.Event) {
fmt.Printf("leaveClosed, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
}
func (d *Door) leaveState(e *fsm.Event) {
fmt.Printf("leaveState, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
}
func (d *Door) enterOpen(e *fsm.Event) {
fmt.Printf("enterOpen, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
}
func (d *Door) enterState(e *fsm.Event) {
fmt.Printf("enterState, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
}
func (d *Door) afterOpen(e *fsm.Event) {
fmt.Printf("afterOpen, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
}
func (d *Door) afterEvent(e *fsm.Event) {
fmt.Printf("afterEvent, current state:%s, Dst:%s \n", d.FSM.Current(), e.Dst)
}
func main() {
door := NewDoor("测试")
fmt.Printf("fsm current state: %s \n", door.FSM.Current())
err := door.FSM.Event(context.Background(), "open")
if err != nil {
fmt.Println(err)
}
fmt.Printf("fsm current state: %s \n", door.FSM.Current())
err = door.FSM.Event(context.Background(), "close")
if err != nil {
fmt.Println(err)
}
fmt.Printf("fsm current state: %s \n", door.FSM.Current())
}
current statefsm current state: closed
beforeOpen, current state:closed, Dst:open
beforeEvent, current state:closed, Dst:open
leaveClosed, current state:closed, Dst:open
leaveState, current state:closed, Dst:open
enterOpen, current state:open, Dst:open
enterState, current state:open, Dst:open
afterOpen, current state:open, Dst:open
afterEvent, current state:open, Dst:open
fsm current state: open
beforeEvent, current state:open, Dst:closed
leaveState, current state:open, Dst:closed
enterState, current state:closed, Dst:closed
afterEvent, current state:closed, Dst:closed
fsm current state: closed
参考资料：