2. 程式人生 > >Go語言操作Redis、MySQL

Go語言操作Redis、MySQL

阿新 • • 發佈：2018-12-11

文章出處：http://www.cnblogs.com/wdliu/p/9330278.html

一、redis

簡介

redis(REmote DIctionary Server)是一個由Salvatore Sanfilippo寫key-value儲存系統，它由C語言編寫、遵守BSD協議、支援網路、可基於記憶體亦可持久化的日誌型、Key-Value型別的資料庫，並提供多種語言的API。和Memcached類似，它支援儲存的value型別相對更多，包括string(字串)、list(連結串列)、set(集合)、zset(sorted set --有序集合)和hash（雜湊型別）。這些資料型別都支援push/pop、add/remove及取交集並集和差集及更豐富的操作，而且這些操作都是原子性的。在此基礎上，redis支援各種不同方式的排序。與memcached一樣，為了保證效率，資料都是快取在記憶體中。區別的是redis會週期性的把更新的資料寫入磁碟或者把修改操作寫入追加的記錄檔案，並且在此基礎上實現了master-slave(主從)同步，redis在3.0版本推出叢集模式。

官方網站：https://redis.io/

原始碼部署

複製程式碼

yum install gcc -y  #安裝C依賴
wget http://download.redis.io/redis-stable.tar.gz  #下載穩定版本
tar zxvf redis-stable.tar.gz  #解壓
cd redis-stable
make PREFIX=/opt/app/redis install   #指定目錄編譯
make install
mkdir /etc/redis   #建立配置目錄
cp redis.conf /etc/redis/6379.conf # 拷貝配置檔案
cp utils/redis_init_script /etc/init.d/redis  #拷貝init啟動指令碼針對6.X系統
chmod a+x  /etc/init.d/redis  #新增執行許可權
修改配置檔案：
 vi /etc/redis/6379.conf
  
bind 0.0.0.0      #監聽地址
maxmemory 4294967296   #限制最大記憶體（4G）：
daemonize yes   #後臺執行

####啟動與停止
/etc/init.d/redis start
/etc/init.d/redis stop

複製程式碼

檢視版本資訊

複製程式碼

#執行客戶端工具
redis-cli 
#輸入命令info
127.0.0.1:6379> info
# Server
redis_version:4.0.10
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:cf83e9c690dbed33
redis_mode:standalone
os:Linux 2.6.32-642.el6.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll

複製程式碼

二、golang操作redis

安裝

golang操作redis的客戶端包有多個比如redigo、go-redis，github上Star最多的莫屬redigo。

github地址：https://github.com/garyburd/redigo  目前已經遷移到：https://github.com/gomodule/redigo 

文件：https://godoc.org/github.com/garyburd/redigo/redis

go get github.com/garyburd/redigo/redis
import "github.com/garyburd/redigo/redis"

連線

Conn介面是與Redis協作的主要介面，可以使用Dial,DialWithTimeout或者NewConn函式來建立連線，當任務完成時，應用程式必須呼叫Close函式來完成操作。

複製程式碼

package main

import (
"github.com/garyburd/redigo/redis"
"fmt"
)


func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
}

複製程式碼

命令操作

通過使用Conn介面中的do方法執行redis命令，redis命令大全參考：http://doc.redisfans.com/

go中傳送與響應對應型別：

Do函式會必要時將引數轉化為二進位制字串

Go Type Conversion
[]byte Sent as is
string Sent as is
int, int64 strconv.FormatInt(v)
float64 strconv.FormatFloat(v, 'g', -1, 64)
bool true -> "1", false -> "0"
nil ""
all other types fmt.Print(v)

Redis 命令響應會用以下Go型別表示：

Redis type Go type
error redis.Error
integer int64
simple string string
bulk string []byte or nil if value not present.
array []interface{} or nil if value not present.

 

可以使用GO的型別斷言或者reply輔助函式將返回的interface{}轉換為對應型別。

操作示例：

get、set

複製程式碼

package main

import (
"github.com/garyburd/redigo/redis"
"fmt"
)


