HarmonyOS APP开发：网络能耗优化与请求策略

📌 核心要点：深入理解网络请求的能耗模型，掌握请求合并、数据压缩、智能缓存与网络状态自适应策略，实现网络通信的功耗与效率双重优化。

一、背景与动机

你知道手机最耗电的组件是什么吗？不是CPU，不是屏幕，而是——射频模块。

每次你的应用发起网络请求，手机的基带芯片就要"醒来"，与基站建立连接，调制射频信号，发送和接收数据，然后再"睡去"。这个过程极其耗电——一次简单的HTTP请求，射频模块的能耗可能相当于CPU全速运行数秒。

更糟糕的是，很多应用的网络行为极其"碎片化"：刚请求完用户信息，又请求配置数据，再请求消息列表……短短几秒内发起了十几个请求，射频模块被反复唤醒，每次只传输少量数据。这就像一个人每隔5分钟就要跑一趟超市买一样东西——来回的油耗远超购物本身的价值。

网络能耗优化的核心思想是：减少请求次数、增大单次传输量、利用缓存避免重复请求、根据网络状态自适应调整策略。

本文将带你从网络能耗模型出发，系统掌握HarmonyOS中的网络能耗优化技术。

二、核心原理

2.1 网络请求能耗模型

flowchart TB
    A[网络请求能耗] --> B[射频唤醒<br/>约40%]
    A --> C[数据传输<br/>约35%]
    A --> D[连接建立<br/>约15%]
    A --> E[协议开销<br/>约10%]
    
    B --> B1[基带芯片激活]
    B --> B2[射频信号发射]
    B --> B3[功率放大器]
    
    C --> C1[上行数据传输]
    C --> C2[下行数据传输]
    C --> C3[重传与纠错]
    
    D --> D1[DNS解析]
    D --> D2[TCP三次握手]
    D --> D3[TLS握手]
    
    E --> E1[HTTP头部]
    E --> E2[Cookie/Token]
    E --> E3[分片与重组]
    
    classDef mainStyle fill:#E74C3C,stroke:#C0392B,color:#fff,font-weight:bold
    classDef wakeStyle fill:#3498DB,stroke:#2980B9,color:#fff
    classDef transferStyle fill:#2ECC71,stroke:#27AE60,color:#fff
    classDef connectStyle fill:#F39C12,stroke:#E67E22,color:#fff
    classDef overheadStyle fill:#9B59B6,stroke:#8E44AD,color:#fff
    
    class A mainStyle
    class B,B1,B2,B3 wakeStyle
    class C,C1,C2,C3 transferStyle
    class D,D1,D2,D3 connectStyle
    class E,E1,E2,E3 overheadStyle

2.2 不同网络类型的能耗差异

关键洞察：WiFi的每比特能耗远低于蜂窝网络。在WiFi可用时优先使用WiFi，可以显著降低网络功耗。

2.3 网络请求的能耗公式

单次请求能耗 ≈ 射频唤醒能耗 + 连接建立能耗 + 数据传输能耗
             = K_wake + K_connect × (1 + TLS) + K_transfer × data_size

其中：

• K_wake：射频唤醒的固定能耗（约50-100mJ）
• K_connect：连接建立的固定能耗（TCP约20mJ，TLS额外约30mJ）
• K_transfer：每字节的传输能耗（WiFi约0.5μJ/B，4G约2μJ/B）

优化方向：减少请求次数（降低K_wake和K_connect的总和）、增大单次数据量（摊薄固定开销）、使用WiFi（降低K_transfer）。

三、代码实战

3.1 基础示例：请求合并与批处理

// request_batcher.ets - 网络请求合并与批处理
import { http } from '@kit.NetworkKit'

// 批量请求配置
interface BatchConfig {
  maxBatchSize: number         // 最大批量大小
  batchIntervalMs: number      // 批处理间隔（毫秒）
  maxWaitTimeMs: number        // 最大等待时间（毫秒）
  enableCompression: boolean   // 启用压缩
}

// 单个请求项
interface RequestItem {
  id: string                   // 请求ID
  url: string                  // 请求URL
  method: http.RequestMethod   // 请求方法
  headers: Record<string, string>  // 请求头
  data?: Object                // 请求体
  resolve: (result: http.HttpResponse) => void  // 成功回调
  reject: (error: Error) => void                  // 失败回调
}

