GoLang设计模式15 - 状态模式(行为型)

状态模式，顾名思义，是一种基于有限状态机制的设计模式。在这种设计模式中，行为是由相应的状态来决定的。接下来我们会用一个售卖机的例子来说明下状态模式。为了便于说明，我们把场景简化一下，假设有一台售卖机只卖一种商品，且只有如下四种状态：

  1. 有商品
  2. 无商品
  3. 商品请求中
  4. 已收款

一台售卖机也应该会有多种功能，我们同样做一下简化，假设这台售卖机只有四个功能：

  1. 选择商品
  2. 补充商品
  3. 投币
  4. 吐出商品

什么时候使用状态模式

  • 在一个对象有多种不同状态的时候。对象需要根据当前的请求来改变它的状态
    • 在前面提到的例子中，售卖机将会受到行为的影响从一种状态切换到另一种状态。比如，当“投币”行为结束后，售货机将会从“商品请求中”状态切换到“已收款”状态。
  • 在一个对象需要根据它当前的状态对同一个请求做出不同响应的时候。这个时候使用状态模式可以避免大量的条件声明。
    • 仍然以售卖机为例，当用户想购买商品时，如果售卖机的状态为“有商品”，它就会继续处理，如果售卖机状态为“无商品”，它就会拒绝处理。请注意，这里售卖机根据它“有商品”和“无商品”的状态，对购买商品的请求作出了两种不同的响应。

UML类图

类图如下：

代码

看下代码：

state.go：

1 type state interface {
2     addItem(int) error
3  
4     requestItem() error
5  
6     insertMoney(money int) error
7  
8     dispenseItem() error
9 }

这里简单解释下：

在代码中我们定义了一个State接口，这个接口中有四个函数分别表示了售卖机的四种行为，如下：

  1. 购买商品：addItem(int) error
  2. 请求商品：requestItem() error
  3. 投币：insertMoney(money int) error
  4. 吐出商品：dispenseItem() error

每个具体的状态实现都实现了以上四个函数，并对每种行为发生时该切换到哪种状态，以及如何响应做了处理

每个具体的状态也都嵌入了一个指向当前售卖机的指针，这样以确保状态的切换是发生在这台售卖机上。

vendingMachine.go:

 1 import "fmt"
 2  
 3 type vendingMachine struct {
 4     hasItem       state
 5     itemRequested state
 6     hasMoney      state
 7     noItem        state
 8  
 9     currentState state
10  
11     itemCount int
12     itemPrice int
13 }
14  
15 func (v *vendingMachine) requestItem() error {
16     return v.currentState.requestItem()
17 }
18  
19 func (v *vendingMachine) addItem(count int) error {
20     return v.currentState.addItem(count)
21 }
22  
23 func (v *vendingMachine) insertMoney(money int) error {
24     return v.currentState.insertMoney(money)
25 }
26  
27 func (v *vendingMachine) dispenseItem() error {
28     return v.currentState.dispenseItem()
29 }
30  
31 func (v *vendingMachine) setState(s state) {
32     v.currentState = s
33 }
34  
35 func (v *vendingMachine) incrementItemCount(count int) {
36     fmt.Printf("Adding %d items\n", count)
37     v.itemCount = v.itemCount + count
38 }

注意这段代码，这里面没有任何条件表达式，所有逻辑处理均由相应的状态实现完成。

下面是具体的状态实现。

hasItemState.go:

 1 import "fmt"
 2  
 3 type hasItemState struct {
 4     vendingMachine *vendingMachine
 5 }
 6  
 7 func (i *hasItemState) requestItem() error {
 8     if i.vendingMachine.itemCount == 0 {
 9         i.vendingMachine.setState(i.vendingMachine.noItem)
10         return fmt.Errorf("No item present")
11     }
12     fmt.Printf("Item requestd\n")
13     i.vendingMachine.setState(i.vendingMachine.itemRequested)
14     return nil
15 }
16  
17 func (i *hasItemState) addItem(count int) error {
18     fmt.Printf("%d items added\n", count)
19     i.vendingMachine.incrementItemCount(count)
20     return nil
21 }
22  
23 func (i *hasItemState) insertMoney(money int) error {
24     return fmt.Errorf("Please select item first")
25 }
26 func (i *hasItemState) dispenseItem() error {
27     return fmt.Errorf("Please select item first")
28 }

hasMoneyState.go:

 1 import "fmt"
 2  
 3 type hasMoneyState struct {
 4     vendingMachine *vendingMachine
 5 }
 6  
 7 func (i *hasMoneyState) requestItem() error {
 8     return fmt.Errorf("Item dispense in progress")
 9 }
