首页 理论 架构 工程 文档 白皮书 著作 研究 案例 下载 博客 关于 开始使用 →
首页 › 第十六编　ICAI Engine计算工程› 第216章　ObjectRepository

第216章　ObjectRepository

📅 2026年09月11日 👤 东塬一老翁 📂 第十六编　ICAI Engine计算工程

第216章　ObjectRepository

216.1 ObjectRepository定义

在第215章中，IndividualRepository 负责 Individual 个体对象的持久化。

Individual 内部又包含大量具体 Object，因此需要进一步建立 ObjectRepository。

ObjectRepository 是 Object Domain Object 与持久化系统之间的边界，负责对象的保存、查询、更新和删除。

其基本模型为：

OR=(O,M,Q,U,D,T)OR=(O,M,Q,U,D,T)

其中：

  • OO：Object，对象领域对象；
  • MM：Mapping，对象映射；
  • QQ：Query，对象查询；
  • UU：Update，对象更新；
  • DD：Delete，对象删除；
  • TT：Time，持久化操作时间。

因此：

ObjectRepository=Save+Query+Update+Delete\boxed{ ObjectRepository = Save + Query + Update + Delete }

其基本关系为：

Object Domain Object
        ↓
ObjectRepository
        ↓
ObjectMapper
        ↓
PDO
        ↓
MySQL

读取方向则相反：

MySQL
  ↓
PDO
  ↓
ObjectRepository
  ↓
ObjectMapper
  ↓
Object Domain Object

因此 ObjectRepository 的本质是：

ObjectRepository=Object Persistence Boundary\boxed{ ObjectRepository = Object\ Persistence\ Boundary }

216.2 Object领域对象

前面的 ObjectEngine 已经定义对象模型：

O=(ID,T,A,S,R)O=(ID,T,A,S,R)

其中：

  • IDID：Object ID，对象唯一标识；
  • TT：Type，对象类型；
  • AA：Attributes，对象属性集合；
  • SS：State，对象当前状态；
  • RR：Relations，对象关系集合。

例如一个对象：

Object O-001
    ├── ID
    ├── Type
    ├── Attributes
    ├── State
    └── Relations

因此：

Object
≠
objects表的一行数据

数据库只是 Object 的一种持久化表达。

可以表示为：

DomainObject↔PersistenceDataDomainObject \leftrightarrow PersistenceData

而不是：

DomainObject=PersistenceDataDomainObject = PersistenceData

216.3 ObjectRepository与ObjectEngine

必须首先明确两个组件的职责边界。

ObjectEngine 负责：

对象计算
对象匹配
对象变化计算
对象更新候选计算
对象验证

ObjectRepository 负责：

对象保存
对象查询
对象读取
对象更新
对象删除

因此：

ObjectEngine=CalculationObjectEngine=Calculation ObjectRepository=PersistenceObjectRepository=Persistence

例如：

Object
  ↓
ObjectEngine
  ↓
计算对象状态变化
  ↓
Update Candidate
  ↓
UpdateEngine
  ↓
ObjectRepository
  ↓
MySQL

ObjectRepository 不应该自己判断：

这个对象是否应该改变？

它只负责：

这个已经确定的对象状态如何正确保存？

216.4 对象保存

216.4.1 保存定义

对象保存是把合法的 Object Domain Object 转换为持久化数据并写入数据库。

基本流程：

Object
  ↓
Validate
  ↓
Map
  ↓
Exists
  ↓
Insert
  ↓
ReadBack
  ↓
Verify

公式：

Save(O)→Validate→Map→Persist→VerifySave(O) \rightarrow Validate \rightarrow Map \rightarrow Persist \rightarrow Verify

216.5 对象保存条件

Object 不能因为 PHP 中存在一个对象实例就直接保存。

应该首先验证：

ValidObject=ID∧Type∧Attributes∧StateValidObject = ID \land Type \land Attributes \land State

其中：

  • IDID：对象身份合法；
  • TypeType：对象类型合法；
  • AttributesAttributes：属性结构合法；
  • StateState：状态结构合法。

