Formily Reactive Tracker 详解:手动追踪依赖的响应式核心工具

原创2026-09-23 23:37:491,875 阅读
文章标签:前端UI组件

Formily Reactive Tracker 详解:手动追踪依赖的响应式核心工具

导读

Tracker 是 Formily 响应式核心库 @formily/reactive 提供的一个手动依赖追踪工具,它的设计目标是:在依赖发生变化时不重复执行 tracker 函数,只触发 scheduler,是否需要重新执行由使用者自行决定。这一特性使它成为 React/Vue 等框架适配层连接响应式内核与组件渲染的桥梁——例如 @formily/reactive-react 的 useObserver 正是基于 Tracker 实现组件级依赖追踪与按需重渲染。读完本文,你将掌握 Tracker 的完整 API 签名、构造函数参数含义、与 autorun 的本质区别,以及它在真实框架适配中的落地方式。

一、Tracker 是什么

在 packages/reactive/docs/api/tracker.zh-CN.md 中,官方对 Tracker 的描述非常精炼:

主要用于接入 React/Vue 的手动追踪依赖工具,在依赖发生变化时不会重复执行 tracker 函数,需要用户手动重复执行,只会触发 scheduler。

拆解这句话,可以得到三个关键结论:

  1. 手动追踪:与 autorun(自动运行)不同,Tracker 不会自动重复执行被追踪的函数,首次执行需要你手动调用 track。
  2. 变化只触发 scheduler:当被追踪的响应式依赖发生变化时,Tracker 只调用构造函数传入的 scheduler 回调,而不会自动重新执行被追踪的视图函数。
  3. 面向框架适配:正因为它把"依赖变化"和"重新执行"解耦,上层框架可以在 scheduler 中决定"何时、以何种方式"刷新(比如 React 的 setState/forceUpdate,Vue 的依赖更新调度)。

Tracker 定义在 packages/reactive/src/tracker.ts,并从 packages/reactive/src/index.ts 通过 export * from './tracker' 对外导出,使用时直接 import { Tracker } from '@formily/reactive' 即可。

二、API 签名与参数说明

官方文档给出的类签名如下:

class Tracker {
  constructor(scheduler?: (reaction: this['track']) => void, name?: string)
  track: <T>(tracker?: () => T) => T
  dispose: () => void
}

对照源码 packages/reactive/src/tracker.ts 的实现,可以对每个成员做更精确的解读:

1. constructor(scheduler?, name?)

参数 类型 默认值 说明
scheduler (reaction: Reaction) => void 无 依赖变化时触发的调度函数,收到一个 reaction 参数(即 track 方法本身),通常在里面再次调用 tracker.track(view) 完成重执行
name string 'TrackerReaction' 该 Tracker 反应的名字,主要用于调试与标识

注意签名中 reaction: this['track'] 的写法——scheduler 收到的参数就是当前 Tracker 实例的 track 方法本身。这一点在源码中体现为:

constructor(
  scheduler?: (reaction: Reaction) => void,
  name = 'TrackerReaction'
) {
  this.track._scheduler = (callback) => {
    if (this.track._boundary === 0) this.dispose()
    if (isFn(callback)) scheduler(callback)
  }
  this.track._name = name
  this.track._boundary = 0
}

这里有一个容易被忽略的重要行为:当 _boundary === 0(即没有嵌套调用)时,scheduler 触发会先自动 dispose() 当前 Tracker。也就是说,每次依赖变化触发调度时,旧的依赖绑定会被清理,为接下来重新 track 收集新依赖做准备。这正是 Tracker 能实现"依赖动态更新"(见下文测试用例)的底层机制。

2. track(tracker?)

track 是被追踪函数执行入口,也是源码中的核心逻辑:

track: Reaction = (tracker: Reaction) => {
  if (!isFn(tracker)) return this.results
  if (this.track._boundary > 0) return
  if (ReactionStack.indexOf(this.track) === -1) {
    releaseBindingReactions(this.track)
    try {
      batchStart()
      ReactionStack.push(this.track)
      this.results = tracker()
    } finally {
      ReactionStack.pop()
      this.track._boundary++
      batchEnd()
      this.track._boundary = 0
    }
  }
  return this.results
}

