首页 理论 架构 工程 规划 文档 白皮书 著作 研究 案例 下载 博客 关于 联系 开始使用 →

第二十七章 智能对象与 Smarty 模板数据映射

第二十七章 智能对象与 Smarty 模板数据映射

  1. 智能对象数据与模板变量的关系
  2. 对象属性向 Smarty 赋值
  3. 对象状态向模板传递
  4. 对象关系的数据组织
  5. 方法调用结果与模板数据更新
  6. 模板数据与实例运行状态同步
  7. 动态对象数据的前台输出

第二十七章 智能对象与 Smarty 模板数据映射

本章研究智能对象实例运行数据与 Smarty 模板变量之间的数据映射机制。第二十六章已经建立智能对象实例的加载、初始化、运行上下文、属性读取与修改、方法调用、状态变化、多实例管理及异常恢复机制。本章在此基础上,进一步解决运行中的智能对象数据如何组织、传递到前台模板,以及模板数据如何随实例属性、状态和方法执行结果变化的问题。

在 WSaiOS 工程体系中,智能对象实例是运行数据的来源,Smarty 是前台数据呈现工具。二者之间不能直接混淆。智能对象的结构定义、属性管理、状态判断、方法执行和数据持久化由后端运行程序负责;Smarty 接收后端组织好的数据,通过模板变量、循环、条件判断和模板组合完成页面呈现。

因此,本章建立的是一套从智能对象运行上下文到 Smarty 模板变量的数据映射机制。其核心过程为:

\[ O_i \rightarrow C_i \rightarrow D_i \rightarrow A_i \rightarrow Smarty \]

其中,\(O_i\) 表示智能对象实例,\(C_i\) 表示实例运行上下文,\(D_i\) 表示经过组织的前台数据,\(A_i\) 表示 PHP 向 Smarty 进行的数据赋值,最终由 Smarty 输出页面。

27.1 智能对象数据与模板变量的关系

智能对象实例在运行过程中具有独立的结构定义、属性值、方法、状态、关系、知识和能力配置。这些数据构成智能对象的运行基础,但并不是所有运行数据都需要直接传递给前台模板。

前台模板需要的数据,应根据页面呈现需求,从实例运行上下文中提取、整理和映射。这样既可以保持智能对象内部结构的完整性,也可以避免前台页面直接依赖后端内部数据组织。

智能对象实例的数据模型可以表示为:

\[ O_i=(ID_i,D_i,P_i,V_i,M_i,S_i,R_i,K_i,A_i,C_i) \]

其中,\(ID_i\) 是实例标识,\(D_i\) 是结构定义,\(P_i\) 是属性定义,\(V_i\) 是实例属性值,\(M_i\) 是方法定义,\(S_i\) 是实例状态,\(R_i\) 是对象关系,\(K_i\) 是知识配置,\(A_i\) 是能力配置,\(C_i\) 是运行约束。

Smarty 模板并不直接使用整个 \(O_i\),而是使用后端组织后的展示数据:

\[ D_i^{view}=F(O_i,C_i,Q_v) \]

其中,\(D_i^{view}\) 表示前台展示数据,\(Q_v\) 表示当前页面的数据需求,\(F\) 表示数据提取、权限检查、字段映射和数据组织过程。

例如,一个工业设备智能对象实例可能包含设备编号、额定功率、运行温度、运行状态、控制方法、报警规则、维护知识和设备关联关系。设备监控页面可能只需要显示设备名称、设备编号、当前温度、运行状态和报警信息,而不需要显示全部内部方法定义和运行配置。

因此,前台数据与智能对象运行数据之间不是简单复制关系,而是按照展示需求建立映射关系。

其工程调用关系如下:

智能对象实例实例运行上下文前台数据组织服务展示字段选择权限与数据范围检查数据格式转换Smarty 数据赋值Smarty 模板解析前台页面输出

建议将这一过程组织在独立的数据映射目录中:

