Golang+Gin框架进行HTTP开发，记录一些学习笔记

友人a丶
Golang
4小时前
14热度
0评论

Viper

Viper是一个强大的配置管理库，主要用于管理Go应用的配置信息。它可以处理多种配置来源，包括配置文件、环境变量、命令行参数等

1.读取配置文件

假设有一个config.yaml配置文件，使用Viper读取配置文件的代码如下：

package main

import (
    "fmt"
    "log"
    "github.com/spf13/viper"
)

func main() {
    // 设置配置文件路径和名称
    viper.SetConfigName("config") // 配置文件名（不带扩展名）
    viper.SetConfigType("yaml")   // 配置文件类型
    viper.AddConfigPath(".")      // 配置文件所在路径

    // 读取配置文件
    if err := viper.ReadInConfig(); err != nil {
        log.Fatalf("Error reading config file, %s", err)
    }

    // 获取配置值
    appName := viper.GetString("app_name")
    debug := viper.GetBool("debug")
    dbHost := viper.GetString("database.host")
    dbPort := viper.GetInt("database.port")
    dbUser := viper.GetString("database.username")
    dbPass := viper.GetString("database.password")
}

2.设置默认值

Viper支持为配置项设置默认值，这在配置项未在配置文件中定义，但我又需要一个默认值的情况下非常有用：

viper.SetDefault("database.port", 3306)

3.绑定环境变量

Viper可以自动从环境变量中读取配置：

viper.AutomaticEnv()
viper.SetEnvPrefix("myapp")

4.动态监听配置变化

Viper可以监听配置文件的变化，并在文件更新时自动重新加载配置：

viper.WatchConfig()
viper.OnConfigChange(func(e fsnotify.Event) {
    fmt.Println("Config file changed:", e.Name)
})

5.绑定到结构体

Viper可以将配置解析到结构体中：

type AppConfig struct {
    AppName  string `mapstructure:"app_name"`
    Debug    bool   `mapstructure:"debug"`
    Database struct {
        Host     string `mapstructure:"host"`
        Port     int    `mapstructure:"port"`
        Username string `mapstructure:"username"`
        Password string `mapstructure:"password"`
    } `mapstructure:"database"`
}

var config AppConfig
if err := viper.Unmarshal(&config); err != nil {
    panic(err)
}

6.读取多个配置文件

Viper可以通过多次调用viper.ReadInConfig()来逐个读取多个配置文件。Viper会按照读取的顺序覆盖配置项，后面的配置文件中的相同键会覆盖前面的配置文件中的值。

Viper可以调用viper.MergeConfig方法可以将多个配置文件合并到一起。

package main

import (
    "fmt"
    "log"
    "github.com/spf13/viper"
)

func main() {
    // 读取第一个配置文件
    viper.SetConfigName("config1") // 配置文件名（不带扩展名）
    viper.SetConfigType("yaml")   // 配置文件类型
    viper.AddConfigPath(".")      // 配置文件所在路径
    if err := viper.ReadInConfig(); err != nil {
        log.Fatalf("Error reading config file, %s", err)
    }

    // 读取第二个配置文件并合并
    viper.SetConfigName("config2") // 配置文件名（不带扩展名）
    if err := viper.MergeInConfig(); err != nil {
        log.Fatalf("Error reading config file, %s", err)
    }
}

也可以省略多次调用viper.SetConfigName，直接合并指定路径的配置文件：

// 读取第二个配置文件并合并
if err := viper.MergeConfigFile("./config2.yaml"); err != nil {
    log.Fatalf("Error reading config file, %s", err)
}

在Go应用中，一旦对Viper进行了初始化，其他模块就可以直接引用而无需重新初始化。这是因为Viper使用了全局变量来存储配置信息，这些配置信息在应用范围内是共享的。

Go模块

模块（Module）是一个相对独立的代码集合，它有自己独立的依赖关系。

1.概念

Go模块是以go.mod文件为标志的代码集合。一个模块可以包含多个包（Package），而包是Go语言中组织代码的基本单元。当

在一个目录下运行go mod init 命令时，就会在该目录下创建一个go.mod文件，从而将该目录及其子目录下的代码定义为一个模块。通常是模块的导入路径，一般是一个以域名开头的字符串，用来唯一标识这个模块。