10  
11 func (i *hasMoneyState) addItem(count int) error {
12     return fmt.Errorf("Item dispense in progress")
13 }
14  
15 func (i *hasMoneyState) insertMoney(money int) error {
16     return fmt.Errorf("Item out of stock")
17 }
18  
19 func (i *hasMoneyState) dispenseItem() error {
20     fmt.Println("Dispensing Item")
21     i.vendingMachine.itemCount = i.vendingMachine.itemCount - 1
22     if i.vendingMachine.itemCount == 0 {
23         i.vendingMachine.setState(i.vendingMachine.noItem)
24     } else {
25         i.vendingMachine.setState(i.vendingMachine.hasItem)
26     }
27     return nil
28 }

itemRequestedState.go:

 1 import "fmt"
 2  
 3 type itemRequestedState struct {
 4     vendingMachine *vendingMachine
 5 }
 6  
 7 func (i *itemRequestedState) requestItem() error {
 8     return fmt.Errorf("Item already requested")
 9 }
10  
11 func (i *itemRequestedState) addItem(count int) error {
12     return fmt.Errorf("Item Dispense in progress")
13 }
14  
15 func (i *itemRequestedState) insertMoney(money int) error {
16     if money < i.vendingMachine.itemPrice {
17         fmt.Errorf("Inserted money is less. Please insert %d", i.vendingMachine.itemPrice)
18     }
19     fmt.Println("Money entered is ok")
20     i.vendingMachine.setState(i.vendingMachine.hasMoney)
21     return nil
22 }
23  
24 func (i *itemRequestedState) dispenseItem() error {
25     return fmt.Errorf("Please insert money first")
26 }

noItemState.go：

 1 import "fmt"
 2  
 3 type noItemState struct {
 4     vendingMachine *vendingMachine
 5 }
 6  
 7 func (i *noItemState) requestItem() error {
 8     return fmt.Errorf("Item out of stock")
 9 }
10  
11 func (i *noItemState) addItem(count int) error {
12     i.vendingMachine.incrementItemCount(count)
13     i.vendingMachine.setState(i.vendingMachine.hasItem)
14     return nil
15 }
16  
17 func (i *noItemState) insertMoney(money int) error {
18     return fmt.Errorf("Item out of stock")
19 }
20  
21 func (i *noItemState) dispenseItem() error {
22     return fmt.Errorf("Item out of stock")
23 }

下面是场景实现main.go:

 1 import (
 2     "fmt"
 3     "log"
 4 )
 5  
 6 func main() {
 7     vendingMachine := newVendingMachine(1, 10)
 8     err := vendingMachine.requestItem()
 9     if err != nil {
10         log.Fatalf(err.Error())
11     }
12     err = vendingMachine.insertMoney(10)
13     if err != nil {
14         log.Fatalf(err.Error())
15     }
16     err = vendingMachine.dispenseItem()
17     if err != nil {
18         log.Fatalf(err.Error())
19     }
20  
21     fmt.Println()
22     err = vendingMachine.addItem(2)
23     if err != nil {
24         log.Fatalf(err.Error())
25     }
26  
27     fmt.Println()
28  
29     err = vendingMachine.requestItem()
30     if err != nil {
31         log.Fatalf(err.Error())
32     }
33  
34     err = vendingMachine.insertMoney(10)
35     if err != nil {
36         log.Fatalf(err.Error())
37     }
38  
39     err = vendingMachine.dispenseItem()
40     if err != nil {
41         log.Fatalf(err.Error())
42     }
43 }
44  
45 func newVendingMachine(itemCount, itemPrice int) *vendingMachine {
46     v := &vendingMachine{
47         itemCount: itemCount,
48         itemPrice: itemPrice,
49     }
50     hasItemState := &hasItemState{
51         vendingMachine: v,
52     }
53     itemRequestedState := &itemRequestedState{
54         vendingMachine: v,
55     }
56     hasMoneyState := &hasMoneyState{
57         vendingMachine: v,
58     }
59     noItemState := &noItemState{
60         vendingMachine: v,
61     }
62  
63     v.setState(hasItemState)
64     v.hasItem = hasItemState
65     v.itemRequested = itemRequestedState
66     v.hasMoney = hasMoneyState
67     v.noItem = noItemState
68     return v
69 }

执行后输出为：

1 Item requestd
2 Money entered is ok
3 Dispensing Item
4  
5 Adding 2 items
6  
7 Item requestd
8 Money entered is ok
9 Dispensing Item

 

posted @ 2023-04-21 11:42  格局打得开  阅读(56)  评论(0)    收藏  举报