// 网络请求批处理器
class NetworkRequestBatcher {
  private queue: RequestItem[] = []
  private batchTimer: number = -1
  private config: BatchConfig
  private isInFlight: boolean = false
  private requestCount: number = 0
  private batchCount: number = 0

  constructor(config?: Partial<BatchConfig>) {
    this.config = {
      maxBatchSize: 10,
      batchIntervalMs: 500,
      maxWaitTimeMs: 2000,
      enableCompression: true,
      ...config
    }
  }

  // 发起请求（加入批量队列）
  request(
    url: string,
    method: http.RequestMethod = http.RequestMethod.GET,
    data?: Object,
    headers?: Record<string, string>
  ): Promise<http.HttpResponse> {
    return new Promise((resolve, reject) => {
      const item: RequestItem = {
        id: `req_${++this.requestCount}`,
        url: url,
        method: method,
        headers: headers || {},
        data: data,
        resolve: resolve,
        reject: reject
      }

      this.queue.push(item)
      this.requestCount++

      // 如果队列达到最大批量大小，立即执行
      if (this.queue.length >= this.config.maxBatchSize) {
        this.flush()
        return
      }

      // 否则设置定时器等待更多请求
      this.scheduleFlush()
    })
  }

  // 调度批量执行
  private scheduleFlush(): void {
    if (this.batchTimer !== -1) return

    this.batchTimer = setTimeout(() => {
      this.flush()
    }, this.config.batchIntervalMs)
  }

  // 执行批量请求
  private async flush(): Promise<void> {
    if (this.batchTimer !== -1) {
      clearTimeout(this.batchTimer)
      this.batchTimer = -1
    }

    if (this.queue.length === 0 || this.isInFlight) return

    this.isInFlight = true
    const batch = this.queue.splice(0, this.config.maxBatchSize)
    this.batchCount++

    console.info(`批量执行 ${batch.length} 个请求 (第${this.batchCount}批)`)

    // 尝试合并为批量接口
    if (this.canMergeRequests(batch)) {
      await this.executeMergedBatch(batch)
    } else {
      // 无法合并，逐个执行但使用同一个HTTP连接
      await this.executeSequentialBatch(batch)
    }

    this.isInFlight = false

    // 如果队列中还有请求，继续处理
    if (this.queue.length > 0) {
      this.scheduleFlush()
    }
  }

  // 检查是否可以合并请求
  private canMergeRequests(batch: RequestItem[]): boolean {
    // 检查是否所有请求都指向同一个API域名
    const domains = new Set(batch.map(r => new URL(r.url).hostname))
    return domains.size === 1 && batch.every(r => r.method === http.RequestMethod.GET)
  }

  // 执行合并的批量请求
  private async executeMergedBatch(batch: RequestItem[]): Promise<void> {
    try {
      // 将多个GET请求合并为一个批量查询接口
      const baseUrl = batch[0].url.split('?')[0]
      const params = batch.map(r => {
        const urlObj = new URL(r.url)
        return Object.fromEntries(urlObj.searchParams)
      })

      const batchUrl = `${baseUrl}/batch`
      const httpRequest = http.createHttp()

      const response = await httpRequest.request(batchUrl, {
        method: http.RequestMethod.POST,
        header: {
          'Content-Type': 'application/json',
          'Accept-Encoding': this.config.enableCompression ? 'gzip' : 'identity'
        },
        extraData: { requests: params }
      })

      // 分发响应
      if (response.responseCode === 200) {
        const results = JSON.parse(response.result as string) as Object[]
        batch.forEach((item, index) => {
          if (results[index]) {
            item.resolve({
              ...response,
              result: results[index]
            } as http.HttpResponse)
          } else {
            item.reject(new Error('批量响应中缺少对应结果'))
          }
        })
      } else {
        batch.forEach(item => item.reject(new Error(`HTTP ${response.responseCode}`)))
      }

      httpRequest.destroy()
    } catch (error) {
      batch.forEach(item => item.reject(error as Error))
    }
  }

