一、起源:业务规则与流程逻辑散落在代码中的代价

流程逻辑与业务规则最初都写在业务方法里:几行 if-else 判断状态、一个 switch 决定折扣、一段代码描述审批顺序。这种写法在系统早期是合理的——规则少、变化慢、参与方只有开发。当规则的来源、变化频率与参与方发生变化后,同一段代码的维护成本会以非线性方式上升。

1.1 四类代价

代价 具体表现 累积后果
变更需要发版 调整一个折扣阈值、增加一个审批节点,都要修改代码、走完整构建与回归、按发布窗口上线 业务侧的变化诉求被交付节奏限制,运营活动被迫按发版周期设计
分支爆炸 状态判断与规则条件散落在多个方法中,同一条件在不同入口重复出现,嵌套层级随业务例外增加 单方法分支数上升,任意修改都可能影响未预期的路径,回归范围无法界定
规则不可见 规则只存在于代码与口头约定中,业务方无法阅读,只能通过文档或询问开发获知当前口径 规则口径与文档长期不一致,线上行为争议时缺少可核对的依据
跨团队协作困难 一个流程跨越多个团队的服务,流程走向写在各部门代码中,无人持有完整视图 流程调整需要多方协同发版,责任边界与流程边界不一致

四类代价的共同根源是同一件事:变化点与变化载体不匹配。变化频繁的是规则口径与流程走向,而变化载体是编译发布单元,两者的更新成本相差几个数量级。

1.2 把变化点外置的动机

把变化点外置,指的是把"下一步做什么""在什么条件下采用哪条口径"从代码分支中移出,用可独立编辑、可独立发布的数据描述。常见形态有三种:

外置形态 描述的对象 规模量级 变更主体
状态转移表 单个业务实体的状态与事件对应关系 状态数个、转移数十条 开发或产品
流程定义 跨步骤、含人工环节的业务流水线 节点数十个、版本数十个 产品与流程责任人
规则集 条件与动作的组合,用于决策与打分 规则数十到数千条 业务运营

外置之后,变化不再触发代码编译,规则与流程可以被业务方阅读、评审和版本化。复杂度并未消失,只是从"每次修改都要重新理解代码"转移到"维护一套模型与运行时"。

1.3 外置的代价

代价必须在引入前明确,否则会把引擎当作无成本的开关:

代价 表现
学习成本 引入 DSL、表达式语法、流程图形化定义,团队需要额外的知识储备与文档
调试成本 断点无法直接落在规则与流程上,定位需要借助引擎的执行日志与实例视图
性能开销 规则匹配、表达式求值、流程实例的持久化都带来运行时开销,需要额外的容量规划
版本治理 模型有了版本,就要回答"新实例用哪个版本""存量实例如何兼容",治理问题随之出现
测试方式改变 规则与流程的测试从方法级用例变为模型级用例,覆盖率的度量方式与代码不同
新的故障模式 规则冲突、流程卡单、实例数据与业务数据不一致,都是代码分支形态下不存在的故障

架构演进的一般规律是复杂度只能转移、无法消除,引擎化同样服从这一规律:它把复杂度从"代码修改与回归"转移到"模型治理与运行时",判断依据是转移之后的总代价是否更低。这一规律在 软件架构演进的问题脉络 第一章有展开。

1.4 本文的定位与引用关系

状态模式、策略模式、责任链模式在代码层面的实现形态已在 设计模式理论与实战手册 第 5.2 节与第 5.4 节说明,本文不重复模式的推演,只讨论把这些模式所表达的变化点外置为模型之后的工程问题:模型怎么定义、怎么持久化、怎么演进、怎么与领域代码划界。

跨服务长流程的一致性、补偿接口与悬挂处置见 Java 分布式事务实践;流程状态的持久化、事务边界与连接绑定见 Java 持久层。


二、原理

2.1 三个不同层次的概念

状态机、工作流引擎、规则引擎常被统称为"流程引擎",但三者描述的对象、变化来源与评价指标都不同。选型错误多来自把其中一者的能力套用到另一者的问题上。

维度 状态机 工作流与流程编排 规则与决策
描述对象 单个实体允许的状态与转移 一次业务流程的步骤、分支与参与方 一组条件到动作的映射
核心元素 状态、事件、守卫、动作 节点、连线、网关、任务、变量 条件、动作、优先级、冲突消解
决策粒度 一次状态推进 从流程起点到终点的一串推进 一次输入到输出或动作的映射
变化来源 业务状态语义调整 流程走向、审批层级、参与角色调整 阈值、费率、名单、评分口径调整
状态存放 业务表的状态字段 引擎的实例表与任务表 无状态,输入与输出均为参数
时间尺度 单次交互内完成 数小时到数周,含等待 单次调用内完成
主要评价指标 非法转移被拒绝、并发更新正确 实例不卡单、超时不失效、可追溯 规则命中可解释、执行耗时可控
主要风险 状态与业务数据不一致 实例积压、版本与存量不兼容 规则冲突、表达式安全与性能

2.1.1 状态机

状态机只回答一个问题:在状态 A 下收到事件 E,是否允许进入状态 B,进入后要做什么。它不关心流程跨越了多少个服务,也不关心条件由谁维护。状态机的价值在于把"任意状态到任意状态"的隐式判断收敛为一张显式的转移表,使非法转移可以被统一拒绝。

2.1.2 工作流与流程编排

工作流描述的是步骤之间的依赖与流转:先做什么、什么条件下走哪条分支、哪些步骤可以并行、哪一步需要人工参与、超时之后怎么处理。它在状态机之上增加了四类能力:人工任务、等待与超时、多实例与并行、流程定义的运行时可视化。

编排与编制是流程控制的两种实现方式:编排由中心组件按流程定义驱动各参与方,流程走向集中可见;编制由各参与方通过事件相互触发,没有中心定义,流程走向分散在订阅关系中。前者的可追溯性更好,后者的耦合更低,长流程跨组织时通常只能采用编制。

2.1.3 规则与决策

规则引擎描述的是"在什么条件下做什么"的集合:输入一组事实,按优先级与冲突消解策略选出若干条规则,执行其动作。规则引擎不持有流程状态,其输出或者是一个决策结果(如利率、折扣、准入结论),或者是一个需要被谁执行的指令。

规则的数量与变化频率是它存在的理由:当分支数量在几十条以上、且口径由业务方维护时,代码中的 if-else 与策略类会同时面临可读性与发布成本问题。

2.1.4 混用的后果

错误用法 表现 原因
用状态机表达多级审批 状态字段膨胀为"三级审批中""五级审批中",每增加一级就新增一批状态与转移 审批层级属于流程结构,属于流程模型的节点配置
用工作流引擎做字段级计算 为每个计算节点建流程实例,实例表增长速度与请求量同量级 无等待、无人工、无跨步骤依赖的计算属于规则或代码
用规则引擎驱动状态流转 状态推进写在规则动作中,非法转移不再被统一拒绝 状态推进需要状态作为前置条件与统一校验入口
三套模型表达同一逻辑 同一个业务判断同时存在于状态守卫、流程条件与规则条件中,三处不一致 缺少唯一权威来源,变更时遗漏其中一处

判断依据是一条:如果一个判断的结果会改变实体的状态,它属于状态机;如果它决定流程接下来走哪条路径,它属于流程定义;如果它只影响一次计算的取值,它属于规则或代码。

2.2 状态机建模

2.2.1 状态与事件与守卫与动作

元素 含义 实现形态
状态 实体在某一时刻所处的阶段,状态之间互斥 状态字段的枚举值
事件 触发状态变化的输入,来自用户操作或系统消息 领域方法名或事件类型
守卫 转移是否允许的附加条件,除状态之外的前置校验 布尔判断,失败则拒绝转移
动作 转移发生时执行的副作用 领域方法内的写入、发消息、记录流水
转移 状态与事件到目标状态的映射 配置表、枚举内定义或状态机库声明