每个模块都有自己的go.mod和go.sum文件，用于记录依赖关系和依赖的版本信息。（类似于JS的package.json）

go get命令的作用是下载并安装指定的 Go 包及其依赖项，会自动解析这个Go包的依赖关系，并下载所有必要的依赖包。

2.go.mod

在 Go 语言中，一个项目目录下的子目录并不一定都是单独的包。是否构成一个包，取决于目录中是否包含 Go 源代码文件（.go 文件）以及这些文件的包声明，包声明的相关命令：

module：声明模块的名称。
go：声明模块兼容的最低 Go 版本。
toolchain：指定构建模块时使用的 Go 工具链版本。
require：声明模块的依赖关系。

知识点

struct 是一种数据类型，用于将多个不同类型的数据组合成一个逻辑单元。interface 是一种类型，用于定义一组方法的集合，它只包含方法签名，不包含数据字段。

1.Struct

struct 是一种用户自定义的数据类型，用于将多个不同类型的数据组合成一个逻辑单元。它类似于其他语言中的类，但没有方法，主要用途：

用于表示复杂的数据结构。
可以包含字段（成员变量）。
可以通过方法（绑定到结构体的函数）来操作数据。

2.Interface

interface 是一种类型，它定义了一组方法的集合。一个类型只要实现了接口中定义的所有方法，就自动实现了该接口。主要还是用于方便各种方法进行调用

定义行为规范（必须传递包含哪些行为方法的数据、变量可以被赋值任意实现行为的数据）
实现多态，方法被调用时可以传递不同类型变量，只要它实现了interface的方法
解耦合，interface可以解耦具体实现和使用代码，使得代码更加模块化和可维护。

new和make

new 和 make 是两个用于分配内存的内置函数，但它们的用途和行为有很大不同。

new：分配内存，但不初始化。它会分配零值。
make：分配内存并初始化。它只能用于切片、map 和 channel。

new(T) 会分配一个类型为 T 的零值，并返回指向该值的指针。当需要一个指向某个类型的零值的指针时，使用 new。：

package main

import "fmt"

func main() {
    // 使用 new 分配一个 int 类型的零值
    p := new(int)
    fmt.Println(*p) // 输出 0，因为 int 的零值是 0
    *p = 42
    fmt.Println(*p) // 输出 42
}

make(T, size) 会分配一个类型为 T 的内存，并初始化，返回该内存的引用。T 只能是切片、map 或 channel。当需要初始化一个切片、map 或 channel 时，使用 make：

package main

import "fmt"

func main() {
    // 使用 make 初始化一个切片
    s := make([]int, 5) // 创建一个长度为 5 的切片
    fmt.Println(s)      // 输出 [0 0 0 0 0]，因为 int 的零值是 0

    // 使用 make 初始化一个 map
    m := make(map[string]int)
    m["key"] = 42
    fmt.Println(m) // 输出 map[key:42]

    // 使用 make 初始化一个 channel
    c := make(chan int)
    go func() {
        c <- 42
    }()
    fmt.Println(<-c) // 输出 42
}

context模块

context模块可以传递一个可取消的信号，让各个协程（goroutine）能够感知到这个取消信号，从而优雅地停止正在执行的任务。

1.方法

空的Context：context.Background()创建一个空的Context，它不能被取消，也没有超时时间，也不能携带值。它通常作为顶级的Context，用于主协程。
```
ctx := context.Background()
```
可取消的Context：使用context.WithCancel(parent)创建一个可以被取消的Context。parent是父Context，当父Context被取消时，子Context也会被取消。
```
ctx, cancel := context.WithCancel(context.Background())
defer cancel() // 在合适的时候调用cancel函数来取消ctx
```
带超时时间的Context：使用context.WithTimeout(parent, timeout)创建一个带有超时时间的Context。timeout是一个time.Duration类型，表示超时时间。
```
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
```
带截止时间的Context：使用context.WithDeadline(parent, deadline)创建一个带有截止时间的Context。deadline是一个time.Time类型，表示截止时间。
```
deadline := time.Now().Add(5 * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel()
```
带值的Context：使用context.WithValue(parent, key, val)创建一个带有值的Context。key通常是一个接口类型，val是对应的值。
```
ctx := context.WithValue(context.Background(), "user_id", 12345)
```