func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    _, err = conn.Do("SET", "name", "wd")
    if err != nil {
        fmt.Println("redis set error:", err)
    }
    name, err := redis.String(conn.Do("GET", "name"))
    if err != nil {
        fmt.Println("redis get error:", err)
    } else {
        fmt.Printf("Got name: %s \n", name)
    }
}

複製程式碼

設定key過期時間

  _, err = conn.Do("expire", "name", 10) //10秒過期
    if err != nil {
        fmt.Println("set expire error: ", err)
        return
    }

批量獲取mget、批量設定mset

複製程式碼

_, err = conn.Do("MSET", "name", "wd","age",22)
    if err != nil {
        fmt.Println("redis mset error:", err)
    }
    res, err := redis.Strings(conn.Do("MGET", "name","age"))
    if err != nil {
        fmt.Println("redis get error:", err)
    } else {
        res_type := reflect.TypeOf(res)
        fmt.Printf("res type : %s \n", res_type)
        fmt.Printf("MGET name: %s \n", res)
        fmt.Println(len(res))
    }
//結果：
//res type : []string 
//MGET name: [wd 22] 
//2

複製程式碼

列表操作

複製程式碼

package main

import (
"github.com/garyburd/redigo/redis"
"fmt"
    "reflect"
)


func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    _, err = conn.Do("LPUSH", "list1", "ele1","ele2","ele3")
    if err != nil {
        fmt.Println("redis mset error:", err)
    }
    res, err := redis.String(conn.Do("LPOP", "list1"))
    if err != nil {
        fmt.Println("redis POP error:", err)
    } else {
        res_type := reflect.TypeOf(res)
        fmt.Printf("res type : %s \n", res_type)
        fmt.Printf("res  : %s \n", res)
    }
}
//res type : string 
//res  : ele3

複製程式碼

hash操作

複製程式碼

package main

import (
"github.com/garyburd/redigo/redis"
"fmt"
    "reflect"
)


func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    _, err = conn.Do("HSET", "student","name", "wd","age",22)
    if err != nil {
        fmt.Println("redis mset error:", err)
    }
    res, err := redis.Int64(conn.Do("HGET", "student","age"))
    if err != nil {
        fmt.Println("redis HGET error:", err)
    } else {
        res_type := reflect.TypeOf(res)
        fmt.Printf("res type : %s \n", res_type)
        fmt.Printf("res  : %d \n", res)
    }
}
//res type : int64 
//res  : 22

複製程式碼

Pipelining(管道)

管道操作可以理解為併發操作，並通過Send()，Flush()，Receive()三個方法實現。客戶端可以使用send()方法一次性向伺服器傳送一個或多個命令，命令傳送完畢時，使用flush()方法將緩衝區的命令輸入一次性發送到伺服器，客戶端再使用Receive()方法依次按照先進先出的順序讀取所有命令操作結果。

Send(commandName string, args ...interface{}) error
Flush() error
Receive() (reply interface{}, err error)
  • Send：傳送命令至緩衝區
  • Flush：清空緩衝區，將命令一次性發送至伺服器
  • Recevie：依次讀取伺服器響應結果，當讀取的命令未響應時，該操作會阻塞。

示例：

複製程式碼

package main

import (
"github.com/garyburd/redigo/redis"
"fmt"
)


func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    conn.Send("HSET", "student","name", "wd","age","22")
    conn.Send("HSET", "student","Score","100")
    conn.Send("HGET", "student","age")
    conn.Flush()

    res1, err := conn.Receive()
    fmt.Printf("Receive res1:%v \n", res1)
    res2, err := conn.Receive()
    fmt.Printf("Receive res2:%v\n",res2)
    res3, err := conn.Receive()
    fmt.Printf("Receive res3:%s\n",res3)
}
//Receive res1:0 
//Receive res2:0
//Receive res3:22

複製程式碼

釋出/訂閱

redis本身具有釋出訂閱的功能，其釋出訂閱功能通過命令SUBSCRIBE(訂閱)／PUBLISH(釋出)實現，並且釋出訂閱模式可以是多對多模式還可支援正則表示式，釋出者可以向一個或多個頻道傳送訊息，訂閱者可訂閱一個或者多個頻道接受訊息。

