第248章　Smarty与ICAI

248.1 Smarty与ICAI的关系

在ICAI工程体系中，机器个体的认知、行为、学习和自我维护属于后端运行层。

而机器个体如果需要通过浏览器与人进行交互，则必须建立页面表现层。

因此形成：

ICAIRuntime→Controller→ViewData→Smarty→HTML→BrowserICAI Runtime \rightarrow Controller \rightarrow ViewData \rightarrow Smarty \rightarrow HTML \rightarrow Browser

Smarty位于View层。

它不负责：

• 认知计算；
• 行为计算；
• 学习计算；
• 风险计算；
• 决策计算；
• 自我维护计算；
• 数据库操作。

因此：

Smarty≠CognitiveEngineSmarty\neq CognitiveEngine Smarty≠BehaviorEngineSmarty\neq BehaviorEngine Smarty≠LearningEngineSmarty\neq LearningEngine Smarty≠RepositorySmarty\neq Repository

Smarty的主要职责是：

ViewData→Template→HTMLViewData\rightarrow Template\rightarrow HTML

---

248.2 Smarty定义

Smarty是一种PHP模板引擎（Template Engine），用于将PHP程序产生的数据传递给页面模板，并根据模板结构生成HTML页面。

在ICAI中，可以将其定义为：

Smarty是ICAI View层中的页面模板处理工具，负责把Controller或View层准备好的ViewData转换为最终HTML页面。

其基本关系为：

PHPData→Smarty→Template→HTMLPHPData \rightarrow Smarty \rightarrow Template \rightarrow HTML

或者：

ViewData→Smarty→HTMLViewData \rightarrow Smarty \rightarrow HTML

Smarty本身并不产生ICAI认知结果。

---

248.3 Smarty的工程位置

ICAI完整MVC结构：

Browser
   ↓
Controller
   ↓
Service
   ↓
Engine
   ↓
Domain Object
   ↓
Repository
   ↓
MySQL

返回页面时：

MySQL
   ↓
Repository
   ↓
Domain Object
   ↓
Engine
   ↓
Service
   ↓
Controller
   ↓
ViewData
   ↓
Smarty
   ↓
HTML
   ↓
Browser

因此Smarty位于整个运行链的末端。

可以表示为：

BusinessResult→ViewData→Smarty→HTMLBusinessResult \rightarrow ViewData \rightarrow Smarty \rightarrow HTML

---

248.4 模板系统

模板系统的核心思想是：

Data+Template\rightarrowOutputData+Template\rightarrowOutput

其中：

• Data表示页面数据；
• Template表示页面结构；
• Output表示最终HTML。

例如：

机器个体名称：
任务处理个体

当前状态：
运行中

当前能力：
任务处理

当前方法：
method_B

这些数据交给模板后，模板负责确定它们如何显示。

因此：

Template≠DataTemplate\neq Data

模板描述页面结构。

数据描述页面内容。

---

248.5 模板与业务逻辑分离

传统PHP页面容易出现：

<?php
// 查询数据库
// 判断业务
// 执行计算
// 修改对象
// 输出HTML
?>

这种方式容易导致：

View→BusinessLogicView\rightarrow BusinessLogic

ICAI不采用这种结构。

ICAI要求：

BusinessLogic→Controller→ViewData→SmartyBusinessLogic \rightarrow Controller \rightarrow ViewData \rightarrow Smarty

页面只负责表现。

因此：

View≠ServiceView\neq Service View≠EngineView\neq Engine

---

248.6 Smarty模板的基本组成

一个页面模板通常包含：

HTML结构
+
变量
+
条件
+
循环
+
页面片段

例如：

<h1>{$individual.name}</h1>

<p>状态：{$individual.state}</p>

<p>方法：{$individual.method}</p>

Smarty负责将：

{$individual.name}

替换成实际数据。

例如：

任务处理个体

最终生成：

<h1>任务处理个体</h1>

---

248.7 View层定义

View层是ICAI MVC中的页面表现层。

它负责：

ViewData\rightarrowPresentationViewData\rightarrowPresentation

View层主要处理：

页面结构
页面布局
数据显示
表单显示
状态显示
结果显示
错误显示
导航

它不负责：

认知
决策
学习
行为计算
数据库操作
领域规则

因此：

View=PresentationView=Presentation

而：

Service=BusinessProcessService=BusinessProcess Engine=DomainCalculationEngine=DomainCalculation

---

248.8 ViewData

Controller不能直接把复杂业务对象随意交给模板，而应该形成明确的ViewData。

例如：

ViewData={Title,Individual,State,Capability,Method,Result,Message}ViewData= \{ Title, Individual, State, Capability, Method, Result, Message \}

Controller可以将这些数据传递给View。

例如：

$viewData = array(
    'title' => 'ICAI机器个体',
    'individual' => $individual,
    'state' => $individual->getState(),
    'method' => $individual->getMethod()
);

然后：

ViewData→SmartyViewData\rightarrow Smarty

---

248.9 Controller与Smarty

Controller负责请求处理。

其页面职责主要是：

接收请求
↓
调用Service
↓
得到Result
↓
整理ViewData
↓
调用View

因此：

Controller→ViewData→SmartyController \rightarrow ViewData \rightarrow Smarty

Controller不应该把业务计算放入模板。

例如错误方式：

Smarty
↓
判断风险
↓
修改机器状态
↓
执行学习

正确方式：

Controller
↓
Service
↓
Engine
↓
Result
↓
ViewData
↓
Smarty

---

248.10 Smarty与ICAI认知结果

ICAI认知结果可以进入ViewData。

例如：

