基于 HarmonyOS 的 AI 学习计划生成应用开发实践——从对齐到评估的全流程技术解析

一、对齐阶段（Align）：从模糊需求到精确规范

1.1 项目上下文分析

在 HarmonyOS 生态快速发展的背景下，AI 应用正成为鸿蒙生态中不可或缺的重要组成部分。"AI 学习计划生成"应用是一个典型的 AI 驱动的工具型应用，旨在帮助用户通过智能化的方式生成个性化的学习计划。本项目基于 HarmonyOS 的 ArkTS 语言和 ArkUI 框架进行开发，遵循标准的鸿蒙应用开发规范。

在开始任何编码工作之前，我们首先对项目上下文进行了全面分析。项目根目录位于 c:\Users\l\DevEcoStudioProjects\MyApplication，这是一个标准的 HarmonyOS 应用工程，采用 entry 模块结构。通过检查 module.json5 配置文件，可以看到应用配置了 EntryAbility 作为主入口，支持 phone 设备类型，使用标准的能力（Ability）生命周期管理。

1.2 需求理解与边界确认

原始需求

用户需要一个能够生成个性化学习计划的 AI 应用。用户输入学习科目、学习目标和可用时间，应用通过 AI 能力生成结构化的学习计划，包括学习阶段划分、每日计划、推荐资源、里程碑和复习安排。

核心功能边界

经过分析，我们确认了以下功能边界：

1. 输入规范：用户提供三个关键输入——科目（subject）、目标（goal）、可用时间（available time），这些输入通过 ArkUI 的 TextInput 组件收集。
2. 输出规范：AI 生成的结构化学习计划，包含 phases（学习阶段）、daily_plan（每日计划）、resources（学习资源）、milestones（里程碑）等核心字段。
3. 技术边界：目前使用 Mock 数据模拟 AI 生成结果，未来可接入真实的大模型 API。
4. UI 边界：采用黑板风格的深绿色主题，模拟教室黑板视觉效果，营造学习氛围。

1.3 项目特性规范

根据 HarmonyOS 应用开发规范和 ArkTS 语法约束，我们制定了以下项目特性规范：

• 语言版本：使用 ArkTS（基于 TypeScript 的鸿蒙静态类型语言），遵循其严格的语法约束
• UI 框架：ArkUI 声明式 UI，使用 @Component 和 @State 装饰器驱动数据绑定
• 架构模式：MVVM 三层架构（Model-Service-View）
• 数据流：单向数据流，用户输入 → Service 处理 → State 更新 → UI 重新渲染
• 路由管理：使用 router 模块进行页面间导航
• 资源管理：遵循 HarmonyOS 资源管理规范，通过 $r 引用资源文件

1.4 关键决策与疑问澄清

在需求分析过程中，我们遇到了几个关键决策点：

Q1：是否直接接入大模型 API？
A：考虑到开发阶段和调试便利性，决定先使用 Mock 数据实现完整的 UI 交互流程，后续再对接真实的大模型 API。这样可以确保 UI 层的完整性和正确性，避免因 API 调用不稳定影响开发进度。

Q2：数据模型设计的粒度如何？
A：根据 AI 学习计划生成的特点，我们需要支持层级化的数据结构。学习计划包含多个阶段（phases），每个阶段包含每日计划（daily_plan），同时需要独立的资源推荐（resources）和里程碑（milestones）信息。因此，数据模型设计为扁平化的类结构，通过数组字段存储列表数据。

Q3：UI 主题风格如何选择？
A：为了与"学习计划"的主题匹配，选择了黑板风格的深绿色（#1B5E20）作为主色调，搭配黄色（#FFD600）作为强调色，模拟教室黑板的视觉效果。这种设计不仅符合应用场景，也能给用户带来沉浸式的学习体验。

1.5 达成共识

经过以上分析，我们最终生成了共识文档，明确了以下关键点：

• 需求描述清晰：AI 学习计划生成应用，输入科目、目标、时间，输出结构化学习计划
• 验收标准明确：完整的输入-输出流程，Mock 数据可正常展示，UI 交互流畅
• 技术方案确定：ArkTS + ArkUI，MVVM 三层架构，黑板风格主题
• 任务边界清晰：本次开发聚焦于前端 UI 和数据流，不涉及后端 API 对接

