AI 助理
备案控制台
开发者社区 数据库 文章 正文

Go语言之GORM框架(二) ——GORM的单表操作

2024-06-19 85
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
日志服务 SLS，月写入数据量 50GB 1个月
简介： Go语言之GORM框架(二) ——GORM的单表操作

前言

在上一篇文章中，我们对Gorm进行了介绍，而在这一篇文章中我们主要介绍GORM的单表查询与Hook函数,在进行今天的内容之前我们先事先说明一下，下面我们对单表进行操作的表结构如下：

type Student struct {
  ID   uint   `gorm:"size:3"`
  Name string `gorm:"size:8"`
  Age  int    `gorm:"size:3"`
  Sex  string `gorm:"size:3"`
  Email *string `gorm:"size:32"`
}

好了，话不多说，开始我们今天的内容

表的初始化

首先我们确定一下我们已经将要演示的数据库内相关内容清空掉了,然后我们就可以开始连接数据库并创建students表了：

package main
import (
  "fmt"
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
)
type Student struct {
  ID    uint    `gorm:"size:3"`
  Name  string  `gorm:"size:8"`
  Age   int     `gorm:"size:3"`
  Sex   string  `gorm:"size:3"`
  Email *string `gorm:"size:32"`
}
var myDB *gorm.DB
func init() {
  user := "root"
  password := "aaaa"
  dbname := "gorm"
  ip := "127.0.0.1"
  port := "3306"
  dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", user, password, ip, port, dbname)
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  if err != nil {
    fmt.Println("数据库连接失败,err:", err)
    return
  }
  fmt.Println("数据库连接成功")
  myDB = db
}
func main() {
  err := myDB.AutoMigrate(&Student{})
  if err != nil {
    fmt.Println("students表创建失败,err:", err)
    return
  }
  fmt.Println("students表创建成功")
}

单表操作

创建并插入数据

插入单条数据

func SingleInsert(student Student) {
  res := myDB.Create(&student)
  if res.Error != nil {
    fmt.Println("插入数据失败,err:", res.Error)
    return
  }
  fmt.Println("插入数据成功")
}
func main() {
  err := myDB.AutoMigrate(&Student{})
  if err != nil {
    fmt.Println("students表创建失败,err:", err)
    return
  }
  fmt.Println("students表创建成功")
  email := "fengxu@163.com"
  student := Student{
    Name:  "fengxu",
    Age:   18,
    Sex:   "男",
    Email: &email,
  }
  SingleInsert(student)
}

运行成功，查找数据库：

这样我们就成功将一条记录插入数据库了

批量插入数据

func Insert(StudentList []Student) {
  var StudentList []Student
  for i := 0; i < 10; i++ {
    email := fmt.Sprintf("No.%d@163.com", i)
    student := Student{
      Name:  fmt.Sprintf("No.%d", i),
      Age:   18 + i,
      Sex:   "男",
      Email: &email,
    }
    StudentList = append(StudentList, student)
  }
  res := myDB.Create(&StudentList)
  if res.Error != nil {
    fmt.Println("插入数据失败,err:", res.Error)
    return
  }
  fmt.Println("插入数据成功")
}

这显示我们成功向students表中批量插入数据。

插入数据的细节

  • 这里的email我为了表示它可以为空，将它的类型设置成了指针，所以我们在传值的时候也要传指针
  • 我们在使用Create函数时，传递的是指针，而不是具体值
  • 由于我们传入到Create函数的是student的指针，所以student在此之后就会出现该记录的其他消息了，比如下面这样：
func SingleInsert(student Student) {
  //插入单条数据
  email := "fengxu@163.com"
  student := Student{
    Name:  "luoyu",
    Age:   18,
    Sex:   "男",
    Email: &email,
  }
  SingleInsert(student)
  res := myDB.Create(&student)
  if res.Error != nil {
    fmt.Println("插入数据失败,err:", res.Error)
    return
  }
  fmt.Println("插入数据成功")
  fmt.Println(student)
}

打印的结果为：

{13 luoyu 18 男 0xc0001e0830}

单表插入的完整代码：