  // 顺序执行批量请求（使用连接复用）
  private async executeSequentialBatch(batch: RequestItem[]): Promise<void> {
    const httpRequest = http.createHttp()

    for (const item of batch) {
      try {
        const response = await httpRequest.request(item.url, {
          method: item.method,
          header: {
            ...item.headers,
            'Accept-Encoding': this.config.enableCompression ? 'gzip' : 'identity'
          },
          extraData: item.data
        })
        item.resolve(response)
      } catch (error) {
        item.reject(error as Error)
      }
    }

    httpRequest.destroy()
  }

  // 获取统计信息
  getStats(): Record<string, number> {
    return {
      totalRequests: this.requestCount,
      totalBatches: this.batchCount,
      avgBatchSize: this.batchCount > 0 ? this.requestCount / this.batchCount : 0,
      pendingRequests: this.queue.length
    }
  }
}

3.2 进阶示例：智能缓存与网络状态自适应

// smart_network.ets - 智能缓存与网络状态自适应
import { http } from '@kit.NetworkKit'
import { connection } from '@kit.NetworkKit'
import { preferences } from '@kit.ArkData'
import { buffer } from '@kit.ArkTS'

// 缓存策略
interface CachePolicy {
  maxAge: number               // 最大缓存时间（秒）
  staleWhileRevalidate: number // 过期后仍可使用的时间（秒）
  maxEntries: number           // 最大缓存条目数
  maxStorageKB: number         // 最大存储大小（KB）
}

// 缓存条目
interface CacheEntry {
  key: string                  // 缓存键
  data: string                 // 缓存数据
  timestamp: number            // 缓存时间
  etag: string                 // ETag标识
  maxAge: number               // 最大有效期
  size: number                 // 数据大小
}

// 网络状态
interface NetworkStatus {
  type: connection.NetType     // 网络类型
  isWifi: boolean              // 是否WiFi
  isCellular: boolean          // 是否蜂窝
  signalStrength: number       // 信号强度（0-100）
  isMetered: boolean           // 是否计费网络
}

// 智能网络管理器
class SmartNetworkManager {
  private cache: Map<string, CacheEntry> = new Map()
  private cachePolicy: CachePolicy
  private currentNetwork: NetworkStatus | null = null
  private requestBatcher: NetworkRequestBatcher
  private prefStore: preferences.Preferences | null = null

  constructor(cachePolicy?: Partial<CachePolicy>) {
    this.cachePolicy = {
      maxAge: 300,               // 默认5分钟
      staleWhileRevalidate: 60,  // 过期后仍可使用1分钟
      maxEntries: 200,
      maxStorageKB: 5120,        // 最大5MB
      ...cachePolicy
    }

    this.requestBatcher = new NetworkRequestBatcher({
      maxBatchSize: 5,
      batchIntervalMs: 300,
      enableCompression: true
    })

    // 监听网络状态变化
    this.monitorNetworkStatus()
  }

  // 智能请求：根据网络状态和缓存策略决定请求方式
  async smartRequest(
    url: string,
    options?: {
      method?: http.RequestMethod
      data?: Object
      headers?: Record<string, string>
      cacheMaxAge?: number       // 自定义缓存时间
      forceRefresh?: boolean     // 强制刷新
    }
  ): Promise<http.HttpResponse> {
    const method = options?.method || http.RequestMethod.GET
    const cacheMaxAge = options?.cacheMaxAge || this.cachePolicy.maxAge
    const forceRefresh = options?.forceRefresh || false

    // GET请求优先使用缓存
    if (method === http.RequestMethod.GET && !forceRefresh) {
      const cached = this.getFromCache(url)
      if (cached) {
        const age = (Date.now() - cached.timestamp) / 1000

        // 缓存未过期，直接返回
        if (age < cacheMaxAge) {
          console.info(`缓存命中: ${url}`)
          return this.createCachedResponse(cached)
        }

        // 缓存过期但在staleWhileRevalidate窗口内，先返回旧数据再后台刷新
        if (age < cacheMaxAge + this.cachePolicy.staleWhileRevalidate) {
          console.info(`缓存过期但可用，后台刷新: ${url}`)
          this.backgroundRefresh(url, cacheMaxAge)
          return this.createCachedResponse(cached)
        }
      }
    }

    // 根据网络状态调整请求策略
    const adaptedOptions = this.adaptToNetworkStatus(url, options)

    // 使用批处理器发起请求
    const response = await this.requestBatcher.request(
      adaptedOptions.url,
      adaptedOptions.method,
      adaptedOptions.data,
      adaptedOptions.headers
    )

    // 缓存成功的GET响应
    if (method === http.RequestMethod.GET && response.responseCode === 200) {
      this.saveToCache(url, response)
    }

    return response
  }

