目录

---

每日一句正能量

“自己有了光芒，才配得上自己追逐的星星。”
所仰慕的“星星”（理想、榜样、目标），之所以耀眼，是因为它本身在发光。真正的“配得上”，源于自身的价值创造。

相信"版本管理是软件开发的基石"。

摘要

摘要：版本管理是软件开发的基础。本文深入探讨HarmonyOS版本管理与升级策略，从版本号规范、分支管理到自动化发布，提供HarmonyOS版本管理的完整实践方案，帮助团队建立高效的版本管理体系。

---

一、引言：为什么版本管理如此重要？

"版本号混乱，用户不知道哪个是最新版。"

"升级后出现兼容性问题，用户怨声载道。"

"回滚困难，问题无法快速修复。"

版本管理是软件开发的基础，良好的版本管理可以：

• 追踪变更：清晰记录每个版本的变更内容
• 快速回滚：在出现问题时快速回滚到稳定版本
• 协同开发：支持多团队并行开发
• 用户信任：让用户了解版本更新内容

---

二、版本号规范

2.1 语义化版本

图1：版本号规范——主版本号.次版本号.修订号

版本号	格式	说明	示例
主版本号	MAJOR	不兼容的API修改	1.0.0 → 2.0.0
次版本号	MINOR	向下兼容的功能新增	1.0.0 → 1.1.0
修订号	PATCH	向下兼容的问题修复	1.0.0 → 1.0.1
构建号	BUILD	构建标识	1.0.0.1234

2.2 版本号管理实现

// 版本号管理器
class VersionManager {
  private currentVersion: Version
  private versionHistory: Version[] = []

  constructor(version: string) {
    this.currentVersion = this.parseVersion(version)
  }

  // 解析版本号
  parseVersion(version: string): Version {
    const parts = version.split('.')
    
    return {
      major: parseInt(parts[0]) || 0,
      minor: parseInt(parts[1]) || 0,
      patch: parseInt(parts[2]) || 0,
      build: parts[3] ? parseInt(parts[3]) : undefined
    }
  }

  // 格式化版本号
  formatVersion(version: Version): string {
    let versionString = `${version.major}.${version.minor}.${version.patch}`
    
    if (version.build !== undefined) {
      versionString += `.${version.build}`
    }
    
    return versionString
  }

  // 增加主版本号
  bumpMajor(): void {
    this.currentVersion.major++
    this.currentVersion.minor = 0
    this.currentVersion.patch = 0
    this.currentVersion.build = undefined
    
    this.recordVersion()
  }

  // 增加次版本号
  bumpMinor(): void {
    this.currentVersion.minor++
    this.currentVersion.patch = 0
    this.currentVersion.build = undefined
    
    this.recordVersion()
  }

  // 增加修订号
  bumpPatch(): void {
    this.currentVersion.patch++
    this.currentVersion.build = undefined
    
    this.recordVersion()
  }

  // 比较版本号
  compareVersions(v1: Version, v2: Version): number {
    if (v1.major !== v2.major) return v1.major - v2.major
    if (v1.minor !== v2.minor) return v1.minor - v2.minor
    if (v1.patch !== v2.patch) return v1.patch - v2.patch
    
    return 0
  }

  // 检查是否为最新版本
  isLatestVersion(version: string): boolean {
    const targetVersion = this.parseVersion(version)
    
    return this.compareVersions(this.currentVersion, targetVersion) >= 0
  }

  // 记录版本
  private recordVersion(): void {
    this.versionHistory.push({ ...this.currentVersion })
  }

  // 获取当前版本
  getCurrentVersion(): string {
    return this.formatVersion(this.currentVersion)
  }

  // 获取版本历史
  getVersionHistory(): Version[] {
    return this.versionHistory
  }
}

// 版本号
interface Version {
  major: number
  minor: number
  patch: number
  build?: number
}

---

三、分支管理

3.1 分支策略

图2：分支管理——主分支、开发分支、特性分支、修复分支

分支类型	描述	命名规范	生命周期
主分支	稳定版本	main/master	长期
开发分支	日常开发	develop	长期
特性分支	新功能开发	feature/xxx	短期
修复分支	问题修复	fix/xxx	短期
发布分支	版本发布	release/xxx	短期

3.2 分支管理实现

// 分支管理器
class BranchManager {
  private branches: Branch[] = []
  private currentBranch: string = 'main'

  // 创建分支
  createBranch(name: string, baseBranch: string): Branch {
    const branch: Branch = {
      name,
      baseBranch,
      createdAt: Date.now(),
      commits: []
    }
    
    this.branches.push(branch)
    return branch
  }

