beego 框架是優秀得go REST API開發框架。下面針對beego中各類數據庫連接操作做一個總結。

1. orm連接方式

beego中的orm操作支持三種數據庫：mysql,sqlite3,postgersql。三種數據庫的驅動如下：

import (
    _ "github.com/go-sql-driver/mysql"
    _ "github.com/lib/pq"
    _ "github.com/mattn/go-sqlite3"
)

對於以上三類數據庫的使用，最好使用orm進行操作，因為簡單的增刪查改已經實現了通用的接口封裝。無需再根據每一個模型，單獨的實現一套增刪查改。另外，orm也支持原生sql查詢，復雜的sql操作可以直接使用orm.Raw()進行原生查詢，簡單快捷。

1.1 orm使用方式

a. 註冊數據庫驅動程序

// 參數1   driverName
// 參數2   數據庫類型
// 這個用來設置 driverName 對應的數據庫類型
// mysql / sqlite3 / postgres 這三種是默認已經註冊過的，所以可以無需設置
orm.RegisterDriver("mysql", orm.DRMySQL)

b.註冊數據庫

ORM 必須註冊一個別名為 default 的數據庫，作為默認使用。
ORM 使用 golang 自己的連接池

// 參數1        數據庫的別名，用來在 ORM 中切換數據庫使用
// 參數2        driverName
// 參數3        對應的鏈接字符串
orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8")

// 參數4(可選)  設置最大空閑連接
// 參數5(可選)  設置最大數據庫連接 (go >= 1.2)
maxIdle := 30
maxConn := 30
orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8", maxIdle, maxConn)
 

c. 註冊模型

orm.RegisterModel(new(User), new(Profile), new(Post))

自此，就可以愉快的使用orm提供的接口進行數據庫操作了。

type Ormer interface {
    Read(interface{}, …string) error
    ReadOrCreate(interface{}, string, …string) (bool, int64, error)
    Insert(interface{}) (int64, error)
    InsertMulti(int, interface{}) (int64, error)
    Update(interface{}, …string) (int64, error)
    Delete(interface{}) (int64, error)
    LoadRelated(interface{}, string, …interface{}) (int64, error)
    QueryM2M(interface{}, string) QueryM2Mer
    QueryTable(interface{}) QuerySeter
    Using(string) error
    Begin() error
    Commit() error
    Rollback() error
    Raw(string, …interface{}) RawSeter
    Driver() Driver
}
 

1.2 操作示例

a. orm連接mysql

import (
    "github.com/astaxie/beego/orm"
    _ "github.com/go-sql-driver/mysql"
)

func init() {
    orm.RegisterDriver("mysql", orm.DRMySQL)
    orm.RegisterDataBase("default", "mysql", "root:root@tcp(192.168.1.1:3306)/ming?charset=utf8")
    orm.RegisterModel(new(User))

    orm.SetMaxIdleConns("default", 10)
    orm.SetMaxOpenConns("default", 100)
}

func Create(param interface{}) (int64, error) {
    return orm.NewOrm().Insert(param)
}

func Update(param interface{}, fields ...string) (int64, error) {
    return orm.NewOrm().Update(param, fields...)
}

func Delete(param interface{}, cols ...string) (int64, error) {
    return orm.NewOrm().Delete(param, cols...)
}

func Read(md interface{}, cols ...string) error {
    return orm.NewOrm().Read(md, cols...)
}

b. orm連接sqlite3

import (
    "github.com/astaxie/beego/orm"

    _ "github.com/mattn/go-sqlite3"
)

func init() {
    orm.RegisterDriver("sqlite3", orm.DRSqlite)
    orm.RegisterDataBase("default", "sqlite3", "conf/sqlite_test.db")
    orm.SetMaxIdleConns("default", 50)
    orm.SetMaxOpenConns("default", 200)

    //設置數據庫時區
    //orm.DefaultTimeLoc = time.UTC

    orm.RegisterModel(new(User))
}