二、架构阶段（Architect）：从系统架构到模块设计

2.1 整体架构设计

基于共识文档，我们设计了 “AI 学习计划生成” 应用的完整架构。该应用采用 HarmonyOS 标准的 MVVM 架构模式，将代码划分为三个核心层次：

┌─────────────────────────────────────────────┐
│              View 层（UI 表现层）              │
│   AI学习计划生成Page.ets                     │
│   - 输入表单（科目/目标/时间）               │
│   - 结果展示（阶段/计划/资源/里程碑）         │
│   - @State 驱动数据绑定                      │
└──────────────────┬──────────────────────────┘
                   │ 调用
┌──────────────────▼──────────────────────────┐
│            Service 层（业务逻辑层）            │
│   AI学习计划生成Service.ets                  │
│   - generateData() 方法                      │
│   - Mock 数据生成逻辑                        │
│   - 未来对接大模型 API                       │
└──────────────────┬──────────────────────────┘
                   │ 实例化
┌──────────────────▼──────────────────────────┐
│            Model 层（数据模型层）              │
│   AI学习计划生成Model.ets                    │
│   - AI学习计划生成Data 类                    │
│   - 数据结构定义（phases/daily_plan等）       │
└─────────────────────────────────────────────┘

2.2 分层设计与核心组件

Model 层（数据模型层）

Model 层是整个应用的数据基础，定义了 AI学习计划生成Data 类。这个类包含了学习计划所需的所有字段，涵盖了学习阶段、每日计划、学习资源、里程碑等四个主要维度。

// AI学习计划生成Model.ets
export class AI学习计划生成Data {
  // 学习阶段相关
  phases: string[] = []       // 阶段列表
  phase: string = ''          // 当前阶段名称
  days: string = ''           // 天数范围
  goal: string = ''           // 阶段目标
  focus: string = ''          // 重点内容

  // 每日计划相关
  daily_plan: string[] = []   // 每日计划列表
  time: string = ''           // 学习时段
  task: string = ''           // 具体任务
  method: string = ''         // 学习方法
  duration: string = ''       // 学习时长

  // 学习资源相关
  resources: string[] = []    // 资源列表
  type: string = ''           // 资源类型
  name: string = ''           // 资源名称
  reason: string = ''         // 推荐原因

  // 复习与里程碑相关
  review_schedule: string = '' // 复习安排
  milestones: string[] = []   // 里程碑列表
  day: string = ''            // 里程碑天数
  milestone: string = ''      // 里程碑名称
  check: string = ''          // 检验方式

  constructor() {
    // 初始化所有字段，确保空值安全
    this.phases = []
    this.phase = ''
    this.days = ''
    this.goal = ''
    this.focus = ''
    this.daily_plan = []
    this.time = ''
    this.task = ''
    this.method = ''
    this.duration = ''
    this.resources = []
    this.type = ''
    this.name = ''
    this.reason = ''
    this.review_schedule = ''
    this.milestones = []
    this.day = ''
    this.milestone = ''
    this.check = ''
  }
}

该数据模型设计的亮点在于：

1. 字段全覆盖：涵盖了学习计划的所有关键维度，确保展示的完整性
2. 空值安全：在构造函数中显式初始化所有字段，避免运行时出现 undefined 错误
3. 数组支持：使用 string[] 类型存储列表数据，配合 ForEach 组件进行列表渲染
4. 扁平化设计：虽然是扁平结构，但通过字段命名约定（如 phases/phase, daily_plan/time/task 等）实现了逻辑上的层级关系

Service 层（业务逻辑层）

Service 层封装了 AI 数据生成的核心业务逻辑，是连接 View 层和 Model 层的桥梁。

// AI学习计划生成Service.ets
import { AI学习计划生成Data } from './AI学习计划生成Model'

export class AI学习计划生成Service {
  private model: AI学习计划生成Data

  constructor() {
    this.model = new AI学习计划生成Data()
  }