  // 根据网络状态调整请求
  private adaptToNetworkStatus(
    url: string,
    options?: {
      method?: http.RequestMethod
      data?: Object
      headers?: Record<string, string>
    }
  ): { url: string; method: http.RequestMethod; data?: Object; headers: Record<string, string> } {
    const headers: Record<string, string> = { ...options?.headers }

    if (!this.currentNetwork) {
      return { url, method: options?.method || http.RequestMethod.GET, data: options?.data, headers }
    }

    // WiFi环境：正常请求
    if (this.currentNetwork.isWifi) {
      headers['Accept-Encoding'] = 'gzip'
      return { url, method: options?.method || http.RequestMethod.GET, data: options?.data, headers }
    }

    // 蜂窝网络：压缩传输、减少数据量
    if (this.currentNetwork.isCellular) {
      headers['Accept-Encoding'] = 'gzip'
      headers['X-Network-Type'] = 'cellular'

      // 请求低质量图片（如果支持）
      if (url.includes('/image/') || url.includes('/avatar/')) {
        url = url + (url.includes('?') ? '&' : '?') + 'quality=low'
      }

      return { url, method: options?.method || http.RequestMethod.GET, data: options?.data, headers }
    }

    // 无网络：返回缓存或错误
    return { url, method: options?.method || http.RequestMethod.GET, data: options?.data, headers }
  }

  // 从缓存获取
  private getFromCache(url: string): CacheEntry | null {
    return this.cache.get(url) || null
  }

  // 保存到缓存
  private saveToCache(url: string, response: http.HttpResponse): void {
    const data = typeof response.result === 'string' ? response.result : JSON.stringify(response.result)
    const etag = response.header?.['etag'] as string || ''

    // 检查缓存容量
    if (this.cache.size >= this.cachePolicy.maxEntries) {
      this.evictOldest()
    }

    this.cache.set(url, {
      key: url,
      data: data,
      timestamp: Date.now(),
      etag: etag,
      maxAge: this.cachePolicy.maxAge,
      size: data.length
    })
  }

  // 后台刷新缓存
  private backgroundRefresh(url: string, maxAge: number): void {
    // 使用低优先级请求刷新缓存
    this.requestBatcher.request(url).then(response => {
      if (response.responseCode === 200) {
        this.saveToCache(url, response)
        console.info(`后台刷新成功: ${url}`)
      }
    }).catch(error => {
      console.warn(`后台刷新失败: ${url}`, error)
    })
  }

  // 创建缓存响应
  private createCachedResponse(entry: CacheEntry): http.HttpResponse {
    return {
      responseCode: 200,
      result: entry.data,
      header: {
        'x-cache': 'HIT',
        'x-cache-age': String(Math.floor((Date.now() - entry.timestamp) / 1000))
      }
    } as http.HttpResponse
  }

  // 淘汰最旧的缓存
  private evictOldest(): void {
    let oldest: CacheEntry | null = null
    this.cache.forEach(entry => {
      if (!oldest || entry.timestamp < oldest.timestamp) {
        oldest = entry
      }
    })
    if (oldest) {
      this.cache.delete(oldest.key)
    }
  }

  // 监听网络状态
  private monitorNetworkStatus(): void {
    try {
      const netConnection = connection.createNetConnection()
      
      netConnection.on('netAvailable', (netHandle) => {
        this.updateNetworkStatus(netHandle)
      })

      netConnection.on('netLost', () => {
        this.currentNetwork = null
        console.info('网络已断开')
      })

      netConnection.on('netCapabilitiesChange', (netHandle) => {
        this.updateNetworkStatus(netHandle)
      })

      netConnection.register(() => {})
    } catch (e) {
      console.warn('网络状态监听初始化失败')
    }
  }