package main
import (
  "fmt"
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
)
type Student struct {
  ID    uint    `gorm:"size:3"`
  Name  string  `gorm:"size:8"`
  Age   int     `gorm:"size:3"`
  Sex   string  `gorm:"size:3"`
  Email *string `gorm:"size:32"`
}
var myDB *gorm.DB
func init() {
  user := "root"
  password := "ba161754"
  dbname := "gorm"
  ip := "127.0.0.1"
  port := "3306"
  dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", user, password, ip, port, dbname)
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  if err != nil {
    fmt.Println("数据库连接失败,err:", err)
    return
  }
  fmt.Println("数据库连接成功")
  myDB = db
}
func SingleInsert(student Student) {
  res := myDB.Create(&student)
  if res.Error != nil {
    fmt.Println("插入数据失败,err:", res.Error)
    return
  }
  fmt.Println("插入数据成功")
  fmt.Println(student)
}
func Insert(StudentList []Student) {
  res := myDB.Create(&StudentList)
  if res.Error != nil {
    fmt.Println("插入数据失败,err:", res.Error)
    return
  }
  fmt.Println("插入数据成功")
}
func main() {
  err := myDB.AutoMigrate(&Student{})
  if err != nil {
    fmt.Println("students表创建失败,err:", err)
    return
  }
  fmt.Println("students表创建成功")
  //插入单条数据
  email := "fengxu@163.com"
  student := Student{
    Name:  "luoyu",
    Age:   18,
    Sex:   "男",
    Email: &email,
  }
  SingleInsert(student)
  //批量插入数据
  var StudentList []Student
  for i := 0; i < 10; i++ {
    email := fmt.Sprintf("No.%d@163.com", i)
    student := Student{
      Name:  fmt.Sprintf("No.%d", i),
      Age:   18 + i,
      Sex:   "男",
      Email: &email,
    }
    StudentList = append(StudentList, student)
  }
  Insert(StudentList)
}

单表查询

前言

在讲解单表查询之前，我们先来看一个很简单的单表查询代码

package main
import (
  "fmt"
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "log"
  "os"
  "time"
)
type Student struct {
  ID    uint    `gorm:"size:3"`
  Name  string  `gorm:"size:8"`
  Age   int     `gorm:"size:3"`
  Sex   string  `gorm:"size:3"`
  Email *string `gorm:"size:32"`
}
var myDB *gorm.DB
var mysqllogger logger.Interface
func init() {
  user := "root"
  password := "ba161754"
  dbname := "gorm"
  ip := "127.0.0.1"
  port := "3306"
  dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", user, password, ip, port, dbname)
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  if err != nil {
    fmt.Println("数据库连接失败,err:", err)
    return
  }
  fmt.Println("数据库连接成功")
  myDB = db
}
func initLogger() {
  var mysqlLogger logger.Interface
  mysqlLogger = logger.Default.LogMode(logger.Info) //设置日志打印级别
  mysqlLogger = logger.New(
    log.New(os.Stdout, "\r\n", log.LstdFlags), // （日志输出的目标，前缀和日志包含的内容）
    logger.Config{
      SlowThreshold:             time.Second, // 慢 SQL 阈值
      LogLevel:                  logger.Info, // 日志级别
      IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
      Colorful:                  true,        // 使用彩色打印
    },
  )
  myDB.Logger = mysqlLogger
}
func main() {
  var student Student
  initLogger()
  myDB.Session(&gorm.Session{
    Logger: mysqllogger,
  })
  myDB.Take(&student) //默认查找第一条数据
  fmt.Println(student)
  student = Student{}
  myDB.First(&student) //查找第一条数据
  fmt.Println(student)
  student = Student{}
  myDB.Last(&student) //查找最后一条数据
  fmt.Println(student)
}

输出结果为：

这里我在打印出查询结果的同时也打印出了它们原生的sql语句，我们可以看到相对于原生sql语句，GORM的语句相对比较简单。

当然和我们平时利用各种各样的筛选条件来进行查询，我们在GORM也可以利用各种各样的条件来完成查询，，最后我们介绍一下下面我们可能会使用的函数：

  • Take:用于从数据库中检索符合条件的第一条记录，并将其填充到指定的结构体中。如果没有指定特定的条件，它会默认返回第一条记录。
  • Find:用于从数据库中检索符合条件的所有记录，并将它们填充到指定的结构体切片中。你可以使用Where函数来添加条件限制，以便只检索满足特定条件的记录。

单条记录查询

  • 根据主键查询
myDB.Take(&student, 1)
  fmt.Println(student)
  myDB.Take(&student, "1")
  fmt.Println(student)

注意:这里指定主键时可以是数字也可以是字符串

  • 根据其他条件来查询
myDB.Take(&student, "name = ?", "fengxu")
  fmt.Println(student)

这里我们用?来作为占位符，这样可以有效的防止sql注入

  • 根据struct来查询
