135-1821-9792

Go这样设置版本号：我们的项目也可以

大家好，我是 polarisxu。

为平顺等地区用户提供了全套网页设计制作服务，及平顺网站建设行业解决方案。主营业务为网站建设、成都网站设计、平顺网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

项目中，特别是开源项目，会特别重视项目的版本号。有些项目，会把版本号写入源码中，每次升级都修改源码号。不过这不是特别好的方式。本文通过学习 Go 语言源码的处理方式来掌握它，并应用于自己的项目中。

本文基于 Go1.17，不同版本的实现细节可能有所不同

01 如何获取版本号

在 Go 语言项目中，如果要获取当前 Go 语言版本，只需要调用 runtime.Version：

 
 
 
    
  
  
  
  1. package main
    2. 
  
  
  
  2. 
  
  
  
  3. import (
    4. 
  
  
  
  4.  "fmt"
    5. 
  
  
  
  5.  "runtime"
    6. 
  
  
  
  6. )
    7. 
  
  
  
  7. 
  
  
  
  8. func main() {
    9. 
  
  
  
  9.  fmt.Println("Go Version:", runtime.Version())
    10. 
  
  
  
  10. }
    11.

02 如何实现的

查看 runtime.Version 的源码：

 
 
 
    
  
  
  
  1. // buildVersion is the Go tree's version string at build time.
    2. 
  
  
  
  2. //
    3. 
  
  
  
  3. // If any GOEXPERIMENTs are set to non-default values, it will include
    4. 
  
  
  
  4. // "X:".
    5. 
  
  
  
  5. //
    6. 
  
  
  
  6. // This is set by the linker.
    7. 
  
  
  
  7. //
    8. 
  
  
  
  8. // This is accessed by "go version ".
    9. 
  
  
  
  9. var buildVersion string
    10. 
  
  
  
  10. 
  
  
  
  11. // Version returns the Go tree's version string.
    12. 
  
  
  
  12. // It is either the commit hash and date at the time of the build or,
    13. 
  
  
  
  13. // when possible, a release tag like "go1.3".
    14. 
  
  
  
  14. func Version() string {
    15. 
  
  
  
  15.  return buildVersion
    16. 
  
  
  
  16. }\
    17.

根据注释提示，在 Go 仓库源码中，找到 src/cmd/link，这是 Go 链接器的实现。在其中的 internal/ld/main.go 文件找到了如下代码：

 
 
 
    
  
  
  
  1. buildVersion := buildcfg.Version
    2. 
  
  
  
  2. if goexperiment := buildcfg.GOEXPERIMENT(); goexperiment != "" {
    3. 
  
  
  
  3.   buildVersion += " X:" + goexperiment
    4. 
  
  
  
  4. }
    5. 
  
  
  
  5. addstrdata1(ctxt, "runtime.buildVersion="+buildVersion)
    6.

buildVersion 值从 buildcfg.Version 获取，如果设置了 GOEXPERIMENT(环境变量值)，则用该值。

着重看 buildcfg.Version 如何得到的：

 
 
 
    
  
  
  
  1. var (
    2. 
  
  
  
  2.  defaultGOROOT string // set by linker
    3. 
  
  
  
  3. 
  
  
  
  4.  GOROOT   = envOr("GOROOT", defaultGOROOT)
    5. 
  
  
  
  5.  GOARCH   = envOr("GOARCH", defaultGOARCH)
    6. 
  
  
  
  6.  GOOS     = envOr("GOOS", defaultGOOS)
    7. 
  
  
  
  7.  GO386    = envOr("GO386", defaultGO386)
    8. 
  
  
  
  8.  GOARM    = goarm()
    9. 
  
  
  
  9.  GOMIPS   = gomips()
    10. 
  
  
  
  10.  GOMIPS64 = gomips64()
    11. 
  
  
  
  11.  GOPPC64  = goppc64()
    12. 
  
  
  
  12.  GOWASM   = gowasm()
    13. 
  
  
  
  13.  GO_LDSO  = defaultGO_LDSO
    14. 
  
  
  
  14.  Version  = version
    15. 
  
  
  
  15. )
    16.