WSaiOS/
└── Presentation/
    └── DataMapping/
        ├── ObjectViewDataBuilder.php
        │   // 根据智能对象实例和页面需求,组织前台展示数据
        ├── ViewFieldResolver.php
        │   // 根据展示配置确定需要读取的对象属性和状态字段
        ├── ViewPermissionChecker.php
        │   // 检查当前用户和页面是否具有相应数据的查看权限
        ├── ViewDataFormatter.php
        │   // 对属性值、状态值、时间和关系数据进行展示格式转换
        └── SmartyDataAssigner.php
            // 将组织完成的展示数据赋值给 Smarty 模板变量

其中,ObjectViewDataBuilder.php 是整个数据映射过程的组织入口。它根据页面需求调用字段解析、权限检查和数据格式转换程序,形成完整的前台数据对象。SmartyDataAssigner.php 只负责将已经处理好的数据交给 Smarty,不参与智能对象内部逻辑。

通过这种分层,智能对象可以在不改变内部结构的情况下,服务于不同的前台页面。例如,同一个设备实例可以分别用于设备详情页、设备监控页和设备管理页,每个页面使用不同的数据映射配置。

27.2 对象属性向 Smarty 赋值

智能对象的属性是前台页面最主要的数据来源之一。对象属性在结构定义中具有名称、类型、单位、约束和语义等定义信息,在实例运行过程中具有对应的实际属性值。

因此,属性映射需要同时处理属性定义和属性值,不能只读取数据库中的某个字段后直接输出。

设智能对象的属性定义集合为:

\[ P_i=\{P_{i1},P_{i2},\ldots,P_{in}\} \]

对应的属性值集合为:

\[ V_i=\{V_{i1},V_{i2},\ldots,V_{in}\} \]

前台需要显示的属性集合为:

\[ V_i^{view}=Select(V_i,Q_v,C_v) \]

其中,\(Q_v\) 表示页面要求显示的属性集合,\(C_v\) 表示属性展示约束。选择结果还需要经过类型检查、权限验证和格式转换,才能进入 Smarty 数据变量。

例如,设备详情页需要显示设备名称、设备编号、额定功率和当前温度,可以将展示字段组织为:

$viewFields = array(
    'device_name',
    'device_code',
    'rated_power',
    'current_temperature'
);

后端根据这些字段从智能对象实例中读取对应属性值,而不是要求 Smarty 自行访问数据库。

PHP 数据组织示例:

class ObjectViewDataBuilder
{
    private $propertyReader;
    private $permissionChecker;
    private $formatter;

    public function __construct(
        $propertyReader,
        $permissionChecker,
        $formatter
    ) {
        $this->propertyReader = $propertyReader;
        $this->permissionChecker = $permissionChecker;
        $this->formatter = $formatter;
    }

    public function buildProperties(
        $instanceId,
        $fieldNames,
        $userContext
    ) {
        $result = array();

        foreach ($fieldNames as $fieldName) {

            if (!$this->permissionChecker->canRead(
                $instanceId,
                $fieldName,
                $userContext
            )) {
                continue;
            }

            $property = $this->propertyReader->read(
                $instanceId,
                $fieldName
            );

            if ($property === null) {
                continue;
            }

            $result[$fieldName] = array(
                'name' => $property['name'],
                'value' => $this->formatter->format(
                    $property['value'],
                    $property['type'],
                    $property['unit']
                ),
                'unit' => $property['unit'],
                'source' => $property['source']
            );
        }

        return $result;
    }
}

上述程序通过属性读取服务获取实例属性,通过权限检查确定字段是否可以展示,再通过格式转换程序形成前台数据。这里的程序是工程实现示例,具体调用接口应与实际属性管理模块保持一致。

PHP 向 Smarty 赋值:

$properties = $viewDataBuilder->buildProperties(
    $instanceId,
    $viewFields,
    $userContext
);

$smarty->assign('object_properties', $properties);

$smarty->display('object/detail.tpl');

Smarty 模板:

<div class="object-properties">
    {foreach $object_properties as $property}
        <div class="property-item">
            <span class="property-name">
                {$property.name|escape}
            </span>

            <span class="property-value">
                {$property.value|escape}
            </span>

            {if $property.unit}
                <span class="property-unit">
                    {$property.unit|escape}
                </span>
            {/if}
        </div>
    {/foreach}
</div>

这里的 Smarty 变量 object_properties 是后端组织后的展示数据,不是智能对象内部的属性定义集合。模板只负责循环读取和显示数据。

对于动态属性系统,前台不能预先假定所有智能对象都具有相同字段。展示字段应由对象结构定义、页面展示配置和当前实例属性共同决定。某个对象没有对应属性时,应按页面配置隐藏、显示为空或标记为未配置,而不能凭空生成属性值。

因此,动态属性映射的关键是保持属性标识与属性语义之间的对应关系:

\[ P_{id}\rightarrow V_{id}\rightarrow D_{view} \]

属性标识用于准确定位,属性值提供当前数据,展示映射负责形成页面变量。

27.3 对象状态向模板传递

智能对象状态是运行过程中形成的重要数据。第二十六章已经建立对象状态读取、状态判断、状态转换和状态保存机制。本节研究如何将这些状态数据传递给 Smarty,使前台页面能够展示智能对象当前运行情况。

智能对象的状态定义与实例当前状态必须分开处理。

状态定义描述对象可能具有的状态类型、状态标识、状态转换条件和状态约束。实例当前状态则描述某个具体对象在当前运行时间所处的状态。

设对象状态定义为:

\[ S_i^d=\{s_1,s_2,\ldots,s_n\} \]

实例当前状态为:

\[ S_i(t)=s_k \]

前台展示的数据不是全部状态定义,而是当前状态及其必要的展示信息:

\[ S_i^{view}=F(S_i^d,S_i(t),Q_v) \]

其中,\(Q_v\) 表示页面需要显示的状态信息。

例如,工业设备可能定义待机、运行、暂停、故障和维护等状态。某台设备当前处于运行状态,前台页面只需要展示当前状态、状态更新时间和必要的状态说明,而不必将全部状态转换规则输出到页面。

状态数据可以组织为:

$stateData = array(
    'state_id' => 'running',
    'state_name' => '运行中',
    'state_value' => 1,
    'state_time' => '2026-11-16 15:30:00',
    'state_source' => 'controller_feedback',
    'confirmed' => true
);

这里的状态来源和确认信息具有重要意义。由程序初始化得到的默认状态、控制指令发出后的预期状态、传感器反馈状态以及控制器确认状态,不能不加区分地统一显示为已经确认的真实运行状态。

状态数据映射程序可以由独立的状态读取组件负责:

class ObjectStateViewBuilder
{
    private $stateReader;

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

    public function build($instanceId)
    {
        $state = $this->stateReader->getCurrentState(
            $instanceId
        );

        if (!$state) {
            return array(
                'available' => false,
                'state_name' => '状态未知'
            );
        }

        return array(
            'available' => true,
            'state_id' => $state['state_id'],
            'state_name' => $state['state_name'],
            'state_time' => $state['updated_at'],
            'state_source' => $state['source'],
            'confirmed' => $state['confirmed']
        );
    }
}

将状态数据赋值给 Smarty:

$stateView = $stateViewBuilder->build($instanceId);

$smarty->assign('object_state', $stateView);

Smarty 模板:

<div class="object-state">
    {if $object_state.available}
        <span class="state-name">
            {$object_state.state_name|escape}
        </span>

        <span class="state-time">
            {$object_state.state_time|escape}
        </span>

        {if !$object_state.confirmed}
            <span class="state-not-confirmed">
                状态尚未确认
            </span>
        {/if}
    {else}
        <span class="state-unknown">
            {$object_state.state_name|escape}
        </span>
    {/if}
</div>

状态映射的工程流程如下:

智能对象实例状态读取程序获取当前状态状态来源与有效性检查状态展示数据组织PHP 赋值 SmartySmarty 状态模板前台状态显示