  // 切换分支
  switchBranch(name: string): boolean {
    const branch = this.branches.find(b => b.name === name)
    
    if (!branch) {
      console.error(`Branch ${name} not found`)
      return false
    }
    
    this.currentBranch = name
    return true
  }

  // 合并分支
  mergeBranch(sourceBranch: string, targetBranch: string): MergeResult {
    const source = this.branches.find(b => b.name === sourceBranch)
    const target = this.branches.find(b => b.name === targetBranch)
    
    if (!source || !target) {
      return {
        success: false,
        conflicts: [],
        message: 'Branch not found'
      }
    }
    
    // 模拟合并
    const conflicts = this.detectConflicts(source, target)
    
    if (conflicts.length > 0) {
      return {
        success: false,
        conflicts,
        message: 'Merge conflicts detected'
      }
    }
    
    // 合并提交
    target.commits.push(...source.commits)
    
    return {
      success: true,
      conflicts: [],
      message: 'Merge successful'
    }
  }

  // 检测冲突
  private detectConflicts(source: Branch, target: Branch): string[] {
    const conflicts: string[] = []
    
    // 简化的冲突检测
    const sourceFiles = new Set(source.commits.flatMap(c => c.files))
    const targetFiles = new Set(target.commits.flatMap(c => c.files))
    
    for (const file of sourceFiles) {
      if (targetFiles.has(file)) {
        conflicts.push(file)
      }
    }
    
    return conflicts
  }

  // 删除分支
  deleteBranch(name: string): boolean {
    const index = this.branches.findIndex(b => b.name === name)
    
    if (index === -1) {
      return false
    }
    
    this.branches.splice(index, 1)
    return true
  }

  // 获取当前分支
  getCurrentBranch(): string {
    return this.currentBranch
  }

  // 获取所有分支
  getAllBranches(): Branch[] {
    return this.branches
  }
}

// 分支
interface Branch {
  name: string
  baseBranch: string
  createdAt: number
  commits: Commit[]
}

// 提交
interface Commit {
  id: string
  message: string
  author: string
  timestamp: number
  files: string[]
}

// 合并结果
interface MergeResult {
  success: boolean
  conflicts: string[]
  message: string
}

---

四、自动化发布

4.1 发布流程

图3：自动化发布——代码提交、构建、测试、打包、发布

阶段	描述	工具	产出
代码提交	开发者提交代码	Git	代码变更
构建	编译代码	hvigor	构建产物
测试	执行测试用例	测试框架	测试报告
打包	生成安装包	打包工具	HAP包
发布	上传到应用市场	发布工具	发布版本

4.2 自动化发布实现

// 自动化发布管理器
class ReleaseManager {
  private versionManager: VersionManager
  private branchManager: BranchManager
  private releaseHistory: Release[] = []

  constructor(versionManager: VersionManager, branchManager: BranchManager) {
    this.versionManager = versionManager
    this.branchManager = branchManager
  }

  // 创建发布
  async createRelease(releaseType: 'major' | 'minor' | 'patch'): Promise<Release> {
    // 更新版本号
    switch (releaseType) {
      case 'major':
        this.versionManager.bumpMajor()
        break
      case 'minor':
        this.versionManager.bumpMinor()
        break
      case 'patch':
        this.versionManager.bumpPatch()
        break
    }

    const version = this.versionManager.getCurrentVersion()

    // 创建发布分支
    const releaseBranch = this.branchManager.createBranch(
      `release/${version}`,
      this.branchManager.getCurrentBranch()
    )

    // 执行构建
    const buildResult = await this.build()

    // 执行测试
    const testResult = await this.test()

    // 打包
    const packageResult = await this.package()

    // 创建发布记录
    const release: Release = {
      version,
      branch: releaseBranch.name,
      buildResult,
      testResult,
      packageResult,
      createdAt: Date.now(),
      status: 'ready'
    }

    this.releaseHistory.push(release)
    return release
  }

  // 执行构建
  private async build(): Promise<BuildResult> {
    // 执行构建的实现
    return {
      success: true,
      duration: 0,
      artifacts: []
    }
  }

  // 执行测试
  private async test(): Promise<TestResult> {
    // 执行测试的实现
    return {
      success: true,
      passed: 0,
      failed: 0,
      duration: 0
    }
  }

  // 执行打包
  private async package(): Promise<PackageResult> {
    // 执行打包的实现
    return {
      success: true,
      path: '',
      size: 0
    }
  }