示意圖：

釋出者：

訂閱者：

操作示例，示例中將使用兩個goroutine分別擔任釋出者和訂閱者角色進行演示：

複製程式碼

package main

import (
    "github.com/garyburd/redigo/redis"
    "fmt"
    "time"
)

func Subs() {  //訂閱者
    conn, err := redis.Dial("tcp", "10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :", err)
        return
    }
    defer conn.Close()
    psc := redis.PubSubConn{conn}
    psc.Subscribe("channel1") //訂閱channel1頻道
    for {
        switch v := psc.Receive().(type) {
        case redis.Message:
            fmt.Printf("%s: message: %s\n", v.Channel, v.Data)
        case redis.Subscription:
            fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
        case error:
            fmt.Println(v)
            return
        }
    }
}

func Push(message string)  { //釋出者
    conn, _ := redis.Dial("tcp", "10.1.210.69:6379")
    _,err1 := conn.Do("PUBLISH", "channel1", message)
       if err1 != nil {
             fmt.Println("pub err: ", err1)
                 return
            }

}

func main()  {
    go Subs()
    go Push("this is wd")
    time.Sleep(time.Second*3)
}
//channel1: subscribe 1
//channel1: message: this is wd

複製程式碼

事務操作

MULTI, EXEC,DISCARD和WATCH是構成Redis事務的基礎，當然我們使用go語言對redis進行事務操作的時候本質也是使用這些命令。

MULTI：開啟事務

EXEC：執行事務

DISCARD：取消事務

WATCH：監視事務中的鍵變化，一旦有改變則取消事務。

示例：

複製程式碼

package main

import (
"github.com/garyburd/redigo/redis"
"fmt"
)


func main()  {
    conn,err := redis.Dial("tcp","10.1.210.69:6379")
    if err != nil {
        fmt.Println("connect redis error :",err)
        return
    }
    defer conn.Close()
    conn.Send("MULTI")
    conn.Send("INCR", "foo")
    conn.Send("INCR", "bar")
    r, err := conn.Do("EXEC")
    fmt.Println(r)
}
//[1, 1]

複製程式碼

連線池使用

redis連線池是通過pool結構體實現，以下是原始碼定義，相關引數說明已經備註：

複製程式碼

type Pool struct {
    // Dial is an application supplied function for creating and configuring a
    // connection.
    //
    // The connection returned from Dial must not be in a special state
    // (subscribed to pubsub channel, transaction started, ...).
    Dial func() (Conn, error) //連線方法

    // TestOnBorrow is an optional application supplied function for checking
    // the health of an idle connection before the connection is used again by
    // the application. Argument t is the time that the connection was returned
    // to the pool. If the function returns an error, then the connection is
    // closed.
    TestOnBorrow func(c Conn, t time.Time) error

    // Maximum number of idle connections in the pool.
    MaxIdle int  //最大的空閒連線數，即使沒有redis連線時依然可以保持N個空閒的連線，而不被清除，隨時處於待命狀態

    // Maximum number of connections allocated by the pool at a given time.
    // When zero, there is no limit on the number of connections in the pool.
    MaxActive int //最大的啟用連線數，同時最多有N個連線

    // Close connections after remaining idle for this duration. If the value
    // is zero, then idle connections are not closed. Applications should set
    // the timeout to a value less than the server's timeout.
    IdleTimeout time.Duration  //空閒連線等待時間，超過此時間後，空閒連線將被關閉

    // If Wait is true and the pool is at the MaxActive limit, then Get() waits
    // for a connection to be returned to the pool before returning.
    Wait bool  //當配置項為true並且MaxActive引數有限制時候，使用Get方法等待一個連線返回給連線池

    // Close connections older than this duration. If the value is zero, then
    // the pool does not close connections based on age.
    MaxConnLifetime time.Duration
    // contains filtered or unexported fields
}

複製程式碼

 示例：

複製程式碼

package main

