Golang 基础
Go 无继承,Go 的编码天然就是模块化的,天然适配微服务,符合云原生直觉,Java 的继承过于臃肿以至于总是撑爆领域
- 可读性大于简洁:Go 不允许
a > b ? a : b这样的三目运算符,也不允许i++嵌套,也不允许函数重载,在 Go 中,可读性的优先级拔的很高 - 组合大于继承:组合相较于继承更加契合 DDD 实践,更容易划分领域边界(做好 DDD 是一件很考验功底的事)
- 性能有限:在内存占用和网络带宽上,Go 具备得天独厚的后发优势
Go 的开源项目,仙之人兮列如麻,不难看出,Go 同时兼顾系统开发和应用开发的能力
- Clash(网络代理)
- Caddy(Web 服务器)
- Docker(容器)
- K8S(容器编排)
- Ollama(大模型本地部署)
- Hugo(静态网站生成)
# 环境搭建
# Win 环境配置
Golang 镜像站下载:All releases - The Go Programming Language (opens new window)
go version
go env
2
Go Mod 命令
go get package@version # 等于 npm install
go mod tidy # 移除无用依赖
go mod download # 根据 go.mod 下载所有依赖
go mod verify # 验证依赖完整性
2
3
4
Windows Go 版本管理:voidint/g: Golang Version Manager (opens new window)
- 解压压缩包:下载好 g1.6.0.windows-amd64.zip 后,将其解压到自定义目录,例如 D:\gvm
配置环境变量
- Win11 系统:依次点击 “系统”>“系统信息”>“高级系统设置”>“环境变量 (N)…”,在 “系统变量” 中进行设置
- 设置 g 的工作目录,G_HOME=D:\gvm
- 新建变量:创建名为 “GOROOT” 的系统变量,变量值设置为解压后的目录,
GOROOT=D:\gvm\go - 修改 Path 变量:在 “系统变量” 中找到 “Path” 变量,点击 “编辑”,然后 “新建”,添加
%G_HOME%和%GOROOT%\bin
g env
g -v
g install 1.20.7
go version
2
3
4
5
# Mac 环境管理
飞神的键盘配置:把键重复速率和重复前延迟都拉满
# 安装 brew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
2
添加环境变量
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zshrc
source ~/.zshrc
2
iTerm / Git / JDK / Maven 下载
brew install --cask iterm2
brew install git
brew search jdk
brew install openjdk@17
brew install maven
2
3
4
5
安装 GVM
brew install mercurial
bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
2
添加环境变量
# 修改 ~/.zshrc 文件
[[ -s "$HOME/.gvm/scripts/gvm" ]] source "$HOME/.gvm/scripts/gvm"
source ~/.zshrc
2
3
4
GVM
gvm listall
gvm list
gvm install go1.19 -B
gvm install go1.24.0 -B
gvm uninstall go1.19
gvm use go1.24.0 default
2
3
4
5
6
VS Code:Go 插件自带 gopls 语言服务器,要求 go 版本 1.21 及以上,也可以手动用 go 下载相应版本的 gopls
快捷键
- 后退:command + 减号
- 转到定义:command + 鼠标点击
- 删除文件:command + 删除
# go 命令
go build:保持打包和测试环境一致,在开发机 / 代码空间打包,下载本地,推到 EOS 环境运行
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o function main.go
CGO_ENABLE=0禁止 CGO 编译静态链接二进制,防止运行时链接到系统的 glibc,若打包和测试环境的 glibc 不一致会导致执行失败GOOS=linux GOARCH=amd64指定系统跨平台编译,本地 Mac,测试环境 Linux
启动、查看并重启进程
# 上传服务器并添加执行权限,当前位于 function 目录
chmod +x ./bin/function
./bin/function > /dev/null 2>&1 & # 启动程序
ps -ef | grep function
kill pid
./bin/function > /dev/null 2>&1 & # 再次启动
2
3
4
5
6
go get:同步依赖包,类似于 maven 的使用,可以手动指定 commit hash 替换远端依赖版本。例如 paas 层的服务在另一个仓库,web-server 为上游调用者,在开发过程中,需要用到 paas 层新开发的接口,需要引入这个开发中的 paas 服务进行联调
cd backend/codev-web-server
go get git.woa.com/devcloud/clouddev/proto/environment@<mentor的分支名或commit>
2
或者 mentor 还没 push、只有本地代码(联调期) 用 replace 临时指到他本地 checkout 的路径(跟你本地 protos 一个套路):
replace git.woa.com/devcloud/clouddev/proto/environment => /他本地/environment/proto的路径
- 等分支合并/打 tag 后,删掉这个 replace,再 go get ...@正式版本换回伪版本号
- 引进来之后,client 还是那套标准姿势:config.yaml 里加对应服务的
client.service块 + 代码里environment.NewXxxClientProxy()调用
go mod tidy:自动清理依赖包
# 基础语法
# 变量与常量
Hello World
package main
import (
"fmt"
)
func main() {
// 定义变量无需指定变量类型,使用`:=`进行定义
s := "Hello Golang!"
// 语句通过换行分割,不用分号(类似于 Python,但不采用司马了的缩进表示嵌套)
fmt.Println(s)
for i := 1; i <= 5; i++ {
fmt.Println("i =", 100/i)
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
fmt.Printf输出
%v通用输出,不知道怎么输出就用这个%s是输出字符串,%d是整数,%f是浮点
fmt.Println,等同于 Java 的 sout:在每个参数之间自动插入空格,并在结尾添加换行符(\n),若不想换行,可用Print
命名规则和习惯
- 文件命名:全小写字母,例如
makeppttest - 文件夹、包命名:小写字母连接,比如
mycontrolflow,应尽量缩小为单个单词如flow,特殊缩写也应该为小写,如ppt - 变量命名:小写字母起头驼峰,比如
numSum := 0 - 常量命名:大写字母起头驼峰,比如
KeyNum := 4 - 函数、结构体、接口、方法命名:驼峰,开头的大小写取决于函数是否可被外部访问,可访问则大写,反之小写,比如
MakePPT(), prepareMakePPT() - 测试文件和函数命名:测试文件以小写字母 + 下划线 + test 的方式命名;而测试函数是以 Test 开头的驼峰,比如
TestAdd()
百度的逆天命名:addPPtTask, MakePPT, buildPptAgentGenPptReq在同一个文件
# 控制结构
if 语句:但条件不需要括号,判断体大括号{}必须存在(这是可读性的要求)
if age > 18 {
fmt.Println("Adult")
}
2
3
在if条件中可以定义变量,但定义的变量作用域仅在if中,如下述的 i
num := rand.Int() // 取随机数
if i := num - 3875633537609512361; i > 0 {
fmt.Println(i, mypackage.SayHello())
} else {
fmt.Println(i, mypackage.SayHelloAgain())
}
2
3
4
5
6
for 语句:一个经典的 for 循环,同样条件语句没小括号
for i := 0; i < 5; i++ {
fmt.Println(i)
}
2
3
注意,Go 中没有 While 循环,统一使用 for
// 死循环
for {
fmt.Println("nmsl")
}
// while 循环平替
i := 0
for i < 5 {
fmt.Println(i)
i++
}
2
3
4
5
6
7
8
9
10
11
注意条件语句中不允许i++ < 5这样的写法,他只能作为语句存在,不能嵌入到其他表达式(为了可读性做的限制)
switch 语句:Go 的switch不需要break,匹配成功后直接 break 跳出
day := "Monday"
switch day {
case "Monday":
fmt.Println("Start of the week")
case "Friday":
fmt.Println("Weekend is near")
default:
fmt.Println("Midweek")
}
fmt.Println("Start TestSwitch()!\n")
2
3
4
5
6
7
8
9
10
多值匹配,用逗号连接
switch day {
case "Saturday", "Sunday":
fmt.Println("Weekend")
default:
fmt.Println("Weekday")
}
2
3
4
5
6
switch 后可以不接变量,而在 case 后添加布尔值,这样 switch 语句将执行第一个为 true 的 case,当作一个 if-else 语句来用
score := 85
switch {
case score >= 90:
fmt.Println("A")
case score >= 80:
fmt.Println("B")
default:
fmt.Println("C")
}
2
3
4
5
6
7
8
9
使用fallthrough修饰 case,那么执行完当前 case 后将继续执行下一个 case
switch num := 2; num {
case 1:
fmt.Println("One")
case 2:
fmt.Println("Two")
fallthrough // 继续执行下一个 case
case 3:
fmt.Println("Three")
case 4:
fmt.Println("Four")
}
2
3
4
5
6
7
8
9
10
11
只会往下执行一条,输出为
Two
Three
2
# 指针与地址
取地址与解引用
&task—— 取地址:得到值所在的指针,是一个指针*task—— 解引用:得到指针指向的值,是一个结构体task *models.Task—— 声明:表明 task 是一个指针task models.Task—— 声明:表示 task 是一个结构体
声明指针,一般用这种情况来避免 nil 指针,而后用具体的 task.Uid 来判断是否赋值成功(而不是通过指针是否为 nil)
task1 := &models.BackupCronTask{}
models.BackupCronTask{}先造一个零值结构体(一个值)&对这个值取地址task的类型是*models.BackupCronTask,指向一块新分配的、非 nil 的结构体内存
声明空指针:只声明「task 的类型是指针」,此时 task == nil,还没有指向任何内存
var task2 *models.BackupCronTask
对于函数和传参而言,*有两种解释,对于入参声明,带不带星号,表示传入的是指针还是值,但在变量前,*task 解出来是一个结构体,&task 取出来是一个指针,也就是说上述两种声明的指针 task,都可以直接作为以下函数的入参
func Test(task *models.BackupCronTask) error {}
Test(task1)
Test(task2)
2
3
4
但如果是一个结构体,就必须进行取地址,拿到其指针再传入
task3 := models.BackupCronTask{Uid: "xxx"}
Test(&task3)
2
指针传递的例子
// GetMainContainerImage 从 containerInfo JSON 中取主容器 codev-main 的镜像地址
// containerInfo 为空、非法或找不到 codev-main 时返回空串
func GetMainContainerImage(containerInfo string) string {
if containerInfo == "" {
return ""
}
var containers []*environment.ContainerStatus
if err := json.Unmarshal([]byte(containerInfo), &containers); err != nil {
return ""
}
for _, c := range containers {
if c.GetName() == ContainerMain {
return c.GetImage()
}
}
return ""
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
和上述指针传递效果完全一样的值传递
func GetMainContainerImage(containerInfo string) string {
// containerInfoItem 解析 DevEnvironmentInstance.ContainerInfo 里的容器状态数组,只取所需字段
type containerInfoItem struct {
Name string `json:"name"`
Image string `json:"image"`
}
if containerInfo == "" {
return ""
}
var containers []containerInfoItem
if err := json.Unmarshal([]byte(containerInfo), &containers); err != nil {
return ""
}
for _, c := range containers {
if c.Name == ContainerMain {
return c.Image
}
}
return ""
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 函数
在 Go 中,函数是一等公民
在 go 中,使用关键字func定义一个函数,以下基本覆盖了所有的构造示例
// 依次是函数挂载点,函数名,参数列表,返回列表
// 这个编码格式挺有意思,来自于连胜哥的风格,严肃学习
func (p *mcp) AgentPPT (
// 传参
ctx context.Context,
extraReq mcpprotocol.WenchainToolMakePPTReq,
params base.AIGCParams,
) (SSEStreamCh, error) { // 返回
// 函数体内容
}
// 如果多个参数类型相同,可以省略前面的类型,只写最后一个,但返回列表需要写全
// 在接收时,也用逗号分开 res1, res2 := hello(x, y)
func hello(x, y int, name string) (int, int) {
// ...
}
// 我们可以在返回值列表直接定义返回变量名,从而在`return`时,可以省略掉`return`的变量
// 相当于一个初始化的语法糖
func rectangleArea(length, width int) (area int) {
area = length * width
return // 省略 area
}
// 变长入参
// 入参列表 (numbers ...int) 会把所有参数作为切片处理
// 可变参数可以和普通参数混用,但可变参数必须放在最后
func sum(numbers ...int) int {
total := 0
for _, num := range numbers {
total += num
}
return total
}
// 函数作为入参
// 这里的函数 op 是变化的,它可以是 add,也可以是 mul 或其他,他只是一个接受两个 int 变量,返回一个 int 变量的 function
// 这样的设计在 MyLisp 的编写中见过,内建函数的实现采用了这种形式
func operate(a, b int, op func(int, int) int) int {
return op(a, b)
}
// 函数作为返回,在这里`double`作为一个函数变量存在,好玩捏
func multiplier(factor int) (func(int) int) {
return func(x int) int {
return x * factor
}
}
func main() {
double := multiplier(2)
fmt.Println(double(5)) // 10
}
// 内部函数:定义内部函数,以便操作“全局”变量
func solve(root *TreeNode, x, y int) (res int) { // 定义函数返回 res int
// 在声明时,只需要填数据类型即可
var dfs func(*TreeNode) int
dfs = func(node *TreeNode) int {
// 操作全局的 res,例如
res += node.Val
// ...
}
dfs(root)
return
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
defer 延迟函数与匿名函数:在函数体内部定义一个 defer 匿名函数,它会在函数 return 之后执行,通常 defer 与 go func 做搭配,用于控制协程结束前的动作
func test() string {
defer func(){
fmt.Println("nmsl")
}
defer func(){
fmt.Println("hahaha")
}
res := "wdnmd"
fmt.Println(res)
return res
}
2
3
4
5
6
7
8
9
10
11
将会依次输出wdnmd, hahaha, nmsl,其顺序为如下,其中 defer1 表示第一个定义的 defer,defer2 表示第二个定义的 defer
函数体 → defer2 → defer1 → return
其定位类似于 Java 中 finally 的用法,用来关闭资源,还有一个值得注意的是,defer 在定义时将会复制函数体之上的值,即使这个值在 defer 之后修改了,defer 内部不会改变,如以下代码,defer 将会输出 1,但函数会返回 2
func test() int {
res := 1
defer fmt.Println(res)
res++
return res
}
2
3
4
5
6
init 函数:init() 是 Go 的特殊函数,不能手动调用,由 runtime 自动触发
- 触发时机和顺序:程序启动时,在 main() 之前执行,但这个包必须被(直接或间接)import 进最终的可执行程序
main.go;没被 import 的包,它的 init 永远不跑 - init 执行顺序
- 先初始化被依赖的包(import 的包先 init),再 init 当前包 —— 依赖在前
- 同一个包内:先完成所有包级变量的初始化,再执行 init()
- 一个包有多个 init()(甚至多个文件里)都会执行,按文件名字典序
- 每个包的 init 只执行一次,即使被 import 多次
所以对于一些要初始化的服务,例如定时任务注册、旁路服务拉起,都可以封在业务函数中 init 函数里,然后最后在 main.go 里进行 import
# 数据结构
# slice 数组
语法:[]数据类型{初始数据1, 初始数据2, ...}
nums := []int{1, 2, 3}
fnums := []float64{3.14, 2.71, 1.618}
words := []string{"Hello", "Go", "Language"}
flags := []bool{true, false, true}
data := []byte{'a', 'b', 'c'}
// 指针切片
x, y, z := 10, 20, 30
numbers := []*int{&x, &y, &z}
fmt.Println(*numbers[0], *numbers[1], *numbers[2]) // 10 20 30
2
3
4
5
6
7
8
9
10
若想定义空的切片
nums := make([]int, 0) // 创建一个容量为 0 的切片
nums := []int{}
var nums []int
2
3
推荐第一种,当然,如果有 nil 的判断,即判断nums == nil是否为空的操作,推荐第三种初始化(在网络编程中,例如 Json 传输,似乎第三种更有利)
切片操作:相当于定义一个 List,然后不断 add 和修改
nums := make([]int, 0) // 定义一个空的切片
// 追加元素
nums = append(nums, 1)
nums = append(nums, 2, 3, 4)
fmt.Println(nums) // 输出: [1 2 3 4]
// 修改元素
nums[0] = 10
fmt.Println(nums) // 输出: [10 2 3 4]
2
3
4
5
6
7
8
9
10
可以通过内建的len()和cap()函数来获取切片的长度和容量
len()返回切片的元素个数(即切片的长度)cap()返回切片的底层数组的容量(即切片所能容纳的元素个数,不一定是当前的长度
nums := []int{1, 2, 3, 4}
fmt.Println("Length:", len(nums)) // 输出: Length: 4
fmt.Println("Capacity:", cap(nums)) // 输出: Capacity: 4(或更大,取决于底层数组的扩展)
2
3
4
函数返回
- 数组是定长的,在定义时必须规定长度,类似于 C 中的数组,在函数返回数组时,将复制整个数据结构进行返回,所以函数返回顺序结构时,绝大部分都是选择返回切片
- 切片是引用类型(指针),返回时不会复制底层数据,而是返回其起始指针
函数返回数组和切片
// 返回切片
func getSlice() []int {
var nums []int
// nums := make([]int, 0)
nums = append(nums, 1, 2, 3, 4)
return nums
}
// 返回一个长度为 3 的整型数组
func getArray() [3]int {
return [3]int{1, 2, 3}
}
2
3
4
5
6
7
8
9
10
11
12
之前在说到函数接收变长参数时提到一个问题:我定义一个变长参数入参和定义一个切片入参有什么区别?
func Sum() int {
return Sum1(getSlice()...)
}
func Sum1(nums ...int) int {
sum := 0
for _, value := range nums {
sum += value
}
return sum
}
func Sum2(nums []int) int {
sum := 0
for _, value := range nums {
sum += value
}
return sum
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
乍一看确实好像没有什么区别,但实际上还是有些微差别,可变入参好于切片入参
如果是
(nums ... int)入参,入参可以为空,但切片不行,至少需要传入一个nil或空切片[]int{}(需要显式传切片)可变入参可以接受切片作为入参,用以下形式
nums := []int{1, 2, 3, 4} Sum1(nums...) // ✅ 正确,将返回 101
2
for range 遍历切片
nums := []int{1, 2, 3}
for index, value := range nums {
fmt.Println(index, value)
}
2
3
4
当不需要使用 index 时,用_替代
nums := []int{1, 2, 3}
sum := 0
for _, value := range nums {
sum += value
}
fmt.Println(sum) // 输出 6
2
3
4
5
6
# map 哈希表
map 的定义:map[键]值{}第一个中括号为键类型,之后跟值类型,大括号中为初始数据
strMapInt := make(map[string]int)
intMapInt := make(map[int]int)
intMapStr := make(map[int]string)
var strMapInt1 map[string]int
strMapInt2 := map[string]int{}
2
3
4
5
6
定义逻辑其实和切片一样,特别是初始化空的情况,用 make 或者 var
追加元素:直接定义就行,比如对于m := make(map[string]string),想要插入元素,直接用m["nmsl"] = wdnmd就行,他会自行判断容量自动扩容
函数返回 map
// 返回一个 map
func getMap() map[string]int {
var m map[string]int
// m := map[string]int{}
// m := make(map[string]int)
m["one"] = 1
m["two"] = 2
return m
}
// 创建函数时定义返回变量
func getMap1() (m map[string]int) {
m["one"] = 1
m["two"] = 2
return
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
使用 for 和 range 遍历映射
m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
fmt.Println(k, v)
}
2
3
4
其他的遍历,两数之和
func twoSum(nums []int, target int) []int {
m := make(map[int]int)
for index, val := range nums{
if preIndex, preVal := m[target-val]; preVal{
return []int{preIndex, index}
}
m[val] = index
}
return nil
}
2
3
4
5
6
7
8
9
10
重点是第四行的 if 语句,这句到底干了什么
if preIndex, preVal := m[target-val]; preVal{}
我们只需要明确,m[target-val]到底返回的是什么,其实是两个值,分别是索引和值内容,if 最后的prevVal实际上就是在判断这个索引下到底存不存在内容
信息量是否有点大,我糙你的,实际上等价于
for index, val := range nums{
preIndex, preVal := m[target-val]
if preVal{
return []int{preIndex, index}
}
m[val] = index
}
2
3
4
5
6
7
if 语句里面能进行变量短声明极大的压缩了编码
# string 字符串
常见的字符串处理,Go 语言的string是不可变的字节序列,Go 主要依赖strings和strconv标准库来进行字符串操作
字符串拼接:+ 号拼接即可
func catStr(str1, str2 string) string {
return str1 + str2
}
2
3
追加字符:使用strings.Builder
func appendChars(original string, chars ...rune) string {
var builder strings.Builder
// 预先分配足够空间(可选优化)
builder.Grow(len(original) + len(chars))
// 写入原始字符串
builder.WriteString(original)
// 逐个追加字符
for _, c := range chars {
builder.WriteRune(c)
}
return builder.String()
}
2
3
4
5
6
7
8
9
10
11
12
取单个字符:在 go 中,用 rune 表示单个字符
func getChar1(str string, index int) rune {
return rune(str[index])
}
2
3
获取字符串长度:len 函数,单位是多少个 rune
s := "hello world"
fmt.Printfln(len(s)) // 输出 11
2
字符串截取
ss := "Hello, Go!"
sub1 := ss[7:] // 从索引 7 开始截取
sub2 := ss[0:5] // 从 0 截取到 5,含头含尾
fmt.Println(sub1, sub2) // Go! Hello
2
3
4
拆分字符串:strings.Split
s := "Go,Python,Java"
words := strings.Split(s, ",")
fmt.Println(words) // ["Go", "Python", "Java"]
2
3
去除首尾空格或指定字符:strings.TrimSpace
import "strings"
s := " Hello, Go! "
fmt.Println(strings.TrimSpace(s)) // "Hello, Go!"
2
3
4
byte[], rune[]和string的区别?
# struct 结构体
OOP 面向对象编程:封装、~
继承~、多态
不同于 Java,结构体的定义和其功能的实现并不在同一域,比方我先定义一个结构体 Account
type Account struct {
Id string
Name string
Password string
}
2
3
4
5
而后我想实现他的功能,直接定义函数,通过在 func 后的小括号指定其所属的结构体,这个小括号叫做接收者
func (a *Account) SayHello() string {
res := "Hello! " + "I'm " + a.id + ":" + a.Name
fmt.Println(res)
return res
}
2
3
4
5
在 Main 中调用
func main() {
account := learning.Account{Id: "1", Name: "test", Password: "123456"}
account.SayHello() // 输出 "Hello! I'm 1:test"
}
2
3
4
值得注意的点是,在定义接受者的时候,如果没有*号,则为值传递(否则为指针传递),值传递不会对对象原本的值做改变(值是复制进来的),只有在传入指针时,原结构体的数据才是可修改的(和 C 保持一致)
结构体的 Embedding 嵌入
type CovertParseSubmit struct {
AIBase
params covertParseSubmitParam
docIdInt uint64
docFlag uint32
docPage uint32
dataType int8
bduss string
}
2
3
4
5
6
7
8
9
将结构体 AIBase 嵌入到结构体 ConvertParseSubmit 里,后者包含前者,这是一个组合(嵌入),而非继承,要和子类的逻辑严格区分开,在 Go 中是没有继承这一说的
# interface 接口
在 Go 语言中,接口(interface)是一种抽象类型,定义了一组方法,但不包含具体实现
接口提供了一种灵活的方式,使不同类型的对象可以共享相同的行为,同时支持多态编程
import "fmt"
// 定义一个接口
type Speaker interface {
Speak() string
Run() string
}
// 定义一个结构体
type Animal struct {
Name string
Type string
}
// 让 Animal 实现 Speaker 接口中的两个函数 Speak 和 Run
// 实现接口函数到结构体的双向绑定,可以通过这个结构体来实例化接口
func (d Animal) Speak() string {
return "I'm " + d.Name + ", I'm a " + d.Type
}
func (d Animal) Run() string {
return "The " + d.Type + " " + d.Name + " is running"
}
func TestInterface() {
var s Speaker
// 通过 Animal 实例化 Speaker
s = Animal{Name: "Buddy", Type: "Dog"}
fmt.Println(s.Speak())
fmt.Println(s.Run())
}
func main() {
learning.TestInterface()
}
/*
输出
I'm Buddy, I'm a Dog
The Dog Buddy is running
*/
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
也就是说,接口定义函数轮廓,具体逻辑由结构体和函数实现共同完成,最后向上返回时,只提供接口,但内容可以是千奇百怪,这就是 Go 中的多模态实现
还可以用 interface 定义函数体的返回,这样相当于 Java 中返回 Object 类,即可返回任意类型
func TestInterfaceFunc(a int) interface {
if a >= 0 {
return 95
} else {
return "hahaha"
}
}
2
3
4
5
6
7
在 Go 中,interface 更像是一个泛型的存在,例如定义一个泛型数组
type PPTJSONData struct {
Title string 'json:"task_id"'
Slide [] interface 'json:"slide"'
}
2
3
4
# GODS 库
提供与 Java Collection 对齐的常用数据结构
# 并发编程
Go 语言的协程(goroutine)和通道(channel)是其并发模型的核心
# Goroutine 协程
Goroutine 是 Go 语言中的一种轻量级线程,它由 Go 运行时(runtime)管理,用户不需要手动管理线程。相比操作系统级别的线程,Goroutine 更加高效,可以轻松创建数十万个 Goroutine,而不会导致大量的资源消耗
协程为什么比线程快
| 特性 | 协程 | 线程 |
|---|---|---|
| 内存消耗 | 非常小(< 2KB),可动态扩展至 1GB | 较大(> 1MB) |
| 创建 / 销毁 | 由 GO 运行时管理(GPM 模型) | 由 OS 管理 |
| 上下文切换 | 都在用户态完成 | 需要在用户态和内核态切换 |
| 通信方式 | 通过 Channel 通信 | 主要靠共享内存 |
Go 使用 go 关键字创建一个协程
import (
"time"
)
func TestGoroutine() {
go TestInterface()
time.Sleep(3 * time.Second)
}
2
3
4
5
6
7
8
Main 函数
func main(){
learning.TestGoroutine()
}
2
3
输出
I'm Buddy, I'm a Dog
The Dog Buddy is running
2
注意: main函数是主 Goroutine,若它执行完毕,所有子 Goroutine 也会立即结束,因此需要time.Sleep等待子 Goroutine 执行(这里手动等了 3s)
也就是说,如果不等,有可能子协程并没有执行,整个程序就跑完了,非阻塞,这和 Java 的线程很不一样(在 Java 里,主线程是需要等待子线程执行完毕才结束的)
在 Go 中,Goroutine 默认是并发的,而不是并行的,如果要让 Go 充分利用多核 CPU 并行执行,需要使用设置 CPU 核心数
import "runtime"
func main() {
runtime.GOMAXPROCS(runtime.NumCPU()) // 设置使用 CPU 核心数
}
2
3
4
5
# Channel 通道与 SSE 传输
Channel 是 Go 语言中用于协程之间通信的数据结构,可在多个 Goroutine 之间传输数据,Channel 的存在意义
- Goroutine 之间共享内存可能导致数据竞争,Channel 提供了一种安全的数据传输方式
- Go 语言提倡通过通信共享内存(CSP 模型,Conmunicating Sequential Process),而不是通过共享内存进行通信
通过 make chan 关键字创建通道,可指定数据类型是 any 任意
ch := make(chan any)
发送和接收消息
func TestChannel() {
ch1 := make(chan int)
ch2 := make(chan string)
go func() {
ch1 <- 42 // 发送数据
}()
go func() {
time.Sleep(1 * time.Second)
ch2 <- "nmsl"
}()
num := <-ch1 // 接收数据
str := <-ch2 // 会被阻塞 1s
fmt.Println(num) // 输出 42
fmt.Println(str) // 输出 nmsl
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Channel 的阻塞特性
- 发送操作
<-会阻塞,直到数据被接收 - 接收操作
<-会阻塞,直到数据被发送
如上述str := <-ch2会被阻塞 1s 才输出
单向 Channel
func sendData(ch chan<- int) { // 只能发送数据
ch <- 100
}
func receiveData(ch <-chan int) { // 只能接收数据
fmt.Println(<-ch)
}
2
3
4
5
6
7
带缓冲的 Channel:默认的 Channel 是无缓冲的,发送和接收必须同步进行,如果想要异步通信,可以使用带缓冲的 Channel
ch := make(chan int, 3) // 创建一个最多存储 3 个 int 的缓冲通道
func main() {
ch := make(chan int, 2) // 容量为 2
ch <- 1
ch <- 2
// ch <- 3 // 若继续写入,会发生死锁(fatal error)
fmt.Println(<- ch) // 1
fmt.Println(<- ch) // 2
}
2
3
4
5
6
7
8
9
10
与智能体的交互,大多都是走的 SSE 流,通过 chan any 管道和<-操作符接收 LLM 的输出并实现“一帧帧”的输出
<- ch // 只同步数据,不进行接收
可以理解为,清除管道中的数据
# Select 语句和超时控制
select语句类似switch,专用于处理channel的并发通信
select会等待某个case变为可用(即channel有数据)default分支可选,如果所有case都阻塞,default立即执行
func main() {
ch1 := make(chan string)
ch2 := make(chan string)
go func() {
time.Sleep(2 * time.Second)
ch1 <- "Message from ch1"
}()
go func() {
time.Sleep(1 * time.Second)
ch2 <- "Message from ch2"
}()
select {
case msg1 := <-ch1:
fmt.Println("Received:", msg1)
case msg2 := <-ch2:
fmt.Println("Received:", msg2)
case <-time.After(3 * time.Second): // 超时控制
fmt.Println("Timeout!")
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# GPM 调度机制
Goroutine、Processor and Machine,协程进程和机器
GPM 调度机制:GPM 是 Go 语言运行时(runtime)用于管理 Goroutine 并发执行的调度模型,它由 Goroutine、Processor 和 Machine 组成
| 组件 | 作用 |
|---|---|
| G(Goroutine) | Go 协程,执行具体的任务 |
| P(Processor) | 逻辑处理器,负责调度 Goroutine 并提供执行环境 |
| M(Machine**)** | OS 线程,代表操作系统的线程,运行 Go 代码 |
GPM 关系图
多个 Goroutine 绑定到 Processor,Processor 绑定到 Machine,Machine 由 OS 线程提供
OS 线程(M1) OS 线程(M2) ...
| |
Processor(P1) Processor(P2) ...
| |
Goroutine(G1, G2, G3...)
2
3
4
5
6
7
# 后端开发
# GDP 框架
GDP 整体架构:包含数据库(MySQL)、缓存(Redis)、消息队列(NMQ)、日志系统(Logger)、配置中心(Sula)等等一系列中间件的开发框架
GDP ghttp.HandlerFunc 注册和执行逻辑:如何注册一个 http 路由?注册过程在 GDP 框架里做了什么事?不同于 Java 接口直接返回 ResultMap,Go 返回的是接口一个标准库中的 net.http.Handler 处理器,这个 Handler 具备处理用户 http 请求的能力,其实际上是一个具有 ServeHTTP 方法的对象
向请求的上下文 ctx 中直接写入响应,实现接口返回的功能,这一逻辑通过实现 Handler 接口实现,通过内置的结构体,完成以下逻辑再由统一的工厂创建
- Init
- InitBase
- OnExecute
在 routes 中,接口绑定的就是工厂创建的一个个 Handler,Controller 通过实现 Handler 接口实现多态和 IoC
注册路由:router.go
userInfo := rootGroup.Group("/user") // 返回一个 Router
// 获取用户信息操作路由
userInfo.HandleFunc("any", "/userinfo", user.NewUserInfo(), gmiddleware.NewUserInfoWareFunc(resource.LoggerService()))
userInfo.HandleFunc("get", "/doclist", user.NewDocList(), gmiddleware.NewUserLoginExtraWareFunc(resource.LoggerService()))
userInfo.HandleFunc("post,get", "/docinfo", user.NewDocInfo(), gmiddleware.NewUserLoginExtraWareFunc(resource.LoggerService()))
2
3
4
5
Router 通过统一的 HandleFunc 接口注册 Handler,用于处理 HTTP 请求
type Router interface {
http.Handler // 继承标准库 net/http 的所有方法
// HandleFunc 注册业务 handler 方式1
// method 是http方法,如GET、POST,也可以使用逗号来连接同时传入多个,如 "GET,POST"
// 也可以用特殊的 ANY,会自动注册所有( ANY 的取值详见 MethodAny )
// path 接口地址,如 "/index","/user/:name","/user/*"。详见 Router
// handler 是业务的逻辑,执行后会返回一个 Response 对象
// ms 是该接口特有的中间件函数,一般为风控、日志等等
HandleFunc(method string, path string, handler HandlerFunc, ms ...MiddleWareFunc)
// HandleStreamFunc 注册业务 handler 方式2: handler 是业务的逻辑,可以持续的以流式方式输出数据
HandleStreamFunc(method string, path string, handler StreamHandlerFunc, ms ...MiddleWareFunc)
// HandleStd 注册业务 handler 方式3: handler 是标准库的 http.HandlerFunc ,比如:
// HandlerStd("any", "/abc*", http.StripPrefix("/abc", http.FileServer(http.Dir("./"))))
HandleStd(method string, path string, handler http.Handler, ms ...MiddleWareFunc)
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
HandleFunc:常规的 HTTP RR 响应,如上面 ghome 例子中返回文库文档列表
userInfo.HandleFunc("get", "/doclist", user.NewDocList(), gmiddleware.NewUserLoginExtraWareFunc(resource.LoggerService()))
HandleStreamFunc:流式接口返回,如 genflow 中的 /chat 接口,返回的将是一个 chatChan 管道
// registerGenFlowAPI
func registerGenFlowAPI(router ghttp.Router) {
router.HandleStreamFunc(http.MethodPost, "/chat", genflow.Chat, gmiddleware.NewUserInfoWareFunc(resource.LoggerService()))
}
2
3
4
HandleStd:标准库的 HandlerFunc,但我发现 function 库里的全是 HandleStd,可能因为是中间层的缘故,同时 HandleStd 里也有 SSE Handler 的返回
mcprouter := router.Group("/mcp")
mcprouter.HandleStd("post", "/makepptbyoutline", mcpapi.NewMakePPTCallFunc()) // ppt生成
mcprouter.HandleStd("post", "/makepptoutline", mcpapi.NewMakePPTOutlineCallFunc()) // ppt大纲生成
imageService.HandleStd("post", "/imageanalysesse", image.NewImageAnalyseSSE()) //图片理解sse
2
3
4
Handler 的实现(Controller 的实现),第一步:定义一个处理业务的结构体,接收请求参数,例如
doclist.go
type docList struct {
reqParams docListParam
}
type docListParam struct {
// ... 略
}
2
3
4
5
6
7
第二步:实现 InitBase、OnInit 和 OnExecute 方法(和 Gin 一样)
- OnInit 主要是做一些参数过滤,业务级别的鉴权,反作弊和频率控制
- OnExecute 是业务主逻辑实现
// InitBase 初始化基础控制器,将基础控制器传入函数中
// 参数:b *mcpapibasecontrol.BaseController - 基础控制器指针
func (u *makepptoutlineCallFunc) InitBase(b *mcpapibasecontrol.BaseController) {
u.base = b
if u.base == nil {
return
}
u.base.OuterName = mcpapibasecontrol.OuterWcSSE
u.base.Logger = resource.LoggerService()
}
// OnInit 请求初始化处理
func (d *docList) OnInit(ctx context.Context, req ghttp.Request, next frame.MiddleWareQueue) (interface{}, error) {
c := gin.Context{
Request: req.HTTPRequest(),
}
if err := c.ShouldBind(&d.reqParams); err != nil {
return nil, wkerror.New(wkerror.ErrorCodeParamsError, err.Error())
}
if err := d.paramCheck(ctx); err != nil {
return nil, err
}
return next.Next(ctx, req)
}
func (d *docList) OnExecute(ctx context.Context, req ghttp.Request) (interface{}, error) {
docListRes := &userDocHomeListRes{}
docType := d.reqParams.Type
// ... 略
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
实际上,这两个方法隐式实现了 Initializer 和 Executor 这两个接口,这是框架 frame.go 的内容
// Initializer 业务流程初始化接口
type Initializer interface {
// 业务流程初始化,最外层的中间件
// 建议参数过滤,业务级别鉴权,反作弊和频率控制等可以在此执行,也可以向里细分中间件分层执行。
// 接受context和request,next,next用于可以执行下一级别的中间件。
OnInit(ctx context.Context, req ghttp.Request, next MiddleWareQueue) (data interface{}, err error)
}
// Executor 业务代码主干部分执行接口
type Executor interface {
// 业务主干流程,业务最内层的"中间件",阉割了next参数,防止业务继续调用Next。
// 建议在此做主干的接口业务,复杂业务请考虑接口是否可以拆分分层,向外拓展分层
// 接受context和request,返回data以及error,用于渲染
OnExecute(ctx context.Context, req ghttp.Request) (data interface{}, err error)
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
在 frame.go 里
- ExecutorNew 作为工厂函数返回 Executor 和一个中间件列表
- NewCommonHandle 方法接收 ExecutorNew,处理所有函数 func,构建 ghttp.HandlerFunc
// ExecutorNew 是Executor的构造函数,并返回需要注册额外的MiddleWareFunc列表
// 构造一个新的业务对象,不同请求下的业务对象都是新生成的,除非业务自己实现了引用,否则每个对象相互独立
// MiddleWareFunc的内容也是延迟构造的,MiddleWareFunc本身也可以拿到本次请求的独立业务对象,因此各个业务层的中间件可以是带状态的
type ExecutorNew func() (Executor, []MiddleWareFunc)
// NewCommonHandle 以e创建一个Handle
func NewCommonHandle(e ExecutorNew, opts ...Option) ghttp.HandlerFunc {
newFrame := &commonHandleFrame{
new: e,
}
for _, opt := range opts {
opt.apply(&newFrame.opts)
}
newFrame.opts.applyDefaultOption()
return newFrame.do
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
框架内部的处理过程:将所有的方法连同 OnInit 和 OnExecute 都包装成中间件丢到 []frame.MiddleWareFunc 里(OnInit 在倒数第二个,OnExecute 在倒数第一个),触发时,将挨个调用 next.Next 执行这些中间件,构成链路递归
func (r *commonHandleFrame) do(ctx context.Context, req ghttp.Request) (resp ghttp.Response) {
// 第1步:调用工厂函数,创建业务对象
e, funcs := r.new() // 这里得到 *docList,每一次 HTTP 打来,都会新建一个业务实例 e
// 第2步:检查是否实现了 Initializer 接口
initializer, ok := e.(Initializer) // 接口断言
// 第3步:将 OnExecute 包装成最后一个中间件
funcs = append(funcs, func(ctx context.Context, req ghttp.Request, _ MiddleWareQueue) (data interface{}, err error) {
return e.OnExecute(ctx, req) // 这里调用 docList.OnExecute
})
// 第4步:构建中间件链并执行
next := NewMiddleWareQueue(funcs)
data, err = next.Next(ctx, req)
return
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
体现到应用层的使用即为,传入一个匿名函数(实则为 ExecutorNew),把刚刚实现了 OnInit 和 OnExecute 的 docList 作为 Executor 返回,同时将日志记录作为中间件函数传进去,NewCommonHandle 接收这个 ExecutorNew 方法,触发 do 方法,按照中间件方法依次执行的顺序构造 ghttp.HandlerFunc 函数返回
func NewDocList() ghttp.HandlerFunc {
feedWareFunc := frame.FeedSampleWareFunc(
resource.LoggerService(),
)
return frame.NewCommonHandle(
// 工厂方法
func() (frame.Executor, []frame.MiddleWareFunc) {
d := &docList{}
return d, []frame.MiddleWareFunc{feedWareFunc}
},
)
}
2
3
4
5
6
7
8
9
10
11
12
13
可以发现
- 函数是 Golang 的一等公民,最后绑定到接口 /doclist 上的,其实是一连串函数顺序构造的
ghttp.HandlerFunc - 通过实现
OnInit和OnExecute方法构造Executor,再通过工厂模式将Executor涉及的所有方法注册成ghttp.HandlerFunc,是 GDP 实现 Controller 控制反转的方式,每一个 HTTP 请求都会触发一次r.new(),即每个请求都有独立的docList,每个实例里的reqParams也不会串数据,从而避免并发问题 - 虽然 Go 没有继承,但通过工厂模式、接口和函数传递一样能够实现多态,相比于 Java 的编码更扁平,更模块化
# GORM
一个样例,因为同时涉及两张表的修改,这里开启一个 DB 事务进行操作
// UpdateEnvBaseInfo 更新环境基本信息
func (envInstance *EnvInstanceController) UpdateEnvBaseInfo(ctx tcontext.Context, req *api.EnvBaseInfoUpdateReq) (err error) {
env, err := envInstance.getEnvInstanceById(ctx, req.EnvId)
if err != nil {
ctx.Logger().Errorf("查询实例错误: %s", err)
return err
}
if err = DefaultAppController.AllowAppIdOperate(ctx, env, app.AppPermissionWrite); err != nil {
ctx.Logger().Errorf("当前 appid 不具备写权限: %s", err)
return err
}
if err = envInstance.AllocOperate(ctx, env.Username); err != nil {
ctx.Logger().Errorf("非环境所有人无权限修改环境信息: %s", err)
return err
}
// 1. 参数校验(事务前)
if req.IdeName != nil && req.IdeName.Value == "" {
return goinfra.ParamInvalidErrorCode.New("IdeName 不能为空")
}
if req.EnvName != nil && req.EnvName.Value == "" {
return goinfra.ParamInvalidErrorCode.New("环境名称不能为空")
}
if req.IdePath != nil && req.IdePath.Value == "" {
return goinfra.ParamInvalidErrorCode.New("IDE 默认路径不能为空")
}
// 2. 统计 devEnvironmentInstance 表的更新
updates := map[string]interface{}{}
if req.TeamEnv != nil { // 只改团队环境状态,只有 AI 容器可被设置,非 AI 环境会 set 报错
remark, errSet := setTeamEnvRemark(env, req.TeamEnv.Value)
if errSet != nil {
ctx.Logger().Errorf("set team env remark fail.err:%v", errSet)
return errSet
}
updates["remark"] = remark
}
if req.EnvName != nil {
updates["envName"] = req.EnvName.Value
}
if req.IdePath != nil {
updates["idePath"] = req.IdePath.Value
}
// 3. 判断本次请求是否存在更新,不存在更新的话直接返回,不消耗 DB 连接
if req.IdeName == nil && len(updates) == 0 {
return nil
}
// 4. 开启事物,因为可能要写两个表
tx, err := config.DbGlobal.Begin(ctx)
if err != nil {
ctx.Logger().Errorf("begin transaction fail.err:%v", err)
return goinfra.InvokeErrorCode.New("操作失败")
}
defer func() {
if r := recover(); r != nil {
err = goinfra.InvokeErrorCode.Newf("panic:%v.err:%v", r, err)
}
if err != nil {
if e := tx.Rollback(ctx); e != nil {
ctx.Logger().Errorf("UpdateEnvBasic Rollback error:%v", e)
}
}
}()
// 5. 写 user_ide_setting 表
if req.IdeName != nil {
ideVersion := ""
if req.IdeVersion != nil {
ideVersion = req.IdeVersion.Value
}
err = envInstance.UpdateEnvIdeInfo(ctx, tx, env, &api.EnvInfoUpdateReq{EnvId: req.EnvId, IdeName: req.IdeName.Value, IdeVersion: ideVersion})
if err != nil {
return err
}
}
// 6. 写 dev_environment_instance 表
if len(updates) > 0 {
updates["updateTime"] = time.Now()
if err = tx.WithContext(ctx).Model(table.DevEnvironmentInstance{}).
Where("uid=?", req.EnvId).Updates(updates).Error; err != nil {
ctx.Logger().Errorf("update env info fail. envId=%s err=%v", req.EnvId, err)
return err
}
}
if err = tx.Commit(ctx); err != nil {
ctx.Logger().Errorf("commit transaction fail.err:%v", err)
return goinfra.InvokeErrorCode.New("操作失败")
}
return nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
可以看到 GORM 是将 SQL 嵌套在业务里进行编写,这和 Java MyBatis 的贫血模型有本质区别
- 在 Java 里,Dao 层只管 DB 读写,上层统一调用 Dao 接口
- 在 Go 里,Dao 操作被封装在业务 business 中,和领域深度绑定
这是组合和继承的设计差异