Golang on ttz.pw

Golang常用库之UUID

Wed, 21 Feb 2024 14:24:16 +0800

1. 什么是UUID？

通用唯一标识符 (UUID) 是一种特定形式的标识符，在大多数实际用途中可以安全地认为是唯一的。两个正确生成的 UUID 相同的可能性几乎可以忽略不计，即使它们是由不同的各方在两个不同的环境中创建的。这就是为什么说 UUID 是普遍唯一的。

UUID 是唯一的(出于实用目的)：它重复的概率非常接近零。
UUID 不依赖中央机构的注册和分配。

UUID 的字符串表示形式由 32 个十六进制数字组成，以 5 个组显示，由连字符 - 分隔。例如：123e4567-e89b-12d3-a456-426655440000

UUID 的生成有两种

第一种是根据Rand 随机数来生成UUID
第二种是直接调用UUID库

但其实第二种的底层源码中也是调用了Rand库来实现的可以理解成不是单一的随机数封装

2. 根据Rand 随机数来生成UUID

 1// blog: https://www.cnblogs.com/zichliang
 2package main
 3 
 4import (
 5	"crypto/rand"
 6	"fmt"
 7	"log"
 8)
 9 
10func getUUID() (uuid string) {
11	b := make([]byte, 16)
12	fmt.Println(b)
13	_, err := rand.Read(b)
14	if err != nil {
15		log.Fatal(err)
16	}
17	uuid = fmt.Sprintf("%x-%x-%x-%x-%x",
18		b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
19	return
20}
21 
22func main() {
23	uuid := getUUID()
24	fmt.Println(uuid)
25}

3. 调用UUID 库

安装UUID库

1go get -u github.com/satori/go.uuid

3.1. UUID 库基本上分为六种分别是v1 v2，v3，v4,v5,v6

3.1.1. uuid.NewV1

返回基于当前时间戳和MAC地址的UUID。

1u1 := uuid.NewV1()
2fmt.Println("u1 >>>", u1)

3.1.2. uuid.NewV2

返回基于POSIX UID/GID的DCE安全UUID。

1u2 := uuid.NewV2(0)
2fmt.Println("u2 >>>", u2)

3.1.3. uuid.NewV3

返回基于命名空间UUID和名称的MD5哈希的UUID。

1u3 := uuid.NewV3(u2, "abc")
2fmt.Println("u3 >>>", u3)

3.1.4. uuid.NewV4

返回随机生成的UUID。

1u4 := uuid.NewV4()
2fmt.Println("u4 >>>", u4)

3.1.5. uuid.NewV5

返回基于命名空间UUID和名称的SHA-1哈希的UUID。

1u5 := uuid.NewV5(u2, "abc")
2fmt.Println("u5 >>>", u5)

3.1.6. uuid.NewV6

本质上没有差距不过更新版本之前某些方法是有两个返回值的，Must是基于前者进行的一个包装

1u6 := uuid.Must(u5, nil)
2fmt.Println("u6 >>>", u6)

有时候我们需要把一个 uuid的字符串转成UUID可以用到以下方法

1s := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
2uuidObject, err := uuid.FromString(s)
3if err != nil {
4  log.Fatalf("failed to parse UUID %q: %v", s, err)
5}
6fmt.Println("successfully parsed UUID Version", uuidObject)

4. 完整代码

 1// blog: https://www.cnblogs.com/zichliang
 2package main
 3 
 4import (
 5	"fmt"
 6	uuid "github.com/satori/go.uuid"
 7)
 8 
 9func main() {
10 
11	//返回基于当前时间戳和MAC地址的UUID。
12	u1 := uuid.NewV1()
13	fmt.Println("u1 >>>", u1)
14 
15	//返回基于POSIX UID/GID的DCE安全UUID。
16	u2 := uuid.NewV2(0)
17	fmt.Println("u2 >>>", u2)
18 
19	//返回基于命名空间UUID和名称的MD5哈希的UUID。
20	u3 := uuid.NewV3(u2, "abc")
21	fmt.Println("u3 >>>", u3)
22 
23	//返回随机生成的UUID。
24	u4 := uuid.NewV4()
25	fmt.Println("u4 >>>", u4)
26 
27	//返回基于命名空间UUID和名称的SHA-1哈希的UUID。
28	u5 := uuid.NewV5(u2, "abc")
29	fmt.Println("u5 >>>", u5)
30 
31	//本质上  没有差距 不过更新版本之前 某些方法 是有两个返回值的，Must是基于前者 进行的一个包装
32	u6 := uuid.Must(u5, nil)
33	fmt.Println("u6 >>>", u6)
34 
35	//如果 u5 和 u6 相等，则返回true，否则返回false。
36	u7 := uuid.Equal(u5, u6)
37	fmt.Println("u7 >>>", u7)
38 
39	// 将字符串转换成UUID
40	s := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
41	uuidObject, err := uuid.FromString(s)
42	if err != nil {
43		log.Fatalf("failed to parse UUID %q: %v", s, err)
44	}
45	fmt.Println("successfully parsed UUID Version", uuidObject)
46}

通过实例理解Web应用用户密码存储方案

Wed, 21 Feb 2024 11:18:07 +0800

1. Web应用用户密码存储的重要性

用户密码是访问Web应用的关键，它直接关乎到用户账号和应用数据的安全。

如果用户密码被泄露或破解，将导致严重后果。后果最轻的算是某个用户或某少数用户的账号被盗用了，用户将失去对账号的控制。盗用账号后，攻击者可以获取该用户的私密信息，或进行额外的攻击；如果用户在多个应用重复使用同一密码，那么后果将进一步严重，用户的一系列账号都将受到安全威胁；更为严重的是Web应用存储用户账号信息的数据库被攻破(俗称“脱库”)，攻击者会拿到存储的全部用户账号信息等，如果用户密码存储不当，攻击者可以很容易破译所有用户的密码，并基于这些密码信息做进一步的攻击。

由此可见，Web应用必须非常重视用户密码的存储安全。在当前弱密码和频繁密码泄露成为常态的背景下，Web应用开发者有责任使用安全的密码存储方案，尽力保护用户信息安全，即便在被脱库的最糟糕情况下，也不让攻击者轻易破解出用户的密码，这也关系到应用和企业的信誉。

2. 密码存储方案的演进：魔高一尺，道高一丈

Web应用用户密码存储方案的演进历史可以分为以下几个阶段，如图所示：

下面我们按图中的演进顺序，对各阶段的密码存储方案逐一说明一下。

2.1. 起始阶段 – 明文存储

早期的Web应用为了实现简单，采用了最简单“粗暴”的用户密码存储方式：明文存储，即直接把用户的密码以纯文本形式存储在数据库中。

显然这种方式的最大优点就是实现简单，验证登录时直接比对明文密码。但这种方式最大的缺点就是极其不安全，密码一旦泄露就失去了全部保密性。但当时人们的安全意识较弱，该方案被广泛使用。

2.2. 弱哈希算法阶段 – MD5和SHA1

随着时间的推移，CPU和GPU性能的提升使得字典破解和穷举攻击更加可行有效，大量密码被泄露的事件引起人们对密码安全的重视，人们更多地认识到明文存储密码的危险性。同时，Web应用的发展也从追求功能和便利，转变为在易用性与安全性之间求平衡。政府和行业协会也开始指定密码存储的最新安全要求的规范和政策，密码学等相关技术的快速发展也为更安全的密码存储提供了前提和支持。

于是人们开始使用MD5、SHA1等单向哈希算法对密码进行处理，只存储密码的哈希值。虽然增加了一定的密码存储的复杂性，但其最大的优点就是在一定程度上放置了明文存储的密码泄露问题。

不过，随着大量使用MD5和SHA-1的应用遭到破解，这些哈希算法的脆弱性暴露无遗。同时彩虹表攻击的出现，让破解者只需要预计算密码哈希表就可以快速破解以弱哈希存储的密码。

于是技术社区以及安全规范都开始提倡和推荐采用更安全的密码存储方案，即采用加盐方案。

2.3. 加盐哈希阶段 – 增加随机盐值

加盐哈希就是在计算密码的哈希值时，在密码字符串前/后面添加一个称为“盐(salt)”的随机字符串，这个随机字符串称为盐值，它的作用是增加哈希后密码的随机性。

加盐哈希的步骤大致如下图：

在用户注册阶段，系统根据用户输入的密码生成在数据库中的哈希密码值：

系统首先随机生成一个足够长的随机字符串作为盐值，可以使用密码学安全的随机数生成算法；
将盐值与用户输入的原始密码字符串拼接在一起(盐值放在密码的前后均可)；
对连接后的字符串计算哈希值，可以使用MD5、SHA-1、SHA256、SHA-512等哈希算法；由于也被证实MD5、SHA-1存在弱点，可以被碰撞攻击，建议至少使用SHA256算法；
将盐值和哈希值一起存储在数据库中(可以向图中那样将hashed_password和salt通过:分隔符组合为一个字段后再存储在数据库中)。

验证登录时，系统根据用户名取出盐值，然后将用户输入的密码与盐值组合计算哈希值，与存储的原始哈希值比较，相同则验证成功。

在密码哈希前加入随机字符串(即“盐(salt)”)可以大幅增加了破解难度，同时不同用户如采用相同密码，也可以通过不同的盐在哈希后得到不同的哈希值，这可以有效地防止预计算表的攻击。

不过随着硬件算力的飞速提高，比如GPU、专用ASIC芯片以及云计算资源等，密码破解效率进一步提高，甚至普通人也可利用现成的破解工具和云资源进行密码破解，攻击者门槛大幅降低，简单加盐也已出现不能有效对抗硬件加速破解的情况。

于是人们开始考虑使用一些新哈希算法，这些算法可以大幅提高攻击者付出的时间和资源消耗成本，增加密码破解难度，这就是下面我们要说的慢哈希算法。

2.4. 慢哈希算法阶段 – Argon2、Bcrypt、Scrypt和PBKDF2

Argon2、Bcrypt、Scrypt和PBKDF2是目前主流的慢哈希算法，它们与SHA256等快速哈希算法的主要差异点如下:

计算速度更慢，需要消耗更多CPU和内存资源，从而对抗硬件加速攻击；
使用更复杂的算法，组合密码学原语，增加破解难度；
可以配置资源消耗参数，调整安全强度；
特定优化使并行计算困难；
经过长时间的密码学分析，仍然安全可靠。

从这些特点可以知道：这些慢哈希算法更适合密码哈希的原因是可以大幅增加攻击者密码破解的成本，如果这么说大家印象还不够深刻，我们就来量化对比一下，下面是以SHA256和Scrypt两个算法为例做的一个简单的benchmark测试：

 1// web-app-password-storage/benchmark/benchmark_test.go
 2
 3package main
 4
 5import (
 6    "crypto/sha256"
 7    "testing"
 8
 9    "golang.org/x/crypto/scrypt"
10)
11
12func BenchmarkSHA256(b *testing.B) {
13    b.ReportAllocs()
14    data := []byte("hello world")
15    b.ResetTimer()
16
17    for i := 0; i < b.N; i++ {
18        sha256.Sum256(data)
19    }
20}
21
22func BenchmarkScrypt(b *testing.B) {
23    b.ReportAllocs()
24    const keyLen = 32
25    data := []byte("hello world")
26    b.ResetTimer()
27
28    for i := 0; i < b.N; i++ {
29        scrypt.Key(data, data, 16384, 8, 1, keyLen)
30    }
31}

我们看看输出的benchmark结果是什么样的：

1$go test -bench .
2goos: darwin
3goarch: amd64
4pkg: demo
5... ...
6BenchmarkSHA256-8        6097324           195.3 ns/op         0 B/op          0 allocs/op
7BenchmarkScrypt-8             26      41812138 ns/op    16781836 B/op         22 allocs/op
8PASS
9ok      demo    2.533s

我们看到无论是cpu消耗还是内存开销，Scrypt算法都是SHA256的几个数量级的倍数。

加盐的慢哈希也是目前的主流的用户密码存储方案，那有读者会问：这四个算法选择哪个更佳呢？说实话要想对这个四个算法做个全面的对比，需要很强的密码学专业知识，这里直接给结论(当然也是来自网络资料)：建议使用Scrypt或Argon2系列的算法，它们俩可提供更高的抗ASIC和并行计算能力，Bcrypt由于简单高效和成熟，目前也仍十分流行。

不过，慢哈希算法在给攻击者带来时间和资源成本等困难的同时，也给服务端正常的身份认证带来一定的性能开销，不过大多数开发者认为这种设计取舍是值得的。

下面我们就基于慢哈希算法结合加盐，用实例说明一下一个Web应用的用户注册与登录过程中，密码是如何被存储和用来验证用户身份的。

3. 加盐哈希存储方案的示例

在这个示例中，我们建立两个html文件：一个是signup.html，用于模拟用户注册；一个是login.html，用于模拟用户登录：

 1// web-app-password-storage/signup.html
 2
 3<!DOCTYPE html>
 4<html>
 5<head>
 6  <title>注册</title>
 7</head>
 8<body>
 9
10<form action="http://localhost:8080/signup" method="post">
11
12  <label>用户名:</label>
13  <input type="text" name="username"/>
14
15  <label>密码:</label>
16  <input type="password" name="password"/>
17
18  <label>确认密码:</label>
19  <input type="password" name="confirm-password"/>
20
21  <button type="submit">注册</button>
22
23</form>
24
25</body>
26</html>
27
28// web-app-password-storage/login.html
29
30<!DOCTYPE html>
31<html>
32<head>
33  <title>登录</title>
34</head>
35<body>
36
37<form action="http://localhost:8080/login" method="post">
38
39  <label>用户名:</label>
40  <input type="text" name="username"/>
41
42  <label>密码:</label>
43  <input type="password" name="password"/>
44
45  <button type="submit">登录</button>
46
47</form>
48
49</body>
50</html>

接下来，我们来写这个web应用的后端：一个http server：

  1// web-app-password-storage/server/main.go
  2
  3package main
  4
  5import (
  6    "database/sql"
  7    "encoding/base64"
  8    "math/rand"
  9    "net/http"
 10    "strings"
 11    "time"
 12
 13    "golang.org/x/crypto/scrypt"
 14    _ "modernc.org/sqlite"
 15)
 16
 17var db *sql.DB
 18
 19func main() {
 20    // 连接SQLite数据库
 21    var err error
 22    db, err = sql.Open("sqlite", "./users.db")
 23    if err != nil {
 24        panic(err)
 25    }
 26    defer db.Close()
 27
 28    // 创建用户表
 29    sqltable := `
 30        CREATE TABLE IF NOT EXISTS users (
 31            id INTEGER PRIMARY KEY AUTOINCREMENT,
 32            username TEXT,
 33            hashedpass TEXT
 34        );
 35    `
 36    _, err = db.Exec(sqltable)
 37    if err != nil {
 38        panic(err)
 39    }
 40
 41    http.HandleFunc("/login", login)
 42    http.HandleFunc("/signup", signup)
 43    http.ListenAndServe(":8080", nil)
 44}
 45
 46func signup(w http.ResponseWriter, r *http.Request) {
 47    username := r.FormValue("username")
 48    password := r.FormValue("password")
 49    cpassword := r.FormValue("confirm-password")
 50
 51    if password != cpassword {
 52        http.Error(w, "password and confirmation password do not match", http.StatusBadRequest)
 53        return
 54    }
 55
 56    // 注册新用户
 57    salt := generateSalt(16)
 58    hashedPassword := hashPassword(password, salt)
 59    stmt, err := db.Prepare("INSERT INTO users(username, hashedpass) values(?, ?)")
 60    if err != nil {
 61        panic(err)
 62    }
 63    _, err = stmt.Exec(username, hashedPassword+":"+salt)
 64    if err != nil {
 65        panic(err)
 66    }
 67    w.Write([]byte("signup ok!"))
 68}
 69
 70func login(w http.ResponseWriter, r *http.Request) {
 71    username := r.FormValue("username")
 72    password := r.FormValue("password")
 73
 74    // 验证登录
 75    storedHashedPassword, salt := getHashedPasswordForUser(db, username)
 76    hashedLoginPassword := hashPassword(password, salt)
 77    if hashedLoginPassword == storedHashedPassword {
 78        w.Write([]byte("Welcome!"))
 79    } else {
 80        http.Error(w, "Invalid username or password", http.StatusUnauthorized) // 401
 81    }
 82}
 83
 84// 生成随机字符串作为盐值
 85func generateSalt(n int) string {
 86    rand.Seed(time.Now().UnixNano())
 87    letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
 88    b := make([]rune, n)
 89    for i := range b {
 90        b[i] = letters[rand.Intn(len(letters))]
 91    }
 92    return string(b)
 93}
 94
 95// 对密码进行bcrypt哈希并返回哈希值与随机盐值
 96func hashPassword(password, salt string) string {
 97    dk, err := scrypt.Key([]byte(password), []byte(salt), 1<<15, 8, 1, 32)
 98    if err != nil {
 99        panic(err)
100    }
101    return base64.StdEncoding.EncodeToString(dk)
102}
103
104// 从数据库获取用户哈希后的密码和盐值
105func getHashedPasswordForUser(db *sql.DB, username string) (string, string) {
106    var hashedPass string
107    row := db.QueryRow("SELECT hashedpass FROM users WHERE username=?", username)
108    if err := row.Scan(&hashedPass); err != nil {
109        panic(err)
110    }
111    split := strings.Split(hashedPass, ":")
112    return split[0], split[1]
113}

示例的结构比较清晰，这里提供了两个http handler，一个是signup用于接收用户注册请求，一个是login，用于接收处理用户登录请求。在注册请求时，我们生成用户密码的带盐慢哈希值，与salt一起存入数据库，这里用sqlite代替通用关系型数据库；在login handler中，我们根据username读取数据库中的salt和hashed_password，然后基于请求中的password与salt重新做一遍hash，将得到的结果与数据库中读取的hashed_password比较，相同则说明用户输入的密码正确。

Go官方维护的golang.org/x/crypto为我们提供了高质量的scrypt包，当然crypto下也有bcrypt、argon2和pbkdf2的实现，感兴趣的童鞋可以自行研究。

4. 小结

用户密码的安全存储是保障Web应用与用户数据安全的基石。简单的密码存储实践如明文和弱哈希算法存在巨大隐患，而随着计算能力提升，任何weak password都可被轻松破解。为有效保护用户，Web应用必须采取更可靠的密码存储方案。

本文详细介绍了从简单明文、单向哈希到先进的加盐慢哈希的演进历程。我们看到，这是一场与不断增强的攻击手段进行的应对之争。随着硬件计算能力、并行与云计算等技术进步，必须加强密码存储机制的强度。当前，结合随机盐、迭代计算的慢哈希可大幅提高破解难度，是推荐的密码存储安全实践。

当然，密码安全需要持续关注新兴攻击手段，并及时采纳更强大的算法。这不仅是技术问题，也需要整个社区的共同努力，通过提高意识和最佳实践来保护用户。

本文示例所涉及的Go源码可以在这里下载。

5. 参考资料

《API安全实战》 – https://book.douban.com/subject/36039150/

《API安全技术与实战》 – https://book.douban.com/subject/35429043/

保密：系统如何保证敏感数据无法被内外部人员窃取滥用？ – https://time.geekbang.org/column/article/334293

使用casbin做基于RBAC的权限验证

Thu, 23 Mar 2023 00:26:20 +0800

1. 概述

Casbin是一个强大的、高效的开源访问控制框架，其权限管理机制支持多种访问控制模型。

Casbin可以

支持自定义请求的格式，默认的请求格式为{subject, object, action}。
具有访问控制模型model和策略policy两个核心概念。
支持RBAC中的多层角色继承，不止主体可以有角色，资源也可以具有角色。
支持内置的超级用户例如：root或administrator。超级用户可以执行任何操作而无需显式的权限声明。
支持多种内置的操作符，如 keyMatch，方便对路径式的资源进行管理，如 /foo/bar可以映射到/foo*

Casbin不能

身份认证 authentication（即验证用户的用户名、密码），casbin只负责访问控制。应该有其他专门的组件负责身份认证，然后由casbin进行访问控制，二者是相互配合的关系。
管理用户列表或角色列表。 Casbin 认为由项目自身来管理用户、角色列表更为合适，用户通常有他们的密码，但是 Casbin 的设计思想并不是把它作为一个存储密码的容器。而是存储RBAC方案中用户和角色之间的映射关系。

2. 快速入门

2.1. 安装

1go get github.com/casbin/casbin/v2

2.2. 创建模型文件

model.conf

 1[request_definition]
 2r = sub, obj, act
 3
 4[policy_definition]
 5p = sub, obj, act
 6
 7[role_definition]
 8g = _, _
 9
10[policy_effect]
11e = some(where (p.eft == allow))
12
13[matchers]
14m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act

2.3. 创建策略文件

policy.csv

p代表了具体的策略信息，比如alice访问/users的GET访问权限 g代表角色的策略信息，比如alice属于admin组，具有访问/users下的GET和POST权限

1p, alice, /users, GET
2p, bob, /users, POST
3p, admin, /users, GET
4p, admin, /users, POST
5p, admin, /users, DELETE
6g, alice, admin

2.4. 初始化enfocer

 1var (
 2  e   *casbin.Enforcer
 3  err error
 4)
 5
 6func init() {
 7  e, err = casbin.NewEnforcer("model.conf", "policy.csv")
 8  if err != nil {
 9    logrus.Fatal("load file failed, %v", err.Error())
10  }
11}

2.5. 定义一个检测权限的函数

 1func checkPermission(ctx *gin.Context, sub, obj, act string) {
 2  logrus.Infof("sub = %s obj = %s act = %s", sub, obj, act)
 3  ok, err := e.Enforce(sub, obj, act)
 4  if err != nil {
 5    logrus.Print("enforce failed %s", err.Error())
 6    ctx.String(http.StatusInternalServerError, "内部服务器错误")
 7    return
 8  }
 9  if !ok {
10    logrus.Println("权限验证不通过")
11    ctx.String(http.StatusOK, "权限验证不通过")
12    return
13  }
14  logrus.Println("权限验证通过")
15  ctx.String(http.StatusOK, "权限验证通过")
16}

2.6. 定义/users下的2个接口

 1func main() {
 2  r := gin.Default()
 3
 4  r.GET("/users", func(ctx *gin.Context) {
 5    sub := ctx.Query("username")
 6    obj := ctx.Request.URL.Path
 7    act := ctx.Request.Method
 8    checkPermission(ctx, sub, obj, act)
 9  })
10  r.POST("/users", func(ctx *gin.Context) {
11    sub := ctx.Query("username")
12    obj := ctx.Request.URL.Path
13    act := ctx.Request.Method
14    checkPermission(ctx, sub, obj, act)
15  })
16
17  r.Run()
18}

2.7. 运行测试

1go run main.go

请求截图

终端输出

3. API操作

这里使用RBAC中的删除用户操作做演示，更多操作请查看文档API概览

3.1. 创建结构体

1type PermissionObj struct {
2  User string `json:"user" form:"user"`
3  Sub  string `json:"sub" form:"sub"`
4}

3.2. 增加删除接口

 1  r.DELETE("/users", func(ctx *gin.Context) {
 2    // 先验证用户权限 
 3    var p PermissionObj
 4    ctx.ShouldBind(&p)
 5    obj := ctx.Request.URL.Path
 6    act := ctx.Request.Method
 7    logrus.Infof("sub = %s obj = %s act = %s", p.User, obj, act)
 8    ok, err := e.Enforce(p.User, obj, act)
 9    if err != nil {
10      ctx.String(http.StatusInternalServerError, "内部服务器错误")
11      return
12    }
13    if !ok {
14      ctx.String(http.StatusOK, "您没有权限")
15      return
16    }
17    logrus.Println("权限验证通过")
18    // 删除指定用户
19    ok, err = e.DeleteUser(p.Sub)
20    if err != nil {
21      logrus.Info(err.Error())
22      ctx.String(http.StatusInternalServerError, "内部服务器错误")
23      return
24    }
25    if !ok {
26      ctx.String(http.StatusOK, "删除用户失败")
27      return
28    }
29    ctx.String(http.StatusOK, "删除用户成功")
30    e.SavePolicy()
31  })

3.3. 运行

1go run main.go

3.4. 删除用户

3.5. policy文件

看到bob已经从policy文件中删除了。

4. 更多

想了解更多更详细的用法，可以参考casbin官网

Go语言中使用gopsutil进行系统信息采集

Thu, 23 Mar 2023 00:01:23 +0800

1. gopsutil包介绍

psutil是一个跨平台进程和系统监控的Python库，而gopsutil是其Go语言版本的实现。

安装go get github.com/shirou/gopsutil

2. gopsutil包的使用

2.1. 采集CPU相关信息

 1package main
 2
 3import (
 4    "fmt"
 5    "github.com/shirou/gopsutil/cpu"
 6)
 7
 8func main() {
 9    c, _ := cpu.Info()
10    fmt.Println("cpu信息:",c)
11    /*用户CPU时间/系统CPU时间/空闲时间。。。等等
12    用户CPU时间：就是用户的进程获得了CPU资源以后，在用户态执行的时间。
13    系统CPU时间：用户进程获得了CPU资源以后，在内核态的执行时间。
14    */
15    c1,_ := cpu.Times(false)
16    fmt.Println("cpu1:",c1)
17    
18    // CPU使用率，每秒刷新一次
19    for{
20     c2, _ := cpu.Percent(time.Duration(time.Second), false)
21     fmt.Println(c2)
22    }
23}

运行后输出结果如下

1cpu信息: [{"cpu":0,"vendorId":"GenuineIntel","family":"6","model":"78","stepping":3,"physicalId":"","coreId":"","cores":2,"modelName":"Intel(R) Core(TM) i5-6360U CPU @ 2.00GHz","mhz":2000,"cacheSize":256,"flags":["fpu","vme","de","pse","tsc","msr","pae","mce","cx8","apic","sep","mtrr","pge","mca","cmov","pat","pse36","clfsh","ds","acpi","mmx","fxsr","sse","sse2","ss","htt","tm","pbe","sse3","pclmulqdq","dtes64","mon","dscpl","vmx","smx","est","tm2","ssse3","fma","cx16","tpr","pdcm","sse4.1","sse4.2","x2apic","movbe","popcnt","aes","pcid","xsave","osxsave","seglim64","tsctmr","avx1.0","rdrand","f16c","rdwrfsgs","tsc_thread_offset","sgx","bmi1","hle","avx2","smep","bmi2","erms","invpcid","rtm","fpu_csds","mpx","rdseed","adx","smap","clfsopt","ipt","mdclear","tsxfa","ibrs","stibp","l1df","acapmsr","ssbd","syscall","xd","1gbpage","em64t","lahf","lzcnt","prefetchw","rdtscp","tsci"],"microcode":""}]
2cpu1: [{"cpu":"cpu-total","user":28155.8,"system":12587.9,"idle":18629.5,"nice":0.0,"iowait":0.0,"irq":0.0,"softirq":0.0,"steal":0.0,"guest":0.0,"guestNice":0.0}]
3[14.640198511110253]
4[24.371859296492058]
5[36.06965174136557]
6[25.249999999869033]
7[9.750000000003183]
8[10.723192019951934]
9[7.231920199519346]

2.2. 采集内存信息

 1package main
 2
 3import (
 4	"fmt"
 5	"github.com/shirou/gopsutil/mem"
 6)
 7
 8func main() {
 9	//获取物理内存和交换区内存信息
10	m1, _ := mem.VirtualMemory()
11	fmt.Println("m1:", m1)
12	m2, _ := mem.SwapMemory()
13	fmt.Println("m2:", m2)
14}

运行后输出结果如下

1m1: {"total":8589934592,"available":2471567360,"used":6118367232,"usedPercent":71.22716903686523,"free":287182848,"active":2450747392,"inactive":2184384512,"wired":2206617600,"laundry":0,"buffers":0,"cached":0,"writeback":0,"dirty":0,"writebacktmp":0,"shared":0,"slab":0,"sreclaimable":0,"sunreclaim":0,"pagetables":0,"swapcached":0,"commitlimit":0,"committedas":0,"hightotal":0,"highfree":0,"lowtotal":0,"lowfree":0,"swaptotal":0,"swapfree":0,"mapped":0,"vmalloctotal":0,"vmallocused":0,"vmallocchunk":0,"hugepagestotal":0,"hugepagesfree":0,"hugepagesize":0}
2m2: {"total":2147483648,"used":1139802112,"free":1007681536,"usedPercent":53.076171875,"sin":0,"sout":0,"pgin":0,"pgout":0,"pgfault":0,"pgmajfault":0}

2.3. 采集主机信息

 1package main
 2
 3import (
 4    "fmt"
 5    "github.com/shirou/gopsutil/host"
 6)
 7
 8func main() {
 9  h,_ := host.Info()
10  fmt.Println("本机信息：",h)
11}

运行结果如下

1本机信息： {"hostname":"bogon","uptime":123107,"bootTime":1679378749,"procs":529,"os":"darwin","platform":"darwin","platformFamily":"Standalone Workstation","platformVersion":"12.6.3","kernelVersion":"21.6.0","kernelArch":"x86_64","virtualizationSystem":"","virtualizationRole":"","hostid":"7eaf5a50-bd77-5161-807f-c0e6b43c525d"}

2.4. 采集磁盘信息

 1package main
 2
 3import(
 4	"fmt"
 5	"github.com/shirou/gopsutil/disk"
 6)
 7
 8func main(){
 9	 //可以通过psutil获取磁盘分区、磁盘使用率和磁盘IO信息
10	 d1, _ := disk.Partitions(true)  //所有分区
11	 fmt.Println("d1:",d1)
12	 d2, _ := disk.Usage("E:")  //指定某路径的硬盘使用情况
13	 fmt.Println("d2:",d2)
14	 d3, _ := disk.IOCounters()  //所有硬盘的io信息
15	 fmt.Println("d3:",d3)
16}

运行结果输出如下

1d1: [{"device":"/dev/disk1s7s1","mountpoint":"/","fstype":"apfs","opts":"ro,journaled,multilabel"} {"device":"devfs","mountpoint":"/dev","fstype":"devfs","opts":"rw,nobrowse,multilabel"} {"device":"/dev/disk1s4","mountpoint":"/System/Volumes/VM","fstype":"apfs","opts":"rw,noexec,nobrowse,journaled,multilabel,noatime"} {"device":"/dev/disk1s2","mountpoint":"/System/Volumes/Preboot","fstype":"apfs","opts":"rw,nobrowse,journaled,multilabel"} {"device":"/dev/disk1s6","mountpoint":"/System/Volumes/Update","fstype":"apfs","opts":"rw,nobrowse,journaled,multilabel"} {"device":"/dev/disk1s1","mountpoint":"/System/Volumes/Data","fstype":"apfs","opts":"rw,nobrowse,journaled,multilabel"} {"device":"/dev/disk1s5","mountpoint":"/Volumes/Macintosh HD","fstype":"apfs","opts":"ro,journaled,multilabel"} {"device":"map auto_home","mountpoint":"/System/Volumes/Data/home","fstype":"autofs","opts":"rw,nobrowse,automounted,multilabel"}]
2d2: <nil>
3d3: map[disk0:{"readCount":4415145,"mergedReadCount":0,"writeCount":1979881,"mergedWriteCount":0,"readBytes":101074788352,"writeBytes":70279589888,"readTime":3035356,"writeTime":1168835,"iopsInProgress":0,"ioTime":4204191,"weightedIO":0,"name":"disk0","serialNumber":"","label":""}]

2.5. 采集网络信息

 1package main
 2
 3import (
 4	"fmt"
 5
 6	"github.com/shirou/gopsutil/net"
 7)
 8
 9func main() {
10	//获取当前网络连接信息
11	n1, _ := net.Connections("all") //可填入tcp、udp、tcp4、udp4等等
12	fmt.Println("n1:", n1)
13
14	//获取网络读写字节／包的个数
15	n2, _ := net.IOCounters(false)
16	fmt.Println("n2:", n2)
17}

输出结果如下

1n1: [{"fd":8,"family":2,"type":1,"localaddr":{"ip":"10.10.10.7","port":53069},"remoteaddr":{"ip":"76.223.31.44","port":443},"status":"ESTABLISHED","uids":null,"pid":458} {"fd":6,"family":2,"type":1,"localaddr":{"ip":"*","port":80},"remoteaddr":{"ip":"","port":0},"status":"LISTEN","uids":null,"pid":462} 
2...
3n2: [{"name":"all","bytesSent":477026803,"bytesRecv":655952405,"packetsSent":538975,"packetsRecv":656382,"errin":0,"errout":0,"dropin":0,"dropout":67,"fifoin":0,"fifoout":0}]

2.6. 采集进程相关信息

 1package main
 2
 3import (
 4	"fmt"
 5
 6	"github.com/shirou/gopsutil/process"
 7)
 8
 9func main() {
10	//获取到所有进程的详细信息
11	p1, _ := process.Pids() //获取当前所有进程的pid
12	fmt.Println("p1:", p1)
13	ifExists, _ := process.PidExists(10086) // 判断进程是否存在
14	fmt.Println("ifExists:", ifExists)
15
16}

输出结果

1p1: [1 88 89 92 93 94 97 99 101 105 107 108 110 114 115 116 117 120 124 125 126 127 128 129 130 131 136 137 138 140 141 144 145 146 149 150 151 152 153 154 155 156 157 158 161 162 163 165 169 170 178 183 210 211 214 215 216 217 225 226 227 228 229 230 231 233 234 236 238 240 242 244 247 249 250 252 256 257 259 260 261 263 264 265 266 269 284 315 317 319 324 325 326 327 329 333 334 340 341 343 346 347 348 349 354 359 360 362 363 364 368 370 371 374 376 378 379 380 382 389 390 391 392 393 396 397 398 399 400 401 402 405 406 407 408 411 412 413 414 415 416 417 418 419 420 421 422 423 424 426 427 428 429 430 431 432 433 434 436 437 438 439 441 442 443 445 446 447 449 450 451 452 453 454 455 456 458 459 462 463 465 466 467 469 471 472 473 474 475 477 479 481 482 483 484 485 486 487 488 489 490 491 492 493 496 499 500 501 502 503 504 505 506 507 508 509 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 528 529 530 531 532 533 534 535 536 537 539 540 543 544 545 546 547 548 551 552 553 554 555 556 557 558 559 560 562 563 565 566 567 568 569 570 571 572 575 576 577 578 579 580 581 582 583 584 585 641 644 645 646 648 651 653 654 655 656 658 659 660 661 662 663 664 665 666 667 668 671 672 674 680 684 685 686 689 691 694 697 698 699 700 701 703 707 709 710 711 712 719 723 731 733 747 759 760 761 762 763 771 791 809 810 849 871 884 885 933 947 1028 1291 1363 1379 1380 1381 1382 1383 1463 1488 1489 1490 1667 1760 1761 2007 2080 2082 2270 2271 2272 2295 2298 2988 3001 3113 3874 3909 3925 4334 4338 4340 4341 4342 4343 4344 4385 4387 4389 4568 4569 5280 5283 5284 5294 5295 5296 5297 5298 5299 5301 5302 5304 5580 5684 5725 5726 5841 7509 7698 7739 8109 8111 8377 9009 9016 9077 9139 9140 9250 9366 9368 9370 9373 9380 9415 9714 10047 10109 10232 10278 10308 10503 10511 10512 10513 10610 10767 10783 11008 21605 21739 21740 21741 21750 21768 21848 21872 21873 21881 21908 21935 21939 21940 22098 22100 22106 22108 22109 22114 22115 22116 22117 22118 22119 22120 22121 22125 22126 22127 22195 22940 22942 23332 23334 23335 23635 23781 23825 23832 23882 23886 23887 23888 23891 23892 23951 23953 23954 23955 23957 23958 23959 23960 23961 24139 24140 24141 24142 26215 26216 26219 26988 26989 27028 28757 28758 28759 28760 28769 29834 29847 29848 29873 29874 29889 29943 29958 29970 30020 30921 30925 30926 30933 30934 30950 30952 30981 30982 31562 32280 32283 32284 32285 32286 32315 32459 32460 32505 32561 32596 32703 32734 32735 32738]
2ifExists: false

3. 应用领域

3.1. 服务器性能监控

写一个程序，周期性的获取服务器的各项指标数据，存入数据库中，然后通过界面进行查询，方便排查故障。

Go语言实现发送短信验证码并登录

Fri, 17 Mar 2023 13:20:05 +0800

现在大多数app或wap都实现了通过手机号获取验证码进行验证登录，下面来看下用go来实现手机号发送短信验证码登录的过程，基于的框架是gin 。

首先是短信服务商的申请，比如腾讯云、阿里云、网易易盾等，腾讯云自己申请个微信公众号就行，然后申请相关的短信签名、和短信模板，腾讯有100条试用喔。

具体的代码实现

配置腾讯云短信服务的发送短信相关配置，具体可以参考腾讯云短信服务的api 文档，进行配置

1sms:
2  secret-key:  #秘钥，可在控制台查询
3  secret-id:  #秘钥id ,可在控制台查询
4  sms-sdk-app-id:  #应用id
5  Sign-name:  #申请的签名
6  template-id:  #模板id

go 这里采用的是viper进行加载配置，相关的加载配置代码如下

定义相关的配置结构体，并加载到整个项目的总的options 配置结构体中

 1// sms 发送短信的配置options
 2type SmsOptions struct {
 3 SecretKey   string `json:"secret-key,omitempty" mapstructure:"secret-key"`
 4 SecretId    string `json:"secret-id,omitempty" mapstructure:"secret-id"`
 5 SmsSdkAppId string `json:"sms-sdk-app-id,omitempty" mapstructure:"sms-sdk-app-id"`
 6 SignName    string `json:"sign-name,omitempty" mapstructure:"sign-name"`
 7 TemplateId  string `json:"template-id,omitempty" mapstructure:"template-id"`
 8}
 9
10func NewSmsOptions() *SmsOptions {
11 return &SmsOptions{
12  SecretKey:   "",
13  SecretId:    "",
14  SmsSdkAppId: "",
15  SignName:    "",
16  TemplateId:  "",
17 }
18}
19
20// 这为项目总的一个options配置，项目启动的时候会将yaml中的加载到option中
21type Options struct {
22 GenericServerRunOptions *genericoptions.ServerRunOptions `json:"server" mapstructure:"server"`
23 MySQLOptions *genericoptions.MySQLOptions `json:"mysql" mapstructure:"mysql"`
24 InsecuresServing *genericoptions.InsecureServerOptions `json:"insecure" mapstructure:"insecure"`
25 Log *logger.Options `json:"log" mapstructure:"log"`
26 RedisOptions *genericoptions.RedisOptions `json:"redis" mapstructure:"redis"`
27 SmsOptions *genericoptions.SmsOptions `json:"sms" mapstructure:"sms"`
28} 
29 
30func NewOptions() *Options  {
31 o:=Options{
32  GenericServerRunOptions: genericoptions.NewServerRunOptions(),
33  MySQLOptions: genericoptions.NewMySQLOptions(),
34  InsecuresServing: genericoptions.NewInsecureServerOptions(),
35  RedisOptions: genericoptions.NewRedisOptions(),
36  Log: logger.NewOptions(),
37  SmsOptions: genericoptions.NewSmsOptions(),
38 }
39 return &o
40}

viper加载配置的代码如下

 1func AddConfigToOptions(options *options.Options) error {
 2    viper.SetConfigName("config")
 3    viper.AddConfigPath("config/")
 4    viper.SetConfigType("yaml")
 5    err := viper.ReadInConfig()
 6    if err != nil {
 7        return err
 8    }
 9
10
11    optDecode := viper.DecodeHook(mapstructure.ComposeDecodeHookFunc(mapstructure.StringToTimeDurationHookFunc(), StringToByteSizeHookFunc()))
12
13
14    err = viper.Unmarshal(options, optDecode)
15    fmt.Println(options)
16    if err != nil {
17        return err
18    }
19    return nil
20}
21
22
23func StringToByteSizeHookFunc() mapstructure.DecodeHookFunc {
24    return func(f reflect.Type,
25    t reflect.Type, data interface{}) (interface{}, error) {
26        if f.Kind() != reflect.String {
27            return data, nil
28        }
29        if t != reflect.TypeOf(datasize.ByteSize(5)) {
30            return data, nil
31        }
32        raw := data.(string)
33        result := new(datasize.ByteSize)
34        result.UnmarshalText([]byte(raw))
35        return result.Bytes(), nil
36    }
37}

下面是发送验证码的实现

 1type SmsClient struct {
 2    Credential *common.Credential
 3    Region     string
 4    Cpf        *profile.ClientProfile
 5    Request    SmsRequest
 6}
 7
 8type Option func(*SmsClient)
 9
10func NewSmsClient(options ...func(client *SmsClient)) *SmsClient {
11    client := &SmsClient{
12        Region: "ap-guangzhou",
13        Cpf:    profile.NewClientProfile(),
14    }
15    for _, option := range options {
16        option(client)
17    }
18    return client
19
20}
21
22func WithRequest(request SmsRequest) Option {
23    return func(smsClient *SmsClient) {
24        smsClient.Request = request
25    }
26}
27
28func WithCredential(options options.SmsOptions) Option {
29    return func(smsClient *SmsClient) {
30        smsClient.Credential = common.NewCredential(options.SecretId, options.SecretKey)
31    }
32}
33func WithCpfReqMethod(method string) Option {
34    return func(smsClient *SmsClient) {
35        smsClient.Cpf.HttpProfile.ReqMethod = method
36    }
37}
38func WithCpfReqTimeout(timeout int) Option {
39    return func(smsClient *SmsClient) {
40        smsClient.Cpf.HttpProfile.ReqTimeout = timeout
41    }
42}
43func WithCpfSignMethod(method string) Option {
44    return func(smsClient *SmsClient) {
45        smsClient.Cpf.SignMethod = method
46    }
47}
48
49func (s *SmsClient) Send() bool {
50    sendClient, _ := sms.NewClient(s.Credential, s.Region, s.Cpf)
51    _, err := sendClient.SendSms(s.Request.request)
52    if _, ok := err.(*errors.TencentCloudSDKError); ok {
53        logger.Warnf("An API error has returned: %s", err)
54        return false
55    }
56
57    if err != nil {
58        logger.Warnf("发送短信失败:%s,requestId:%s", err)
59        return false
60    }
61    logger.Info("发送短信验证码成功")
62    return true
63}

定义发送的client,这里采用function option 的编程模式来初始化发送的client.和发送的request,request的代码如下

 1type SmsRequest struct {
 2    request *sms.SendSmsRequest
 3}
 4
 5func NewSmsRequest(options *options.SmsOptions, withOptions ...func(smsRequest *SmsRequest)) *SmsRequest {
 6    request := sms.NewSendSmsRequest()
 7
 8    request.SmsSdkAppId = &options.SmsSdkAppId
 9    request.SignName = &options.SignName
10    request.TemplateId = &options.TemplateId
11    smsRequest := &SmsRequest{request: request}
12    for _, option := range withOptions {
13        option(smsRequest)
14    }
15    return smsRequest
16
17}
18
19type RequestOption func(*SmsRequest)
20
21func WithPhoneNumberSet(phoneSet []string) RequestOption {
22    return func(smsRequest *SmsRequest) {
23        smsRequest.request.PhoneNumberSet = common.StringPtrs(phoneSet)
24    }
25}
26
27func WithTemplateParamSet(templateSet []string) RequestOption {
28    return func(smsRequest *SmsRequest) {
29        smsRequest.request.TemplateParamSet = common.StringPtrs(templateSet)
30    }
31}

创建发送验证码的控制层，发送成功，并将此处的电话号码和验证码保存到redis缓存中，用来登录时候的验证码有效性的校验

 1func (u *userService) SendPhoneCode(ctx context.Context, phone string) bool {
 2    // 获取配置参数
 3    smsSetting := global.TencenSmsSetting
 4    phoneSet := []string{phone}
 5    // 随机生成6位的验证码
 6    var randCode string = fmt.Sprintf("%06v", rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(1000000))
 7    templateSet := []string{randCode, "60"}
 8    smsRequest := tencenSms.NewSmsRequest(smsSetting, tencenSms.WithPhoneNumberSet(phoneSet), tencenSms.WithTemplateParamSet(templateSet))
 9    smsClient := tencenSms.NewSmsClient(tencenSms.WithRequest(*smsRequest), tencenSms.WithCredential(*smsSetting))
10    go smsClient.Send()
11    // 将验证码和手机号保存到redis中
12    _ = u.cache.UserCaches().SetSendPhoneCodeCache(ctx, phone, randCode)
13    return true
14
15}

后面是通过手机验证码进行登录的流程

 1func (u *userService) LoginByPhoneCode(ctx context.Context, phone string, phoneCode string) (*model.User,error) {
 2    // 从缓存中获取该手机号对应的验证码是否匹配
 3    cacheCode, err :=u.cache.UserCaches().GetSendPhoneCodeFromCache(ctx,phone)
 4    if err != nil {
 5        return nil, errors.WithCode(code.ErrUserPhoneCodeExpire,err.Error())
 6    }
 7    if cacheCode!=phoneCode {
 8        return nil,errors.WithCode(code.ErrUserPhoneCodeMiss,"")
 9    }
10    return &model.User{
11        Nickname: "lala",
12    }, nil
13}

使用 channel 控制并发数量

Fri, 17 Mar 2023 12:37:57 +0800

1. 协程

goroutine 是轻量级线程，调度由 Go 运行时进行管理的。Go 语言的并发控制主要使用关键字 go 开启协程 goroutine。Go 协程（Goroutine）之间通过信道（channel）进行通信，简单的说就是多个协程之间通信的管道。信道可以防止多个协程访问共享内存时发生资源争抢的问题。语法格式：

1// 普通函数创建 goroutine
2go 函数名(参数列表)
3
4//匿名函数创建 goroutine
5go func(参数列表){
6    //函数体
7}(调用参数列表)

协程可以开启多少个？是否有限制呢？

 1func testRoutine() {
 2    var wg sync.WaitGroup
 3    for i := 0; i < math.MaxInt32; i++ {
 4        wg.Add(1)
 5        go func(i int) {
 6            defer wg.Done()
 7            fmt.Printf("并发数量：%d/n", i)
 8            time.Sleep(time.Second)
 9        }(i)
10    }
11    wg.Wait()
12}

以上代码开启了 math.MaxInt32个协程的并发，执行后可以看到结果直接 panic：“panic: too many concurrent operations on a single file or socket (max 1048575)”。整个并发操作超出了系统最大值。

2. 控制协程数量

sync 同步机制

使用 sync.WaitGroup 启动指定数量的协程 goroutine。

 1func testRoutine() {
 2    var wg = sync.WaitGroup{}
 3
 4    taskCount := 5 // 指定并发数量
 5    for i := 0; i < taskCount; i++ {
 6        wg.Add(1)
 7        go func(i int) {
 8            fmt.Println("go func ", i)
 9            wg.Done()
10        }(i)
11    }
12    wg.Wait()
13}

如果 taskcount 设置的很大超出了限制的，则其还是没有控制到并发数量。可以优化下设计，类似池的设计思想，通过允许最大连接数控制量，当超出了数量就需要等待释放，有空闲的连接的时候才可以继续执行。

 1func testRoutine() {
 2    task_chan := make(chan bool, 3) //100 为 channel长度
 3    wg := sync.WaitGroup{}
 4    defer close(task_chan)
 5    for i := 0; i < math.MaxInt; i++ {
 6        wg.Add(1)
 7        fmt.Println("go func ", i)
 8        task_chan <- true
 9        go func() {
10                <-task_chan
11                defer wg.Done()
12        }()
13    }
14
15    wg.Wait()
16}

创建缓冲区大小为 3 的 channel，在没有被接收的情况下，至多发送 3 个消息则被阻塞。通过 channel 控制每次并发的数量。
开启协程前，设置 task_chan <- true，若缓存区满了则阻塞
协程任务执行完成后就释放缓冲区
等待所有的并发都处理结束后则函数结束。其实可以不使用 sync.WaitGroup。因使用 channel 控制并发处理的任务数量可以不用使用等待并发处理结束。

3. 参考资料：

boilingfrog.github.io/2021/04/14/控制goroutine的数量/

GoCSV包：一个能将结构体和csv文件直接互转的工具

Fri, 17 Mar 2023 11:44:44 +0800

1. gocsv小档案

大家在开发中一定遇到过将数据导出成csv格式文件的需求。go标准库中的csv包是只能写入字符串类型的切片。而在go中一般都是以结构体为操作对象，若使用标准的csv包，就需要将结构体先转换成对应的字符串类型，再写入文件。那可不可以将结构体对象直接输出成csv格式内容呢？

今天给大家推荐的就是一个能将结构体和csv内容进行快速互转的工具包：gocsv

1. gocsv小档案

gocsv 小档案
star	1.5 k
used by	1.6k
contributors	80
作者	gocarina
功能简介	提供一个简单、高效地将csv内容和结构体进行互转的功能
项目地址	https://github.com/gocarina/gocsv
相关知识	reflect、结构体tag

1.1. gocsv的基本功能

gocsv包的最基本的作用就是能够方便的将csv内容转换到对应的结构体上，或者将结构体的内容快速的转换成csv格式（包括写入文件）。

1.2. gocsv.UnmarshalFile函数：csv内容转成结构体

假设文件中的内容如下：

1client_id,client_name,client_age
21,Jose,42
32,Daniel,26
43,Vincent,32

然后从文件中读取出内容，并直接转换到结构体Client上，如下：

 1package main
 2
 3import (
 4 "fmt"
 5 "os"
 6
 7 "github.com/gocarina/gocsv"
 8)
 9
10type NotUsed struct {
11 Name string
12}
13
14type Client struct { // Our example struct, you can use "-" to ignore a field
15 Id            string `csv:"client_id"`
16 Name          string `csv:"client_name"`
17 Age           string `csv:"client_age"`
18 NotUsedString string `csv:"-"`
19 NotUsedStruct NotUsed `csv:"-"` 
20}
21
22func main() {
23 clientsFile, err := os.OpenFile("clients.csv", os.O_RDWR|os.O_CREATE, os.ModePerm)
24 if err != nil {
25  panic(err)
26 }
27 defer clientsFile.Close()
28
29 clients := []*Client{}
30
31 if err := gocsv.UnmarshalFile(clientsFile, &clients); err != nil { // Load clients from file
32  panic(err)
33 }
34 for _, client := range clients {
35  fmt.Println("Hello", client.Name)
36 }
37}

1.3. gocsv.MarshalFile函数：结构体转成csv文件

 1package main
 2
 3import (
 4 "fmt"
 5 "os"
 6
 7 "github.com/gocarina/gocsv"
 8)
 9
10type NotUsed struct {
11 Name string
12}
13
14type Client struct { // Our example struct, you can use "-" to ignore a field
15 Id            string `csv:"client_id"`
16 Name          string `csv:"client_name"`
17 Age           string `csv:"client_age"`
18 NotUsedString string `csv:"-"`
19 NotUsedStruct NotUsed `csv:"-"` 
20}
21
22func main() {
23 clientsFile, err := os.OpenFile("clients.csv", os.O_RDWR|os.O_CREATE, os.ModePerm)
24 if err != nil {
25  panic(err)
26 }
27 defer clientsFile.Close()
28
29 clients := []*Client{}
30
31 clients = append(clients, &Client{Id: "12", Name: "John", Age: "21"}) // Add clients
32 clients = append(clients, &Client{Id: "13", Name: "Fred"})
33 clients = append(clients, &Client{Id: "14", Name: "James", Age: "32"})
34 clients = append(clients, &Client{Id: "15", Name: "Danny"})
35 
36 err = gocsv.MarshalFile(&clients, clientsFile) // Use this to save the CSV back to the file
37 if err != nil {
38  panic(err)
39 }
40
41}

1.4. 自定义类型转换器

gocsv包还可以给自定义的结构体类型定义csv和结构体的互转函数。只要自定义的类型实现如下接口即可：

1type TypeMarshaller interface {
2 MarshalCSV() (string, error)
3}
4
5// TypeUnmarshaller is implemented by any value that has an UnmarshalCSV method
6// This converter is used to convert a string to your value representation of that string
7type TypeUnmarshaller interface {
8 UnmarshalCSV(string) error
9}

或者将结构体转换成csv字符串时，需要实现如下接口：

1// MarshalText encodes the receiver into UTF-8-encoded text and returns the result.
2type TextMarshaler interface {
3 MarshalText() (text []byte, err error)
4}
5
6type TextUnmarshaler interface {
7 UnmarshalText(text []byte) error
8}

例如，我们定义了一个结构体DateTime，里面有一个time.Time类型的属性。并且DateTime类型实现了TypeMarshaller接口的MarshalCSV函数和TypeUnmarshaller接口的UnmarshalCSV函数。如下：

 1type DateTime struct {
 2 time.Time
 3}
 4
 5// Convert the internal date as CSV string
 6func (date *DateTime) MarshalCSV() (string, error) {
 7 return date.Time.Format("20060201"), nil
 8}
 9
10// You could also use the standard Stringer interface 
11func (date *DateTime) String() (string) {
12 return date.String() // Redundant, just for example
13}
14
15// Convert the CSV string as internal date
16func (date *DateTime) UnmarshalCSV(csv string) (err error) {
17 date.Time, err = time.Parse("20060201", csv)
18 return err
19}
20
21type Client struct { // Our example struct with a custom type (DateTime)
22 Id       string   `csv:"id"`
23 Name     string   `csv:"name"`
24 Employed DateTime `csv:"employed"`
25}
26
27func main() {
28
29 client := []Client{
30  {
31   Id: "001",
32   Name: "Go学堂",
33   Employed: DateTime{time.Now()},
34  },
35 }
36
37 csvContent, _ := gocsv.MarshalString(client)
38 fmt.Println("csv:", csvContent) //输出内容是 001,Go学堂,20231003
39}

当我们运行上述代码，最终的输出内容是：

1001,xzeu,20231003

最后的日期就是按DateTime的MarshalCSV函数格式输出的。

1.5. 自定义CSV的Reader/Writer

在开头处我们提到，csv文件中的分隔符默认是逗号。但也可以是其他字符。这就要求我们在读取或写入之前指定好内容的分隔号。那么就可以通过自定义的Reader/Writer来覆盖默认的Reader/Writer的选项。如下：

指定读取内容的分割符是 “|”

1gocsv.SetCSVReader(func(in io.Reader) gocsv.CSVReader {
2    r := csv.NewReader(in)
3 r.Comma = '|'
4    return r // Allows use pipe as delimiter
5})

指定写入的内容是用分割符 “|” 进行分割的

1gocsv.SetCSVWriter(func(out io.Writer) *gocsv.SafeCSVWriter {
2 writer := csv.NewWriter(out)
3    writer.Comma = '|'
4    return gocsv.NewSafeCSVWriter(writer)
5})

1.6. gocsv包的特点总结

结构体切片和csv内容互转。能够将结构体切片（或数组）直接输出成csv内容或输出到文件。反之亦然。
csv标签。其转换过程是通过结构体上的“csv”标签进行关联的。
csv标签对应csv内容表头。当结构体和csv格式互转时，结构体中的csv标签对应的就是csv表格的表头，结构体中的字段顺序对应的就是csv文件列的顺序。
底层依然是使用标准库中的csv。在写入csv文件时，底层实际上用的还是go标准库中的encoding/csv/Writer结构体的Write(row []string)方法。
自动将结构体字段的类型转换成字符串：大家看到标准csv包中的Write方法的入参是string类型的切片，而在要转换的结构体上的字段可以是各种类型。这里就是gocsv包中的一个特点：可以将字段中的非string类型转换成string类型，最终写入到csv文件中。
可自定义类型转换器。可以通过实现TypeMarshaller接口或TypeUnMarshaller接口对自定义类型的内容按对应的格式输出成csv内容。
可自定义CSV的Reader/Writer来覆盖默认参数。比如csv格式的内容默认使用逗号分隔内容。通过该功能我们可以指定使用其他分隔符的csv内容。比如使用"|“或”;“等。这里需要注意的是将csv文件的内容一定是解析到结构体类型的切片或数组中。同样，也只有是结构体类型的切片或数组才能直接写入到csv文件中。

Golang Httprequest

Thu, 10 Nov 2022 19:57:29 +0800

Go语言HttpRequest项目源码地址： https://github.com/kirinlabs/HttpRequest

主要实现功能

支持常用的GET、POST、DELETE、PUT等
GET 除了正常请求url，也可以附带"name=flyfreely&address=beijing"或者map[string]interface{} 两种参数，包会自动整合到QueryString中
POST 支持string, []byte, *bytes.Reader, *bytes.Buffer, *strings.Reader, map[string]interface{}等参数; 如果发送JSON请求，几乎可以支持发送所有数据类型。
支持自定义Transport

具有快速构建Headers、Cookies、设置超时时间、请求、耗时、打印请求信息等功能

安装：

1go get https://github.com/kirinlabs/HttpRequest

发送请求

导入HttpRequest

1import "github.com/kirinlabs/HttpRequest"

实例化：

1req := HttpRequest.NewRequest()

然后，尝试获取某个网页。我们来获取 Github 的公共时间线

1res,err := req.Get("https://api.github.com/events")

返回一个res的Response对象和err的Error对象

自定义Transport

 1var transport *http.Transport
 2 
 3func init() {   
 4    transport = &http.Transport{
 5        DialContext: (&net.Dialer{
 6            Timeout:   30 * time.Second,
 7            KeepAlive: 30 * time.Second,
 8            DualStack: true,
 9        }).DialContext,
10        MaxIdleConns:          100, 
11        IdleConnTimeout:       90 * time.Second,
12        TLSHandshakeTimeout:   5 * time.Second,
13        ExpectContinueTimeout: 1 * time.Second,
14    }
15}
16 
17func demo(){
18    // Use http.DefaultTransport
19    res, err := HttpRequest.Get("http://127.0.0.1:8080")
20 
21    // Use custom Transport
22    res, err := HttpRequest.Transport(transport).Get("http://127.0.0.1:8080")
23}

Post 请求

 1//无参请求
 2res,err := req.Post("https://www.baidu.com")
 3 
 4//发送整数类型
 5res,err := req.Post("https://www.baidu.com",uint32(100))
 6 
 7//发送[]byte
 8res,err := req.Post("https://www.baidu.com",[]byte("bytes data"))
 9 
10//发送*bytes.Reader,*strings.Reader,*bytes.Buffer
11data := bytes.NewReader(buf []byte)
12res,err := req.Post("https://www.baidu.com",data)
13res,err := req.Post("https://www.baidu.com",strings.NewReader("string data"))
14 
15//请求体为文本
16res,err := req.Post("https://www.baidu.com","hello")
17 
18 
19//请求体为Json字符串
20res,err := req.Post("https://www.baidu.com","{\"name\":\"github\"}")
21 
22 
23//map传参
24res.err := req.Post("https://www.baidu.com",map[string]interface{}{
25    "name":"github",
26    "type":1,
27})

也可以不用实例化，直接发送请求

 1//快速发送Get请求
 2res,err := HttpRequest.Get("https://www.baidu.com")
 3 
 4res,err := HttpRequest.Get("https://www.baidu.com","title=baidu")
 5 
 6 
 7//快速发送Post请求
 8res,err := HttpRequest.Post("https://www.baidu.com")
 9 
10//发送整数类型
11res,err := req.Post("https://www.baidu.com",uint32(100))
12 
13//发送[]byte
14res,err := req.Post("https://www.baidu.com",[]byte("bytes data"))
15 
16//发送*bytes.Reader,*strings.Reader,*bytes.Buffer
17res,err := req.Post("https://www.baidu.com",bytes.NewReader(buf []byte))
18res,err := req.Post("https://www.baidu.com",bytes.NewBuffer(buf []byte))
19res,err := req.Post("https://www.baidu.com",strings.NewReader("string data"))
20 
21 
22res,err := HttpRequest.Post("https://www.baidu.com","title=baidu&type=pdf")
23 
24res,err := HttpRequest.Post("https://www.baidu.com",map[string]interface{}{
25    "title":"baidu",
26})
27 
28 
29//快速发送JSON请求
30res,err := HttpRequest.JSON().Post("https://www.baidu.com",map[string]interface{}{
31    "title":"baidu",
32})
33 
34res,err := HttpRequest.JSON().Post("https://www.baidu.com",`{"title":"baidu","type":"pdf"}`)

传递URL参数

你想为URL的查询字符串(query string)传递数据。如：手工构建URL,http://www.baidu.com/index?key=value。HttpRequest允许你使用第2个参数以字符串"id=100&name=github"或map[string]interface{}{“id”:10,“name”:“github”}字典的形式把数据传递给URL：

手工传参：

1res,err := req.Get("https://www.baidu.com/index?name=github")

字符串传参：

1res,err := req.Get("https://www.baidu.com/index?name=github","id=100&type=1")

map传参：

1res,err := req.Get("https://www.baidu.com/index?name=github",map[string]interface{}{
2    "id":10,
3    "type":1,
4})

响应内容

能读取服务器响应的内容

1res,err := req.Post("https://api.github.com/events")

获取服务器返回的内容：

1body,err := res.Body()
2 
3fmt.Println(string(body))

获取服务器响应状态码：

1res.StatusCode()

获取服务器响应Headers:

1res.Headers()

返回一个map[string]string的字典

获取请求响应时间：

1res.Time()

Json响应内容

HttpRequest内置JSON解码，来解析JSON数据：

1//Format the json return value
2body, err := res.Json() 
3 
4fmt.Println(body)

如果JSON解码失败，会返回一个err错误

定制请求头

如果想为请求添加HTTP头部信息，只需要简单的传一个map给SetHeaders方法

1req.SetHeaders(map[string]string{
2    "Content-Type":"application/json",
3    "Source":"api",
4})

注：所有header值必须是字符串，SetHeaders可以多次调用，如果Key重复则会覆盖前面设置的值

BasicAuth 认证