Hekyのblog - Go
type: channel
link: https://blog.heky.top/index.php/category/go/
items: 通过context解决goroutine的信息传递
items: select完成对多个channel监控
items: 单向channel
items: 使用close()关闭channel
items: go通过channel进行goroutine之间的通信
items: go中RWMutex读写锁介绍
items: go中atomic包原子化加减操作
items: go中mutex的使用
items: go通过waitgroup等待协程的执行
items: 通过interface解决动态类型传参
items: go多接口实现
items: panic，recover介绍和使用
items: go函数闭包
items: go函数的可变参数
items: json Unmarshal(non-pointer model.Submit)报错
items: Go flag库
items: gorm查询多对多关联的数量
items: gin DELETE 获取参数方式
items: Go语言整型转字符串方法
items: go生成随机数
items: gorm实现多对多关联
items: gorm多对多关联去重插入
items: gorm多对多关联删除
items: godotenv的使用
items: service.home被标记为未定义
items: Gin中间件的定义与详解
items: gin的使用
items: gorm的使用
items: Cobra 介绍和简单使用
items: AIR：热重载 Go 应用的工具
items: Go日志文件写入
items: etcd的介绍和使用

通过context解决goroutine的信息传递
type: item
date: 2025-07-10T12:05:14+08:00
description: 假如有一个方法一直在打印提示信息，现在想要在main方法中经过一段的时间主动的去停止，这个时候我们可以选择使用共享变量的方式（注意加读写锁），也可以使用channel的方式。例如：共享变量：var stop bool var rwlock sync.RWMutex var wg sync.WaitGroup func g1() { for { rwlock.RLock() if stop { fmt.Println("退出了捏") wg.Done() return } time.Sleep(time.Second) fmt.Println("欸嘿！") rwlock.RUnlock() } } func main() { wg.Add(1) go g1() time.Sleep(3*time.Second) rwlock.Lock() stop = true rwlock.Unlock() wg.Wait() fmt.Println("退出程序") }运行结果：欸嘿！ 欸嘿！ 欸嘿！ 退出了捏 退出程序使用channel：var wg sync.WaitGroup func g1(stop chan struct{}) { for { select { case <- stop: fmt.Println("退出了捏") wg.Done() return default: time.Sleep(time.Second) fmt.Println("欸嘿！") } } } func main() { stop := make(chan struct{}) wg.Add(1) go g1(stop) time.Sleep(3*time.Second) stop <- struct{}{} wg.Wait() fmt.Println("退出程序") }因为channel是协程安全的所以不用加锁运行结果：欸嘿！ 欸嘿！ 欸嘿！ 退出了捏 退出程序除此之外，还有一种更常用的方式，就是使用context，例如：var wg sync.WaitGroup func g1(ctx context.Context) { for { select { case <- ctx.Done(): fmt.Println("退出了捏") wg.Done() return default: time.Sleep(time.Second) fmt.Println("欸嘿！") } } } func main() { wg.Add(1) ctx, cancel := context.WithCancel(context.Background()) go g1(ctx) time.Sleep(3*time.Second) cancel() wg.Wait() fmt.Println("退出程序") }运行结果：欸嘿！ 欸嘿！ 欸嘿！ 退出了捏 退出程序WithCancel() 方法返回值是一个 context.Context 类型的interface和一个cancel方法ctx（context.Context）有一个Done方法，返回值是一个channel当使用cancel方法之后，ctx会向Done()返回的channel中发送一个信号此时接受到信号，select跳转到退出的分支，由此完成对goroutine的信息传递实现主动退出

select完成对多个channel监控
type: item
date: 2025-07-10T11:01:32+08:00
description: 假如现在有两个方法，分别有对应的channel，每当他们运行完成之后会向channel中发送一个信号。现在想要知道是哪一个方法先完成，可以如何做？此时可以使用select方法，来对channel进行监控。select的语法和switch很像，例如：func g1(ch chan struct{}) { time.Sleep(time.Second) ch <- struct{}{} } func g2(ch chan struct{}) { time.Sleep(2*time.Second) ch <- struct{}{} } func main() { ch1 := make(chan struct{}) ch2 := make(chan struct{}) go g1(ch1) go g2(ch2) select { case <-ch1: fmt.Println("g1 done") case <-ch2: fmt.Println("g2 done") } }运行结果为：g1 done假如我现在将这个select放到一个for循环中，不断地监控两个channel，并且想要当超过一定的时间之后就自动退出，也就是设定超时时间，这个时候可以使用 time.NewTimer() 这个方法接收一个时间做为参数，并返回一个timer对象，这个对象有一个成员 C 是一个channel，当时间到达时timer会往这个timer中发送一个信号。我们可以根据这个原理来完成超时时间的设置比如：func g1(ch chan struct{}) { time.Sleep(time.Second) ch <- struct{}{} } func g2(ch chan struct{}) { time.Sleep(2*time.Second) ch <- struct{}{} } func main() { ch1 := make(chan struct{}) ch2 := make(chan struct{}) timer := time.NewTimer(4*time.Second) go g1(ch1) go g2(ch2) for { select { case <-ch1: fmt.Println("g1 done") case <-ch2: fmt.Println("g2 done") case <-timer.C: fmt.Println("time out!") return } } }运行结果如下：g1 done g2 done time out!同时和switch一样，select也支持default方法，当没有读取到值时就运行default。关于select还有两点需要注意的：select时某一个分支就绪了（获取到了值）就执行哪一个分支如果多个分支同时就绪，是随机执行，目的是为了防止一直读取某一个分支的值，从而造成”饥饿“现象

单向channel
type: item
date: 2025-07-09T19:08:19+08:00
description: channel如果直接定义一般都是双向的，即我们既可以往里面写值，也可以从里面读值。但是有的时候我们希望某一个方法里面只能是读值，不能写值、或者是只能够写值，不能够读值，此时就需要用到单项channel。单向channel的定义和双向channel差不多，只是多了一个 <- 来标识是单向写入还是单向取出var ch1 chan<- int // 写入 var ch2 <-chan int // 取出对于初始化可以通过将一个双向channel赋值给单向channel来完成初始化，go会在内部自动完成类型的转换。var ch1 chan<- int // 写入 var ch2 <-chan int // 取出 ch := make(chan int, 1) ch1 = ch ch2 = ch例如：var wg sync.WaitGroup func producer(out chan<- int) { defer wg.Done() for i:= 0; i < 10; i ++ { out <- i } close(out) } func receiver(in <-chan int) { defer wg.Done() for num := range in { fmt.Println(num) } } func main() { wg.Add(2) c := make(chan int) go producer(c) go receiver(c) wg.Wait() }运行结果如下：0 1 2 3 4 5 6 7 8 9

