第170章 IndividualService

170.1 提出背景

第166章已经建立了Individual基类，第167章建立了Individual的对象组合体系，第168章进一步建立了Class、Object与Runtime Object的统一关系，第169章又定义了Service层。

在这一基础上，ICAI需要一个专门负责Individual生命周期与运行管理的Service。

因此建立：

IndividualService（个体服务）

IndividualService不是Individual对象本身，也不是IndividualManager的简单替代，更不是数据库操作类。

它的主要职责是：

创建 Individual
读取 Individual
更新 Individual
管理 Individual 当前状态

进一步组织为：

$IndividualService=Create+Read+Update+StateIndividualService = Create + Read + Update + State$

其核心目标是让一个Individual能够从数据库中的持久化记录，逐步进入ICAI Runtime，成为具有当前状态、对象组合、能力、方法、行为、记忆和经验的实际运行个体。

170.2 IndividualService定义

IndividualService 是负责Individual领域对象创建、读取、更新以及运行状态协调的应用服务。

可以定义：

$IS=(I,O,K,C,M,B,MM,E,S,L)IS=(I,O,K,C,M,B,MM,E,S,L)$

其中：

$ISIS$ ：IndividualService；
$II$ ：Individual；
$OO$ ：Objects，个体关联对象；
$KK$ ：Knowledge，知识；
$CC$ ：Capabilities，能力；
$MM$ ：Methods，方法；
$BB$ ：Behaviors，行为；
$MMMM$ ：Memories，记忆；
$EE$ ：Experiences，经验；
$SS$ ：State，个体状态；
$LL$ ：Lifecycle，生命周期。

因此IndividualService并不只是：

createIndividual()
getIndividual()
updateIndividual()

而是负责将Individual作为一个完整ICAI对象进行生命周期管理。

基本流程：

Input
 ↓
IndividualService
 ↓
IndividualRepository
 ↓
Individual Domain Object
 ↓
Load Composition
 ↓
State
 ↓
Runtime Individual

170.3 Individual创建

170.3.1 创建的含义

Individual创建不是简单向individuals表插入一条记录。

真正的Individual创建过程是：

$Create(I)=Identity+Type+Attributes+InitialState+CompositionCreate(I) = Identity + Type + Attributes + InitialState + Composition$

即：

Identity
 ↓
Type
 ↓
Attributes
 ↓
Initial State
 ↓
Object Composition
 ↓
Individual Created

例如创建一个Robot：

Individual ID = 1001
Type = robot
State = created

此时Individual已经具有自己的身份，但尚未成为完整运行对象。

170.3.2 Individual创建输入

可以建立：

$input = array(
    'type' => 'robot',
    'name' => 'Robot-001'
);

IndividualService负责检查最基本的创建条件。

例如：

if (empty($input['type'])) {
    return false;
}

然后建立Domain Object：

$individual = new Individual(
    null,
    $input['type']
);

如果系统采用具体类型类，则可以由Factory产生：

type = human
    ↓
Human

type = robot
    ↓
Robot

type = device
    ↓
Device

因此可以进一步使用：

IndividualFactory

处理具体对象实例化。

170.4 Individual身份

Individual必须具有稳定Identity。

可以定义：

$Identity=(ID,Type,Name)Identity=(ID,Type,Name)$

其中：

$IDID$ ：唯一标识；
$TypeType$ ：Individual类型；
$NameName$ ：可读名称。

例如：

ID: 1001
Type: robot
Name: Robot-001

Identity与State必须分开。

例如：

Individual ID = 1001
State = ready

状态改变为：

Individual ID = 1001
State = running

Individual仍然是同一个Individual。

因此：

$Identityt=Identityt+1Identity_t = Identity_{t+1}$

而：

$Statet≠Statet+1State_t \neq State_{t+1}$

是完全正常的。

170.5 Individual初始状态

创建Individual后，应当建立明确的初始状态。

例如：

CREATED

然后经过初始化：

CREATED
   ↓
INITIALIZED
   ↓
READY

因此：

new Individual()

不应该直接代表：

READY

因为对象刚刚创建时，其Capabilities、Methods、Objects、Memory等可能尚未加载。

170.6 Individual读取

170.6.1 读取不是简单查询数据库

Individual读取过程需要解决两个不同问题：

读取持久化数据

和：

恢复Runtime Individual

因此：

