分类 Go 下的文章

在 Go 语言中,我们通常使用两种包来生成随机数,分别是用于生成伪随机数的 math/rand 包和用于生成加密安全随机数的 crypto/rand 包。

使用 math/rand

  1. 生成随机数math/rand 包提供了如 rand.Int()rand.Intn(n)(生成 0 到 n-1 的整数)和 rand.Float64()(生成范围在 0.0, 1.0) 的浮点数)等函数,可以用来生成伪随机数[3。
  2. 设置种子
    默认情况下,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内部使用操作系统提供的随机性资源,因此不需要也不能通过设置种子来改变随机结果。

基本使用方式

  1. 生成随机字节
    常见的做法是先生成一个字节切片,然后利用 io.ReadFullrand.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())
    }

    这里我们不需要设置种子,而是直接依赖操作系统安全地生成随机数。

  2. 生成安全随机整数
    如果需要生成一个加密安全的随机整数,可以使用 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)) // 生成区间 [0,900) 内的随机数
    if err != nil {
        panic(err)
    }
    result := n.Int64() + 100 // 加上100,变换到 [100, 999] 区间
    fmt.Println("随机生成的三位数是:", result)
}

这里说明几点:

  • 使用 rand.Int(rand.Reader, big.NewInt(900)) 能确保生成的随机数是加密安全的,并且不需要设置种子,因为它直接调用了操作系统的随机资源。
  • 生成的随机数范围是 [0,899],再加上 100 后就得到了三位数 [100, 999] 的结果。

假设想实现的是文章(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;"` // 指定关联的多对多关系
}

说明

  1. 多对多关系标记
    TagArticle 结构体中,都使用了 gorm:"many2many:article_tags;" 标记。这告诉 GORM:

    • 这两个表之间存在多对多关系。
    • 关联关系使用的中间表命名为 article_tags。如果不指定,GORM 会根据一定规则生成。
  2. 自动管理中间表
    使用上述标记后,GORM 在执行自动迁移(AutoMigrate)时会自动创建中间表 article_tags,其中包含两个外键字段(例如 article_idtag_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)
}

目前的问题是:在插入文章的同时直接传入包含多个 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
    })
}

说明

  1. 事务使用
    使用 db.Transaction 来确保整个操作的原子性,如果中间任一步出现错误,整个事务会回滚。
  2. Tag 去重逻辑
    对于每个传入的 Tag,我们先根据唯一字段(比如 Name)进行查找:

    • 如果找不到则使用 tx.Create(&tag) 新建标签;
    • 如果找到了,则直接使用已存在的标签,避免重复插入。
  3. 自动建立关联
    当调用 tx.Create(&article) 时,GORM 会自动处理多对多关系,将 article.Tags 中的 Tag 信息写入关联表 article_tags。注意这要求你的 Article 模型中所定义的多对多标签 gorm:"many2many:article_tags;" 是正确设置的。

通过这种方式,每次插入文章时,相同的 Tag 都只会在数据库中保留一条记录,而只是在关联表中添加一条关联记录。这样既避免了数据冗余,也能保持多对多关系的正确性。

直接调用 db.Delete(&article) 仅会删除 articles 表中的记录,而不会自动清除多对多关联关系(即 article_tags 连接表中的记录)。

在 GORM 中,对于多对多关联,如果需要同时删除关联关系,需要使用 Association Mode 来额外处理,例如:

// 删除文章所有 Tag 关联(删除连接表中的记录)
db.Model(&article).Association("Tags").Clear()

或者,可以配置数据库中的外键约束(例如添加 ON DELETE CASCADE),不过这需要在数据库层面配置,是另一种实现方式。

安装

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