状态变化后,前台应当重新读取有效的实例状态数据,而不是由 Smarty 自行推断状态。对于设备控制场景,发送启动命令只表示执行请求已经发出,不能直接把设备状态改成“运行中”。只有获得符合条件的设备反馈或状态确认后,才能按相应状态规则更新前台展示。

27.4 对象关系的数据组织

智能对象之间可能存在包含、组成、关联、依赖、控制和协作等结构关系。前台页面不仅需要显示单个对象的属性和状态,也可能需要显示对象之间的关系。

例如,一个工业生产系统中可能存在生产线、控制设备、电机、传感器和执行装置等多个智能对象。它们分别具有独立的实例标识和运行数据,同时通过结构关系组成一个整体。

对象关系可以表示为:

\[ R_i=\{r_1,r_2,\ldots,r_n\} \]

单条关系可以表示为:

\[ r_j=(ID_r,O_a,O_b,T_r,C_r) \]

其中,\(ID_r\) 是关系标识,\(O_a\) 和 \(O_b\) 是关系两端的对象,\(T_r\) 是关系类型,\(C_r\) 是关系约束。

前台关系数据需要将关系标识转换为页面可以使用的对象信息。关系本身不能只传递两个实例 ID,还需要根据页面要求读取关系两端的对象名称、类型和必要状态。

例如:

$relationData = array(
    array(
        'relation_id' => 'rel_1001',
        'relation_type' => 'contains',
        'source' => array(
            'instance_id' => 'line_001',
            'name' => '第一生产线'
        ),
        'target' => array(
            'instance_id' => 'motor_001',
            'name' => '一号电机'
        )
    ),
    array(
        'relation_id' => 'rel_1002',
        'relation_type' => 'monitors',
        'source' => array(
            'instance_id' => 'sensor_001',
            'name' => '温度传感器'
        ),
        'target' => array(
            'instance_id' => 'motor_001',
            'name' => '一号电机'
        )
    )
);

上述数据表达了生产线包含电机、传感器监测电机的关系。它只是前台关系展示数据,不能替代后端完整的关系定义和约束。

对象关系的数据组织可以由关系展示数据构建程序完成:

class ObjectRelationViewBuilder
{
    private $relationRepository;
    private $objectReader;

    public function __construct(
        $relationRepository,
        $objectReader
    ) {
        $this->relationRepository = $relationRepository;
        $this->objectReader = $objectReader;
    }

    public function build($instanceId)
    {
        $relations = $this->relationRepository
            ->getRelations($instanceId);

        $result = array();

        foreach ($relations as $relation) {

            $source = $this->objectReader->getSummary(
                $relation['source_id']
            );

            $target = $this->objectReader->getSummary(
                $relation['target_id']
            );

            if (!$source || !$target) {
                continue;
            }

            $result[] = array(
                'relation_id' => $relation['relation_id'],
                'relation_type' => $relation['relation_type'],
                'source' => $source,
                'target' => $target
            );
        }

        return $result;
    }
}

Smarty 模板可以通过循环组织关系展示:

<div class="object-relations">
    {foreach $object_relations as $relation}
        <div class="relation-item">
            <span class="relation-source">
                {$relation.source.name|escape}
            </span>

            <span class="relation-type">
                {$relation.relation_type|escape}
            </span>

            <span class="relation-target">
                {$relation.target.name|escape}
            </span>
        </div>
    {/foreach}
</div>

当对象关系数量较多时,前台可以根据关系类型、对象层级和页面区域组织数据。例如,设备详情页只展示与当前设备直接相关的对象,生产线页面则可以展示其下属设备及关联传感器。

关系展示数据还需要遵守对象访问权限。即使两个对象在结构上存在关系,也不意味着当前用户可以查看两个对象的全部属性和运行数据。关系读取与对象信息读取应分别进行权限检查。

对于复杂对象关系,后端可以先完成关系查询和关系结构整理,再将适合页面呈现的数据交给 Smarty。Smarty 不负责判断两个对象是否具有合法的结构关系,也不负责执行关系计算。