$Read(I)=Persistence Load+Domain Reconstruction+Composition Load+State LoadRead(I) = Persistence\ Load + Domain\ Reconstruction + Composition\ Load + State\ Load$

基本过程：

Individual ID
 ↓
IndividualRepository
 ↓
individuals
 ↓
Individual Object
 ↓
Load Objects
 ↓
Load Attributes
 ↓
Load Knowledge
 ↓
Load Capability
 ↓
Load Method
 ↓
Load Behavior
 ↓
Load Memory
 ↓
Load Experience
 ↓
Runtime Individual

170.7 IndividualRepository与IndividualService

IndividualService不应该直接操作MySQL。

应当通过：

IndividualRepository

完成持久化数据访问。

例如：

class IndividualService
{
    protected $repository;

    public function __construct($repository)
    {
        $this->repository = $repository;
    }

    public function get($id)
    {
        return $this->repository->find($id);
    }
}

Repository负责：

SELECT
INSERT
UPDATE
DELETE

Service负责：

什么时候读取
读取之后如何组织
读取之后进入什么状态

因此：

$IndividualService≠IndividualRepositoryIndividualService \neq IndividualRepository$

170.8 完整Individual读取

仅仅读取：

$individual = $repository->find($id);

还不足以恢复完整ICAI Individual。

因为Individual可能具有：

Objects[]
Attributes[]
Knowledge[]
Capabilities[]
Methods[]
Behaviors[]
Memories[]
Experiences[]
Relations[]

所以需要进一步执行组合加载。

可以抽象为：

$Load(I)=O+K+C+M+B+MM+ELoad(I) = O+K+C+M+B+MM+E$

其中：

$OO$ ：Objects；
$KK$ ：Knowledge；
$CC$ ：Capabilities；
$MM$ ：Methods；
$BB$ ：Behaviors；
$MMMM$ ：Memories；
$EE$ ：Experiences。

最终形成：

Persistence
 ↓
Individual
 ↓
Composition
 ↓
Runtime Individual

170.9 Individual更新

170.9.1 更新的定义

Individual更新是对已经存在的Individual及其当前状态、属性或组成关系进行合法修改。

可以定义：

$Update(I)=Identity+Attribute+Composition+StateUpdate(I)=Identity+Attribute+Composition+State$

但不同内容的更新方式不同。

例如：

Name
Attribute
State
Capability
Method
Memory
Experience

不应该全部通过一个SQL UPDATE解决。

170.10 Individual属性更新

例如：

$individual->setName('Robot-002');

Service负责组织更新：

public function updateName($id, $name)
{
    $individual = $this->get($id);

    if (!$individual) {
        return false;
    }

    $individual->setName($name);

    return $this->repository->save($individual);
}

这里形成：

Request
 ↓
IndividualService
 ↓
Load Individual
 ↓
Domain Object Update
 ↓
Repository Save
 ↓
Result

170.11 Individual组合更新

Individual的复杂组成也可能发生变化。

例如：

Individual
 ↓
Capability

新增Capability：

Individual
    +
Capability
    ↓
Updated Individual

或者：

Individual
 ↓
Memory

新增Memory：

Individual
    +
Memory
    ↓
Updated Memory Set

此时IndividualService可以调用专门Service：

IndividualService
      ↓
CapabilityService

IndividualService
      ↓
MemoryService

IndividualService
      ↓
ExperienceService

而不是把所有子对象操作都塞进IndividualService。

170.12 Individual状态

Individual状态是本章最重要的部分之一。

Individual State（个体状态） 表示某一个具体Individual在某一时刻的实际运行状态。

可以定义：

$St=State(I,t)S_t = State(I,t)$

其中：

$II$ ：具体Individual；
$tt$ ：时间；
$StS_t$ ：Individual在时间 $tt$ 的状态。

例如：

Individual 1001
State = Ready

执行行为后：

Individual 1001
State = Running

执行完成：

Individual 1001
State = Completed

发生异常：

Individual 1001
State = Failed

170.13 Individual状态与Class Type的区别

必须严格区分：

Type

与：

State

例如：

Robot

是Type。

而：

Ready
Running
Failed

是State。

因此：

$Robot≠RunningRobot \neq Running$

一个Robot可以：

Robot + Ready
Robot + Running
Robot + Failed
Robot + Maintenance

Type决定“它是什么”。

State决定“它现在是什么状态”。

170.14 Individual状态机

可以建立基础Individual状态机：

CREATED
   ↓
INITIALIZED
   ↓
