@e7w/easy-model 0.1.7 → 0.1.9

package/README.md

@@ -1,530 +1,298 @@
-# easy-model
-
-一个功能强大的 React 状态管理库，集成了状态管理、IoC 容器、观察者模式和加载器等功能。
-
-## 特性
-
-- 🚀 **简单易用** - 基于类的状态管理，直观的 API 设计
-- 🔄 **响应式** - 自动观察状态变化，精确更新组件
-- 💉 **IoC 容器** - 内置依赖注入容器，支持命名空间隔离
-- 🎯 **类型安全** - 完整的 TypeScript 支持，基于 Zod 的运行时类型验证
-- ⚡ **性能优化** - 智能缓存和垃圾回收机制
-- 🔧 **加载状态管理** - 内置异步操作加载状态管理
-- 🧩 **模块化** - 可按需使用各个功能模块
-
-## 安装
-
-```bash
-npm install @e7w/easy-model
-# 或
-yarn add @e7w/easy-model
-# 或
-pnpm add @e7w/easy-model
-```
-
-## 核心概念
-
-### 1. 状态管理
-
-基于类的状态管理，支持自动观察和响应式更新。
-
-```tsx
-import { useModel } from "@e7w/easy-model";
-
-class CounterModel {
-  constructor(public name: string) {}
-
-  count = 0;
-
-  increment() {
-    this.count++;
-  }
-
-  decrement() {
-    this.count--;
-  }
-
-  reset() {
-    this.count = 0;
-  }
-}
-
-function Counter() {
-  const { count, increment, decrement, reset } = useModel(CounterModel, [
-    "main",
-  ]);
-
-  return (
-    <div>
-      <h2>计数器: {count}</h2>
-      <button onClick={increment}>+1</button>
-      <button onClick={decrement}>-1</button>
-      <button onClick={reset}>重置</button>
-    </div>
-  );
-}
-```
-
-### 2. IoC 容器
-
-内置的依赖注入容器，支持值注入、构造函数注入和装饰器注入。
-
-```tsx
-import { Container, VInjection, CInjection, inject } from "@e7w/easy-model";
-import { z } from "zod";
-
-// 定义配置 schema
-const configSchema = z.object({
-  apiUrl: z.string(),
-  timeout: z.number(),
-});
-
-const loggerSchema = z.object({
-  log: z.function(),
-});
-
-// 定义服务类
-class Logger {
-  log(message: string) {
-    console.log(`[LOG] ${message}`);
-  }
-}
-
-class ApiService {
-  @inject(configSchema)
-  config: z.infer<typeof configSchema> = { apiUrl: "", timeout: 0 };
-
-  @inject(loggerSchema)
-  logger: Logger | undefined;
-
-  async fetchData() {
-    this.logger?.log(`Fetching data from ${this.config.apiUrl}`);
-    // 实际的 API 调用逻辑
-  }
-}
-
-function App() {
-  return (
-    <Container namespace="app">
-      {/* 注入配置值 */}
-      <VInjection
-        schema={configSchema}
-        val={{ apiUrl: "https://api.example.com", timeout: 5000 }}
-      />
-
-      {/* 注入构造函数 */}
-      <CInjection schema={loggerSchema} ctor={Logger} />
-
-      <YourComponents />
-    </Container>
-  );
-}
-```
-
-### 3. 观察者模式
-
-手动观察对象变化，适用于非 React 环境。注意：`observe` 函数是内部实现，不对外导出。
-
-```tsx
-import { watch } from "@e7w/easy-model";
-
-// 注意：observe 函数未导出，这里仅作为概念说明
-// 实际使用中，观察功能已集成在 useModel 和 useInstance 中
-
-// 监听对象变化的概念示例（实际需要通过 useModel 等方式）
-const unwatch = watch(someObservableObject, (path, oldValue, newValue) => {
-  console.log(`属性 ${path.join(".")} 从 ${oldValue} 变为 ${newValue}`);
-});
-
-// 取消监听
-unwatch();
-```
-
-### 4. 加载状态管理
-
-内置的异步操作加载状态管理，支持全局和局部加载状态。
-
-```tsx
-import { loader } from "@e7w/easy-model";
-
-class DataService {
-  data: any[] = [];
-
-  @loader.load(true) // true 表示全局加载状态
-  async fetchData() {
-    const response = await fetch("/api/data");
-    this.data = await response.json();
-    return this.data;
-  }
-
-  @loader.load() // 局部加载状态
-  async updateItem(id: string, updates: any) {
-    const response = await fetch(`/api/data/${id}`, {
-      method: "PUT",
-      body: JSON.stringify(updates),
-    });
-    return response.json();
-  }
-
-  @loader.once() // 只执行一次的异步操作
-  async initializeApp() {
-    // 初始化逻辑
-  }
-}
-
-function DataComponent() {
-  const service = useModel(DataService, []);
-  const { globalLoading } = useModel(loader, []);
-
-  return (
-    <div>
-      {globalLoading > 0 && <div>全局加载中...</div>}
-      <button onClick={() => service.fetchData()}>加载数据</button>
-      {service.data.map(item => (
-        <div key={item.id}>{item.name}</div>
-      ))}
-    </div>
-  );
-}
-```
-
-## API 参考
-
-### 状态管理
-
-#### `useModel<T>(Constructor: T, args: ConstructorParameters<T>): InstanceType<T>`
-
-创建或获取模型实例，自动观察状态变化并更新组件。
-
-**参数:**
-
-- `Constructor`: 模型类构造函数
-- `args`: 构造函数参数数组
-
-**返回值:** 模型实例，包含所有属性和方法
-
-#### `useInstance<T>(instance: T): T`
-
-直接使用现有实例，自动观察状态变化。
-
-**参数:**
-
-- `instance`: 要观察的对象实例
-
-**返回值:** 观察后的实例
-
-#### `provide<T>(Constructor: T): T`
-
-为类提供实例缓存和观察功能。
-
-**参数:**
-
-- `Constructor`: 要包装的类构造函数
-
-**返回值:** 包装后的构造函数，支持实例缓存
-
-### IoC 容器
-
-#### `Container`
-
-IoC 容器组件，提供依赖注入的上下文环境。
-
-**Props:**
-
-- `namespace?: string` - 命名空间，用于隔离不同的依赖注入环境
-- `children: ReactNode` - 子组件
-
-#### `VInjection<T>`
-
-值注入组件，将值注入到容器中。
-
-**Props:**
-
-- `schema: ZodType<T>` - Zod schema，用于类型验证
-- `val: T` - 要注入的值
-
-#### `CInjection<T>`
-
-构造函数注入组件，将构造函数注入到容器中。
-
-**Props:**
-
-- `schema: ZodType<T>` - Zod schema，用于类型验证
-- `ctor: new () => T` - 要注入的构造函数
-
-#### `inject<T>(schema: ZodType<T>, namespace?: string)`
-
-装饰器函数，用于从容器中注入依赖到类属性。
-
-**参数:**
-
-- `schema: ZodType<T>` - Zod schema，用于类型验证
-- `namespace?: string` - 可选的命名空间
-
-**返回值:** 装饰器函数
-
-### 观察者模式
-
-#### `watch(target: object, callback: WatchCallback): () => void`
-
-监听对象的变化。
-
-**参数:**
-
-- `target: object` - 要监听的对象
-- `callback: WatchCallback` - 变化时的回调函数
-
-**返回值:** 取消监听的函数
-
-**WatchCallback 类型:**
-
-```typescript
-type WatchCallback = (
-  path: Array<string | symbol>,
-  oldValue: any,
-  newValue: any
-) => void;
-```
-
-### 加载器
-
-#### `loader.load(isGlobal?: boolean)`
-
-异步方法装饰器，自动管理加载状态。
-
-**参数:**
-
-- `isGlobal?: boolean` - 是否影响全局加载状态，默认为 false
-
-**返回值:** 方法装饰器
-
-#### `loader.once()`
-
-确保异步方法只执行一次的装饰器。
-
-**返回值:** 方法装饰器
-
-#### `loader.isLoading(target: Function): boolean`
-
-检查指定方法是否正在加载中。
-
-**参数:**
-
-- `target: Function` - 要检查的方法
-
-**返回值:** 是否正在加载
-
-#### `loader.isGlobalLoading: boolean`
-
-获取全局加载状态。
-
-**返回值:** 是否有全局加载正在进行
-
-#### `loader.globalLoading: number`
-
-获取当前全局加载的数量。
-
-**返回值:** 正在进行的全局加载数量
-
-#### `finalizationRegistry(model: object)`
-
-为模型注册垃圾回收回调。
-
-**参数:**
-
-- `model: object` - 要监听垃圾回收的对象
-
-**返回值:** 包含 `register` 和 `unregister` 方法的对象
-
-## 高级用法
-
-### 组件间通信
-
-```tsx
-// 全局状态模型
-class AppState {
-  user: User | null = null;
-  theme: "light" | "dark" = "light";
-
-  setUser(user: User) {
-    this.user = user;
-  }
-
-  toggleTheme() {
-    this.theme = this.theme === "light" ? "dark" : "light";
-  }
-}
-
-// 在任何组件中使用
-function Header() {
-  const { user, theme, toggleTheme } = useModel(AppState, []);
-
-  return (
-    <header className={theme}>
-      <span>欢迎, {user?.name}</span>
-      <button onClick={toggleTheme}>切换主题</button>
-    </header>
-  );
-}
-
-function Sidebar() {
-  const { user } = useModel(AppState, []); // 同一个实例
-
-  return <aside>{user && <UserProfile user={user} />}</aside>;
-}
-```
-
-### 嵌套模型
-
-```tsx
-class UserModel {
-  constructor(public id: string) {}
-
-  name = "";
-  email = "";
-
-  updateProfile(data: Partial<UserModel>) {
-    Object.assign(this, data);
-  }
-}
-
-const User = provide(UserModel);
-
-class TeamModel {
-  members: UserModel[] = [];
-
-  addMember(userId: string) {
-    const user = User(userId);
-    this.members.push(user);
-  }
-
-  removeMember(userId: string) {
-    this.members = this.members.filter(m => m.id !== userId);
-  }
-}
-
-function TeamManagement() {
-  const team = useModel(TeamModel, ["team-1"]);
-
-  return (
-    <div>
-      <h2>团队成员</h2>
-      {team.members.map(member => (
-        <UserCard key={member.id} id={member.id} />
-      ))}
-    </div>
-  );
-}
-
-function UserCard({ id }: { id: UserModel["id"] }) {
-  const observedUser = useModel(User, [id]);
-
-  return (
-    <div>
-      <span>{observedUser.name}</span>
-      <span>{observedUser.email}</span>
-    </div>
-  );
-}
-```
-
-### 命名空间隔离
-
-```tsx
-function App() {
-  return (
-    <div>
-      <Container namespace="dev">
-        <VInjection schema={configSchema} val={devConfig} />
-      </Container>
-
-      <Container namespace="prod">
-        <VInjection schema={configSchema} val={prodConfig} />
-      </Container>
-    </div>
-  );
-}
-```
-
-## 最佳实践
-
-### 1. 模型设计
-
-- **单一职责**: 每个模型类应该只负责一个特定的业务领域
-- **类型安全**: 充分利用 TypeScript 的类型系统
-
-```tsx
-// ✅ 好的实践
-class UserModel {
-  constructor(public id: string) {}
-
-  private _profile: UserProfile | null = null;
-
-  get profile() {
-    return this._profile;
-  }
-
-  updateProfile(updates: Partial<UserProfile>) {
-    this._profile = { ...this._profile, ...updates };
-  }
-}
-
-// ❌ 避免的实践
-class BadModel {
-  // 避免在模型中直接操作 DOM
-  updateUI() {
-    document.getElementById("user-name")!.textContent = this.name;
-  }
-}
-```
-
-### 2. 依赖注入
-
-- **明确依赖**: 使用 Zod schema 明确定义依赖的类型
-- **命名空间**: 使用命名空间隔离不同环境的配置
-- **懒加载**: 只在需要时注入依赖
-
-### 3. 性能优化
-
-- **合理使用参数**: 相同参数会返回相同实例，利用这一点进行优化
-- **避免过度观察**: 不要观察不必要的对象
-- **及时清理**: 使用 `finalizationRegistry` 进行资源清理
-
-## 类型定义
-
-```typescript
-// 主要导出的类型
-export interface WatchCallback {
-  (path: Array<string | symbol>, oldValue: any, newValue: any): void;
-}
-
-export interface FinalizationRegistry {
-  register(callback: () => void): void;
-  unregister(): void;
-}
-
-export interface LoaderInstance {
-  loading: Record<symbol, [Function, Promise<unknown>]>;
-  globalLoading: number;
-  load(isGlobal?: boolean): MethodDecorator;
-  once(): MethodDecorator;
-}
-```
-
-## 兼容性
-
-- **React**: >= 17.0.0
-- **TypeScript**: >= 4.5.0
-- **Zod**: ^4.1.5
-
-## 许可证
-
-MIT License - 详见 [LICENSE.md](./LICENSE.md)
-
-## 贡献
-
-欢迎提交 Issue 和 Pull Request！
-
-## 更新日志
-
-详见 [CHANGELOG.md](./CHANGELOG.md)
+# easy-model
+
+**easy-model** 是一个围绕「类模型（Model Class）+ 依赖注入 + 精细化变更监听」构建的 React 状态管理与 IoC 工具集。你可以用普通的 TypeScript 类描述业务模型，通过少量 API 即可：
+
+- **在函数组件中直接创建 / 注入模型实例**（`useModel` / `useInstance`）
+- **跨组件共享同一实例**，支持按参数分组实例缓存（`provide`）
+- **监听模型及其嵌套属性的变化**（`watch` / `useWatcher`）
+- **用装饰器和 IoC 容器做依赖注入**（`Container` / `CInjection` / `VInjection` / `inject`）
+- **统一管理异步调用的加载状态**（`loader` / `useLoader`）
+
+相比 Redux / MobX / Zustand，easy-model 的目标是：**保持接近类 OOP 的心智模型，同时提供较好的性能和类型体验，并内建 IoC 能力。**
+
+### 核心特性一览
+
+- **类模型驱动（Class-based Model）**  
+  直接用 TypeScript 类描述业务：字段即状态，方法即业务逻辑，没有额外的 action / reducer ceremony。
+
+- **按参数缓存实例（Instance by arguments）**  
+  使用 `provide` 包装后，相同参数获取的是同一实例，不同参数获取不同实例，天然支持「按业务 key」分区的状态。
+
+- **深层变更监听（Deep watch）**  
+  `watch` / `useWatcher` 可以监听到：
+  - 模型自身字段的变化；
+  - 嵌套对象属性变化；
+  - 实例之间的嵌套 / 引用关系变化；
+  - getter 返回的衍生实例的变化。
+
+- **React Hooks 友好**
+  - `useModel`：在组件中创建并订阅模型；
+  - `useInstance`：在组件中订阅已有实例；
+  - `useWatcher`：在函数组件中挂载监听回调；
+  - `useLoader`：统一获取全局 loading 状态及单个方法的 loading 状态。
+
+- **IoC 容器与依赖注入**
+  - 使用 `Container` / `CInjection` / `VInjection` / `config` 配置注入；
+  - 使用 `inject` 装饰器在类中按 schema 声明依赖；
+  - 支持 namespace 隔离与 `clearNamespace` 清理。
+
+### 示例（example/）
+
+`example/` 目录包含运行时示例，可帮助快速理解 API。下面是几个「直给」的核心用法片段。
+
+- **基础计数器：`useModel` / `useWatcher`**（见 `example/index.tsx`）  
+  使用 `CounterModel` 展示如何在函数组件中创建模型实例、读取 / 更新字段，并监听变更：
+
+  ```tsx
+  import { useModel, useWatcher } from "easy-model";
+
+  class CounterModel {
+    count = 0;
+    label: string;
+    constructor(initial = 0, label = "计数器") {
+      this.count = initial;
+      this.label = label;
+    }
+    increment() {
+      this.count += 1;
+    }
+    decrement() {
+      this.count -= 1;
+    }
+  }
+
+  function Counter() {
+    const counter = useModel(CounterModel, [0, "示例"]);
+
+    useWatcher(counter, (keys, prev, next) => {
+      console.log("changed:", keys.join("."), prev, "->", next);
+    });
+
+    return (
+      <div>
+        <h2>{counter.label}</h2>
+        <div>{counter.count}</div>
+        <button onClick={() => counter.decrement()}>-</button>
+        <button onClick={() => counter.increment()}>+</button>
+      </div>
+    );
+  }
+  ```
+
+- **跨组件通信：`useModel` + `useInstance`**  
+  通过 `CommunicateModel` + `provide`，让多个组件共享同一实例（按参数分组）：
+
+  ```tsx
+  import { provide, useModel, useInstance } from "easy-model";
+
+  class CommunicateModel {
+    constructor(public name: string) {}
+    value = 0;
+    random() {
+      this.value = Math.random();
+    }
+  }
+
+  const CommunicateProvider = provide(CommunicateModel);
+
+  function CommunicateA() {
+    const { value, random } = useModel(CommunicateModel, ["channel"]);
+    return (
+      <div>
+        <span>组件 A：{value}</span>
+        <button onClick={random}>改变数值</button>
+      </div>
+    );
+  }
+
+  function CommunicateB() {
+    const { value } = useInstance(CommunicateProvider("channel"));
+    return <div>组件 B：{value}</div>;
+  }
+  ```
+
+- **独立监听：`watch`**  
+  在 React 外部或普通函数中监听某个实例，将变更记录到日志列表中：
+
+  ```tsx
+  import { provide, watch } from "easy-model";
+
+  class WatchModel {
+    constructor(public name: string) {}
+    value = 0;
+  }
+
+  const WatchProvider = provide(WatchModel);
+  const inst = WatchProvider("watch-demo");
+
+  const stop = watch(inst, (keys, prev, next) => {
+    console.log(`${keys.join(".")}: ${prev} -> ${next}`);
+  });
+
+  inst.value += 1;
+  // 不再需要时取消监听
+  stop();
+  ```
+
+- **异步加载与全局 Loading：`loader` / `useLoader`**  
+  通过装饰器标记异步方法，并在组件中读取全局 / 单方法 loading 状态：
+
+  ```tsx
+  import { loader, useLoader, useModel } from "easy-model";
+
+  class LoaderModel {
+    constructor(public name: string) {}
+
+    @loader.load(true)
+    async fetch() {
+      return new Promise<number>(resolve =>
+        setTimeout(() => resolve(42), 1000)
+      );
+    }
+  }
+
+  function LoaderDemo() {
+    const { isGlobalLoading, isLoading } = useLoader();
+    const inst = useModel(LoaderModel, ["loader-demo"]);
+
+    return (
+      <div>
+        <div>全局加载状态：{String(isGlobalLoading)}</div>
+        <div>当前加载状态：{String(isLoading(inst.fetch))}</div>
+        <button onClick={() => inst.fetch()} disabled={isGlobalLoading}>
+          触发一次异步加载
+        </button>
+      </div>
+    );
+  }
+  ```
+
+- **依赖注入示例：`example/inject.tsx`**  
+  展示了如何用 zod schema 描述依赖，并通过容器完成注入：
+
+  ```tsx
+  import {
+    CInjection,
+    Container,
+    VInjection,
+    config,
+    inject,
+  } from "easy-model";
+  import { object, number } from "zod";
+
+  const schema = object({ number: number() }).describe("测试用schema");
+
+  class Test {
+    xxx = 1;
+  }
+
+  class MFoo {
+    @inject(schema)
+    bar?: { number: number };
+    baz?: number;
+  }
+
+  config(
+    <Container>
+      <CInjection schema={schema} ctor={Test} />
+      <VInjection schema={schema} val={{ number: 100 }} />
+    </Container>
+  );
+  ```
+
+- **Benchmark 示例：`example/benchmark.tsx`**  
+  提供 easy-model / Redux / MobX / Zustand 在同一场景下的**粗略性能对比面板**，下文有详细说明。
+
+### 测试（test/）
+
+`test/` 目录使用 Vitest + React Testing Library 覆盖了核心行为：
+
+- **provide 与实例缓存**
+  - 相同参数返回同一实例；
+  - 不同参数返回不同实例。
+
+- **watch 的深层监听能力**
+  - 监听简单字段变更；
+  - 监听嵌套对象属性变更；
+  - 处理实例之间的嵌套引用关系；
+  - 支持 getter 返回实例（如 `child2`）的变更路径监听。
+
+- **IoC 配置与命名空间**
+  - 通过 `config` + `Container` + `CInjection` / `VInjection` 注册依赖；
+  - `isRegistered` 判断指定 schema 是否已在某个 namespace 注册；
+  - `clearNamespace` 清理命名空间中的注册项。
+
+- **Hooks 行为**
+  - `useModel` + `useInstance` 在两个组件间共享状态并同步更新 UI；
+  - `useWatcher` 在函数组件中监听模型变化；
+  - `loader` + `useLoader` 正确反映全局 / 单个方法的 loading 状态。
+
+### 与 Redux / MobX / Zustand 的对比
+
+下表是从「心智模型 / 用法复杂度 / 性能 & 能力边界」等角度对比 easy-model 与常见方案：
+
+| 方案           | 编程模型                 | 典型心智负担                                                       | 内建 IoC / DI          | 性能特征（本项目场景）                  |
+| -------------- | ------------------------ | ------------------------------------------------------------------ | ---------------------- | --------------------------------------- |
+| **easy-model** | 类模型 + Hooks + IoC     | 写类 + 写方法即可，少量 API（`provide` / `useModel` / `watch` 等） | 是                     | 在极端批量更新下仍为**个位数毫秒**      |
+| **Redux**      | 不可变 state + reducer   | 需要 action / reducer / dispatch 等模板代码                        | 否                     | 在同场景下为**数十毫秒级**              |
+| **MobX**       | 可观察对象 + 装饰器      | 对响应式系统有一定学习成本，隐藏的依赖追踪                         | 否（偏响应式而非 IoC） | 性能优于 Redux，但仍是**十几毫秒级**    |
+| **Zustand**    | Hooks store + 函数式更新 | API 简洁，偏轻量，适合局部状态                                     | 否                     | 在本场景下是**最快**，但不提供 IoC 能力 |
+
+从项目角度看，easy-model 的特点在于：
+
+- **对比 Redux**：
+  - 不需要拆分 action / reducer / selector，业务逻辑直接写在模型方法里；
+  - 避免大量模板代码，类型推断更直接（基于类字段和方法签名）；
+  - 自动处理实例缓存与变更订阅，无需手动 connect / useSelector。
+
+- **对比 MobX**：
+  - 保留类模型的直觉优势，同时用显式 API（`watch` / `useWatcher`）暴露依赖关系；
+  - 依赖注入、命名空间、清理等能力是 easy-model 的一等公民，而非额外工具。
+
+- **对比 Zustand**：
+  - 性能接近（在本项目 benchmark 中 easy-model 仍处于个位数毫秒），但提供更完整的 IoC / DI / deep watch 组合能力；
+  - 更适合中大型、需要明确领域模型和依赖关系的项目，而不仅是「轻量局部状态 store」。
+
+### Benchmark 场景说明（与 Redux / MobX / Zustand 的粗略性能对比）
+
+在 `example/benchmark.tsx` 中，项目提供了一个**简单且偏极端**的 benchmark，用来在同一台机器上粗略比较不同状态管理方案在「大量同步写入」场景下的表现。核心场景为：
+
+1. **初始化一个包含 10,000 个数字的数组**；
+2. 点击按钮后，对所有元素做 **5 轮自增**；
+3. 使用 `performance.now()` 统计这段**同步计算与状态写入**时间；
+4. **不计入 React 首屏渲染时间**，仅关注每次点击触发的计算 + 状态写入耗时。
+
+在一台常规开发机上的一次测试结果（单位：ms，取单次运行的代表值）大致如下（数值可能因环境而异，仅供参考）：
+
+| 实现           | 耗时（ms） |
+| -------------- | ---------- |
+| **easy-model** | ≈ 3.1      |
+| **Redux**      | ≈ 51.5     |
+| **MobX**       | ≈ 16.9     |
+| **Zustand**    | ≈ 0.6      |
+
+需要特别强调：
+
+- **这是一个刻意放大的「批量更新」场景**，主要目的是放大不同实现之间在「大量同步写入 + 通知」路径上的差异；
+- 结果会受到：浏览器 / Node 版本、硬件性能、打包模式等多种因素影响，因此这里只能作为**趋势性的参考**，而非严谨的性能报告；
+- Zustand 在这个场景下表现最好，这是符合其「极简 store + 函数式更新」定位的；
+- easy-model 虽然在这类极端场景下略慢于 Zustand，但**仍明显快于 Redux / MobX**，同时提供：
+  - 类模型 + IoC + 深度监听等高级能力；
+  - 更适合中大型业务的结构化编码体验。
+
+### 适用场景
+
+easy-model 更适合以下类型的项目：
+
+- 领域模型清晰、希望用类来承载业务状态与方法；
+- 需要在各处优雅地做依赖注入（如仓储、服务、配置、schema 等）；
+- 对「监听某个模型 / 某个嵌套字段的变化」有较强需求；
+- 希望在保证结构化代码与可维护性的同时，获得接近轻量状态库的性能。
+
+如果你目前在使用 Redux / MobX / Zustand，想要：
+
+- 减少心智负担和模板代码；
+- 获得更自然的类模型与 IoC 能力；
+- 又不希望在性能上明显吃亏；
+
+那么可以尝试将部分模块迁移到 easy-model，并先在 `example/benchmark.tsx` 中实际运行一次 benchmark，观察在你的机器和真实业务数据规模下的表现。