myDB.Where(&Student{Name: "fengxu"}).Find(&student)
  fmt.Println(student)
  student = Student{}
  • 获取查询结果
var studentList []Student
    err := myDB.Find(&studentList).Error
  switch {
  case errors.Is(err, gorm.ErrRecordNotFound):
    fmt.Println("没有找到数据")
  default:
    fmt.Println("sql语句出现问题")
  }
  count := myDB.Find(&studentList).RowsAffected  //获取查询结果条数
  fmt.Println(count)
}

完整代码：

func SingleSerach() {
  var student Student
  var studentList []Student
  //根据主键查询
  myDB.Take(&student, 1)
  fmt.Println(student)
  student = Student{}
  myDB.Take(&student, "3")
  fmt.Println(student)
  student = Student{}
  //根据字段查询
  myDB.Take(&student, "name = ?", "fengxu")
  fmt.Println(student)
  student = Student{}
  //根据struct来查询
  //student.ID = 4
  myDB.Where(&Student{Name: "fengxu"}).Find(&student)
  fmt.Println(student)
  student = Student{}
  err := myDB.Find(&studentList).Error
  switch {
  case errors.Is(err, gorm.ErrRecordNotFound):
    fmt.Println("没有找到数据")
  default:
    fmt.Println("sql语句出现问题")
  }
  count := myDB.Find(&studentList).RowsAffected
  fmt.Println(count)
}

多条记录查询

  • 简单示例：
func MultipleSearch() {
  var studentList []Student
  myDB.Find(&studentList)
  for _, v := range studentList {
    fmt.Println(v)
  }
  //上面我们打印的email是地址，我们需要对它进行序列化
  for _, v := range studentList {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }
}
  • 按照主键来查询
studentList1 := []Student{}
  myDB.Find(&studentList1, 1, 2, 3, 4, 5, 6)
  for _, v := range studentList1 {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }
  studentList2 := []Student{}
  myDB.Find(&studentList2, []int{1, 2, 3, 4, 5, 6})
  for _, v := range studentList2 {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }

注意：这里其实用不用前片都可以,但是测试结果是切片速度明显较快，建议使用切片

  • 按照其他条件来查询
//根据字段查询
  studentList := []Student{}
  myDB.Where("name in ?", []string{"fengxu", "luoyu"}).Find(&studentList)
  for _, v := range studentList {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }

全部代码：

func MultipleSearch() {
  var studentList []Student
  myDB.Find(&studentList)
  for _, v := range studentList {
    fmt.Println(v)
  }
  //按主键查询
  studentList1 := []Student{}
  myDB.Find(&studentList1, 1, 2, 3, 4, 5, 6)
  for _, v := range studentList1 {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }
  
  studentList2 := []Student{}
  myDB.Find(&studentList2, []int{1, 2, 3, 4, 5, 6})
  for _, v := range studentList2 {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }
  //根据字段查询
  studentList = []Student{}
  myDB.Where("name in ?", []string{"fengxu", "luoyu"}).Find(&studentList)
  for _, v := range studentList {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }
}

单表数据的更新

示例：

func Update() {
  var student Student
  myDB.Take(&student, 1)
  student.Name = "三玖"
  student.Sex = "女"
  myDB.Save(&student)
  fmt.Println(student)
}

注意:

  • Save会保留所有的字段,哪怕我们将字段的值设为0
  • Save函数其实是一个组合操作，如果当前不存在该字段，则是执行Create否则执行Update
  • 不要将 Save 和 Model一同使用, 这是 未定义的行为

单列更新

  • 更新单列指定字段
//更新指定字段
  student = Student{}
  myDB.Take(&student)
  student.Age = 19
  myDB.Select("age").Save(&student)
  fmt.Println(student)
  • 批量更新
//同时更新单个指定字段
  studentList := []Student{}
  myDB.Where("name like ?", "No.%").Find(&studentList).Update("age", 19)
  for _, v := range studentList {
    fmt.Println(v.Name, v.Age)
  }
  
  //同时更新多个指定字段
  Email := "sanjiu@163.com"
  new_student := Student{
    Age:   20,
    Sex:   "女",
    Email: &Email,
  }
  myDB.Model(&student).Where("name=?", "三玖").Updates(new_student)  //方法一:struct
  
  myDB.Model(&student).Where("name=?", "三玖").Updates(map[string]interface{}{
    "age":   20,
    "sex":   "女",
    "email": "sanjiu@163.com",
  })//  方法二:map