关键行为逐条说明:

  • 非函数直接返回上次结果:if (!isFn(tracker)) return this.results,isFn 定义在 packages/reactive/src/checkers.ts。
  • 重入保护:_boundary > 0 时直接返回,避免递归重复执行;同时检查 ReactionStack 中是否已有自身,防止重复入栈。
  • 先释放再收集:执行前调用 releaseBindingReactions(this.track) 清空上一次的依赖绑定,然后 ReactionStack.push(this.track) 将自身压入全局反应栈(定义在 packages/reactive/src/environment.ts),随后执行 tracker()。执行期间,任何被读取的响应式属性都会通过 bindTargetKeyWithCurrentReaction(见 packages/reactive/src/reaction.ts)把当前 Tracker 绑定到该属性上。
  • 批处理包裹:整个执行过程用 batchStart() / batchEnd()(同样来自 packages/reactive/src/reaction.ts)包裹,保证执行过程中触发的多次依赖变更被合并到 PendingReactions,在批处理结束后统一调度。

3. dispose()

dispose = () => {
  disposeBindingReactions(this.track)
}

调用 disposeBindingReactions(packages/reactive/src/reaction.ts 中定义)将 Tracker 标记为 _disposed = true,并释放所有已收集的依赖绑定,同时挂起相关的 computed 反应。销毁后该 Tracker 不再响应任何依赖变化,组件卸载时必须调用它来防止内存泄漏。

三、官方用例逐步解读

原文档给出了一个完整用例:

import { observable, Tracker } from '@formily/reactive'

const obs = observable({
  aa: 11,
})

const view = () => {
  console.log(obs.aa)
}

const tracker = new Tracker(() => {
  tracker.track(view)
})

tracker.track(view)

obs.aa = 22

tracker.dispose()

逐步分析执行过程:

  1. observable({ aa: 11 }) 创建响应式对象。
  2. view 读取 obs.aa,是待追踪的视图函数。
  3. new Tracker(() => { tracker.track(view) }) 创建 Tracker,scheduler 内部通过闭包再次执行 track。注意这里用到了"先声明变量、后引用"的闭包技巧——scheduler 只在依赖变化时才执行,此时 tracker 变量已完成初始化。
  4. tracker.track(view) 手动执行第一次追踪:收集 obs.aa 到当前 Tracker 的依赖集合,view 执行打印 11。
  5. obs.aa = 22 修改依赖属性,触发 runReactions(packages/reactive/src/reaction.ts),找到绑定在该属性上的 Tracker 并调用其 _scheduler,于是 tracker.track(view) 再次执行,view 打印 22。关键在于:view 的第二次执行是由 scheduler 手动触发的,而不是 Tracker 自动完成的。
  6. tracker.dispose() 释放所有依赖绑定,此后 obs.aa 再变化也不会触发任何调度。

这个流程直观展示了"手动追踪 + 手动重执行"的核心模型。

四、结合源码与测试的深入理解

1. Tracker 与 autorun 的本质区别

autorun 定义在 packages/reactive/src/autorun.ts,它的实现与 Tracker 非常相似(同样的 ReactionStack 压栈、batchStart/batchEnd 包裹),但有一个根本差异:

  • autorun 在创建时立即执行一次 reaction(),并且把 reaction 自身作为 _scheduler 的兜底——依赖变化时 reaction 会被重新调度执行(packages/reactive/src/reaction.ts 的 runReactions 中,没有 _scheduler 或不在批处理范围内时直接调用 reaction())。
  • Tracker 创建时不执行任何函数,首次执行必须手动 track;且它强制要求传入 scheduler 来决定"变化后做什么"。

一句话总结:autorun 是"自动循环",Tracker 是"手动开关"。

2. 测试用例验证的关键行为

packages/reactive/src/tests/tracker.spec.ts 中有 4 个测试,覆盖了 Tracker 最重要的行为:

  • base tracker:验证基本流程——track 首次执行、obs.value = 123 后 scheduler 触发重新 track、dispose 后不再响应。
  • nested tracker:验证 view 内部同时存在读与写(obs.value = obs.value || 321)时,首次 track 执行一次、依赖变化后经 scheduler 再执行一次,且能拿到正确值。
  • tracker recollect dependencies:这是最有价值的一个用例,验证依赖动态重收集:
const view = () => {
  fn()
  if (obs.aa === 'aaa') {
    return obs.bb
  }
  return obs.cc
}

首次 track 时 obs.aa === 'aaa',只收集了 obs.aa 和 obs.bb;随后 obs.aa = '111' 触发重执行后,view 分支改变,重新收集 obs.aa 和 obs.cc;此时再改 obs.bb,因为 obs.bb 已不在依赖集合中,不会触发调度。这就是 track 执行前 releaseBindingReactions 先清空旧依赖的意义所在——依赖集合永远是"最近一次执行实际读取的属性"。

  • shared scheduler with multi tracker:模拟 React StrictMode 场景——两个 Tracker 共享一个 render 流程,obs.value 变化后只有 scheduler1 被调用、scheduler2 被调用 0 次。这验证了批处理与去重机制:同一轮变化中,已在调度队列里的反应不会重复入队。

3. Tracker 在 React 适配层的真实落地

Tracker 并非一个孤立概念,它是 packages/reactive-react/src/hooks/useObserver.ts 中 useObserver 的底层实现:

export const useObserver = <T extends () => any>(
  view: T,
  options?: IObserverOptions
): ReturnType<T> => {
  const forceUpdate = useForceUpdate()
  const tracker = useCompatFactory(
    () =>
      new Tracker(() => {
        if (typeof options?.scheduler === 'function') {
          options.scheduler(forceUpdate)
        } else {
          forceUpdate()
        }
      }, options?.displayName)
  )
  return tracker.track(view)
}

可以看到:

  • 用 useCompatFactory 保证组件生命周期内 Tracker 实例只创建一次;
  • scheduler 中调用 forceUpdate() 触发 React 重渲染——这正是"依赖变化只触发 scheduler,由 scheduler 决定重执行"这一设计在框架层的直接体现;
  • options.displayName 被透传为 Tracker 的 name,便于调试。

也就是说,你在 React 中使用 @formily/react 时,每个组件的响应式依赖收集与重渲染调度,底层都是通过 Tracker 完成的。类似地,@formily/reactive-vue 等 Vue 适配层也采用了同一套 Tracker 机制接入 Vue 的渲染调度。

五、最佳实践与注意事项

基于源码与测试,使用 Tracker 时有几点值得注意:

  1. 首次执行必须手动调用 track:Tracker 构造函数不会执行任何追踪函数,忘记调用 track 会导致依赖从未被收集。
  2. scheduler 中务必重新 track:如果 scheduler 只做"通知"而不重新执行 track,那么视图永远不会用新值更新;官方用例中的 tracker.track(view) 模式是最标准的写法。
  3. 及时 dispose:组件卸载或 Tracker 不再需要时调用 dispose(),释放依赖绑定,避免无效调度与内存泄漏。从源码看,每次 scheduler 触发前也会先 dispose 旧绑定,但显式调用仍是必须的收尾动作。
  4. 循环依赖需自控:由于 scheduler 由用户编写,务必保证 scheduler 内部的 track 不会造成无限递归(_boundary 重入保护只能防住同步重入,无法替代业务层面的终止条件)。
  5. 嵌套 Tracker 安全:ReactionStack 的存在保证嵌套 track 时依赖绑定到正确的反应上,测试用例 nested tracker 已验证该场景。

结语

Tracker 是 Formily 响应式体系中最贴近"框架适配"层面的基础工具:它通过"手动追踪、变化只触发 scheduler"的设计,把依赖收集与执行调度彻底解耦,从而让 React/Vue 等不同渲染模型都能以统一方式接入 @formily/reactive。理解它,就理解了 Formily 响应式内核如何与前端框架握手。进一步探索时,可以对照阅读 packages/reactive/src/tracker.ts 源码、packages/reactive/src/tests/tracker.spec.ts 测试,以及 packages/reactive/docs/api/autorun.zh-CN.md 中 autorun 的对比实现。

登录后查看全文
formily