HarmonyOS开发：实时推荐与流式计算

核心要点：实时推荐是用户体验的"加速器"——用户刚点击了一篇科技文章，下一秒推荐列表就更新了更多科技内容。本文深入讲解HarmonyOS端侧实时推荐的实现架构，涵盖事件驱动推荐、流式特征更新、增量计算、滑动窗口统计等核心技术，并提供完整的ArkTS实战代码。

一、背景与动机

想象这样一个场景：你在新闻APP里连续点了几篇"新能源汽车"的文章，然后往下拉刷新——首页立刻变成了汽车频道。这不是魔法，这是实时推荐在工作。

传统的推荐系统是"批处理"模式：每天凌晨跑一次全量计算，更新推荐结果。但用户的兴趣是实时变化的——上午关注科技新闻，下午可能就在看美食攻略。如果推荐结果不能及时跟上用户兴趣的变化，体验就会大打折扣。

实时推荐的核心挑战在于：如何在有限的端侧算力下，实现毫秒级的推荐更新？

答案就是流式计算——不等待全量数据，而是对每一条新产生的用户行为"即时处理、即时更新"。

二、核心原理

2.1 实时推荐架构

2.2 流式计算 vs 批处理

2.3 滑动窗口统计

滑动窗口是流式计算的核心数据结构，用于统计"最近N条"或"最近N分钟"的数据特征：

时间轴: ──────────────────────────────►
              ┌──────────────┐
  旧数据 ─────│  滑动窗口    │───── 新数据进入
              │  (最近5分钟)  │
              └──────────────┘
              ↑ 窗口随时间滑动，旧数据被淘汰

2.4 兴趣漂移检测

用户的兴趣不是静态的，会随时间"漂移"。实时推荐需要检测这种漂移并及时响应：

• 短期兴趣：最近几分钟的行为模式，变化快
• 中期兴趣：最近几天的行为模式，相对稳定
• 长期兴趣：用户的基本偏好，变化缓慢

当短期兴趣与长期兴趣出现明显偏差时，说明用户正在"探索"新领域，推荐应该及时调整。

三、代码实战

3.1 事件总线与流式行为处理

先实现事件驱动的行为处理管线。

// EventBus.ets - 事件总线与流式行为处理

/**
 * 推荐事件类型
 */
export enum RecEventType {
  ITEM_VIEW = 'item_view',           // 浏览物品
  ITEM_CLICK = 'item_click',         // 点击物品
  ITEM_COLLECT = 'item_collect',     // 收藏物品
  ITEM_SHARE = 'item_share',         // 分享物品
  ITEM_DISLIKE = 'item_dislike',     // 不感兴趣
  SEARCH_QUERY = 'search_query',     // 搜索查询
  SESSION_START = 'session_start',   // 会话开始
  SESSION_END = 'session_end',       // 会话结束
  SCROLL_DEPTH = 'scroll_depth',     // 滚动深度
  DWELL_TIME = 'dwell_time',         // 停留时长
}

/**
 * 推荐事件数据结构
 */
export interface RecEvent {
  type: RecEventType
  userId: string
  itemId?: string
  data?: Record<string, Object>
  timestamp: number
}

/**
 * 事件监听器回调类型
 */
type EventListener = (event: RecEvent) => void

/**
 * 事件总线
 * 发布-订阅模式，解耦事件产生与消费
 */
export class EventBus {
  private listeners: Map<string, EventListener[]> = new Map()
  private eventQueue: RecEvent[] = []           // 事件缓冲队列
  private isProcessing: boolean = false          // 是否正在处理
  private maxQueueSize: number = 1000            // 最大队列长度
  private processingBatchSize: number = 50       // 批量处理大小

  /**
   * 订阅事件
   */
  on(eventType: string, listener: EventListener): void {
    if (!this.listeners.has(eventType)) {
      this.listeners.set(eventType, [])
    }
    this.listeners.get(eventType)!.push(listener)
  }

  /**
   * 取消订阅
   */
  off(eventType: string, listener: EventListener): void {
    const listeners = this.listeners.get(eventType)
    if (listeners) {
      const idx = listeners.indexOf(listener)
      if (idx >= 0) {
        listeners.splice(idx, 1)
      }
    }
  }