  // 更新网络状态
  private updateNetworkStatus(netHandle: connection.NetHandle): void {
    try {
      const capabilities = connection.getNetCapabilities(netHandle)
      this.currentNetwork = {
        type: capabilities?.bearerTypes?.[0] || connection.NetType.UNKNOWN,
        isWifi: capabilities?.bearerTypes?.includes(connection.NetType.WIFI) || false,
        isCellular: capabilities?.bearerTypes?.includes(connection.NetType.CELLULAR) || false,
        signalStrength: 80,  // 简化，实际应从系统获取
        isMetered: !capabilities?.bearerTypes?.includes(connection.NetType.WIFI)
      }
      console.info(`网络状态更新: ${this.currentNetwork.isWifi ? 'WiFi' : '蜂窝'}`)
    } catch (e) {
      console.warn('获取网络能力失败')
    }
  }

  // 清除缓存
  clearCache(): void {
    this.cache.clear()
  }

  // 获取缓存统计
  getCacheStats(): Record<string, number> {
    let totalSize = 0
    this.cache.forEach(entry => totalSize += entry.size)
    return {
      entries: this.cache.size,
      totalSizeKB: Math.floor(totalSize / 1024),
      hitRate: 0  // 需要额外统计
    }
  }
}

3.3 完整示例：低功耗网络策略

// low_power_network.ets - 低功耗网络策略
import { http } from '@kit.NetworkKit'
import { batteryInfo } from '@ohos.batteryInfo'

// 低功耗网络策略配置
interface LowPowerNetworkConfig {
  // 请求节流
  minRequestInterval: number       // 最小请求间隔（毫秒）
  maxRequestsPerMinute: number     // 每分钟最大请求数
  // 数据压缩
  requestCompression: boolean      // 请求体压缩
  responseMinification: boolean    // 响应精简
  // 延迟策略
  deferNonCritical: boolean        // 延迟非关键请求
  deferUntilWifi: boolean          // 延迟到WiFi可用
  deferUntilCharging: boolean      // 延迟到充电时
  // 缓存策略
  aggressiveCache: boolean         // 激进缓存
  offlineMode: boolean             // 离线模式
}

// 请求优先级
enum RequestPriority {
  CRITICAL = 0,    // 关键：登录、支付
  HIGH = 1,        // 高：核心数据
  NORMAL = 2,      // 普通：列表数据
  LOW = 3,         // 低：预加载
  BACKGROUND = 4   // 后台：统计上报
}

// 低功耗网络管理器
class LowPowerNetworkManager {
  private config: LowPowerNetworkConfig
  private deferredRequests: DeferredRequest[] = []
  private lastRequestTime: number = 0
  private requestCountInWindow: number = 0
  private windowStartTime: number = Date.now()

  constructor(config?: Partial<LowPowerNetworkConfig>) {
    this.config = {
      minRequestInterval: 1000,
      maxRequestsPerMinute: 30,
      requestCompression: true,
      responseMinification: true,
      deferNonCritical: true,
      deferUntilWifi: false,
      deferUntilCharging: false,
      aggressiveCache: false,
      offlineMode: false,
      ...config
    }

    // 根据电量自动调整策略
    this.adaptToBatteryLevel()
  }

  // 根据电量调整策略
  private adaptToBatteryLevel(): void {
    const level = batteryInfo.batterySOC

    if (level <= 10) {
      // 极低电量：最激进优化
      this.config.minRequestInterval = 10000
      this.config.maxRequestsPerMinute = 5
      this.config.deferNonCritical = true
      this.config.deferUntilWifi = true
      this.config.aggressiveCache = true
    } else if (level <= 20) {
      // 低电量
      this.config.minRequestInterval = 5000
      this.config.maxRequestsPerMinute = 10
      this.config.deferNonCritical = true
      this.config.aggressiveCache = true
    } else if (level <= 50) {
      // 中等电量
      this.config.minRequestInterval = 2000
      this.config.maxRequestsPerMinute = 20
      this.config.deferNonCritical = false
    } else {
      // 电量充足
      this.config.minRequestInterval = 500
      this.config.maxRequestsPerMinute = 60
      this.config.deferNonCritical = false
      this.config.aggressiveCache = false
    }
  }