因此：

PHPObject≠ValidDomainObjectPHPObject \neq ValidDomainObject

而：

ValidDomainObject≠ValidPersistenceDataValidDomainObject \neq ValidPersistenceData

必须经过 Repository Mapping 和持久化验证。

216.6 对象保存的数据结构

基础对象可以保存到：

objects

属性可以保存到：

object_attributes

关系可以保存到：

object_relations

状态历史可以保存到：

object_state_history

因此：

objects
    │
    ├── object_attributes
    ├── object_relations
    └── object_state_history

ObjectRepository 可以负责对象聚合的持久化协调，但不应该把所有认知计算都塞进 Repository。

216.7 对象查询

对象查询是 ObjectRepository 最重要的能力之一。

查询不只是：

SELECT * FROM objects

而是根据不同查询条件获取对象集合。

基本模型：

Query(C)→{O1,O2,…,On}Query(C)\rightarrow \{O_1,O_2,\ldots,O_n\}

其中 CC 是查询条件。

例如：

按照ID查询
按照Individual查询
按照Type查询
按照State查询
按照创建时间查询
按照状态范围查询

216.8 按ID查询

最基本的对象查询：

findById(ID)→OfindById(ID)\rightarrow O

流程：

Object ID
   ↓
Repository
   ↓
SELECT
   ↓
Persistence Data
   ↓
Mapper
   ↓
Object

PHP：

public function findById($id)
{
    $sql = "
        SELECT *
        FROM objects
        WHERE id = :id
        LIMIT 1
    ";

    $stmt = $this->pdo->prepare($sql);

    $stmt->execute(array(
        ':id' => $id
    ));

    $data = $stmt->fetch(PDO::FETCH_ASSOC);

    if (!$data) {
        return null;
    }

    return $this->mapper->toDomain($data);
}

这里返回的是 Domain Object，而不是裸数据库数组。

216.9 按Individual查询对象

一个 Individual 可以拥有多个 Object：

I→{O1,O2,…,On}I \rightarrow \{O_1,O_2,\ldots,O_n\}

因此需要：

findByIndividualId(I)→{O}findByIndividualId(I) \rightarrow \{O\}

例如：

public function findByIndividualId($individualId)
{
    $sql = "
        SELECT *
        FROM objects
        WHERE individual_id = :individual_id
        ORDER BY id ASC
    ";

    $stmt = $this->pdo->prepare($sql);

    $stmt->execute(array(
        ':individual_id' => $individualId
    ));

    $objects = array();

    while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
        $objects[] = $this->mapper->toDomain($data);
    }

    return $objects;
}

这项能力对于：

IndividualRepository
IndividualAggregateLoader
CognitiveEngine
SceneEngine

都非常重要。

216.10 按对象类型查询

Object Type 是对象的重要分类属性。

因此：

findByType(T)→{O1,…,On}findByType(T)\rightarrow\{O_1,\ldots,O_n\}

例如：

public function findByType($type)
{
    $sql = "
        SELECT *
        FROM objects
        WHERE type = :type
        ORDER BY id ASC
    ";

    $stmt = $this->pdo->prepare($sql);

    $stmt->execute(array(
        ':type' => $type
    ));

    $objects = array();

    while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
        $objects[] = $this->mapper->toDomain($data);
    }

    return $objects;
}

Repository 只是查询。

真正的：

类型计算
类型推导
类型匹配

应该由 ObjectEngine 或 MatchingEngine 处理。

216.11 按状态查询

对象状态也是重要的持久化查询条件。

例如：

ready
active
blocked
inactive
archived

可以建立：

findByState(S)→{O}findByState(S)\rightarrow\{O\}

例如：

public function findByState($state)
{
    $sql = "
        SELECT *
        FROM objects
        WHERE state = :state
        ORDER BY id ASC
    ";

    $stmt = $this->pdo->prepare($sql);

    $stmt->execute(array(
        ':state' => $state
    ));

    $objects = array();

    while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
        $objects[] = $this->mapper->toDomain($data);
    }

    return $objects;
}

但是必须注意：