  // 发布版本
  async publishRelease(version: string): Promise<boolean> {
    const release = this.releaseHistory.find(r => r.version === version)
    
    if (!release) {
      console.error(`Release ${version} not found`)
      return false
    }
    
    if (release.status !== 'ready') {
      console.error(`Release ${version} is not ready`)
      return false
    }
    
    // 发布到应用市场
    const publishResult = await this.publishToMarket(release)
    
    if (publishResult) {
      release.status = 'published'
    }
    
    return publishResult
  }

  // 发布到应用市场
  private async publishToMarket(release: Release): Promise<boolean> {
    // 发布到应用市场的实现
    return true
  }

  // 获取发布历史
  getReleaseHistory(): Release[] {
    return this.releaseHistory
  }
}

// 发布
interface Release {
  version: string
  branch: string
  buildResult: BuildResult
  testResult: TestResult
  packageResult: PackageResult
  createdAt: number
  status: 'ready' | 'published' | 'archived'
}

// 构建结果
interface BuildResult {
  success: boolean
  duration: number
  artifacts: string[]
}

// 测试结果
interface TestResult {
  success: boolean
  passed: number
  failed: number
  duration: number
}

// 打包结果
interface PackageResult {
  success: boolean
  path: string
  size: number
}

---

五、升级策略

5.1 升级方式

图4：升级策略——强制升级、推荐升级、静默升级、手动升级

升级方式	描述	适用场景	用户体验
强制升级	必须升级才能使用	重大版本更新	较差
推荐升级	建议升级但不强制	功能更新	较好
静默升级	后台自动升级	修复更新	最好
手动升级	用户手动触发	可选更新	一般

5.2 升级实现

// 升级管理器
class UpgradeManager {
  private currentVersion: string
  private upgradeStrategies: Map<string, UpgradeStrategy> = new Map()

  constructor(currentVersion: string) {
    this.currentVersion = currentVersion
  }

  // 检查升级
  async checkUpgrade(): Promise<UpgradeInfo | null> {
    // 获取最新版本信息
    const latestVersion = await this.getLatestVersion()
    
    if (!latestVersion) {
      return null
    }
    
    // 比较版本号
    if (this.compareVersions(this.currentVersion, latestVersion) >= 0) {
      return null
    }
    
    // 获取升级策略
    const strategy = this.getUpgradeStrategy(latestVersion)
    
    return {
      currentVersion: this.currentVersion,
      latestVersion,
      strategy,
      downloadUrl: await this.getDownloadUrl(latestVersion)
    }
  }

  // 执行升级
  async performUpgrade(upgradeInfo: UpgradeInfo): Promise<UpgradeResult> {
    try {
      // 下载更新包
      const downloadResult = await this.downloadUpdate(upgradeInfo.downloadUrl)
      
      if (!downloadResult.success) {
        return {
          success: false,
          message: 'Download failed'
        }
      }
      
      // 验证更新包
      const verifyResult = await this.verifyUpdate(downloadResult.path)
      
      if (!verifyResult.success) {
        return {
          success: false,
          message: 'Verification failed'
        }
      }
      
      // 安装更新
      const installResult = await this.installUpdate(downloadResult.path)
      
      if (!installResult.success) {
        return {
          success: false,
          message: 'Installation failed'
        }
      }
      
      // 更新当前版本
      this.currentVersion = upgradeInfo.latestVersion
      
      return {
        success: true,
        message: 'Upgrade successful'
      }
    } catch (error) {
      return {
        success: false,
        message: error instanceof Error ? error.message : 'Unknown error'
      }
    }
  }

  // 获取最新版本
  private async getLatestVersion(): Promise<string | null> {
    // 获取最新版本的实现
    return null
  }

  // 获取升级策略
  private getUpgradeStrategy(version: string): UpgradeStrategy {
    return this.upgradeStrategies.get(version) || 'recommended'
  }

  // 获取下载地址
  private async getDownloadUrl(version: string): Promise<string> {
    // 获取下载地址的实现
    return ''
  }

  // 下载更新
  private async downloadUpdate(url: string): Promise<DownloadResult> {
    // 下载更新的实现
    return {
      success: true,
      path: ''
    }
  }

  // 验证更新
  private async verifyUpdate(path: string): Promise<VerifyResult> {
    // 验证更新的实现
    return {
      success: true
    }
  }

  // 安装更新
  private async installUpdate(path: string): Promise<InstallResult> {
    // 安装更新的实现
    return {
      success: true
    }
  }

  // 比较版本号
  private compareVersions(v1: string, v2: string): number {
    const parts1 = v1.split('.').map(Number)
    const parts2 = v2.split('.').map(Number)
    
    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
      const part1 = parts1[i] || 0
      const part2 = parts2[i] || 0
      
      if (part1 !== part2) {
        return part1 - part2
      }
    }
    