  // 生成AI学习计划生成数据
  generateData(input: Record<string, Object>): AI学习计划生成Data {
    let result: AI学习计划生成Data = new AI学习计划生成Data()
    // Mock data generation based on input
    let subjectVal: string = String(input['subject'] || '')

    result.phases = ['示例数据1', '示例数据2', '示例数据3']
    result.daily_plan = ['示例数据1', '示例数据2', '示例数据3']
    result.resources = ['示例数据1', '示例数据2', '示例数据3']
    result.review_schedule = '生成结果：' + subjectVal
    result.milestones = ['示例数据1', '示例数据2', '示例数据3']
    return result
  }
}

Service 层的关键设计考量：

1. 依赖注入就绪：generateData 方法接收 Record<string, Object> 类型参数，这种设计便于未来替换为真实的大模型 API 调用
2. Mock 数据隔离：所有 Mock 数据集中在 Service 层，未来切换为真实 API 时只需修改 Service 层，View 层无需改动
3. 类型安全：输入参数使用 Record<string, Object> 而非 any，符合 ArkTS 不支持 any 类型的语法约束
4. 可扩展性：预留了 private model 字段，便于后续添加缓存、状态管理等复杂逻辑

View 层（UI 表现层）

View 层使用 ArkUI 声明式 UI 框架，通过 @State 装饰器驱动数据绑定，实现响应式 UI 更新。

// AI学习计划生成Page.ets（核心结构）
@Entry
@Component
struct AI学习计划生成Page {
  @State inputData: Record<string, Object> = {}
  @State resultData: AI学习计划生成Data | null = null
  @State showResult: boolean = false
  private service: AI学习计划生成Service = new AI学习计划生成Service()

  build() {
    Column() {
      // 黑板Header
      Row() {
        Text('← 返回')
          .fontSize(13)
          .fontColor('#E8F5E9')
          .onClick(() => { router.back() })
        Blank()
        // 标题区域
        Text('📱 AI学习计划生成')
          .fontSize(18)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFFFFF')
        Blank()
        Text('📋').fontSize(22)
      }
      .width('100%')
      .padding({ left: 20, right: 20, top: 16, bottom: 14 })
      .backgroundColor('#1B5E20')

      Scroll() {
        Column() {
          // 输入区域与结果展示区域
          // ...
        }
      }
    }
    .width('100%').height('100%')
    .backgroundColor('#1B5E20')
  }
}

View 层的设计遵循以下原则：

1. 声明式 UI：使用 @Component 装饰器定义组件，组件结构通过 build() 方法声明
2. 状态驱动：使用 @State 装饰器标记响应式状态变量，状态变化自动触发 UI 重新渲染
3. 条件渲染：通过 if (this.showResult && this.resultData !== null) 控制结果区域的显示与隐藏
4. 列表渲染：使用 ForEach 组件遍历数组数据，生成列表项
5. 样式统一：通过链式调用设置组件的字体、颜色、间距等样式属性

2.3 数据流向设计

应用的数据流严格遵循单向数据流原则，确保数据变化可预测、可追踪：

用户输入（TextInput onChange）
    │
    ▼
inputData 状态更新
    │
    ▼
点击"开始学习"按钮（onClick）
    │
    ▼
调用 service.generateData(inputData)
    │
    ▼
返回 AI学习计划生成Data 实例
    │
    ▼
更新 resultData 和 showResult 状态
    │
    ▼
ArkUI 自动重新渲染，展示结果

这种单向数据流的设计优势在于：

• 可预测性：数据变化路径清晰，便于调试和问题定位
• 可测试性：每个环节都可以独立测试
• 性能优化：ArkUI 框架可以精确追踪状态变化，只重新渲染受影响的组件

2.4 异常处理策略

在 ArkTS 的语法约束下，我们制定了以下异常处理策略：

1. 空值保护：所有数据字段在构造函数中初始化默认值，避免空指针异常
2. 类型转换安全：在 Service 层使用 String(input['subject'] || '') 确保类型转换安全
3. 条件渲染保护：在 View 层使用 if (this.resultData !== null) 确保在数据准备好之前不渲染结果区域
4. 数组迭代保护：使用 if (this.resultData.phases) 检查数组是否存在，避免 ForEach 遍历空值