QueryState≠CalculateStateQueryState \neq CalculateState

Repository 查询已经保存的状态。

StateEngine 计算状态。

216.12 对象聚合查询

Object 本身还可能拥有：

Attributes
State
Relations

因此可以提供：

LoadAggregate(OID)→(O,A,S,R)LoadAggregate(OID) \rightarrow (O,A,S,R)

完整读取：

objects
   ↓
Object
   ├── Attributes
   ├── State
   └── Relations

例如：

public function loadAggregate($id)
{
    $object = $this->findById($id);

    if (!$object) {
        return null;
    }

    $object->setAttributes(
        $this->attributeRepository->findByObjectId($id)
    );

    $object->setRelations(
        $this->relationRepository->findByObjectId($id)
    );

    return $object;
}

状态可以由 StateRepository 加载。

这样避免 ObjectRepository 自己重新实现整个 StateRepository 和 RelationRepository。

216.13 查询与计算必须分离

这是 ObjectRepository 设计中的核心原则。

例如用户要求：

找到所有可处理当前任务的对象。

不能直接在 ObjectRepository 中实现全部认知判断。

正确流程：

Requirement
    ↓
ObjectRepository
    ↓
Load Object Candidates
    ↓
ObjectEngine
    ↓
MatchingEngine
    ↓
CapabilityEngine
    ↓
DecisionEngine

因此：

Repository→Candidate RetrievalRepository \rightarrow Candidate\ Retrieval Engine→Candidate CalculationEngine \rightarrow Candidate\ Calculation DecisionEngine→Final SelectionDecisionEngine \rightarrow Final\ Selection

216.14 对象更新

对象更新模型：

Ot+ΔO→Ot+1O_t+\Delta O\rightarrow O_{t+1}

其中：

  • OtO_t：当前对象；
  • ΔO\Delta O：经过验证的变化；
  • Ot+1O_{t+1}：更新后的对象。

基本流程：

Current Object
      ↓
Load
      ↓
Compare
      ↓
ΔObject
      ↓
Validate
      ↓
Update
      ↓
ReadBack
      ↓
Verify

216.15 对象更新不是对象重建

错误方式：

Delete Object
    ↓
Create New Object

正确方式：

Object_t
    ↓
ΔO
    ↓
Object_{t+1}

例如：

Object O-001
state = ready

经过 StateEngine 和 UpdateEngine 确认：

ready → active

那么只需要：

UPDATE objects
SET state = 'active'
WHERE id = ?

不需要重新创建 Object。

216.16 对象属性更新

如果只是某一个属性发生变化：

At+ΔA→At+1A_t+\Delta A\rightarrow A_{t+1}

例如：

temperature = 30

变成：

temperature = 35

则：

ΔA=temperature:30→35\Delta A = temperature:30\rightarrow35

只更新该属性。

这就是：

Minimal Object Update\boxed{Minimal\ Object\ Update}

216.17 对象状态更新

状态更新必须经过 StateEngine。

正确流程：

Event
 ↓
StateEngine
 ↓
Candidate State
 ↓
Validation
 ↓
Verification
 ↓
UpdateEngine
 ↓
ObjectRepository
 ↓
MySQL

而不能：

ObjectRepository
       ↓
直接改变状态

Repository 不应该自己决定：

ready 是否可以变成 active？

这是 StateEngine 的职责。

216.18 对象关系更新

如果 Object 新增关系：

O1 → supports → O2

应该由 RelationEngine 计算关系是否合法。

流程：

Object O1
Object O2
Condition
Rule
    ↓
RelationEngine
    ↓
Relation Candidate
    ↓
Verification
    ↓
RelationRepository

而不是 ObjectRepository 自己计算关系。

因此：

ObjectRepository≠RelationEngineObjectRepository \neq RelationEngine

216.19 对象删除

Object 删除必须特别谨慎，因为 Object 可能被大量认知结构引用。

例如：

Individual
   ↓
Object
   ↓
Relation
   ↓
Knowledge
   ↓
Capability
   ↓
Method
   ↓