  /**
   * 发布事件
   * 事件先入缓冲队列，异步批量处理
   */
  emit(event: RecEvent): void {
    // 队列满时丢弃最旧的事件
    if (this.eventQueue.length >= this.maxQueueSize) {
      this.eventQueue.shift()
      console.warn('[EventBus] 事件队列已满，丢弃旧事件')
    }

    this.eventQueue.push({
      ...event,
      timestamp: event.timestamp || Date.now(),
    })

    // 触发异步处理
    if (!this.isProcessing) {
      this.processEvents()
    }
  }

  /**
   * 批量处理事件
   */
  private processEvents(): void {
    if (this.eventQueue.length === 0) {
      this.isProcessing = false
      return
    }

    this.isProcessing = true

    // 取出一批事件
    const batch = this.eventQueue.splice(0, this.processingBatchSize)

    // 分发事件
    for (const event of batch) {
      const listeners = this.listeners.get(event.type)
      if (listeners) {
        for (const listener of listeners) {
          try {
            listener(event)
          } catch (error) {
            console.error(`[EventBus] 事件处理异常: ${error}`)
          }
        }
      }

      // 通知通配监听器
      const wildcardListeners = this.listeners.get('*')
      if (wildcardListeners) {
        for (const listener of wildcardListeners) {
          listener(event)
        }
      }
    }

    // 继续处理剩余事件（使用setTimeout避免阻塞）
    setTimeout(() => {
      this.processEvents()
    }, 0)
  }

  /**
   * 获取队列中待处理事件数
   */
  getPendingCount(): number {
    return this.eventQueue.length
  }

  /**
   * 清空事件队列
   */
  clear(): void {
    this.eventQueue = []
    this.isProcessing = false
  }
}

3.2 滑动窗口与实时特征计算

实现滑动窗口统计和实时特征更新。

// SlidingWindow.ets - 滑动窗口与实时特征计算

import { RecEvent, RecEventType } from './EventBus'

/**
 * 滑动窗口配置
 */
export interface WindowConfig {
  windowSize: number      // 窗口大小（事件数或毫秒数）
  slideInterval: number   // 滑动间隔
  windowType: 'count' | 'time'  // 按数量或时间
}

/**
 * 窗口统计结果
 */
export interface WindowStats {
  itemCounts: Map<string, number>    // 物品出现次数
  categoryCounts: Map<string, number> // 分类出现次数
  tagScores: Map<string, number>      // 标签累计得分
  totalEvents: number                 // 总事件数
  startTime: number                   // 窗口起始时间
  endTime: number                     // 窗口结束时间
}

/**
 * 滑动窗口统计器
 * 维护一个随时间/数量滑动的窗口，实时计算统计特征
 */
export class SlidingWindowStats {
  private config: WindowConfig
  private events: RecEvent[] = []           // 窗口内的事件
  private cachedStats: WindowStats | null = null  // 缓存的统计结果
  private isDirty: boolean = true           // 是否需要重新计算

  // 物品元数据（用于查询分类和标签）
  private itemMetadata: Map<string, { category: string; tags: string[] }> = new Map()

  constructor(config: WindowConfig) {
    this.config = config
  }

  /**
   * 设置物品元数据
   */
  setItemMetadata(metadata: Map<string, { category: string; tags: string[] }>): void {
    this.itemMetadata = metadata
  }

  /**
   * 添加事件到窗口
   */
  addEvent(event: RecEvent): void {
    this.events.push(event)
    this.isDirty = true

    // 滑动窗口：移除超出窗口的旧事件
    this.evictOldEvents()
  }

  /**
   * 批量添加事件
   */
  addEvents(events: RecEvent[]): void {
    for (const event of events) {
      this.events.push(event)
    }
    this.isDirty = true
    this.evictOldEvents()
  }

  /**
   * 移除超出窗口的旧事件
   */
  private evictOldEvents(): void {
    if (this.config.windowType === 'count') {
      // 按数量：保留最近N条
      while (this.events.length > this.config.windowSize) {
        this.events.shift()
      }
    } else {
      // 按时间：保留最近N毫秒
      const cutoff = Date.now() - this.config.windowSize
      while (this.events.length > 0 && this.events[0].timestamp < cutoff) {
        this.events.shift()
      }
    }
  }