import (
    "github.com/garyburd/redigo/redis"
    "fmt"
)

var Pool redis.Pool
func init()  {      //init 用於初始化一些引數，先於main執行
    Pool = redis.Pool{
        MaxIdle:     16,
        MaxActive:   32,
        IdleTimeout: 120,
        Dial: func() (redis.Conn, error) {
            return redis.Dial("tcp", "10.1.210.69:6379")
        },
    }
}

func main()  {

    conn :=Pool.Get()
    res,err := conn.Do("HSET","student","name","jack")
    fmt.Println(res,err)
    res1,err := redis.String(conn.Do("HGET","student","name"))
    fmt.Printf("res:%s,error:%v",res1,err)

}
//0 <nil>
//res:jack,error:<nil>

複製程式碼

三、golang操作mysql

mysql目前來說是使用最為流行的關係型資料庫，golang操作mysql使用最多的包go-sql-driver/mysql。

sqlx包是作為database/sql包的一個額外擴充套件包，在原有的database/sql加了很多擴充套件，如直接將查詢的資料轉為結構體，大大簡化了程式碼書寫，當然database/sql包中的方法同樣起作用。

github地址：

  • https://github.com/go-sql-driver/mysql
  • https://github.com/jmoiron/sqlx

golang sql使用：

安裝

go get "github.com/go-sql-driver/mysql"
go get "github.com/jmoiron/sqlx"

連線資料庫

var Db *sqlx.DB
db, err := sqlx.Open("mysql","username:[email protected](ip:port)/database?charset=utf8")
Db = db

處理型別（Handle Types)

sqlx設計和database/sql使用方法是一樣的。包含有4中主要的handle types： 

  • sqlx.DB - 和sql.DB相似，表示資料庫。 
  • sqlx.Tx - 和sql.Tx相似，表示事物。 
  • sqlx.Stmt - 和sql.Stmt相似，表示prepared statement。 
  • sqlx.NamedStmt - 表示prepared statement（支援named parameters）

所有的handler types都提供了對database/sql的相容，意味著當你呼叫sqlx.DB.Query時，可以直接替換為sql.DB.Query.這就使得sqlx可以很容易的加入到已有的資料庫專案中。

此外，sqlx還有兩個cursor型別： 

  • sqlx.Rows - 和sql.Rows類似，Queryx返回。 
  • sqlx.Row - 和sql.Row類似，QueryRowx返回。

 

相比database/sql方法還多了新語法，也就是實現將獲取的資料直接轉換結構體實現。

  • Get(dest interface{}, …) error
  • Select(dest interface{}, …) error 

 

建表

以下所有示例均已以下表結構作為操作基礎。

複製程式碼

CREATE TABLE `userinfo` (
    `uid` INT(10) NOT NULL AUTO_INCREMENT,
    `username` VARCHAR(64)  DEFAULT NULL,
    `password` VARCHAR(32)  DEFAULT NULL,
    `department` VARCHAR(64)  DEFAULT NULL,
    `email` varchar(64) DEFAULT NULL,
    PRIMARY KEY (`uid`)
)ENGINE=InnoDB DEFAULT CHARSET=utf8

複製程式碼

Exec使用

Exec和MustExec從連線池中獲取一個連線然後只想對應的query操作。對於不支援ad-hoc query execution的驅動，在操作執行的背後會建立一個prepared statement。在結果返回前這個connection會返回到連線池中。

需要注意的是不同的資料庫型別使用的佔位符不同，mysql採用？作為佔位符號。

 

  • MySQL 使用？ 
  • PostgreSQL 使用1,1,2等等 
  • SQLite 使用？或$1 
  • Oracle 使用:name

 

Exec增刪該示例

查詢語法使用Query後續會提到

複製程式碼

package main

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
    "fmt"
)

var Db *sqlx.DB

func init()  {
    db, err := sqlx.Open("mysql", "stu:[email protected](10.0.0.241:3307)/test?charset=utf8")
    if err != nil {
        fmt.Println("open mysql failed,", err)
        return
    }
    Db = db
}

