我是状态机，一颗永远骚动的机器引擎

本文转载自微信公众号「精益码农」，作者小码甲 。转载本文请联系精益码农公众号。

成都创新互联-专业网站定制、快速模板网站建设、高性价比临澧网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式临澧网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖临澧地区。费用合理售后完善，10年实体公司更值得信赖。

状态机是一种行为设计模式，它允许对象在其内部状态改变时改变其行为。看起来好像对象改变了它的类。

请仔细理解上面每一个字。

我们以自动售货机为例，为简化演示，我们假设自动售货机只有1种商品， 故自动售货机有itemCount 、itemPrice 2个属性。

不考虑动作的前后相关性，自动售货机对外暴露4种行为：

  • 给自动售货机加货 addItem
  • 选择商品 requestItem
  • 付钱 insertMoney
  • 出货 dispenseItem

重点来了，当发生某种行为，自动售货机会进入如下4种状态之一， 并据此状态做出特定动作， 之后进入另外一种状态.....

  • 有商品 hasItem
  • 无商品 noItem
  • 已经选好商品 itemRequested
  • 已付钱 hasMoney

当对象可能处于多种不同的状态之一、根据传入的动作更改当前的状态， 继续接受后续动作，状态再次发生变化.....

这样的模式类比于机器引擎，周而复始的工作和状态转化，这也是状态机的定语叫“机Machine”的原因。

有了以上思路，我们尝试沟通UML 伪代码：

状态机设计模式的伪代码实现：

  • 所谓的机器Machine维护了状态切换的上下文
  • 机器对外暴露的行为，驱动机器的状态变更， 行为和状态是有因果关系的
  • 机器到达特定的状态 只具备特定的行为，其他行为是不被允许的， 这在外面看，貌似是对象改变了原类的行为

下面使用golang实现了 状态机设计模型：这里你也可以看下golang 是如何体现OOP中的类继承、接口实现

goodMachine：状态变更上下文

 
 
 
 
    
  
  
  
  
  1. package main 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import ( 
    4.   
  
  
  
  4.  "fmt" 
    5.   
  
  
  
  5.  "reflect" 
    6.   
  
  
  
  6. ) 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8. type goodMachine struct { 
    9.   
  
  
  
  9.  currentState state 
    10.   
  
  
  
  10.  itemCount    int 
    11.   
  
  
  
  11.  itemPrice    int 
    12.   
  
  
  
  12. } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14. func newGoodMachine(itemCount, itemPrice int) *goodMachine { 
    15.   
  
  
  
  15.  v := &goodMachine{ 
    16.   
  
  
  
  16.   itemCount: itemCount, 
    17.   
  
  
  
  17.   itemPrice: itemPrice, 
    18.   
  
  
  
  18.  } 
    19.   
  
  
  
  19.  if itemCount <= 0 { 
    20.   
  
  
  
  20.   v.setState(&noItemState{v}) // 实现state接口的是*noItemState 指针类型 
    21.   
  
  
  
  21.  } else { 
    22.   
  
  
  
  22.   v.setState(&hasItemState{v}) 
    23.   
  
  
  
  23.  } 
    24.   
  
  
  
  24.  return v 
    25.   
  
  
  
  25. } 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27. func (v *goodMachine) setState(s state) { 
    28.   
  
  
  
  28.  fmt.Println("enter state: ", reflect.TypeOf(s)) 
    29.   
  
  
  
  29.  v.currentState = s 
    30.   
  
  
  
  30. } 
    31.   
  
  
  
  31.  
    32.   
  
  
  
  32. func (v *goodMachine) requestItem() error { 
    33.   
  
  
  
  33.  return v.currentState.requestItem() 
    34.   
  
  
  
  34. } 
    35.   
  
  
  
  35.  
    36.   
  
  
  
  36. func (v *goodMachine) addItem(count int) error { 
    37.   
  
  
  
  37.  return v.currentState.addItem(count) 
    38.   
  
  
  
  38. } 
    39.   
  
  
  
  39.  
    40.   
  
  
  
  40. func (v *goodMachine) insertMoney(money int) error { 
    41.   
  
  
  
  41.  return v.currentState.insertMoney(money) 
    42.   
  
  
  
  42. } 
    43.   
  
  
  
  43.  
    44.   
  
  
  
  44. func (v *goodMachine) incrementItemCount(count int) { 
    45.   
  
  
  
  45.  v.itemCount += count 
    46.   
  
  
  
  46. } 
    47.   
  
  
  
  47.  
    48.   
  
  
  
  48. func (v goodMachine) dispenseItem() error { 
    49.   
  
  
  
  49.  return v.currentState.dispenseItem() 
    50.   
  
  
  
  50. } 
    51.

自动售货机对外的行为，被委托给特定的state对象

state：自动售货机对外暴露的行为

 
 
 
 
    
  
  
  
  
  1. package main 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. //  代表某种状态，能接受的某种动作 
    4.   
  
  
  
  4. type state interface { 
    5.   
  
  
  
  5.  addItem(count int) error 
    6.   
  
  
  
  6.  requestItem() error 
    7.   
  
  
  
  7.  insertMoney(money int) error 
    8.   
  
  
  
  8.  dispenseItem() error 
    9.   
  
  
  
  9. } 
    10.

