文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
社区首页 >专栏 >go: State Pattern

go: State Pattern

作者头像
geovindu
发布于 2026-06-18 16:34:05
发布于 2026-06-18 16:34:05
1210
举报

项目结构：

代码语言：javascript
复制
*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:59
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : auth.go
*/
package auth
 
import (
    "errors"
    "godesginpattern/statedesgin/common/consts"
)
 
// User 操作人信息（实际项目对接用户系统）
type User struct {
    ID   int64
    Role string
}
 
// CheckPermission 权限校验：不同状态、不同操作需要不同权限
func CheckPermission(user *User, stateCode int, isReject bool) error {
    // 规则：终态（不可操作）、管理员拥有所有权限、操作员可操作中间态、查看者无操作权限
    switch stateCode {
    case consts.OrderFinished, consts.OrderCancel, consts.ApplyPass, consts.ApplyReject,
        consts.LogisticsSigned, consts.ProcessProduct, consts.SaleStop, consts.SaleSoldOut:
        return errors.New("终态不允许操作，无权限")
    }
 
    switch user.Role {
    case consts.RoleAdmin:
        return nil // 管理员全部允许
    case consts.RoleOperator:
        return nil // 操作员允许中间态操作
    case consts.RoleViewer:
        return errors.New("查看者无操作权限")
    default:
        return errors.New("未知角色，无操作权限")
    }
}
 
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:42
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : state_const.go
*/
package consts
 
// 订单状态
const (
    OrderWaitPay  = 1
    OrderPaid     = 2
    OrderShipped  = 3
    OrderFinished = 4
    OrderCancel   = 5
)
const (
    OrderWaitPayDesc  = "待支付"
    OrderPaidDesc     = "已付款"
    OrderShippedDesc  = "已发货"
    OrderFinishedDesc = "已完成"
    OrderCancelDesc   = "已取消"
)
 
// 审批状态
const (
    ApplyDraft  = 10
    ApplyReview = 11
    ApplyPass   = 12
    ApplyReject = 13
)
const (
    ApplyDraftDesc  = "草稿"
    ApplyReviewDesc = "待审批"
    ApplyPassDesc   = "审批通过"
    ApplyRejectDesc = "审批驳回"
)
 
// 物流状态
const (
    LogisticsWaitSend = 20
    LogisticsOut      = 21
    LogisticsTransit  = 22
    LogisticsSigned   = 23
)
const (
    LogisticsWaitSendDesc = "待发货"
    LogisticsOutDesc      = "已出库"
    LogisticsTransitDesc  = "运输中"
    LogisticsSignedDesc   = "已签收"
)
 
// 珠宝加工状态
const (
    ProcessRaw     = 30
    ProcessRough   = 31
    ProcessFine    = 32
    ProcessProduct = 33
)
const (
    ProcessRawDesc     = "原料原石"
    ProcessRoughDesc   = "粗加工"
    ProcessFineDesc    = "精加工"
    ProcessProductDesc = "成品入库"
)
 
// 商品销售状态
const (
    SaleUnShelve = 40
    SaleOnSale   = 41
    SaleStop     = 42
    SaleSoldOut  = 43
)
const (
    SaleUnShelveDesc = "未上架"
    SaleOnSaleDesc   = "售卖中"
    SaleStopDesc     = "已停售"
    SaleSoldOutDesc  = "已售罄"
)
 
// 通用错误提示
const (
    ErrStateNoTransfer = "当前状态不允许正向流转"
    ErrStateNoReject   = "当前状态不允许驳回回退"
    ErrConditionFail   = "前置条件不满足"
)
 
// 权限常量
const (
    RoleAdmin    = "admin"
    RoleOperator = "operator"
    RoleViewer   = "viewer"
)
 
// 日志常量
const (
    LogTypeProcess = "state_process"
    LogTypeReject  = "state_reject"
    LogTypeTimer   = "state_timer"
)
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：State Pattern 状态模式  https://pkg.go.dev/github.com/sirupsen/logrus
#     go get github.com/sirupsen/logrus
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 11:00
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : log.go
*/
package util
 
import (
    "github.com/sirupsen/logrus"
    "os"
)
 
// 初始化日志
var Log *logrus.Logger
 
func init() {
    Log = logrus.New()
    Log.Out = os.Stdout
    Log.SetFormatter(&logrus.TextFormatter{
        FullTimestamp: true,
    })
    Log.SetLevel(logrus.InfoLevel)
}
 
// StateLog 状态流转日志（统一格式）
func StateLog(logType, businessType, operator string, entityID int64, msg string) {
    Log.WithFields(logrus.Fields{
        "log_type":      logType,
        "business_type": businessType,
        "operator":      operator,
        "entity_id":     entityID,
    }).Info(msg)
}
代码语言：javascript
复制
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:40
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : approval.go
*/
package entity
 
import "godesginpattern/statedesgin/state/iface"
 
type Approval struct {
    ID         int64
    Reason     string
    StatusCd   int
    Status     iface.State
    ApproverID int64
}
 
func (a *Approval) SetStatus(s iface.State) {
    a.Status = s
}
 