注意:Updates函数在struct方法更新字段时会自动忽略零值，如果想避免建议使用map或使用Select函数说明一下要更新的字段，示例如下：

DB.Model(&Student{}).Where("age = ?", 21).Select("gender", "email").Updates(Student{
  Email:  &email,
  Gender: false,
})

单表删除

func Delete() {
  var student Student
  var studentlist []Student
  myDB.Take(&student, 1)
  myDB.Delete(&student) //单行删除
  myDB.Take(&studentlist, []int{1, 2, 3})
  myDB.Delete(&studentlist) //批量删除
}

代码汇总

以上有关单表操作的全部代码：

package main
import (
  "encoding/json"
  "errors"
  "fmt"
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
  "gorm.io/gorm/logger"
  "log"
  "os"
  "time"
)
type Student struct {
  ID    uint    `gorm:"size:3"`
  Name  string  `gorm:"size:8"`
  Age   int     `gorm:"size:3"`
  Sex   string  `gorm:"size:3"`
  Email *string `gorm:"size:32"`
}
var myDB *gorm.DB
var mysqllogger logger.Interface
func init() {
  user := "root"
  password := "nicai"
  dbname := "gorm"
  ip := "127.0.0.1"
  port := "3306"
  dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", user, password, ip, port, dbname)
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  if err != nil {
    fmt.Println("数据库连接失败,err:", err)
    return
  }
  fmt.Println("数据库连接成功")
  myDB = db
}
func initLogger() {
  var mysqlLogger logger.Interface
  mysqlLogger = logger.Default.LogMode(logger.Info) //设置日志打印级别
  mysqlLogger = logger.New(
    log.New(os.Stdout, "\r\n", log.LstdFlags), // （日志输出的目标，前缀和日志包含的内容）
    logger.Config{
      SlowThreshold:             time.Second, // 慢 SQL 阈值
      LogLevel:                  logger.Info, // 日志级别
      IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
      Colorful:                  true,        // 使用彩色打印
    },
  )
  myDB.Logger = mysqlLogger
}
func SingleSerach() {
  var student Student
  var studentList []Student
  //根据主键查询
  myDB.Take(&student, 1)
  fmt.Println(student)
  student = Student{}
  myDB.Take(&student, "3")
  fmt.Println(student)
  student = Student{}
  //根据字段查询
  myDB.Take(&student, "name = ?", "fengxu")
  fmt.Println(student)
  student = Student{}
  //根据struct来查询
  //student.ID = 4
  myDB.Where(&Student{Name: "fengxu"}).Find(&student)
  fmt.Println(student)
  student = Student{}
  err := myDB.Find(&studentList).Error
  switch {
  case errors.Is(err, gorm.ErrRecordNotFound):
    fmt.Println("没有找到数据")
  default:
    fmt.Println("sql语句出现问题")
  }
  count := myDB.Find(&studentList).RowsAffected
  fmt.Println(count)
}
func MultipleSearch() {
  var studentList []Student
  myDB.Find(&studentList)
  for _, v := range studentList {
    fmt.Println(v)
  }
  //按主键查询
  studentList1 := []Student{}
  myDB.Find(&studentList1, 1, 2, 3, 4, 5, 6)
  for _, v := range studentList1 {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }
  studentList2 := []Student{}
  myDB.Find(&studentList2, []int{1, 2, 3, 4, 5, 6})
  for _, v := range studentList2 {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }
  //根据字段查询
  studentList = []Student{}
  myDB.Where("name in ?", []string{"fengxu", "luoyu"}).Find(&studentList)
  for _, v := range studentList {
    data, _ := json.Marshal(v)
    fmt.Println(string(data))
  }
}
func Update() {
  //update操作示例
  var student Student
  myDB.Take(&student, 1)
  student.Name = "三玖"
  student.Sex = "女"
  myDB.Save(&student)
  fmt.Println(student)
  //更新指定字段
  student = Student{}
  myDB.Take(&student)
  student.Age = 19
  myDB.Select("age").Save(&student)
  fmt.Println(student)
  //同时更新多列的指定字段
  studentList := []Student{}
  myDB.Where("name like ?", "No.%").Find(&studentList).Update("age", 19)
  for _, v := range studentList {
    fmt.Println(v.Name, v.Age)
  }
  //同时更新多列
  Email := "sanjiu@163.com"
  new_student := Student{
    Age:   20,
    Sex:   "女",
    Email: &Email,
  }
  myDB.Model(&student).Where("name=?", "三玖").Updates(new_student) //方法一:struct
  myDB.Model(&student).Where("name=?", "三玖").Updates(map[string]interface{}{
    "age":   20,
    "sex":   "女",
    "email": "sanjiu@163.com",
  }) //  方法二:map
}
func Delete() {
  var student Student
  var studentlist []Student
  myDB.Take(&student, 1)
  myDB.Delete(&student) //单行删除
  myDB.Take(&studentlist, []int{1, 2, 3})
  myDB.Delete(&studentlist) //批量删除
}
func main() {
  //var student Student
  initLogger()
  myDB.Session(&gorm.Session{
    Logger: mysqllogger,
  })
  //myDB.Take(&student) //默认查找第一条数据
  //fmt.Println(student)
  //student = Student{}
  //
  //myDB.First(&student) //查找第一条数据
  //fmt.Println(student)
  //student = Student{}
  //
  //myDB.Last(&student) //查找最后一条数据
  //fmt.Println(student)
  Delete()
}