CognitiveResult={Object,State,Relation,Judgment,Reason,Confidence}CognitiveResult= \{ Object, State, Relation, Judgment, Reason, Confidence \}

Controller获得认知结果以后：

$viewData = array(
    'object' => $result['object'],
    'state' => $result['state'],
    'judgment' => $result['judgment'],
    'reason' => $result['reason']
);

Smarty只负责显示：

<h2>{$judgment}</h2>
<p>{$reason}</p>

因此：

CognitiveEngine→CognitiveResultCognitiveEngine\rightarrow CognitiveResult

再：

CognitiveResult→ViewDataCognitiveResult\rightarrow ViewData

最后：

ViewData→SmartyViewData\rightarrow Smarty

---

248.11 Smarty与行为结果

第245章建立：

Behavior→Action→ResultBehavior \rightarrow Action \rightarrow Result

如果行为执行完成以后需要向用户展示：

行为名称
动作
结果
状态
时间

Controller将结果整理成：

BehaviorViewDataBehaviorViewData

再交给Smarty。

因此：

BehaviorResult→ViewData→SmartyBehaviorResult \rightarrow ViewData \rightarrow Smarty

Smarty不执行Behavior。

---

248.12 Smarty与学习结果

第246章建立：

Feedback→Memory→Experience→Learning→UpdateFeedback \rightarrow Memory \rightarrow Experience \rightarrow Learning \rightarrow Update

学习完成以后，如果需要显示：

学习状态
学习对象
原值
新值
学习原因
更新时间

则：

LearningResult→ViewData→SmartyLearningResult \rightarrow ViewData \rightarrow Smarty

例如：

<h2>学习结果</h2>

<p>对象：{$learning.object}</p>

<p>原方法：{$learning.old_method}</p>

<p>新方法：{$learning.new_method}</p>

<p>状态：{$learning.status}</p>

页面只是显示学习结果。

---

248.13 Smarty与自我维护结果

第247章建立：

Detection→Risk→Conflict→Diagnosis→Repair→VerificationDetection \rightarrow Risk \rightarrow Conflict \rightarrow Diagnosis \rightarrow Repair \rightarrow Verification

这些结果同样可以通过View层展示。

例如：

检测：异常
风险：High
冲突：Method状态不一致
诊断：Method_A失效
修复：切换Method_B
验证：成功

Controller整理：

MaintenanceResult→MaintenanceViewDataMaintenanceResult \rightarrow MaintenanceViewData

Smarty负责：

MaintenanceViewData→HTMLMaintenanceViewData \rightarrow HTML

---

248.14 ICAI页面定义

ICAI页面是机器个体运行状态、认知结果、行为结果、学习结果和维护结果的可视化表现。

因此：

ICAIPage=Presentation(ICAIState,Result,Memory,Capability)ICAIPage= Presentation(ICAIState,Result,Memory,Capability)

但这里的Presentation不是重新计算这些对象，而是将已有结果表现出来。

因此：

ICAIPage≠ICAIEngineICAIPage\neq ICAIEngine

页面是机器个体的外部表现层。

---

248.15 ICAI页面的基本结构

一个完整的ICAI管理页面可以包含：

机器个体信息
↓
当前状态
↓
当前能力
↓
当前目标
↓
当前认知
↓
当前行为
↓
最近结果
↓
学习记录
↓
维护状态
↓
历史记录

例如：

┌────────────────────────────┐
│ ICAI机器个体                │
├────────────────────────────┤
│ ID：ICAI-001                │
│ 名称：任务处理个体          │
│ 状态：运行中                │
│                            │
│ 当前能力：任务处理          │
│ 当前方法：method_B          │
│                            │
│ 最近认知：条件C有效         │
│ 最近行为：执行任务          │
│ 最近结果：成功              │
│                            │
│ 学习状态：已更新            │
│ 维护状态：正常              │
└────────────────────────────┘

这个页面本身不产生任何智能计算。

---

248.16 ICAI页面的数据来源

页面显示的数据应该具有明确来源。

例如：

IndividualView←IndividualDomainObjectIndividualView \leftarrow IndividualDomainObject CognitionView←CognitiveResultCognitionView \leftarrow CognitiveResult BehaviorView←BehaviorResultBehaviorView \leftarrow BehaviorResult LearningView←LearningResultLearningView \leftarrow LearningResult MaintenanceView←MaintenanceResultMaintenanceView \leftarrow MaintenanceResult

因此页面上的每一个重要数据都应该可以追溯到对应的ICAI领域对象或运行结果。

---

248.17 ICAI页面与Domain Object

Domain Object不能直接等同于HTML。

关系应该是：

DomainObject→Controller→ViewData→Smarty→HTMLDomainObject \rightarrow Controller \rightarrow ViewData \rightarrow Smarty \rightarrow HTML

例如：

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

$viewData = array(
    'id' => $individual->getId(),
    'name' => $individual->getName(),
    'state' => $individual->getState(),
    'method' => $individual->getMethod()
);

然后交给模板。

这样Domain Object仍然保持领域层职责。

---

248.18 Smarty模板变量

模板变量用于表达ViewData。

例如：

<h1>{$name}</h1>

<p>ID：{$id}</p>

<p>状态：{$state}</p>

<p>当前方法：{$method}</p>

这里：

{$name}
{$id}
{$state}
{$method}

都是页面变量。

它们不应该承担领域计算。

---

248.19 Smarty条件显示

页面可以根据ViewData进行简单表现层判断。

例如：

{if $state == 'running'}
    <span>运行中</span>
{else}
    <span>非运行状态</span>
{/if}

这是页面表现条件。

但以下逻辑不应该放进Smarty：