func (a *Approval) SyncStatus() {
    a.StatusCd = a.Status.GetCode()
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:40
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : logistics.go
*/
package entity
 
import "godesginpattern/statedesgin/state/iface"
 
type Logistics struct {
    ID       int64
    Express  string
    StatusCd int
    Status   iface.State
}
 
func (l *Logistics) SetStatus(s iface.State) {
    l.Status = s
}
 
func (l *Logistics) SyncStatus() {
    l.StatusCd = l.Status.GetCode()
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:40
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : order.go
*/
package entity
 
import "godesginpattern/statedesgin/state/iface"
 
type Order struct {
    ID       int64
    Title    string
    StatusCd int
    Status   iface.State
    PayPrice float64
}
 
func (o *Order) SetStatus(s iface.State) {
    o.Status = s
}
 
func (o *Order) SyncStatus() {
    o.StatusCd = o.Status.GetCode()
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:40
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : process.go
*/
package entity
 
import "godesginpattern/statedesgin/state/iface"
 
type ProcessTask struct {
    ID       int64
    Name     string
    StatusCd int
    Status   iface.State
}
 
func (p *ProcessTask) SetStatus(s iface.State) {
    p.Status = s
}
 
func (p *ProcessTask) SyncStatus() {
    p.StatusCd = p.Status.GetCode()
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:40
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : sale.go
*/
package entity
 
import "godesginpattern/statedesgin/state/iface"
 
type SaleGoods struct {
    ID       int64
    Sku      string
    StatusCd int
    Status   iface.State
}
 
func (s *SaleGoods) SetStatus(st iface.State) {
    s.Status = st
}
 
func (s *SaleGoods) SyncStatus() {
    s.StatusCd = s.Status.GetCode()
}
代码语言：javascript
复制
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 11:06
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : repo.go
*/
package repo
 
import (
    "errors"
    "godesginpattern/statedesgin/common/util"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/state/impl"
)
 
// 模拟数据库（生产环境替换为MySQL等真实数据库，事务对接真实DB事务）
type Repo struct{}
 
func NewRepo() *Repo {
    return &Repo{}
}
 
// 事务接口（统一事务入口）
func (r *Repo) WithTransaction(fn func() error) error {
    util.StateLog("transaction", "common", "system", 0, "事务开始")
    // 模拟事务开启
    defer func() {
        if err := recover(); err != nil {
            util.StateLog("transaction", "common", "system", 0, "事务回滚："+err.(string))
        } else {
            util.StateLog("transaction", "common", "system", 0, "事务提交")
        }
    }()
 
    // 执行事务逻辑
    if err := fn(); err != nil {
        return err
    }
    return nil
}
 
// 保存订单（模拟DB写入）
func (r *Repo) SaveOrder(order *entity.Order) error {
    util.StateLog("db_save", "order", "system", order.ID, "订单状态持久化："+order.Status.GetDesc())
    // 模拟DB报错（用于测试事务回滚）
    // return errors.New("数据库保存失败")
    return nil
}
 
// 保存审批（模拟DB写入）
func (r *Repo) SaveApproval(approval *entity.Approval) error {
    util.StateLog("db_save", "approval", "system", approval.ID, "审批状态持久化："+approval.Status.GetDesc())
    return nil
}
 
// 保存物流（模拟DB写入）
func (r *Repo) SaveLogistics(logistics *entity.Logistics) error {
    util.StateLog("db_save", "logistics", "system", logistics.ID, "物流状态持久化："+logistics.Status.GetDesc())
    return nil
}
 
// 保存加工任务（模拟DB写入）
func (r *Repo) SaveProcess(process *entity.ProcessTask) error {
    util.StateLog("db_save", "process", "system", process.ID, "加工状态持久化："+process.Status.GetDesc())
    return nil
}
 
// 保存销售商品（模拟DB写入）
func (r *Repo) SaveSale(sale *entity.SaleGoods) error {
    util.StateLog("db_save", "sale", "system", sale.ID, "销售状态持久化："+sale.Status.GetDesc())
    return nil
}
 
// 订单超时关闭（定时任务调用）
func (r *Repo) CloseOrder(order *entity.Order) error {
    if order.Status.GetCode() != 1 { // 只有待支付状态可关闭
        return errors.New("订单非待支付状态，无法关闭")
    }
    order.SetStatus(impl.NewOrderCancel()) // 这里impl需要导入，后面会统一处理
    order.SyncStatus()
    util.StateLog("db_update", "order", "timer", order.ID, "订单超时关闭，状态改为已取消")
    return r.SaveOrder(order)
}
代码语言：javascript
复制
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:41
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : flow_service.go
*/
package service
 
import (
    "fmt"
    "godesginpattern/statedesgin/common/auth"
    "godesginpattern/statedesgin/common/consts"
    "godesginpattern/statedesgin/common/util"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/repo"
    "godesginpattern/statedesgin/state/iface"
    "godesginpattern/statedesgin/workflow"
)
 
type FlowService struct {
    repo     *repo.Repo
    workflow *workflow.Workflow
}
 
func NewFlowService(repo *repo.Repo, workflow *workflow.Workflow) *FlowService {
    return &FlowService{
        repo:     repo,
        workflow: workflow,
    }
}
 
// DoProcess 正向流转（整合：权限+事务+日志+工作流）
func (f *FlowService) DoProcess(target any, st iface.State, user *auth.User, businessType string, entityID int64) string {
    // 1. 权限校验
    if err := auth.CheckPermission(user, st.GetCode(), false); err != nil {
        util.StateLog(consts.LogTypeProcess, businessType, user.Role, entityID, "流转失败："+err.Error())
        return fmt.Sprintf("【流转失败】%v", err)
    }
 
    // 2. 条件校验
    if err := st.CheckCondition(target); err != nil {
        util.StateLog(consts.LogTypeProcess, businessType, user.Role, entityID, "流转失败："+err.Error())
        return fmt.Sprintf("【流转失败】%v", err)
    }
 
    // 3. 事务包装（状态流转+数据持久化）
    err := f.repo.WithTransaction(func() error {
        // 执行状态流转
        if err := st.Process(target); err != nil {
            return err
        }
        // 数据持久化（根据业务类型保存）
        switch t := target.(type) {
        case *entity.Order:
            return f.repo.SaveOrder(t)
        case *entity.Approval:
            return f.repo.SaveApproval(t)
        case *entity.Logistics:
            return f.repo.SaveLogistics(t)
        case *entity.ProcessTask:
            return f.repo.SaveProcess(t)
        case *entity.SaleGoods:
            return f.repo.SaveSale(t)
        default:
            return fmt.Errorf("未知业务类型")
        }
    })
 
    // 4. 结果处理+日志+工作流同步
    if err != nil {
        util.StateLog(consts.LogTypeProcess, businessType, user.Role, entityID, "流转失败："+err.Error())
        return fmt.Sprintf("【流转失败】%v", err)
    }
    // 同步工作流
    f.workflow.SyncWorkflow(businessType, entityID, st)
    util.StateLog(consts.LogTypeProcess, businessType, user.Role, entityID, "流转成功，状态："+st.GetDesc())
    return fmt.Sprintf("【流转成功】下一状态：%s", st.GetDesc())
}
 
// DoReject 反向驳回（整合：权限+事务+日志+工作流）
func (f *FlowService) DoReject(target any, st iface.State, user *auth.User, businessType string, entityID int64) string {
    // 1. 权限校验
    if err := auth.CheckPermission(user, st.GetCode(), true); err != nil {
        util.StateLog(consts.LogTypeReject, businessType, user.Role, entityID, "驳回失败："+err.Error())
        return fmt.Sprintf("【驳回失败】%v", err)
    }
 
    // 2. 事务包装
    err := f.repo.WithTransaction(func() error {
        // 执行驳回
        if err := st.Reject(target); err != nil {
            return err
        }
        // 数据持久化
        switch t := target.(type) {
        case *entity.Order:
            return f.repo.SaveOrder(t)
        case *entity.Approval:
            return f.repo.SaveApproval(t)
        case *entity.Logistics:
            return f.repo.SaveLogistics(t)
        case *entity.ProcessTask:
            return f.repo.SaveProcess(t)
        case *entity.SaleGoods:
            return f.repo.SaveSale(t)
        default:
            return fmt.Errorf("未知业务类型")
        }
    })
 
    // 3. 结果处理+日志+工作流同步
    if err != nil {
        util.StateLog(consts.LogTypeReject, businessType, user.Role, entityID, "驳回失败："+err.Error())
        return fmt.Sprintf("【驳回失败】%v", err)
    }
    f.workflow.SyncWorkflow(businessType, entityID, st)
    util.StateLog(consts.LogTypeReject, businessType, user.Role, entityID, "驳回成功，状态："+st.GetDesc())
    return fmt.Sprintf("【驳回成功】回退状态：%s", st.GetDesc())
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 11:07
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : timer_service.go
*/
package service
 
import (
    "godesginpattern/statedesgin/common/consts"
    "godesginpattern/statedesgin/common/util"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/repo"
    "time"
)
 
// TimerService 定时服务（订单超时关闭、状态超时推进）
type TimerService struct {
    repo *repo.Repo
}
 
func NewTimerService(repo *repo.Repo) *TimerService {
    return &TimerService{
        repo: repo,
    }
}
 
// StartOrderTimer 订单超时关闭定时任务（模拟：10秒后关闭待支付订单）
func (t *TimerService) StartOrderTimer(order *entity.Order) {
    util.StateLog(consts.LogTypeTimer, "order", "timer", order.ID, "订单定时关闭任务启动，10秒后检查")
    go func() {
        time.Sleep(10 * time.Second)
        // 定时执行：关闭待支付订单
        if err := t.repo.CloseOrder(order); err != nil {
            util.StateLog(consts.LogTypeTimer, "order", "timer", order.ID, "订单定时关闭失败："+err.Error())
        } else {
            util.StateLog(consts.LogTypeTimer, "order", "timer", order.ID, "订单定时关闭成功")
        }
    }()
}
 
// StartProcessTimer 加工任务超时推进（模拟：15秒后自动推进粗加工→精加工）
func (t *TimerService) StartProcessTimer(process *entity.ProcessTask) {
    util.StateLog(consts.LogTypeTimer, "process", "timer", process.ID, "加工任务定时推进任务启动，15秒后执行")
    go func() {
        time.Sleep(15 * time.Second)
        if process.Status.GetCode() == 31 { // 粗加工状态
            process.Status.Process(process)
            _ = t.repo.SaveProcess(process)
            util.StateLog(consts.LogTypeTimer, "process", "timer", process.ID, "加工任务定时推进成功，粗加工→精加工")
        } else {
            util.StateLog(consts.LogTypeTimer, "process", "timer", process.ID, "加工任务非粗加工状态，不推进")
        }
    }()
}
代码语言：javascript
复制
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:39
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : state.go
*/
package iface
 
// State 增强通用状态接口
type State interface {
    Process(ctx any) error
    Reject(ctx any) error
    CheckCondition(ctx any) error
    GetCode() int
    GetDesc() string
}
 
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:41
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : approval_state.go
*/
package impl
 
import (
    "errors"
    "godesginpattern/statedesgin/common/consts"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/state/iface"
)
 
// 审核
type applyDraft struct{}
 
func NewApplyDraft() iface.State                   { return &applyDraft{} }
func (a *applyDraft) GetCode() int                 { return consts.ApplyDraft }
func (a *applyDraft) GetDesc() string              { return consts.ApplyDraftDesc }
func (a *applyDraft) CheckCondition(ctx any) error { return nil }
func (a *applyDraft) Process(ctx any) error {
    ap := ctx.(*entity.Approval)
    ap.SetStatus(NewApplyReview())
    ap.SyncStatus()
    return nil
}
func (a *applyDraft) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
type applyReview struct{}
 
func NewApplyReview() iface.State      { return &applyReview{} }
func (a *applyReview) GetCode() int    { return consts.ApplyReview }
func (a *applyReview) GetDesc() string { return consts.ApplyReviewDesc }
func (a *applyReview) CheckCondition(ctx any) error {
    ap := ctx.(*entity.Approval)
    if ap.ApproverID <= 0 {
        return errors.New(consts.ErrConditionFail + "：未配置审批人")
    }
    return nil
}
func (a *applyReview) Process(ctx any) error {
    ap := ctx.(*entity.Approval)
    ap.SetStatus(NewApplyPass())
    ap.SyncStatus()
    return nil
}
func (a *applyReview) Reject(ctx any) error {
    ap := ctx.(*entity.Approval)
    ap.SetStatus(NewApplyDraft())
    ap.SyncStatus()
    return nil
}
 
type applyPass struct{}
 
func NewApplyPass() iface.State                   { return &applyPass{} }
func (a *applyPass) GetCode() int                 { return consts.ApplyPass }
func (a *applyPass) GetDesc() string              { return consts.ApplyPassDesc }
func (a *applyPass) CheckCondition(ctx any) error { return nil }
func (a *applyPass) Process(ctx any) error {
    return errors.New(consts.ErrStateNoTransfer)
}
func (a *applyPass) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
type applyReject struct{}
 
func NewApplyReject() iface.State                   { return &applyReject{} }
func (a *applyReject) GetCode() int                 { return consts.ApplyReject }
func (a *applyReject) GetDesc() string              { return consts.ApplyRejectDesc }
func (a *applyReject) CheckCondition(ctx any) error { return nil }
func (a *applyReject) Process(ctx any) error {
    return errors.New(consts.ErrStateNoTransfer)
}
func (a *applyReject) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:41
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : logistics_state.go
*/
package impl
 
import (
    "errors"
    "godesginpattern/statedesgin/common/consts"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/state/iface"
)
 
// 物流
type logisticsWaitSend struct{}
 
func NewLogisticsWaitSend() iface.State                   { return &logisticsWaitSend{} }
func (l *logisticsWaitSend) GetCode() int                 { return consts.LogisticsWaitSend }
func (l *logisticsWaitSend) GetDesc() string              { return consts.LogisticsWaitSendDesc }
func (l *logisticsWaitSend) CheckCondition(ctx any) error { return nil }
func (l *logisticsWaitSend) Process(ctx any) error {
    lg := ctx.(*entity.Logistics)
    lg.SetStatus(NewLogisticsOut())
    lg.SyncStatus()
    return nil
}
func (l *logisticsWaitSend) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
type logisticsOut struct{}
 
func NewLogisticsOut() iface.State                   { return &logisticsOut{} }
func (l *logisticsOut) GetCode() int                 { return consts.LogisticsOut }
func (l *logisticsOut) GetDesc() string              { return consts.LogisticsOutDesc }
func (l *logisticsOut) CheckCondition(ctx any) error { return nil }
func (l *logisticsOut) Process(ctx any) error {
    lg := ctx.(*entity.Logistics)
    lg.SetStatus(NewLogisticsTransit())
    lg.SyncStatus()
    return nil
}
func (l *logisticsOut) Reject(ctx any) error {
    lg := ctx.(*entity.Logistics)
    lg.SetStatus(NewLogisticsWaitSend())
    lg.SyncStatus()
    return nil
}
 
type logisticsTransit struct{}
 
func NewLogisticsTransit() iface.State                   { return &logisticsTransit{} }
func (l *logisticsTransit) GetCode() int                 { return consts.LogisticsTransit }
func (l *logisticsTransit) GetDesc() string              { return consts.LogisticsTransitDesc }
func (l *logisticsTransit) CheckCondition(ctx any) error { return nil }
func (l *logisticsTransit) Process(ctx any) error {
    lg := ctx.(*entity.Logistics)
    lg.SetStatus(NewLogisticsSigned())
    lg.SyncStatus()
    return nil
}
func (l *logisticsTransit) Reject(ctx any) error {
    lg := ctx.(*entity.Logistics)
    lg.SetStatus(NewLogisticsOut())
    lg.SyncStatus()
    return nil
}
 
type logisticsSigned struct{}
 
func NewLogisticsSigned() iface.State                   { return &logisticsSigned{} }
func (l *logisticsSigned) GetCode() int                 { return consts.LogisticsSigned }
func (l *logisticsSigned) GetDesc() string              { return consts.LogisticsSignedDesc }
func (l *logisticsSigned) CheckCondition(ctx any) error { return nil }
func (l *logisticsSigned) Process(ctx any) error {
    return errors.New(consts.ErrStateNoTransfer)
}
func (l *logisticsSigned) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:41
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : order_state.go
*/
package impl
 
import (
    "errors"
    "godesginpattern/statedesgin/common/consts"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/state/iface"
)
 
// 待支付
type orderWaitPay struct{}
 
func NewOrderWaitPay() iface.State      { return &orderWaitPay{} }
func (o *orderWaitPay) GetCode() int    { return consts.OrderWaitPay }
func (o *orderWaitPay) GetDesc() string { return consts.OrderWaitPayDesc }
func (o *orderWaitPay) CheckCondition(ctx any) error {
    ord := ctx.(*entity.Order)
    if ord.PayPrice <= 0 {
        return errors.New(consts.ErrConditionFail + "：订单金额非法")
    }
    return nil
}
func (o *orderWaitPay) Process(ctx any) error {
    ord := ctx.(*entity.Order)
    ord.SetStatus(NewOrderPaid())
    ord.SyncStatus()
    return nil
}
func (o *orderWaitPay) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
// 已付款
type orderPaid struct{}
 
func NewOrderPaid() iface.State                   { return &orderPaid{} }
func (o *orderPaid) GetCode() int                 { return consts.OrderPaid }
func (o *orderPaid) GetDesc() string              { return consts.OrderPaidDesc }
func (o *orderPaid) CheckCondition(ctx any) error { return nil }
func (o *orderPaid) Process(ctx any) error {
    ord := ctx.(*entity.Order)
    ord.SetStatus(NewOrderShipped())
    ord.SyncStatus()
    return nil
}
func (o *orderPaid) Reject(ctx any) error {
    ord := ctx.(*entity.Order)
    ord.SetStatus(NewOrderWaitPay())
    ord.SyncStatus()
    return nil
}
 
// 已发货
type orderShipped struct{}
 
func NewOrderShipped() iface.State                   { return &orderShipped{} }
func (o *orderShipped) GetCode() int                 { return consts.OrderShipped }
func (o *orderShipped) GetDesc() string              { return consts.OrderShippedDesc }
func (o *orderShipped) CheckCondition(ctx any) error { return nil }
func (o *orderShipped) Process(ctx any) error {
    ord := ctx.(*entity.Order)
    ord.SetStatus(NewOrderFinished())
    ord.SyncStatus()
    return nil
}
func (o *orderShipped) Reject(ctx any) error {
    ord := ctx.(*entity.Order)
    ord.SetStatus(NewOrderPaid())
    ord.SyncStatus()
    return nil
}
 
// 已完成
type orderFinished struct{}
 
func NewOrderFinished() iface.State                   { return &orderFinished{} }
func (o *orderFinished) GetCode() int                 { return consts.OrderFinished }
func (o *orderFinished) GetDesc() string              { return consts.OrderFinishedDesc }
func (o *orderFinished) CheckCondition(ctx any) error { return nil }
func (o *orderFinished) Process(ctx any) error {
    return errors.New(consts.ErrStateNoTransfer)
}
func (o *orderFinished) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
// 已取消
type orderCancel struct{}
 
func NewOrderCancel() iface.State                   { return &orderCancel{} }
func (o *orderCancel) GetCode() int                 { return consts.OrderCancel }
func (o *orderCancel) GetDesc() string              { return consts.OrderCancelDesc }
func (o *orderCancel) CheckCondition(ctx any) error { return nil }
func (o *orderCancel) Process(ctx any) error {
    return errors.New(consts.ErrStateNoTransfer)
}
func (o *orderCancel) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:42
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : process_state.go
*/
package impl
 
import (
    "errors"
    "godesginpattern/statedesgin/common/consts"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/state/iface"
)
 
// 生产
type processRaw struct{}
 
func NewProcessRaw() iface.State                   { return &processRaw{} }
func (p *processRaw) GetCode() int                 { return consts.ProcessRaw }
func (p *processRaw) GetDesc() string              { return consts.ProcessRawDesc }
func (p *processRaw) CheckCondition(ctx any) error { return nil }
func (p *processRaw) Process(ctx any) error {
    task := ctx.(*entity.ProcessTask)
    task.SetStatus(NewProcessRough())
    task.SyncStatus()
    return nil
}
func (p *processRaw) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
type processRough struct{}
 
func NewProcessRough() iface.State                   { return &processRough{} }
func (p *processRough) GetCode() int                 { return consts.ProcessRough }
func (p *processRough) GetDesc() string              { return consts.ProcessRoughDesc }
func (p *processRough) CheckCondition(ctx any) error { return nil }
func (p *processRough) Process(ctx any) error {
    task := ctx.(*entity.ProcessTask)
    task.SetStatus(NewProcessFine())
    task.SyncStatus()
    return nil
}
func (p *processRough) Reject(ctx any) error {
    task := ctx.(*entity.ProcessTask)
    task.SetStatus(NewProcessRaw())
    task.SyncStatus()
    return nil
}
 
type processFine struct{}
 
func NewProcessFine() iface.State                   { return &processFine{} }
func (p *processFine) GetCode() int                 { return consts.ProcessFine }
func (p *processFine) GetDesc() string              { return consts.ProcessFineDesc }
func (p *processFine) CheckCondition(ctx any) error { return nil }
func (p *processFine) Process(ctx any) error {
    task := ctx.(*entity.ProcessTask)
    task.SetStatus(NewProcessProduct())
    task.SyncStatus()
    return nil
}
func (p *processFine) Reject(ctx any) error {
    task := ctx.(*entity.ProcessTask)
    task.SetStatus(NewProcessRough())
    task.SyncStatus()
    return nil
}
 
type processProduct struct{}
 
func NewProcessProduct() iface.State                   { return &processProduct{} }
func (p *processProduct) GetCode() int                 { return consts.ProcessProduct }
func (p *processProduct) GetDesc() string              { return consts.ProcessProductDesc }
func (p *processProduct) CheckCondition(ctx any) error { return nil }
func (p *processProduct) Process(ctx any) error {
    return errors.New(consts.ErrStateNoTransfer)
}
func (p *processProduct) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:42
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : sale_state.go
*/
package impl
 
import (
    "errors"
    "godesginpattern/statedesgin/common/consts"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/state/iface"
)
 
// 销售
type saleUnShelve struct{}
 
func NewSaleUnShelve() iface.State                   { return &saleUnShelve{} }
func (s *saleUnShelve) GetCode() int                 { return consts.SaleUnShelve }
func (s *saleUnShelve) GetDesc() string              { return consts.SaleUnShelveDesc }
func (s *saleUnShelve) CheckCondition(ctx any) error { return nil }
func (s *saleUnShelve) Process(ctx any) error {
    g := ctx.(*entity.SaleGoods)
    g.SetStatus(NewSaleOnSale())
    g.SyncStatus()
    return nil
}
func (s *saleUnShelve) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
type saleOnSale struct{}
 
func NewSaleOnSale() iface.State                   { return &saleOnSale{} }
func (s *saleOnSale) GetCode() int                 { return consts.SaleOnSale }
func (s *saleOnSale) GetDesc() string              { return consts.SaleOnSaleDesc }
func (s *saleOnSale) CheckCondition(ctx any) error { return nil }
func (s *saleOnSale) Process(ctx any) error {
    g := ctx.(*entity.SaleGoods)
    g.SetStatus(NewSaleSoldOut())
    g.SyncStatus()
    return nil
}
func (s *saleOnSale) Reject(ctx any) error {
    g := ctx.(*entity.SaleGoods)
    g.SetStatus(NewSaleUnShelve())
    g.SyncStatus()
    return nil
}
 
type saleStop struct{}
 
func NewSaleStop() iface.State                   { return &saleStop{} }
func (s *saleStop) GetCode() int                 { return consts.SaleStop }
func (s *saleStop) GetDesc() string              { return consts.SaleStopDesc }
func (s *saleStop) CheckCondition(ctx any) error { return nil }
func (s *saleStop) Process(ctx any) error {
    return errors.New(consts.ErrStateNoTransfer)
}
func (s *saleStop) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
 
type saleSoldOut struct{}
 
func NewSaleSoldOut() iface.State                   { return &saleSoldOut{} }
func (s *saleSoldOut) GetCode() int                 { return consts.SaleSoldOut }
func (s *saleSoldOut) GetDesc() string              { return consts.SaleSoldOutDesc }
func (s *saleSoldOut) CheckCondition(ctx any) error { return nil }
func (s *saleSoldOut) Process(ctx any) error {
    return errors.New(consts.ErrStateNoTransfer)
}
func (s *saleSoldOut) Reject(ctx any) error {
    return errors.New(consts.ErrStateNoReject)
}
代码语言：javascript
复制
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 11:07
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : workflow.go
*/
package workflow
 
import (
    "godesginpattern/statedesgin/common/util"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/state/iface"
    "godesginpattern/statedesgin/state/impl"
)
 
// Workflow 工作流适配（对接外部工作流引擎，如Activiti、Camunda）
type Workflow struct{}
 
func NewWorkflow() *Workflow {
    return &Workflow{}
}
 
// StartWorkflow 启动工作流（关联状态流转）
func (w *Workflow) StartWorkflow(businessType string, entityID int64, initialState iface.State) {
    util.StateLog("workflow", businessType, "system", entityID, "工作流启动，初始状态："+initialState.GetDesc())
    // 实际项目：调用工作流引擎API，创建流程实例，绑定状态流转事件
}
 
// SyncWorkflow 同步工作流状态（状态流转后，同步更新工作流）
func (w *Workflow) SyncWorkflow(businessType string, entityID int64, currentState iface.State) {
    util.StateLog("workflow", businessType, "system", entityID, "工作流状态同步："+currentState.GetDesc())
    // 实际项目：调用工作流引擎API，推进流程节点
}
 
// 工作流驱动状态流转（示例：审批流程）
func (w *Workflow) DriveApproval(approval *entity.Approval) error {
    // 模拟工作流节点触发：草稿 → 待审批 → 通过
    approval.SetStatus(impl.NewApplyDraft())
    approval.SyncStatus()
    w.SyncWorkflow("approval", approval.ID, approval.Status)
 
    approval.Status.Process(approval)
    w.SyncWorkflow("approval", approval.ID, approval.Status)
 
    approval.Status.Process(approval)
    w.SyncWorkflow("approval", approval.ID, approval.Status)
 
    return nil
}

调用：

代码语言：javascript
复制
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：State Pattern 状态模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/25 10:49
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : statebll.go
 
stateflow/
├── go.mod
├── cmd/main.go
├── internal/
│   ├── entity/         # 增加数据库字段、状态码持久化
│   │   ├── order.go
│   │   ├── approval.go
│   │   ├── logistics.go
│   │   ├── process.go
│   │   └── sale.go
│   ├── state/
│   │   ├── iface/      # 接口增强：增加驳回、条件校验
│   │   ├── iface/state.go
│   │   └── impl/       # 全部状态新增 驳回/回退逻辑
│   │       ├── order_state.go
│   │       ├── approval_state.go
│   │       ├── logistics_state.go
│   │       ├── process_state.go
│   │       └── sale_state.go
│   ├── service/        # 增强：条件校验、持久化、统一拦截
│   └── service/flow_service.go
│   │   ├── flow_service.go  # 增强：事务、日志、权限、工作流对接
│   │   └── timer_service.go # 新增：定时关闭服务
│   ├── repo/repo.go           # 新增：数据持久化（模拟数据库，支持事务）
│   └── workflow/workflow.go    # 新增：工作流适配
└── common/
 
        ├── consts/         # 错误码、状态常量
        │       └── /state_const.go
        ├──util/          # 日志、工具
        │        └──log.go
        └── auth/           # 新增：权限控制
               └──auth.go
*/
package bll
 
import (
    "fmt"
    "godesginpattern/statedesgin/common/auth"
    "godesginpattern/statedesgin/entity"
    "godesginpattern/statedesgin/repo"
    "godesginpattern/statedesgin/service"
    "godesginpattern/statedesgin/state/impl"
    "godesginpattern/statedesgin/workflow"
    "time"
)
 
func StateMain() {
    // 初始化依赖
    repo := repo.NewRepo()
    workflow := workflow.NewWorkflow()
    flowSvc := service.NewFlowService(repo, workflow)
    timerSvc := service.NewTimerService(repo)
 
    // 模拟操作人（管理员：拥有所有权限）
    admin := &auth.User{ID: 1001, Role: "admin"}
 
    fmt.Println("==================================================")
    fmt.Println("【订单全环节顺畅流转示例】：待支付 → 已付款 → 已发货 → 已完成")
    fmt.Println("==================================================")
    order := &entity.Order{
        ID:       1001,
        Title:    "高端钻石戒指",
        PayPrice: 9999.99,
    }
    order.SetStatus(impl.NewOrderWaitPay())
    order.SyncStatus()
    workflow.StartWorkflow("order", order.ID, order.Status)
    fmt.Println("初始状态：", order.Status.GetDesc())
    fmt.Println(flowSvc.DoProcess(order, order.Status, admin, "order", order.ID))
    fmt.Println(flowSvc.DoProcess(order, order.Status, admin, "order", order.ID))
    fmt.Println(flowSvc.DoProcess(order, order.Status, admin, "order", order.ID))
    // 测试订单定时关闭（另起一个待支付订单）
    order2 := &entity.Order{ID: 1002, Title: "翡翠手镯", PayPrice: 5999.99}
    order2.SetStatus(impl.NewOrderWaitPay())
    order2.SyncStatus()
    timerSvc.StartOrderTimer(order2)
 
    fmt.Println("\n==================================================")
    fmt.Println("【审批全环节顺畅流转示例】：草稿 → 待审批 → 审批通过")
    fmt.Println("==================================================")
    approval := &entity.Approval{
        ID:         2001,
        Reason:     "珠宝采购审批（100件翡翠原石）",
        ApproverID: 10086,
    }
    approval.SetStatus(impl.NewApplyDraft())
    approval.SyncStatus()
    workflow.StartWorkflow("approval", approval.ID, approval.Status)
    fmt.Println("初始状态：", approval.Status.GetDesc())
    fmt.Println(flowSvc.DoProcess(approval, approval.Status, admin, "approval", approval.ID))
    fmt.Println(flowSvc.DoProcess(approval, approval.Status, admin, "approval", approval.ID))
 
    fmt.Println("\n==================================================")
    fmt.Println("【物流全环节顺畅流转示例】：待发货 → 已出库 → 运输中 → 已签收")
    fmt.Println("==================================================")
    logistics := &entity.Logistics{
        ID:      3001,
        Express: "顺丰速运",
    }
    logistics.SetStatus(impl.NewLogisticsWaitSend())
    logistics.SyncStatus()
    workflow.StartWorkflow("logistics", logistics.ID, logistics.Status)
    fmt.Println("初始状态：", logistics.Status.GetDesc())
    fmt.Println(flowSvc.DoProcess(logistics, logistics.Status, admin, "logistics", logistics.ID))
    fmt.Println(flowSvc.DoProcess(logistics, logistics.Status, admin, "logistics", logistics.ID))
    fmt.Println(flowSvc.DoProcess(logistics, logistics.Status, admin, "logistics", logistics.ID))
 
    fmt.Println("\n==================================================")
    fmt.Println("【加工全环节顺畅流转示例】：原石 → 粗加工 → 精加工 → 成品入库")
    fmt.Println("==================================================")
    process := &entity.ProcessTask{
        ID:   4001,
        Name: "翡翠原石加工（高端挂件）",
    }
    process.SetStatus(impl.NewProcessRaw())
    process.SyncStatus()
    workflow.StartWorkflow("process", process.ID, process.Status)
    fmt.Println("初始状态：", process.Status.GetDesc())
    fmt.Println(flowSvc.DoProcess(process, process.Status, admin, "process", process.ID))
    fmt.Println(flowSvc.DoProcess(process, process.Status, admin, "process", process.ID))
    // 启动加工定时推进任务（15秒后自动推进粗加工→精加工，这里先演示手动推进）
    timerSvc.StartProcessTimer(process)
    fmt.Println(flowSvc.DoProcess(process, process.Status, admin, "process", process.ID))
 
    fmt.Println("\n==================================================")
    fmt.Println("【销售全环节顺畅流转示例】：未上架 → 售卖中 → 已售罄")
    fmt.Println("==================================================")
    sale := &entity.SaleGoods{
        ID:  5001,
        Sku: "JEW-2026-001",
    }
    sale.SetStatus(impl.NewSaleUnShelve())
    sale.SyncStatus()
    workflow.StartWorkflow("sale", sale.ID, sale.Status)
    fmt.Println("初始状态：", sale.Status.GetDesc())
    fmt.Println(flowSvc.DoProcess(sale, sale.Status, admin, "sale", sale.ID))
    fmt.Println(flowSvc.DoProcess(sale, sale.Status, admin, "sale", sale.ID))
 
    // 等待定时任务执行（查看日志输出）
    fmt.Println("\n等待定时任务执行（15秒后结束）...")
    time.Sleep(15 * time.Second)
    fmt.Println("程序执行完毕，所有环节流转完成！")
 
}　

输出：

代码语言：javascript
复制
===== 展示【State pattern（状态模式）】示例 =====
==================================================
【订单全环节顺畅流转示例】：待支付 → 已付款 → 已发货 → 已完成
==================================================
time="2026-04-25T11:13:49+08:00" level=info msg="工作流启动，初始状态：待支付" business_type=order entity_id=1001 log_type=workflow operator=system
初始状态： 待支付
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="订单状态持久化：已付款" business_type=order entity_id=1001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：待支付" business_type=order entity_id=1001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：待支付" business_type=order entity_id=1001 log_type=state_process operator=admin
【流转成功】下一状态：待支付
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="订单状态持久化：已发货" business_type=order entity_id=1001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：已付款" business_type=order entity_id=1001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：已付款" business_type=order entity_id=1001 log_type=state_process operator=admin
【流转成功】下一状态：已付款
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="订单状态持久化：已完成" business_type=order entity_id=1001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：已发货" business_type=order entity_id=1001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：已发货" business_type=order entity_id=1001 log_type=state_process operator=admin
【流转成功】下一状态：已发货
time="2026-04-25T11:13:49+08:00" level=info msg="订单定时关闭任务启动，10秒后检查" business_type=order entity_id=1002 log_type=state_timer operator=timer
 
==================================================
【审批全环节顺畅流转示例】：草稿 → 待审批 → 审批通过
==================================================
time="2026-04-25T11:13:49+08:00" level=info msg="工作流启动，初始状态：草稿" business_type=approval entity_id=2001 log_type=workflow operator=system
初始状态： 草稿
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="审批状态持久化：待审批" business_type=approval entity_id=2001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：草稿" business_type=approval entity_id=2001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：草稿" business_type=approval entity_id=2001 log_type=state_process operator=admin
【流转成功】下一状态：草稿
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="审批状态持久化：审批通过" business_type=approval entity_id=2001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：待审批" business_type=approval entity_id=2001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：待审批" business_type=approval entity_id=2001 log_type=state_process operator=admin
【流转成功】下一状态：待审批
 
==================================================
【物流全环节顺畅流转示例】：待发货 → 已出库 → 运输中 → 已签收
==================================================
time="2026-04-25T11:13:49+08:00" level=info msg="工作流启动，初始状态：待发货" business_type=logistics entity_id=3001 log_type=workflow operator=system
初始状态： 待发货
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="物流状态持久化：已出库" business_type=logistics entity_id=3001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：待发货" business_type=logistics entity_id=3001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：待发货" business_type=logistics entity_id=3001 log_type=state_process operator=admin
【流转成功】下一状态：待发货
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="物流状态持久化：运输中" business_type=logistics entity_id=3001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：已出库" business_type=logistics entity_id=3001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：已出库" business_type=logistics entity_id=3001 log_type=state_process operator=admin
【流转成功】下一状态：已出库
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="物流状态持久化：已签收" business_type=logistics entity_id=3001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：运输中" business_type=logistics entity_id=3001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：运输中" business_type=logistics entity_id=3001 log_type=state_process operator=admin
【流转成功】下一状态：运输中
 
==================================================
【加工全环节顺畅流转示例】：原石 → 粗加工 → 精加工 → 成品入库
==================================================
time="2026-04-25T11:13:49+08:00" level=info msg="工作流启动，初始状态：原料原石" business_type=process entity_id=4001 log_type=workflow operator=system
初始状态： 原料原石
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="加工状态持久化：粗加工" business_type=process entity_id=4001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：原料原石" business_type=process entity_id=4001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：原料原石" business_type=process entity_id=4001 log_type=state_process operator=admin
【流转成功】下一状态：原料原石
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="加工状态持久化：精加工" business_type=process entity_id=4001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：粗加工" business_type=process entity_id=4001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：粗加工" business_type=process entity_id=4001 log_type=state_process operator=admin
【流转成功】下一状态：粗加工
time="2026-04-25T11:13:49+08:00" level=info msg="加工任务定时推进任务启动，15秒后执行" business_type=process entity_id=4001 log_type=state_timer operator=timer
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="加工状态持久化：成品入库" business_type=process entity_id=4001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：精加工" business_type=process entity_id=4001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：精加工" business_type=process entity_id=4001 log_type=state_process operator=admin
【流转成功】下一状态：精加工
 
==================================================
【销售全环节顺畅流转示例】：未上架 → 售卖中 → 已售罄
==================================================
time="2026-04-25T11:13:49+08:00" level=info msg="工作流启动，初始状态：未上架" business_type=sale entity_id=5001 log_type=workflow operator=system
初始状态： 未上架
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="销售状态持久化：售卖中" business_type=sale entity_id=5001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：未上架" business_type=sale entity_id=5001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：未上架" business_type=sale entity_id=5001 log_type=state_process operator=admin
【流转成功】下一状态：未上架
time="2026-04-25T11:13:49+08:00" level=info msg="事务开始" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="销售状态持久化：已售罄" business_type=sale entity_id=5001 log_type=db_save operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="事务提交" business_type=common entity_id=0 log_type=transaction operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="工作流状态同步：售卖中" business_type=sale entity_id=5001 log_type=workflow operator=system
time="2026-04-25T11:13:49+08:00" level=info msg="流转成功，状态：售卖中" business_type=sale entity_id=5001 log_type=state_process operator=admin
【流转成功】下一状态：售卖中
 
等待定时任务执行（15秒后结束）...
time="2026-04-25T11:13:59+08:00" level=info msg="订单超时关闭，状态改为已取消" business_type=order entity_id=1002 log_type=db_update operator=timer
time="2026-04-25T11:13:59+08:00" level=info msg="订单状态持久化：已取消" business_type=order entity_id=1002 log_type=db_save operator=system
time="2026-04-25T11:13:59+08:00" level=info msg="订单定时关闭成功" business_type=order entity_id=1002 log_type=state_timer operator=timer
time="2026-04-25T11:14:04+08:00" level=info msg="加工任务非粗加工状态，不推进" business_type=process entity_id=4001 log_type=state_timer operator=timer
程序执行完毕，所有环节流转完成！
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2026-06-17，如有侵权请联系 cloudcommunity@tencent.com 删除
func
return
state
工作流
事务

本文分享自 作者个人站点/博客 前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ，欢迎热爱写作的你一起参与！

func
return
state
工作流
事务
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2026 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 粤公网安备44030502008569号

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2026 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论