  // 执行低功耗请求
  async request(
    url: string,
    priority: RequestPriority = RequestPriority.NORMAL,
    options?: {
      method?: http.RequestMethod
      data?: Object
      headers?: Record<string, string>
    }
  ): Promise<http.HttpResponse | null> {
    // 检查是否应该延迟请求
    if (this.shouldDeferRequest(priority)) {
      this.deferRequest(url, priority, options)
      return null
    }

    // 检查请求频率限制
    if (!this.checkRateLimit()) {
      if (priority <= RequestPriority.HIGH) {
        // 关键请求等待后执行
        await this.waitForRateLimit()
      } else {
        this.deferRequest(url, priority, options)
        return null
      }
    }

    // 检查最小间隔
    const timeSinceLastRequest = Date.now() - this.lastRequestTime
    if (timeSinceLastRequest < this.config.minRequestInterval) {
      await new Promise(resolve => 
        setTimeout(resolve, this.config.minRequestInterval - timeSinceLastRequest)
      )
    }

    // 执行请求
    try {
      const httpRequest = http.createHttp()
      const headers: Record<string, string> = {
        ...options?.headers,
        'Accept-Encoding': this.config.requestCompression ? 'gzip' : 'identity'
      }

      const response = await httpRequest.request(url, {
        method: options?.method || http.RequestMethod.GET,
        header: headers,
        extraData: options?.data
      })

      this.lastRequestTime = Date.now()
      this.requestCountInWindow++

      httpRequest.destroy()
      return response
    } catch (error) {
      console.error(`请求失败: ${url}`, error)
      return null
    }
  }

  // 检查是否应该延迟请求
  private shouldDeferRequest(priority: RequestPriority): boolean {
    // 离线模式：延迟所有请求
    if (this.config.offlineMode) return true

    // 关键请求不延迟
    if (priority <= RequestPriority.CRITICAL) return false

    // 非关键请求在低电量时延迟
    if (this.config.deferNonCritical && priority >= RequestPriority.LOW) {
      return true
    }

    // 延迟到WiFi
    if (this.config.deferUntilWifi && priority >= RequestPriority.NORMAL) {
      // 实际应检查当前是否WiFi
      return true
    }

    // 延迟到充电
    if (this.config.deferUntilCharging && priority >= RequestPriority.BACKGROUND) {
      const isCharging = batteryInfo.chargingStatus === batteryInfo.BatteryChargeState.ENABLE
      return !isCharging
    }

    return false
  }

  // 延迟请求
  private deferRequest(
    url: string,
    priority: RequestPriority,
    options?: { method?: http.RequestMethod; data?: Object; headers?: Record<string, string> }
  ): void {
    this.deferredRequests.push({
      url: url,
      priority: priority,
      options: options,
      createdAt: Date.now()
    })
    console.info(`请求已延迟: ${url}, 优先级: ${priority}`)
  }

  // 检查频率限制
  private checkRateLimit(): boolean {
    const now = Date.now()
    // 每分钟重置计数器
    if (now - this.windowStartTime > 60000) {
      this.requestCountInWindow = 0
      this.windowStartTime = now
    }
    return this.requestCountInWindow < this.config.maxRequestsPerMinute
  }

  // 等待频率限制解除
  private async waitForRateLimit(): Promise<void> {
    const waitTime = 60000 - (Date.now() - this.windowStartTime)
    if (waitTime > 0) {
      await new Promise(resolve => setTimeout(resolve, waitTime))
      this.requestCountInWindow = 0
      this.windowStartTime = Date.now()
    }
  }

  // 执行延迟的请求（充电或WiFi可用时调用）
  async executeDeferredRequests(): Promise<void> {
    if (this.deferredRequests.length === 0) return

    // 按优先级排序
    this.deferredRequests.sort((a, b) => a.priority - b.priority)

    const requests = [...this.deferredRequests]
    this.deferredRequests = []

    for (const req of requests) {
      await this.request(req.url, req.priority, req.options)
    }

    console.info(`已执行 ${requests.length} 个延迟请求`)
  }

  // 获取统计信息
  getStats(): Record<string, number> {
    return {
      deferredCount: this.deferredRequests.length,
      requestCountInWindow: this.requestCountInWindow,
      maxRequestsPerMinute: this.config.maxRequestsPerMinute
    }
  }
}

// 延迟请求
interface DeferredRequest {
  url: string
  priority: RequestPriority
  options?: { method?: http.RequestMethod; data?: Object; headers?: Record<string, string> }
  createdAt: number
}

