Tony Bai - Part 61

Go项目组织：在单一repo中管理多个Go module指南

五月 10, 2023
0 条评论

本文永久链接 – https://tonybai.com/2023/05/10/a-guide-of-managing-multiple-go-modules-in-mono-repo

0. 单repo单module管理回顾

众所周知，Go在1.11版本中引入了go module，随着近几年Go module机制的逐渐成熟，它已经被Go团队确定为Go标准的依赖管理与构建方案，原先的GOPATH mode已经被彻底废弃。

在Go module模式下，最常见的Go项目组织方式就是一个repo(代码仓库)对应一个Go module。repo的根路径中放置go.mod文件，repo的根路径也是module root directory。该Go module下的package的导入路径则由go.mod中的module path以及该package相对于module root directory的路径共同构成。

以“example.com/go”这一module path为例，如果某个package存放在foo/bar下，那么bar下的package的导入路径就是“example.com/go/foo/bar”；如果是v2版本，那么导入路径为“example.com/go/v2/foo/bar”。

在一个repo对应一个Go module的策略下，Go module的版本管理和发布也相对容易，通常我们采用分支方式来进行major号升级(如下图)，通过tag来进行版本发布。

上图是单repo单module的分支管理方案，两种方案均可。

左侧的方案中：master分支承载v0-v1，每升级一个major号，建立一个vN分支，default分支指向最高major号的分支，方便开发者clone repo时直接拿到最新的代码。

注：左侧方案有一个问题，那就是一旦default分支执行最高major号分支vN，那么你如果要go get master分支的最近更新，需要显式指定master分支，比如: go get example.com/go/foo/bar@master。使用latest或不加任何分支名都无法获取到master上的最新更新。

右侧的方案也是建立vN分支，但不同的是，该方案会将master分支作为active开发分支，也是默认分支并定期将稳定后的feature同步到最高major号分支，这也是我个人比较喜欢的方式。前不久刚刚被官宣为redis官方Go客户端的go-redis采用的就是这个方案(下面是go-redis的vN分支情况)：

注：在单一repo中管理一个go module的方法十分成熟了。我在专栏《Go语言第一课》的06和07讲对此做了系统的讲解，感兴趣的小伙伴可以去阅读一下。

有了单repo单module的项目组织方式，就会有单repo多module的组织方式，比如著名的etcd项目，就是在一个repo中管理多个go module的典型例子。

那么为什么要在一个repo中管理多个go module呢？我们继续往下看。

1. 为什么要在一个repo中管理多个Go module

其实这个问题的本质是monorepo与multiple repo之间的“战争”。那么上述问题也就变成了一个monorepo与multiple repo的优劣对比。我个人从未真正使用过monorepo这种所有项目代码都放在一个单一仓库中的组织形式，不过从网上的公开资料来看，monorepo有如下的一些优点：

容易看到

如果你正在做一个调用其他微服务的微服务，你可以看一下代码，了解它是如何工作的，并确定bug是来自你自己的代码还是其他团队的微服务。

代码共享

团队为微服务重复编写代码会产生额外的工作开销。有了monorepo，团队可以更容易地分享代码。

改进协作

有了monorepo，就更容易在各团队之间实现代码和工具的标准化。

标准化

单一代码仓库使得跨团队的代码和工具的标准化更加容易。

可发现性

有了monorepo，更容易找到你需要的代码。

发布管理

单一版本使我们更容易地管理跨多个服务的发布。

更容易重构

重构代码在单版本中更容易，因为所有的代码都在一个地方。

当然，使用单一代码仓库也有一些缺点，这些缺点也足以让很多组织和开发团队对其望而却步：

增加仓库的大小

一个单库通常会比只包含一个项目的版本库大。这可能会导致更长的构建时间和更多的磁盘空间使用。

增加复杂性

单一代码仓库的管理比只包含一个项目的版本库更复杂。这是因为有更多的代码需要跟踪和管理。

增加冲突的风险

当多个开发者在单一仓库中处理相同的代码时，会有更大的冲突风险。这是因为开发人员可能在同一个代码的不同版本上工作。

不能限制访问

monorepo不允许有选择的分享。

陡峭的学习曲线

当新的开发者开始与已经有monorepo的组织合作时，他们通常需要足够长的时间来适应所有紧密耦合的依赖关系。