  /**
   * 获取当前窗口统计
   */
  getStats(): WindowStats {
    if (!this.isDirty && this.cachedStats) {
      return this.cachedStats
    }

    const stats: WindowStats = {
      itemCounts: new Map(),
      categoryCounts: new Map(),
      tagScores: new Map(),
      totalEvents: this.events.length,
      startTime: this.events.length > 0 ? this.events[0].timestamp : Date.now(),
      endTime: this.events.length > 0 ? this.events[this.events.length - 1].timestamp : Date.now(),
    }

    // 行为类型权重
    const behaviorWeights: Record<string, number> = {
      [RecEventType.ITEM_VIEW]: 1.0,
      [RecEventType.ITEM_CLICK]: 2.0,
      [RecEventType.ITEM_COLLECT]: 4.0,
      [RecEventType.ITEM_SHARE]: 3.5,
      [RecEventType.ITEM_DISLIKE]: -2.0,
    }

    for (const event of this.events) {
      if (!event.itemId) continue

      // 统计物品出现次数
      stats.itemCounts.set(event.itemId,
        (stats.itemCounts.get(event.itemId) || 0) + 1
      )

      // 查询物品元数据
      const meta = this.itemMetadata.get(event.itemId)
      if (meta) {
        // 统计分类
        stats.categoryCounts.set(meta.category,
          (stats.categoryCounts.get(meta.category) || 0) + 1
        )

        // 累加标签得分
        const weight = behaviorWeights[event.type] || 1.0
        for (const tag of meta.tags) {
          stats.tagScores.set(tag,
            (stats.tagScores.get(tag) || 0) + weight
          )
        }
      }
    }

    this.cachedStats = stats
    this.isDirty = false
    return stats
  }

  /**
   * 获取TopN热门标签
   */
  getTopTags(topN: number = 10): Array<{ tag: string; score: number }> {
    const stats = this.getStats()
    return Array.from(stats.tagScores.entries())
      .map(([tag, score]) => ({ tag, score }))
      .sort((a, b) => b.score - a.score)
      .slice(0, topN)
  }

  /**
   * 获取TopN热门分类
   */
  getTopCategories(topN: number = 5): Array<{ category: string; count: number }> {
    const stats = this.getStats()
    return Array.from(stats.categoryCounts.entries())
      .map(([category, count]) => ({ category, count }))
      .sort((a, b) => b.count - a.count)
      .slice(0, topN)
  }

  /**
   * 检测兴趣漂移
   * 比较短期窗口和长期窗口的标签分布差异
   */
  detectInterestDrift(longTermStats: SlidingWindowStats): {
    hasDrift: boolean
    driftScore: number
    emergingTags: string[]
    decliningTags: string[]
  } {
    const shortTags = this.getTopTags(20)
    const longTags = longTermStats.getTopTags(20)

    const shortTagMap = new Map(shortTags.map(t => [t.tag, t.score]))
    const longTagMap = new Map(longTags.map(t => [t.tag, t.score]))

    // 归一化
    const shortMax = Math.max(...shortTags.map(t => t.score), 1)
    const longMax = Math.max(...longTags.map(t => t.score), 1)

    const emergingTags: string[] = []
    const decliningTags: string[] = []
    let totalDrift = 0

    // 检测新兴兴趣
    shortTagMap.forEach((score, tag) => {
      const normalizedShort = score / shortMax
      const normalizedLong = (longTagMap.get(tag) || 0) / longMax
      const diff = normalizedShort - normalizedLong

      if (diff > 0.3) {
        emergingTags.push(tag)
      }
      totalDrift += Math.abs(diff)
    })

    // 检测衰退兴趣
    longTagMap.forEach((score, tag) => {
      const normalizedLong = score / longMax
      const normalizedShort = (shortTagMap.get(tag) || 0) / shortMax
      const diff = normalizedLong - normalizedShort

      if (diff > 0.3) {
        decliningTags.push(tag)
      }
    })

    const driftScore = totalDrift / Math.max(shortTagMap.size, 1)
    const hasDrift = driftScore > 0.5 || emergingTags.length > 2

    return { hasDrift, driftScore, emergingTags, decliningTags }
  }

  /**
   * 清空窗口
   */
  clear(): void {
    this.events = []
    this.cachedStats = null
    this.isDirty = true
  }

  /**
   * 获取窗口内事件数
   */
  size(): number {
    return this.events.length
  }
}

3.3 实时推荐引擎与UI集成

将事件总线、滑动窗口和实时推荐整合到完整的应用中。

// RealtimeRecommendationPage.ets - 实时推荐页面
import { EventBus, RecEvent, RecEventType } from './EventBus'
import { SlidingWindowStats, WindowConfig, WindowStats } from './SlidingWindowStats'

/**
 * 实时推荐结果
 */
interface RealtimeRecItem {
  itemId: string
  score: number
  reason: string
  isUrgent: boolean  // 是否为紧急推荐（兴趣漂移触发）
}

