前言

在设计电商系统订单模块时，订单会涉及各种状态以及状态与状态之间的流转，可扩展性、可维护性 是我们需要关注的重点！本文分享一下我的技术方案。

389840-20210705193918302-48805829.png

如上图，使用 golang 实现上图的订单流转，同时当后续增加订单状态或订单事件时，可以进行快速完成。

目的

关于订单状态的处理，使用统一入口，提高程序的 可扩展性 和 可维护性。

逻辑分析

订单状态包括：默认、已预订、已确认、已锁定。

订单事件包括：创建订单、确认订单、修改订单、支付订单。

通过上图我们还知道了状态与事件之间的关系，比如只有 已确认 的订单才可以进行 修改订单。

需要考虑如下问题：

  1. 当订单状态增加时，如何尽可能少的改动或改动对历史影响不大？
  2. 如果在同一入口调用，每个事件的处理方法需要的入参都有所不同，如何处理？
  3. 当某个事件完成后，有可能会进行发短信或客户端 Push 的操作，如何处理？
  4. 有可能某个事件，在不同平台(C端、商家后台、管理平台)的处理逻辑也有些不同，如何处理？

如何设计代码能够解决以上问题？

下面是我的一种代码实现，供大家参考，实现了在 创建订单 时，进行传入参数和完成后给用户发送短信，其他事件的操作，同理就可以实现。

代码实现

定义状态

  1. // 定义订单状态
  2. const (
  3.     StatusDefault   = State(0)
  4.     StatusReserved  = State(10)
  5.     StatusConfirmed = State(20)
  6.     StatusLocked    = State(30)
  7. )
  9. // statusText 定义订单状态文案
  10. var statusText = map[State]string{
  11.     StatusDefault:   "默认",
  12.     StatusReserved:  "已预订",
  13.     StatusConfirmed: "已确认",
  14.     StatusLocked:    "已锁定",
  15. }
  17. // statusEvent 定义订单状态对应的可操作事件
  18. var statusEvent = map[State][]Event{
  19.     StatusDefault:   {EventCreate},
  20.     StatusReserved:  {EventConfirm},
  21.     StatusConfirmed: {EventModify, EventPay},
  22. }
  24. func StatusText(status State) string {
  25.     return statusText[status]
  26. }

当有新订单状态的增加时，在此文件中增加相应状态即可，同时维护好订单状态与订单事件之间的关系。

定义事件

  1. // 定义订单事件
  2. const (
  3.     EventCreate  = Event("创建订单")
  4.     EventConfirm = Event("确定订单")
  5.     EventModify  = Event("修改订单")
  6.     EventPay     = Event("支付订单")
  7. )
  9. // 定义订单事件对应的处理方法
  10. var eventHandler = map[Event]Handler{
  11.     EventCreate:  handlerCreate,
  12.     EventConfirm: handlerConfirm,
  13.     EventModify:  handlerModify,
  14.     EventPay:     handlerPay,
  15. }

当有新订单事件的增加时，在此文件中增加相应事件即可，同时维护好订单事件与事件实现方法之间的关系。

定义事件的处理方法

  1. var (
  2.     // handlerCreate 创建订单
  3.     handlerCreate = Handler(func(opt *Opt) (State, error) {
  4.         message := fmt.Sprintf("正在处理创建订单逻辑，订单ID(%d), 订单名称(%s) ... 处理完毕！", opt.OrderId, opt.OrderName)
  5.         fmt.Println(message)
  7.         if opt.HandlerSendSMS != nil {
  8.             _ = opt.HandlerSendSMS("18888888888", "恭喜你预定成功了！")
  9.         }
  11.         return StatusReserved, nil
  12.     })
  14.     // handlerConfirm 确认订单
  15.     handlerConfirm = Handler(func(opt *Opt) (State, error) {
  16.         return StatusConfirmed, nil
  17.     })
  19.     // handlerModify 修改订单
  20.     handlerModify = Handler(func(opt *Opt) (State, error) {
  21.         return StatusReserved, nil
  22.     })
  24.     // handlerPay 支付订单
  25.     handlerPay = Handler(func(opt *Opt) (State, error) {
  26.         return StatusLocked, nil
  27.     })
  28. )

在此文件中维护具体的事件处理方法，如果逻辑比较复杂可以考虑拆分文件处理。