总的来说，使用monorepo既有优点也有缺点，是否使用monorepo最终还是要取决于项目和团队的具体需求。

不过，monorepo下的多module是实际存在的，并且Google内部就是如此，显然go module也一定要对此做很好的支持的，下面我们就来看看go是如何支持mono repo下的多个go module的。

我们先来看看mono repo下各个go module的导入路径的确定。

2. monorepo中各个go module下的package的导入路径

在前面回顾单repo单module的项目组织方式下，module下的package的导入路径为：module path+package在module root directory下的相对路径。那么monorepo中各个go module下的package的导入路径又是什么呢？

首先monorepo下的各个go module的module root路径并非monorepo的root路径，以下面的结构举例；

example.com
└── go/
    ├── mqtt/
    │   ├── bar/
    │   │   └── go.mod
    │   └── foo/
    │       └── go.mod
    └── vehicle/
        ├── baz/
        │   └── go.mod
        └── zoo/
            └── go.mod

我们看到在example.com这个顶层目录下并没有go module，go modules分布在example.com下的各个子目录中。以mqtt/bar下的go module为例，它的module path应该为repo根路径+bar的相对路径，即example.com/go/mqtt/bar，这样bar下面的package pkg1，它的导入路径就为example.com/go/mqtt/bar/pkg1，如果bar这个go module升级到v2版本，则pkg1的导入路径就会变为example.com/go/mqtt/bar/v2/pkg1。其余的go module下的packge的导入路径以此类推。

3. monorepo下各个go module的版本发布

在单repo单module下，我们通过打vx.y.z标签的方式发布module，但是在monorepo多module下，再在repo上针对repo打整体的、诸如v1.0.1这样的标签就没有太大意义了(当然为了整体管理的需要，依然可以打整体标签，比如像etcd那样打v3.5.8)，并且对于monorepo下的多个go module而言，go get也不会识别这种整体标签，那么我们该如何发布monorepo下的go module呢？

其实也很简单，我们为module单独打标签来发布。以上面的example.com/go/mqtt/bar这个module为例，如果我们要为其发布v1.0.0版本，我们需要为example.com这个repo打上tag：go/mqtt/bar/v1.0.0；如果它要发布v1.1.0版本了，我们则需为example.com这个repo打上tag：go/mqtt/bar/v1.1.0。也就是说要发布哪个module，就用module相对于monorepo根的相对路径+版本号作为tag号。

4. monorepo下各个go module的major版本变更

了解了上述monorepo下各个go module的版本发布方式后，我们就可以将monorepo下的每个go module像单repo单module那样单独对待了！以example.com/go/mqtt/bar为例，当major版本变更时，我们可以建立类似go/mqtt/bar/v1分支，然后将master分支的go.mod中的module path改为example.com/go/mqtt/bar/v2，这样我们就可以在go/mqtt/bar/v1分支继续维护v1版本的bar module，并打tag：go/mqtt/bar/v1.x.y；在master分支维护v2版本的bar module，并打tag：go/mqtt/bar/v2.x.y。

当然go还支持另外一种major版本的维护方式，那就是通过目录隔离。当major版本要升级为v2时，我们可以在go/mqtt/bar下面建立v2目录(像v2这类目录被称为major version subdirectories)，然后在v2目录下维护major为v2的版本，这种方式下你就无需建立vN分支了，可以在master上通过目录隔离的方式同时维护多个major版本。发布时，同样打go/mqtt/bar/v2.x.y标签。这种方式一个最大的好处就是与GOPATH mode可以“无缝衔接”，因为GOPATH mode下，go工具链就是通过路径查找package的。

不过这种major version subdirectories的方式并不常用，即便在开源项目中也是比较少见的。

5. 小结

本文介绍了go module的基础概念，回顾了单repo单module的包管理方法，包括版本发布、major号升级等。接下来，我们介绍了monorepo下管理多个go module的方案，除了在打tag时要注意带上相对路径外，monorepo下module的包管理方法与单repo单module本质上是一致的。

6. 参考资料

REPO STYLE WARS: MONO VS MULTI – https://gigamonkeys.com/mono-vs-multi/
Mono Repo vs Multi Repo: Deep Dive Into The Neverending Debate – https://speakerdeck.com/lemiorhan/mono-repo-vs-multi-repo-deep-dive-into-the-neverending-debate