@Entry
@Component
struct RealtimeRecommendationPage {
  // 事件总线
  private eventBus: EventBus = new EventBus()
  // 短期窗口（最近50条行为）
  private shortWindow: SlidingWindowStats = new SlidingWindowStats({
    windowSize: 50, slideInterval: 1, windowType: 'count',
  })
  // 长期窗口（最近500条行为）
  private longWindow: SlidingWindowStats = new SlidingWindowStats({
    windowSize: 500, slideInterval: 10, windowType: 'count',
  })

  @State recommendations: RealtimeRecItem[] = []
  @State shortTermTags: Array<{ tag: string; score: number }> = []
  @State longTermTags: Array<{ tag: string; score: number }> = []
  @State driftInfo: string = ''
  @State eventCount: number = 0
  @State isRefreshing: boolean = false
  @State lastUpdateTime: string = ''

  // 模拟物品元数据
  private itemMetadata: Map<string, { category: string; tags: string[] }> = new Map([
    ['item_001', { category: '科技', tags: ['AI', '芯片', '半导体'] }],
    ['item_002', { category: '科技', tags: ['手机', '评测', '鸿蒙'] }],
    ['item_003', { category: '生活', tags: ['美食', '探店', '火锅'] }],
    ['item_004', { category: '科技', tags: ['编程', 'ArkTS', '开发'] }],
    ['item_005', { category: '娱乐', tags: ['电影', '科幻', '推荐'] }],
    ['item_006', { category: '生活', tags: ['旅行', '攻略', '自驾'] }],
    ['item_007', { category: '科技', tags: ['AI', '大模型', 'GPT'] }],
    ['item_008', { category: '娱乐', tags: ['音乐', '古典', '钢琴'] }],
    ['item_009', { category: '生活', tags: ['健身', '跑步', '装备'] }],
    ['item_010', { category: '科技', tags: ['编程', 'Python', '入门'] }],
  ])

  // 模拟推荐候选池
  private candidatePool: Array<{ itemId: string; baseScore: number }> = [
    { itemId: 'item_001', baseScore: 0.8 },
    { itemId: 'item_002', baseScore: 0.7 },
    { itemId: 'item_003', baseScore: 0.6 },
    { itemId: 'item_004', baseScore: 0.9 },
    { itemId: 'item_005', baseScore: 0.5 },
    { itemId: 'item_006', baseScore: 0.4 },
    { itemId: 'item_007', baseScore: 0.85 },
    { itemId: 'item_008', baseScore: 0.3 },
    { itemId: 'item_009', baseScore: 0.45 },
    { itemId: 'item_010', baseScore: 0.75 },
  ]

  aboutToAppear(): void {
    this.initEngine()
  }

  /**
   * 初始化实时推荐引擎
   */
  private initEngine(): void {
    // 设置物品元数据
    this.shortWindow.setItemMetadata(this.itemMetadata)
    this.longWindow.setItemMetadata(this.itemMetadata)

    // 订阅事件
    this.eventBus.on('*', (event: RecEvent) => {
      this.handleEvent(event)
    })

    // 订阅特定事件类型
    this.eventBus.on(RecEventType.ITEM_CLICK, (event: RecEvent) => {
      console.info(`[RealtimeRec] 用户点击: ${event.itemId}`)
    })

    this.eventBus.on(RecEventType.ITEM_DISLIKE, (event: RecEvent) => {
      console.info(`[RealtimeRec] 用户不感兴趣: ${event.itemId}`)
      // 立即从推荐列表中移除
      this.recommendations = this.recommendations.filter(
        r => r.itemId !== event.itemId
      )
    })

    console.info('[RealtimeRec] 引擎初始化完成')
  }

  /**
   * 处理用户行为事件
   */
  private handleEvent(event: RecEvent): void {
    this.eventCount++

    // 更新滑动窗口
    this.shortWindow.addEvent(event)
    this.longWindow.addEvent(event)

    // 更新标签统计
    this.shortTermTags = this.shortWindow.getTopTags(8)
    this.longTermTags = this.longWindow.getTopTags(8)

    // 检测兴趣漂移
    const drift = this.shortWindow.detectInterestDrift(this.longWindow)
    if (drift.hasDrift) {
      this.driftInfo = `检测到兴趣漂移! 新兴: ${drift.emergingTags.join(', ')}`
      console.info(`[RealtimeRec] ${this.driftInfo}`)
      // 紧急触发推荐更新
      this.refreshRecommendations(true, drift.emergingTags)
    }

    // 更新时间
    this.lastUpdateTime = new Date().toLocaleTimeString()

    // 定期刷新推荐（每10个事件刷新一次）
    if (this.eventCount % 10 === 0) {
      this.refreshRecommendations(false)
    }
  }