Behavior
   ↓
Execution

因此：

Delete(Object)≠DELETE FROM objectsDelete(Object) \neq DELETE\ FROM\ objects

216.20 对象删除前引用检查

删除 Object 前应该检查：

Individual Reference
Relation Reference
Knowledge Reference
Capability Reference
Method Reference
Behavior Reference
Memory Reference
Experience Reference
History Reference

可以定义：

CanDelete(O)=NoRequiredReference∧DeleteRule∧HistoryPolicyCanDelete(O) = NoRequiredReference \land DeleteRule \land HistoryPolicy

如果存在必须保留的引用：

Delete
   ↓
Reference Check
   ↓
Blocked

而不是强制删除。

216.21 对象删除方式

ObjectRepository 可以提供：

Logical Delete
Archive
Physical Delete

逻辑删除

active
  ↓
deleted

保留对象数据。

归档

active
  ↓
archived

对象停止当前使用，但历史数据继续保存。

物理删除

真正删除：

DELETE FROM objects

必须经过引用和删除规则检查。

因此：

PhysicalDeletePhysicalDelete

应该是最严格的一种操作。

216.22 ObjectRepository PHP接口

兼容 PHP 5.6 / PHP 7：

<?php

interface ObjectRepositoryInterface
{
    public function findById($id);

    public function findByIndividualId($individualId);

    public function findByType($type);

    public function findByState($state);

    public function loadAggregate($id);

    public function save($object);

    public function update($object);

    public function archive($id);

    public function delete($id);

    public function exists($id);
}

接口本身不包含：

ObjectEngine
StateEngine
RelationEngine
MatchingEngine
DecisionEngine

它只定义对象持久化能力。

216.23 ObjectMapper

ObjectMapper 负责：

Object↔PersistenceDataObject \leftrightarrow PersistenceData

例如：

<?php

class ObjectMapper
{
    public function toPersistence($object)
    {
        return array(
            'id' => $object->getId(),
            'individual_id' => $object->getIndividualId(),
            'type' => $object->getType(),
            'name' => $object->getName(),
            'state' => $object->getState()
        );
    }

    public function toDomain($data)
    {
        $object = new ObjectEntity();

        $object->setId($data['id']);
        $object->setIndividualId($data['individual_id']);
        $object->setType($data['type']);
        $object->setName($data['name']);
        $object->setState($data['state']);

        return $object;
    }
}

这里使用 ObjectEntity，是为了避免 PHP 中 Object 与基础对象概念产生命名混乱。

216.24 ObjectRepository完整基本实现

<?php

class MySQLObjectRepository implements ObjectRepositoryInterface
{
    protected $pdo;
    protected $mapper;

    public function __construct(PDO $pdo, ObjectMapper $mapper)
    {
        $this->pdo = $pdo;
        $this->mapper = $mapper;
    }

    public function exists($id)
    {
        $sql = "
            SELECT COUNT(*) AS total
            FROM objects
            WHERE id = :id
        ";

        $stmt = $this->pdo->prepare($sql);

        $stmt->execute(array(
            ':id' => $id
        ));

        $row = $stmt->fetch(PDO::FETCH_ASSOC);

        return ((int)$row['total'] > 0);
    }

    public function findById($id)
    {
        $sql = "
            SELECT *
            FROM objects
            WHERE id = :id
            LIMIT 1
        ";

        $stmt = $this->pdo->prepare($sql);

        $stmt->execute(array(
            ':id' => $id
        ));

        $data = $stmt->fetch(PDO::FETCH_ASSOC);

        if (!$data) {
            return null;
        }

        return $this->mapper->toDomain($data);
    }

    public function findByIndividualId($individualId)
    {
        $sql = "
            SELECT *
            FROM objects
            WHERE individual_id = :individual_id
            ORDER BY id ASC
        ";

        $stmt = $this->pdo->prepare($sql);

        $stmt->execute(array(
            ':individual_id' => $individualId
        ));

        $objects = array();

        while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
            $objects[] = $this->mapper->toDomain($data);
        }