“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！2023年，Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码，关注代码质量并深入理解Go核心技术，并继续加强与星友的互动。欢迎大家加入！

img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

微博(暂不可用)：https://weibo.com/bigwhite20xx
微博2：https://weibo.com/u/6484441286
博客：tonybai.com
github: https://github.com/bigwhite

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

Go：值与指针

五月 5, 2023
0 条评论

本文永久链接 – https://tonybai.com/2023/05/05/go-value-and-pointer

1. 计算机中的值

在百万年的演化历史中，人类对事物的属性进行了抽象，有了数量、精度、信息等概念的表示，对应的我们称之为整数、小数、文本文字等。计算机出现后，我们使用计算机对真实世界的问题进行建模，通过计算机的高效计算解决这些问题并输出答案。为了建模，计算机需要建立对上述基本概念的抽象和表示，于是有了类型与值的概念。

计算机中所有数据都存储在内存中并参与问题解决的计算，真实世界的概念表示与内存中的数据的转换关系如下图：

图中的有界比特序列(bounded bit sequence)就是真实世界概念表示在计算机内存中的存储形式，我们可以统称它为一个值(value)。这个值的比特序列形式由类型决定。举个例子：一个公司的员工数量为1000人，这个真实世界的概念在计算机中的表示过程如下：

我们用uint16类型来表示员工数量，这样它在内存存储形式为0000 0011 1110 1000。如果你用不同的类型来表示员工数量，那么在内存中表示员工数量的值的比特序列将是不同的。

反之，对于内存中的一段有界比特序列，在不同类型guided的decode下，得到的结果也是不同的，如下图。

我们看到：在uint64的guided下，0000 0011 1110 1000这个比特序列被解释为1000；而在[2]byte的guided下，0000 0011 1110 1000这个同样的比特序列则被解释成了2个数字。

计算机中的值不仅仅可以表示一个数字，也可以表示一个字符串，甚至是像结构体这样的复合类型，它本质上就是一块儿连续的内存，内存单元是有地址的，通过该地址访问和更新内存单元中的值。

但在编程过程中直接使用内存地址是十分不便的，因此在高级编程语言中，编程语言通过具名的标识符与内存单元建立“绑定”关系，就得到了我们通常说的常量和变量，而内存单元中存储的数据(即值)也可说成是常量持有的数据和变量持有的数据。

当然也有一些不和任何标识符“绑定”的值，我们称之为字面值(literal value)。我们通常用字面值为变量和常量赋[初]值：

var a int = 17
s := "hello"
const f float64 = 3.1415926

原生类型的字面值，可以简单理解为汇编中的立即数；而复杂类型(比如结构体)的字面值，则一般是临时存储在栈上的有界比特序列。

2. 一切皆是值

根据上一节关于值的定义，我们可以认为：在Go语言中，所有东西都是以值的形式存在的。在Go语言中，不仅仅是基本类型如整数、浮点数、布尔值等，就连复杂的数据结构，如结构体、数组、切片、map、channel等都以值的形式存在。

到这里有小伙伴可能会问：“不对啊，map、channel等应该是指针吧”。别急，要解答这个问题，我们就要来看看值的分类。

2.1 值的分类

在Go中，值可分为以下几种类型：

基本类型值

基本类型是Go语言中最基础的数据类型，它们是直接由语言定义的。基本类型的值通常是简单的值，比如整数、浮点数、布尔值等。在Go语言中，基本类型的值可以进行各种运算和比较操作。

复合类型值

复合类型则是由基本类型组成的更复杂的数据类型。它们的值由多个基本类型值组合而成，并且可以使用结构化的方式进行访问和操作。在Go语言中，复合类型包括分为数组、切片、map、结构体、接口、channel等多种类型。这些复合类型在不同的场景下都有不同的用途，可以用于表示不同的数据结构或者实现不同的算法。

字符串在Go中是一个特殊的存在，从Go类型角度来看，它应该属于原生内置的基本类型，但从值的角度考虑，由于在运行时字符串类型表示为一个两字段的结构(如下)

type StringHeader struct {
    Data uintptr
    Len  int
}