建模时的三条约束:

  1. 状态互斥且完备:任一时刻实体处于且仅处于一个状态;所有可能出现的中间态都必须被显式定义,不允许用 null 或空字符串表达"还没开始";
  2. 转移的判定集中在守卫中:业务规则(如金额校验、库存充足)作为守卫,业务动作作为动作,两者分离,避免动作执行到一半才发现前置条件不满足;
  3. 终态不可再转出:终态(已完成、已取消)需要显式声明,防止历史数据被再次推进。

图形态表示(便于与业务方对齐,本身不是可执行模型):

订单状态转移
  PENDING_PAY ──支付成功──► PAID ──发货──► SHIPPED ──签收──► FINISHED(终态)
       │                      │                │
       └──超时未付/用户取消──► CANCELLED(终态)
                              └──退款完成──► REFUNDED(终态)

守卫示例
  PAID ──发货──► SHIPPED
    要求:支付完成时间距今小于 X 天、库存已锁定、收货地址非空

2.2.2 状态持久化与并发更新

状态存放的位置决定了并发控制方式。主流做法是把状态放在业务表的状态字段上,用条件更新实现"比较并设置",使非法转移与并发冲突都表现为影响行数为 0:

-- 条件更新:只有前置状态与版本号都匹配时才推进
UPDATE t_order
SET status = #{targetStatus},
    version = version + 1,
    update_time = NOW(3)
WHERE id = #{id}
  AND status = #{expectStatus}
  AND version = #{version};
-- 影响行数为 1 表示转移成功;为 0 表示前置状态不匹配或已被并发修改
/**
 * 状态推进统一入口:先取守卫结果,再执行条件更新,最后写入状态流水。
 * 影响行数为 0 时不做重试,直接判定为非法转移或并发冲突。
 */
public void transit(Long id, OrderEvent event, OrderCommand command) {
    Order order = orderMapper.selectById(id);
    // 守卫:当前状态是否允许该事件,附加业务条件是否满足
    if (!OrderStateMachine.canTransit(order.getStatus(), event)) {
        throw new IllegalStateTransitionException(order.getStatus(), event);
    }
    guard.check(order, event, command);
    OrderStatus target = OrderStateMachine.target(order.getStatus(), event);
    int affected = orderMapper.compareAndSetStatus(id, order.getStatus(), order.getVersion(), target);
    if (affected == 0) {
        throw new ConcurrentModificationException("状态已被其他请求变更,id=" + id);
    }
    // 流水与业务数据处于同一本地事务
    stateLogMapper.insert(id, order.getStatus(), target, event, command.getOperator());
}

乐观锁与悲观锁的取舍:

方式 机制 适用 代价
乐观锁(版本号或条件更新) 更新语句携带前置状态与版本 冲突概率低、单次操作耗时短 冲突时需要上层决定重试还是拒绝
悲观锁(SELECT ... FOR UPDATE) 事务内锁定该行 冲突概率高、后续有多步写入 持锁期间占用连接,事务时长被放大
分布式锁 以业务键加锁 跨进程的同业务并发 锁的失效与续期引入新故障模式

状态推进属于短事务,优先使用乐观锁;只有在一个业务操作需要在同一事务内连续多次修改同一实体时,才考虑悲观锁,此时需与连接池容量一起核算,连接与事务绑定的机制见 Java 持久层 第 2.6 节与第 2.7 节。

2.2.3 非法转移的拒绝

非法转移要在三个位置被拦截,缺一不可:

位置 作用 实现
入口校验 阻止非法请求进入业务逻辑,减少无效写入 按当前状态返回"允许的事件列表",前端据此渲染按钮
转移判定 以状态机为准拒绝未定义转移 转移表查询失败即拒绝,抛出可识别的业务异常
数据写入 兜住并发与绕过入口的调用 条件更新的前置状态约束

三个位置中只有第三处是可靠的最终防线,前两处是体验与效率的优化。原因在于状态可能在被读取之后、写入之前被其他请求改变,只有写入语句的原子比较才能给出确定结论。

拒绝的语义需要区分:非法转移(状态机未定义该转移)应返回明确的业务错误,不重试;并发冲突(状态已变但目标转移本来合法)可由上层按最新的当前状态重新决策一次,重试次数需要封顶,避免形成活锁。

2.2.4 状态机与领域模型的融合方式

融合方式 形态 适用 风险
领域方法内校验 聚合根内的业务方法自行校验前置状态 状态少、转移固定、单一入口 多个入口重复书写校验,规则容易漂移
独立转移表 状态与事件到目标的映射集中在枚举或配置类中 多处入口共享同一套转移规则 转移表与业务方法需要保持同步
状态机库驱动 由框架声明状态、事件、转移与监听器 需要状态轨迹、监听器、持久化扩展 框架侵入领域层,测试需要处理框架上下文
引擎托管 状态存于引擎的实例表,业务表冗余一份 流程含人工任务、需要运行时改流程 两份状态的一致性与对账成本

融合方式的选择标准是状态推进的入口数量:入口只有一个时,领域方法内校验最简单;入口超过一个且规则一致时,应抽出转移表;只有在流程含等待与人工环节时,才把状态托管给引擎。

与代码级实现的关系:单选的状态选择可用策略模式表达,按顺序尝试的处理可用责任链表达,状态驱动的行为变化可用状态模式表达,三者的代码形态见 设计模式理论与实战手册 第五章。状态转移表可以看作状态模式的数据化形式,把编译期固定的转移改为运行期可读的配置。

2.3 流程编排模型

2.3.1 顺序与分支与并行与子流程

结构 语义 建模要点 常见问题
顺序 节点依次执行 每个节点应可独立重试 前序节点副作用未完成时后序已启动
排他分支 满足条件的一支被选中 必须配置默认分支 条件同时不满足时流程停在网关处
并行分支 多支同时执行,全部到达后继续 汇聚节点需等待全部令牌 汇聚条件写错导致流程永久等待
包含分支 满足条件的多支执行,按实际激活数汇聚 需要运行时记录激活分支数 分支数为零时的汇聚判定
子流程 把可复用的片段封装为独立定义 参数传递与异常向外抛出 子流程版本与父流程版本耦合
边界事件 超时、消息、错误附着在节点或子流程上 中断与非中断语义需明确 中断事件触发后原节点动作仍在执行

并行结构是流程引擎中最容易出现"流程永久停留"的地方,原因是令牌的汇聚判定与分支的激活数量不一致。建模约束有两条:汇聚节点必须使用引擎提供的并行汇聚语义而不是"统计已到达数量";包含分支在分支数可能为零时,需要显式配置零分支的处理路径。

2.3.2 人工任务与超时与催办

人工任务是流程引擎区别于状态机的核心能力,它的实现包含四件事:

事项 需要的数据 处理方式
任务生成 任务名、办理人候选、候选组、到期时间、任务表单标识 由节点配置生成,写入任务表
认领与办理 认领人、办理意见、输出变量 认领后锁定办理权,办理时推进流程
超时 到期时间、超时动作(提醒、自动通过、自动拒绝、升级) 由定时任务扫描到期任务,按配置动作处理
催办与转办 催办次数、转办记录 催办是通知动作,转办变更办理人并留痕

人工环节的设计约束有三条:办理动作必须幂等,重复提交同一条任务不能推进两次流程;超时动作必须与流程定义一并版本化,避免存量实例的超时口径随新版本变化;任务的候选范围必须由业务规则确定而不是写死在流程定义中,否则人员调整需要改流程。

2.3.3 补偿与回滚路径

流程引擎提供的是流程层的回退路径(回到上一个节点、跳转到指定节点),它解决的是"流程走向"的回退;业务数据的回退需要业务补偿接口。两者的区别与长流程的补偿方案(Saga、TCC、消息类方案)见 Java 分布式事务实践 第 2.1 节与第 3.3 节。

流程层的三条约束:

  1. 回退不等于数据回滚:流程回到上一节点后,已产生的业务数据仍需显式补偿,补偿接口需按业务单号幂等;
  2. 补偿节点需成对定义:有正向节点就应有对应的补偿节点,补偿顺序按依赖拓扑确定,不能简单逆序;
  3. 已发送的对外动作不可补偿:通知、短信、对外接口调用属于不可撤回动作,应放在流程尽量靠后或明确标注为不可补偿步骤。

2.3.4 流程实例与变量的持久化

