关于处理电商系统订单状态的流转,分享下我的技术方案(附带源码)

前言

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

order_flow.png

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

目的

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

逻辑分析

订单状态包括:默认已预订已确认已锁定

订单事件包括:创建订单确认订单修改订单支付订单

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

需要考虑如下问题:

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

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

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

代码实现

定义状态

// 定义订单状态
const (
    StatusDefault   = State(0)
    StatusReserved  = State(10)
    StatusConfirmed = State(20)
    StatusLocked    = State(30)
)

// statusText 定义订单状态文案
var statusText = map[State]string{
    StatusDefault:   "默认",
    StatusReserved:  "已预订",
    StatusConfirmed: "已确认",
    StatusLocked:    "已锁定",
}

// statusEvent 定义订单状态对应的可操作事件
var statusEvent = map[State][]Event{
    StatusDefault:   {EventCreate},
    StatusReserved:  {EventConfirm},
    StatusConfirmed: {EventModify, EventPay},
}

func StatusText(status State) string {
    return statusText[status]
}

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

定义事件

// 定义订单事件
const (
    EventCreate  = Event("创建订单")
    EventConfirm = Event("确定订单")
    EventModify  = Event("修改订单")
    EventPay     = Event("支付订单")
)

// 定义订单事件对应的处理方法
var eventHandler = map[Event]Handler{
    EventCreate:  handlerCreate,
    EventConfirm: handlerConfirm,
    EventModify:  handlerModify,
    EventPay:     handlerPay,
}

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

定义事件的处理方法

var (
    // handlerCreate 创建订单
    handlerCreate = Handler(func(opt *Opt) (State, error) {
        message := fmt.Sprintf("正在处理创建订单逻辑,订单ID(%d), 订单名称(%s) ... 处理完毕!", opt.OrderId, opt.OrderName)
        fmt.Println(message)

        if opt.HandlerSendSMS != nil {
            _ = opt.HandlerSendSMS("18888888888", "恭喜你预定成功了!")
        }

        return StatusReserved, nil
    })

    // handlerConfirm 确认订单
    handlerConfirm = Handler(func(opt *Opt) (State, error) {
        return StatusConfirmed, nil
    })

    // handlerModify 修改订单
    handlerModify = Handler(func(opt *Opt) (State, error) {
        return StatusReserved, nil
    })

    // handlerPay 支付订单
    handlerPay = Handler(func(opt *Opt) (State, error) {
        return StatusLocked, nil
    })
)

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

核心代码

type State int                             // 状态
type Event string                          // 事件
type Handler func(opt *Opt) (State, error) // 处理方法,并返回新的状态

// FSM 有限状态机
type FSM struct {
    mu       sync.Mutex                  // 排他锁
    state    State                       // 当前状态
    handlers map[State]map[Event]Handler // 当前状态可触发的有限个事件
}

// 获取当前状态
func (f *FSM) getState() State {
    return f.state
}

// 设置当前状态
func (f *FSM) setState(newState State) {
    f.state = newState
}

// addHandlers 添加事件和处理方法
func (f *FSM) addHandlers() (*FSM, error) {
    ...

    return f, nil
}

// Call 事件处理
func (f *FSM) Call(event Event, opts ...Option) (State, error) {
    f.mu.Lock()
    defer f.mu.Unlock()

    ...

    return f.getState(), nil
}

// NewFSM 实例化 FSM
func NewFSM(initState State) (fsm *FSM, err error) {
    fsm = new(FSM)
    fsm.state = initState
    fsm.handlers = make(map[State]map[Event]Handler)

    fsm, err = fsm.addHandlers()
    if err != nil {
        return
    }

    return
}

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

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

调用方式

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

  • 创建订单,状态变为 已预订
  • 修改订单,不可操作(已预订状态不可修改);
  • 确定订单,状态变为 已确认
  • 修改订单,状态变为 已预订
  • 确定订单,状态变为 已确认
  • 支付订单,状态变为 已锁定
// 通过订单ID 或 其他信息查询到订单状态
orderStatus := order.StatusDefault

orderMachine, err := order.NewFSM(orderStatus)
if err != nil {
    fmt.Println(err.Error())
    return
}

// 创建订单,订单创建成功后再给用户发送短信
if _, err = orderMachine.Call(order.EventCreate,
    order.WithOrderId(1),
    order.WithOrderName("测试订单"),
    order.WithHandlerSendSMS(sendSMS),
); err != nil {
    fmt.Println(err.Error())
}

// 修改订单
if _, err = orderMachine.Call(order.EventModify); err != nil {
    fmt.Println(err.Error())
}

// 确认订单
if _, err = orderMachine.Call(order.EventConfirm); err != nil {
    fmt.Println(err.Error())
}

// 修改订单
if _, err = orderMachine.Call(order.EventModify); err != nil {
    fmt.Println(err.Error())
}

// 确认订单
if _, err = orderMachine.Call(order.EventConfirm); err != nil {
    fmt.Println(err.Error())
}

// 支付订单
if _, err = orderMachine.Call(order.EventPay); err != nil {
    fmt.Println(err.Error())
}

输出:

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

小结

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


新亮笔记
技术的深度和广度只能靠自己努力去发掘,谁也不能替你学习,在这里希望你能有所收获。

日拱一卒

2.9k 声望
1.2k 粉丝
0 条评论
推荐阅读
关于项目中 Repository 层的思考
维护这一层的开发者,可以称为 仓库管理员 ,当使用者需要查询数据的时候,需要告诉仓库管理员,由仓库管理员拿给他,至于仓库管理员从哪拿的数据,使用者无需关系。

新亮2阅读 1.8k评论 1

一个HTTP请求的曲折经历
作为程序员的我们每天都在和网络请求打交道,而前端程序员接触的最多的就是HTTP请求。平时工作中,处理网络请求之类的操作是最多的了。但是一个请求从客户端发出到被服务端处理、再回送响应,再被客户端接收这一...

nero24阅读 5.1k评论 1

前端如何入门 Go 语言
类比法是一种学习方法,它是通过将新知识与已知知识进行比较,从而加深对新知识的理解。在学习 Go 语言的过程中,我发现,通过类比已有的前端知识,可以更好地理解 Go 语言的特性。

robin23阅读 3.3k评论 6

封面图
Nginx 一网打尽:动静分离、压缩、缓存、黑白名单、跨域、高可用、性能优化...
早期的业务都是基于单体节点部署,由于前期访问流量不大,因此单体结构也可满足需求,但随着业务增长,流量也越来越大,那么最终单台服务器受到的访问压力也会逐步增高。时间一长,单台服务器性能无法跟上业务增...

民工哥23阅读 1.1k

封面图
Golang 中 []byte 与 string 转换
string 类型和 []byte 类型是我们编程时最常使用到的数据结构。本文将探讨两者之间的转换方式,通过分析它们之间的内在联系来拨开迷雾。

机器铃砍菜刀24阅读 58.2k评论 2

年度最佳【golang】map详解
这篇文章主要讲 map 的赋值、删除、查询、扩容的具体执行过程,仍然是从底层的角度展开。结合源码,看完本文一定会彻底明白 map 底层原理。

去去100216阅读 11.6k评论 2

年度最佳【golang】GMP调度详解
Golang最大的特色可以说是协程(goroutine)了, 协程让本来很复杂的异步编程变得简单, 让程序员不再需要面对回调地狱, 虽然现在引入了协程的语言越来越多, 但go中的协程仍然是实现的是最彻底的. 这篇文章将通过分析...

去去100215阅读 11.9k评论 4

日拱一卒

2.9k 声望
1.2k 粉丝
宣传栏