  /**
   * 刷新推荐列表
   */
  private refreshRecommendations(
    isUrgent: boolean = false,
    boostTags: string[] = []
  ): void {
    this.isRefreshing = true

    setTimeout(() => {
      const shortStats = this.shortWindow.getStats()
      const recentItems = new Set(
        Array.from(shortStats.itemCounts.keys())
      )

      // 计算每个候选的实时得分
      const results: RealtimeRecItem[] = []

      for (const candidate of this.candidatePool) {
        // 跳过最近已交互的物品
        if (recentItems.has(candidate.itemId)) continue

        const meta = this.itemMetadata.get(candidate.itemId)
        if (!meta) continue

        let score = candidate.baseScore
        let reason = '综合推荐'
        let urgent = false

        // 基于短期兴趣加分
        for (const tag of meta.tags) {
          const tagScore = shortStats.tagScores.get(tag) || 0
          score += tagScore * 0.1
        }

        // 兴趣漂移紧急加分
        if (isUrgent && boostTags.length > 0) {
          const matchCount = meta.tags.filter(t => boostTags.includes(t)).length
          if (matchCount > 0) {
            score += matchCount * 0.5
            reason = `兴趣漂移: ${meta.tags.filter(t => boostTags.includes(t)).join(',')}`
            urgent = true
          }
        }

        // 分类热度加分
        const categoryCount = shortStats.categoryCounts.get(meta.category) || 0
        score += categoryCount * 0.05

        results.push({
          itemId: candidate.itemId,
          score,
          reason,
          isUrgent: urgent,
        })
      }

      // 排序
      results.sort((a, b) => b.score - a.score)
      this.recommendations = results.slice(0, 8)
      this.isRefreshing = false
    }, 100)
  }

  /**
   * 模拟用户行为
   */
  private simulateBehavior(type: RecEventType, itemId: string): void {
    const event: RecEvent = {
      type,
      userId: 'user_001',
      itemId,
      timestamp: Date.now(),
    }
    this.eventBus.emit(event)
  }

  build() {
    Navigation() {
      Column() {
        // 实时状态栏
        this.StatusBar()

        // 兴趣标签对比
        this.InterestComparison()

        // 模拟行为按钮
        this.SimulationBar()

        // 推荐结果
        this.RecommendListView()
      }
      .width('100%')
      .height('100%')
      .backgroundColor('#0f0f1a')
    }
    .title('实时推荐')
    .titleMode(NavigationTitleMode.Mini)
    .navBarStyle(NavigationBarStyle.Constant)
  }

  // ======== 子组件 ========

  @Builder
  StatusBar() {
    Row() {
      Text(`事件: ${this.eventCount}`)
        .fontSize(12)
        .fontColor('#888888')

      Text(` | `)
        .fontSize(12)
        .fontColor('#444444')

      Text(`更新: ${this.lastUpdateTime || '暂无'}`)
        .fontSize(12)
        .fontColor('#888888')

      if (this.driftInfo) {
        Text(` | `)
          .fontSize(12)
          .fontColor('#444444')

        Text('⚠ 漂移')
          .fontSize(12)
          .fontColor('#D0021B')
      }
    }
    .width('100%')
    .padding({ left: 16, right: 16, top: 8, bottom: 4 })
  }

  @Builder
  InterestComparison() {
    Column() {
      // 短期兴趣
      Text('短期兴趣（最近50条行为）')
        .fontSize(12)
        .fontColor('#7B68EE')
        .margin({ bottom: 6 })

      Flex({ wrap: FlexWrap.Wrap }) {
        ForEach(this.shortTermTags, (item: { tag: string; score: number }) => {
          Text(`${item.tag} ${item.score.toFixed(1)}`)
            .fontSize(11)
            .fontColor('#E0E0E0')
            .padding({ left: 8, right: 8, top: 3, bottom: 3 })
            .borderRadius(10)
            .backgroundColor('rgba(123,104,238,0.2)')
            .margin({ right: 4, bottom: 4 })
        })
      }

      // 长期兴趣
      Text('长期兴趣（最近500条行为）')
        .fontSize(12)
        .fontColor('#F5A623')
        .margin({ top: 10, bottom: 6 })

      Flex({ wrap: FlexWrap.Wrap }) {
        ForEach(this.longTermTags, (item: { tag: string; score: number }) => {
          Text(`${item.tag} ${item.score.toFixed(1)}`)
            .fontSize(11)
            .fontColor('#E0E0E0')
            .padding({ left: 8, right: 8, top: 3, bottom: 3 })
            .borderRadius(10)
            .backgroundColor('rgba(245,166,35,0.2)')
            .margin({ right: 4, bottom: 4 })
        })
      }

      // 漂移提示
      if (this.driftInfo) {
        Text(this.driftInfo)
          .fontSize(12)
          .fontColor('#D0021B')
          .margin({ top: 8 })
          .padding(8)
          .borderRadius(8)
          .backgroundColor('rgba(208,2,27,0.1)')
      }
    }
    .width('100%')
    .padding({ left: 16, right: 16, top: 8, bottom: 8 })
  }