27.5 方法调用结果与模板数据更新

智能对象方法由后端运行引擎调用。方法执行后可能产生属性变化、状态变化、关系变化或计算结果。这些结果需要经过后端处理,再映射为新的模板数据。

方法调用与前台数据更新之间的关系可以表示为:

\[ M_j \rightarrow R_m \rightarrow \Delta O_i \rightarrow D_i^{view,new} \]

其中,\(M_j\) 是智能对象方法,\(R_m\) 是方法执行结果,\(\Delta O_i\) 是实例运行数据变化,\(D_i^{view,new}\) 是更新后的展示数据。

这里需要明确区分方法调用结果和智能对象实际运行结果。

例如,用户在设备管理页面点击“启动设备”,前台向后端提交方法调用请求。后端验证权限、参数和执行条件,再由方法执行器调用对应的实际程序。方法返回结果可能表示请求已接受、指令已发送、执行程序已完成,或者设备反馈已经确认。这些结果具有不同含义,不能统一处理为设备已经启动。

方法调用结果可以组织为:

$methodResult = array(
    'method_id' => 'start_device',
    'request_id' => 'req_202611160001',
    'accepted' => true,
    'executed' => true,
    'confirmed' => false,
    'message' => '启动指令已发送',
    'updated_at' => '2026-11-16 15:32:00'
);

后端根据方法执行结果决定是否重新读取实例属性和状态。如果方法只是成功发送指令,而设备状态尚未反馈确认,那么前台应显示指令执行进度或等待确认状态,而不能直接将设备状态显示为运行中。

方法结果与展示数据更新的处理程序可以组织为:

class MethodViewUpdateService
{
    private $resultHandler;
    private $viewDataBuilder;

    public function __construct(
        $resultHandler,
        $viewDataBuilder
    ) {
        $this->resultHandler = $resultHandler;
        $this->viewDataBuilder = $viewDataBuilder;
    }

    public function update(
        $instanceId,
        $methodResult,
        $userContext
    ) {
        $resultData = $this->resultHandler->format(
            $methodResult
        );

        $objectData = $this->viewDataBuilder->build(
            $instanceId,
            $userContext
        );

        return array(
            'method_result' => $resultData,
            'object_data' => $objectData
        );
    }
}

前台可以通过 Smarty 显示方法调用结果:

<div class="method-result">
    <p>{$method_result.message|escape}</p>

    {if $method_result.confirmed}
        <span class="result-confirmed">
            执行结果已确认
        </span>
    {elseif $method_result.executed}
        <span class="result-pending">
            等待运行结果确认
        </span>
    {elseif $method_result.accepted}
        <span class="result-accepted">
            请求已接受
        </span>
    {/if}
</div>

对于不涉及真实设备的普通软件对象,方法执行结果可能已经足以确认业务处理完成;对于工业设备、机器人和无人机等物理对象,则需要结合设备反馈、传感器信息或其他有效确认来源判断实际运行状态。

方法执行完成后,展示数据的更新过程应当由后端统一组织:

提交方法调用请求验证并调用实例方法执行已注册处理程序返回方法结果保存有效运行变化返回执行结果重新读取实例数据返回最新运行数据赋值展示数据输出更新后的页面

该流程保证方法执行、运行数据变化和页面数据更新之间具有明确的数据关系,同时避免 Smarty 直接执行智能对象方法。

27.6 模板数据与实例运行状态同步

智能对象可能持续运行,属性值和状态值也可能不断变化。如果前台只在页面第一次加载时取得一次数据,之后就可能出现页面数据与实例实际运行状态不一致的问题。

因此,需要建立模板数据与实例运行状态之间的同步机制。

首先需要区分两个层次的数据。

实例运行数据是后端运行引擎维护的对象属性、状态、关系和方法执行结果。模板数据是从实例运行数据中提取出来的页面展示数据。二者存在映射关系,但不要求所有内部运行数据都同步到前台。