结语

上面仅仅是我基于Gorm框架学习的一些笔记，详细可以参考：

GORM官方文档

文章标签：
云数据库 RDS MySQL 版
日志服务
Go
数据库
SQL
关键词：
Go语言
Go框架
Go语言gorm
Go gorm
Go操作
相关实践学习
如何快速连接云数据库RDS MySQL
本场景介绍如何通过阿里云数据管理服务DMS快速连接云数据库RDS MySQL，然后进行数据表的CRUD操作。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
落雨便归尘
目录
相关文章
卓伊凡
|
3天前
|
监控 Linux PHP
【02】客户端服务端C语言-go语言-web端PHP语言整合内容发布-优雅草网络设备监控系统-2月12日优雅草简化Centos stream8安装zabbix7教程-本搭建教程非docker搭建教程-优雅草solution
【02】客户端服务端C语言-go语言-web端PHP语言整合内容发布-优雅草网络设备监控系统-2月12日优雅草简化Centos stream8安装zabbix7教程-本搭建教程非docker搭建教程-优雅草solution
卓伊凡
51 20
游客akle7anmklvj6
|
2天前
|
存储 监控 算法
探秘员工泄密行为防线：基于Go语言的布隆过滤器算法解析
在信息爆炸时代，员工泄密行为对企业构成重大威胁。本文聚焦布隆过滤器（Bloom Filter）这一高效数据结构，结合Go语言实现算法，帮助企业识别和预防泄密风险。通过构建正常操作“指纹库”，实时监测员工操作，快速筛查可疑行为。示例代码展示了如何利用布隆过滤器检测异常操作，并提出优化建议，如调整参数、结合日志分析系统等，全方位筑牢企业信息安全防线，守护核心竞争力。
游客akle7anmklvj6
14 5
智物科技库
|
10天前
|
Go C语言
Go语言入门：分支结构
本文介绍了Go语言中的条件语句，包括`if...else`、`if...else if`和`switch`结构，并通过多个练习详细解释了它们的用法。`if...else`用于简单的条件判断；`if...else if`处理多条件分支；`switch`则适用于基于不同值的选择逻辑。特别地，文章还介绍了`fallthrough`关键字，用于优化重复代码。通过实例如判断年龄、奇偶数、公交乘车及成绩等级等，帮助读者更好地理解和应用这些结构。
智物科技库
34 14
陌陌谣
|
24天前
|
存储 监控 算法
内网监控系统之 Go 语言布隆过滤器算法深度剖析
在数字化时代，内网监控系统对企业和组织的信息安全至关重要。布隆过滤器（Bloom Filter）作为一种高效的数据结构，能够快速判断元素是否存在于集合中，适用于内网监控中的恶意IP和违规域名筛选。本文介绍其原理、优势及Go语言实现，提升系统性能与响应速度，保障信息安全。
陌陌谣
27 5
智物科技库
|
1月前
|
算法 安全 Go
Go语言中的加密和解密是如何实现的？
Go语言通过标准库中的`crypto`包提供丰富的加密和解密功能，包括对称加密（如AES）、非对称加密（如RSA、ECDSA）及散列函数（如SHA256）。`encoding/base64`包则用于Base64编码与解码。开发者可根据需求选择合适的算法和密钥，使用这些包进行加密操作。示例代码展示了如何使用`crypto/aes`包实现对称加密。加密和解密操作涉及敏感数据处理，需格外注意安全性。
智物科技库
45 14
2G冲浪词条
|
1月前
|
存储 安全 Go
Go语言中的map数据结构是如何实现的？
Go 语言中的 `map` 是基于哈希表实现的键值对数据结构，支持快速查找、插入和删除操作。其原理涉及哈希函数、桶（Bucket）、动态扩容和哈希冲突处理等关键机制，平均时间复杂度为 O(1)。为了确保线程安全，Go 提供了 `sync.Map` 类型，通过分段锁实现并发访问的安全性。示例代码展示了如何使用自定义结构体和切片模拟 `map` 功能，以及如何使用 `sync.Map` 进行线程安全的操作。
2G冲浪词条
54 9
卓伊凡
|
9天前
|
监控 关系型数据库 MySQL
【01】客户端服务端C语言-go语言-web端PHP语言整合内容发布-优雅草网络设备监控系统-硬件设备实时监控系统运营版发布-本产品基于企业级开源项目Zabbix深度二开-分步骤实现预计10篇合集-自营版
【01】客户端服务端C语言-go语言-web端PHP语言整合内容发布-优雅草网络设备监控系统-硬件设备实时监控系统运营版发布-本产品基于企业级开源项目Zabbix深度二开-分步骤实现预计10篇合集-自营版
卓伊凡
18 0
晚来风急
|
JavaScript Go .NET
Go 应用框架 beego 1.7.0，新增改进功能
晚来风急
2407 0
陌陌谣
|
2月前
|
存储 监控 算法
员工上网行为监控中的Go语言算法：布隆过滤器的应用
在信息化高速发展的时代，企业上网行为监管至关重要。布隆过滤器作为一种高效、节省空间的概率性数据结构，适用于大规模URL查询与匹配，是实现精准上网行为管理的理想选择。本文探讨了布隆过滤器的原理及其优缺点，并展示了如何使用Go语言实现该算法，以提升企业网络管理效率和安全性。尽管存在误报等局限性，但合理配置下，布隆过滤器为企业提供了经济有效的解决方案。
陌陌谣
95 8
员工上网行为监控中的Go语言算法：布隆过滤器的应用
听风de歌
|
2月前
|
存储 Go 索引
go语言中数组和切片
go语言中数组和切片
听风de歌
48 7