func main()  {
    result, err := Db.Exec("INSERT INTO userinfo (username, password, department,email) VALUES (?, ?, ?,?)","wd","123","it","[email protected]")
    if err != nil{
        fmt.Println("insert failed,error： ", err)
        return
    }
    id,_ := result.LastInsertId()
    fmt.Println("insert id is :",id)
    _, err1 := Db.Exec("update userinfo set username = ? where uid = ?","jack",1)
    if err1 != nil{
        fmt.Println("update failed error:",err1)
    } else {
        fmt.Println("update success!")
    }
    _, err2 := Db.Exec("delete from userinfo where uid = ? ", 1)
    if err2 != nil{
        fmt.Println("delete error:",err2)
    }else{
        fmt.Println("delete success")
    }

}
//insert id is : 1
//update success!
//delete success

複製程式碼

sql預宣告（Prepared Statements）

對於大部分的資料庫來說，當一個query執行的時候，在sql語句資料庫內部宣告已經宣告過了，其宣告是在資料庫中，我們可以提前進行宣告，以便在其他地方重用。

stmt, err := db.Prepare(`SELECT * FROM place WHERE telcode=?`)
row = stmt.QueryRow(65)
 
tx, err := db.Begin()
txStmt, err := tx.Prepare(`SELECT * FROM place WHERE telcode=?`)
row = txStmt.QueryRow(852)

當然sqlx還提供了Preparex()進行擴充套件，可直接用於結構體轉換

stmt, err := db.Preparex(`SELECT * FROM place WHERE telcode=?`)
var p Place
err = stmt.Get(&p, 852)

Query

Query是database/sql中執行查詢主要使用的方法，該方法返回row結果。Query返回一個sql.Rows物件和一個error物件。

在使用的時候應該吧Rows當成一個遊標而不是一系列的結果。儘管資料庫驅動快取的方法不一樣，通過Next()迭代每次獲取一列結果，對於查詢結果非常巨大的情況下，可以有效的限制記憶體的使用，Scan()利用reflect把sql每一列結果對映到go語言的資料型別如string，[]byte等。如果你沒有遍歷完全部的rows結果，一定要記得在把connection返回到連線池之前呼叫rows.Close()。

Query返回的error有可能是在server準備查詢的時候發生的，也有可能是在執行查詢語句的時候發生的。例如可能從連線池中獲取一個壞的連級（儘管資料庫會嘗試10次去發現或建立一個工作連線）。一般來說，錯誤主要由錯誤的sql語句，錯誤的類似匹配，錯誤的域名或表名等。

在大部分情況下，Rows.Scan()會把從驅動獲取的資料進行拷貝，無論驅動如何使用快取。特殊型別sql.RawBytes可以用來從驅動返回的資料總獲取一個zero-copy的slice byte。當下一次呼叫Next的時候，這個值就不在有效了，因為它指向的記憶體已經被驅動重寫了別的資料。

Query使用的connection在所有的rows通過Next()遍歷完後或者呼叫rows.Close()後釋放。 

示例：

複製程式碼

package main

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
    "fmt"
)

var Db *sqlx.DB

func init()  {
    db, err := sqlx.Open("mysql", "stu:[email protected](10.0.0.241:3307)/test?charset=utf8")
    if err != nil {
        fmt.Println("open mysql failed,", err)
        return
    }
    Db = db
}

func main()  {
    rows, err := Db.Query("SELECT username,password,email FROM userinfo")
    if err != nil{
        fmt.Println("query failed,error： ", err)
        return
    }
    for rows.Next() {  //迴圈結果
        var username,password,email string
        err = rows.Scan(&username, &password, &email)
        println(username,password,email)
    }
    
}
//wd 123 [email protected]
//jack 1222 [email protected]

複製程式碼

Queryx

Queryx和Query行為很相似，不過返回一個sqlx.Rows物件，支援擴充套件的scan行為,同時可將對資料進行結構體轉換。

示例：

複製程式碼

package main

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
    "fmt"
)

var Db *sqlx.DB