2.使用

context模块在Go语言的并发编程和分布式系统中起着非常重要的作用，它可以更好地控制协程的执行，传递请求范围的值，以及实现超时和取消机制：

网络请求：在处理HTTP请求时，context可以用来传递请求的超时时间、取消信号以及请求范围的值（如用户身份信息等）。例如，当一个HTTP请求被取消时，与这个请求相关的所有操作（如数据库查询、调用其他服务等）都可以通过context感知到取消信号，从而停止执行。
分布式系统：在分布式系统中，context可以用来传递追踪ID等信息，方便进行日志记录和问题追踪。同时，也可以用来控制分布式任务的超时和取消。
并发任务：在并发编程中，context可以用来控制多个协程的执行。例如，当一个任务被取消时，与这个任务相关的所有协程都可以通过context感知到取消信号，从而停止执行。

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // 启动多个子协程来处理任务
    for i := 0; i < 3; i++ {
        go func(id int) {
            select {
            case <-ctx.Done(): // 监听上下文的结束
                fmt.Printf("Goroutine %d cancelledn", id)
                return
            case <-time.After(20 * time.Second):
                fmt.Printf("Goroutine %d finished after 20 secondsn", id)
            }
        }(i)
    }

    // 模拟任务的执行
    time.Sleep(10 * time.Second)
    fmt.Println("Cancelling all goroutines")
    cancel()
}

sync模块

sync 包是 Go 标准库中的一个非常重要的包，它提供了多种同步原语，用于在并发编程中协调多个协程（goroutine）的行为。这些同步原语可以帮助解决并发编程中的竞态条件、死锁等问题。

1. sync.Mutex

sync.Mutex 是一个互斥锁，用于保护共享资源，确保同一时间只有一个协程可以访问该资源。

var mu sync.Mutex

mu.Lock()    // 加锁
defer mu.Unlock() // 解锁

2.sync.RWMutex

sync.RWMutex 是一个读写互斥锁，允许多个协程同时读取共享资源，但写入时需要独占访问。

var rwMu sync.RWMutex

rwMu.RLock()    // 加读锁
defer rwMu.RUnlock() // 解读锁

rwMu.Lock()    // 加写锁
defer rwMu.Unlock() // 解写锁

3.sync.WaitGroup

sync.WaitGroup 用于等待一组协程完成。它通过 Add、Done 和 Wait 方法来协调协程的完成。

var wg sync.WaitGroup

wg.Add(1)    // 增加计数
defer wg.Done() // 减少计数

wg.Wait()    // 等待所有协程完成

4.sync.Once

sync.Once 用于确保某个操作只执行一次。它通过 Do 方法来保证操作的唯一性。

var once sync.Once

once.Do(func() {
    // 只执行一次的操作
})

os/signal模块

os/signal 包用于处理操作系统发出的信号。

1.基础用法

创建一个 os.Signal 类型的通道，用于接收信号：

sigChan := make(chan os.Signal, 1)

使用 signal.Notify 函数将信号通道注册到一个或多个信号上：

signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

通过监听信号通道来处理接收到的信号：

go func() {
    for sig := range sigChan {
        fmt.Printf("Received signal: %vn", sig)
        // 根据信号类型执行相应的处理逻辑
    }
}()

信号忽略：signal.Ignore(syscall.SIGPIPE)，函数忽略某些信号
恢复默认：signal.Reset(syscall.SIGINT)，恢复默认的信号处理

2.高级技巧

可以创建多个信号通道来分组处理不同类型的信号：

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    sigChan1 := make(chan os.Signal, 1)
    sigChan2 := make(chan os.Signal, 1)
    signal.Notify(sigChan1, syscall.SIGINT)
    signal.Notify(sigChan2, syscall.SIGTERM, syscall.SIGHUP)

    go func() {
        for {
            select {
            case sig := <-sigChan1:
                fmt.Printf("Caught SIGINT: %vn", sig)
            case sig := <-sigChan2:
                fmt.Printf("Caught SIGTERM or SIGHUP: %vn", sig)
            }
        }
    }()

    fmt.Println("Program is running... Press Ctrl+C to exit")
    select {}
}