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

目录

前言

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

如上图，使用 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 方法即可！

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

调用方式

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

• 创建订单，状态变为 已预订；
• 修改订单，不可操作（已预订状态不可修改）；
• 确定订单，状态变为 已确认；
• 修改订单，状态变为 已预订；
• 确定订单，状态变为 已确认；
• 支付订单，状态变为 已锁定；

// 通过订单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 ，供下载使用。