流程引擎自身的运行状态需要落库,典型表结构分为运行时(当前实例与当前任务)与历史(已结束实例与流转记录)两部分:

表类别 内容 增长特征 清理前提
实例表 流程实例标识、当前节点、状态、业务关联键 与启动的流程数量同量级,未结束实例长期存在 实例结束后方可归档
任务表 待办任务的办理人、候选组、到期时间 与人工节点数量相关,办理完成后删除 任务完成后
变量表 流程变量名与值 与实例数乘以变量个数同量级 随实例归档
历史表 已结束实例、节点流转记录、办理记录 只增不减,是容量管理的主要对象 按保留期归档

变量设计的两条约束:

  • 变量只放推进流程所需的最小信息,如业务单号、决策输入标记、金额档位;业务明细数据放在业务表中,通过业务单号关联。把完整业务对象放进流程变量会让变量表膨胀,且业务表与变量表出现两份可写副本;
  • 变量必须可序列化且结构稳定,实例长期存在时,变量中对象的结构变更会导致历史实例反序列化失败,变量应尽量使用字符串与数值等基础类型。

2.3.5 长流程与跨服务调用的边界

流程引擎决定的是"下一步调用谁",它不提供跨服务的事务原子性。把跨服务写操作放进流程节点时,需要按最终一致的约束处理:

节点实现与一致性责任的划分
  流程引擎负责:            在什么条件下、按什么顺序调用哪个节点
  领域服务负责:            本次调用的业务语义与本地事务
  消息与幂等机制负责:       调用失败后的重试、重复调用的去重
  对账任务负责:            长期不一致的发现与兜底

形态
  流程节点 → 调用下游服务(接口需幂等,按业务单号去重)
           → 调用失败抛出可重试异常,由流程引擎按配置重试
           → 重试耗尽进入人工任务或补偿节点

两条边界要求:节点内的远程调用必须有超时,超时时间小于流程引擎对该节点的重试判定阈值;节点实现必须幂等,重复执行同一节点不产生第二次业务副作用,幂等的实现手段见 消息可靠性与幂等设计 第 2.5 节与第 3.4 节。

2.4 规则引擎模型

2.4.1 条件与动作与优先级与冲突消解

规则的典型结构由三部分组成:条件(输入事实需要满足的断言)、动作(命中后执行的操作)、优先级(多条规则同时命中时的执行顺序)。

冲突消解策略决定了"多条规则同时命中"的结果,常见策略有四类:

策略 语义 适用 风险
优先级优先 按优先级排序,高优先级先执行 规则之间有明确的覆盖关系 优先级字段被滥用,全部规则争抢高优先级
首个命中 按顺序匹配,命中即停止 规则互斥、结果唯一 规则顺序成为隐式语义,插入新规则会改变旧结果
全部命中 所有满足条件的规则都执行 累计计算(如叠加优惠、打标签) 动作之间可能相互覆盖,需要合并策略
冲突分组 同组内互斥,组内择一执行 存在互斥的策略族 分组划分需要业务参与

无论采用哪种策略,都需要对规则集做两项静态检查:重叠(两条规则条件相交且动作不同,结果不确定)与空洞(存在输入组合没有任何规则命中,且业务要求必须有结论)。这两项检查是规则质量的主要抓手,缺少它们的规则集在规模上升后会出现无法解释的结果。

2.4.2 规则集与决策表

规则集表示法有两种主流形态:

形态 结构 可读性 适用规模
条件表达式 每条规则一行表达式加动作 开发友好,业务方难以核对 数十条,逻辑有嵌套与函数调用
决策表 行为规则、列为条件与动作的表格 业务方可直接阅读与维护 数百条,条件为枚举与区间组合

决策表的优势在于把"条件的全部组合"显式列出,配合覆盖度分析可以发现未覆盖的组合;代价是条件维度增加时表会迅速膨胀,维度超过五六个后需要拆分为多张表并串联。

决策表的典型形态(导入后由规则引擎编译为规则集):

会员折扣决策表
| 规则编号 | 会员等级 | 订单金额下限 | 活动标记 | 折扣率 | 备注             |
| R1       | VIP      | 1000         | 促销     | 0.75   | 优先级 30        |
| R2       | VIP      | 1000         | -        | 0.85   | 优先级 20        |
| R3       | 普通     | 500          | 促销     | 0.90   | 优先级 10        |
| R4       | 普通     | -            | -        | 1.00   | 默认规则,优先级 0|

2.4.3 表达式求值方式与安全性

条件与动作的求值方式决定了能力上限与安全边界,四类方式的取舍如下:

方式 能力 性能 安全风险 适用
内置判定器 只支持比较、区间、集合包含、布尔组合 高,可预编译为判定函数 极低 占绝大多数的阈值、名单类规则
表达式 AST 求值 支持算术、字符串、常用函数,无控制流 高,可编译缓存 低,需限定函数白名单 涉及计算与格式判断的规则
脚本引擎 支持控制流、集合遍历、自定义函数 中,首次编译有开销 高,可执行任意代码 逻辑复杂且由开发维护的规则
编译型规则 DSL 支持模式匹配、事实插入与传播 低到中,内存占用高 中,取决于宿主语言能力 规则数量大、事实对象复杂、需要推理

安全性要求来自一个事实:在应用进程内执行的表达式与脚本,隔离能力受限于语言与运行时本身。同进程内的脚本无法完全阻止资源耗尽与越权访问,因此控制手段以限制能力为主:

风险 触发方式 防治
任意代码执行 脚本可调用反射、类加载、外部进程 禁止脚本引擎,或限定到函数白名单并移除反射相关能力
无限循环 脚本中包含 while(true) 或自递归 不使用支持控制流的求值方式,或只允许固定次数的迭代
资源耗尽 单次求值创建大对象、拼接超长字符串 限制输入规模与函数能力,设置求值超时与结果大小上限
表达式注入 规则内容由外部输入拼装,条件被改写 规则内容只允许通过受控的编辑界面维护,落库前做结构与函数白名单校验
数据越权 动作中直接访问未授权数据源 动作只允许调用已注册的业务接口,不允许直连数据源

求值超时的实现需要注意一点:线程中断对无法响应中断的求值逻辑无效。对确有风险的自定义脚本,应放到独立进程或受限的运行时中执行,通过进程级隔离与超时终止来兜底,而不是依赖应用内的线程池超时。规则由业务方维护时,这一点尤其重要——规则内容的正确性无法完全由代码评审保证,只能由运行时的能力限制兜底。

2.4.4 规则的可解释性与可追溯

规则执行的结论需要能被解释,否则争议无法定位。可解释性包含三问:命中了哪条规则、触发了什么条件的取值、为什么其他规则没有命中。

{
  "decisionId": "d-20260923-0001",
  "ruleSetKey": "member_discount",
  "ruleSetVersion": 17,
  "input": { "memberLevel": "VIP", "orderAmount": 1280.0, "promotion": true },
  "hits": [
    { "ruleId": "R1", "priority": 30, "matched": true, "effects": { "discountRate": 0.75 } }
  ],
  "skipped": [
    { "ruleId": "R2", "reason": "condition_not_matched", "detail": "promotion 不为空" },
    { "ruleId": "R4", "reason": "overridden_by_higher_priority" }
  ],
  "result": { "discountRate": 0.75 },
  "elapsedMs": 3
}

决策日志的三条设计约束:日志必须记录规则集版本,否则无法还原当时的规则内容;日志需要区分"条件不满足"与"被更高优先级覆盖"两类未命中原因;日志的写入不能放在同步决策路径上做重试,应允许异步落库并在失败时降级为采样。

2.5 引擎化的代价

把上述三类模型投入生产后,新增的工程负担集中在五个方面:

方面 具体表现 缓解方式
学习与调试 需要理解 DSL 与引擎语义;问题定位需要同时看业务日志与引擎实例视图 建立实例视图与决策日志,把引擎状态纳入可观测体系
性能与并发 规则匹配与表达式求值的单次开销、流程实例的持久化写入次数增加 规则集缓存与预编译、流程变量精简、批量与异步持久化
版本与兼容 模型版本与实例版本并存,历史实例依赖旧版本定义 定义不可变、按版本隔离、实例启动时绑定版本
治理 谁有权修改规则与流程、修改后由谁验收、如何防止绕过评审直接改库 变更流程与权限分离、发布需评审、运行时只读取已发布版本
测试方式改变 用例从方法级变为"输入事实集到决策"与"流程路径覆盖" 用决策表用例与流程路径用例替代代码分支覆盖