热门文章

最新文章

  • 1
    Go 1.24.0 重磅发布：新特性、新工具，开发者必看！
  • 2
    【02】客户端服务端C语言-go语言-web端PHP语言整合内容发布-优雅草网络设备监控系统-2月12日优雅草简化Centos stream8安装zabbix7教程-本搭建教程非docker搭建教程-优雅草solution
  • 3
    Go语言入门：分支结构
  • 4
    扩散模型版CS: GO！世界模型+强化学习：2小时训练登顶Atari 100K
  • 5
    内网监控系统之 Go 语言布隆过滤器算法深度剖析
  • 6
    Go Common Test
  • 7
    【01】客户端服务端C语言-go语言-web端PHP语言整合内容发布-优雅草网络设备监控系统-硬件设备实时监控系统运营版发布-本产品基于企业级开源项目Zabbix深度二开-分步骤实现预计10篇合集-自营版
  • 8
    探秘员工泄密行为防线：基于Go语言的布隆过滤器算法解析
  • 9
    Mac下Go安装配置并使用Protobuf
  • 10
    Go语言之反射
  • 1
    探秘员工泄密行为防线：基于Go语言的布隆过滤器算法解析
    14
  • 2
    Go Common Test
    19
  • 3
    【02】客户端服务端C语言-go语言-web端PHP语言整合内容发布-优雅草网络设备监控系统-2月12日优雅草简化Centos stream8安装zabbix7教程-本搭建教程非docker搭建教程-优雅草solution
    51
  • 4
    Go 1.24.0 重磅发布：新特性、新工具，开发者必看！
    71
  • 5
    【01】客户端服务端C语言-go语言-web端PHP语言整合内容发布-优雅草网络设备监控系统-硬件设备实时监控系统运营版发布-本产品基于企业级开源项目Zabbix深度二开-分步骤实现预计10篇合集-自营版
    18
  • 6
    Go语言入门：分支结构
    34
  • 7
    扩散模型版CS: GO！世界模型+强化学习：2小时训练登顶Atari 100K
    33
  • 8
    内网监控系统之 Go 语言布隆过滤器算法深度剖析
    27
  • 9
    Go语言中的map数据结构是如何实现的？
    54
  • 10
    Go语言中的加密和解密是如何实现的？
    45

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践
    • 下一篇
    PAI Model Gallery 支持云上一键部署 DeepSeek-V3、DeepSeek-R1 系列模型