很奇怪，Version 的值，直接用 version 赋值的。但 version 的值是什么?在 src/cmd/dist/buildruntime.go 文件中，有一个函数 mkbuildcfg，用于生成 buildcfg：

 
 
 
    
  
  
  
  1. // mkbuildcfg writes internal/buildcfg/zbootstrap.go:
    2. 
  
  
  
  2. //
    3. 
  
  
  
  3. // package buildcfg
    4. 
  
  
  
  4. //
    5. 
  
  
  
  5. // const defaultGOROOT = 
    6. 
  
  
  
  6. // const defaultGO386 = 
    7. 
  
  
  
  7. // ...
    8. 
  
  
  
  8. // const defaultGOOS = runtime.GOOS
    9. 
  
  
  
  9. // const defaultGOARCH = runtime.GOARCH
    10. 
  
  
  
  10. //
    11. 
  
  
  
  11. // The use of runtime.GOOS and runtime.GOARCH makes sure that
    12. 
  
  
  
  12. // a cross-compiled compiler expects to compile for its own target
    13. 
  
  
  
  13. // system. That is, if on a Mac you do:
    14. 
  
  
  
  14. //
    15. 
  
  
  
  15. // GOOS=linux GOARCH=ppc64 go build cmd/compile
    16. 
  
  
  
  16. //
    17. 
  
  
  
  17. // the resulting compiler will default to generating linux/ppc64 object files.
    18. 
  
  
  
  18. // This is more useful than having it default to generating objects for the
    19. 
  
  
  
  19. // original target (in this example, a Mac).
    20. 
  
  
  
  20. func mkbuildcfg(file string) {
    21. 
  
  
  
  21.  var buf bytes.Buffer
    22. 
  
  
  
  22.  fmt.Fprintf(&buf, "// Code generated by go tool dist; DO NOT EDIT.\n")
    23. 
  
  
  
  23.  fmt.Fprintln(&buf)
    24. 
  
  
  
  24.  fmt.Fprintf(&buf, "package buildcfg\n")
    25. 
  
  
  
  25.  fmt.Fprintln(&buf)
    26. 
  
  
  
  26.  fmt.Fprintf(&buf, "import \"runtime\"\n")
    27. 
  
  
  
  27.  fmt.Fprintln(&buf)
    28. 
  
  
  
  28.  fmt.Fprintf(&buf, "const defaultGO386 = `%s`\n", go386)
    29. 
  
  
  
  29.  fmt.Fprintf(&buf, "const defaultGOARM = `%s`\n", goarm)
    30. 
  
  
  
  30.  fmt.Fprintf(&buf, "const defaultGOMIPS = `%s`\n", gomips)
    31. 
  
  
  
  31.  fmt.Fprintf(&buf, "const defaultGOMIPS64 = `%s`\n", gomips64)
    32. 
  
  
  
  32.  fmt.Fprintf(&buf, "const defaultGOPPC64 = `%s`\n", goppc64)
    33. 
  
  
  
  33.  fmt.Fprintf(&buf, "const defaultGOEXPERIMENT = `%s`\n", goexperiment)
    34. 
  
  
  
  34.  fmt.Fprintf(&buf, "const defaultGO_EXTLINK_ENABLED = `%s`\n", goextlinkenabled)
    35. 
  
  
  
  35.  fmt.Fprintf(&buf, "const defaultGO_LDSO = `%s`\n", defaultldso)
    36. 
  
  
  
  36.  fmt.Fprintf(&buf, "const version = `%s`\n", findgoversion())
    37. 
  
  
  
  37.  fmt.Fprintf(&buf, "const defaultGOOS = runtime.GOOS\n")
    38. 
  
  
  
  38.  fmt.Fprintf(&buf, "const defaultGOARCH = runtime.GOARCH\n")
    39. 
  
  
  
  39. 
  
  
  
  40.  writefile(buf.String(), file, writeSkipSame)
    41. 
  
  
  
  41. }
    42.

其中 version 的值是通过 findgoversion() 得到，该函数定义在 src/cmd/dist/build.go 中：(省略了部分细节)

 
 
 
    
  
  
  
  1. // findgoversion determines the Go version to use in the version string.
    2. 
  
  
  
  2. func findgoversion() string {
    3. 
  
  
  
  3.  // The $GOROOT/VERSION file takes priority, for distributions
    4. 
  
  
  
  4.  // without the source repo.
    5. 
  
  
  
  5.  path := pathf("%s/VERSION", goroot)
    6. 
  
  
  
  6.  if isfile(path) {
    7. 
  
  
  
  7.   ...
    8. 
  
  
  
  8.  }
    9. 
  
  
  
  9. 
  
  
  
  10.  // The $GOROOT/VERSION.cache file is a cache to avoid invoking
    11. 
  
  
  
  11.  // git every time we run this command. Unlike VERSION, it gets
    12. 
  
  
  
  12.  // deleted by the clean command.
    13. 
  
  
  
  13.  path = pathf("%s/VERSION.cache", goroot)
    14. 
  
  
  
  14.  if isfile(path) {
    15. 
  
  
  
  15.   return chomp(readfile(path))
    16. 
  
  
  
  16.  }
    17. 
  
  
  
  17. 
  
  
  
  18.  // Show a nicer error message if this isn't a Git repo.
    19. 
  
  
  
  19.  if !isGitRepo() {
    20. 
  
  
  
  20.   fatalf("FAILED: not a Git repo; must put a VERSION file in $GOROOT")
    21. 
  
  
  
  21.  }
    22. 
  
  
  
  22. 
  
  
  
  23.  // Otherwise, use Git.
    24. 
  
  
  
  24.  // What is the current branch?
    25. 
  
  
  
  25.  branch := chomp(run(goroot, CheckExit, "git", "rev-parse", "--abbrev-ref", "HEAD"))
    26. 
  
  
  
  26.  ...
    27. 
  
  
  
  27. 
  
  
  
  28.  // Cache version.
    29. 
  
  
  
  29.  writefile(tag, path, 0)
    30. 
  
  
  
  30. 
  
  
  
  31.  return tag
    32. 
  
  
  
  32. }
    33.

