详解Go 依赖管理 go mod tidy

前言

go mod tidy的作用是把项目所需要的依赖添加到go.mod，并删除go.mod中，没有被项目使用的依赖。

Tidy makes sure go.mod matches the source code in the module.
It adds any missing modules necessary to build the current module's
packages and dependencies, and it removes unused modules that
don't provide any relevant packages. It also adds any missing entries
to go.sum and removes any unnecessary ones.

接下来我们将深入源码研究go mod tidy的执行过程

• 版本 go 1.18

• 编辑器 vscode

Debug准备

源码的位置

输入命令行go env,找到GOROOT这一项（go的安装路径）

路径${GOROOT}/src/cmd/go/internal/modcmd就是go mod命令相关的源码了。其程序入口${GOROOT/src/cmd/go/main.go}进入该目录（其实也可以不进，但是待会看源码时还是得进去）执行以下命令go build -o ./godebug.exe -gcflags all="-N -l" -mod=mod .得到以下程序。

注：可以直接调试main.go这个文件，但是 go mod tidy这个命令是根据执行命令时的工作路径查找go.mod文件，这无形指定了工作路径为：${GOROOT}/src/cmd

debug 配置文件

{
   "version": "0.2.0",
   "configurations": [
       {
           "name": "GO debug",
           "type": "go",
           "request": "attach",
           "mode": "remote",
           "host": "127.0.0.1",
           "port": 2345,
       }
   ]
}

dlv启动

随便进一个go项目中，执行命令dlv exec --headless --listen :2345 --api-version=2 D:/go/src/cmd/go/godebug.exe -- mod tidy,这里的程序是我们上面刚刚编译出来的，路径自己CV就行。

现在dlv服务端已经ok了，现在回到源码那边，启动客户端就行了。

如果走的exec，好像是没法vscode的restart按钮貌似不起作用,每次都需要重复执行以上两个动作

执行过程

入口${GOOROOT}/src/cmd/go/internal/modcmd/tidy.go,该方法只是做了一些参数配置，主要逻辑在modload.LoadPackages

func runTidy(ctx context.Context, cmd *base.Command, args []string) {
       ...
modload.LoadPackages(ctx, modload.PackageOpts{
GoVersion:                tidyGo.String(),
Tags:                     imports.AnyTags(),
Tidy:                     true,
TidyCompatibleVersion:    tidyCompat.String(),
VendorModulesInGOROOTSrc: true,
ResolveMissingImports:    true,
LoadTests:                true,
AllowErrors:              tidyE,
SilenceMissingStdImports: true,
}, "all")
}

• 加载项目go.mod的文件内容

• 构建整个项目的依赖关系

• 更新go.mod文件

// {GOROOT}/src/cmd/go/internal/modload/load.go
func LoadPackages(参数省略)(参数省略) {
...
       //  加载项目go.mod的文件内容
initialRS := LoadModFile(ctx)
...
}

加载go.mod文件

1.根据执行go mod tidy时所在的工作路径，向上查找最先找到的go.mod文件，读取并解析该文件内容。

// ${GOROOT}/src/cmd/go/internal/modload/init.go
func LoadModFile(ctx context.Context) *Requirements {
...
// 做一些初始化的设置，获取当前项目的go.mod路径
// 执行go mod tidy 是的工作路径往上一层层寻找，找到的第一个路径即为目标路径
       // 查找路径的调用栈`Init() => findModuleRoot(base.Cwd())`
Init()
...
// 读取go.mod文件并解析该文件内容;modRoots的长度为1，大于1的情况我没有遇到过
for _, modroot := range modRoots {
gomod := modFilePath(modroot)
data, f, err := ReadModFile(gomod, fixVersion(ctx, &fixed))
}
...
// 只获取go.mod文件中的require列表，并记录每个依赖的最高版本号
rs := requirementsFromModFiles(ctx, modFiles)
...
// 如果发现当前的go.mod文件有重复的依赖路径
       // 这里会先对当前项目的go.mod文件进行一次依赖项的计算
if rs.hasRedundantRoot() {
       // If any module path appears more than once in the roots, we know that the
       // go.mod file needs to be updated even though we have not yet loaded any
       // transitive dependencies.
...
}
...
}

加载依赖

// {GOROOT}/src/cmd/go/internal/modload/load.go
func LoadPackages(...) (...) {
   // 找出项目的所有依赖,有个全局变量负责最后的存储的
   ld := loadFromRoots(ctx, loaderParams{
       PackageOpts:  opts,
       requirements: initialRS,
       allPatternIsRoot: allPatternIsRoot,
       listRoots: func(rs *Requirements) (roots []string) {
           // 实际上调用的是 matchPackages() 方法
           updateMatches(rs, nil)
           // 这里的matches长度也是1个
           for _, m := range matches {
               roots = append(roots, m.Pkgs...)
           }
           return roots
       },
   })
}