判断风险
计算RiskScore
执行Diagnosis
选择RepairMethod
修改DomainObject
保存MySQL

因为：

TemplateCondition≠BusinessRuleTemplateCondition\neq BusinessRule

---

248.20 Smarty循环

如果ViewData包含历史记录：

$viewData['memories'] = $memories;

模板可以循环显示：

<ul>
{foreach $memories as $memory}
    <li>
        {$memory.time}
        -
        {$memory.result}
    </li>
{/foreach}
</ul>

循环只负责表现集合。

实际Memory的读取过程应该已经在Controller→Service→Repository层完成。

因此：

Smarty≠MemoryRepositorySmarty\neq MemoryRepository

---

248.21 ICAI页面布局

ICAI页面可以按照机器个体运行结构进行布局。

例如：

页面
│
├── Individual
│   ├── ID
│   ├── Type
│   └── State
│
├── Cognition
│   ├── Object
│   ├── State
│   ├── Relation
│   └── Judgment
│
├── Behavior
│   ├── Goal
│   ├── Method
│   ├── Action
│   └── Result
│
├── Learning
│   ├── Feedback
│   ├── Memory
│   ├── Experience
│   └── Update
│
└── Maintenance
    ├── Detection
    ├── Risk
    ├── Diagnosis
    ├── Repair
    └── Verification

这使页面结构直接对应ICAI理论结构。

---

248.22 ICAI Dashboard

可以进一步建立ICAI Dashboard。

Dashboard不是新的Engine，而是多个ViewData的组合。

其数据结构：

DashboardData={Individual,Cognition,Behavior,Learning,Maintenance}DashboardData= \{ Individual, Cognition, Behavior, Learning, Maintenance \}

完整数据来源：

IndividualService→IndividualDataIndividualService \rightarrow IndividualData CognitiveService→CognitiveDataCognitiveService \rightarrow CognitiveData BehaviorService→BehaviorDataBehaviorService \rightarrow BehaviorData LearningService→LearningDataLearningService \rightarrow LearningData MaintenanceService→MaintenanceDataMaintenanceService \rightarrow MaintenanceData

Controller将它们组织成：

DashboardViewDataDashboardViewData

最后：

DashboardViewData→Smarty→HTMLDashboardViewData \rightarrow Smarty \rightarrow HTML

---

248.23 ICAI页面不是机器个体本身

必须建立一个重要概念：

ICAIPage≠MachineIndividualICAIPage\neq MachineIndividual

页面只是机器个体的表现形式。

机器个体可以没有页面而继续运行。

例如：

ICAI Runtime
↓
Service
↓
Engine
↓
Domain Object
↓
Repository

可以完全不经过：

SmartySmarty

而直接通过CLI或内部任务运行。

因此：

ICAIRuntime≠WebPageICAI Runtime\neq WebPage

---

248.24 ICAI页面也不是认知接口

页面可以接收用户输入，但输入仍然必须进入Controller。

正确结构：

Browser→HTMLForm→Controller→Service→EngineBrowser \rightarrow HTMLForm \rightarrow Controller \rightarrow Service \rightarrow Engine

而不是：

Browser→Smarty→EngineBrowser \rightarrow Smarty \rightarrow Engine

Smarty只负责显示表单。

---

248.25 ICAI页面表单

例如机器个体查询页面：

<form method="post" action="/icai/query.php">
    <input type="text" name="individual_id">
    <button type="submit">查询</button>
</form>

用户提交以后：

Browser→ControllerBrowser \rightarrow Controller

Controller进行参数处理：

Request→Controller→ServiceRequest \rightarrow Controller \rightarrow Service

Service再调用相关领域服务。

最终结果：

Result→ViewData→SmartyResult \rightarrow ViewData \rightarrow Smarty

---

248.26 ICAI页面安全边界

页面数据不能直接信任。

例如用户提交：

individual_id

Controller必须负责：

接收
↓
检查
↓
规范化
↓
验证
↓
传递Service

Smarty不负责输入安全。

因此：

InputValidation≠SmartyResponsibilityInputValidation\neq SmartyResponsibility

---

248.27 Smarty与异常页面

ICAI运行过程中可能出现：

BusinessFailure
PersistenceFailure
LearningFailure
RepairFailure
VerificationFailure

Controller应将这些结果转换成页面数据。

例如：

Exception/Failure→Controller→ErrorViewData→SmartyException/Failure \rightarrow Controller \rightarrow ErrorViewData \rightarrow Smarty

Smarty只负责显示：

<div class="error">
    {$message}
</div>

它不负责分析异常。

---

248.28 Smarty与成功页面

同样，成功结果：

Result→ViewData→SmartyResult \rightarrow ViewData \rightarrow Smarty

例如：

<div class="success">
    {$message}
</div>

页面表现成功。

真正的成功状态已经由Service、Engine和Domain Object确定。

---

248.29 View与MySQL边界

View绝不能直接访问MySQL。

错误结构：

Smarty→MySQLSmarty \rightarrow MySQL

正确结构：

Smarty←ViewData←Controller←Service←Repository←MySQLSmarty \leftarrow ViewData \leftarrow Controller \leftarrow Service \leftarrow Repository \leftarrow MySQL

因此：

View≠RepositoryView\neq Repository Smarty≠MySQLSmarty\neq MySQL

这也是MVC分层能够保持稳定的重要条件。

---

248.30 Smarty与ICAI运行状态

ICAI页面可以显示实时或当前运行状态。

例如：

状态：Running
目标：Task-001
能力：TaskProcess
方法：Method-B

但是“Running”这个状态应该来自Domain Object：

DomainObject.StateDomainObject.State

而不是由Smarty自己决定。

