脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - Go语言操作数据库及其常规操作的示例代码

Go语言操作数据库及其常规操作的示例代码

2021-05-26 01:01听风走了八千里 Golang

这篇文章主要介绍了Go语言操作数据库及其常规操作的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

Go操作MySQL

 

安装: go get -u github.com/go-sql-driver/mysql

GO语言的操作数据库的驱动原生支持连接池, 并且是并发安全的 标准库没有具体的实现 只是列出了一些需要的第三方库实现的具体内容

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//第一次连接MySQL成功
package main
 
import (
 "database/sql"
 _ "github.com/go-sql-driver/mysql"   // _想当于init()初始化
 "log"
)
 
func main() {
 // root 用户名 1qa2ws3ed是密码  后边的书ip:port  gouse 库名
 dsn := "root:1qa2ws3ed@tcp(127.0.0.1:3306)/gouse"
 db, err := sql.Open("mysql", dsn)
 if err != nil {
  panic(err)
 }
 // ping是尝试连接MySQL数据库
 
 if err = db.Ping(); err != nil{
  panic(err)
 }
 log.Fatalln("Mysql数据库连接成功")
 
}

Go调用MySQL封装成函数

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package main
 
import (
 "database/sql"
 "encoding/json"
 "fmt"
 _ "github.com/go-sql-driver/mysql"
)
 
var db *sql.DB
 
func InitDB() (err error) {
 dsn := "root:1qa2ws3ed@tcp(127.0.0.1:3306)/gouse"
 
 db, err = sql.Open("mysql", dsn)
 CheckErr(err)
 
 err = db.Ping()
 CheckErr(err)
 fmt.Println("数据库连接成功...")
 // 设置数据库连接池最大连接数
 db.SetConnMaxLifetime(10)
 
 //设置最大闲置连接数
 db.SetMaxIdleConns(5)
 
 return
}
 
type data struct {
 Username string `json:"username"`
 Password string `json:"password"`
}
 
 
func main()  {
 err := InitDB()
 CheckErr(err)
 
 query, err := db.Query("select username, password from test")
 CheckErr(err)
 
 for query.Next(){
  line := data{}
  // 查询数据的时候必须要调用scan方法如果 没有 使用scan  连接通道一直保持连接 无法释放连接 
  _ = query.Scan(&line.Username, &line.Password)
  fmt.Println(line)
  dataDic := map[string]string{
   "username": line.Username,
   "password": line.Password,
  }
  marshal, _ := json.Marshal(dataDic)
  fmt.Println(string(marshal))
 }
}
 
func CheckErr(err error) {
 if err != nil {
  fmt.Println(err)
  panic(err)
 }
}

GO—MySQL的增删改查

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package main
 
import (
 "database/sql"
 "encoding/json"
 "fmt"
 "time"
 
 _ "github.com/go-sql-driver/mysql"
)
 
var db *sql.DB
 
// InitDB 数据库连接初始化
func InitDB() (err error) {
 dsn := "root:1qa2ws3ed@tcp(127.0.0.1:3306)/gouse"
 
 db, err = sql.Open("mysql", dsn)
 CheckErr(err)
 
 err = db.Ping()
 CheckErr(err)
 fmt.Println("数据库连接成功...")
 // 设置数据库连接池最大连接数
 db.SetConnMaxLifetime(10)
 
 //设置最大闲置连接数
 db.SetMaxIdleConns(5)
 
 return
 
}
 
type data struct {
 Username string `json:"username"`
 Password string `json:"password"`
}
 
// SelectQuery 查询函数
func SelectQuery() {
 sqlStr := "select username, password from test where id > ?"
 query, err := db.Query(sqlStr, 1)
 CheckErr(err)
 defer query.Close()
 
 fmt.Printf("现在是北京时间 %s , 你今天进步了吗？\n", time.Now().Format("2006-01-02 15:04:05"))
 
 for query.Next() {
  line := data{}
  // 查询数据的时候必须要调用scan方法如果 没有 使用scan  连接通道一直保持连接 无法释放连接
  _ = query.Scan(&line.Username, &line.Password)
  //fmt.Println(line)
  dataDic := map[string]string{
   "username": line.Username,
   "password": line.Password,
  }
  marshal, _ := json.Marshal(dataDic)
  fmt.Printf("查询到的数据为 %s\n", string(marshal))
 }
}
 