        return $objects;
    }

    public function findByType($type)
    {
        $sql = "
            SELECT *
            FROM objects
            WHERE type = :type
            ORDER BY id ASC
        ";

        $stmt = $this->pdo->prepare($sql);

        $stmt->execute(array(
            ':type' => $type
        ));

        $objects = array();

        while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
            $objects[] = $this->mapper->toDomain($data);
        }

        return $objects;
    }

    public function findByState($state)
    {
        $sql = "
            SELECT *
            FROM objects
            WHERE state = :state
            ORDER BY id ASC
        ";

        $stmt = $this->pdo->prepare($sql);

        $stmt->execute(array(
            ':state' => $state
        ));

        $objects = array();

        while ($data = $stmt->fetch(PDO::FETCH_ASSOC)) {
            $objects[] = $this->mapper->toDomain($data);
        }

        return $objects;
    }

    public function save($object)
    {
        $data = $this->mapper->toPersistence($object);

        $sql = "
            INSERT INTO objects
            (
                id,
                individual_id,
                type,
                name,
                state
            )
            VALUES
            (
                :id,
                :individual_id,
                :type,
                :name,
                :state
            )
        ";

        $stmt = $this->pdo->prepare($sql);

        $success = $stmt->execute(array(
            ':id' => $data['id'],
            ':individual_id' => $data['individual_id'],
            ':type' => $data['type'],
            ':name' => $data['name'],
            ':state' => $data['state']
        ));

        if (!$success) {
            return false;
        }

        return $this->exists($data['id']);
    }

    public function update($object)
    {
        $data = $this->mapper->toPersistence($object);

        $sql = "
            UPDATE objects
            SET
                individual_id = :individual_id,
                type = :type,
                name = :name,
                state = :state
            WHERE id = :id
        ";

        $stmt = $this->pdo->prepare($sql);

        $success = $stmt->execute(array(
            ':id' => $data['id'],
            ':individual_id' => $data['individual_id'],
            ':type' => $data['type'],
            ':name' => $data['name'],
            ':state' => $data['state']
        ));

        if (!$success) {
            return false;
        }

        return $this->exists($data['id']);
    }

    public function archive($id)
    {
        $sql = "
            UPDATE objects
            SET state = 'archived'
            WHERE id = :id
        ";

        $stmt = $this->pdo->prepare($sql);

        return $stmt->execute(array(
            ':id' => $id
        ));
    }

    public function delete($id)
    {
        $sql = "
            DELETE FROM objects
            WHERE id = :id
        ";

        $stmt = $this->pdo->prepare($sql);

        return $stmt->execute(array(
            ':id' => $id
        ));
    }

    public function loadAggregate($id)
    {
        $object = $this->findById($id);

        if (!$object) {
            return null;
        }

        /*
         * Attributes、Relations、State
         * 应由对应 Repository 加载。
         */

        return $object;
    }
}

这段实现展示的是 Repository 的基本持久化职责。它没有把 ObjectEngine 的计算逻辑放进 Repository。

实际项目中的字段名称必须以真实数据库结构为准，不能因为理论模型而直接假设现有项目一定存在这些字段。

216.25 对象保存后的验证

执行：

$stmt->execute();

只能说明 PDO 执行过程没有直接报告失败。

不能简单等价于：

PersistenceSuccessPersistenceSuccess

更完整的验证：

PersistenceSuccess=SQLSuccess∧Exists∧IdentityMatch∧DataMatchPersistenceSuccess = SQLSuccess \land Exists \land IdentityMatch \land DataMatch

因此保存流程：

Save
 ↓
SQL Execute
 ↓
Exists
 ↓
ReadBack
 ↓
Compare
 ↓
Verify

如果保存后的对象读取结果不符合预期，就应该记录持久化验证失败。

216.26 对象更新后的验证

更新同样不能只判断 SQL 是否执行。

应该：

Update(Ot,ΔO)→ReadBack→Compare→VerifyUpdate(O_t,\Delta O) \rightarrow ReadBack \rightarrow Compare \rightarrow Verify

例如：

state:
ready
↓
active