READY
   ↓
RUNNING
   ↓
COMPLETED

异常：

RUNNING
   ↓
FAILED

取消：

READY / RUNNING
   ↓
CANCELLED

阻塞：

READY
   ↓
BLOCKED

恢复：

FAILED
   ↓
DIAGNOSING
   ↓
REPAIRING
   ↓
VERIFYING
   ↓
READY

因此Individual状态并不是一个普通字符串，而是一个受到状态转换规则控制的对象。

170.15 IndividualState对象

可以建立独立：

class IndividualState
{
    protected $name;
    protected $time;
    protected $reason;

    public function __construct($name, $time, $reason)
    {
        $this->name = $name;
        $this->time = $time;
        $this->reason = $reason;
    }

    public function getName()
    {
        return $this->name;
    }
}

Individual：

class Individual
{
    protected $id;
    protected $type;
    protected $state;

    public function setState($state)
    {
        $this->state = $state;
    }

    public function getState()
    {
        return $this->state;
    }
}

这样：

Individual
    ↓
IndividualState

形成组合关系。

170.16 状态转换

状态不能随意修改。

应该由规则控制：

$Transition(S1,A,C)→S2Transition(S_1,A,C)\rightarrow S_2$

其中：

$S1S_1$ ：当前状态；
$AA$ ：触发Action；
$CC$ ：Transition Condition；
$S2S_2$ ：新状态。

例如：

READY
 ↓
Start Behavior
 ↓
RUNNING

又例如：

RUNNING
 ↓
Execution Result = Success
 ↓
COMPLETED

失败：

RUNNING
 ↓
Execution Result = Failure
 ↓
FAILED

因此：

$Result→State TransitionResult \rightarrow State\ Transition$

是ICAI运行系统的重要关系。

170.17 IndividualService状态更新

IndividualService可以提供状态更新接口：

public function changeState($id, $newState)
{
    $individual = $this->get($id);

    if (!$individual) {
        return false;
    }

    $currentState = $individual->getState();

    if (!$this->canTransition(
        $currentState,
        $newState
    )) {
        return false;
    }

    $individual->setState($newState);

    return $this->repository->save($individual);
}

状态转换规则可以独立：

class IndividualStateEngine
{
    public function canTransition($from, $to)
    {
        $rules = array(
            'created' => array('initialized'),
            'initialized' => array('ready'),
            'ready' => array('running', 'blocked'),
            'running' => array(
                'completed',
                'failed',
                'cancelled'
            ),
            'failed' => array(
                'diagnosing'
            )
        );

        if (!isset($rules[$from])) {
            return false;
        }

        return in_array(
            $to,
            $rules[$from]
        );
    }
}

于是形成：

IndividualService
       ↓
IndividualStateEngine
       ↓
State Transition
       ↓
Individual
       ↓
Repository

这里体现了第169章建立的Service与Engine职责分离。

170.18 Individual状态不能伪造

ICAI系统必须遵循：

状态必须由事实和规则产生，而不是由程序为了表示“成功”而直接设置。

例如不能：

$individual->setState('completed');

然后认为任务已经完成。

正确流程应当是：

Behavior
 ↓
Action
 ↓
Execution
 ↓
Actual Result
 ↓
Verification
 ↓
State Transition
 ↓
Completed

因此：

$Completed⇐Actual Execution+Valid Result+VerificationCompleted \Leftarrow Actual\ Execution + Valid\ Result + Verification$

而不是：

$Completed⇐Function ReturnedCompleted \Leftarrow Function\ Returned$

170.19 Individual创建、读取、更新统一流程

IndividualService可以统一表示为：

Create
   ↓
Individual
   ↓
Read
   ↓
Load Composition
   ↓
Initialize
   ↓
Ready
   ↓
Update
   ↓
State Change
   ↓
Persist

完整生命周期：

$Created→Initialized→Loaded→Ready→Running→Updated→SavedCreated \rightarrow Initialized \rightarrow Loaded \rightarrow Ready \rightarrow Running \rightarrow Updated \rightarrow Saved$

异常：

$Running→Failed→Diagnosis→Repair→Verification→ReadyRunning \rightarrow Failed \rightarrow Diagnosis \rightarrow Repair \rightarrow Verification \rightarrow Ready$

170.20 IndividualService PHP结构

可以建立基础Service：

class IndividualService
{
    protected $repository;
    protected $stateEngine;