  @Builder
  SimulationBar() {
    Column() {
      Text('模拟用户行为（点击触发实时推荐更新）')
        .fontSize(12)
        .fontColor('#888888')
        .margin({ bottom: 8 })

      // 浏览行为
      Row() {
        Text('浏览:')
          .fontSize(12)
          .fontColor('#999999')
          .width(36)

        ForEach(['item_001', 'item_003', 'item_005', 'item_007'], (id: string) => {
          Text(id.replace('item_', '#'))
            .fontSize(12)
            .fontColor('#E0E0E0')
            .padding({ left: 8, right: 8, top: 4, bottom: 4 })
            .borderRadius(8)
            .backgroundColor('rgba(255,255,255,0.08)')
            .margin({ right: 4 })
            .onClick(() => this.simulateBehavior(RecEventType.ITEM_VIEW, id))
        })
      }
      .margin({ bottom: 6 })

      // 点击行为
      Row() {
        Text('点击:')
          .fontSize(12)
          .fontColor('#999999')
          .width(36)

        ForEach(['item_001', 'item_004', 'item_007', 'item_010'], (id: string) => {
          Text(id.replace('item_', '#'))
            .fontSize(12)
            .fontColor('#E0E0E0')
            .padding({ left: 8, right: 8, top: 4, bottom: 4 })
            .borderRadius(8)
            .backgroundColor('rgba(123,104,238,0.2)')
            .margin({ right: 4 })
            .onClick(() => this.simulateBehavior(RecEventType.ITEM_CLICK, id))
        })
      }
      .margin({ bottom: 6 })

      // 收藏行为
      Row() {
        Text('收藏:')
          .fontSize(12)
          .fontColor('#999999')
          .width(36)

        ForEach(['item_004', 'item_007'], (id: string) => {
          Text(id.replace('item_', '#'))
            .fontSize(12)
            .fontColor('#E0E0E0')
            .padding({ left: 8, right: 8, top: 4, bottom: 4 })
            .borderRadius(8)
            .backgroundColor('rgba(245,166,35,0.2)')
            .margin({ right: 4 })
            .onClick(() => this.simulateBehavior(RecEventType.ITEM_COLLECT, id))
        })
      }

      // 不感兴趣
      Row() {
        Text('不感兴趣:')
          .fontSize(12)
          .fontColor('#999999')

        ForEach(['item_008', 'item_009'], (id: string) => {
          Text(id.replace('item_', '#'))
            .fontSize(12)
            .fontColor('#E0E0E0')
            .padding({ left: 8, right: 8, top: 4, bottom: 4 })
            .borderRadius(8)
            .backgroundColor('rgba(208,2,27,0.2)')
            .margin({ left: 4 })
            .onClick(() => this.simulateBehavior(RecEventType.ITEM_DISLIKE, id))
        })
      }
      .margin({ top: 6 })
    }
    .width('100%')
    .padding({ left: 16, right: 16, top: 8, bottom: 8 })
    .borderRadius(12)
    .backgroundColor('rgba(255,255,255,0.04)')
    .margin({ left: 16, right: 16, top: 4, bottom: 4 })
  }

  @Builder
  RecommendListView() {
    Column() {
      Row() {
        Text('实时推荐结果')
          .fontSize(14)
          .fontColor('#E0E0E0')
          .fontWeight(FontWeight.Medium)

        if (this.isRefreshing) {
          LoadingProgress()
            .width(16)
            .height(16)
            .color('#7B68EE')
            .margin({ left: 8 })
        }
      }
      .margin({ bottom: 8 })
    }
    .width('100%')
    .padding({ left: 16, right: 16, top: 8 })

    List({ space: 8 }) {
      ForEach(this.recommendations, (item: RealtimeRecItem, index: number) => {
        ListItem() {
          this.RecCard(item, index + 1)
        }
      })
    }
    .width('100%')
    .layoutWeight(1)
    .padding({ left: 16, right: 16 })
  }