更新后重新读取：

state = active

才能确认：

VerifiedUpdate=trueVerifiedUpdate=true

216.27 ObjectRepository与StateRepository

ObjectRepository 保存 Object 本体。

StateRepository 保存 State 持久化记录。

二者关系：

ObjectEngine
      ↓
StateEngine
      ↓
State Candidate
      ↓
UpdateEngine
      ↓
ObjectRepository / StateRepository

不能让 ObjectRepository 自己实现完整 StateEngine。

因为：

Object≠StateObject \neq State

虽然：

Object→StateObject \rightarrow State

但是两者属于不同 Domain Object。

216.28 ObjectRepository与RelationRepository

同样：

ObjectRepository

负责：

Object

而：

RelationRepository

负责：

Relation

关系计算由：

RelationEngine

完成。

完整流程：

Object O1
Object O2
   ↓
RelationEngine
   ↓
Relation Candidate
   ↓
Verification
   ↓
RelationRepository
   ↓
MySQL

因此不能因为 Relation 是 Object 的组成部分，就把 RelationEngine 的逻辑直接放进 ObjectRepository。

216.29 ObjectRepository与IndividualRepository

两者属于不同层级。

Individual→ObjectsIndividual \rightarrow Objects

IndividualRepository：

保存 Individual
读取 Individual
协调 Individual 聚合

ObjectRepository：

保存 Object
查询 Object
更新 Object
删除 Object

关系：

IndividualRepository
        ↓
ObjectRepository
        ↓
objects

或者通过 AggregateLoader：

Individual
   ↓
IndividualAggregateLoader
   ↓
ObjectRepository
   ↓
Object集合

因此：

IndividualRepository≠ObjectRepositoryIndividualRepository \neq ObjectRepository

但是：

IndividualRepository⊃Object Aggregate CoordinationIndividualRepository \supset Object\ Aggregate\ Coordination

216.30 对象删除与历史数据

一个 Object 可能已经产生：

State History
Behavior History
Execution History
Feedback
Memory
Experience
Knowledge
Relation History

因此：

DeleteObject≠DeleteObjectHistoryDeleteObject \neq DeleteObjectHistory

尤其当历史数据已经进入 Memory、Experience 或 Learning 后，直接物理删除 Object 可能破坏历史引用。

因此推荐：

Object Active
     ↓
Object Inactive
     ↓
Object Archived

历史继续保存。

如果必须物理删除：

Reference Check
      ↓
History Policy
      ↓
Delete Rule
      ↓
Physical Delete

216.31 ObjectRepository的数据生命周期

对象持久化生命周期可以定义为：

Create
   ↓
Initialize
   ↓
Save
   ↓
Load
   ↓
Runtime
   ↓
Modify
   ↓
Validate
   ↓
Update
   ↓
Verify
   ↓
Inactive
   ↓
Archive
   ↓
Delete

而认知生命周期则可能是：

Object
 ↓
State
 ↓
Relation
 ↓
Scene
 ↓
Knowledge
 ↓
Capability
 ↓
Method
 ↓
Decision
 ↓
Behavior
 ↓
Execution
 ↓
Result
 ↓
Feedback
 ↓
Learning
 ↓
Update
 ↓
ObjectRepository

两个生命周期通过 Repository 与 UpdateEngine 连接。

216.32 ObjectRepository完整工程结构

最终 Object 相关工程结构可以形成：

Controller
    ↓
ObjectService
    ├── ObjectRepository
    ├── StateRepository
    └── RelationRepository
             ↓
          MySQL

认知计算：

ObjectService
    ↓
ObjectEngine
    ↓
StateEngine
    ↓
RelationEngine
    ↓
SceneEngine
    ↓
KnowledgeEngine

更新：

LearningEngine
      ↓
Update Candidate
      ↓
UpdateEngine
      ↓
Object
      ↓
ObjectRepository
      ↓
MySQL

216.33 ObjectRepository统一操作模型

可以将 ObjectRepository 的四项核心操作统一表示为：

保存