Smarty只是：

State\rightarrowDisplayState\rightarrowDisplay

---

248.31 ICAI页面与状态变化

当机器个体发生：

Statet→Statet+1State_t\rightarrow State_{t+1}

Controller再次读取Domain Object：

DomainObjectt+1DomainObject_{t+1}

形成：

ViewDatat+1ViewData_{t+1}

Smarty重新渲染：

ViewDatat+1→HTMLt+1ViewData_{t+1} \rightarrow HTML_{t+1}

因此：

StateChange→ViewDataChange→PageChangeStateChange \rightarrow ViewDataChange \rightarrow PageChange

页面变化来自机器个体真实状态变化，而不是页面自身产生状态。

---

248.32 ICAI页面与学习状态

例如第246章学习以后：

MethodA→MethodBMethod_A\rightarrow Method_B

页面重新读取：

CurrentMethod = method_B

然后：

ViewData.method=methodBViewData.method=method_B

Smarty显示：

当前方法：method_B

因此页面可以成为学习结果的可视化窗口。

---

248.33 ICAI页面与维护状态

第247章完成维护以后：

Verification=SuccessVerification=Success

页面可以显示：

维护状态：正常
最后维护：成功

数据来源：

MaintenanceResult→ViewData→SmartyMaintenanceResult \rightarrow ViewData \rightarrow Smarty

页面不能自己判断：

Verification=SuccessVerification=Success

它只能显示后端已经确定的结果。

---

248.34 Smarty与ICAI完整MVC

最终可以建立：

Browser
   ↓
Controller
   ↓
Service
   ↓
Engine
   ↓
Domain Object
   ↓
Repository
   ↓
MySQL

MySQL
   ↓
Repository
   ↓
Domain Object
   ↓
Engine
   ↓
Service
   ↓
Controller
   ↓
ViewData
   ↓
Smarty
   ↓
HTML
   ↓
Browser

因此：

Request→Business→Domain→Persistence→View→ResponseRequest \rightarrow Business \rightarrow Domain \rightarrow Persistence \rightarrow View \rightarrow Response

---

248.35 Smarty与ICAI四大核心系统

第244章：

CognitiveMVCCognitiveMVC

第245章：

BehaviorMVCBehaviorMVC

第246章：

LearningMVCLearningMVC

第247章：

MaintenanceMVCMaintenanceMVC

第248章的Smarty/View层将这四类结果统一表现出来：

CognitiveResult→ViewDataCognitiveResult \rightarrow ViewData BehaviorResult→ViewDataBehaviorResult \rightarrow ViewData LearningResult→ViewDataLearningResult \rightarrow ViewData MaintenanceResult→ViewDataMaintenanceResult \rightarrow ViewData

最终：

ViewData→Smarty→HTMLViewData \rightarrow Smarty \rightarrow HTML

---

248.36 ICAI页面的统一数据模型

可以建立统一页面数据：

ICAIViewData={Individual,Cognition,Behavior,Learning,Maintenance,Message,Error}ICAIViewData= \{ Individual, Cognition, Behavior, Learning, Maintenance, Message, Error \}

其中：

Individual表示机器个体信息。

Cognition表示认知结果。

Behavior表示行为结果。

Learning表示学习结果。

Maintenance表示维护结果。

Message表示页面消息。

Error表示页面错误。

Smarty只负责把这些数据按照模板结构输出。

---

248.37 ICAI页面模板结构

一个统一的ICAI模板可以采用：

templates/
├── layout/
│   └── main.tpl
│
├── individual/
│   └── detail.tpl
│
├── cognition/
│   └── result.tpl
│
├── behavior/
│   └── result.tpl
│
├── learning/
│   └── result.tpl
│
└── maintenance/
    └── result.tpl

这种结构与ICAI领域结构对应。

例如：

Cognition→cognition/result.tplCognition\rightarrow cognition/result.tpl Behavior→behavior/result.tplBehavior\rightarrow behavior/result.tpl Learning→learning/result.tplLearning\rightarrow learning/result.tpl Maintenance→maintenance/result.tplMaintenance\rightarrow maintenance/result.tpl

---

248.38 Smarty模板与Domain Object的转换

Domain Object不应该要求模板理解所有领域方法。

可以先转换：

DomainObject→ViewDataDomainObject \rightarrow ViewData

例如：

$viewData = array(
    'id' => $individual->getId(),
    'name' => $individual->getName(),
    'state' => $individual->getState(),
    'method' => $individual->getMethod()
);

然后：

ViewData→SmartyViewData \rightarrow Smarty

这样可以保持：

DomainLayer≠PresentationLayerDomainLayer\neq PresentationLayer

---

248.39 Smarty与ICAI工程分层

最终ICAI工程可以明确划分：

Presentation Layer
    ↓
Smarty / HTML

Controller Layer
    ↓
Controller

Application Layer
    ↓
Service

Domain Calculation Layer
    ↓
Engine

Domain Model Layer
    ↓
Domain Object

Persistence Layer
    ↓
Repository

Storage Layer
    ↓
MySQL

因此Smarty属于最外层的Presentation Layer。

---

248.40 Smarty与ICAI独立运行

ICAI必须保持一个重要特性：

ICAI Runtime≠SmartyICAI\ Runtime\neq Smarty

机器个体可以在没有浏览器的情况下运行：

CLI
↓
Controller/Command
↓
Service
↓
Engine
↓
Domain Object

也可以通过Web：

Browser
↓
Controller
↓
Service
↓
Engine
↓
Domain Object
↓
Smarty

因此Web页面只是ICAI的一种表现接口，而不是ICAI本身。

---