• 获取遍历树的根节点（当前项目的所有满足条件的文件夹路径）loadFromRoots()=> listRoots() => matchPackages()

// ${GOROOT}/src/cmd/go/internal/modload/search.go
func matchPackages(...) {
   // 遍历项目根路径
   walkPkgs := func(root, importPathRoot string, prune pruning) {
       ...
       // 这里的root为go.mod所在的目录，importPathRoot为go.mod定义的module
       err := fsys.Walk(root, func(path string, fi fs.FileInfo, err error) error {
           // 一大堆判断过滤
           ...
           // 包名 = moduleName + 相对路径
           name := importPathRoot + filepath.ToSlash(path[len(root):])
           if _, _, err := scanDir(path, tags); err != imports.ErrNoGo {
               m.Pkgs = append(m.Pkgs, name)
           }
           return nil
       })
   }
   // 同样的这里modules也只有1个，多个的没遇到过
   for _, mod := range modules {
       walkPkgs(root, modPrefix, prune)
   }
   return
}

• 从项目跟路径出发构建依赖关系

// {GOROOT}/src/cmd/go/internal/modload/load.go
func loadFromRoots(ctx context.Context, params loaderParams) *loader {
   ...
   // 注这里是多次循环的过程
   // a=>b,只有当b加载后才能知道是否有b=>c,b=>d。
   // 所以这里会不断的重复这个过程，直至所有的依赖关系构建完毕
   for {
       ld.reset()
       ...
       // 找出项目下的文件夹路径，这里的rootPkgs每次循环都是一样的
       rootPkgs := ld.listRoots(ld.requirements)
       ...
       // 从根路径出发，遍历全部的文件，获取依赖关系
       // 在加载依赖A的同时，会根据依赖A里面的go.mod继续去找依赖B
       // 如果发现项目中有直接引用依赖A,但是当前项目的go.mod没有(前面加载过，存放在ld.requirements),
       // 则会给该pkg一个err(这里不是module,是module里面的某个包，例如 A/xxxx,A/yyy),
       // 这里会交由ld.resolveMissingImports去处理
       for _, path := range rootPkgs {
           // 这里是并发加载，速度还是比较快的
           // 主要的逻辑在在ld.load方法上
           root := ld.pkg(ctx, path, pkgIsRoot)
           if !inRoots[root] {
               ld.roots = append(ld.roots, root)
               inRoots[root] = true
           }
       }
       // 这个只是将依赖树给平铺了存放在 ld.pkgs
       ld.buildStacks()
       ...
       // 某种程度上, 可以认为这里下载的是缺失的直接依赖，即go.mod里面没声明，但是项目却使用到了的
       // 如果发现没有缺失的直接依赖了，即可认为依赖关系已经构建完毕。
       // 因为上述过程会自动构建依赖关系，这里只是添加缺失的直接依赖，然后由上面的循环来构建依赖关系
       modAddedBy := ld.resolveMissingImports(ctx)
       if len(modAddedBy) == 0 {
           break
       }
   }
   ...
}
// 因为构建的是整个依赖关系，所以上述过程完成后，项目中不需要的依赖也已经自动剔除了

• 加载一个单独的pkg

// {GOROOT}/src/cmd/go/internal/modload/load.go
func (ld *loader) load(ctx context.Context, pkg *loadPkg) {
...
// 找出pkg的module及其所在目录
pkg.mod, pkg.dir, pkg.altMods, pkg.err = importFromModules(ctx, pkg.path, ld.requirements, mg)
if pkg.dir == "" {
return
}
...
// 扫描文件获取所有的import
// 这里是一个pkg的所有import
/*
例如:
A/B/xxx.go
import "11111"
A/B/yyy.go
import "22222"
则 pkg
import "1111"
import "2222"
*/
imports, testImports, err = scanDir(pkg.dir, ld.Tags)
...
// 递归执行 ld.pkg 组装下数据结构，又回来继续调用 ld.load
for _, path := range imports {
pkg.imports = append(pkg.imports, ld.pkg(ctx, path, importFlags))
}
}

更新go.mod文件

这里就比较简单了，就是单纯的写文件而已。在第二过程的时候已经将依赖关系构建完成了，其结果存放在一个全局变量里面MainModules,这里就是单纯校验写文件了

func LoadPackages(...) (...) {
...
if err := commitRequirements(ctx); err != nil {
base.Fatalf("go: ％v", err)
}
...
}

来源：https://juejin.cn/post/7160520524630589470