因此，我们将其归为复合类型值范畴。

指针类型值

有一类值十分特殊，它自身是一个基本类型值，更准确的说是一个整型值，但这个整型值的含义却是另外一个值所在内存单元的地址。如下图所示：

我们看到：指针类型值为0×12345678，这个值是另外一个内存块(值为0×17)的地址。指针类型值在Go语言以及C、C++这一的静态语言中扮演着极其重要的角色。

回答前面小伙伴的问题：map、channel是不是值? 是值，只不过是指针类型值。从Go语法上来说，map、channel是某个runtime指针类型的实例。

2.2 值的可变性

在继续深入指针之前，我们先来插播一个内容：值的可变性。

前面说过值是一段连续内存，是一个有界比特序列。原理上来说，内存中的值都是可变的。但现实中，考虑到操作系统管理以及应用安全的需要，暴露给开发人员的值被做了限定，即有些值(内存单元中的数据)是可变的，而有一些值是不可变的。

首先，操作系统负责物理内存与虚拟内存的映射，应用开发人员面对的是平坦的虚拟内存。这部分平坦的虚拟内存也被分为了几个段(segment)，比如：BSS段、数据段、代码段、堆栈等，有些segment上的值是只读的，不可变的，比如代码段，有些则是可读写的可变的，比如堆栈。

此外，Go在编程语言层面也对值做了限制，常量值是不可变的，字符串类型值是不可变的，其他则为可变值。

2.3 指针类型

针对指针这类值，编程语言抽象出了一种类型：指针类型，指针类型的变量与指针类型值绑定，它内部存储的是另外一个内存单元的地址。这样就衍生出通过指针读取和更新指针指向的值的操作方法：

var a int = 5 // 基础类型值
var p = &a    // p为指针类型变量(*int)，其值为变量a的地址。

println(*p)   // 通过指针读取其指向的变量a的值
*p = 15       // 通过指针更新其指向的变量a的值

不过，指针更大的好处在于传递开销低，且传递后，接收指针的函数/方法体中依然可以修改指针指向的内存单元的值。

接下来，我们来详细说一下值的传递。

2.4. 值的传递

无论是赋值还是传参，Go语言中的所有值的传递的方法都是值拷贝，也称为逐位拷贝(bitwise copy)。

不过即便是值拷贝，也会带来三种不同效果：

传值：你是你，我是我

效果：传递前后的变量各自独立更新，互不影响。

示例：传整型、浮点型、布尔值等。

传指针：你是你，我是我，但我们共同指向他

效果：传递前后的指针变量拥有相同的指针值，因此共同指向同一个内存对象(d)。通过其中一个指针变量对指向的内存对象进行更新后(e)，另一个指针变量可以感知到相同的变化。

示例：传*T指针类型变量。包括在Go runtime层面本质是一个指针的类型，比如map、channel等。

传“引用”：你是你，我是我，但我们有一部分共同指向他

首先要注意，Go语言规范中没有“引用类型”这一表述。其次，也不要将这里的“引用”与其他语言的“引用类型”相提并论。

这里传“引用”的效果是：传递前后的变量一部分是独立更新互不影响的，一部分则是有共同指向，相互影响的。最典型的例子就是切片。当我们将切片传入函数后，函数内对切片的更新操作会影响到原切片，包括更新切片元素的值、向切片追加元素等。尤其是向切片追加(append)元素后，会导致传递前后的两个切片出现“不一致”，详情可以参考我之前写的一篇文章《当函数设计遇到切片》。

这里之所以使用的“引用”来形容这种效果，主要是像slice这样的类型与我们熟知的其他语言中的引用(reference)很像，都是它们以“值”的形态传递，但却能干着“指针”的活儿。

3. 关于值的一些tips

3.1 零值

在Go语言中，每个变量都有一个默认的零值，即在变量未被初始化时的默认值。这个默认值取决于变量的类型，可以是一个数字、布尔值、字符串、指针、数组、结构体等等。

在Go语言中，零值可以用来初始化变量的默认值，也可以用来清空变量的值。

var i int // i的零值为0
var s string // s的零值为""
var p *int // p的零值为nil
var a [3]int // a的零值为[0 0 0]
var b struct { x int; y float64 } // b的零值为{0 0.0}