设实例在时间 \(t\) 的运行数据为:

\[ O_i(t) \]

页面展示数据为:

\[ D_i^{view}(t)=F(O_i(t),Q_v,C_v) \]

当实例运行数据发生变化时:

\[ \Delta O_i(t)=O_i(t+1)-O_i(t) \]

后端根据变化内容重新计算需要更新的展示数据:

\[ D_i^{view}(t+1)=F(O_i(t+1),Q_v,C_v) \]

对于非数值属性和离散状态,变化应通过属性值比较、状态转换记录和关系差异进行判断,不应将所有变化都理解为数值减法。

在工程实现中,可以采用页面请求刷新、定时数据读取、服务端事件推送等方式同步展示数据。具体采用哪种方式,取决于运行环境和通信条件。Smarty 本身负责生成页面,不负责建立持续运行的数据同步通道。

建议将同步程序组织如下:

WSaiOS/
└── Presentation/
    └── Synchronization/
        ├── ViewDataSyncService.php
        │   // 组织实例运行数据与前台展示数据的同步过程
        ├── ViewDataVersionManager.php
        │   // 管理展示数据版本和实例数据版本之间的对应关系
        ├── ViewDataChangeDetector.php
        │   // 比较前后数据并识别需要更新的展示字段
        ├── ViewDataRefreshController.php
        │   // 接收前台刷新请求并返回最新展示数据
        └── ViewDataSyncRepository.php
            // 保存必要的同步版本、更新时间和同步记录

同步数据可以包含实例标识、数据版本、状态版本和更新时间:

$syncData = array(
    'instance_id' => 'motor_001',
    'instance_version' => 18,
    'state_version' => 9,
    'view_version' => 25,
    'updated_at' => '2026-11-16 15:35:00',
    'data' => array(
        'current_temperature' => 62.5,
        'current_state' => 'running'
    )
);

其中,instance_version 用于标识实例运行数据版本,state_version 用于标识状态数据版本,view_version 用于标识前台展示数据版本。它们不一定同步递增,因为属性、状态和展示配置可能分别发生变化。

后端可以通过版本比较判断是否需要刷新:

\[ Refresh= \begin{cases} 1,& V_{server}>V_{client}\\ 0,& V_{server}=V_{client}\\ Check,& V_{server}<V_{client} \end{cases} \]

当服务端版本高于客户端版本时,说明客户端展示数据可能已经过期,需要取得更新数据。当客户端版本高于服务端版本时,不能直接认定客户端数据更新,而应检查版本来源、实例标识和数据有效性。

对于页面定时刷新,可以提供独立接口:

class ViewDataRefreshController
{
    private $viewDataBuilder;

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

    public function refresh($instanceId, $userContext)
    {
        $data = $this->viewDataBuilder->build(
            $instanceId,
            $userContext
        );

        return array(
            'success' => true,
            'instance_id' => $instanceId,
            'data' => $data
        );
    }
}

页面刷新请求的执行过程为:

实例运行数据发生变化运行数据持久化或版本更新前台发起数据刷新请求后端验证实例与访问权限读取最新实例运行数据重新组织展示数据返回展示数据与版本前台更新页面内容

对于持续运行的机器人、无人机和工业控制对象,还需要考虑通信中断。

在通信模式下,前台可以通过中央控制服务获取实例运行数据,但中央控制服务只能提供其当前已经取得并确认的数据。通信中断时,前台不能将中央控制端最后一次收到的数据当成现场实时状态。

在非通信模式下,智能个体可以在本地运行环境中维护自己的实例状态和展示数据。若本地存在操作界面,可以直接从本地运行引擎读取数据;如果没有通信链路,远程前台无法实时取得本地状态。通信恢复后,需要按照数据版本、时间和来源进行同步,不能简单地用中央数据覆盖本地最新运行结果。

因此,模板数据同步必须服从实例运行数据的真实性、来源和版本约束,而不是为了页面显示效果改变实际运行状态。

27.7 动态对象数据的前台输出