type stu struct {
    Username string   `db:"username"`
    Password string      `db:"password"`
    Department string  `db:"department"`
    Email string        `db:"email"`
}

func init()  {
    db, err := sqlx.Open("mysql", "stu:[email protected](10.0.0.241:3307)/test?charset=utf8")
    if err != nil {
        fmt.Println("open mysql failed,", err)
        return
    }
    Db = db
}

func main()  {
    rows, err := Db.Queryx("SELECT username,password,email FROM userinfo")
    if err != nil{
        fmt.Println("Qeryx failed,error： ", err)
        return
    }
    for rows.Next() {  //迴圈結果
        var stu1 stu
        err = rows.StructScan(&stu1)// 轉換為結構體
        fmt.Println("stuct data：",stu1.Username,stu1.Password)
    }
}
//stuct data： wd 123
//stuct data： jack 1222

複製程式碼

QueryRow和QueryRowx

QueryRow和QueryRowx都是從資料庫中獲取一條資料，但是QueryRowx提供scan擴充套件，可直接將結果轉換為結構體。

複製程式碼

package main

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
    "fmt"
)

var Db *sqlx.DB

type stu struct {
    Username string   `db:"username"`
    Password string      `db:"password"`
    Department string  `db:"department"`
    Email string        `db:"email"`
}

func init()  {
    db, err := sqlx.Open("mysql", "stu:[email protected](10.0.0.241:3307)/test?charset=utf8")
    if err != nil {
        fmt.Println("open mysql failed,", err)
        return
    }
    Db = db
}

func main()  {
    row := Db.QueryRow("SELECT username,password,email FROM userinfo where uid = ?",1) // QueryRow返回錯誤，錯誤通過Scan返回
    var username,password,email string
    err :=row.Scan(&username,&password,&email)
    if err != nil{
        fmt.Println(err)
    }
    fmt.Printf("this is QueryRow res:[%s:%s:%s]\n",username,password,email)
    var s stu
    err1 := Db.QueryRowx("SELECT username,password,email FROM userinfo where uid = ?",2).StructScan(&s)
    if err1 != nil{
        fmt.Println("QueryRowx error :",err1)
    }else {
        fmt.Printf("this is QueryRowx res:%v",s)
    }
}
//this is QueryRow res:[wd:123:[email protected]]
//this is QueryRowx res:{jack 1222  [email protected]}

複製程式碼

Get 和Select（非常常用）

Get和Select是一個非常省時的擴充套件，可直接將結果賦值給結構體，其內部封裝了StructScan進行轉化。Get用於獲取單個結果然後Scan，Select用來獲取結果切片。

示例：

複製程式碼

package main

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
    "fmt"
)

var Db *sqlx.DB

type stu struct {
    Username string   `db:"username"`
    Password string      `db:"password"`
    Department string  `db:"department"`
    Email string        `db:"email"`
}

func init()  {
    db, err := sqlx.Open("mysql", "stu:[email protected](10.0.0.241:3307)/test?charset=utf8")
    if err != nil {
        fmt.Println("open mysql failed,", err)
        return
    }
    Db = db
}

func main()  {
    var stus []stu
    err := Db.Select(&stus,"SELECT username,password,email FROM userinfo")
    if err != nil{
        fmt.Println("Select error",err)
    }
    fmt.Printf("this is Select res:%v\n",stus)
    var s stu
    err1 := Db.Get(&s,"SELECT username,password,email FROM userinfo where uid = ?",2)
    if err1 != nil{
        fmt.Println("GET error :",err1)
    }else {
        fmt.Printf("this is GET res:%v",s)
    }
}
//this is Select res:[{wd 123  [email protected]} {jack 1222  [email protected]}]
//this is GET res:{jack 1222  [email protected]}

複製程式碼

事務（Transactions）

事務操作是通過三個方法實現：

Begin()：開啟事務

Commit()：提交事務（執行sql)

Rollback()：回滾

使用流程：

複製程式碼

tx, err := db.Begin()
err = tx.Exec(...)
err = tx.Commit()

//或者使用sqlx擴充套件的事務
tx := db.MustBegin()
tx.MustExec(...)
err = tx.Commit()