// InsertQuery 插入数据
func InsertQuery() {
 // sql 语句
 sqlStr := `insert into test (username,password) values ("kuQi", "123qwe")`
 result, err := db.Exec(sqlStr)
 CheckErr(err)
 id, err := result.LastInsertId()
 CheckErr(err)
 fmt.Printf("插入成功数据的id为 %v", id)
}
 
// UpdateQuery 更新数据函数
func UpdateQuery(dataField string, user string) {
 sqlStr := `update test set password=? where username=?`
 result, err := db.Exec(sqlStr, dataField, user)
 CheckErr(err)
 rowsAffected, err := result.RowsAffected()
 CheckErr(err)
 fmt.Printf("被更新字段的id为%d\n", rowsAffected)
 
}
 
// DeleteQuery 删除
func DeleteQuery(id int) {
 sqlStr := `delete from test where id=?`
 result, err := db.Exec(sqlStr, id)
 CheckErr(err)
 rowsAffected, err := result.RowsAffected()
 CheckErr(err)
 if rowsAffected == 0 {
  fmt.Printf("没有匹配到要删除的id=%d数据", id)
  return
 }
 fmt.Printf("删除数据库的id为%d", id)
 
}
 
//CheckErr 异常捕获函数
func CheckErr(err error) {
 if err != nil {
  fmt.Println(err)
  panic(err)
 }
}
 
// main 主函数 所有函数的入口
func main() {
 err := InitDB()
 CheckErr(err)
 
 //InsertQuery()
 UpdateQuery("hahaGolang123", "kuQi")
 SelectQuery()
 DeleteQuery(5)
}

MySQL的预处理

什么是预处理？
普通SQL语句执行过程：
 1.客户端对SQL语句进行占位符的替换得到了完整的SQL语句
 2.客户端发送完整SQL语句到MySQL服务端
 3.MySQL服务端执行完整的SQL语句并将结果返回终端

预处理的执行过程
 1.先把SQL语句拆分成两部分，SQL语句部分和参数部分
 2.先把SQL语句部分发送给MySQL服务端进行SQL预处理
 3.然后参数部分发送给MySQL服务端，MySQL对SQL语句进行拼接
 4.MySQL服务端执行完整的SQL语句返回结果

为什么要进行预处理？
  1.为了优化MySQL服务器重复执行SQL的方法。可以执行服务器的性能，提前让服务器编译，一次编译多次执行，节省后续重复编译的成本
  2.并且避免SQL注入

Go实现MySQL预处理

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// prepare方法现将SQL发送到MySQL服务端, 返回一个准备好的状态用于之后的查询和命令。返回值可以同时执行多个查询和命令  ； 命令也就是SQL语句
// PrepareInsert 预处理执行插入语句
func PrepareInsert() {
 
 defer wg.Done()
 sqlStr := `insert into test (username, password) values (?, ?)`
 // - 预处理 stmt 就是编译好的sql语句 之后直接传递参数即可
 stmt, err := db.Prepare(sqlStr)
 var u1 = uuid.Must(uuid.NewV4())
 CheckErr(err)
 defer stmt.Close()
 i := rand.Int()
 
 username := fmt.Sprintf("yonghuming%d", i)
 result, err := stmt.Exec(username, u1.String()[:10])
 CheckErr(err)
 rowsAffected, err := result.LastInsertId()
 CheckErr(err)
 fmt.Printf("成功插入id=%d条数据\n", rowsAffected)
}

Go语言实现MySQL实现事务操作

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
// go语言中使用一下三个方法实现MySQL中的事务操作， 开始事务
func (db *DB) Begin()(*Tx, error)
 
// 提交事务  相当与Python中的conn.commit()
func (tx *Tx) Commit() error  
 