使用close()关闭channel
type: item
date: 2025-07-09T07:39:00+08:00
description: 对于channel来说可以使用for range语法来不断地读值，但是如果当全部值已经读取完毕之后，for range就会阻塞。这个时候我们可以使用close()，来手动的关闭channel，此时for range就会退出了。例如：func main() { var msg chan int var wg sync.WaitGroup wg.Add(1) msg = make(chan int, 3) go func(msg chan int) { defer wg.Done() for data := range msg { fmt.Println(data) } fmt.Println("所有消息都读完啦!") }(msg) for i := 0; i < 3; i ++ { msg <- i; } close(msg) wg.Wait() }运行结果如下：0 1 2 所有消息都读完啦!有一个需要注意的地方，对于一个close了的channel来说可以继续读值，但是不能向里写值

go通过channel进行goroutine之间的通信
type: item
date: 2025-07-08T12:55:00+08:00
description: 在go语言中，两个协程之间进行通信，使用的是一种消息队列的形式。消息的生产者将消息放入消息队列，然后消费者从消息队列中获取消息。go提供了一个数据类型和语法糖来完成这种操作 channel 、 <- 例如：func main() { var msg chan string msg = make(chan string, 1) msg <- "哈喽，哈喽！" data := <- msg fmt.Println(data) }channel的使用需要初始化，并且需要显性的指明缓冲区大小chan 后面跟着的是channel中放的数据类型，这个同样需要显性的指明运行结果应该是：哈喽，哈喽！当缓冲区大小为0时，不能直接的在一个协程中写入和读取例如：func main() { var msg chan string msg = make(chan string, 0) // 缓冲区大小设为0 msg <- "哈喽，哈喽！" data := <- msg fmt.Println(data) }运行之后会报死锁：fatal error: all goroutines are asleep - deadlock!此时，由于go语言有一种happen-before的机制，让我们可以使用一个另外的goroutine来读取，例如：func main() { var msg chan string var wg sync.WaitGroup wg.Add(1) msg = make(chan string, 0) // 缓冲区大小设为0 go func(msg chan string) { defer wg.Done() data := <- msg fmt.Println(data) }(msg) msg <- "哈喽，哈喽！" wg.Wait() }运行结果为：哈喽，哈喽！

go中RWMutex读写锁介绍
type: item
date: 2025-07-07T23:07:00+08:00
description: 读写锁，RWMuex常用的有四个方法 Lock(), RLock(), Unlock(),RUnlock()，分别是加写锁，加读锁，释放写锁以及释放读锁对于写锁来说，会阻塞其他的写锁和读锁对于读锁来说，不会阻塞读锁（可以同时有多个读锁存在），但是会阻塞写锁同时因为读锁可以有多个，所以当存在一个读和写的goroutine时，写的协程只能等全部的读锁被释放时才能获取。应用场景就是在一个系统中，大部分时间是读的请求大于写的请求。所以读是可以并发的，但是显然写和读、写和写之间只能是串行，不能同时进行。例如：package main import ( "fmt" "sync" "time" ) var ( rwlock sync.RWMutex wg sync.WaitGroup ) func main() { wg.Add(6) go func() { defer wg.Done() time.Sleep(time.Second) // 为了让读锁先被获取 rwlock.Lock() defer rwlock.Unlock() fmt.Println("获取到写锁") time.Sleep(3 * time.Second) }() for range 5 { go func() { defer wg.Done() for { rwlock.RLock() fmt.Println("获取到读锁") time.Sleep(500 * time.Millisecond) rwlock.RUnlock() } }() } wg.Wait() }在这个例子中一共是启了6个goroutine，其中一个负责写，另外五个负责读，在读的goroutine中有一个for循环不断获取读锁，在写的goroutine中当获取到写锁之后休眠3秒，让效果更直观。

go中atomic包原子化加减操作
type: item
date: 2025-07-07T21:12:03+08:00
description: 对于假如说现在有一个公共的变量var count int同时有两个方法Add() 和 Sub() Add方法可以将count加10000次，Sub方法可以将count减10000次。这个问题来说，除了使用mutex之外也可以使用atomic包中的Addint32()方法来实现。例如：var count int32 var wg sync.WaitGroup func add() { defer wg.Done() for range 100000 { atomic.AddInt32(&count, 1) } } func sub() { defer wg.Done() for range 100000 { atomic.AddInt32(&count, -1) } } func main() { wg.Add(2) go add() go sub() wg.Wait() fmt.Println(count) }运行之后的结果：0

go中mutex的使用
type: item
date: 2025-07-07T20:21:00+08:00
description: 假如说现在有一个公共的变量var count int同时有两个方法Add() 和 Sub() Add方法可以将count加10000次，Sub方法可以将count减10000次。现在同时启动两个goroutine来运行这两个方法例如：var count int var wg sync.WaitGroup func add() { defer wg.Done() for range 100000 { count += 1 } } func sub() { defer wg.Done() for range 100000 { count -= 1 } } func main() { wg.Add(2) go add() go sub() wg.Wait() fmt.Println(count) }运行之后会发现count的值不是预期中的零，而是每次运行之后都是一个随机的值。这是因为事实上对count进行加1的操作并不是一个原子操作，而是可以分为3各部分：加载count -> count + 1 -> 写入count同理，对count减一也是三个部分：加载count -> count - 1 -> 写入count而在两个并发的过程当中，这六个独立的操作是可以不按照既定的顺序进行，每次执行的顺序都不唯一，会相互之间有交叉，所以这就造成了，我们每次运行之后count的结果为一个随机值的原因。为了解决这种对公共资源的竞争情况，可以使用互斥锁，也就是 mutex互斥锁可以让一个过程变为原子操作，即对于上面让count加1这个操作，如果这个 count += 1 被锁包裹，那么这个代码所表示的三个部分会变为一个整体。当然这是对于加了同一个锁的多个协程而言的。比如如果有两个互斥锁lock1和lock2，在函数add()中 count += 1 被lock1包裹，而在函数sub()中 count -= 1 被lock2包裹，此时再运行仍然会打印出随机数。因此在使用互斥锁时，对于多个想要使用共同的公共资源的协程来说需要加上同一把锁。例如：var count int var wg sync.WaitGroup var lock sync.Mutex func add() { defer wg.Done() for range 100000 { lock.Lock() count += 1 lock.Unlock() } } func sub() { defer wg.Done() for range 100000 { lock.Lock() count -= 1 lock.Unlock() } } func main() { wg.Add(2) go add() go sub() wg.Wait() fmt.Println(count) }运行结果为：0而对于使用不同的锁的情况例如：var ( count int wg sync.WaitGroup lock sync.Mutex lock1 sync.Mutex ) func add() { defer wg.Done() for range 100000 { lock.Lock() count += 1 lock.Unlock() } } func sub() { defer wg.Done() for range 100000 { lock1.Lock() count -= 1 lock1.Unlock() } } func main() { wg.Add(2) go add() go sub() wg.Wait() fmt.Println(count) }运行结果仍然为一个随机数

go通过waitgroup等待协程的执行
type: item
date: 2025-07-06T14:57:21+08:00
description: 在go中假如我起了一个goroutine，在主协程中为了让子协程运行完，可以使用 time.Sleep 的方式，主动的等到子协程运行完之后再退出。但是假如我不知道这个子协程运行的具体时间，这个时候为了让主协程可以等待协程运行完之后退出可以使用 sync.WaitGroup 。sync.WaitGroup 提供了三个方法：Add(), Done(), Wait()第一个Add，可以添加需要等待的协程数量，第二个Done可以让等待的协程数量减一，最后一个Wait可以放在main函数中，效果是当等待的协程数量清零之后才会运行后面的内容。例如：func main() { var wg sync.WaitGroup for i := 0; i < 10; i ++ { wg.Add(1) go func(i int) { defer wg.Done() fmt.Println(i) }(i) } wg.Wait() fmt.Print("全部协程都运行完了呢！") }运行之后的结果应该类似于：0 9 3 2 4 7 6 8 5 1 全部协程都运行完了呢！

通过interface解决动态类型传参
type: item
date: 2025-07-06T09:20:00+08:00
description: 在go语言中，interface{}类型可以接收任意值，根据这个特性，可以完成动态类型传参，例如：func add(a, b interface{}) interface{} { switch a.(type) { case int: ai, _ := a.(int) bi, _ := b.(int) return ai + bi case float64: ai, _ := a.(float64) bi, _ := b.(float64) return ai + bi default: return nil } }这个函数完成了一个int类型和float64类型可以同时使用的相加函数

go多接口实现
type: item
date: 2025-07-05T10:56:22+08:00
description: 对于一个结构体来说，可以通过同时实现多个接口的方法来实现多个接口，例如：type Writer interface { Write() } type Closer interface { Close() } type WriteCloser struct{} func (wc *WriteCloser) Write() { fmt.Println("write") } func (wc *WriteCloser) Close() { fmt.Println("close") } func main() { var It1 Writer = &WriteCloser{} It1.Write() var It2 Closer = &WriteCloser{} It2.Close() }运行之后的结果是：write close对于一个接口来说，可以通过接口字段组合实现不同的行为，也叫做接口嵌入。例如：type Writer interface { Write() } type WriteCloser struct{ Writer } type writedatabase struct {} type writefile struct {} func (wd *writedatabase) Write() { fmt.Println("write to database") } func (wf *writefile) Write() { fmt.Println("write to file") } func main() { var wc = &WriteCloser { &writedatabase{}, } wc.Write() var wc2 = &WriteCloser { &writefile{}, } wc2.Write() }运行之后的结果是：write to database write to file

panic，recover介绍和使用
type: item
date: 2025-07-04T15:19:32+08:00
description: 在go中，使用panic来抛出一个错误并将程序停止。一般有主动panic和被动panic两种情况。对于主动panic，可以是当一个程序启动时如果需要的依赖程序没有启动就将这个启动停掉，比如没有开etcd或mysql等，例如：func main() { ismysql := false; // 模拟mysql未启动的场景 if !ismysql { panic("mysql 未启动") } }运行之后会得到如下结果：panic: mysql 未启动 goroutine 1 [running]: main.main() C:/gostudy/20250704/exe1/exe1.go:6 +0x25 exit status 2对于被动panic的情况，如果不想要让程序退出可以使用recover来接受这个panic，之后可以选择打印或者做其他处理，并且程序是保持运行的。例如：var mp map[string]string func A() { defer func() { r := recover() fmt.Println("捕获到panic", r) }() mp["heky"] = "heky" // 在不用make或者初值初始化的情况下程序会报panic } func main() { A() fmt.Println("程序继续运行，未退出") }运行之后会得到如下结果：捕获到panic assignment to entry in nil map 程序继续运行，未退出这里需要注意的是如果要使用recover来捕获panic，recover必须在一个defer后面跟着的匿名函数中，并且这个recover必须在panic之前（因为在panic之后就是不可达的）。

go函数闭包
type: item
date: 2025-07-03T16:23:00+08:00
description: 假如说有一个需求就是每次访问一个函数之后都会获得一个变量递增之后的值，并且可以随时将这个变量的值清零。如果想要做到前半部分的需求，我们可以使用全局变量。例如var idx int func getidx() int { idx += 1 return idx } func main() { for range 5 { fmt.Println(getidx()) } }之后想要完成第二个需求也可以通过将idx赋值为0来实现。除了全局变量之外，还可以使用go函数闭包的特性来实现。例如：func getidx() func() int { idx := 0 return func() int { idx += 1 return idx } } func main() { id := getidx() for range 5 { fmt.Println(id()) } }此时假如想要将值清零可以重新调用getidx，获取一个新的函数的句柄，然后调用新获取的函数的句柄。例如：func main() { // ... 省略上面内容 id2 := getidx() for range 3 { fmt.Println(id2()) } }运行之后的结果应该如下所示：1 2 3 4 5 1 2 3通过上面的例子可以看出和使用全局变量的方式相比，函数闭包的实现可以不依赖于一个专门的变量，这对于后面有多个线程同时需要使用到idx时可以避免发生堵塞和竞争。

go函数的可变参数
type: item
date: 2025-07-03T14:03:00+08:00
description: 在go中定义一个函数之后，对于形参的长度是可以变换的。通常对于可以变化长度的形参后面加上三个点 ... ，并且此时这个参数就变为了一个切片，例如：func add(items ...int) (sum int) { for _, v := range items { sum += v; } return }对于这个函数来说，实现了将多个传入的int类型的参数进行相加的功能。我们可以这样来使用sum := add(1, 2, 3) println(sum)在这个例子中add函数传入了三个参数，那么 items 此时等价于 [1,2,3] 通过调试也可以看出这一点

json Unmarshal(non-pointer model.Submit)报错
type: item
date: 2025-06-12T21:50:42+08:00
description: 这个报错：json: Unmarshal(non-pointer model.Submit)出现在语句：err := c.ShouldBind(codedata)说明在调用 ShouldBind 时传入了一个 非指针类型 的参数，而它需要一个指针类型来把 JSON 数据反序列化进去。问题详解：在 Go 的 encoding/json 包（Gin 的绑定底层也是用它）中，json.Unmarshal 必须接收一个指针，否则无法修改原变量的值。例如：type Submit struct { Code string `json:"code"` }错误写法（非指针）：var codedata model.Submit // 这是值类型 err := c.ShouldBind(codedata) // 这里会报错：json: Unmarshal(non-pointer model.Submit)正确写法（指针）：var codedata model.Submit err := c.ShouldBind(&codedata) // 正确，传指针正确写法总结：var codedata model.Submit err := c.ShouldBind(&codedata) if err != nil { c.JSON(400, gin.H{"error": err.Error()}) return }

Go flag库
type: item
date: 2025-04-30T08:03:00+08:00
description: 在 Go 语言中，flag 是一个用于解析命令行参数的标准库。通过这个库，你可以很方便地从命令行中获取用户传入的参数，比如字符串、整数、布尔值等。主要用途：处理命令行参数，例如：go run main.go -name=Tom -age=25 -debug=true基本使用示例：package main import ( "flag" "fmt" ) func main() { // 定义命令行参数 name := flag.String("name", "default", "请输入用户名") age := flag.Int("age", 18, "请输入年龄") debug := flag.Bool("debug", false, "是否开启调试模式") // 解析命令行参数 flag.Parse() fmt.Println("name:", *name) fmt.Println("age:", *age) fmt.Println("debug:", *debug) }常用函数：函数用途flag.String(name, default, usage)定义字符串参数flag.Int(name, default, usage)定义整数参数flag.Bool(name, default, usage)定义布尔参数flag.Parse()开始解析命令行参数flag.Args()获取非 flag 的参数flag.NArg()获取非 flag 参数个数需要注意，flag 默认只支持 -key=value 或 -key value 的形式，不支持 --key 的双横线写法（这在某些 CLI 工具中是常见的）。使用上面的写法获取到的变量是一个指针，所以在访问的时候如果要访问对应的值需要在变量之前加一个*号如果想要直接得到变量也可以是用下面这种写法var name string flag.StringVar(&name, "name", "default", "请输入用户名")这种写法是自己定义一个变量，然后将它的地址传进去flag 后面的提示文字（也叫 usage 或说明文本）会在以下几种情况下自动显示：1. 用户执行程序时传入了 h 或 -help这是最常见的触发方式，flag 包会自动帮你注册 -h 和 --help 参数，触发时会显示所有参数的说明信息。例如：go run main.go -h输出会像这样：Usage of /tmp/go-build.../main: -age int 请输入年龄 (default 18) -debug 是否开启调试模式 (default false) -name string 请输入用户名 (default "default")2. 程序中手动调用 flag.Usage()你可以在代码里手动触发帮助信息显示，例如参数验证失败时：if *name == "" { fmt.Println("name 参数不能为空") flag.Usage() os.Exit(1) }3. 覆盖默认的帮助输出内容（可选）你也可以自定义 flag.Usage 的行为，比如美化输出：flag.Usage = func() { fmt.Println("用法说明：") fmt.Println(" -name string 请输入用户名 (默认值：default)") fmt.Println(" -age int 请输入年龄 (默认值：18)") fmt.Println(" -debug 是否开启调试模式 (默认值：false)") }总结一下：方式是否自动显示帮助信息运行时使用 -h 或 --help✅ 自动显示手动调用 flag.Usage()✅ 手动触发用户没有传必要参数❌ 不会自动显示（需要你手动判断并触发）

gorm查询多对多关联的数量
type: item
date: 2025-04-10T15:37:00+08:00
description: 下面给出两种常见的做法，关键在于如何统计某个标签被多少篇文章引用：方法一：使用 Join Table 直接查询统计假设你的多对多关系存储在 article_tags 表中，并且标签模型（Tag）类似如下：type Tag struct { ID uint `gorm:"primaryKey"` Name string // 其他字段... }那么在删除文章时，你可以通过查询 article_tags 表来统计当前标签是否被其他文章引用：func DeletePost(uid string) error { var article Article db := sql.GetDB() // 预加载 Tags, 这样后续能遍历对应的标签 if err := db.Where("uid = ?", uid).Preload("Tags").First(&article).Error; err != nil { return err } // 遍历每个标签，检查是否还存在其他文章关联 for _, tag := range article.Tags { var count int64 // 查询 join table 中该 tag 被其他文章引用的次数 // 请确保 "article_tags" 为你实际使用的表名 db.Table("article_tags").Where("tag_id = ?", tag.ID).Count(&count) if count == 1 { // 如果仅有一个关联，则删除该标签 if err := db.Delete(&tag).Error; err != nil { return err } } } // 移除关联（删除 join table 中对应记录） if err := db.Model(&article).Association("Tags").Clear(); err != nil { return err } // 删除文章记录 if err := db.Delete(&article).Error; err != nil { return err } return nil }方法二：借助 GORM Association Mode 的 Count 方法如果你在标签的模型中也定义了与文章的关联（比如在 Tag 模型中加入 Articles []Article gorm:"many2many:article_tags;"`），你就可以利用 GORM 内置的 Association("Articles").Count()` 来查询关联数量。示例如下：标签模型：type Tag struct { ID uint `gorm:"primaryKey"` Name string Articles []Article `gorm:"many2many:article_tags;"` }在删除文章的函数中：func DeletePost(uid string) error { var article Article db := sql.GetDB() // 预加载 Tags，确保能遍历所有标签 if err := db.Where("uid = ?", uid).Preload("Tags").First(&article).Error; err != nil { return err } // 先清除文章与标签的关联关系 if err := db.Model(&article).Association("Tags").Clear(); err != nil { return err } // 检查每个标签是否已经没有文章关联，如果是则删除标签 for _, tag := range article.Tags { // 使用 Association Mode 的 Count 方法 count := db.Model(&tag).Association("Articles").Count() if count == 1 { if err := db.Delete(&tag).Error; err != nil { return err } } } // 删除文章记录 if err := db.Delete(&article).Error; err != nil { return err } return nil }总结查询统计方式：可以直接根据 join table（如 article_tags）进行查询统计，代码简单直观，不需要在 Tag 模型中额外定义关联。Association Count 方式：需要在 Tag 模型中定义反向的多对多关联，但借助 GORM 的 Association().Cou…

gin DELETE 获取参数方式
type: item
date: 2025-04-09T13:04:00+08:00
description: 在 Gin 中，不论是 DELETE 还是 GET、POST 等请求方式，底层都是通过传入一个 *gin.Context 来获取请求参数，因此它们在参数获取上使用的机制基本是一致的。不过需要注意的是：URL 参数和查询字符串参数：DELETE 接口可以同样通过路径参数（例如通过 :id 定义的参数）和查询字符串参数（使用 c.Query() 或 c.DefaultQuery() 方法）来接收参数，这与 GET 接口没有区别。请求体参数：虽然 Gin 支持通过 c.Bind() 等方法解析 JSON、XML 或表单数据到结构体中（这在 POST 请求中比较常见），但 HTTP 规范中 DELETE 请求一般不建议携带请求体，所以如果需要通过请求体传参，可能会遇到客户端或服务器处理上的限制。实际上，Gin 并没有做出特殊处理，只是删除请求通常不包含 body，使用时需要根据实际需求选用合适的参数传递方式。所以总结来说：Gin 中 DELETE 类型接口的参数接收方式在技术实现上与 GET、POST 是类似的，都依赖于 *gin.Context，但在具体使用时需要注意 DELETE 请求通常更偏向于使用路径或查询参数，而不推荐使用请求体。

Go语言整型转字符串方法
type: item
date: 2025-04-09T12:50:00+08:00
description: 在 Go 语言中，不能直接使用简单的类型转换将整型转换为字符串，因为 Go 是一种静态类型语言，变量的类型一经定义就不能随意改变。常见的做法有以下两种方法：使用 fmt.Sprintf：可借助 fmt.Sprintf 函数将整型格式化为字符串，例如：package main import ( "fmt" ) func main() { num := 123 str := fmt.Sprintf("%d", num) // %d 表示十进制整数 fmt.Println(str) // 输出 "123" } 这种方法灵活性较高，可以轻松实现不同进制的转换.使用 strconv.Itoa：Go 标准库 strconv 提供了 Itoa（Integer to ASCII 的缩写）函数，专门用于将整型转换为字符串：package main import ( "fmt" "strconv" ) func main() { num := 123 str := strconv.Itoa(num) fmt.Println(str) // 输出 "123" } 这种方法更加直接简单，适用于需要将整数转换为十进制字符串的场景。两种方法各有优劣，根据实际业务需求选择合适的方案即可.

go生成随机数
type: item
date: 2025-04-08T12:39:00+08:00
description: 在 Go 语言中，我们通常使用两种包来生成随机数，分别是用于生成伪随机数的 math/rand 包和用于生成加密安全随机数的 crypto/rand 包。使用 math/rand生成随机数math/rand 包提供了如 rand.Int()、rand.Intn(n)（生成 0 到 n-1 的整数）和 rand.Float64()（生成范围在 0.0, 1.0) 的浮点数）等函数，可以用来生成伪随机数[3。设置种子默认情况下，math/rand 使用的是固定的随机种子，这意味着每次程序运行时生成的随机数序列都是相同的。为了使随机数每次都不同，我们需要调用 rand.Seed() 方法，并通常传入 time.Now().UnixNano() 作为种子，例如：package main import ( "fmt" "math/rand" "time" ) func main() { // 通过当前时间的纳秒数来设置种子，确保每次运行生成不同的随机序列 rand.Seed(time.Now().UnixNano()) // 生成一个在 0 到 99 范围内的随机整数 fmt.Println(rand.Intn(100)) // [1][2] // 生成一个在 [0.0, 1.0) 范围内的随机浮点数 fmt.Println(rand.Float64()) // [3] }如果不设置种子，那么会生成相同的数字序列，这对于大多数需要随机性的场景来说是不合适的。使用 crypto/rand如果需要生成加密安全的随机数，比如用于生成密钥、令牌等敏感信息时，可以使用 crypto/rand 包。该包提供的随机数生成方法与 math/rand 不同，并且生成的随机数适合用在需要高随机性保障的场景中。crypto/rand内部使用操作系统提供的随机性资源，因此不需要也不能通过设置种子来改变随机结果。基本使用方式生成随机字节常见的做法是先生成一个字节切片，然后利用 io.ReadFull 从 rand.Reader 中读取随机数据填充到该切片中。例如，可以生成一个 32 字节的随机数组，并将其用于生成 session ID：package main import ( "crypto/rand" "encoding/base64" "fmt" "io" ) func sessionId() string { b := make([]byte, 32) // 从 rand.Reader 中精确读取 32 字节数据填充到 b 中 if _, err := io.ReadFull(rand.Reader, b); err != nil { panic(err) } // 对生成的字节数组进行 base64 编码，作为 session ID 返回 return base64.URLEncoding.EncodeToString(b) } func main() { fmt.Println("Session ID:", sessionId()) }这里我们不需要设置种子，而是直接依赖操作系统安全地生成随机数。生成安全随机整数如果需要生成一个加密安全的随机整数，可以使用 rand.Int 函数，这个函数接受一个 io.Reader（通常使用 rand.Reader）和一个 big.Int 类型的上限。例如，生成范围在 [0, max) 内的随机整数：package main import ( "crypto/rand" "fmt" "math/big" ) func main() { max := big.NewInt(28) // 生成的随机数将介于 0 到 27 之间 n, err := rand.Int(rand.Reader, max) if err != nil { fmt.Println("Error:", err) return } fmt.Println("Secure Random Number:", n) }这种方式可以确保生成的整数在加密安全方面满足要求，非常适合生成密钥、令牌等场景。随机生成三位数下面给出一个示例代码，展示如何使用 Go 语言中的 crypto/rand 包来生成一个三位数（即 100~999 范围内的随机整数）。这种方法使用了 rand.Int 函数生成一个区间内的随机大数，再通过加上偏移量得到最终的结package main import ( "crypto/rand" "fmt" "math/big" ) func main() { // 我们希望生成100至999之间的随机数，共900个可能值（0~899，然后加上100） n, err := rand.Int(rand.Reader, big.NewInt(900)…

gorm实现多对多关联
type: item
date: 2025-04-05T13:51:00+08:00
description: 假设想实现的是文章（Article）和标签（Tag）之间的多对多关系。在 GORM 中，多对多关联可以通过在关联字段上使用 gorm:"many2many:<join_table_name>" 标记来实现。下面是一个正确的示例：// Tag 表示标签，每个标签可以关联多篇文章。 type Tag struct { gorm.Model Name string // 可选的标签名称 Articles []Article `gorm:"many2many:article_tags;"` // 指定关联的多对多关系 } // Article 表示文章，每篇文章可以有多个标签。 type Article struct { gorm.Model Title string // 文章标题 Content string // 文章内容 Tags []Tag `gorm:"many2many:article_tags;"` // 指定关联的多对多关系 }说明多对多关系标记在 Tag 和 Article 结构体中，都使用了 gorm:"many2many:article_tags;" 标记。这告诉 GORM：这两个表之间存在多对多关系。关联关系使用的中间表命名为 article_tags。如果不指定，GORM 会根据一定规则生成。自动管理中间表使用上述标记后，GORM 在执行自动迁移（AutoMigrate）时会自动创建中间表 article_tags，其中包含两个外键字段（例如 article_id 和 tag_id）。这样就完成了文章和标签之间的多对多关联定义。示例用法下面是一个简单的示例，展示如何保存一篇文章及其标签：// 假设 db 是已经初始化的 *gorm.DB 实例 // 创建标签 tag1 := Tag{Name: "Golang"} tag2 := Tag{Name: "数据库"} // 创建文章并关联标签 article := Article{ Title: "使用 GORM 实现多对多关联", Content: "这里详细介绍如何使用 GORM 定义多对多关联关系。", Tags: []Tag{tag1, tag2}, } // 保存文章（此时 GORM 会自动插入关联的标签以及中间表数据） if err := db.Create(&article).Error; err != nil { log.Fatal(err) }

gorm多对多关联去重插入
type: item
date: 2025-04-05T13:41:52+08:00
description: 目前的问题是：在插入文章的同时直接传入包含多个 Tag 的切片，由于 GORM 在保存多对多关联时默认认为每个 Tag 都是新的记录，导致每次插入文章时相同的 Tag 都会重新创建。为了解决这个问题，我们需要确保在保存文章之前，先对每个 Tag 去重，也就是先查询数据库中是否已经存在该 Tag，如果存在则使用已有记录，否则再创建新记录。下面给出一种常见的做法，使用 GORM 的事务（Transaction）和 FirstOrCreate 方法来处理这些逻辑。假设 Tag 模型类似于：type Tag struct { ID uint `gorm:"primaryKey"` Name string `gorm:"uniqueIndex"` // 保证 tag 名称的唯一性 // 其它字段... }下面是修改后的示例代码：func CreatePost(article Article) error { db := sql.GetDB() // 使用事务确保操作的原子性 return db.Transaction(func(tx *gorm.DB) error { // 处理每个 Tag for i, tag := range article.Tags { var existingTag Tag // 根据 Tag 的唯一字段（例如 Name）进行查找 if err := tx.Where("name = ?", tag.Name).First(&existingTag).Error; err != nil { if errors.Is(err, gorm.ErrRecordNotFound) { // 如果没有找到，则创建新标签 if err := tx.Create(&tag).Error; err != nil { return err } // 更新 article.Tags 中的数据为新创建的 tag article.Tags[i] = tag } else { // 出现其它错误时，返回错误，事务会回滚 return err } } else { // 找到了，使用已有的 tag 记录 article.Tags[i] = existingTag } } // 创建文章，GORM 会自动将 article.Tags 中的 Tag 与 Article 关联(写入中间表) if err := tx.Create(&article).Error; err != nil { return err } return nil }) } 说明事务使用使用 db.Transaction 来确保整个操作的原子性，如果中间任一步出现错误，整个事务会回滚。Tag 去重逻辑对于每个传入的 Tag，我们先根据唯一字段（比如 Name）进行查找：如果找不到则使用 tx.Create(&tag) 新建标签；如果找到了，则直接使用已存在的标签，避免重复插入。自动建立关联当调用 tx.Create(&article) 时，GORM 会自动处理多对多关系，将 article.Tags 中的 Tag 信息写入关联表 article_tags。注意这要求你的 Article 模型中所定义的多对多标签 gorm:"many2many:article_tags;" 是正确设置的。通过这种方式，每次插入文章时，相同的 Tag 都只会在数据库中保留一条记录，而只是在关联表中添加一条关联记录。这样既避免了数据冗余，也能保持多对多关系的正确性。

gorm多对多关联删除
type: item
date: 2025-04-05T12:24:27+08:00
description: 直接调用 db.Delete(&article) 仅会删除 articles 表中的记录，而不会自动清除多对多关联关系（即 article_tags 连接表中的记录）。在 GORM 中，对于多对多关联，如果需要同时删除关联关系，需要使用 Association Mode 来额外处理，例如：// 删除文章所有 Tag 关联（删除连接表中的记录） db.Model(&article).Association("Tags").Clear()或者，可以配置数据库中的外键约束（例如添加 ON DELETE CASCADE），不过这需要在数据库层面配置，是另一种实现方式。

godotenv的使用
type: item
date: 2025-04-04T22:08:02+08:00
description: 安装go get github.com/joho/godotenv // go install github.com/joho/godotenv/cmd/godotenv@latest使用将应用程序配置添加到项目根目录中的 .env 文件中：S3_BUCKET=YOURS3BUCKET SECRET_KEY=YOURSECRETKEYGOESHERE然后，在Go 应用程序中，可以执行以下作package main import ( "log" "os" "github.com/joho/godotenv" ) func main() { err := godotenv.Load() if err != nil { log.Fatal("Error loading .env file") } s3Bucket := os.Getenv("S3_BUCKET") secretKey := os.Getenv("SECRET_KEY") // now do something with s3 or whatever }参考文档：https://github.com/joho/godotenv

service.home被标记为未定义
type: item
date: 2025-04-04T21:27:36+08:00
description: 问题分析：函数未导出：在Go语言中，只有首字母大写的标识符（如函数、变量等）才在包外可见。如果希望home函数可以通过service.home调用，需要将其定义为导出的函数：func Home(c *gin.Context) { c.JSON(200, gin.H{"message": "hello world"}) }这样，主程序可以通过service.Home访问它。小写函数home是私有的，主程序无法访问。

Gin中间件的定义与详解
type: item
date: 2025-04-04T20:07:06+08:00
description: 1. Gin中间件的定义在Gin框架中，中间件(Middleware)是一个函数，它具有以下特点：func(c *gin.Context) { // 中间件逻辑 }更准确地说，Gin中间件是一个符合gin.HandlerFunc类型的函数，其签名如下：type HandlerFunc func(*Context)2. 中间件的核心特征访问请求和响应：通过gin.Context参数可以访问请求和操作响应处理流程控制：调用c.Next()继续执行后续中间件或处理函数调用c.Abort()终止后续中间件执行执行时机：可以在请求处理前执行(pre-processing)可以在请求处理后执行(post-processing)3. 中间件的完整生命周期一个典型的中间件执行流程：func LoggerMiddleware(c *gin.Context) { // 1. 请求处理前的逻辑 start := time.Now() // 2. 调用下一个中间件或路由处理函数 c.Next() // 3. 请求处理后的逻辑 latency := time.Since(start) log.Printf("请求处理耗时: %v", latency) }4. 中间件的分类(1) 全局中间件router := gin.Default() router.Use(LoggerMiddleware) // 全局生效(2) 路由组中间件authGroup := router.Group("/admin") authGroup.Use(AuthMiddleware) // 只对该路由组生效(3) 单个路由中间件router.GET("/secure", AuthMiddleware, func(c *gin.Context) { // 处理逻辑 })5. 中间件的常见用途日志记录：记录请求信息、处理时间等认证鉴权：JWT验证、Session检查等错误处理：统一错误捕获和处理限流：控制请求频率数据预处理：解析通用参数响应格式化：统一响应格式CORS处理：跨域资源共享配置6. 内置中间件示例Gin自带了一些常用中间件：// 1. 恢复中间件(Recovery) router := gin.Default() // 默认包含Logger和Recovery中间件 // 2. 静态文件服务 router.Static("/assets", "./assets") // 3. 自定义中间件 router.Use(func(c *gin.Context) { c.Set("requestId", uuid.New().String()) c.Next() })7. 自定义中间件最佳实践一个完整的自定义中间件示例：func RequestIDMiddleware() gin.HandlerFunc { return func(c *gin.Context) { // 生成唯一请求ID requestID := uuid.New().String() // 设置到上下文和响应头 c.Set("Request-ID", requestID) c.Writer.Header().Set("X-Request-ID", requestID) // 继续处理 c.Next() // 可以在这里添加请求后的处理逻辑 } } // 使用方式 router.Use(RequestIDMiddleware())8. 中间件链的执行顺序中间件的执行顺序遵循"洋葱模型"：请求 -> 中间件1前 -> 中间件2前 -> 处理函数 -> 中间件2后 -> 中间件1后 -> 响应9. 注意事项性能影响：中间件会增加处理时间，应避免复杂耗时的操作错误处理：中间件中应妥善处理错误，避免panic资源释放：如果有资源分配，确保在适当时候释放避免阻塞：不要长时间阻塞在中间件中10. 高级用法：中止中间件链func AuthMiddleware(c *gin.Context) { if !checkAuth(c) { // 中止后续中间件执行 c.Abort() c.JSON(http.StatusUnauthorized, gin.H{"error": "未授权"}) return } c.Next() }总结来说，Gin中间件是一种强大的机制，允许开发者在请求处理流程的不同阶段插入自定义逻辑，实现横切关注点(Cross-cutting concerns)的分离和复用。

gin的使用
type: item
date: 2025-04-04T17:06:00+08:00
description: 安装go install github.com/gin-gonic/gin@latest // 或 go get -u github.com/gin-gonic/gin引入import "github.com/gin-gonic/gin"开始生成实例：// 使用默认中间件（logger 和 recovery 中间件）创建 gin 路由 r := gin.Default()运行r.Run() // 默认在 8080 端口启动服务，除非定义了一个 PORT 的环境变量。 // r.Run(":8888") 传入参数切换端口 路由r.GET("/someGet", getting) r.POST("/somePost", posting) r.PUT("/somePut", putting) r.DELETE("/someDelete", deleting) r.PATCH("/somePatch", patching) r.HEAD("/someHead", head) r.OPTIONS("/someOptions", options)注：对于每一种路由都是传入两个参数，一个是路由的路径，第二个是处理请求的函数对于请求函数例如：func(c *gin.Context) { // 其他处理代码 ... // 其他处理代码 // 响应 c.String(http.StatusOK, "hello world") }需要传入一个参数 c 为gin的上下文类型gin中存在多种不同的响应类型返回JSON数据func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{ "message": "hello world", "status": "success", }) }返回HTML模板func(c *gin.Context) { c.HTML(http.StatusOK, "index.tmpl", gin.H{ "title": "Main website", }) } // gin.H{} 传递给模板，模板中使用{{.title}}使用，其他的更多用法比如循环，分支，之类可以查找go官方文档 // https://pkg.go.dev/text/template // https://pkg.go.dev/html/template需要先设置模板目录：router := gin.Default() router.LoadHTMLGlob("templates/*")返回XML数据func(c *gin.Context) { c.XML(http.StatusOK, gin.H{ "message": "hello world", "status": "success", }) }返回YAML数据func(c *gin.Context) { c.YAML(http.StatusOK, gin.H{ "message": "hello world", "status": "success", }) }返回ProtoBuf数据func(c *gin.Context) { data := &protoexample.Test{ Label: proto.String("hello"), Reps: []int64{1, 2, 3}, } c.ProtoBuf(http.StatusOK, data) }返回文件func(c *gin.Context) { c.File("/path/to/file") }返回文件流func(c *gin.Context) { c.FileFromFS("/path/to/file", http.Dir("/var/www")) }返回数据流func(c *gin.Context) { reader := strings.NewReader("some data") c.DataFromReader(http.StatusOK, int64(reader.Len()), "text/plain", reader, nil) }重定向func(c *gin.Context) { c.Redirect(http.StatusMovedPermanently, "<https://www.google.com/>") } func(c *gin.Context) { c.Request.URL.Path = "/" r.HandleContext(c) }返回纯文本func(c *gin.Context) { c.String(http.StatusOK, "hello world") }关于Gin框架中的gin.Hgin.H是Gin框架中一个非常实用的快捷方式，它实际上是一个…

gorm的使用
type: item
date: 2025-04-04T11:17:51+08:00
description: gorm golang对象关系映射框架安装go get -u gorm.io/gorm go get -u gorm.io/driver/sqlite连接数据库sqlitedb, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{}) if err != nil { panic("failed to connect database") }mysql// 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情 dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local" db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})其他数据库或高级用法：https://gorm.io/zh_CN/docs/connecting_to_the_database.html声明模型例：type Product struct { gorm.Model Code string Price uint }GORM 通过将 Go 结构体（Go structs） 映射到数据库表来简化数据库交互。 模型是使用普通结构体定义的。 这些结构体可以包含具有基本Go类型、指针或这些类型的别名，甚至是自定义类型（只需要实现 database/sql 包中的Scanner和Valuer接口）。约定主键：GORM 使用一个名为ID 的字段作为每个模型的默认主键。表名：默认情况下，GORM 将结构体名称转换为 snake_case 并为表名加上复数形式。 例如，一个 User 结构体在数据库中的表名变为 users 。列名：GORM 自动将结构体字段名称转换为 snake_case 作为数据库中的列名。时间戳字段：GORM使用字段 CreatedAt 和 UpdatedAt 来自动跟踪记录的创建和更新时间。gorm.ModelGORM提供了一个预定义的结构体，名为gorm.Model，其中包含常用字段：// gorm.Model 的定义 type Modelstruct { ID uint `gorm:"primaryKey"` CreatedAt time.Time UpdatedAt time.Time DeletedAt gorm.DeletedAt `gorm:"index"` }将其嵌入在您的结构体中: 您可以直接在您的结构体中嵌入 gorm.Model ，以便自动包含这些字段。 这对于在不同模型之间保持一致性并利用GORM内置的约定非常有用，请参考嵌入结构。包含的字段：ID ：每个记录的唯一标识符（主键）。CreatedAt ：在创建记录时自动设置为当前时间。UpdatedAt：每当记录更新时，自动更新为当前时间。DeletedAt：用于软删除（将记录标记为已删除，而实际上并未从数据库中删除）。文档：https://gorm.io/zh_CN/docs/models.html迁移(Migration)迁移(Migration)是什么？迁移是指对数据库结构进行版本控制的机制，它允许您：以编程方式定义数据库表结构跟踪数据库模式的变化历史在不同环境(开发/测试/生产)之间保持数据库结构一致回滚到之前的数据库版本迁移与创建数据库的区别特性迁移(Migration)创建数据库范围表结构、字段、索引等整个数据库实例功能修改现有结构、版本控制创建新的数据库容器粒度细粒度(表/字段级)粗粒度(数据库级)目的模式演进数据库初始化GORM中的迁移实现在GORM中，迁移通常通过AutoMigrate方法实现：// 自动迁移模型结构到数据库表 db.AutoMigrate(&User{}, &Product{}, &Order{}) // 这会在数据库中创建对应的表(如果不存在)或修改表结构以匹配模型迁移的典型用途初始化表结构：创建新表添加字段：向现有表添加新列修改字段：更改字段类型或约束删除字段：从表中移除列创建索引：添加或删除索引高级迁移功能GORM还支持更复杂的迁移操作：// 使用Migrator接口进行精细控制 m := db.Migrator() // 检查表是否存在 m.HasTable(&User{}) // 创建表 m.CreateTable(&User{}) // 添加列 m.AddColumn(&User{}, "CreditCardNumber") // 修改列 m.AlterColumn(&User{}, "Name") // 删除列 m.DropColumn(…

Cobra 介绍和简单使用
type: item
date: 2025-02-27T11:13:31+08:00
description: Cobra 是go语言中用于创建 CLI 应用程序的库。本身提供了一个快速创建 cli 应用的脚手架 cobra-cli安装：cobra:go get -u github.com/spf13/cobra@latestcobra-cli：go install github.com/spf13/cobra-cli@latest快速创建应用：现在假设要创建一个名为test的cli程序，你可以使用一下步骤来创建1. 初始化新的go模块：go mod init test2. 使用cobra-cli来快速创建应用模板cobra-cli init2.1 cobra-cli init 提供三个可选标志--author ：cobra-cli init --author "Steve Francia spf@spf13.com"--license ：cobra-cli init --license apache--viper ：cobra-cli init --viper使用 --viper 标志自动设置 viperViper 是 Cobra 的伴侣，旨在轻松处理环境变量和配置文件，并将它们无缝连接到应用程序标志。3. 向项目添加命令这个部分使用cobra-cli的add命令，例如：cobra-cli add serve cobra-cli add config cobra-cli add create -p 'configCmd'您会注意到，此最终命令具有 -p 标志。这用于将父命令分配给新添加的命令。在这种情况下，我们想将 “create” 命令分配给 “config” 命令。如果未指定，则所有命令的默认父级为 rootCmd。默认情况下，cobra-cli 会将 Cmd 附加到提供的名称，并将此名称用作内部变量名称。指定父级时，请确保与代码中使用的变量名称匹配。注意：命令名称使用 camelCase（而不是 snake_case/kebab-case）。否则，您将遇到错误。例如，cobra-cli add add-user 不正确，但 cobra-cli add addUser 有效。最终在运行完这三个命令之后会在 cmd 文件夹中看到对应命令的go文件。这时可以参考官方文档来进行编写对应的代码。参考：cobra github Cobra 生成器READMECobra 用户指南

AIR：热重载 Go 应用的工具
type: item
date: 2025-01-30T15:52:00+08:00
description: 安装使用 go install （推荐）使用 go 1.23 或更高版本:go install github.com/air-verse/air@latest使用方法只需执行 air 命令air文档GitHub URL: https://github.com/air-verse/airREADME: https://github.com/air-verse/air/blob/master/README-zh_cn.md

Go日志文件写入
type: item
date: 2024-12-02T11:29:31+08:00
description: 在现代 Go 语言程序中，可以使用标准库和第三方库来实现日志的产生并写入文件。以下是详细步骤和示例代码，使用标准库的 log 包和 os 包：使用标准库实现日志写入文件导入必要的包：os：用于文件操作。log：用于日志输出。创建或打开日志文件：使用 os.OpenFile 打开或创建日志文件。设置日志输出目标：使用 log.SetOutput 将日志输出定向到文件。编写日志记录逻辑：使用 log.Println、log.Printf 等记录日志。示例代码package main import ( "log" "os" ) func main() { // 打开或创建日志文件 logFile, err := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) if err != nil { log.Fatalf("无法打开日志文件: %v", err) } defer logFile.Close() // 设置日志输出到文件 log.SetOutput(logFile) // 配置日志前缀和时间格式 log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) // 记录日志 log.Println("程序启动") log.Printf("正在运行的 PID: %d", os.Getpid()) // 模拟一些日志输出 for i := 0; i < 5; i++ { log.Printf("这是第 %d 条日志", i+1) } log.Println("程序结束") }运行结果运行该程序后，会生成或追加到 app.log 文件中，文件内容示例：2024/12/02 14:00:00 main.go:21: 程序启动 2024/12/02 14:00:00 main.go:22: 正在运行的 PID: 12345 2024/12/02 14:00:00 main.go:26: 这是第 1 条日志 2024/12/02 14:00:00 main.go:26: 这是第 2 条日志 2024/12/02 14:00:00 main.go:26: 这是第 3 条日志 2024/12/02 14:00:00 main.go:26: 这是第 4 条日志 2024/12/02 14:00:00 main.go:26: 这是第 5 条日志 2024/12/02 14:00:00 main.go:28: 程序结束使用第三方库 logrus如果需要更高级的功能（如结构化日志），可以使用第三方日志库，如 logrus。安装 logrus：go get github.com/sirupsen/logrus示例代码：package main import ( "os" log "github.com/sirupsen/logrus" ) func main() { // 打开或创建日志文件 logFile, err := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) if err != nil { log.Fatalf("无法打开日志文件: %v", err) } defer logFile.Close() // 设置输出目标为文件 log.SetOutput(logFile) // 设置日志格式为 JSON log.SetFormatter(&log.JSONFormatter{}) // 日志记录 log.WithFields(log.Fields{ "event": "启动", "pid": os.Getpid(), }).Info("程序启动") log.Info("这是普通日志信息") log.Warn("这是警告日志信息") log.Error("这是错误日志信息") }运行结果：日志文件 app.log 中的内容可能是这样的：{"event":"启动","level":"info","msg":"程序启动","pid":12345,"time":"2024-12-02T14:00:00Z"} {"level":"info","msg":"这是普通日志信息","time":"2024-12-02T14:00:00Z"} {"level":"warning","msg":"这是警告日志信息","time":"2024-12-02T14:00:00Z"} {"level":"error","msg":"这是错误日志信息","time":"2024-12-02T14:00:00Z"}总结使用标准库的 log 包可以满足基础需求，简单易用。…

etcd的介绍和使用
type: item
date: 2024-11-30T14:44:27+08:00
description: etcd简介etcd是一个开源的分布式键值存储系统，它主要用于配置管理、服务发现、分布式锁和协调分布式系统。etcd使用Raft算法来实现共识机制，确保数据的一致性和可靠性。它最初由CoreOS团队开发，现在由Cloud Native Computing Foundation (CNCF)维护。功能特点高可用性：etcd通过多节点部署提供高可用性，即使部分节点失效，系统仍然可以正常工作。一致性：使用Raft算法实现强一致性，确保所有节点的数据一致。轻量级：etcd设计轻量，易于部署和扩展。安全性：支持TLS/SSL加密通信，保障数据传输安全。动态配置：可以动态更改配置，无需停机。观察者模式：支持观察特定键的变化，实现实时数据同步。应用场景服务发现：在微服务架构中，服务实例可以注册到etcd，并由服务发现客户端查询。配置管理：集中管理配置数据，动态更新配置，无需重启服务。分布式锁：在分布式系统中，多个进程或服务可能需要对共享资源进行同步访问，etcd可以用来实现分布式锁。集群管理：用于管理Kubernetes集群中的节点信息和状态。基本操作etcd提供了一套API，允许用户进行基本的键值操作，如：设置键值：etcdctl set /path value获取键值：etcdctl get /path删除键：etcdctl del /path观察变化：etcdctl watch /path安装和部署从GitHub Release获取etcd安装包访问etcd GitHub页面：打开浏览器，访问etcd的GitHub官方页面：https://github.com/etcd-io/etcd。导航到Releases页面：在GitHub页面上找到并点击“Releases”标签，这将展示所有可用的etcd版本。选择合适版本：根据系统环境（如操作系统和架构）选择合适的版本。通常，最新版本会位于列表的顶部，但也可以根据需要选择其他稳定版本。下载安装包：在选定的版本下，会看到为不同操作系统和架构准备的预编译二进制文件。找到适合系统的文件，并点击下载链接（通常是.tar.gz或.zip格式）。解压安装包：下载完成后，使用适当的工具解压安装包到希望安装etcd的目录。验证安装：解压后，进入解压的目录，会看到etcd和etcdctl两个可执行文件。可以通过运行./etcd --version和./etcdctl version来验证这两个工具是否已正确安装。部署windows：双击etcd.exe 默认开启端口2379cmd输入：etcdctl.exe --endpoints=http://127.0.0.1:2379 put key value来设置值输入etcdctl.exe --endpoints=http://127.0.0.1:2379 get key 来获取值