广告
返回顶部
首页 > 资讯 > 后端开发 > GO >详解Go 依赖管理 go mod tidy
  • 717
分享到

详解Go 依赖管理 go mod tidy

Go 依赖管理 go mod tidygo mod tidy 2022-11-11 21:11:55 717人浏览 泡泡鱼
摘要

目录前言Debug准备源码的位置debug 配置文件dlv启动执行过程加载Go.mod文件加载依赖更新go.mod文件前言 go mod tidy的作用是把项目所需要的依赖添加到go

前言

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
	 
	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)
	}
	...
}

以上就是详解Go 依赖管理 go mod tidy的详细内容,更多关于Go 依赖管理 go mod tidy的资料请关注编程网其它相关文章!

您可能感兴趣的文档:

--结束END--

本文标题: 详解Go 依赖管理 go mod tidy

本文链接: https://www.lsjlt.com/news/121300.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑,方便收藏和打印~

下载Word文档
猜你喜欢
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作