三、原子化阶段（Atomize）：将任务分解为可管理的原子任务

3.1 任务分解

在架构设计完成后，我们将整个开发任务分解为以下 6 个原子任务，每个任务都有明确的输入、输出和验收标准：

原子任务 1：创建 Model 数据模型

输入：需求文档中的数据结构定义
输出：AI学习计划生成Model.ets 文件
验收标准：

• 定义 AI学习计划生成Data 类
• 包含 phases、daily_plan、resources、milestones 等核心字段
• 所有字段在构造函数中初始化
• 遵循 ArkTS 语法约束（不支持 any 类型、不支持解构赋值等）

技术要点：

• 使用 export class 导出类，符合 ArkTS 模块化规范
• 所有字段使用显式类型标注，避免使用 any 或 unknown
• 数组类型使用 string[] 语法
• 构造函数中显式初始化所有字段

原子任务 2：实现 Service 服务层

输入：AI学习计划生成Data 模型类
输出：AI学习计划生成Service.ets 文件
验收标准：

• 定义 AI学习计划生成Service 类
• 实现 generateData 方法，接收输入参数并返回数据
• 使用 Mock 数据填充返回结果
• 遵循 ArkTS 语法约束

技术要点：

• 使用 import 语句导入 Model 类，所有 import 语句必须在文件开头
• 方法返回类型必须显式声明（ArkTS 不支持仅基于返回类型的泛型推断）
• 输入参数使用 Record<string, Object> 类型，这是 ArkTS 支持的键值对类型

原子任务 3：构建 Page 页面 UI

输入：UI 设计稿、Model 类、Service 类
输出：AI学习计划生成Page.ets 文件
验收标准：

• 使用 @Entry 和 @Component 装饰器定义页面组件
• 包含输入表单（科目、目标、可用时间）
• 包含"开始学习"按钮
• 包含结果展示区域（阶段、计划、资源、里程碑）
• 黑板风格主题（深绿色背景、黄色强调色）
• 使用 @State 驱动数据绑定

技术要点：

• 使用 TextInput 组件收集用户输入
• 使用 Button 组件触发数据生成
• 使用 ForEach 组件遍历数组数据
• 使用 Scroll 组件实现内容滚动
• 使用 router.back() 实现页面返回导航

原子任务 4：注册路由配置

输入：Page 页面文件路径
输出：路由配置文件更新
验收标准：

• 在 main_pages.json 中注册页面路由
• 页面路径指向 AI学习计划生成Page.ets

原子任务 5：集成到应用列表

输入：路由配置
输出：应用列表入口更新
验收标准：

• 在应用主列表中添加 “AI学习计划生成” 入口
• 点击入口可正确导航到 AI学习计划生成页面

原子任务 6：UI 测试与验证

输入：完整的页面实现
输出：测试报告
验收标准：

• 输入表单可正常编辑
• 点击按钮可生成并展示结果
• 返回按钮可正常导航回上一页
• 页面在不同屏幕尺寸下显示正常

3.2 任务依赖关系

原子任务 1（Model）
    │
    ▼
原子任务 2（Service）── 依赖 Model
    │
    ▼
原子任务 3（Page）── 依赖 Model + Service
    │
    ├──► 原子任务 4（路由）── 依赖 Page
    │
    └──► 原子任务 5（集成）── 依赖 路由
              │
              ▼
         原子任务 6（测试）

3.3 每个原子任务的实现细节

原子任务 1 的实现细节

在实现 AI学习计划生成Data 类时，我们特别注意了 ArkTS 的语法约束：

• 不支持 any 类型：所有字段都使用具体的 string 或 string[] 类型
• 不支持解构赋值：在构造函数中逐字段初始化，而不是使用解构语法
• 不支持在构造函数中声明类字段：所有字段声明在类声明内部，构造函数只做赋值操作
• 不支持 as const 断言：不使用字面量类型断言，而是使用显式类型标注