  @Builder
  RecCard(item: RealtimeRecItem, rank: number) {
    Row() {
      Text(`#${rank}`)
        .fontSize(14)
        .fontWeight(FontWeight.Bold)
        .fontColor(item.isUrgent ? '#D0021B' : (rank <= 3 ? '#F5A623' : '#666666'))
        .width(32)

      Column() {
        Row() {
          Text(item.itemId)
            .fontSize(15)
            .fontColor('#E0E0E0')
            .fontWeight(FontWeight.Medium)

          if (item.isUrgent) {
            Text('紧急')
              .fontSize(10)
              .fontColor('#D0021B')
              .padding({ left: 4, right: 4, top: 1, bottom: 1 })
              .borderRadius(4)
              .backgroundColor('rgba(208,2,27,0.15)')
              .margin({ left: 6 })
          }
        }

        Text(item.reason)
          .fontSize(11)
          .fontColor('#999999')
          .margin({ top: 2 })
      }
      .layoutWeight(1)
      .alignItems(HorizontalAlign.Start)

      Text(item.score.toFixed(2))
        .fontSize(14)
        .fontColor('#F5A623')
        .fontWeight(FontWeight.Medium)
    }
    .width('100%')
    .padding(12)
    .borderRadius(10)
    .backgroundColor(item.isUrgent ? 'rgba(208,2,27,0.08)' : 'rgba(255,255,255,0.06)')
    .backdropBlur(20)
  }
}

四、踩坑与注意事项

4.1 事件风暴问题

坑：用户快速滑动列表时，每秒可能产生数十个VIEW事件，导致事件队列积压、推荐计算频繁触发。

解：

• 事件防抖（debounce）：同类事件在短时间内只处理最后一次
• 事件限流（throttle）：固定时间间隔内只处理一个事件
• 事件合并：连续的VIEW事件合并为一次"浏览序列"

// 事件防抖器
class EventDebouncer {
  private timers: Map<string, number> = new Map()
  private delay: number

  constructor(delay: number = 500) {
    this.delay = delay
  }

  debounce(key: string, callback: () => void): void {
    const existingTimer = this.timers.get(key)
    if (existingTimer) {
      clearTimeout(existingTimer)
    }
    this.timers.set(key, setTimeout(() => {
      callback()
      this.timers.delete(key)
    }, this.delay) as number)
  }
}

4.2 滑动窗口内存泄漏

坑：长时间运行后，滑动窗口中的事件数组可能持续增长，导致内存占用不断增加。

解：

• 严格限制窗口大小
• 定期清理过期事件
• 使用环形缓冲区替代数组

// 环形缓冲区实现
class RingBuffer<T> {
  private buffer: (T | null)[]
  private head: number = 0
  private tail: number = 0
  private count: number = 0

  constructor(private capacity: number) {
    this.buffer = new Array(capacity).fill(null)
  }

  push(item: T): void {
    this.buffer[this.tail] = item
    this.tail = (this.tail + 1) % this.capacity
    if (this.count === this.capacity) {
      this.head = (this.head + 1) % this.capacity // 覆盖最旧
    } else {
      this.count++
    }
  }

  toArray(): T[] {
    const result: T[] = []
    for (let i = 0; i < this.count; i++) {
      const idx = (this.head + i) % this.capacity
      result.push(this.buffer[idx] as T)
    }
    return result
  }

  get size(): number {
    return this.count
  }
}

4.3 推荐结果抖动

坑：实时推荐更新太频繁，用户看到推荐列表不断变化，产生"闪烁"感。

解：

• 推荐列表更新采用"渐进式"策略，每次最多替换2-3个条目
• 新推荐项添加过渡动画
• 设置最小更新间隔（如30秒）

// 渐进式推荐更新
function mergeRecommendations(
  oldList: RealtimeRecItem[],
  newList: RealtimeRecItem[],
  maxReplace: number = 3
): RealtimeRecItem[] {
  const oldIds = new Set(oldList.map(r => r.itemId))
  const result = [...oldList]

  // 找出新增的推荐项
  const newItems = newList.filter(r => !oldIds.has(r.itemId))

  // 每次最多替换maxReplace个
  let replaceCount = 0
  for (const newItem of newItems) {
    if (replaceCount >= maxReplace) break
    // 替换得分最低的旧项
    const minIdx = result.reduce(
      (minIdx, item, idx) => item.score < result[minIdx].score ? idx : minIdx,
      0
    )
    result[minIdx] = newItem
    replaceCount++
  }

  // 重新排序
  result.sort((a, b) => b.score - a.score)
  return result
}