四、踩坑与注意事项

坑点1：请求合并导致响应延迟

批处理的本质是"等待更多请求一起发送"，这意味着单个请求的响应时间会增加。如果你的应用对某些请求的响应时间要求很高（如搜索建议），不应该将它们放入批处理队列。关键请求应该绕过批处理器，直接发送。

坑点2：缓存数据不一致

激进缓存策略可能导致用户看到过期数据。比如用户修改了个人资料，但缓存中还是旧数据。写操作（POST/PUT/DELETE）成功后，必须主动清除相关缓存，确保下次读取时获取最新数据。

坑点3：网络状态监听消耗电量

频繁查询网络状态本身也会消耗电量。connection.createNetConnection()的回调机制是事件驱动的，不会持续轮询，但如果你在回调中执行了复杂的逻辑，仍然会增加功耗。网络状态回调中只做轻量操作，如更新状态变量。

坑点4：压缩与解压缩的CPU开销

启用gzip压缩可以减少网络传输量，但压缩和解压缩需要CPU计算。对于小数据包（<1KB），压缩可能反而增加总能耗——因为CPU压缩的能耗大于节省的传输能耗。仅对大于1KB的请求/响应启用压缩。

坑点5：延迟请求在应用退出时丢失

如果应用被用户关闭或被系统杀死，延迟队列中的请求就会丢失。对于重要的写操作（如数据上报），不应该延迟执行，或者在应用退出前将延迟队列持久化到本地存储。

坑点6：HTTP/2与HTTP/1.1的连接复用差异

HTTP/2原生支持多路复用，一个连接可以同时传输多个请求，天然适合"减少连接数"的优化目标。但HTTP/1.1需要使用管道化（pipelining）或连接池来实现类似效果。如果你的服务端支持HTTP/2，优先使用HTTP/2，可以减少连接建立的开销。

坑点7：忽略DNS解析的能耗

DNS解析是网络请求的"隐藏成本"——每次解析都需要向DNS服务器发送查询，消耗射频能量。使用DNS预解析和DNS缓存，减少重复解析的次数。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. HTTP/3支持：HarmonyOS 6的网络栈支持HTTP/3（基于QUIC协议），连接建立更快、传输更高效，特别适合弱网环境。

2. 系统DNS缓存：系统级DNS缓存自动管理，应用无需手动实现DNS缓存，减少了重复解析的能耗。

3. 网络功耗统计：新增应用级网络功耗统计API，可以查询应用的网络流量和对应的功耗估算。

适配代码

// HarmonyOS 6 HTTP/3与网络功耗统计
import { http } from '@kit.NetworkKit'
import { powerStats } from '@ohos.powerStats'

// 使用HTTP/3（自动协商）
async function requestWithHttp3(): Promise<void> {
  const httpRequest = http.createHttp()
  
  // HarmonyOS 6自动协商HTTP/3
  const response = await httpRequest.request('https://api.example.com/data', {
    method: http.RequestMethod.GET,
    // 启用HTTP/3优先协商
    httpProtocol: http.HttpProtocol.HTTP3,
    header: {
      'Accept-Encoding': 'gzip, br'  // 支持Brotli压缩
    }
  })
  
  httpRequest.destroy()
}

// 查询网络功耗统计
async function queryNetworkPowerStats(): Promise<void> {
  try {
    // HarmonyOS 6新增：应用级网络功耗统计
    const stats = powerStats.getNetworkPowerStats()
    console.info(`网络流量: ${stats.totalBytes}bytes`)
    console.info(`WiFi流量: ${stats.wifiBytes}bytes`)
    console.info(`蜂窝流量: ${stats.cellularBytes}bytes`)
    console.info(`预估网络功耗: ${stats.estimatedPowerMah}mAh`)
  } catch (error) {
    console.error('查询网络功耗统计失败:', error)
  }
}

六、总结

三维度评价表

网络能耗优化是"积少成多"的优化——单次请求节省的能耗可能微不足道，但一天几十次、一个月上千次的请求，累积起来就是显著的电量节省。建议在项目中建立网络请求审计机制：定期检查请求频率、数据量、缓存命中率，确保网络行为始终在最优状态。每减少一次不必要的请求，就是为用户的电量做了一次贡献。