前面各节分别建立了智能对象属性、状态、关系、方法结果和运行变化向 Smarty 模板传递的机制。本节进一步将这些数据组织为统一的动态对象展示数据,并通过 Smarty 模板完成前台页面输出。

动态对象前台输出需要解决两个问题:一是不同智能对象具有不同结构,页面不能依赖固定字段;二是同一个智能对象可能具有不同的展示场景,需要根据页面需求组织不同的数据集合。

因此,前台输出采用动态数据组织方式。后端根据智能对象的结构定义、实例运行数据和展示配置,形成统一的数据输出对象。

可以将完整展示数据表示为:

\[ D_i^{view}= (ID_i,P_i^{view},S_i^{view},R_i^{view}, M_i^{result},V_i^{meta}) \]

其中,\(P_i^{view}\) 表示属性展示数据,\(S_i^{view}\) 表示状态展示数据,\(R_i^{view}\) 表示关系展示数据,\(M_i^{result}\) 表示方法执行结果,\(V_i^{meta}\) 表示数据版本、来源和更新时间等信息。

例如,一个工业设备实例的前台数据可以组织为:

$objectViewData = array(
    'instance' => array(
        'instance_id' => 'motor_001',
        'object_name' => '一号电机',
        'object_type' => 'industrial_motor'
    ),

    'properties' => array(
        'rated_power' => array(
            'name' => '额定功率',
            'value' => 15,
            'unit' => 'kW'
        ),
        'current_temperature' => array(
            'name' => '当前温度',
            'value' => 62.5,
            'unit' => '℃'
        )
    ),

    'state' => array(
        'state_id' => 'running',
        'state_name' => '运行中',
        'confirmed' => true
    ),

    'relations' => array(
        array(
            'relation_type' => 'belongs_to',
            'target_name' => '第一生产线'
        )
    ),

    'method_result' => array(
        'method_id' => 'start_device',
        'message' => '设备运行状态已确认',
        'confirmed' => true
    ),

    'meta' => array(
        'instance_version' => 18,
        'view_version' => 25,
        'updated_at' => '2026-11-16 15:35:00'
    )
);

这个数据结构只是某个设备实例的展示结果。其他类型的智能对象可以具有完全不同的属性、状态和关系,后端仍然可以使用相同的数据映射和 Smarty 赋值机制。

前台控制器可以这样组织数据:

$objectViewData = $objectViewService->build(
    $instanceId,
    $pageConfig,
    $userContext
);

$smarty->assign(
    'smart_object',
    $objectViewData
);

$smarty->display('object/dynamic.tpl');

Smarty 动态模板:

<div class="smart-object">

    <div class="object-header">
        <h2>
            {$smart_object.instance.object_name|escape}
        </h2>

        <span>
            {$smart_object.instance.object_type|escape}
        </span>
    </div>

    <div class="object-properties">
        {foreach $smart_object.properties as $property}
            <div class="property-item">
                <span>{$property.name|escape}</span>
                <strong>{$property.value|escape}</strong>
                <span>{$property.unit|escape}</span>
            </div>
        {/foreach}
    </div>

    <div class="object-state">
        <span>
            {$smart_object.state.state_name|escape}
        </span>

        {if !$smart_object.state.confirmed}
            <span>状态待确认</span>
        {/if}
    </div>

    <div class="object-relations">
        {foreach $smart_object.relations as $relation}
            <div class="relation-item">
                <span>
                    {$relation.relation_type|escape}
                </span>

                <span>
                    {$relation.target_name|escape}
                </span>
            </div>
        {/foreach}
    </div>

    <div class="object-method-result">
        <span>
            {$smart_object.method_result.message|escape}
        </span>
    </div>

    <div class="object-data-meta">
        <span>
            数据更新时间:
            {$smart_object.meta.updated_at|escape}
        </span>
    </div>

</div>

这里的 Smarty 模板通过统一的 smart_object 变量读取数据。属性部分采用循环结构,因此不需要为每个可能出现的智能对象属性编写固定模板字段。对于不同对象类型,可以根据展示配置选择不同的页面模板,也可以通过 Smarty 模板继承和组合复用页面结构。

