乘风原创程序

    当前位置:首页>>编程开发>>GO语言>> 关于处理电商系统订单状态的流转,分享下我的技术方案(附带源码)
  • 关于处理电商系统订单状态的流转,分享下我的技术方案(附带源码)
  • 2021/7/7 16:03:36
  • 目录

    前言

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

    如上图,使用 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 ,供下载使用。