Go語言操作資料庫及其常規操作
Go操作MySQL
安裝: go get -u github.com/go-sql-driver/mysql
GO語言的操作資料庫的驅動原生支援連接池, 並且是並發安全的 標準庫沒有具體的實現 只是列出了一些需要的第三方庫實現的具體內容
//第一次連接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封裝成函數
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的增刪改查
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預處理
// 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實現事務操作
// 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
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 查詢只需要定義一個存儲的變數 然後自動就會將查詢的出來的值放入變數中
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
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釋放資源
// 通道版本
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")
}
// 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對象更容易使用。
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選項，他們是一系列定義好的常量。
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的輸出目的地，默認是標準錯誤輸出
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
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
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.")
- 日誌記錄
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
log.SetFormatter(&log.JSONFormatter{})
- 追蹤函數
log.SetReportCaller(true)
這樣就會將哪個文件哪一行 都記錄下來 但是不是特殊需求無需開啟這個 因為會增加性能開銷