// 回滚事务
func (tx *Tx) Rollback() error
 
package main
 
import (
 "database/sql"
 "fmt"
 
 _ "github.com/go-sql-driver/mysql"
)
 
var db *sql.DB
 
type data struct {
 Username string `json:"username"`
 Password string `json:"password"`
}
 
// InitDB 数据库连接初始化
func InitDB() (err error) {
 dsn := "root:1qa2ws3ed@tcp(127.0.0.1:3306)/gouse"
 
 db, err = sql.Open("mysql", dsn)
 CheckErr(err)
 
 err = db.Ping()
 CheckErr(err)
 fmt.Println("数据库连接成功...")
 // 设置数据库连接池最大连接数
 db.SetMaxOpenConns(100)
 
 //设置最大闲置连接数
 db.SetMaxIdleConns(5)
 
 return
 
}
 
//CheckErr 异常捕获函数
func CheckErr(err error) {
 if err != nil {
  fmt.Println(err)
  panic(err)
 }
}
 
// TranSaCtIon MySQL的事务操作
func TranSaCtIon() {
 // 开启事务
 tx, err := db.Begin()
 CheckErr(err)
 
 // 执行多个SQL操作
 sqlStr := `update test set id=id+100000 where password=?`
 result, err := tx.Exec(sqlStr, "07f70f7e-4")
 CheckErr(err)
 id, err := result.LastInsertId()
 if err != nil {
  // 语句回滚
  err := tx.Rollback()
  fmt.Println("事务回滚")
  CheckErr(err)
 
 }
 fmt.Printf("修改后的id为%d\n", id)
 
}
 
func main() {
 err := InitDB()
 CheckErr(err)
 TranSaCtIon()
}

sqlx使用

第三方库sqlx能够简化操作，提高开发效率

安装go get github.com/jmoiron/sqlx

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main
 
import (
 "fmt"
 
 _ "github.com/go-sql-driver/mysql"
 "github.com/jmoiron/sqlx"
)
 
var db *sqlx.DB
 
// InitDB 数据库初始化
func InitDB() (err error) {
 dsn := "root:1qa2ws3ed@tcp(127.0.0.1:3306)/gouse"
 db, err = sqlx.Connect("mysql", dsn)
 CheckErr(err)
 db.SetMaxOpenConns(50)
 db.SetMaxIdleConns(10)
 fmt.Println("goUse 数据库连接成功")
 return
}
 
//CheckErr 异常捕获函数
func CheckErr(err error) {
 if err != nil {
  fmt.Println(err)
  panic(err)
 }
}
 
func main() {
 err := InitDB()
 CheckErr(err)
}

sqlx相较于原生的sql库好处在于 查询的时候sql原生的需要next scan 回调获取结果

sqlx 查询只需要定义一个存储的变量 然后自动就会将查询的出来的值放入变量中

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package main
 
import (
 "encoding/json"
 "fmt"
 
 _ "github.com/go-sql-driver/mysql"
 "github.com/jmoiron/sqlx"
)
 
var db *sqlx.DB
 
type user struct {
 ID       int    `json:"id"`
 Username string `json:"username"`
 Password string `json:"password"`
}
 
// InitDB 数据库初始化
func InitDB() (err error) {
 dsn := "root:1qa2ws3ed@tcp(127.0.0.1:3306)/gouse"
 // Connect 就是连接的同时db.ping()一下
 db, err = sqlx.Connect("mysql", dsn)
 CheckErr(err)
 db.SetMaxOpenConns(50)
 db.SetMaxIdleConns(10)
 fmt.Println("goUse 数据库连接成功")
 return
}
 
// SelectDB 查询单条数据的方法
func SelectDB() {
 sqlStr := `select * from test where id=?`
 var data user
 _ = db.Get(&data, sqlStr, 990)
 //CheckErr(err)
 fmt.Printf("%#v\n", data)
 marshal, err := json.Marshal(data)
 CheckErr(err)
 fmt.Println(string(marshal))
}
 
