golang标准库和第三方框架超详细使用指南

    在上一篇golang超详细入门教程（一）中，大致介绍了基本概念和语法，本文主要介绍golang常用库。

目录

四、标准库介绍

    4.1 fmt包：格式化输出

    4.2 net包：网络编程

    4.3 time包：时间相关操作

    4.4 os包：操作系统接口

    4.5 strings包：字符串处理

    4.6 json包：JSON处理

    4.7 http包：HTTP处理

    4.8 reflect包：反射机制

    4.9 error包：错误处理

    4.10 sync包：同步机制

五、常用第三方库和框架

    5.1 Gin：用于创建Web应用

    5.2 Gorm：用于数据库访问

    5.3 Viper：用于配置管理

    5.4 UUID：生成唯一标识符

    5.5 Golang-Boilerplate：快速创建项目模板

    5.6 Gomega and Gomega matchers：用于测试断言

    5.7 GoDoc：文档生成工具

---

四、标准库介绍

    4.1 fmt包：格式化输出

  go fmt是Go语言的一个命令行工具，用于格式化Go源代码。

    它使用gofmt命令来执行格式化操作。go fmt命令会对指定的Go源文件进行格式化，将代码按照Go语言的标准格式进行排版，使其符合Go语言的编码规范。格式化的内容包括缩进、命名规范、代码布局等。

    以下是go fmt的使用示例：

package main

import (
    "fmt"
)

func main() {
    var name string
    var age int
    fmt.Scan(&name, &age)
    fmt.Printf("输入的值为： 姓名:%s 年龄:%d ", name, age)
}

    将上面的代码保存为.go文件，然后通过终端进入到该文件所在的目录，执行go fmt命令即可格式化该文件。

    4.2 net包：网络编程

 net包是Go标准库中的一个包，提供了网络相关的接口和服务1。

 net包中包含了与网络编程相关的类型和方法，可以用于实现TCP/IP、UDP、域名解析和Unix域socket等网络协议1。

    以下是一些net包中的常见类型和方法：

• net.TCPAddr：表示TCP地址结构，包括IP地址和端口号。
• net.UDPAddr：表示UDP地址结构，包括IP地址和端口号。
• net.IPAddr：表示IP地址结构，包括IPv4和IPv6地址。
• net.ResolveTCPAddr：解析给定的字符串地址为TCP地址。
• net.ResolveUDPAddr：解析给定的字符串地址为UDP地址。
• net.ResolveIPAddr：解析给定的字符串地址为IP地址。
• net.Dial：建立连接并返回一个连接对象。
• net.Listen：在给定的网络类型上创建一个监听器。
• net.Conn：表示一个连接对象，提供了读写操作的方法。
• net.Listener：表示一个监听器对象，用于接受来自客户端的连接请求。

    以下是net包中使用示例：

package main

import (
    "fmt"
    "net"
)

func main() {
    // 监听TCP端口
    listener, err := net.Listen("tcp", "localhost:8080")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer listener.Close()

    // 监听UDP端口
    conn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("localhost"), Port: 8080})
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()
}

    4.3 time包：时间相关操作

  time包是Go语言中处理时间（日期和时间）的库。

     time包主要函数有：Now、Unix、Tick、Format等。

  time包提供了time.Time类型，用于表示时间；time.Now函数，用于获取当前时间；time.Unix函数，用于将时间戳转为时间格式；time.Tick函数，用于设置定时器；以及time.Format方法，用于格式化时间等。

    以下是go time包的使用示例：

package main

import (
    "fmt"
    "time"
)

func timeDemo() {
    now := time.Now() // 获取当前时间
    fmt.Printf("current time:%v\n", now)
    year := now.Year() // 年
    month := now.Month() // 月
    day := now.Day() // 日
    hour := now.Hour() // 小时
    minute := now.Minute() // 分钟
    second := now.Second() // 秒
    fmt.Println(year, month, day, hour, minute, second)
}

