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)
這樣就會將哪個檔案哪一行 都記錄下來 但是不是特殊需求無需開啟這個 因為會增加性能開銷
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/277974.html
標籤：其他