func Create(param interface{}) (int64, error) {
    return orm.NewOrm().Insert(param)
}

func Update(param interface{}, fields ...string) (int64, error) {
    return orm.NewOrm().Update(param, fields...)
}

func Delete(param interface{}, cols ...string) (int64, error) {
    return orm.NewOrm().Delete(param, cols...)
}

func Read(md interface{}, cols ...string) error {
    return orm.NewOrm().Read(md, cols...)
}

c. orm連接 postgresql

golang orm可以連接postgres，但是好像不支持數據庫中的schema.

import (
    "github.com/astaxie/beego/orm"
    _ "github.com/lib/pq"
)

func init() {
    orm.RegisterDriver("postgres", orm.DRPostgres)
    orm.RegisterDataBase("default", "postgres", "host=192.168.1.1 port=5432 user=root password=root dbname=test sslmode=disable")

    //orm.RegisterModelWithPrefix("schema_name", new(PmPark))
    orm.RegisterModel(new(PmPark))
    orm.SetMaxIdleConns("default", 10)
    orm.SetMaxOpenConns("default", 50)
}

2. 非orm連接方式

使用非orm連接方式，除了mysql,sqlite3,postgresql外，其他的如sqlserver,mongodb,redis等等，都有自己的連接方式。

a. mysql

import (
    "fmt"
    "database/sql"

    _ "github.com/go-sql-driver/mysql"
)

func getMysqlDB() (*sql.DB, error) {
    connectString := "root:123456@tcp(localhost:3306)/test?charset=utf8"

    db, err := sql.Open("mysql", connectString)
    if err != nil {
        return nil, err
    }

    return db, nil
}

b. sqlite3

import (
    "database/sql"
    _ "github.com/mattn/go-sqlite3"
)

func GetDBConn() (*sql.DB, error) {
    return sql.Open("sqlite3", "./data/location.db")
}

c. postgresql

import (
    "database/sql"
    "errors"
    "fmt"
    "time"

    "github.com/astaxie/beego"

    _ "github.com/lib/pq"
)

var (
    host     string = ""
    port     int
    user     string = ""
    password string = ""
    dbname   string = ""

    max_conn  int = 40
    idle_conn int = 10

    postgreConn *sql.DB //全局sql連接,已實現連接池,所以可以只創建一個實例

    DB_CONN_ERROR error
)

func init() {
    host = beego.AppConfig.String("postgres_host")
    port, _ = beego.AppConfig.Int("postgres_port")
    user = beego.AppConfig.String("postgres_user")
    password = beego.AppConfig.String("postgres_password")
    dbname = beego.AppConfig.String("postgres_dbname")

    max_conn = beego.AppConfig.DefaultInt("postgres_max_conn", 50)
    idle_conn = beego.AppConfig.DefaultInt("postgres_idle_conn", 10)

    DB_CONN_ERROR = errors.New("數據庫連接失敗")
}

func GetPostgresSession() *sql.DB {
    if postgreConn == nil {
        psqlInfo := fmt.Sprintf(`host=%s port=%d user=%s password=%s dbname=%s sslmode=disable`,
            host, port, user, password, dbname)

        db, err := sql.Open("postgres", psqlInfo)
        if err != nil {
            return nil
        }

        db.SetConnMaxLifetime(30 * time.Minute)
        db.SetMaxOpenConns(max_conn)
        db.SetMaxIdleConns(idle_conn)

        //      err = db.Ping()
        //      if err != nil {
        //          return nil
        //      }

        postgreConn = db
    }

    return postgreConn
}

d. mongodb

import (
    "errors"
    "time"

    "github.com/astaxie/beego"
    "gopkg.in/mgo.v2"
)