原子任务 2 的实现细节

Service 层的 generateData 方法目前使用 Mock 数据，但设计上已经为未来对接真实 AI 大模型做好了准备：

// 未来对接真实大模型 API 的示例代码
// 只需修改 Service 层，View 层无需任何改动
generateData(input: Record<string, Object>): AI学习计划生成Data {
  let result: AI学习计划生成Data = new AI学习计划生成Data()
  
  // 获取输入参数
  let subject: string = String(input['subject'] || '')
  let goal: string = String(input['goal'] || '')
  let time: string = String(input['time'] || '')
  
  // 调用大模型 API（未来实现）
  // const aiResponse = await this.callAIModel(subject, goal, time)
  // result = this.parseAIResponse(aiResponse)
  
  // 当前使用 Mock 数据
  result.phases = ['示例数据1', '示例数据2', '示例数据3']
  // ...
  
  return result
}

原子任务 3 的实现细节

Page 页面的 UI 实现包含了几个关键的技术点：

输入表单的实现：
每个输入字段都使用 TextInput 组件，并绑定 onChange 事件来更新 inputData 状态。这里需要注意，ArkTS 不支持通过索引访问对象字段（obj["field"]），但 Record<string, Object> 类型是例外，它支持通过索引访问。

结果展示的实现：
结果展示区域使用条件渲染（if 语句）控制显示，结合 ForEach 组件实现列表数据的遍历展示。ArkTS 中的 ForEach 组件需要提供键值生成函数，这里使用索引作为键值：

ForEach(this.resultData.phases, (item: string, index: number) => {
  Row() {
    Text('• ').fontSize(12).fontColor('#666666')
    Text(item).fontSize(12).fontColor('#333333')
  }
  .width('100%')
  .padding({ top: 2, bottom: 2 })
}, (item: string, index: number) => index.toString())

主题样式的实现：
黑板风格的主题通过在根 Column 组件上设置 backgroundColor('#1B5E20') 实现，搭配黄色（#FFD600）作为强调色，模拟了教室黑板的视觉效果。

四、审批阶段（Approve）：成果审核与质量把控

4.1 代码审查要点

在审批阶段，我们对每个原子任务的产出进行了严格的代码审查，重点关注以下几个方面：

4.1.1 ArkTS 语法合规性审查

由于 ArkTS 是静态类型语言，与标准 TypeScript 存在诸多语法差异，我们逐项检查了以下约束：

检查项	状态	说明
不支持 any 类型	✅ 通过	所有变量使用具体类型
不支持解构赋值	✅ 通过	使用逐字段赋值
不支持 Function.bind	✅ 通过	使用传统 OOP 风格
不支持 in 运算符	✅ 通过	使用 instanceof 替代
import 语句在文件开头	✅ 通过	所有 import 在文件顶部
不支持 # 私有标识符	✅ 通过	使用 private 关键字
不支持 is 运算符	✅ 通过	使用 instanceof 替代
不支持索引访问对象字段	✅ 通过	使用 Record 类型索引（例外场景）

4.1.2 架构合规性审查

• MVVM 三层架构：验证 Model、Service、View 三层职责清晰，无跨层调用
• 单向数据流：验证数据从 View → Service → Model → View 的流向正确
• 模块间依赖：验证 Page 依赖 Service 和 Model，Service 依赖 Model，Model 无外部依赖

4.1.3 性能审查

• 渲染性能：使用 Scroll 组件包裹内容区域，确保大量内容时可滚动
• 状态管理：@State 装饰器仅用于直接影响 UI 的状态变量，避免不必要的状态更新
• 列表渲染：ForEach 组件使用索引作为键值，确保列表项更新的效率

4.2 验收标准确认

我们对照共识文档中的验收标准，逐项确认：

1. 输入功能完整：✅ 用户可以通过三个 TextInput 分别输入科目、目标和可用时间
2. 数据生成功能：✅ 点击"开始学习"按钮后，调用 Service 生成数据
3. 结果展示完整：✅ 结果区域展示学习阶段、每日计划、学习资源、里程碑等全部信息
4. UI 主题一致：✅ 黑板风格深绿色主题，全局样式统一
5. 导航功能正常：✅ 返回按钮可正常导航回上一页
6. 代码无编译错误：✅ 遵循 ArkTS 所有语法约束