248.41 Smarty与ICAI系统边界

本章最终明确：

Smarty≠ICAISmarty\neq ICAI Smarty≠CognitionSmarty\neq Cognition Smarty≠BehaviorSmarty\neq Behavior Smarty≠LearningSmarty\neq Learning Smarty≠MaintenanceSmarty\neq Maintenance Smarty≠RepositorySmarty\neq Repository

Smarty的唯一核心职责可以概括为：

ViewData→Template→HTMLViewData\rightarrow Template\rightarrow HTML

而ICAI核心运行职责是：

Object→Cognition→Behavior→Learning→MaintenanceObject \rightarrow Cognition \rightarrow Behavior \rightarrow Learning \rightarrow Maintenance

二者通过Controller和ViewData连接。

---

248.42 本章总结

第248章建立了Smarty与ICAI之间的工程关系。

Smarty属于ICAI的View层，是页面模板处理工具。

其基本关系为：

ViewData→Smarty→HTMLViewData \rightarrow Smarty \rightarrow HTML

完整页面返回链为：

MySQL→Repository→DomainObject→Engine→Service→Controller→ViewData→Smarty→HTML→BrowserMySQL \rightarrow Repository \rightarrow DomainObject \rightarrow Engine \rightarrow Service \rightarrow Controller \rightarrow ViewData \rightarrow Smarty \rightarrow HTML \rightarrow Browser

ICAI的认知、行为、学习和自我维护结果都可以通过View层进行表现：

CognitiveResult→ViewData→SmartyCognitiveResult \rightarrow ViewData \rightarrow Smarty BehaviorResult→ViewData→SmartyBehaviorResult \rightarrow ViewData \rightarrow Smarty LearningResult→ViewData→SmartyLearningResult \rightarrow ViewData \rightarrow Smarty MaintenanceResult→ViewData→SmartyMaintenanceResult \rightarrow ViewData \rightarrow Smarty

最终形成：

ICAI Runtime→Result→ViewData→Smarty→HTMLICAI\ Runtime \rightarrow Result \rightarrow ViewData \rightarrow Smarty \rightarrow HTML

因此，Smarty不是ICAI的认知核心，而是机器个体与人之间的页面表现层。

ICAI真正的核心仍然位于：

DomainObject+Cognition+Behavior+Learning+MaintenanceDomainObject + Cognition + Behavior + Learning + Maintenance

Smarty所完成的是：

MachineIndividual→ViewData→HumanReadablePageMachineIndividual \rightarrow ViewData \rightarrow HumanReadablePage

由此，ICAI形成了从内部机器个体到外部页面表现的完整工程映射：

机器个体→领域对象→业务结果→ViewData→Smarty→HTML→用户机器个体 \rightarrow 领域对象 \rightarrow 业务结果 \rightarrow ViewData \rightarrow Smarty \rightarrow HTML \rightarrow 用户

这也使Smarty在ICAI体系中的位置得到明确：它不是智能本身，而是智能运行结果的页面表达层。

第248章　Smarty与ICAI

248.43 Smarty实际渲染完整示例

前面的理论已经明确：

ViewData→Smarty→Template→HTMLViewData\rightarrow Smarty\rightarrow Template\rightarrow HTML

为了验证这一关系，本节建立一个最小但完整的Smarty实际渲染案例。

本案例模拟一个ICAI机器个体：

ID：ICAI-001
名称：任务处理个体
类型：TaskProcessor
状态：running
当前能力：task_process
当前方法：method_B
当前目标：完成Task-001

系统不使用任何大模型、神经网络、Embedding、Vector Search或生成式机制。

页面数据完全由PHP数组和对象产生，Smarty只负责模板渲染。

---

248.44 示例工程结构

建立以下目录：

smarty-icai-demo/
│
├── index.php
│
├── app/
│   └── MachineIndividual.php
│
└── templates/
    └── individual.tpl

运行关系：

index.php
   ↓
MachineIndividual
   ↓
ViewData
   ↓
Smarty
   ↓
individual.tpl
   ↓
HTML

---

248.45 MachineIndividual领域对象

建立：

app/MachineIndividual.php

代码：

<?php

class MachineIndividual
{
    protected $id;
    protected $name;
    protected $type;
    protected $state;
    protected $capability;
    protected $method;
    protected $goal;

    public function __construct(
        $id,
        $name,
        $type,
        $state,
        $capability,
        $method,
        $goal
    ) {
        $this->id = $id;
        $this->name = $name;
        $this->type = $type;
        $this->state = $state;
        $this->capability = $capability;
        $this->method = $method;
        $this->goal = $goal;
    }

    public function getId()
    {
        return $this->id;
    }

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

    public function getType()
    {
        return $this->type;
    }

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

    public function getCapability()
    {
        return $this->capability;
    }

    public function getMethod()
    {
        return $this->method;
    }

    public function getGoal()
    {
        return $this->goal;
    }
}

这个对象属于Domain Object。

因此：

MachineIndividual≠SmartyMachineIndividual\neq Smarty MachineIndividual≠TemplateMachineIndividual\neq Template

它负责表达机器个体的数据和属性。

---

248.46 创建ICAI机器个体

在：

index.php

中加载领域对象：

<?php

require_once __DIR__ . '/app/MachineIndividual.php';

$individual = new MachineIndividual(
    'ICAI-001',
    '任务处理个体',
    'TaskProcessor',
    'running',
    'task_process',
    'method_B',
    '完成 Task-001'
);

此时机器个体已经存在于PHP运行环境中。

可以表示为：

Individual={ID,Name,Type,State,Capability,Method,Goal}Individual= \{ ID, Name, Type, State, Capability, Method, Goal \}