    public function __construct(
        $repository,
        $stateEngine
    ) {
        $this->repository = $repository;
        $this->stateEngine = $stateEngine;
    }

    public function create($input)
    {
        $individual = new Individual(
            null,
            $input['type']
        );

        $individual->setState('created');

        return $this->repository->save(
            $individual
        );
    }

    public function get($id)
    {
        return $this->repository->find($id);
    }

    public function update($individual)
    {
        return $this->repository->save(
            $individual
        );
    }

    public function changeState(
        $id,
        $newState
    ) {
        $individual = $this->get($id);

        if (!$individual) {
            return false;
        }

        $currentState =
            $individual->getState();

        if (!$this->stateEngine->canTransition(
            $currentState,
            $newState
        )) {
            return false;
        }

        $individual->setState(
            $newState
        );

        return $this->update(
            $individual
        );
    }
}

该结构只是IndividualService的基础骨架，真正系统还需要加入Composition加载、权限、事务、History、Feedback、Verification等机制。

但其职责边界已经明确：

IndividualService
    ├── Create
    ├── Read
    ├── Update
    └── State

170.21 IndividualService与Individual Domain Object

二者关系可以定义为：

$IndividualService→IndividualIndividualService \rightarrow Individual$

Individual负责：

Identity
Type
Attributes
State
Capabilities
Methods
Behaviors
Memories
Experiences

IndividualService负责：

Create
Load
Coordinate
Update
State Transition
Persist

因此：

Individual = Domain Object
IndividualService = Application Service

不能把两者合并成一个巨大类。

170.22 IndividualService与Manager

IndividualManager与IndividualService也应保持边界。

可以定义：

$Manager=Collection/Object ManagementManager = Collection/Object\ Management$ $Service=Task/Process ManagementService = Task/Process\ Management$

例如：

IndividualManager

负责：

注册Individual
查找Individual
管理Individual集合
删除Individual
缓存Individual

而：

IndividualService

负责：

创建Individual
初始化Individual
读取完整Individual
更新Individual
改变Individual状态
保存运行结果

二者可以协作：

IndividualService
       ↓
IndividualManager
       ↓
Individual

170.23 IndividualService与Runtime Object

第168章定义了Runtime Object：

$RO=(O,S,C,R,T)RO=(O,S,C,R,T)$

因此Individual进入Runtime以后，可以形成：

$RuntimeIndividual=Individual+State+Context+Relation+TimeRuntimeIndividual = Individual + State + Context + Relation + Time$

IndividualService承担将持久化Individual加载为可运行Individual的重要职责。

过程：

MySQL
 ↓
Repository
 ↓
Individual
 ↓
Composition Load
 ↓
State Load
 ↓
Runtime Context
 ↓
Runtime Individual

因此IndividualService成为：

Persistence Individual → Runtime Individual

之间的重要工程桥梁。

170.24 Individual状态与Memory、Experience

Individual状态变化不能孤立存在。

例如：

Individual
State: Ready
 ↓
Behavior
 ↓
Execution
 ↓
Result
 ↓
Feedback
 ↓
State: Completed

这个变化可以进一步形成：

History
 ↓
Memory
 ↓
Experience

因此：

$State Change→Result→Feedback→Memory→ExperienceState\ Change \rightarrow Result \rightarrow Feedback \rightarrow Memory \rightarrow Experience$

Experience又可以影响后续：

Capability
Method
Decision
Risk

因此IndividualService虽然只负责Individual本身，但它位于整个ICAI运行链的重要入口位置。

170.25 IndividualService数据库结构

可以建立基础：

individuals

id
type
name
state
created_at
updated_at

进一步使用关系表保存Individual组合对象：

individual_objects

id
individual_id
object_id
relation_type

individual_capabilities

id
individual_id
capability_id

individual_methods

id
individual_id
method_id

individual_behaviors

id
individual_id
behavior_id

individual_memories

id
individual_id
memory_id

individual_experiences

id
individual_id
experience_id

因此数据库保存的是：

Individual Persistence

而不是直接等同于：

Runtime Individual

170.26 Individual状态历史

状态变化本身也应该形成History。

例如：

Individual 1001

created
10:00:01

initialized
10:00:02

ready
10:00:03

running
10:01:10

completed
10:01:15

可以建立：

individual_state_history

id
individual_id
from_state
to_state
reason
created_at

这样可以回答：

Individual当前是什么状态？

也可以回答：

Individual为什么进入这个状态？