治理问题最容易被低估:当规则可以由业务方在界面上修改后立即生效时,规则库实际上成为生产代码的一部分,却缺少与代码相同的评审、测试与回滚流程。缺少配套治理的规则外置,会把发布风险从"受控的发版"转变为"随时可能发生的配置变更"。

2.6 选型判断

选型从问题的形态出发,而不是从引擎的能力出发:

问题形态 建议方案 理由
状态不超过五个,转移固定,无人工环节,无外部参与方 状态字段加领域方法内校验 引入引擎的治理成本高于收益
状态与转移较多,多个入口共享同一套转移规则,需要状态轨迹 转移表或状态机库 转移表解决规则分散,状态轨迹解决追溯问题
存在人工任务、等待、超时、需要运行时查看流程走向 工作流引擎 人工任务与实例视图是状态机无法承载的能力
规则条件数量在数十条以上,口径由业务方维护,变更频率高于发版节奏 规则外置(判定器或决策表) 变更成本与参与方是规则外置的核心理由
规则条件少但计算复杂,由开发维护,变更频率低 代码中的策略与判定逻辑 表达式与脚本引入的安全与性能成本不划算
流程跨越多个团队且无法统一流程定义 事件编制加对账 中心化编排需要各方接受同一定义,跨组织难以达成

反例清单(这些场景下引入引擎通常得不偿失):

反例 判断依据
只有一个业务场景使用该流程,且一年内不会调整 流程定义的管理成本无法被复用收益覆盖
把流程定义改成配置,是为了让业务方"看到"流程 展示需求可以用流程文档或只读视图满足,不需要可执行模型
规则由开发维护、变更走正常发版,只是数量稍多 规则外置的收益来自变更成本,而不是规则数量本身
为了统一技术栈,把不同团队各自合理的流程实现强行收敛到一个引擎 统一带来的收益低于各场景适配引擎的成本
用规则引擎承载领域不变量(如金额必须大于零) 领域不变量属于代码职责,外置后可能被绕过

最后一条是实践中最常见的技术债来源:把领域不变量外置为可编辑的规则后,任何有规则编辑权限的人都可能使不变量失效,而代码中的校验无法感知。

2.7 与其他技术的关系

相关技术 关系 引用
事件驱动与消息队列 事件用于触发状态机的事件输入与流程节点的推进;投递语义决定了节点会被重复执行,幂等因此成为节点实现的前提 消息队列原理 第 2.4 节
定时任务与补偿任务 超时任务、催办、超时自动处理、流程实例的滞留扫描都由周期性任务驱动;调度方式决定任务是否可能重复执行 linux: 计划任务与定时器 第 3.8 节
规则缓存与配置中心 规则集与流程定义属于需要动态生效的配置,其加载、刷新与灰度依赖配置中心的能力 Spring Cloud 微服务 第 2.3 节
分布式事务与补偿 长流程跨服务写入的一致性由补偿与对账承担,流程引擎只负责调用顺序 Java 分布式事务实践 第 2.1 节

三、实现

3.1 状态机落地

3.1.1 状态定义与转移表的组织方式

转移表的三种组织方式,按变更成本递增:

/**
 * 方式一:枚举内声明转移,编译期固定,适合状态与转移稳定的场景。
 * 新增转移需要改代码,但不会有运行期配置错误。
 */
public enum OrderStatus {
    PENDING_PAY, PAID, SHIPPED, FINISHED, CANCELLED;

    private static final Map<OrderStatus, Map<OrderEvent, OrderStatus>> TABLE = Map.of(
        PENDING_PAY, Map.of(OrderEvent.PAY_SUCCESS, PAID,
                            OrderEvent.CANCEL,      CANCELLED),
        PAID,        Map.of(OrderEvent.DELIVER,     SHIPPED,
                            OrderEvent.REFUND,      CANCELLED),
        SHIPPED,     Map.of(OrderEvent.SIGN,        FINISHED)
    );

    public static boolean canTransit(OrderStatus from, OrderEvent event) {
        return TABLE.getOrDefault(from, Map.of()).containsKey(event);
    }