---

248.47 创建ViewData

Controller或者页面控制程序不应该直接让模板自行读取Domain Object。

应该先建立ViewData：

$viewData = array(
    'id' => $individual->getId(),
    'name' => $individual->getName(),
    'type' => $individual->getType(),
    'state' => $individual->getState(),
    'capability' => $individual->getCapability(),
    'method' => $individual->getMethod(),
    'goal' => $individual->getGoal()
);

此时：

DomainObject→ViewDataDomainObject \rightarrow ViewData

数据已经从领域对象转换成页面需要的数据结构。

---

248.48 安装Smarty

真实Smarty渲染需要Smarty模板引擎。

如果项目已经通过Composer安装Smarty，则可以使用：

composer require smarty/smarty

安装后通常会形成：

vendor/
└── smarty/

并存在：

vendor/autoload.php

本示例采用Composer方式加载Smarty。

因此：

require_once __DIR__ . '/vendor/autoload.php';

---

248.49 创建Smarty对象

在index.php中：

$smarty = new Smarty\Smarty();

$smarty->setTemplateDir(__DIR__ . '/templates/');

这里：

Smarty对象
↓
模板目录
↓
templates/

Smarty知道应该从哪里寻找：

individual.tpl

---

248.50 向Smarty分配ViewData

将PHP准备好的数据交给Smarty：

$smarty->assign('individual', $viewData);

此时形成：

ViewData→SmartyViewData \rightarrow Smarty

Smarty内部获得：

individual
    ├── id
    ├── name
    ├── type
    ├── state
    ├── capability
    ├── method
    └── goal

---

248.51 建立Smarty模板

创建：

templates/individual.tpl

完整内容：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>ICAI机器个体</title>
</head>
<body>

<h1>ICAI机器个体</h1>

<table border="1" cellpadding="8" cellspacing="0">
    <tr>
        <th>字段</th>
        <th>值</th>
    </tr>

    <tr>
        <td>ID</td>
        <td>{$individual.id}</td>
    </tr>

    <tr>
        <td>名称</td>
        <td>{$individual.name}</td>
    </tr>

    <tr>
        <td>类型</td>
        <td>{$individual.type}</td>
    </tr>

    <tr>
        <td>状态</td>
        <td>{$individual.state}</td>
    </tr>

    <tr>
        <td>能力</td>
        <td>{$individual.capability}</td>
    </tr>

    <tr>
        <td>当前方法</td>
        <td>{$individual.method}</td>
    </tr>

    <tr>
        <td>当前目标</td>
        <td>{$individual.goal}</td>
    </tr>
</table>

</body>
</html>

这里最重要的代码是：

{$individual.id}

例如：

{$individual.name}

Smarty会读取PHP通过：

$smarty->assign('individual', $viewData);

传递进去的数据。

---

248.52 执行Smarty渲染

在index.php最后：

$smarty->display('individual.tpl');

于是完整过程变成：

MachineIndividual
        ↓
$viewData
        ↓
$smarty->assign()
        ↓
individual.tpl
        ↓
$smarty->display()
        ↓
HTML

数学表达为：

HTML=Render(Template,ViewData)HTML=Render(Template,ViewData)

---

248.53 完整index.php

将前面的代码合并以后：

<?php

require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/app/MachineIndividual.php';

$individual = new MachineIndividual(
    'ICAI-001',
    '任务处理个体',
    'TaskProcessor',
    'running',
    'task_process',
    'method_B',
    '完成 Task-001'
);

$viewData = array(
    'id' => $individual->getId(),
    'name' => $individual->getName(),
    'type' => $individual->getType(),
    'state' => $individual->getState(),
    'capability' => $individual->getCapability(),
    'method' => $individual->getMethod(),
    'goal' => $individual->getGoal()
);

$smarty = new Smarty\Smarty();

$smarty->setTemplateDir(__DIR__ . '/templates/');

$smarty->assign(
    'individual',
    $viewData
);

$smarty->display('individual.tpl');

这就是一个完整的：

PHP→ViewData→Smarty→TPL→HTMLPHP \rightarrow ViewData \rightarrow Smarty \rightarrow TPL \rightarrow HTML

实际渲染入口。

---

248.54 实际浏览器结果

浏览器访问：

http://localhost/smarty-icai-demo/

最终页面应该显示：

ICAI机器个体

字段             值

ID               ICAI-001
名称             任务处理个体
类型             TaskProcessor
状态             running
能力             task_process
当前方法         method_B
当前目标         完成 Task-001

注意：

浏览器看到的是HTML。

浏览器并不知道：

MachineIndividual
Smarty
ViewData

这些都是服务器端处理过程。

---

248.55 实际渲染过程拆解

一次页面请求可以拆成以下步骤。

第一步：浏览器请求

Browser
↓
GET /

第二步：PHP入口执行

index.php

第三步：建立机器个体

MachineIndividual

第四步：建立ViewData

MachineIndividual
↓
ViewData

第五步：Smarty接收数据

ViewData
↓
$smarty->assign()

第六步：Smarty读取模板

templates/individual.tpl

第七步：模板变量替换

例如：

{$individual.name}

变成：

任务处理个体

第八步：生成HTML

Smarty
↓
HTML

第九步：返回浏览器

HTML
↓
Browser

完整过程：

Browser→PHP→DomainObject→ViewData→Smarty→Template→HTML→BrowserBrowser \rightarrow PHP \rightarrow DomainObject \rightarrow ViewData \rightarrow Smarty \rightarrow Template \rightarrow HTML \rightarrow Browser

---

248.56 Smarty条件渲染实际示例