4.4 上下文感知缺失

坑：推荐只考虑用户历史行为，忽略了当前上下文（时间、地点、设备状态等）。

解：

• 融合时间上下文：不同时段推荐不同类型内容
• 融合设备状态：低电量时减少刷新频率
• 融合网络状态：离线时使用缓存推荐

// 上下文感知推荐
interface RecContext {
  hour: number          // 当前小时
  dayOfWeek: number     // 星期几
  isWeekend: boolean    // 是否周末
  batteryLevel: number  // 电量百分比
  networkType: string   // 网络类型
}

function adjustByContext(
  items: RealtimeRecItem[],
  context: RecContext
): RealtimeRecItem[] {
  return items.map(item => {
    let adjustedScore = item.score

    // 时间上下文：夜间推荐轻松内容
    if (context.hour >= 22 || context.hour < 6) {
      // 降低工作类内容权重
      if (item.reason.includes('编程') || item.reason.includes('开发')) {
        adjustedScore *= 0.7
      }
    }

    // 低电量时降低非核心内容权重
    if (context.batteryLevel < 20) {
      adjustedScore *= 0.8
    }

    return { ...item, score: adjustedScore }
  }).sort((a, b) => b.score - a.score)
}

4.5 离线场景处理

坑：用户离线时无法获取云端推荐数据，推荐列表为空。

解：

• 预缓存推荐结果到本地
• 离线时使用端侧推荐引擎
• 网络恢复后自动同步更新

五、HarmonyOS 6适配

5.1 版本差异

5.2 迁移指南

1. 跨设备事件同步

HarmonyOS 6支持跨设备实时同步用户行为事件：

// HarmonyOS 6 跨设备事件同步（概念代码）
import { distributedHardware } from '@kit.DistributedHardwareKit'

// 监听分布式设备上的行为事件
distributedHardware.on('event', (event: RecEvent) => {
  this.eventBus.emit(event)
  console.info(`[RealtimeRec] 收到跨设备事件: ${event.type}`)
})

2. 环境感知推荐

HarmonyOS 6新增环境感知能力，可以获取更丰富的上下文信息：

// HarmonyOS 6 环境感知（概念代码）
import { sensor } from '@kit.SensorServiceKit'

// 光线传感器：判断室内/室外
sensor.on(sensor.SensorType.LIGHT, (data) => {
  const isIndoor = data.intensity < 100
  // 室外场景推荐不同内容
})

// 运动传感器：判断静止/运动
sensor.on(sensor.SensorType.ACCELEROMETER, (data) => {
  const isMoving = Math.abs(data.x) + Math.abs(data.y) + Math.abs(data.z) > 20
  // 运动中推荐短内容
})

3. 长时后台计算

HarmonyOS 6增强了长时后台任务，可以在后台持续运行推荐计算：

// HarmonyOS 6 长时后台任务
import { backgroundTaskManager } from '@kit.BackgroundTasksKit'

async function startBackgroundRecommendation(): Promise<void> {
  const request: backgroundTaskManager.ContinuousTaskRequest = {
    bgMode: backgroundTaskManager.BackgroundMode.DATA_TRANSFER,
    wantAgent: wantAgentObj,
  }
  await backgroundTaskManager.startBackgroundRunning(request)
  // 在后台持续运行推荐计算
}

六、总结

本文完整实现了HarmonyOS端侧的实时推荐系统，核心知识点回顾：

核心要点回顾：

1. ⚡ 事件驱动是实时推荐的骨架，发布-订阅模式解耦事件产生与消费
2. 🪟 滑动窗口是流式计算的核心，按数量或时间维护动态统计
3. 🔄 兴趣漂移检测让推荐系统具备"感知力"，及时发现用户新兴趣
4. 🚨 紧急推荐机制在检测到兴趣漂移时立即响应，不等定时刷新
5. 🎯 防抖+限流+渐进更新三大策略，避免推荐结果抖动
6. 📱 HarmonyOS 6的跨设备同步和环境感知，让实时推荐更智能

下一篇我们将深入推荐效果评估与A/B测试，讲解如何科学地衡量推荐系统的效果。