複製程式碼

由於事務是一個一直連線的狀態，所以Tx物件必須繫結和控制單個連線。一個Tx會在整個生命週期中儲存一個連線，然後在呼叫commit或Rollback()的時候釋放掉。在呼叫這幾個函式的時候必須十分小心，否則連線會一直被佔用直到被垃圾回收。 

使用示例：

複製程式碼

package main

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
    "fmt"
)

var Db *sqlx.DB

func init()  {
    db, err := sqlx.Open("mysql", "stu:[email protected](10.0.0.241:3307)/test?charset=utf8")
    if err != nil {
        fmt.Println("open mysql failed,", err)
        return
    }
    Db = db
}

func main()  {
    tx, err := Db.Beginx()
    _, err = tx.Exec("insert into userinfo(username,password) values(?,?)", "Rose","2223")
    if err != nil {
        tx.Rollback()
    }
    _, err = tx.Exec("insert into userinfo(username,password) values(?,?)", "Mick",222)
    if err != nil {
        fmt.Println("exec sql error:",err)
        tx.Rollback()
    }
    err = tx.Commit()
    if err != nil {
        fmt.Println("commit error")
    }

}

複製程式碼

連線池設定

預設情況下，連線池增長無限制，並且只要連線池中沒有可用的空閒連線，就會建立連線。我們可以使用DB.SetMaxOpenConns設定池的最大大小。未使用的連線標記為空閒，如果不需要則關閉。要避免建立和關閉大量連線，可以使用DB.SetMaxIdleConns設定最大空閒連線。

注意：該設定方法golang版本至少為1.2

  • DB.SetMaxIdleConns(n int)    設定最大空閒連線數
  • DB.SetMaxOpenConns(n int)  設定最大開啟的連線數

 

示例：

複製程式碼

package main

import (
    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
    "fmt"
)

var Db *sqlx.DB

func init()  {
    db, err := sqlx.Open("mysql", "stu:[email protected](10.0.0.241:3307)/test?charset=utf8")
    if err != nil {
        fmt.Println("open mysql failed,", err)
        return
    }
    Db = db
    Db.SetMaxOpenConns(30)
    Db.SetMaxIdleConns(15)

}

複製程式碼

相關推薦

Go語言操作Redis、MySQL

文章出處：http://www.cnblogs.com/wdliu/p/9330278.html 一、redis 簡介 redis(REmote DIctionary Server)是一個由Salvatore Sanfilippo寫key-value儲存系統，它由C語言編寫、遵守BSD協

Go語言操作Redis