    return 0
  }
}

// 升级信息
interface UpgradeInfo {
  currentVersion: string
  latestVersion: string
  strategy: UpgradeStrategy
  downloadUrl: string
}

// 升级策略
enum UpgradeStrategy {
  FORCED = 'forced',
  RECOMMENDED = 'recommended',
  SILENT = 'silent',
  MANUAL = 'manual'
}

// 升级结果
interface UpgradeResult {
  success: boolean
  message: string
}

// 下载结果
interface DownloadResult {
  success: boolean
  path: string
}

// 验证结果
interface VerifyResult {
  success: boolean
}

// 安装结果
interface InstallResult {
  success: boolean
}

---

六、版本管理最佳实践

6.1 版本发布检查清单

在发布新版本前，确保完成以下检查：

检查项	描述	负责人	状态
代码审查	所有变更经过代码审查	开发团队	必做
测试通过	所有测试用例通过	QA团队	必做
文档更新	更新版本说明文档	产品经理	必做
兼容性测试	验证兼容性	测试团队	必做
性能测试	验证性能指标	测试团队	必做
安全审查	安全漏洞扫描	安全团队	必做
灰度发布	小范围验证	运维团队	建议
监控配置	配置监控告警	运维团队	建议

6.2 版本回滚策略

当新版本出现问题时，需要快速回滚：

// 版本回滚管理器
class RollbackManager {
  private versionManager: VersionManager
  private releaseHistory: Release[] = []

  constructor(versionManager: VersionManager) {
    this.versionManager = versionManager
  }

  // 回滚到指定版本
  async rollbackToVersion(targetVersion: string): Promise<RollbackResult> {
    // 验证目标版本是否存在
    const targetRelease = this.releaseHistory.find(r => r.version === targetVersion)
    
    if (!targetRelease) {
      return {
        success: false,
        message: `Version ${targetVersion} not found`
      }
    }

    // 执行回滚
    const rollbackResult = await this.executeRollback(targetRelease)
    
    if (rollbackResult.success) {
      // 更新当前版本
      this.versionManager = new VersionManager(targetVersion)
    }
    
    return rollbackResult
  }

  // 执行回滚
  private async executeRollback(release: Release): Promise<RollbackResult> {
    try {
      // 停止当前服务
      await this.stopService()
      
      // 恢复旧版本
      await this.restoreVersion(release)
      
      // 启动服务
      await this.startService()
      
      // 验证回滚
      const verifyResult = await this.verifyRollback(release)
      
      if (!verifyResult.success) {
        return {
          success: false,
          message: 'Rollback verification failed'
        }
      }
      
      return {
        success: true,
        message: `Successfully rolled back to version ${release.version}`
      }
    } catch (error) {
      return {
        success: false,
        message: error instanceof Error ? error.message : 'Rollback failed'
      }
    }
  }

  // 停止服务
  private async stopService(): Promise<void> {
    // 停止服务的实现
  }

  // 恢复版本
  private async restoreVersion(release: Release): Promise<void> {
    // 恢复版本的实现
  }

  // 启动服务
  private async startService(): Promise<void> {
    // 启动服务的实现
  }

  // 验证回滚
  private async verifyRollback(release: Release): Promise<VerifyResult> {
    // 验证回滚的实现
    return { success: true }
  }
}

// 回滚结果
interface RollbackResult {
  success: boolean
  message: string
}

---

七、常见问题与解决

问题	现象	原因	解决方案
版本冲突	不同模块版本不一致	依赖管理不当	统一版本管理、依赖锁定
升级失败	升级后应用无法启动	兼容性问题	兼容性测试、灰度发布
回滚困难	无法回滚到旧版本	缺少备份	版本备份、快速回滚
分支混乱	分支过多难以管理	分支策略不当	分支规范、定期清理
发布延迟	发布流程耗时久	流程复杂	自动化发布、并行执行
用户投诉	强制升级引起不满	升级策略不当	推荐升级、用户选择

---

七、结语：版本管理是软件开发的"基石"

版本管理是软件开发的"基石"：

• 版本号规范：清晰的版本号让用户了解更新内容
• 分支管理：合理的分支策略支持并行开发
• 自动化发布：自动化的发布流程提高效率
• 升级策略：灵活的升级策略提升用户体验

作为一名讲师，我在课上常说：**"好的版本管理，让软件开发像交响乐一样有序。"**

---

转载自：https://blog.csdn.net/u014727709/article/details/165126851
欢迎 👍点赞✍评论⭐收藏，欢迎指正