4.3 安全性审查

在安全性方面，我们重点关注了以下问题：

1. 输入验证：虽然当前使用 Mock 数据，但 Service 层的 generateData 方法对输入参数做了空值保护（String(input['subject'] || '')）
2. 数据隔离：用户输入数据仅用于内存中的业务处理，不涉及持久化存储，降低数据泄露风险
3. 无敏感信息：应用不涉及用户隐私数据采集，符合最小权限原则

4.4 设计评审

在审批阶段，我们还对整体设计进行了评审：

设计优点：

• 黑板主题与学习计划的应用场景高度契合，用户体验一致
• 三层架构职责清晰，便于后续扩展和维护
• 组件化设计，输入区域和结果展示区域独立，便于单侧测试

改进建议：

• 后续可增加加载状态（Loading）动画，提升数据生成过程中的用户体验
• 可考虑增加输入校验（如科目不能为空），提升数据质量
• 结果展示区域可增加折叠/展开功能，优化长内容的浏览体验

五、自动化执行阶段（Automate）：自动化代码生成与执行

5.1 自动化脚本设计

在自动化执行阶段，我们设计了代码生成脚本，用于自动化生成 AI 学习计划生成应用的完整代码骨架。自动化脚本的核心逻辑如下：

5.1.1 Model 自动生成

Model 层的自动生成逻辑基于数据结构的元数据定义，通过模板引擎生成完整的类代码：

// 自动化生成 Model 的模板逻辑（伪代码）
const modelFields = [
  { name: 'phases', type: 'string[]', desc: '阶段列表' },
  { name: 'phase', type: 'string', desc: '当前阶段' },
  { name: 'days', type: 'string', desc: '天数范围' },
  { name: 'goal', type: 'string', desc: '阶段目标' },
  { name: 'focus', type: 'string', desc: '重点内容' },
  { name: 'daily_plan', type: 'string[]', desc: '每日计划列表' },
  { name: 'time', type: 'string', desc: '学习时段' },
  { name: 'task', type: 'string', desc: '具体任务' },
  { name: 'method', type: 'string', desc: '学习方法' },
  { name: 'duration', type: 'string', desc: '学习时长' },
  { name: 'resources', type: 'string[]', desc: '资源列表' },
  { name: 'type', type: 'string', desc: '资源类型' },
  { name: 'name', type: 'string', desc: '资源名称' },
  { name: 'reason', type: 'string', desc: '推荐原因' },
  { name: 'review_schedule', type: 'string', desc: '复习安排' },
  { name: 'milestones', type: 'string[]', desc: '里程碑列表' },
  { name: 'day', type: 'string', desc: '里程碑天数' },
  { name: 'milestone', type: 'string', desc: '里程碑名称' },
  { name: 'check', type: 'string', desc: '检验方式' },
]

// 生成类声明和构造函数
let classCode = 'export class AI学习计划生成Data {\n'
for (const field of modelFields) {
  classCode += `  ${field.name}: ${field.type} = ${getDefaultValue(field.type)}\n`
}
classCode += '\n  constructor() {\n'
for (const field of modelFields) {
  classCode += `    this.${field.name} = ${getDefaultValue(field.type)}\n`
}
classCode += '  }\n}\n'

5.1.2 Service 自动生成

Service 层的自动生成逻辑基于标准化的服务模板：

// 自动化生成 Service 的模板
const serviceCode = `import { ${modelName}Data } from './${modelName}Model'

export class ${modelName}Service {
  private model: ${modelName}Data

  constructor() {
    this.model = new ${modelName}Data()
  }

  generateData(input: Record<string, Object>): ${modelName}Data {
    let result: ${modelName}Data = new ${modelName}Data()
    // Mock data generation
    result.phases = ['示例数据1', '示例数据2', '示例数据3']
    result.daily_plan = ['示例数据1', '示例数据2', '示例数据3']
    result.resources = ['示例数据1', '示例数据2', '示例数据3']
    result.review_schedule = '生成结果：' + String(input['subject'] || '')
    result.milestones = ['示例数据1', '示例数据2', '示例数据3']
    return result
  }
}`