    public static OrderStatus target(OrderStatus from, OrderEvent event) {
        OrderStatus to = TABLE.getOrDefault(from, Map.of()).get(event);
        if (to == null) {
            throw new IllegalStateTransitionException(from, event);
        }
        return to;
    }
}
-- 方式二:转移表落库,运行期可查,适合转移随业务配置调整的场景。
-- 代价是运行期错误(配错目标状态)无法在编译期发现,需要校验与灰度。
CREATE TABLE t_state_transition (
  id             BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  biz_type       VARCHAR(64)     NOT NULL COMMENT '业务类型,如 order',
  from_status    VARCHAR(32)     NOT NULL COMMENT '前置状态',
  event          VARCHAR(64)     NOT NULL COMMENT '事件',
  to_status      VARCHAR(32)     NOT NULL COMMENT '目标状态',
  guard_expr     VARCHAR(512)    DEFAULT NULL COMMENT '守卫表达式标识,不含脚本',
  enabled        TINYINT         NOT NULL DEFAULT 1 COMMENT '是否启用',
  version        INT             NOT NULL DEFAULT 1 COMMENT '配置版本',
  update_time    DATETIME(3)     NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
  PRIMARY KEY (id),
  UNIQUE KEY uk_biz_from_event (biz_type, from_status, event)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '状态转移表';

方式三是由状态机库声明状态与转移,框架负责转移判定、监听器与状态轨迹。三种方式可以在同一系统内共存:核心实体用枚举固定,配置化实体用转移表,含人工环节的实体交给流程引擎托管。

3.1.2 持久化与并发控制

状态推进的写入路径需要同时满足三个条件:前置状态匹配、版本号匹配、流水与业务写入同事务。做法已在第 2.2.2 节给出,这里补充两点实现细节:

  • 条件更新必须带前置状态而不是只带主键:只按主键更新会让并发的两次推进同时成功,最终状态取决于执行顺序;
  • 状态流水与业务数据在同一本地事务内写入:分两个事务写入会出现"状态已变但无流水"或"有流水但状态未变",破坏审计链。

批量推进(如批量审核通过)需要单独处理:批量操作不能在一条 SQL 中跳过前置状态校验,应逐条按条件更新并统计影响行数,对影响行数为 0 的记录单独返回失败原因。

3.1.3 状态变更的历史记录与审计

状态流水表是排查与审计的基础,需要记录的内容如下:

CREATE TABLE t_state_log (
  id            BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  biz_type      VARCHAR(64)     NOT NULL COMMENT '业务类型',
  biz_id        BIGINT UNSIGNED NOT NULL COMMENT '业务主键',
  from_status   VARCHAR(32)     DEFAULT NULL COMMENT '变更前状态',
  to_status     VARCHAR(32)     NOT NULL COMMENT '变更后状态',
  event         VARCHAR(64)     NOT NULL COMMENT '触发事件',
  operator_type TINYINT         NOT NULL COMMENT '1 用户 2 系统 3 定时任务 4 运维手工',
  operator_id   VARCHAR(64)     DEFAULT NULL COMMENT '操作人标识,系统操作为任务名',
  trace_id      VARCHAR(64)     DEFAULT NULL COMMENT '链路追踪标识',
  remark        VARCHAR(256)    DEFAULT NULL COMMENT '变更依据或原因',
  create_time   DATETIME(3)     NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
  PRIMARY KEY (id),
  KEY idx_biz (biz_type, biz_id),
  KEY idx_create_time (create_time)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '状态变更流水';

三处要求:operator_type 必须区分系统、任务与人工,运维手工修复不能与正常业务变更混在同一个取值中,否则审计无法识别异常变更;trace_id 与追踪体系对接,使一次请求内的状态变更可以被串起来;流水的保留期由合规要求决定,操作留痕与证据链的完整性要求见 合规与审计 第 2.2 节与第 3.3 节。流水表的指标口径与埋点方式见 Java 应用可观测性埋点 第 3.2 节。

3.1.4 可视化与排查手段

手段 用途 实现要点
状态分布统计 判断是否存在异常积压(如大量长期停留在中间态) 按业务类型与状态分组计数,设置留存时长的分位指标
单笔状态轨迹 排查单笔业务的完整变更过程 按业务主键查询流水,按时间正序展示,标注操作人类型
允许操作列表查询 前端按钮渲染与人工排查 按当前状态返回允许事件,与转移表同源,避免两处定义
非法转移计数 发现入口校验缺失、重复提交、外部绕过写入 转移判定失败与条件更新影响行数为 0 均计入指标

3.2 工作流落地

3.2.1 流程定义的组织与版本管理

流程定义的组织需要回答两个问题:定义存在哪里,版本如何与实例绑定。

组织方式 形态 优点 缺点
定义随应用发布 定义文件在代码仓库中,随应用一起部署 可评审、可回溯、与环境一致 流程调整需要发版,失去了部分引擎化收益
定义存于引擎库 通过建模器编辑后直接部署到引擎 调整无需发版 缺少与代码同级的评审与测试,环境间同步依赖人工
定义在代码库、部署到引擎 定义文件入库评审,由流水线部署到引擎 兼顾评审与免发版 需要额外的部署流程与权限控制

版本管理的三条规则:

  1. 新实例绑定启动时的版本,版本发布后只影响新启动的实例;
  2. 存量实例继续使用启动时的定义,直到实例结束,保证流程行为可复现;
  3. 定义一经发布不可修改,只能发布新版本,修改已发布版本会使存量实例的行为在运行中发生变化,是排查最困难的一类问题。

高危 提醒:修改流程定义与状态机转移(在引擎库中直接修改已发布版本的节点、连线与网关条件,或修改正在生效的状态转移表)会改变运行中实例的后续行为。影响范围是全部引用该版本的实例:进行中的实例会在下一次到达被修改的节点时使用新语义,可能出现条件不匹配导致流程停在网关、汇聚节点等待数不一致导致流程永久等待、状态流转跳过了必要环节;若修改的转移表删除了某条转移,业务侧的该操作会直接失败。执行前必须完成四项确认:确认该版本是否仍有运行中实例(按实例状态与版本统计)、确认新定义与旧定义的差异仅影响预期范围、确认过渡期间不会出现跨版本并行的分支(如新旧实例需要在同一汇聚点会合)、确认状态转移表的修改有对应的应用代码兼容。变更应以发布新版本的方式进行,按实例灰度切换而不是直接改库;涉及状态转移表时先在预发环境用存量数据副本验证。回滚方式:将新实例的绑定版本回退到旧版本并停止向新版本启动实例;已经进入新版本的实例只能按新版本的语义处理,或使用引擎提供的实例迁移能力把实例迁回旧版本(迁移前需逐实例核对当前节点在新旧版本中是否存在),无法迁移时应通过流程跳转或人工任务把实例推进到可结束状态。

3.2.2 节点实现与幂等

节点的实现形态与幂等要求:

/**
 * 服务任务节点:调用下游服务,按业务单号幂等,失败抛出可重试异常。
 * 节点内不做远程调用的重试,重试由流程引擎按节点配置统一驱动,避免重试叠加。
 */
@Component("createDeliveryOrder")
public class CreateDeliveryOrderDelegate implements JavaDelegate {

    @Override
    public void execute(DelegateExecution execution) {
        String bizNo = (String) execution.getVariable("bizNo");
        // 幂等键:业务单号加动作类型,重复执行不产生第二次副作用
        if (deliveryOrderMapper.existsByBizNo(bizNo)) {
            return;
        }
        try {
            deliveryClient.create(bizNo);
            deliveryOrderMapper.insert(bizNo, Status.CREATED);
        } catch (ConnectException | SocketTimeoutException e) {
            // 连接与超时类失败可重试
            throw new RetryableNodeException("调用配送服务失败,bizNo=" + bizNo, e);
        } catch (BusinessRejectedException e) {
            // 业务拒绝不可重试,交由边界错误事件处理
            throw new BpmnError("DELIVERY_REJECTED", e.getMessage());
        }
    }
}

幂等的实现手段(唯一约束、去重表、状态条件更新)见 消息可靠性与幂等设计 第 2.5 节。节点实现中需要避免的三个做法:

做法 问题
节点内自带重试循环 与引擎的重试叠加,实际重试次数放大,故障时形成请求风暴
节点内统一捕获所有异常并返回成功 失败被吞掉,流程继续推进,数据停在中间态
节点内在同一事务中连续调用多个下游 事务时长被远程调用拉长,连接占用与锁等待同时上升

3.2.3 人工任务与通知

人工任务的落地包含待办查询、办理、通知三条链路:

链路 实现要点
待办查询 按办理人与候选组查询任务表,返回业务摘要;业务摘要通过业务单号回查业务表,不写入流程变量
办理 认领后校验办理权,办理动作幂等(同一任务重复提交只推进一次),记录办理意见
通知 任务创建与超时提醒通过消息发送,通知失败不影响流程推进,通知内容只含业务单号与跳转链接

通知与流程推进的关系需要明确:通知是流程的旁路动作,发送失败只重试通知本身,不能让通知失败阻塞流程;同时通知不宜由流程节点同步调用,避免外部渠道故障拖慢流程推进。

3.2.4 超时与补偿任务

超时与补偿的技术手段是周期任务,落地要点:

任务 扫描对象 处理动作 幂等要求
任务超时 到期时间已过的待办任务 按流程定义配置提醒、自动通过、自动拒绝或升级 同一任务只处理一次,处理前先更新任务状态
实例滞留 超过阈值未推进的流程实例 告警并进入人工排查队列,不自动推进 只做告警与标记,不做状态修改
补偿重试 执行失败的补偿记录 按退避策略重试,重试耗尽转人工 补偿接口本身幂等
变量清理 已结束实例的变量与历史记录 按保留期归档 归档前确认实例已结束

任务调度方式(应用内定时、独立调度进程、系统级 cron 与 systemd timer)的取舍与注意点见 linux: 计划任务与定时器 第 3.8 节。多实例部署时,超时任务必须通过分布式锁或分片保证同一任务不被重复处理,否则会出现同一任务被多个实例同时处理的重复通知与重复推进。

3.2.5 流程实例查询与运维排查

排查一个流程问题需要的最小视图:

实例视图(按业务单号或实例标识查询)
  1. 实例基本信息:定义标识与版本、业务单号、启动时间、当前状态(运行中、已挂起、已结束)
  2. 当前节点:节点类型(服务任务、人工任务、网关)、进入时间、停留时长
  3. 流转记录:节点进出时间、执行人(人工节点)、异常信息
  4. 任务列表:待办任务、办理人、到期时间、催办次数
  5. 变量快照:流程变量当前值(仅展示,不直接修改)
  6. 关联业务数据:按业务单号回查业务表状态,作为判断依据

排查的第一步是判断"流程状态"与"业务状态"是否一致:流程停在人工任务而业务数据已完成,或流程已结束而业务数据缺失,都属于不一致,需要按第 3.6 节处置。

高危 提醒:批量修复流程实例数据(直接更新实例表的当前节点、批量跳转节点、批量删除滞留实例、批量把实例标记为已结束)会绕过流程定义与状态校验。影响范围是该批次覆盖的全部实例及其关联业务:跳转节点会使目标节点所需的变量缺失,节点执行时抛异常或写入错误数据;把实例标记为已结束会使未执行的补偿节点不再执行;删除实例会连同历史与变量一并丢失,业务单号与流程实例的关联同时断裂。执行前必须完成四项确认:导出待修复实例的完整快照(实例、变量、任务、流转记录)并作为回滚依据、逐类归因并确保修复动作与业务真实状态一致、确认目标节点所需的变量已就位或采用跳转到"人工兜底节点"的策略、确认批量的范围限定了实例状态与时间窗口且不含运行中的正常实例。修复应先在预发环境用生产数据副本验证,按业务类型分小批执行并逐批核对。回滚方式:数据层面按导出的快照逐实例恢复实例表、变量表与任务表;无法完全恢复时应以业务表状态为准,通过流程跳转把实例推进到可结束状态,并记录修复原因与结论,操作留痕要求见 合规与审计 第 3.3 节。

3.3 规则落地

3.3.1 规则的存储与加载方式

方式 存储 更新时效 适用
代码内常量与策略类 代码库 随发版 变更频率低、条件简单
配置中心 配置中心 秒级到分钟级 阈值、开关类规则
规则表加缓存 数据库 由缓存刷新策略决定 规则数量多、需要版本与审批
规则文件加流水线发布 代码库与对象存储 随流水线 需要评审与可回溯

规则表加缓存的组合是主流形态,表结构需要支持版本与发布状态:

CREATE TABLE t_rule (
  id            BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
  rule_set_key  VARCHAR(64)     NOT NULL COMMENT '规则集标识',
  rule_set_version INT          NOT NULL COMMENT '规则集版本',
  rule_id       VARCHAR(64)     NOT NULL COMMENT '规则编号,决策日志引用',
  condition_expr VARCHAR(2048)  NOT NULL COMMENT '条件表达式,仅允许白名单语法',
  action_json   JSON            NOT NULL COMMENT '动作定义,引用已注册的动作标识',
  priority      INT             NOT NULL DEFAULT 0 COMMENT '优先级,数值越大越优先',
  status        TINYINT         NOT NULL COMMENT '0 草稿 1 已发布 2 已下线',
  publish_time  DATETIME(3)     DEFAULT NULL,
  update_by     VARCHAR(64)     NOT NULL COMMENT '最后修改人',
  PRIMARY KEY (id),
  UNIQUE KEY uk_set_ver_rule (rule_set_key, rule_set_version, rule_id),
  KEY idx_set_status (rule_set_key, status)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT = '规则定义表';

加载方式的两条要求:规则集按版本整体加载,半个版本的规则集不参与执行,避免规则之间的引用关系断裂;缓存刷新带版本号校验,本地缓存通过版本号轮询或配置中心的推送机制失效,避免多实例之间长时间使用不同版本。

3.3.2 规则执行顺序与命中策略

执行顺序需要明确到可复现的程度,两种策略的组合方式如下:

执行顺序(首个命中为主,优先级决定顺序)
  1. 按优先级降序排序,优先级相同时按规则编号排序(顺序稳定,不依赖数据库返回顺序)
  2. 依次求值条件,命中后执行动作
  3. 命中策略:互斥规则集取首个命中;累计规则集取全部命中并按合并策略汇总
  4. 无任何规则命中时,执行默认规则;默认规则缺失则返回明确的"无匹配"错误

累计规则集的合并策略
  折扣类:取最小值(更优惠者生效),禁止相加
  额度类:求和并受上限约束
  标签类:取并集
  互斥类:报错,说明规则集定义有冲突

优先级的使用需要治理:优先级字段一旦对业务方开放,容易演变为所有规则争抢高优先级。可行的约束是把优先级降级为"分层"概念(如系统规则层、活动规则层、兜底层),层内按编号排序,不允许同一层内跳过层顺序。

3.3.3 灰度与 A/B 验证

规则变更的风险集中在"结果口径变化对业务的影响"上,因此验证手段以结果对比为主:

阶段 方式 观察指标 通过标准
影子执行 新规则集只计算不生效,与生效版本并行执行 决策差异率、差异样本分布 差异均能归因于本次变更的预期范围
小流量灰度 按用户标识或业务单号哈希切分流量 命中分布、决策耗时、下游指标 与影子阶段结论一致,无异常样本
定向灰度 对指定租户、渠道或活动生效 该范围内业务指标 指标符合预期
全量 切换默认规则集版本 全局业务指标与决策耗时 与灰度结论一致

灰度设计的两条约束:灰度维度一旦确定,切换过程中不能同时调整维度,否则差异无法归因;影子执行与正式执行必须记录同一个决策标识,便于逐笔对比。

高危 提醒:变更规则并全量生效(跳过影子与灰度,直接把新的规则集版本置为默认或把规则状态批量改为已发布)会使新口径立即作用于全部流量。影响范围是该规则集覆盖的全部业务:命中范围扩大或缩小会直接改变折扣、额度、准入与费率,产生对外可见的金额差异与合同口径差异;若规则存在重叠且动作不同,冲突消解结果可能与预期相反;若表达式中新增了未注册的函数或超限的输入处理,会在运行期抛异常,使依赖该决策的接口整体失败。执行前必须完成四项确认:规则集在影子模式下已比对过差异并逐类归因、条件表达式的语法与函数已通过离线校验、规则集的重叠与空洞检查无未决项、变更具备回滚到上一版本的路径且上一版本仍可用。生效应按流量或范围分批放开并逐批观察决策差异率与业务指标。回滚方式:将默认版本指针切回上一发布版本并清理本地缓存,规则表保留全部版本记录不物理删除;已按新口径产生的业务数据(如已发放的优惠、已通过的准入)无法通过回滚自动撤销,需要按业务补偿流程处理,因此生效前的差异评估是控制影响面的主要手段。

3.3.4 规则变更的评审与回滚

环节 要求
编辑 只有草稿状态的规则可编辑,编辑权限与发布权限分离
评审 规则差异需要以可读形式展示(新旧条件与动作对照),评审记录与规则版本绑定
测试 用决策表用例离线执行,覆盖新增与受影响的条件组合
发布 发布动作生成新的规则集版本,已发布版本不可编辑
回滚 通过版本指针切换回退,回退动作同样留痕

评审与发布权限分离的意义在于:规则库是生产代码的一部分,编辑者不应同时拥有使变更直接生效的能力。

3.3.5 规则执行日志与可解释性

决策日志的结构与要求见第 2.4.4 节。落地时的三点取舍:

  • 日志写入位置:同步写入保证完整性但增加决策耗时,异步写入降低耗时但可能丢失;建议对金额与准入类决策同步写入,对展示与推荐类决策异步采样;
  • 日志保留期:与合规留存要求对齐,账务与准入类决策的保留期通常长于其他业务,日志的留存与保护要求见 合规与审计 第 2.4 节;
  • 日志与指标的关系:日志用于单笔解释,指标用于整体判断;命中率、无匹配率、冲突率、求值耗时都应作为指标暴露,指标口径见 Java 应用可观测性埋点 第 3.2 节。

3.3.6 执行性能与缓存

优化手段 作用 注意事项
规则集预编译 避免每次决策重新解析条件表达式 编译后的结构随版本失效,需与版本绑定
条件求值短路 按代价从低到高排列条件,减少昂贵判断 短路顺序改变可能影响依赖同一函数的条件行为
事实对象精简 减少参与匹配的字段数量 精简后需确认规则使用的字段都在其中
结果缓存 对相同输入复用决策结果 输入必须完整参与缓存键,规则版本变化时整体失效
分类规则集 按业务类型把大规则集拆小 分类依据必须来自输入,不能来自调用方声明

结果缓存的风险在于输入与规则版本的组合:缓存键不含规则版本时,规则更新后会出现新旧结果混用;缓存键不含全部输入字段时,会返回错误的决策结果。缓存必须在规则版本变化时整体失效。

3.4 与领域代码的边界

3.4.1 哪些逻辑应留在代码

留在代码 理由
领域不变量(金额非负、状态互斥、数量守恒) 不变量是模型正确性的前提,不允许被外部配置绕过
精确计算(金额、税费、分摊) 需要强类型与精确的数值语义,表达式求值难以保证精度与可测性
数据一致性与事务边界 事务边界由代码与框架管理,规则与流程无法表达
权限与鉴权判定 权限模型需要与认证体系一致,外置会形成第二套权限来源
与外部系统交互的协议细节 协议适配属于技术职责,变更来源于对方而不是业务口径

3.4.2 哪些逻辑适合外置

外置 理由
阈值、费率、限额 数值调整频繁,业务方需要自主控制
名单与黑白名单 数据量大、由业务维护、变更频繁
审批链与审批层级 组织与流程调整频繁,属于流程结构
策略选择(走哪套计算口径) 选项集合稳定,选择条件由业务维护
评分与打分的权重 权重由业务试算与调整

判断依据可以归纳为一条:外置的是"选哪个"和"取多少",留在代码的是"怎么算"和"必须成立"。

3.4.3 避免引擎与代码双写同一逻辑

双写有四种典型形态,都会在变更时产生不一致:

双写形态 表现 处置
代码与规则各有一份条件 代码中仍有 if (userType == VIP && amount > 1000),规则也定义了同一条件 外置后删除代码分支,代码只调用规则接口
状态机与流程条件重复 流程网关条件重复了状态机的转移判定 流程条件只做流程分支选择,状态推进统一走状态机入口
状态字段与引擎实例状态并存 业务表有状态字段,引擎实例也维护状态,两者分别可写 明确唯一权威来源,另一份作为只读投影并定期核对
规则与流程各有一段计算 折扣在规则中算一次,流程节点中又算一次 计算只保留一处,另一处改为读取结果

统一来源的做法是"单一写入口加只读投影":所有状态推进只经过状态机入口,流程实例状态与业务状态字段之间由同步逻辑单向写入,并在对账任务中核对差异。

3.4.4 测试策略

引擎化之后测试的对象从代码分支变为模型与实例,测试方式随之调整:

测试对象 测试方式 参考
状态转移 遍历转移表,逐条断言允许与拒绝,覆盖非法转移与并发冲突 —
规则集 决策表用例逐行断言,覆盖新增规则、受影响规则、无匹配输入与冲突输入 测试与质量保障 第 3.5 节
流程定义 路径覆盖:每个分支、每个终态、每个错误边界至少一条实例路径 测试与质量保障 第 2.6 节
节点实现 幂等验证、重试验证、异常分类验证,外部依赖用替身 测试与质量保障 第 2.5 节
回归 规则与流程变更后,用测试租户跑通全路径并核对业务数据 —

流程定义的测试需要在真实引擎上运行而不是静态校验,因为网关条件、汇聚语义与边界事件的行为只有执行才能验证。测试环境中的流程实例需要随用例清理,避免测试实例混入生产调度,测试数据的隔离方式见 测试与质量保障 第 3.5 节。

3.5 运维与治理

3.5.1 流程实例积压与卡单排查

排查顺序
  1. 按定义版本与当前节点统计实例数与停留时长分布
     → 集中在某一个节点:该节点的实现或依赖异常
     → 分散在多个节点:整体任务调度或引擎不可用
     → 集中在某一个版本:该版本定义的条件或汇聚语义有误
  2. 抽取停留时长最长的实例,查看流转记录与异常信息
  3. 检查该节点的依赖:下游服务可用性、超时配置、重试配置
  4. 检查任务调度:超时任务与补偿任务的最近成功时间
  5. 检查引擎运行时数据:任务表未认领任务数、变量表增长、连接池占用

卡单的根因分类与处置:

根因 判定依据 处置
节点依赖不可用 节点异常信息为连接或超时类 恢复依赖,由引擎按配置重试
重试耗尽 实例状态为异常或等待人工 转入人工任务或补偿节点
网关条件不匹配 实例停在排他网关且无默认分支 补齐默认分支(新版本)或跳转到兜底节点
汇聚等待 并行分支中一支未完成 核对分支激活数,补齐未完成分支
人工任务无人办理 任务候选组为空或办理人已离职 调整候选范围(由业务规则给出)或转办
引擎不可用 全部新实例无法创建 恢复引擎与其数据库,见第 3.5.4 节

3.5.2 引擎元数据与运行时数据的容量管理

引擎自身的数据分为定义(元数据)与实例(运行时数据)两部分,容量管理主要针对运行时数据:

容量估算
  实例数       ≈ 日均流程启动量 × 平均流程时长(天)        # 未结束实例
  历史记录数   ≈ 日均流程启动量 × 保留天数
  变量数据量   ≈ 历史记录数 × 单实例变量个数 × 平均变量大小
  任务数据量   ≈ 未结束实例数 × 单实例待办任务数

示例
  日均启动 5 万笔,平均流程时长 1.5 天
    → 运行中实例约 7.5 万
  保留 180 天(含每个节点流转记录,单实例约 4KB)
    → 历史数据约 3.6 亿 KB,量级为 TB 级

三类治理动作:

动作 做法 前提
归档 将已结束实例、历史流转记录按时间分区迁移到归档库或冷存储 实例状态为已结束,且保留期已过
清理 按时间分区整体丢弃,优于按行删除 清理范围不含未结束实例与异常待人工实例
读写分离 实例查询与业务查询共用同一库时,历史查询走只读实例 查询的实时性要求可接受复制延迟,代价见 mysql 主从实践 第 3.8 节

容量管理的常见失误是只关注业务表的增长而忽略引擎表:引擎历史表的增长速度与流程启动量同量级,且一旦清理策略失效,其膨胀速度往往超过业务表。

3.5.3 版本升级与历史实例兼容

高危 提醒:升级引擎版本(含引擎服务端、客户端依赖与数据库表结构)会改变实例的运行时行为与数据结构。影响范围是该引擎实例上的全部流程定义与运行中实例:升级通常伴随表结构变更脚本,脚本未执行或部分执行会导致启动失败或运行期写入异常;默认参数(重试次数、超时判定、任务过期策略、变量序列化方式)的变更会让运行中实例在下一个节点处使用新的判定口径;序列化方式的变更会使历史实例中的变量无法反序列化,表现为实例读取变量失败或实例无法推进。执行前必须完成五项确认:核对版本说明中的行为变更与表结构变更逐项、确认历史实例与运行中实例的兼容范围(是否存在跨版本不可读的变量结构)、在预发环境用生产数据副本完整跑通一条含人工环节与错误分支的长流程、确认数据库与相关表的备份已完成且恢复流程可用、确认回滚到旧版本时的新版本数据可被旧版本读取或已明确回滚为数据丢失。升级应按实例灰度并在每批之间观察实例推进率与异常计数。回滚方式:应用层面回退到旧版本并停止新实例启动;表结构层面可先保留新旧两套结构,使回退无需执行反向 DDL;若新版本已写入旧版本无法识别的变量结构,回滚时需要逐实例核对并按业务单号重建变量,无法重建的实例通过跳转到人工兜底节点处理。

升级涉及的数据保护措施与恢复流程见 mysql 备份与恢复 第 2.3 节与第 3.6 节:升级前的备份必须包含点级恢复能力,且恢复演练应在升级前完成,而不是在升级失败后才验证。

3.5.4 备份与恢复

引擎数据的恢复要求高于普通业务表,原因在于它是流程推进的唯一依据:

数据 恢复要求 做法
流程定义 可恢复到任一历史版本 定义文件入库,部署产物按版本留存
规则定义 可按版本恢复 规则表不物理删除,版本记录长期保留
流程实例与任务 恢复后能继续推进 与业务表在同一备份策略下,恢复需保持同一时间点
状态流水与决策日志 可追溯 归档后独立备份,保留期与合规要求一致

恢复时的顺序是先定义后实例:定义先恢复到与实例绑定的版本,再恢复实例数据,否则实例会因找不到对应定义版本而无法推进。恢复演练的周期与方式见 mysql 备份与恢复 第 3.6 节。

3.5.5 治理职责的划分

角色 职责 权限边界
业务规则责任人 提出并维护规则口径、确认差异影响 可编辑草稿,不可发布
规则评审人 评审规则差异与影响范围 可发布规则新版本,不可直接改库
流程责任人 维护流程定义与版本 可发布流程新版本,不可修改已发布版本
开发 实现节点、守卫、动作与规则求值能力 不可绕过状态机写入状态字段
运维 实例排查、容量管理、版本升级与恢复 实例级修复需按第 3.2.5 节的流程执行并留痕

职责划分的核心是两条:编辑与发布分离;运行时只读取已发布版本,任何人不能以"临时改一下"的方式直接修改生效中的定义。

3.6 常见问题与处置

问题 典型表现 判定方式 处置
状态数据不一致 业务表状态与流程实例状态不一致;同一实体在两张表中状态不同 按业务单号关联比对;对账任务定时扫描差异 明确唯一权威来源,以业务表状态为准修正投影;修正前导出原值
重复执行与并发冲突 同一节点被执行多次,或状态被推进两次 流水表中同一业务存在重复事件;条件更新影响行数为 0 的次数上升 补齐节点幂等与唯一约束;并发冲突按最新状态重新决策并封顶重试
流程卡住无人处理 实例长期停留在同一节点,无待办任务也无异常 按节点统计停留时长分位;核对任务表是否存在对应任务 补齐候选范围与超时配置;对存量实例按跳转或转办处理
规则冲突与优先级混乱 同一输入在不同时间得到不同结果;多条规则同时命中 规则静态检查的重叠项;决策日志中的多命中记录 引入分层优先级与冲突分组;重叠规则合并或明确互斥
规则无匹配 决策返回无结果,下游接口报错 无匹配率指标上升 补齐默认规则;默认规则缺失属于设计缺陷
表达式导致的性能问题 单次决策耗时上升,或出现超长耗时请求 决策耗时分位指标;求值超时计数 精简事实对象、预编译表达式、限制脚本能力
表达式导致的安全风险 规则内容可执行计划外操作或耗尽资源 规则变更审计、异常线程与内存增长 收紧求值能力至白名单;高风险脚本移出应用进程执行
引擎版本升级导致历史实例不可用 升级后部分实例无法推进或变量读取失败 按实例版本统计推进失败数 见第 3.5.3 节的回滚与实例处理方式
实例数据与业务数据规模失衡 引擎表增长远快于业务表 引擎表行数与业务表行数比值 检查变量是否存放了业务明细;恢复归档与清理任务

问题处置的通用顺序是:先阻止新增(修正判定逻辑、补齐幂等、收紧配置),再处理存量(对已产生的异常实例与不一致数据按第 3.2.5 节的方式逐类修复),最后补齐监控(把该问题的可观测指标加入告警)。

3.7 落地路径

3.7.1 从状态字段到状态机到流程引擎的渐进演进

第 1 步:状态字段加领域方法校验
  适用:状态少、转移固定、单一入口
  产出:统一的状态推进入口与状态流水

第 2 步:抽出转移表
  触发条件:状态推进入口超过一个,或需要向前端返回允许操作列表
  产出:转移表与非法转移的统一拒绝

第 3 步:引入状态机能力(状态机库或自研运行时)
  触发条件:需要状态轨迹查询、监听器扩展、状态可视化
  产出:可查询的状态视图与监听器机制

第 4 步:引入工作流引擎
  触发条件:出现人工任务、等待与超时、需要运行时查看与调整流程走向
  产出:流程定义与版本管理、实例视图、人工任务与超时机制

第 5 步:规则外置
  触发条件:规则数量与变更频率超出代码维护的成本边界,且业务方需要参与
  产出:规则版本、评审、灰度与决策日志

演进的关键约束:每一步都由明确的触发条件驱动,不因技术储备而提前引入;
已经外置的逻辑必须从代码中删除,不保留两套实现。

3.7.2 试点范围的选择

选择标准 说明
流程边界清晰 起止明确、参与方固定,避免试点期间流程范围变化
变更频率高 试点收益来自变更成本的降低,稳定的流程无法体现收益
影响面可控 不涉及资金与对外承诺,或可以先以影子模式运行
具备可对比的基线 能采集变更前后的口径、耗时与缺陷数据
有明确的业务责任人 流程与规则的责任人参与,否则外置后仍然无人维护

试点不宜选择最复杂的流程:复杂流程的建模成本高、试错代价大,容易在试点阶段消耗掉对引擎化收益的信心。

3.7.3 成本与收益评估

维度 收益来源 成本来源
交付效率 规则与流程调整不再等待发版,交付周期缩短 模型编辑、评审与发布流程的固定开销
质量 规则口径可读可核对,非法转移被统一拒绝 引擎引入的新故障模式与相应的运维投入
人力 业务方可自主维护口径,减少开发重复修改 需要有人承担规则与流程的评审与治理
运行 状态与流程可查询,排查路径清晰 引擎运行开销、实例数据容量与升级维护
风险 变更可按版本回滚 配置化变更的生效速度带来的快速扩散风险

评估的可行做法是设置"可回滚的对照期":同一业务在试点范围内使用引擎,范围外保持原实现,对比变更交付周期、缺陷数、排查耗时与运行开销。缺少对照数据的评估容易把引擎带来的可见收益与同时发生的其他改进混为一谈。

3.7.4 避免过度设计的边界

过度设计形态 判断依据 收敛方向
为单一场景引入完整流程引擎 只有一种流程、参与方固定、无人工环节 回到状态机与代码
把领域不变量外置为可编辑规则 规则被修改即破坏模型正确性 不变量回到代码,规则只表达业务口径
自研规则引擎与流程引擎 现有能力可以满足,自研动机是"可控" 优先使用成熟实现,自研仅在有明确的能力缺口时进行
一次外置全部逻辑 把可自动化的判断也改成配置 只外置变化频繁、需要业务参与的部分
用表达式承载控制流 条件中出现循环与复杂分支 复杂逻辑回到代码,规则只做条件与动作

判断是否过度设计的方法是把当前需求与模型能力对照一次:如果模型提供的元素中有大半在可预见的需求里不会被用到,说明模型比问题复杂。


四、总结

  • 规则与流程散落在代码中的代价集中在四处:变更需要发版、分支爆炸、规则不可见、跨团队协作困难;根源是变化点与变化载体的更新成本不匹配
  • 外置把复杂度从"每次修改都要重新理解代码"转移到"维护一套模型与运行时",复杂度只是转移而非消除,判断依据是转移后的总代价是否更低
  • 状态机描述单实体允许的状态与转移,工作流描述步骤、分支与人工环节,规则描述条件到动作的映射;三者的适用问题不同,混用会导致状态字段膨胀、实例表按请求量增长、非法转移无人拒绝
  • 状态推进的可靠防线是数据写入处的条件更新,入口校验与转移判定只是体验与效率的优化;拒绝语义需要区分非法转移(不重试)与并发冲突(可按最新状态重新决策一次)
  • 并行结构的汇聚语义是流程引擎最容易出现永久等待的位置;包含分支在分支数可能为零时需要显式处理路径
  • 流程变量只放推进流程所需的最小信息,业务明细留在业务表;变量使用基础类型,避免历史实例因对象结构变更无法反序列化
  • 规则集的冲突消解策略必须显式选择,配合重叠与空洞检查;缺少这两项检查的规则集在规模上升后会出现无法解释的结果
  • 表达式与脚本求值的安全边界由能力限制决定:同进程内无法完全隔离,控制手段以白名单、去除控制流、限制输入规模与进程级隔离为主
  • 治理是最容易被低估的代价:规则与流程一旦可在线修改,就成为生产代码的一部分,需要与代码同级的评审、测试与回滚流程,编辑与发布权限必须分离
  • 选型从问题形态出发:状态少且转移固定用状态字段加代码校验,入口多且需要轨迹用转移表或状态机库,含人工任务与等待用流程引擎,规则多且由业务维护才做规则外置
  • 引擎只决定下一步调用谁,不提供跨服务原子性;节点实现必须幂等,重试由引擎统一驱动,补偿与对账仍由业务机制承担
  • 状态流水与决策日志是排查与审计的基础:必须记录操作人类型、触发事件、规则集版本与未命中原因,运维手工修复不能与正常业务变更混在同一取值中
  • 四类高危操作分别是修改流程定义与状态机转移、批量修复流程实例数据、变更规则并全量生效、升级引擎版本;它们的共同点是绕过正常校验路径直接改变生效中的模型或存量数据,执行前必须核对存量实例状态、导出快照作为回滚依据,并按范围分批执行
  • 容量管理的主要对象是引擎的历史与变量数据而非业务表,其增长速度与流程启动量同量级;恢复顺序必须先定义后实例,否则实例会因找不到绑定版本而无法推进
  • 落地按状态字段、转移表、状态机、流程引擎、规则外置的顺序演进,每一步由明确的触发条件驱动;已经外置的逻辑必须从代码中删除,不保留两套实现