在这个例子中，我们使用var关键字声明了5个变量，并使用它们的零值来初始化这些变量的值。

另外，我们可以使用零值来清空变量的值，例如：

var i int = 10 // 初始化i的值为10
i = 0 // 使用i的零值来清空它的值

在使用零值时，需要注意以下两个问题：

指针类型的零值为nil，不能直接使用nil指针来访问变量的值，否则会导致panic。
可声明零长度数组类型，这样的类型的实例不占用内存空间，这在一些特殊场合下会很有用。

3.2 值的比较

Go语言的值比较是通过比较两个值的二进制表示来实现的。在Go语言中，值比较主要用于判断两个值是否相等。下面是Go语言值比较的场景、规则和注意事项：

场景

判断两个值是否相等；
判断两个值是否不相等；
判断一个值是否为nil；
判断两个指针是否指向同一个对象。

规则

对于基本类型（如int、float、bool等），只需要比较它们的值就可以了；
对于复合类型（如数组、切片、map等），需要递归比较它们的元素或键值对；
对于结构体类型，需要递归比较它们的字段；
对于接口类型，需要判断它们是否指向同一个动态类型以及动态值是否相等。

注意事项

对于浮点数类型，不能使用“==”运算符进行比较，因为浮点数的精度问题可能导致比较结果不正确，应该使用math包中的函数进行比较；
对于切片类型，Go不支持直接使用“==”运算符进行比较，因为它们的底层数据结构可能不同，应该使用reflect包中的函数DeepEqual进行比较；
对于结构体类型，如果其中包含不可比较的字段（如切片、映射、函数等），则整个结构体类型也是不可比较的；
对于指针类型，需要注意空指针的情况，应该先判断指针是否为nil，再进行比较。

3.3 method receiver的值与指针类型的选择

在Go语言中，method receiver可以是值类型或指针类型。这个选择可能会影响代码的性能、正确性和可读性等方面。

当一个方法的receiver是一个值类型时，receiver的传递会出现“传值”效果，方法体中对这个值的修改不会影响原来的值。但是，如果这个值类型的对象非常大，每次调用方法都需要进行复制，这会导致一定的性能损失。

当一个方法的receiver是一个指针类型时，这个方法操作的就是原来的对象，并且可以修改原来的对象。这种方式可以避免复制对象的开销，并且可以访问和修改对象的内部状态。但是，如果多个goroutine同时访问同一个对象时，就会发生竞争条件，导致程序出现不可预料的行为。

在选择method receiver的类型时，可考虑以下几个因素：

对象的大小：如果对象很小，可以选择值类型的method receiver，避免复制对象的开销；如果对象很大，可以选择指针类型的method receiver，避免复制整个对象的开销。
对象的可变性：如果对象需要被修改，应该选择指针类型的method receiver；如果对象不需要被修改，可以选择值类型的method receiver，保证代码的可预测性和可读性。
对象类型或对象的指针类型是否需要实现特定的接口。

注：关于method receiver的类型选择问题，在《Go语言第一课》专栏的第25讲有系统的讲解。

3.4 使用unsafe.Pointer进行不同type guided的值decode

前面说过，值是一个“有界比特序列”，在不同类型guided的decode下，得到的结果也是不同的。我们可以通过unsafe.Pointer来进行不同的decode，比如下面例子将一个uint32的值重新分别decode为一个[2]uint16和[4]uint8数组：

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a uint32 = 0x12345678

    b := (*[2]uint16)(unsafe.Pointer(&a))
    c := (*[4]uint8)(unsafe.Pointer(&a))

    fmt.Println(*b) // [22136 4660]
    fmt.Println(*c) // [120 86 52 18]
}

4. 小结

本文对Go语言中值做了重新解读，我们认为Go中的值就是一个有界比特序列(bounded bit sequence)，是真实世界概念表示在计算机内存中的存储形式。

围绕着值这个概念，我们指出Go中一切皆是值。在这一观点的基础上，重新了解了值的分类、值的可变性、指针类型以及重要的值的传递，学习了值的传递的本质：bitwise-copy，以及这个传递过程针对不同类型值所取得的不同效果。

最后，我们了解了一些与值有关的tips，包括零值、值比较、method receiver类型选择以及值decode。