// ManySelect 查询多条数据方法
func ManySelect() {
 sqlStr := `select * from test where id < ?`
 var dataList []user
 err := db.Select(&dataList, sqlStr, 1000)
 CheckErr(err)
 //fmt.Println(dataList)
 marshal, err := json.Marshal(dataList)
 CheckErr(err)
 fmt.Println(string(marshal))
}
 
//CheckErr 异常捕获函数
func CheckErr(err error) {
 if err != nil {
  fmt.Println(err)
  panic(err)
 }
}
 
func main() {
 err := InitDB()
 CheckErr(err)
 SelectDB()
 ManySelect()
 
}

Go操作Redis

 

安装go get -u github.com/go-redis/redis

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main
 
import (
 "fmt"
 
 "github.com/go-redis/redis"
)
 
var redisDB *redis.Client
 
// InitRedisDB redis数据库初始化
func InitRedisDB() (err error) {
 
 redisDB = redis.NewClient(&redis.Options{
  Addr:     "127.0.0.1:6379",
  Password: "",
  DB:       0,
 })
 _, err = redisDB.Ping(redisDB.Context()).Result()
 CheckErr(err)
 fmt.Println("redis 连接成功")
 return
}
 
//CheckErr 异常捕获函数
func CheckErr(err error) {
 if err != nil {
  fmt.Println(err)
  panic(err)
 }
}
 
func main() {
 _ = InitRedisDB()
}
  • set(key, value)：给数据库中名称为key的string赋予值value
  • get(key)：返回数据库中名称为key的string的value
  • getset(key, value)：给名称为key的string赋予上一次的value
  • mget(key1, key2,…, key N)：返回库中多个string的value
  • setnx(key, value)：添加string，名称为key，值为value
  • setex(key, time, value)：向库中添加string，设定过期时间time
  • mset(key N, value N)：批量设置多个string的值
  • msetnx(key N, value N)：如果所有名称为key i的string都不存在
  • incr(key)：名称为key的string增1操作
  • incrby(key, integer)：名称为key的string增加integer
  • decr(key)：名称为key的string减1操作
  • decrby(key, integer)：名称为key的string减少integer
  • append(key, value)：名称为key的string的值附加value
  • substr(key, start, end)：返回名称为key的string的value的子串

NSQ分布式消息队列

 

NSQ是目前比较流行的一个分布式消息队列，下面主要是NSQ及GO语言如何操作NSQ

NSQ是GO语言编写的一个开源的实时分布式内存消息队列, 其性能十分优异, NSQ的优势有：

​ 1.NSQ提倡分布式和扩散的拓扑，没有单点故障，支持容错和高可用性，并提供可靠的消息交付保证

​ 2.NSQ支持横向扩展， 没有任何集中式代理

​ 3.NSQ易于配置和部署，并且内置了管理界面

安装go get -u github.com/nsqio/go-nsq

Context

在Go HTTP 包的server中，每一个请求都在对应着一个响应，请求处理函数通常会启动额外的goroutine用来访问后端的服务，比如数据库和rpc服务，用来处理一个请求的goroutine通常需要访问一些与请求特定的数据，比如终端的身份认证信息、验证相关的token、请求和截止时间。当一个请求被取消或超时时，所有用来处理该请求的goroutine都应该迅速退出，然后系统才能释放这些goroutine

如何优雅的结束goroutine释放资源

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// 通道版本
package main
 
import (
 "fmt"
 "sync"
 "time"
)
 
var wg sync.WaitGroup
 
func worker(exitChan <-chan struct{}) {
 defer wg.Done()
Test:
 for {
  fmt.Println("worker")
  time.Sleep(time.Second)
  select {
  case <-exitChan:
   break Test
  default:
  }
 
 }
 
}
 