ICAI页面不仅可以显示数据，还可以根据已经确定的状态进行页面表现。

例如：

<h2>运行状态</h2>

{if $individual.state == 'running'}
    <p>机器个体正在运行。</p>
{elseif $individual.state == 'stopped'}
    <p>机器个体已经停止。</p>
{else}
    <p>机器个体处于未知状态。</p>
{/if}

这里Smarty只是根据：

individual.state

决定显示哪段HTML。

它没有计算机器个体为什么运行，也没有决定机器个体是否应该运行。

因此：

TemplateCondition≠CognitiveDecisionTemplateCondition\neq CognitiveDecision

---

248.57 Smarty循环实际示例

假设Controller提供最近的运行记录：

$viewData['history'] = array(
    array(
        'time' => '2026-09-05 10:00:00',
        'method' => 'method_A',
        'result' => 'failure'
    ),
    array(
        'time' => '2026-09-05 10:05:00',
        'method' => 'method_A',
        'result' => 'failure'
    ),
    array(
        'time' => '2026-09-05 10:10:00',
        'method' => 'method_B',
        'result' => 'success'
    )
);

模板：

<h2>运行历史</h2>

<table border="1" cellpadding="8">
    <tr>
        <th>时间</th>
        <th>方法</th>
        <th>结果</th>
    </tr>

    {foreach $individual.history as $item}
    <tr>
        <td>{$item.time}</td>
        <td>{$item.method}</td>
        <td>{$item.result}</td>
    </tr>
    {/foreach}
</table>

最终页面显示：

运行历史

时间                  方法        结果
2026-09-05 10:00:00   method_A    failure
2026-09-05 10:05:00   method_A    failure
2026-09-05 10:10:00   method_B    success

这里的历史记录已经由PHP准备完成。

Smarty只是循环输出。

---

248.58 Smarty与ICAI学习结果实际显示

可以进一步把第246章的学习结果加入ViewData。

例如：

$viewData['learning'] = array(
    'status' => 'success',
    'old_method' => 'method_A',
    'new_method' => 'method_B',
    'reason' => 'method_A连续失败，method_B验证成功'
);

模板：

<h2>学习结果</h2>

<p>学习状态：{$individual.learning.status}</p>

<p>原方法：{$individual.learning.old_method}</p>

<p>新方法：{$individual.learning.new_method}</p>

<p>学习原因：{$individual.learning.reason}</p>

页面结果：

学习结果

学习状态：success
原方法：method_A
新方法：method_B
学习原因：method_A连续失败，method_B验证成功

这里真正发生学习的是后端：

Learning→UpdateLearning \rightarrow Update

页面只负责：

LearningResult→HTMLLearningResult \rightarrow HTML

---

248.59 Smarty与ICAI维护结果实际显示

同样可以显示第247章的维护结果。

Controller提供：

$viewData['maintenance'] = array(
    'detection' => 'abnormal',
    'risk' => 'high',
    'conflict' => 'method_A持续失败',
    'diagnosis' => 'method_A在Condition_C下失效',
    'repair' => '切换到method_B',
    'verification' => 'success'
);

模板：

<h2>自我维护</h2>

<ul>
    <li>检测：{$individual.maintenance.detection}</li>
    <li>风险：{$individual.maintenance.risk}</li>
    <li>冲突：{$individual.maintenance.conflict}</li>
    <li>诊断：{$individual.maintenance.diagnosis}</li>
    <li>修复：{$individual.maintenance.repair}</li>
    <li>验证：{$individual.maintenance.verification}</li>
</ul>

最终形成：

自我维护

检测：abnormal
风险：high
冲突：method_A持续失败
诊断：method_A在Condition_C下失效
修复：切换到method_B
验证：success

完整计算仍然发生在：

MaintenanceEngineMaintenanceEngine

而不是Smarty。

---

248.60 完整ICAI页面ViewData

经过前面的组合，可以形成完整ViewData：

$viewData = array(
    'id' => $individual->getId(),
    'name' => $individual->getName(),
    'type' => $individual->getType(),
    'state' => $individual->getState(),
    'capability' => $individual->getCapability(),
    'method' => $individual->getMethod(),
    'goal' => $individual->getGoal(),

    'learning' => array(
        'status' => 'success',
        'old_method' => 'method_A',
        'new_method' => 'method_B',
        'reason' => 'method_A连续失败，method_B验证成功'
    ),

    'maintenance' => array(
        'detection' => 'abnormal',
        'risk' => 'high',
        'conflict' => 'method_A持续失败',
        'diagnosis' => 'method_A在Condition_C下失效',
        'repair' => '切换到method_B',
        'verification' => 'success'
    )
);

于是：

ICAIViewData={Individual,Learning,Maintenance}ICAIViewData= \{ Individual, Learning, Maintenance \}

再交给：

SmartySmarty

---

248.61 完整ICAI Smarty模板

完整模板可以写成：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>ICAI机器个体</title>
</head>

<body>

<h1>ICAI机器个体</h1>

<h2>个体信息</h2>

<table border="1" cellpadding="8">
    <tr>
        <td>ID</td>
        <td>{$individual.id}</td>
    </tr>

    <tr>
        <td>名称</td>
        <td>{$individual.name}</td>
    </tr>

    <tr>
        <td>类型</td>
        <td>{$individual.type}</td>
    </tr>

    <tr>
        <td>状态</td>
        <td>{$individual.state}</td>
    </tr>

    <tr>
        <td>能力</td>
        <td>{$individual.capability}</td>
    </tr>

    <tr>
        <td>当前方法</td>
        <td>{$individual.method}</td>
    </tr>

    <tr>
        <td>当前目标</td>
        <td>{$individual.goal}</td>
    </tr>