Save(O)→Validate→Map→Insert→VerifySave(O) \rightarrow Validate \rightarrow Map \rightarrow Insert \rightarrow Verify

查询

Query(C)→Database→Map→{O}Query(C) \rightarrow Database \rightarrow Map \rightarrow \{O\}

更新

Ot+ΔO→Validate→Update→ReadBack→VerifyO_t+\Delta O \rightarrow Validate \rightarrow Update \rightarrow ReadBack \rightarrow Verify

删除

Delete(O)→ReferenceCheck→DeletePolicy→Archive/Delete→VerifyDelete(O) \rightarrow ReferenceCheck \rightarrow DeletePolicy \rightarrow Archive/Delete \rightarrow Verify

216.34 ObjectRepository核心原则

ObjectRepository 必须遵守以下原则。

原则一：对象与数据库分离

Object≠DatabaseRecordObject \neq DatabaseRecord

原则二：Repository不负责对象计算

Repository≠ObjectEngineRepository \neq ObjectEngine

原则三：Repository不负责状态计算

Repository≠StateEngineRepository \neq StateEngine

原则四：Repository不负责关系计算

Repository≠RelationEngineRepository \neq RelationEngine

原则五：查询不等于匹配

Query≠MatchingQuery \neq Matching

原则六：更新不等于学习

Update≠LearningUpdate \neq Learning

原则七：保存必须可验证

Save→ReadBack→VerifySave \rightarrow ReadBack \rightarrow Verify

原则八：更新遵守最小更新原则

Ot+ΔO→Ot+1O_t+\Delta O\rightarrow O_{t+1}

原则九：删除必须检查引用

Delete→ReferenceCheckDelete \rightarrow ReferenceCheck

原则十：历史数据不能被无条件删除

DeleteObject≠DeleteHistoryDeleteObject \neq DeleteHistory

216.35 本章总结

ObjectRepository 是 ICAI Object 持久化体系的核心组件。

它将 Object Domain Object 与 MySQL 隔离：

Object↔ObjectRepository↔MySQL\boxed{ Object \leftrightarrow ObjectRepository \leftrightarrow MySQL }

其四项核心能力是：

Save+Query+Update+Delete\boxed{ Save + Query + Update + Delete }

对象保存：

Object→Validate→Map→Persist→VerifyObject \rightarrow Validate \rightarrow Map \rightarrow Persist \rightarrow Verify

对象查询：

QueryCondition→MySQL→PersistenceData→ObjectQueryCondition \rightarrow MySQL \rightarrow PersistenceData \rightarrow Object

对象更新：

Ot+ΔO→Ot+1O_t+\Delta O\rightarrow O_{t+1}

对象删除：

Delete→ReferenceCheck→DeletePolicy→Archive/DeleteDelete \rightarrow ReferenceCheck \rightarrow DeletePolicy \rightarrow Archive/Delete

最终形成：

ObjectEngine
     ↓
计算
     ↓
UpdateEngine
     ↓
Object
     ↓
ObjectRepository
     ↓
MySQL

而读取则形成：

MySQL
  ↓
ObjectRepository
  ↓
ObjectMapper
  ↓
Object
  ↓
ObjectEngine

由此，ICAI 的对象工程边界进一步明确：

ObjectEngine=对象计算\boxed{ ObjectEngine=对象计算 } ObjectRepository=对象持久化\boxed{ ObjectRepository=对象持久化 } ObjectService=对象应用流程编排\boxed{ ObjectService=对象应用流程编排 } MySQL=持久化存储\boxed{ MySQL=持久化存储 }

四者共同构成：

ObjectService→ObjectEngine→Object→ObjectRepository→MySQL\boxed{ ObjectService \rightarrow ObjectEngine \rightarrow Object \rightarrow ObjectRepository \rightarrow MySQL }

ObjectRepository 因此不是一个简单的 CRUD 类，而是 ICAI 从 运行时 Object → 持久化 Object → 再恢复运行时 Object 的核心数据边界。

← 第215章　IndividualRepository
第217章　StateRepository →

Leave a Reply

Your email address will not be published. Required fields are marked *