按一下顺序获得 Version(如果前面的获取不到，则依次执行后续获取步骤)

  • 从 $GOROOT/VERSION 获取，在这个文件中放了版本信息，你可以看看你的 Go 安装目录下这个文件的信息
  • 从 $GOROOT/VERSION.cache 获取
  • 根据 Git 仓库生成版本信息，并且生成缓存，这样后续直接读取 $GOROOT/VERSION.cache 获取

03 自己项目

通过前文分析，总结下 Go 版本是如何写入 Go 源码的：

  • 正式版本，通过项目根目录的一个文件得到，比如 $GOROOT/VERSION;
  • 非正式版本，通过 Git 获得版本信息;为了避免编译时重复执行 Git 相关操作，可以生成缓存;
  • 通过环境变量控制版本信息;

最后，可以通过一个 API 把版本信息公开给用户。

对于我们自己的 Go 项目，通过 Git 获得版本信息，可以通过 shell 脚本实现，最后编译 Go 项目时，将版本信息通过 -X 传递进去。

现在我们通过脚本来实现这个功能。

项目代码如下：

 
 
 
    
  
  
  
  1. // main.go
    2. 
  
  
  
  2. package main
    3. 
  
  
  
  3. 
  
  
  
  4. import (
    5. 
  
  
  
  5.  "fmt"
    6. 
  
  
  
  6. )
    7. 
  
  
  
  7. 
  
  
  
  8. var Version string
    9. 
  
  
  
  9. 
  
  
  
  10. func main() {
    11. 
  
  
  
  11.  fmt.Println("Version:", Version)
    12. 
  
  
  
  12. }
    13.

现在写一个 shell 脚本，通过该脚本对以上代码进行编译：

 
 
 
    
  
  
  
  1. #!/bin/sh
    2. 
  
  
  
  2. 
  
  
  
  3. version=""
    4. 
  
  
  
  4. 
  
  
  
  5. if [ -f "VERSION" ]; then
    6. 
  
  
  
  6.     version=`cat VERSION`
    7. 
  
  
  
  7. fi
    8. 
  
  
  
  8. 
  
  
  
  9. if [[ -z $version ]]; then
    10. 
  
  
  
  10.     if [ -d ".git" ]; then
    11. 
  
  
  
  11.         version=`git symbolic-ref HEAD | cut -b 12-`-`git rev-parse HEAD`
    12. 
  
  
  
  12.     else
    13. 
  
  
  
  13.         version="unknown"
    14. 
  
  
  
  14.     fi
    15. 
  
  
  
  15. fi
    16. 
  
  
  
  16. 
  
  
  
  17. go build -ldflags "-X main.Version=$version" main.go
    18.
  • 如果有 VERSION 文件，读取该文件的值作为版本信息;
  • 如果 version 的值是空，判断当前项目是否是 Git 项目。是，则获取版本信息，格式：master-commithash;否则，版本信息设置为 unknown;
  • 通过 go build 的 ldflags 传递版本信息给 main.Version;

这样项目中的 Version 就设置上正确的值了。

04 总结

本文通过对 Go 源码中版本信息的学习研究，掌握了优秀开源项目设置版本信息的做法。最后，演示了如何在自己的项目中用上该技能。

本文没有演示环境变量，一般用的比较少。


文章名称：Go这样设置版本号：我们的项目也可以
标题URL：http://wtcwzsj.com/article/ccddici.html

其他资讯


关于我们
我们的服务
网站建设案例
新闻动态
联系我们

135-1821-9792

公司服务热线
友情链接： 成都广告扇定制   手机网站制作设计   光华村机房   攀枝花网站设计   成都产品认证   防护网厂   兴隆湖idc机柜托管   成都柴油发电机公司   楼顶招牌制作   成都水电改造   

Copyright © 2009-2022 www.wtcwzsj.com 青羊区广皓图文设计工作室（个体工商户） 版权所有　蜀ICP备19037934号