package main import (     "fmt"         "time"     "log"     "github.com/garyburd/redigo/redis" ) func main(){     fmt.Println("Redis:")

使用go語言操作mysql資料庫

1.下載並匯入資料庫驅動包 官方不提供實現，先下載第三方的實現，點選這裡檢視各種各樣的實現版本。 這裡選擇了Go-MySQL-Driver這個實現。地址是：https://github.com/go-sql-driver/mysql/。 然後按照裡面的說明下載驅動包： $ go get

go語言操作mysql範例（增刪查改）

    go官方僅提供了database package，database package下有兩個包sql，sql/driver。這兩個包用來定義操作資料庫的介面，這就保證了無論使用哪種資料庫，他們的操作方式都是相同的。     但go官方並沒有提供連線資料庫的drive

go操作redis和mysql示例

pip 時間 upd commit 響應 ini 修改 insert let 一：redis示例 使用redis的包是： github.com/garyburd/redigo/redis 1：編寫第一個示例： 鏈接，設置，獲取 redis_basic.go packa

golang 操作 Redis & Mysql & RabbitMQ

requests now() ++ routing ont connect ner red lang golang 操作 Redis & Mysql & RabbitMQ Reids 安裝導入 go get github.com/garyburd/redi

go語言的排序、結構體排序

sea 封裝 class 讓其 其他 zhang import 過去 blue 原文：https://studygolang.com/articles/1598 晚上準備動手寫點 go 的程序的時候，想起 go 如何排序的問題。排序 sort 是個基本的操作，當然搜索

Go語言6-介面、反射

介面 接著上次的繼續講介面，先回顧一下介面的用法： package main import "fmt" // 定義介面 type Car interface { GetName() string Run() } // 定義結構體 type Tesla struct { Nam

Go語言發展歷史、核心、特性及學習路線

Go語言發展歷史、核心、特性及學習路線 目錄 知名程式語言發展簡史 Go語言主要發展過程 Go語言設計初衷 Go語言的優勢 Go語言的核心特性 Go語言能開發什麼？ 採用Go語言的國內外企業 Go語言學生路線 一、 Go語言的發展歷史 （

go語言學習--string、int、int64互相轉換

#string到int int,err:=strconv.Atoi(string) #string到int64 int64, err := strconv.ParseInt(string, 10, 64) #int到string string:=strconv.Ito

Go語言10-http和mysql

http 程式設計 Go 原生支援http： import "net/http" Go 的http服務效能和nginx比較接近：就是說用Go寫的Web程式上線，程式前面不需要再部署nginx的Web伺服器，這裡省掉的是Web伺服器。如果伺服器上部署了多個Web應用，還是需要反向代理的，一般這也是ngin

Go語言基礎（九）—— Go語言結構體、Go語言切片（Slice）、range遍歷、Go語言Map（集合）

Go語言結構體 Go 語言中陣列可以儲存同一型別的資料，但在結構體中我們可以為不同項定義不同的資料型別。 結構體是由一系列具有相同型別或不同型別的資料構成的資料集合。  結構體表示一項記錄，比如儲存圖書館的書籍記錄，每本書有以下屬性： Title ：標題&nbs

swoft操作redis、多例項配置

修改連線池配置 app/config/properties/cache.php 配置檔案 return [ 'redis' => [ 'name' => 'redis', 'uri' =>

初次部署springboot、docker、redis、mysql、nginx

本文章適合所有初學者閱讀、我會從剛買來的一臺伺服器開始從零到部署專案   當然怎麼購買我就不多說了 使用到的技術有springboot、docker、redis、mysql、nginx 操作環境MAC電腦 首先通過終端連線伺服器   ssh [email pr

Redis資料庫學習筆記03--go語言與Redis資料庫簡單互動

目錄 1.使用go語言與redis資料庫互動配置 1.1 安裝redis資料庫操作工具包redigo 1.2 測試redigo工具包是否正常工作 1.3 redigo工具包來源 1.4 go get命令概述 2.redigo工具包簡單使用說明 3.go語言與Redis資料

Go語言操作excel

圖片儲存，excel表格安裝dpi為120儲存的 dpi：每英寸佔用的畫素個數 舉例： 本地圖片 畫素為500，dpi為96， 以計算單位為基準 在excel中的畫素就是 (500/96*120)，保證計算單位相同。 1英寸=畫素/dpi 1磅=(畫素-7)

docker執行redis、mysql

1.列出本地主機上的映象。 docker images 2.從Docker Hub中拉取或者更新指定映象。 docker pull redis docker pull mysql 3.執行redis和mysql映象。（--name:指定容器名 -p:指定埠對映，即主機埠到容器埠的對映 -d:

day7-python操作redis、excel

一、操作redis import redis r=redis.Redis(host='127.0.0.1',password='pass',port=6379,db=13,decode_responses=True)#連線redis #String 型別 #增 set key value #刪 del

Go 語言變量、常量

ota 變量 size 枚舉值 函數 改變 lse 必須 註意 變量 第一種，指定變量類型，聲明後若不賦值，使用默認值。 var v_name v_type v_name = value 第二種，根據值自行判定變量類型。 var v_name = value

Go語言中編譯、執行，以及開發注意事項

** 編譯 ** 1.有了go原始檔，通過編譯器將其編譯成機器可以識別的二進位制原始碼檔案 2.在該原始檔目錄下，通過go build對原始檔.go進行編譯，可以指定生成的可執行檔名，在Windows下必須是.exe字尾 go build -o 新檔名.exe 原始檔名.go