func main() {
 wg.Add(1)
 c := make(chan struct{})
 
 go worker(c)
 time.Sleep(10 * time.Second)
 c <- struct{}{}
 close(c)
 wg.Wait()
 fmt.Println("Over")
 
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// Context版本
package main
 
import (
 "context"
 "fmt"
 "sync"
 "time"
)
 
var wg sync.WaitGroup
 
func worker(ctx context.Context) {
 defer wg.Done()
Test:
 for {
  fmt.Println("worker")
  time.Sleep(time.Second)
  select {
  case <-ctx.Done():
   break Test
  default:
  }
 
 }
 
}
 
func main() {
 wg.Add(1)
 ctx, cancelFunc := context.WithCancel(context.Background())
 
 go worker(ctx)
 time.Sleep(10 * time.Second)
 
 cancelFunc()
 wg.Wait()
 fmt.Println("Over")
}

如果goroutine开启了新的goroutine，只需要将ctx传入到新的goroutine中即可

Background() 和 TODO()

go内置两个函数: Background() 和TUDO(),这两个函数分别返回了一个实现了context接口的background和todo. 我们代码中最开始都是以这两个内置的上下文对象作为最顶层的partent context，衍生出更多的子上下文对象。

backgroud() 主要用于main函数，初始化以及代码测试，作为context这个树结构的最顶层context，也就是跟context。

todo()，他目前还不知道能干点啥?

使用context的注意事项

  • 推荐以参数显示传递context
  • 以context作为参数的函数方法，应该把context作为第一个参数
  • 给一个函数传递context的时候，不要nil，如果不知道传递什么，就使用context.TODO()
  • context是并发安全的，可以随意在多个goroutine中传递

log标准库

 

log包定义了Logger类型, 该类型提供了一些格式化输出的方法。本包也提供了一个预定义的标准logger，可以通过调用函数Print系列，fatal系列和panic系列来使用，比自行创建的logger对象更容易使用。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
 
import "log"
 
func main() {
 log.Println("这是第一条工作日志")
 
 v := "THIS is worker log"
 log.Printf("%#v\n", v)
 // Fatal将会值写入信息之后，执行exit(1)
 log.Fatal("之后写一万行代码 我也不执行了哦")
 
 // 可以通过log.Panic 引发异常 会将日志写入之后引发异常
 log.Panic("测试panic的日志")
 
}

flag选项（日志输出内容设置）

log标准库提供了如下的flag选项，他们是一系列定义好的常量。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const (
 Ldate = 1 << iota
  Ltime
  Lmicroseconds
  Llongfile
  Lshortfile
  LUTC
  LstdFlags = Ldate | Ltime
)
 
 
 
package main
import "log"
func main() {
    // 设置默认附加的内容
  log.SetFlags(log.Llongfile | log.Ltime)
    // 设置日志前缀
  log.SetPrefix("[go_log] ")
  log.Println("测试日志")
 
}
output>>>
[go_log] 19:02:14 /Users/mac/GolandProjects/src/day02/go_log库/main.go:19: 测试日志

配置日志输出位置

setoutput函数用来设置logger的输出目的地，默认是标准错误输出

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
 
import (
 "log"
 "os"
)
 
func main() {
 
 file, err := os.OpenFile("test.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
 if err != nil {
  log.Panic("文件打开失败")
 }
  // 设置了写入文件 日志内容就不会打印到终端了
 log.SetOutput(file)
 log.SetFlags(log.Llongfile | log.Ltime)
 log.SetPrefix("[go_log] ")
 log.Println("测试日志")
 
}

我们可以定义一个init初始化函数 将log全部配置好 这样更加标准化

第三方日志库logrus的使用

 

logrus是GO结构化的logger 与上边的logger标准库完全兼容

安装logrusgo get github.com/sirupsen/logrus

?
1
2
3
4
5
6
7
8
9
10
11
12
package main
 
import (
 log "github.com/sirupsen/logrus"
)
 
func main() {
 log.WithFields(log.Fields{
  "animals": "dog",
  "time":    log.FieldKeyTime,
 }).Info("这是啥")
}

日志级别

Trace、debug、info、warning、error、fatal、panic

?
1
2
3
4
5
6
7
8
9
log.Trace("跟踪?")
log.Debug("Debug?")
log.Info("信息")
log.Warn("警告？")
log.Error("Something failed but I'm not quitting.")
// 记完日志后会调用os.Exit(1)
log.Fatal("Bye.")
// 记完日志后会调用 panic()
log.Panic("I'm bailing.")

日志记录

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package main
 
import (
 "os"
 "time"
 
 log "github.com/sirupsen/logrus"
)
 
func main() {
 file, err := os.OpenFile("logrustest.log", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
 if err != nil {
  log.Panicln(err)
 }
 log.SetOutput(file)
 for i := 0; i < 100; i++ {
  log.WithFields(log.Fields{
   "animals": "dog",
   "Countey": "China",
   "City":    "BeiJing",
  }).Info("这是啥")
  time.Sleep(time.Second)
 }
 
 log.Trace("跟踪?")
 log.Info("信息")
 log.Warn("警告？")
 // 设置日志级别， 会记录info以上级别（warn error fatal panic）
 log.SetLevel(log.InfoLevel)
 
}
 
>>>结果
time="2021-02-04T12:00:15+08:00" level=info msg="这是啥" City=BeiJing Countey=China animals=dog
time="2021-02-04T12:00:17+08:00" level=info msg="这是啥" City=BeiJing Countey=China animals=dog
time="2021-02-04T12:00:18+08:00" level=info msg="这是啥" City=BeiJing Countey=China animals=dog
time="2021-02-04T12:00:19+08:00" level=info msg="这是啥" City=BeiJing Countey=China animals=dog

日志的条目除了使用withfield 和withfields添加的相关日志，还有一些默认添加的日志字段

time 记录日志的时间戳 msg 记录日志信息 level记录日志级别

日志格式化

logrus内置一下两种日志格式化程序

logrus.TextFormatter logrus.JSONFormatter

?
1
log.SetFormatter(&log.JSONFormatter{})

追踪函数

?
1
log.SetReportCaller(true)

这样就会将哪个文件哪一行 都记录下来  但是不是特殊需求无需开启这个 因为会增加性能开

到此这篇关于Go语言操作数据库及其常规操作的示例代码的文章就介绍到这了,更多相关Go语言操作数据库内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://www.cnblogs.com/zjaiccn/p/14667326.html

  • 数据库
  • GO语言

    • 延伸 · 阅读

    精彩推荐
    • GolangGolang通脉之数据类型详情

      Golang通脉之数据类型详情

      这篇文章主要介绍了Golang通脉之数据类型，在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等，Go语言中标识符允许由...

      羌4272021-11-24
    • Golanggolang json.Marshal 特殊html字符被转义的解决方法

      golang json.Marshal 特殊html字符被转义的解决方法

      今天小编就为大家分享一篇golang json.Marshal 特殊html字符被转义的解决方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧 ...

      李浩的life12792020-05-27
    • Golanggolang的httpserver优雅重启方法详解

      golang的httpserver优雅重启方法详解

      这篇文章主要给大家介绍了关于golang的httpserver优雅重启的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      helight2992020-05-14
    • Golanggo日志系统logrus显示文件和行号的操作

      go日志系统logrus显示文件和行号的操作

      这篇文章主要介绍了go日志系统logrus显示文件和行号的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      SmallQinYan12302021-02-02
    • Golanggolang 通过ssh代理连接mysql的操作

      golang 通过ssh代理连接mysql的操作

      这篇文章主要介绍了golang 通过ssh代理连接mysql的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      a165861639710342021-03-08
    • Golanggo语言制作端口扫描器

      go语言制作端口扫描器

      本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。 ...

      脚本之家3642020-04-25
    • GolangGolang中Bit数组的实现方式

      Golang中Bit数组的实现方式

      这篇文章主要介绍了Golang中Bit数组的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      天易独尊11682021-06-09
    • Golanggolang如何使用struct的tag属性的详细介绍

      golang如何使用struct的tag属性的详细介绍

      这篇文章主要介绍了golang如何使用struct的tag属性的详细介绍，从例子说起，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看...

      Go语言中文网11352020-05-21
    最近更新
    编辑推荐
    阅读排行
    热门标签
    gosublime 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图