以及：

Individual之前经历过什么状态？

因此：

$Current State≠State HistoryCurrent\ State \neq State\ History$

Current State描述当前状态。

State History描述状态变化过程。

170.27 IndividualService统一模型

经过本章建立，可以定义：

$IS=(C,R,U,S,P)IS=(C,R,U,S,P)$

其中：

$CC$ ：Create；
$RR$ ：Read；
$UU$ ：Update；
$SS$ ：State；
$PP$ ：Persistence。

完整流程：

$Create→Read→Load→Update→State→PersistCreate \rightarrow Read \rightarrow Load \rightarrow Update \rightarrow State \rightarrow Persist$

如果进入Runtime：

$Individual→Runtime→Behavior→Action→Execution→Result→FeedbackIndividual \rightarrow Runtime \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Result \rightarrow Feedback$

最终：

$Feedback→Memory→Experience→Individual UpdateFeedback \rightarrow Memory \rightarrow Experience \rightarrow Individual\ Update$

于是形成Individual级闭环：

Individual
 ↓
Goal
 ↓
Capability
 ↓
Method
 ↓
Decision
 ↓
Behavior
 ↓
Execution
 ↓
Result
 ↓
Feedback
 ↓
Memory
 ↓
Experience
 ↓
Individual Update
 ↓
New State

170.28 本章小结

IndividualService是ICAI进入实际软件工程运行层后的核心基础Service之一。

它的职责可以归纳为：

$IndividualService=Create+Read+Update+State\boxed{ IndividualService = Create + Read + Update + State }$

其中：

Create负责建立Individual身份、类型、初始属性和初始状态。

Read负责从Persistence恢复Individual，并进一步加载其Object、Knowledge、Capability、Method、Behavior、Memory、Experience等组合结构。

Update负责对Individual及其合法组成关系进行更新。

State负责维护Individual当前运行状态，并通过State Engine控制状态转换。

其核心工程关系为：

Controller
    ↓
IndividualService
    ├── IndividualRepository
    ├── IndividualStateEngine
    └── Individual Domain Object
             ↓
       Object Composition
             ↓
Capability / Method / Behavior
             ↓
Memory / Experience

最终形成：

$Persistence→Individual→Runtime→State→Cognition→Behavior→Result→Feedback→Learning→Individual Update\boxed{ Persistence \rightarrow Individual \rightarrow Runtime \rightarrow State \rightarrow Cognition \rightarrow Behavior \rightarrow Result \rightarrow Feedback \rightarrow Learning \rightarrow Individual\ Update }$

由此，Individual不再只是第166章定义的一个OOP基类，而成为一个能够被 创建、读取、加载、更新、运行、改变状态并持续积累Memory与Experience的实际ICAI运行主体。

同时，IndividualService也明确了第169章Service层在具体Domain中的第一次完整落地：

$Service→Domain Object→Engine→Repository\boxed{ Service \rightarrow Domain\ Object \rightarrow Engine \rightarrow Repository }$

这为后续CapabilityService、MethodService、DecisionService、BehaviorService、MemoryService、ExperienceService等专业Service的建立提供统一工程基础。

第170章 IndividualService

第170章 IndividualService

170.1 提出背景

170.2 IndividualService定义

170.3 Individual创建

170.3.1 创建的含义

170.3.2 Individual创建输入

170.4 Individual身份

170.5 Individual初始状态

170.6 Individual读取

170.6.1 读取不是简单查询数据库

170.7 IndividualRepository与IndividualService

170.8 完整Individual读取

170.9 Individual更新

170.9.1 更新的定义

170.10 Individual属性更新

170.11 Individual组合更新

170.12 Individual状态

170.13 Individual状态与Class Type的区别

170.14 Individual状态机

170.15 IndividualState对象

170.16 状态转换

170.17 IndividualService状态更新

170.18 Individual状态不能伪造

170.19 Individual创建、读取、更新统一流程

170.20 IndividualService PHP结构

170.21 IndividualService与Individual Domain Object

170.22 IndividualService与Manager

170.23 IndividualService与Runtime Object

170.24 Individual状态与Memory、Experience

170.25 IndividualService数据库结构

individuals

individual_objects

individual_capabilities

individual_methods

individual_behaviors

individual_memories

individual_experiences

170.26 Individual状态历史

individual_state_history

170.27 IndividualService统一模型

170.28 本章小结

Leave a Reply Cancel reply