noItemState : 无商品

 
 
 
 
    
  
  
  
  
  1. package main 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import "fmt" 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. type noItemState struct { 
    6.   
  
  
  
  6.  *goodMachine // 存在匿名类型 goodMachine，类型是*goodMachine 
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. //  给自动售货机供货-----> 有货状态 
    10.   
  
  
  
  10. func (i *noItemState) addItem(count int) error { 
    11.   
  
  
  
  11.  i.incrementItemCount(count) 
    12.   
  
  
  
  12.  i.setState(&hasItemState{i.goodMachine}) 
    13.   
  
  
  
  13.  return nil 
    14.   
  
  
  
  14. } 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16. func (i *noItemState) requestItem() error { 
    17.   
  
  
  
  17.  return fmt.Errorf("item out of  stock") 
    18.   
  
  
  
  18. } 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20. func (i *noItemState) insertMoney(money int) error { 
    21.   
  
  
  
  21.  return fmt.Errorf("item out of stock") 
    22.   
  
  
  
  22. } 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24. func (i *noItemState) dispenseItem() error { 
    25.   
  
  
  
  25.  return fmt.Errorf("item out of stock") 
    26.   
  
  
  
  26. } 
    27.   
  
  
  
  27.  
    28.   
  
  
  
  28. // golang: 使用指针接受者实现了state接口的全部函数，那么隐式表明*noItemState 指针类型实现了State接口 
    29.

注意：noItemState 结构体内定义了 goodMachine， 就表明noItemState继承了goodMachine类 ;

指针接受者 noItemState实现了state接口的所有函数，那么我们就说*noItemState实现了state接口。

hasItemState: 有商品

 
 
 
 
    
  
  
  
  
  1. package main 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import "fmt" 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. type hasItemState struct { 
    6.   
  
  
  
  6.  *goodMachine 
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. func (v *hasItemState) addItem(count int) error { 
    10.   
  
  
  
  10.  v.incrementItemCount(count) 
    11.   
  
  
  
  11.  return nil 
    12.   
  
  
  
  12. } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14. // 有人选择了商品---> 没货状态/已经选定商品 
    15.   
  
  
  
  15. func (v *hasItemState) requestItem() error { 
    16.   
  
  
  
  16.  if v.goodMachine.itemCount == 0 { 
    17.   
  
  
  
  17.   v.setState(&noItemState{v.goodMachine}) 
    18.   
  
  
  
  18.   return fmt.Errorf("no item present") 
    19.   
  
  
  
  19.  } 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.  fmt.Print("item  requested\n") 
    22.   
  
  
  
  22.  v.setState(&itemRequestedState{v.goodMachine}) 
    23.   
  
  
  
  23.  return nil 
    24.   
  
  
  
  24. } 
    25.   
  
  
  
  25.  
    26.   
  
  
  
  26. func (v *hasItemState) insertMoney(money int) error { 
    27.   
  
  
  
  27.  return fmt.Errorf("Please select item first") 
    28.   
  
  
  
  28. } 
    29.   
  
  
  
  29.  
    30.   
  
  
  
  30. func (v *hasItemState) dispenseItem() error { 
    31.   
  
  
  
  31.  return fmt.Errorf("Please select item first") 
    32.   
  
  
  
  32. } 
    33.

itemRequestedState：有人选定商品

 
 
 
 
    
  
  
  
  
  1. package main 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import "fmt" 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. type itemRequestedState struct { 
    6.   
  
  
  
  6.  *goodMachine 
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. func (i *itemRequestedState) addItem(count int) error { 
    10.   
  
  
  
  10.  return fmt.Errorf("shopping is  in  process") 
    11.   
  
  
  
  11. } 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13. func (i *itemRequestedState) requestItem() error { 
    14.   
  
  
  
  14.  return fmt.Errorf("item already requested") 
    15.   
  
  
  
  15. } 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17. // 付钱----> 已收钱状态 
    18.   
  
  
  
  18. func (i *itemRequestedState) insertMoney(money int) error { 
    19.   
  
  
  
  19.  if money < i.goodMachine.itemPrice { 
    20.   
  
  
  
  20.   fmt.Errorf("insert money is less, please insert %d", i.goodMachine) 
    21.   
  
  
  
  21.  } 
    22.   
  
  
  
  22.  fmt.Println("money entered is ok") 
    23.   
  
  
  
  23.  i.setState(&hasMoneyState{i.goodMachine}) 
    24.   
  
  
  
  24.  return nil 
    25.   
  
  
  
  25. } 
    26.   
  
  
  
  26. func (i *itemRequestedState) dispenseItem() error { 
    27.   
  
  
  
  27.  return fmt.Errorf("please insert money first") 
    28.   
  
  
  
  28. } 
    29.

hasMoneyState：已付钱

 
 
 
 
    
  
  
  
  
  1. package main 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import "fmt" 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. type hasMoneyState struct { 
    6.   
  
  
  
  6.  *goodMachine 
    7.   
  
  
  
  7. } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. func (i *hasMoneyState) addItem(count int) error { 
    10.   
  
  
  
  10.  return fmt.Errorf("shopping is in process") 
    11.   
  
  
  
  11. } 
    12.   
  
  
  
  12. func (i *hasMoneyState) requestItem() error { 
    13.   
  
  
  
  13.  return fmt.Errorf("shopping is in process") 
    14.   
  
  
  
  14. } 
    15.   
  
  
  
  15. func (i *hasMoneyState) insertMoney(money int) error { 
    16.   
  
  
  
  16.  return fmt.Errorf("already pay money") 
    17.   
  
  
  
  17. } 
    18.   
  
  
  
  18. func (i *hasMoneyState) dispenseItem() error { 
    19.   
  
  
  
  19.  fmt.Println("dispensing item") 
    20.   
  
  
  
  20.  i.goodMachine.itemCount = i.goodMachine.itemCount - 1 
    21.   
  
  
  
  21.  if i.goodMachine.itemCount == 0 { 
    22.   
  
  
  
  22.   i.setState(&noItemState{i.goodMachine}) 
    23.   
  
  
  
  23.  } else { 
    24.   
  
  
  
  24.   i.setState(&hasItemState{i.goodMachine}) 
    25.   
  
  
  
  25.  } 
    26.   
  
  
  
  26.  return nil 
    27.   
  
  
  
  27. } 
    28.

main.go 执行

 
 
 
 
    
  
  
  
  
  1. package main 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import ( 
    4.   
  
  
  
  4.   "fmt" 
    5.   
  
  
  
  5.   "log" 
    6.   
  
  
  
  6. ) 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8. func main() { 
    9.   
  
  
  
  9.   goodMachine := newGoodMachine(1, 10) 
    10.   
  
  
  
  10.   err := goodMachine.requestItem() 
    11.   
  
  
  
  11.   if err != nil { 
    12.   
  
  
  
  12.     log.Fatalf(err.Error()) 
    13.   
  
  
  
  13.   } 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15.   err = goodMachine.insertMoney(10) 
    16.   
  
  
  
  16.   if err != nil { 
    17.   
  
  
  
  17.     log.Fatalf(err.Error()) 
    18.   
  
  
  
  18.   } 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.   err = goodMachine.dispenseItem() 
    21.   
  
  
  
  21.   if err != nil { 
    22.   
  
  
  
  22.     log.Fatalf(err.Error()) 
    23.   
  
  
  
  23.   } 
    24.   
  
  
  
  24.   fmt.Println() 
    25.   
  
  
  
  25.  
    26.   
  
  
  
  26.   err = goodMachine.requestItem() 
    27.   
  
  
  
  27.   if err != nil { 
    28.   
  
  
  
  28.     log.Fatalf(err.Error()) 
    29.   
  
  
  
  29.   } 
    30.   
  
  
  
  30.   err = goodMachine.insertMoney(10) 
    31.   
  
  
  
  31.   if err != nil { 
    32.   
  
  
  
  32.     log.Fatal(err.Error()) 
    33.   
  
  
  
  33.   } 
    34.   
  
  
  
  34.   err = goodMachine.dispenseItem() 
    35.   
  
  
  
  35.   if err != nil { 
    36.   
  
  
  
  36.     log.Fatalf(err.Error()) 
    37.   
  
  
  
  37.   } 
    38.   
  
  
  
  38. } 
    39.

初始化了商品数量为1，价格为10 的自动售货机，连续掏10元钱买两次, 随时打印状态, 输出如下：

 
 
 
 
    
  
  
  
  
  1. enter state:  *main.hasItemState 
    2.   
  
  
  
  2. item  requested 
    3.   
  
  
  
  3. enter state:  *main.itemRequestedState 
    4.   
  
  
  
  4. money entered is ok 
    5.   
  
  
  
  5. enter state:  *main.hasMoneyState      
    6.   
  
  
  
  6. dispensing item 
    7.   
  
  
  
  7. enter state:  *main.noItemState        
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. 2021/08/11 17:39:45 item out of  stock 
    10.   
  
  
  
  10. exit status 1 
    11.

状态机为什么定语是机器?Machine?

状态机表现了：

对象的状态受外界行为所影响，不断的切换，到达特定的状态又只能接受特定的行为， 真实生动的体现了机器Machine引擎的特征。

本文示例亦是学习golang OOP编程的范例，golang 类继承、接口实现实在是太秀了。

github: https://github.com/zaozaoniao/statemachine

网页名称：我是状态机，一颗永远骚动的机器引擎
文章源于：http://www.csdahua.cn/qtweb/news27/198327.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站导航知识

分类信息网

广汉锦华建材　　 　柔性防护网　　 　犀浦门窗定制　　 　新网创想　　 　微信公众号开发　　 　重庆做网站　　 　网络营销推广　　 　高端网站策划　　 　3D立体画　　 　网站制作　　 　ssl数字证书　　 　娄底尾呼妄服装　　 　成都网站制作　　 　成都关键词SEO优化　　 　重庆小程序开发公司　　 　微信小程序　　 　网站优化公司　　 　电商网店　　 　营山网站建设　　 　四川雅安服务器托管