func main() {
    timeDemo()
}

    运行以上代码，输出如下结果：

2023 July 5 15 26 17 736596440 +0800 CST m=+0.000139043```

    4.4 os包：操作系统接口

 go os包提供了许多与操作系统交互的函数1。

    以下是go os包的部分函数及其功能1：

• Hostname()：返回内核提供的主机名。
• Getpagesize()：返回底层的系统内存页的尺寸。
• Environ()：返回表示环境变量的格式为"key=value"的字符串的切片拷贝。
• Getenv(key string)：检索并返回名为key的环境变量的值，如果不存在该环境变量会返回空字符串。
• Setenv(key,value string)：设置名为key的环境变量，如果出错会返回该错误。
• Clearenv()：删除所有环境变量。
• Exit(code int)：让当前程序以给出的状态码code退出，一般来说，状态码0表示成功，非0表示出错，程序会立刻终止，defer的函数不会被执行。

    以下是go os包的使用示例：

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println(os.Hostname())           // 返回内核提供的主机名
    fmt.Println(os.Getpagesize())         // 返回底层的系统内存页的尺寸
    fmt.Println(os.Environ())             // 返回表示环境变量的格式为"key=value"的字符串的切片拷贝
    fmt.Println(os.Getenv("PATH"))         // 检索并返回名为"PATH"的环境变量的值
    fmt.Println(os.Setenv("PATH","test"))  // 设置名为"PATH"的环境变量
    fmt.Println(os.Clearenv())             // 删除所有环境变量
    fmt.Println(os.Exit(0))                // 让当前程序以状态码0退出
    fmt.Println(os.Getuid())               // 返回调用者的用户ID
    fmt.Println(os.Getgid())               // 返回调用者的组ID
    fmt.Println(os.Getpid())                // 返回调用者所在进程的进程ID
    fmt.Println(os.Getppid())               // 返回调用者所在进程的父进程的进程ID
}

    4.5 strings包：字符串处理

    strings包是Go语言标准库中提供的一个包，用于处理字符串相关的操作。

    strings包中包含了许多函数，可以用于字符串的切割、拼接、替换、查找等操作。

    以下是strings包中一些常用的函数及用法示例1：

• Index(str, substr string) int：返回子字符串substr在字符串str中第一次出现的索引，如果未找到则返回-1。
• Join(strSlice []string, sep string) string：将字符串切片strSlice用sep连接成一个字符串。
• Repeat(str string, count int) string：将字符串str重复count次，返回一个新字符串。
• Replace(str, old, new string, n int) string：将字符串str中old替换为new，最多替换n次。
• ToUpper(str string) string：将字符串str转换为大写。
• ToLower(str string) string：将字符串str转换为小写。

    以下是go strings包的使用示例：

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello, World!"
    fmt.Println(strings.Count(str, "o"))       // 输出：3
    fmt.Println(strings.Index(str, "o"))       // 输出：4
    fmt.Println(strings.IndexRune(str, 'o'))    // 输出：4
    fmt.Println(strings.Count(str, "l"))       // 输出：3
    fmt.Println(strings.HasPrefix("Hello", "He"))    // 输出：true
    fmt.Println(strings.HasSuffix("Hello", "lo"))    // 输出：true
    fmt.Println(strings.Replace(str, "o", "*", -1))  // 输出：Hello, W*rld!
    fmt.Println(strings.Fields(str))               // 输出：["Hello", "World!"]
    fmt.Println(strings.SplitAfter(str, "o"))       // 输出：[Hello, World! o]
    fmt.Println(strings.ToLower(str))              // 输出：hello, world!
    fmt.Println(strings.ToUpper(str))              // 输出：HELLO, WORLD!
}

    4.6 json包：JSON处理

  encoding/json包是Go语言中处理JSON数据的库。

  encoding/json包主要函数有：Unmarshal、Marshal、MarshalIndent、NewEncoder、NewDecoder等

    以下是go json包的使用示例

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // 编码，将结构体转换为JSON格式的字符串
    type Person struct {
        Name string `json:"name"`
        Age  int    `json:"age"`
        Address string
    }
    p := Person{Name: "John", Age: 20, Address: "Hangzhou"}
    b, err := json.Marshal(p)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(b))

    // 解码，将JSON格式的字符串转换为结构体
    var p2 Person
    err = json.Unmarshal([]byte(`{"name":"John","age":20,"address":"Hangzhou"}`), &p2)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(p2.Name, p2.Age, p2.Address)
}

    4.7 http包：HTTP处理

    Go的http包是Go语言中处理HTTP协议的库1。

    http包有两个核心功能：Conn和ServeMux1。

• Conn：goroutine与一般编写的http服务器不同，Go为了实现高并发和高性能，使用了goroutines来处理Conn的读写事件，这样每个请求都能保持独立，相互不会阻塞，可以高效的响应网络事件。
• ServeMux：自定义的锁（sync.RWMutex），由于请求涉及到并发处理，因此这里需要一个锁机制。

    以下是Go http包的使用示例：

package main

import (
    "fmt"
    "net/http"
)

func sayhello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, Go!")
}

func main() {
    http.HandleFunc("/", sayhello)
    http.ListenAndServe(":9090", nil)
}

    4.8 reflect包：反射机制

 reflect包是Go语言中用于运行时反射的库。

    reflect包主要提供了以下功能：对变量进行反射，获取变量的值、类型信息、修改变量的值以及调用变量的方法。

    以下是reflect包的部分使用示例：

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Tom", Age: 18}
    value := reflect.ValueOf(p)
    fmt.Println(value.FieldByName("Name").String())     // 输出：Tom
    fmt.Println(value.FieldByName("Age").Int())         // 输出：18
    fmt.Println(value.Type().Field(0).Name)             // 输出：Name
    fmt.Println(value.Type().Field(1).Name)             // 输出：Age
    fmt.Println(value.Type().Method(0).Name)           // 输出：String

    value.FieldByName("Name").SetString("Jerry")         // 修改Name字段的值为Jerry
    fmt.Println(value.FieldByName("Name").String())     // 输出：Jerry
}

    4.9 error包：错误处理

 errors包是Go语言中处理错误的一个标准库。

    errors包提供的主要功能有：创建错误对象、判断错误类型、转换错误类型。

    创建错误对象使用errors.New()函数，该函数接收一个字符串参数，返回一个error类型的值。

err := errors.New("something went wrong")

    判断错误类型使用errors.Is()函数，该函数接收两个参数，一个是错误对象，另一个是目标错误类型，返回一个布尔值 。

err := errors.New("invalid input")
err1 := errors.New("invalid input")
fmt.Println(errors.Is(err1, err)) // 输出 false

    转换错误类型使用errors.As()函数，该函数接收两个参数，一个是错误对象，另一个是目标类型，返回一个布尔值。

type MyError struct {
    Code int
    Msg  string
}

err := &MyError{Code: 123, Msg: "something went wrong"}
var target *MyError

if errors.As(err, &target) {
    fmt.Println(target)
} else {
    fmt.Println("err is not of type *MyError")
}

    4.10 sync包：同步机制

 sync包是Go语言中提供的一些简单的同步原语。

    sync包中常用的类型有Mutex、RWMutex、WaitGroup。

• Mutex是互斥锁，提供了Lock和Unlock两个方法，用于保护临界区，同一时间只有一个goroutine能够获取锁并执行临界区代码。
• RWMutex是读写锁，分为读锁和写锁，多个goroutine可以同时持有读锁，但只能有一个goroutine持有写锁。
• WaitGroup用于等待一组goroutine完成。

    以下是使用sync包的示例代码：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    var wg sync.WaitGroup
    var rwmu sync.RWMutex
    var count int

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()
            defer mu.Unlock()
            count++
        }()
    }

    wg.Wait()
    fmt.Println("count:", count)

    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            go func() {
                defer rwmu.RUnlock()
                rwmu.RLock()
                fmt.Println("data:", data)
            }()
        } else {
            go func() {
                defer rwmu.Unlock()
                rwmu.Lock()
                data = "pidancode.com"
            }()
        }
    }
}

五、常用第三方库和框架

    5.1 Gin：用于创建Web应用

    gin是一个使用Go语言实现的HTTP Web框架，具有快速、灵活和容错方便等特点。

    gin的优点：

1. 封装优雅，API友好。
2. 源码注释明确。
3. 发布1.0版本。
4. 快速灵活，容错方便。
5. 支持中间件机制。
6. 可以捕获panic并恢复。
7. 支持解析并验证请求的JSON。

    gin的使用示例：

package main

import (
    "net/http"
    "gopkg.in/gin-gonic/gin.v1"
)

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        name := c.Query("name")
        c.String(http.StatusOK, "Hello %s", name)
    })
    r.Run(":8080")
}

    5.2 Gorm：用于数据库访问

    Gorm是Go语言的ORM库，它具有丰富的功能和良好的扩展性。

    Gorm提供了许多方便的方法和功能，例如：

• 查询所有对象：varusers[]User; result:=db.Find(&users)。
• 指定查询条件（where）：db.Where(&User{Name:"jinzhu"},"name","Age").Find(&users)。
• 限制返回数量：db.Limit(10).Offset(5).Find(&users)。
• 查询部分字段：db.Select("name","age").Find(&users)。
• 查询排序：db.Order("age desc, name").Find(&users)。

    Gorm使用示例：

package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "gorm.io/gorm/logger"
)

type User struct {
    ID   uint   `gorm:"primarykey"`
    Name string `gorm:"column:name"`
    Age  uint   `gorm:"column:age"`
}

func main() {
    // 连接数据库
    dsn := "user=test password=ZHOUjian.22 host=121.36.43.223 port=3306 dbname=cmdb"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    // 设置logger，输出SQL语句和执行时间
    db.Callback().Query().Before("gorm:query").Register("logger", logger.Default.LogFunc())
    // 执行查询
    var users []User
    db.Find(&users)
    // 指定查询条件
    db.Where(&User{Name: "jinzhu"}).Find(&users)
    // 限制返回数量
    db.Limit(10).Offset(5).Find(&users)
    // 查询部分字段（即从select * 改造为 select name, age）
    db.Select("name", "age").Find(&users)
    // 查询并按年龄降序、姓名升序排列
    db.Order("age desc, name").Find(&users)
}

    5.3 Viper：用于配置管理

    Viper是一个完善的Go语言配置包，它的目的是处理各种格式的配置文件信息。Viper支持多种格式的配置文件，如json、toml、yaml、yml、properties、props、prop、hcl、tfvars、dotenv、env、ini等，同时也支持从文件、环境变量、命令行、io.Reader、远程配置中心（etcd、etcd3、consul、firestore）读取和修改配置。Viper可以监听配置文件修改，并应用到程序中。

    Viper使用示例：

// 在main函数中设置配置文件路径和格式
viper.SetConfigType("yaml")
viper.SetConfigName("config")
viper.AddConfigPath("/etc/app/config")
viper.AddConfigPath("./")

// 读取配置文件内容到变量中
viper.Get("server.host") // 获取host的值
viper.Get("server.port") // 获取port的值

    5.4 UUID：生成唯一标识符

    UUID是Universally Unique Identifier的缩写，即通用唯一识别码。

    UUID的目的是让分布式系统中的所有元素，都能有唯一的辨识资讯，而不需要透过中央控制端来做辨识资讯的指定。如此一来，每个人都可以创建不与其它人冲突的UUID。

    在Go语言中，并没有UUID的标准库，所以需要借助第三方库来生成UUID，例如Go-UUID。

    使用示例：

package main

import (
    "fmt"
    "math/rand"
    "time"
    "go-uuid"
)

func main() {
    // 生成一个UUID
    u1, err := go_uuid.NewV4()
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(u1)
}

    5.5 Golang-Boilerplate：快速创建项目模板

    Golang-Boilerplate是一个用于生成Go语言基础代码的模板库。

    Golang-Boilerplate可以帮助开发者快速生成重复的代码，提高开发效率。

    Golang-Boilerplate包含了一些常用的代码片段，如错误处理、日志记录、数据验证等。

    使用Golang-Boilerplate可以减少重复编码，提高代码质量和可维护性。

    下面是一个使用Golang-Boilerplate的示例：

package main

import (
    "fmt"
    "net/http"

    "golang-boilerplate/handler"
)

func main() {
    handler := handler.New()
    http.Handle("/", handler)
    http.ListenAndServe(":8080", nil)
}

    在这个示例中，我们使用了Golang-Boilerplate的handler包来创建一个HTTP处理器，然后通过http.Handle函数将根路径("/")映射到该处理器上，最后通过http.ListenAndServe函数启动了一个HTTP服务器。 

    5.6 Gomega and Gomega matchers：用于测试断言

    Gomega是一个Go语言的测试库，它提供了一些用于编写单元测试和集成测试的断言和匹配器。Gomega匹配器是该库中的一部分，用于测试期望值是否与实际值匹配。

    Gomega匹配器用于判断测试用例中的期望结果是否与实际结果相匹配，如果不匹配，则测试失败。

    Gomega匹配器可以用于测试各种类型的数据，包括基本数据类型、容器、错误、接口和自定义类型。使用Gomega匹配器可以简化测试用例的编写，提高测试的准确性和可读性。

    下面是一些Gomega匹配器的使用示例：

• ShouldEqual：用于比较两个值是否相等，相等则测试通过。

Expect(1).ShouldEqual(1)
Expect("foo").ShouldEqual("foo")

• ShouldNotEqual：用于比较两个值是否不相等，不相等则测试通过。

Expect(1).ShouldNotEqual(2)
Expect("foo").ShouldNotEqual("bar")

• ShouldResemble：用于比较两个值是否具有相同的结构，但不关心具体的值。

Expect([]int{1, 2, 3}).ShouldResemble([]int{1, 2, 3})
Expect([]string{"foo", "bar"}).ShouldResemble([]string{"foo", "bar"})

• ShouldNotResemble：用于比较两个值是否不具有相同的结构。

Expect([]int{1, 2, 3}).ShouldNotResemble([]int{4, 5, 6})
Expect([]string{"foo", "bar"}).ShouldNotResemble([]string{"baz", "qux"})

    以上只是Gomega匹配器的一部分，Gomega还提供了更多的匹配器，可以根据具体的需求选择合适的匹配器。

    5.7 GoDoc：文档生成工具

    GoDoc是Go语言的一个文档生成工具，它可以从Go源代码中自动生成API文档。

    GoDoc可以生成以HTML形式呈现的文档，并支持多种样式和主题。

    GoDoc使用正则表达式来识别注释，注释在源代码中的位置和格式都会被记录下来，然后根据这些信息生成文档。

    使用GoDoc的步骤如下：

1. 在代码中添加注释，注释需要以//开头。
2. 在代码文件所在目录下运行gopls命令，该命令会自动启动GoDoc。
3. 在浏览器中输入localhost:6060/pkg/your/package/name，即可查看生成的文档。其中your/package/name为要查看的包名。

    下面是一个使用GoDoc的示例：

    假设有一个名为test/testdoc/doc.go的文件，内容如下：

/ Package testdoc is a test package
//
// BUG(who):
// Because of BUG(who), this package is not working correctly.
//
// Features:
// This package has many features, such as...
//
// Future works:
// We plan to add more features and fix bugs in the future.

    在浏览器中输入localhost:6060/pkg/test/testdoc，即可查看该包的文档。