// 連接mongodb數據庫
var (
    MongodbAddr   string = "" //mongodb數據庫地址
    MongodbName   string = "" //mongodb數據名稱
    MongodbUser   string = "" //mongodb用戶名
    MongodbPasswd string = "" //mongodb密碼
)

var (
    mongosession *mgo.Session
)

func init() {
    MongodbAddr = beego.AppConfig.String("mongodb_addr")
    MongodbName = beego.AppConfig.String("mongodb_name")
    MongodbUser = beego.AppConfig.String("mongodb_username")
    MongodbPasswd = beego.AppConfig.String("mongodb_passwd")
}

func GetMongoSession() *mgo.Session {
    if mongosession == nil {
        var err error

        if MongodbUser == "" || MongodbPasswd == "" {
            mongosession, err = mgo.Dial(MongodbAddr)
        } else {
            dialInfo := &mgo.DialInfo{
                Addrs:     []string{MongodbAddr},
                Direct:    false,
                Timeout:   time.Second * 30,
                Database:  MongodbName,
                Source:    "admin",
                Username:  MongodbUser,
                Password:  MongodbPasswd,
                PoolLimit: 4096, // Session.SetPoolLimit
            }

            mongosession, err = mgo.DialWithInfo(dialInfo)
        }

        if err != nil {
            return nil
        }
    }

    return mongosession.Clone()
}

func WithMongoCollection(collectionName string, s func(*mgo.Collection) error) error {
    session := GetMongoSession()
    if session == nil {
        return errors.New("獲取mongodb連接失敗")
    }
    defer session.Close()

    c := session.DB(MongodbName).C(collectionName)
    return s(c)
}

e.sqlserver

import (
    "database/sql"
    "time"

    "fmt"

    "github.com/astaxie/beego"
    _ "github.com/denisenkom/go-mssqldb"
)

const (
    CONN_LIVE_TIME = 24 //連接使用時間 小時
)

var (
    db       *sql.DB = nil //全局數據庫連接
)

func init() {
    host := beego.AppConfig.String("yr_host")
    port, err := beego.AppConfig.Int("yr_port")
    if err != nil {
        port = 1433
    }

    user := beego.AppConfig.String("user")
    password := beego.AppConfig.String("password")
    dbName := beego.AppConfig.String("name")

    connString := fmt.Sprintf("server=%s;port%d;database=%s;user id=%s;password=%s", host, port, dbName, user, password)
    db, err = sql.Open("mssql", connString)
    if err != nil {
        return 
    }

    db.SetMaxOpenConns(200)
    db.SetMaxIdleConns(50)
    db.SetConnMaxLifetime(time.Duration(CONN_LIVE_TIME) * time.Hour)
}

f.redis

import (
    "time"

    "github.com/astaxie/beego"
    "github.com/gomodule/redigo/redis"
)

var (
    db_addr     string = ""
    db_password string = ""

    redisPool *redis.Pool //redis連接池
)

func init() {
    db_addr = beego.AppConfig.String("redis_addr")
    db_password = beego.AppConfig.String("redis_password")
}


//獲取Redis連接池
func newRedisPool(server, password string) (*redis.Pool, error) {
    var err error
    return &redis.Pool{
        MaxIdle:     32,
        IdleTimeout: 180 * time.Second,
        Dial: func() (redis.Conn, error) {
            var c redis.Conn
            c, err = redis.Dial("tcp", server)
            if err != nil {
                return nil, err
            }

            if password != "" {
                if _, err = c.Do("AUTH", password); err != nil {
                    c.Close()
                    return nil, err
                }
            }

            return c, err
        },
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            _, err := c.Do("PING")
            return err
        },
    }, err
}

/*
獲取redis數據庫連接
*/
func GetRedisConnection() (redis.Conn, error) {
    if redisPool == nil {
        var err error
        redisPool, err = newRedisPool(db_addr, db_password)
        if err != nil {
            return nil, err
        }
    }

    return redisPool.Get(), nil
}

beego中各類數據庫連接方式