5.1.3 Page 自动生成

Page 层的自动生成最为复杂，需要生成完整的 ArkUI 组件代码，包括输入表单、按钮和结果展示区域：

// 自动化生成 Page 的模板结构
const pageCode = `import { ${modelName}Data } from './${modelName}Model'
import { ${modelName}Service } from './${modelName}Service'
import { router } from '@kit.ArkUI'

@Entry
@Component
struct ${modelName}Page {
  @State inputData: Record<string, Object> = {}
  @State resultData: ${modelName}Data | null = null
  @State showResult: boolean = false
  private service: ${modelName}Service = new ${modelName}Service()

  build() {
    Column() {
      // Header 区域
      Row() {
        Text('← 返回').onClick(() => { router.back() })
        // ... 标题
      }
      
      Scroll() {
        Column() {
          // 输入区域
          // 按钮
          // 结果展示区域
        }
      }
    }
  }
}`

5.2 自动化构建流程

整个自动化构建流程包括以下几个步骤：

步骤 1：项目初始化

# 创建应用目录结构
mkdir -p entry/src/main/ets/apps/AI学习计划生成

步骤 2：代码生成

# 运行代码生成脚本，生成 Model、Service、Page 三个文件
# 生成 AI学习计划生成Model.ets
# 生成 AI学习计划生成Service.ets
# 生成 AI学习计划生成Page.ets

步骤 3：路由配置
在 main_pages.json 中添加页面路由配置，注册新生成的页面路径。

步骤 4：应用集成
在主应用列表中添加 AI学习计划生成 的入口，配置导航跳转。

步骤 5：编译验证

# 使用 HarmonyOS SDK 编译验证
hvigorw assembleHap

5.3 自动化测试

为了确保代码质量，我们还设计了自动化测试方案：

单元测试

// Model 层单元测试
describe('AI学习计划生成Data', () => {
  it('应该正确初始化所有字段', () => {
    const data = new AI学习计划生成Data()
    expect(data.phases).toEqual([])
    expect(data.phase).toEqual('')
    expect(data.daily_plan).toEqual([])
    // ... 验证所有字段
  })
})

// Service 层单元测试
describe('AI学习计划生成Service', () => {
  it('应该根据输入生成数据', () => {
    const service = new AI学习计划生成Service()
    const input: Record<string, Object> = {
      'subject': '数学',
      'goal': '掌握微积分',
      'time': '每天2小时'
    }
    const result = service.generateData(input)
    expect(result.phases).toBeDefined()
    expect(result.phases.length).toBeGreaterThan(0)
    expect(result.review_schedule).toContain('数学')
  })
})

UI 交互测试

// UI 组件测试
describe('AI学习计划生成Page', () => {
  it('应该正确渲染输入表单', () => {
    // 验证三个 TextInput 组件存在
    // 验证"开始学习"按钮存在
  })
  
  it('点击按钮后应该展示结果区域', () => {
    // 模拟输入
    // 模拟点击按钮
    // 验证结果区域显示
  })
})

5.4 自动化部署

在部署阶段，我们使用 HarmonyOS 的 hvigor 构建工具进行自动化打包：

# 清理构建缓存
hvigorw clean

# 构建 HAP 包
hvigorw assembleHap

# 构建 App 包（用于应用市场发布）
hvigorw assembleApp

构建完成后，生成的 HAP 包可以直接安装到 HarmonyOS 设备或模拟器上进行测试验证。

六、评估阶段（Assess）：全流程回顾与经验总结

6.1 技术亮点总结

6.1.1 架构设计亮点

MVVM 三层架构的纯正实践：
本应用严格遵循了 MVVM 架构模式，Model、Service、View 三层职责清晰、边界明确。View 层只负责 UI 渲染和事件响应，所有业务逻辑集中在 Service 层，数据模型独立于 UI 表现。这种架构