游戏客户端架构 / 系统课时

验证生命周期与通信契约

验证生命周期与通信契约

组件重构后,即使角色仍能受伤、HUD 仍能更新,也可能留下重复订阅、停用后回调或销毁后访问的问题。本课把生命周期和消息规则转成可执行断言,覆盖初始化、启停、状态恢复和最终清理,让重构结果可以回归验证。

学习目标

  • 定义组件在创建、就绪、启用、停用和销毁阶段的合法行为。
  • 验证事件仅在有效订阅期交付,并在重新启用时恢复最新状态。
  • 用自动化断言定位初始化顺序、重复订阅和资源清理缺陷。

先确定可观察的契约

生命周期测试不应只判断某个函数是否调用,还要检查外界能够观察到的结果。以生命值组件 Health 和显示组件 Hud 为例,宿主负责组装二者;Health 只向事件总线发布消息,完全不认识 HUD。

阶段 允许的动作 必须满足的行为
Created 注入依赖并初始化 尚不能启用或响应事件
Ready 首次启用、销毁 订阅数为零
Active 更新显示、停用、销毁 每次有效事件只处理一次
Disabled 重新启用、销毁 不接收事件,重启时读取最新快照
Disposed 重复销毁 不再订阅,也不能重新启用

约定事件名为 health.changed,载荷包含 entityId、previousHp 和 currentHp。发布者必须先更新生命值,再发布变更;未发生变化时不发布。显示组件只消费指定实体的消息,不通过事件对象反向修改生命值。

按时间线检查通信链路

关键不是“有订阅和取消订阅两个方法”,而是订阅必须与启用期配对:初始化前不可启用,连续启用不能重复订阅,停用后发出的消息不能修改 HUD,重新启用要补读停用期间变化的状态。销毁还必须清除订阅,并禁止复活。

生命周期状态与事件交付的回归验证时序

运行一份最小契约测试

下面的 Python 3 示例使用标准库即可运行。它用一个小型事件总线模拟同步消息交付,以 assert 核对状态与订阅数量;真实项目可以把相同断言移植到引擎测试框架中。

python
class EventBus:
    def __init__(self):
        self.handlers = {}

    def subscribe(self, topic, callback):
        # 集合保证同一个回调重复订阅时仍只有一份
        self.handlers.setdefault(topic, set()).add(callback)

    def unsubscribe(self, topic, callback):
        self.handlers.get(topic, set()).discard(callback)

    def publish(self, topic, payload):
        # 快照遍历允许回调期间发生解绑
        for callback in tuple(self.handlers.get(topic, ())):
            callback(payload)

    def count(self, topic):
        return len(self.handlers.get(topic, ()))

class Health:
    def __init__(self, bus, entity_id, hp=100):
        self.bus, self.entity_id, self.hp = bus, entity_id, hp

    def damage(self, amount):
        if amount < 0:
            raise ValueError("damage must be non-negative")
        old_hp = self.hp
        self.hp = max(0, self.hp - amount)
        if self.hp != old_hp:
            self.bus.publish("health.changed", {
                "entityId": self.entity_id,
                "previousHp": old_hp,
                "currentHp": self.hp,
            })

class Hud:
    def __init__(self):
        self.state = "Created"
        self.hp = None
        self.received = 0
        self.last_event = None
        self.listener = self.on_health_changed

    def initialize(self, bus, entity_id):
        if self.state != "Created":
            raise RuntimeError("invalid initialization")
        self.bus, self.entity_id = bus, entity_id
        self.state = "Ready"

    def enable(self, snapshot_hp):
        if self.state == "Active":
            return
        if self.state not in ("Ready", "Disabled"):
            raise RuntimeError("invalid enable")
        # 重新启用需要补齐停用期间错过的状态
        self.hp = snapshot_hp
        self.bus.subscribe("health.changed", self.listener)
        self.state = "Active"

    def disable(self):
        if self.state == "Disabled":
            return
        if self.state != "Active":
            raise RuntimeError("invalid disable")
        self.bus.unsubscribe("health.changed", self.listener)
        self.state = "Disabled"

    def destroy(self):
        if self.state == "Disposed":
            return
        if self.state == "Active":
            self.disable()
        if self.state not in ("Ready", "Disabled"):
            raise RuntimeError("invalid destroy")
        self.state = "Disposed"

    def on_health_changed(self, event):
        if self.state == "Active" and event["entityId"] == self.entity_id:
            self.hp = event["currentHp"]
            self.last_event = dict(event)
            self.received += 1

bus = EventBus()
health = Health(bus, "enemy-demo")
hud = Hud()

try:
    hud.enable(health.hp)
except RuntimeError:
    print("初始化顺序:通过")
else:
    raise AssertionError("未初始化仍可启用")

hud.initialize(bus, health.entity_id)
hud.enable(health.hp)
hud.enable(health.hp)
health.damage(20)
assert bus.count("health.changed") == 1
assert (hud.hp, hud.received) == (80, 1)
assert hud.last_event == {
    "entityId": "enemy-demo", "previousHp": 100, "currentHp": 80
}
health.damage(0)
assert hud.received == 1
print("订阅幂等与显示更新:通过")

hud.disable()
health.damage(10)
assert (hud.hp, hud.received, bus.count("health.changed")) == (80, 1, 0)
hud.enable(health.hp)
assert (hud.hp, bus.count("health.changed")) == (70, 1)
print("停用与恢复快照:通过")

hud.destroy()
health.damage(10)
assert (hud.hp, hud.received, bus.count("health.changed")) == (70, 1, 0)
try:
    hud.enable(health.hp)
except RuntimeError:
    print("销毁解绑与禁止复活:通过")
else:
    raise AssertionError("已销毁组件仍可启用")

预期输出:

text
初始化顺序:通过
订阅幂等与显示更新:通过
停用与恢复快照:通过
销毁解绑与禁止复活:通过

这个例子检查的是契约而非某个引擎回调名称。Hud 没有持有 Health,宿主在启用时提供生命值快照;事件总线的订阅数是可检查的观测点,能直接暴露重复注册或解绑遗漏。

把失败归因到具体边界

测试失败时按生命周期顺序排查,而不是直接更换整个事件系统。

  • 未初始化就可启用:检查宿主是否在依赖注入和初始化完成前调用启用操作。
  • 一次伤害刷新多次:记录订阅者身份与注册次数,查找重复注册或旧实例残留。
  • 停用后仍刷新:检查解绑时使用的回调引用是否与订阅时相同,以及消息是否已进入待执行队列。
  • 重新启用显示旧值:检查是否读取最新状态快照,不能依赖停用期间被丢弃的事件。
  • 销毁后仍访问对象:检查销毁时是否完成解绑、取消异步任务,并拒绝后续启用。

纳入重构验收

把这些用例放入每次组件重构的自动回归,并增加至少一次从角色生成、受伤、停用、重新启用到场景退出的集成测试。验收证据应包括状态断言、事件处理次数、订阅数量和错误日志;只看最终 HUD 文本不足以证明链路没有泄漏。

通过标准是合法路径结果正确、非法路径明确拒绝、停用期间无多余副作用、销毁后无订阅残留。这样才算验证了可替换的组件行为,而不仅是演示场景“看起来能运行”。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

验证生命周期与通信契约

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通