go: State Pattern

博客园 - ®Geovin Du Dream Park™

go: Functional Options Pattern go:Timing Functions Pattern python: Timing Functions Pattern go: Steady-State Pattern python: Steady-State Pattern go: Handshaking Pattern python: Handshaking Pattern go: Fail-Fast Pattern python: Fail-Fast Pattern I go: Deadline Pattern python: Deadline Pattern go: Circuit-Breaker Pattern python: Circuit-Breaker Pattern go: Bulkheads Pattern python: Bulkheads Pattern go: Push & Pull Pattern python: Push & Pull Pattern python: Publish/Subscribe Pattern II go: Publish/Subscribe Pattern python: Publish/Subscribe Pattern go: Futures & Promises Pattern python: Futures & Promises Pattern go: Worker Pool Pattern go：Pipeline Pattern python: Worker Pool Pattern python: Pipeline Pattern go: Fan-Out Pattern python: Fan-Out Pattern go: Fan-In Pattern python: Fan-In Pattern Fan-In go: Producer Consumer Pattern python: Producer Consumer Pattern go: Parallelism Pattern python: Parallelism Pattern go: Reactor Pattern python: Reactor Pattern go: Generators Pattern python: speech to text offline python: Generators Pattern go: Coroutines Pattern python:Coroutines Pattern go: Broadcast Pattern python: Broadcast Pattern python: Bounded Parallelism Pattern go: Bounded Parallelism Pattern python: N-Barrier Pattern go: N-Barrier Pattern python: Semaphore Pattern go: Semaphore Pattern python: Read-Write Lock Pattern go: Read-Write Lock Pattern python: Monitor Pattern go: Monitor Pattern python: Mutex Pattern go: Lock/Mutex Pattern Python: Condition Variable Pattern go:Condition Variable Pattern python: Registry Pattern python: Interpreter Pattern go: Interpreter Pattern go: Registry Pattern go: Memento Pattern go: Command Pattern go:Template Method Pattern go: Strategy Pattern go: Visitor Pattern go: Observer Pattern go: Mediator Pattern go: Iterator Pattern go: Chain of Responsibility Pattern go: Proxy Pattern go:Decorator Pattern go: Facade Pattern go: Flyweight Pattern go: Composite Pattern go: Singleton Pattern go: Prototype Pattern go: Bridge Pattern go: Adapter Pattern go: Builder Pattern 密码进行加盐哈希 using CSharp,Python,Go,Java go: Abstract Factory Pattern go: Model，Interface，DAL ，Factory，BLL using mysql go: Simple Factory Pattern go: Factory Method Pattern go: goLang 在Windows环境搭建Go语言开发环境 CSharp: Parallel Extensions cpp: class python: 蝴蝶跟随鼠标 javascript: 中国历史人物热力分布图using echart javascript: 中国历史人物热力图 python: 初养龙虾微信纯文字自动回复using workBuddy python: object 入门 python: Factory Method Pattern python: Simple Factory Pattern python: Abstract Factory Pattern 区域化代码 python: Null Object Pattern python: Builder Pattern python: Adapter Pattern

go: State Pattern

®Geovin Du Dream Park™ · 2026-04-25 · via 博客园 - ®Geovin Du Dream Park™

项目结构：

34f36634-4bf2-45bb-9445-adee6517ae4d

/*
# 版权所有  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)
}

/*
# 版权所有  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()
}

/*
# 版权所有  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)
}

/*
# 版权所有  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, "加工任务非粗加工状态，不推进")
		}
	}()
}

/*
# 版权所有  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)
}

/*
# 版权所有  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
}

调用：

/*
# 版权所有  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("程序执行完毕，所有环节流转完成！")

}

输出：

===== 展示【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
程序执行完毕，所有环节流转完成！

哲学管理(学)人生, 文学艺术生活, 自动(计算机学)物理(学)工作, 生物(学)化学逆境, 历史(学)测绘(学)时间, 经济(学)数学金钱(理财), 心理(学)医学情绪, 诗词美容情感, 美学建筑(学)家园, 解构建构(分析)整合学习, 智商情商(IQ、EQ)运筹(学)生存.---Geovin Du(涂聚文）

此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。原文来自 — 版权归原作者所有。

推荐订阅源

博客园 - ®Geovin Du Dream Park™