核心代码

  1. type State int                             // 状态
  2. type Event string                          // 事件
  3. type Handler func(opt *Opt) (State, error) // 处理方法，并返回新的状态
  5. // FSM 有限状态机
  6. type FSM struct {
  7.     mu       sync.Mutex                  // 排他锁
  8.     state    State                       // 当前状态
  9.     handlers map[State]map[Event]Handler // 当前状态可触发的有限个事件
  10. }
  12. // 获取当前状态
  13. func (f *FSM) getState() State {
  14.     return f.state
  15. }
  17. // 设置当前状态
  18. func (f *FSM) setState(newState State) {
  19.     f.state = newState
  20. }
  22. // addHandlers 添加事件和处理方法
  23. func (f *FSM) addHandlers() (*FSM, error) {
  24.     ...
  26.     return f, nil
  27. }
  29. // Call 事件处理
  30. func (f *FSM) Call(event Event, opts ...Option) (State, error) {
  31.     f.mu.Lock()
  32.     defer f.mu.Unlock()
  34.     ...
  36.     return f.getState(), nil
  37. }
  39. // NewFSM 实例化 FSM
  40. func NewFSM(initState State) (fsm *FSM, err error) {
  41.     fsm = new(FSM)
  42.     fsm.state = initState
  43.     fsm.handlers = make(map[State]map[Event]Handler)
  45.     fsm, err = fsm.addHandlers()
  46.     if err != nil {
  47.         return
  48.     }
  50.     return
  51. }

对订单状态的操作，只需要使用 Call 方法即可！

关于方法 addHandlers 和 Call 的代码就不贴了，在文章后面我提供了源码地址，供大家下载。

调用方式

例如当前状态为 默认状态，依次进行如下操作：

  • 创建订单，状态变为 已预订；
  • 修改订单，不可操作（已预订状态不可修改）；
  • 确定订单，状态变为 已确认；
  • 修改订单，状态变为 已预订；
  • 确定订单，状态变为 已确认；
  • 支付订单，状态变为 已锁定；
  1. // 通过订单ID 或 其他信息查询到订单状态
  2. orderStatus := order.StatusDefault
  4. orderMachine, err := order.NewFSM(orderStatus)
  5. if err != nil {
  6.     fmt.Println(err.Error())
  7.     return
  8. }
  10. // 创建订单，订单创建成功后再给用户发送短信
  11. if _, err = orderMachine.Call(order.EventCreate,
  12.     order.WithOrderId(1),
  13.     order.WithOrderName("测试订单"),
  14.     order.WithHandlerSendSMS(sendSMS),
  15. ); err != nil {
  16.     fmt.Println(err.Error())
  17. }
  19. // 修改订单
  20. if _, err = orderMachine.Call(order.EventModify); err != nil {
  21.     fmt.Println(err.Error())
  22. }
  24. // 确认订单
  25. if _, err = orderMachine.Call(order.EventConfirm); err != nil {
  26.     fmt.Println(err.Error())
  27. }
  29. // 修改订单
  30. if _, err = orderMachine.Call(order.EventModify); err != nil {
  31.     fmt.Println(err.Error())
  32. }
  34. // 确认订单
  35. if _, err = orderMachine.Call(order.EventConfirm); err != nil {
  36.     fmt.Println(err.Error())
  37. }
  39. // 支付订单
  40. if _, err = orderMachine.Call(order.EventPay); err != nil {
  41.     fmt.Println(err.Error())
  42. }

输出：

  1. 正在处理创建订单逻辑，订单ID(1), 订单名称(测试订单) ... 处理完毕！
  2. 发送短信，给(18888888888)发送了(恭喜你预定成功了！)
  3. 操作[创建订单]，状态从 [默认] 变成 [已预订]
  4. [警告] 状态(已预订)不允许操作(修改订单)
  5. 操作[确定订单]，状态从 [已预订] 变成 [已确认]
  6. 操作[修改订单]，状态从 [已确认] 变成 [已预订]
  7. 操作[确定订单]，状态从 [已预订] 变成 [已确认]
  8. 操作[支付订单]，状态从 [已确认] 变成 [已锁定]

小结

以上就是我的技术方案，希望能对你有所帮助，感兴趣的可以再进行封装，上述代码已提交到 github go-fsm-order，供下载使用。