</table>


<h2>学习结果</h2>

<table border="1" cellpadding="8">
    <tr>
        <td>状态</td>
        <td>{$individual.learning.status}</td>
    </tr>

    <tr>
        <td>原方法</td>
        <td>{$individual.learning.old_method}</td>
    </tr>

    <tr>
        <td>新方法</td>
        <td>{$individual.learning.new_method}</td>
    </tr>

    <tr>
        <td>原因</td>
        <td>{$individual.learning.reason}</td>
    </tr>
</table>


<h2>自我维护</h2>

<table border="1" cellpadding="8">
    <tr>
        <td>检测</td>
        <td>{$individual.maintenance.detection}</td>
    </tr>

    <tr>
        <td>风险</td>
        <td>{$individual.maintenance.risk}</td>
    </tr>

    <tr>
        <td>冲突</td>
        <td>{$individual.maintenance.conflict}</td>
    </tr>

    <tr>
        <td>诊断</td>
        <td>{$individual.maintenance.diagnosis}</td>
    </tr>

    <tr>
        <td>修复</td>
        <td>{$individual.maintenance.repair}</td>
    </tr>

    <tr>
        <td>验证</td>
        <td>{$individual.maintenance.verification}</td>
    </tr>
</table>

</body>
</html>

这已经是一个完整的ICAI页面模板。

---

248.62 完整渲染链

至此，整个实际渲染过程可以准确表示为：

Browser
   ↓
index.php
   ↓
MachineIndividual
   ↓
ViewData
   ↓
Smarty::assign()
   ↓
individual.tpl
   ↓
Smarty::display()
   ↓
HTML
   ↓
Browser

如果加入完整ICAI MVC：

Browser
   ↓
Controller
   ↓
Service
   ↓
Engine
   ↓
Domain Object
   ↓
Repository
   ↓
MySQL
   ↓
Domain Object
   ↓
Engine
   ↓
Service
   ↓
Controller
   ↓
ViewData
   ↓
Smarty
   ↓
HTML
   ↓
Browser

因此：

Request→Controller→Service→Engine→DomainObject→Repository→MySQLRequest \rightarrow Controller \rightarrow Service \rightarrow Engine \rightarrow DomainObject \rightarrow Repository \rightarrow MySQL

返回：

MySQL→Repository→DomainObject→Engine→Service→Controller→ViewData→Smarty→HTMLMySQL \rightarrow Repository \rightarrow DomainObject \rightarrow Engine \rightarrow Service \rightarrow Controller \rightarrow ViewData \rightarrow Smarty \rightarrow HTML

---

248.63 Smarty实际运行验证

如果使用Composer安装的Smarty，项目目录应至少具有：

smarty-icai-demo/
│
├── index.php
├── composer.json
├── vendor/
│   └── autoload.php
│
├── app/
│   └── MachineIndividual.php
│
└── templates/
    └── individual.tpl

命令行进入项目目录：

cd /d D:\smarty-icai-demo

检查PHP：

D:\wamp\bin\php\php5.6.25\php.exe -v

或者：

D:\wamp\bin\php\php7.0.10\php.exe -v

然后通过WAMP的Apache访问：

http://localhost/smarty-icai-demo/

实际验证标准不是“代码看起来正确”，而是浏览器真正出现：

ICAI机器个体

ID：ICAI-001
名称：任务处理个体
类型：TaskProcessor
状态：running
能力：task_process
当前方法：method_B
当前目标：完成 Task-001

并能够同时显示：

学习结果
自我维护

只有浏览器真正输出上述HTML，才能确认：

PHP→ViewData→Smarty→TPL→HTMLPHP \rightarrow ViewData \rightarrow Smarty \rightarrow TPL \rightarrow HTML

这条链实际运行成功。

---

248.64 Smarty实际渲染与伪代码的区别

理论描述：

ViewData→Smarty→HTMLViewData\rightarrow Smarty\rightarrow HTML

只是结构定义。

真正的工程验证必须具有：

PHP文件
+
Domain Object
+
Smarty安装
+
TPL模板
+
HTTP入口
+
Apache/PHP运行环境
+
浏览器实际HTML输出

因此：

Theory≠RuntimeTheory\neq Runtime TemplateDefinition≠RenderSuccessTemplateDefinition\neq RenderSuccess PHPCode≠BrowserResultPHPCode\neq BrowserResult

只有：

BrowserResult=ExpectedHTMLBrowserResult=ExpectedHTML

才能证明页面渲染链真正成立。

---

248.65 Smarty在ICAI中的最终位置

经过实际示例，可以进一步确定Smarty在ICAI中的工程位置：

                    ICAI Runtime
                         │
        ┌────────────────┼────────────────┐
        ↓                ↓                ↓
   Cognition         Behavior         Learning
        │                │                │
        └────────────────┼────────────────┘
                         ↓
                     Result
                         ↓
                     ViewData
                         ↓
                       Smarty
                         ↓
                      Template
                         ↓
                       HTML
                         ↓
                      Browser

因此Smarty不参与ICAI核心智能计算，而负责将已经完成的机器个体运行结果转换成用户能够看到的页面。

最终关系为：

ICAI Intelligence→Runtime Result→ViewData→Smarty→HTMLICAI\ Intelligence \rightarrow Runtime\ Result \rightarrow ViewData \rightarrow Smarty \rightarrow HTML

本节的实际运行示例进一步证明：

Smarty是ICAI页面表现层，而不是ICAI智能计算层。

这一区分使ICAI的领域层、业务层、持久化层和表现层保持独立，也使机器个体可以在没有Web页面的情况下独立运行。