动态对象输出的完整程序目录可以组织为:

WSaiOS/
└── Presentation/
    ├── DataMapping/
    │   ├── ObjectViewDataBuilder.php
    │   │   // 从实例运行上下文组织完整的前台对象数据
    │   ├── ViewFieldResolver.php
    │   │   // 根据对象结构和页面配置确定展示字段
    │   ├── ViewPermissionChecker.php
    │   │   // 检查展示字段及对象关系的读取权限
    │   ├── ViewDataFormatter.php
    │   │   // 转换属性、状态、关系和时间等展示数据
    │   └── SmartyDataAssigner.php
    │       // 将展示数据赋值给 Smarty
    │
    ├── State/
    │   └── ObjectStateViewBuilder.php
    │       // 将实例当前状态组织为前台状态数据
    │
    ├── Relation/
    │   └── ObjectRelationViewBuilder.php
    │       // 将实例关系组织为前台可读取的关系数据
    │
    ├── Synchronization/
    │   ├── ViewDataSyncService.php
    │   │   // 组织实例运行数据与前台展示数据的同步
    │   ├── ViewDataVersionManager.php
    │   │   // 管理实例数据版本和展示数据版本
    │   └── ViewDataRefreshController.php
    │       // 接收前台刷新请求并返回最新展示数据
    │
    └── Controller/
        └── ObjectViewController.php
            // 接收对象页面请求,组织展示数据并调用 Smarty

Smarty 展示模板目录则独立组织:

templates/
└── object/
    ├── dynamic.tpl
    │   // 通用动态对象展示模板
    ├── detail.tpl
    │   // 智能对象详细信息页面模板
    ├── state.tpl
    │   // 智能对象运行状态展示模板
    ├── relation.tpl
    │   // 智能对象关系展示模板
    └── components/
        ├── property_list.tpl
        │   // 对象动态属性列表组件
        ├── state_display.tpl
        │   // 对象状态展示组件
        └── relation_list.tpl
            // 对象关系展示组件

上述目录体现了后端数据映射程序和 Smarty 页面模板之间的职责分离。Presentation 目录负责读取、筛选、组织、验证和传递数据;templates/object 目录负责页面结构和数据呈现。两者通过明确的数据变量进行连接。

在实际工程中,还需要对前台输出进行数据安全处理。所有用户可见字符串应按对应输出环境进行转义;用户提交的修改请求必须重新经过后端权限、属性定义、数据类型和业务约束验证。不能因为某个字段已经在 Smarty 页面显示,就允许前台直接修改其对应的实例数据。

动态对象前台输出的整体过程如下:

智能对象实例运行读取实例运行上下文提取属性与属性值提取当前状态提取对象关系提取方法执行结果展示数据组织权限与数据有效性检查形成统一展示数据对象PHP向Smarty赋值Smarty模板解析动态页面输出

本章最终建立了智能对象运行数据与 Smarty 展示变量之间的映射关系。智能对象实例提供真实的结构化运行数据,后端数据映射程序负责按照页面需求组织数据,Smarty 负责将数据呈现为动态页面。对象属性、状态、关系和方法执行结果均可以按照统一机制传递到前台,同时通过数据版本和刷新机制保持展示内容与实例运行数据之间的关联。

这一机制使智能对象的前台页面不再依赖预先固定的对象字段。不同结构的智能对象可以使用统一的数据映射程序,根据各自的属性、状态和关系形成不同的页面内容。

第二十七章的工程逻辑可以归纳为:

\[ \boxed{ \text{智能对象运行数据} \rightarrow \text{展示数据映射} \rightarrow \text{Smarty变量} \rightarrow \text{动态页面} } \]

下一章将在此基础上研究基于 Smarty 的智能个体动态页面生成,重点解决不同智能个体如何依据自身结构和展示配置形成对应的页面结构。

Leave a Reply

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

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守