• 5.6 NOSQL数据库操作
    • redis
    • mongoDB
    • links

    5.6 NOSQL数据库操作

    NoSQL(Not Only SQL)，指的是非关系型的数据库。随着Web2.0的兴起，传统的关系数据库在应付Web2.0网站，特别是超大规模和高并发的SNS类型的Web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。

    而Go语言作为21世纪的C语言，对NOSQL的支持也是很好，目前流行的NOSQL主要有redis、mongoDB、Cassandra和Membase等。这些数据库都有高性能、高并发读写等特点，目前已经广泛应用于各种应用中。我接下来主要讲解一下redis和mongoDB的操作。

    redis

    redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)和zset(有序集合)。

    目前应用redis最广泛的应该是新浪微博平台，其次还有Facebook收购的图片社交网站instagram。以及其他一些有名的互联网企业

    Go目前支持redis的驱动有如下

    • https://github.com/garyburd/redigo (推荐)
    • https://github.com/go-redis/redis
    • https://github.com/hoisie/redis
    • https://github.com/alphazero/Go-Redis
    • https://github.com/simonz05/godis

    我以redigo驱动为例来演示如何进行数据的操作:

    2. package main
    4. import (
    5.     "fmt"
    6.     "os"
    7.     "os/signal"
    8.     "syscall"
    9.     "time"
    11.     "github.com/garyburd/redigo/redis"
    12. )
    14. var (
    15.     Pool *redis.Pool
    16. )
    18. func init() {
    19.     redisHost := ":6379"
    20.     Pool = newPool(redisHost)
    21.     close()
    22. }
    24. func newPool(server string) *redis.Pool {
    26.     return &redis.Pool{
    28.         MaxIdle:     3,
    29.         IdleTimeout: 240 * time.Second,
    31.         Dial: func() (redis.Conn, error) {
    32.             c, err := redis.Dial("tcp", server)
    33.             if err != nil {
    34.                 return nil, err
    35.             }
    36.             return c, err
    37.         },
    39.         TestOnBorrow: func(c redis.Conn, t time.Time) error {
    40.             _, err := c.Do("PING")
    41.             return err
    42.         },
    43.     }
    44. }
    46. func close() {
    47.     c := make(chan os.Signal, 1)
    48.     signal.Notify(c, os.Interrupt)
    49.     signal.Notify(c, syscall.SIGTERM)
    50.     signal.Notify(c, syscall.SIGKILL)
    51.     go func() {
    52.         <-c
    53.         Pool.Close()
    54.         os.Exit(0)
    55.     }()
    56. }
    58. func Get(key string) ([]byte, error) {
    60.     conn := Pool.Get()
    61.     defer conn.Close()
    63.     var data []byte
    64.     data, err := redis.Bytes(conn.Do("GET", key))
    65.     if err != nil {
    66.         return data, fmt.Errorf("error get key %s: %v", key, err)
    67.     }
    68.     return data, err
    69. }
    71. func main() {
    72.     test, err := Get("test")
    73.     fmt.Println(test, err)
    74. }

    另外以前我fork了最后一个驱动，更新了一些bug，目前应用在我自己的短域名服务项目中(每天200W左右的PV值)

    https://github.com/astaxie/goredis

    接下来的以我自己fork的这个redis驱动为例来演示如何进行数据的操作

    2. package main
    4. import (
    5.     "fmt"
    7.     "github.com/astaxie/goredis"
    8. )
    10. func main() {
    11.     var client goredis.Client
    12.     // 设置端口为redis默认端口
    13.     client.Addr = "127.0.0.1:6379"
    15.     //字符串操作
    16.     client.Set("a", []byte("hello"))
    17.     val, _ := client.Get("a")
    18.     fmt.Println(string(val))
    19.     client.Del("a")
    21.     //list操作
    22.     vals := []string{"a", "b", "c", "d", "e"}
    23.     for _, v := range vals {
    24.         client.Rpush("l", []byte(v))
    25.     }
    26.     dbvals,_ := client.Lrange("l", 0, 4)
    27.     for i, v := range dbvals {
    28.         println(i,":",string(v))
    29.     }
    30.     client.Del("l")
    31. }

    我们可以看到操作redis非常的方便，而且我实际项目中应用下来性能也很高。client的命令和redis的命令基本保持一致。所以和原生态操作redis非常类似。

    mongoDB

    MongoDB是一个高性能，开源，无模式的文档型数据库，是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，采用的是类似json的bjson格式来存储数据，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

    下图展示了mysql和mongoDB之间的对应关系，我们可以看出来非常的方便，但是mongoDB的性能非常好。

    NOSQL数据库操作 - 图1

    图5.1 MongoDB和Mysql的操作对比图

    目前Go支持mongoDB最好的驱动就是mgo，这个驱动目前最有可能成为官方的pkg。

    安装mgo:

    1. go get gopkg.in/mgo.v2

    下面我将演示如何通过Go来操作mongoDB：

    2. package main
    4. import (
    5.     "fmt"
    6.     "log"
    8.     "gopkg.in/mgo.v2"
    9.     "gopkg.in/mgo.v2/bson"
    10. )
    12. type Person struct {
    13.     Name  string
    14.     Phone string
    15. }
    17. func main() {
    18.     session, err := mgo.Dial("server1.example.com,server2.example.com")
    19.     if err != nil {
    20.         panic(err)
    21.     }
    22.     defer session.Close()
    24.     // Optional. Switch the session to a monotonic behavior.
    25.     session.SetMode(mgo.Monotonic, true)
    27.     c := session.DB("test").C("people")
    28.     err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
    29.         &Person{"Cla", "+55 53 8402 8510"})
    30.     if err != nil {
    31.         log.Fatal(err)
    32.     }
    34.     result := Person{}
    35.     err = c.Find(bson.M{"name": "Ale"}).One(&result)
    36.     if err != nil {
    37.         log.Fatal(err)
    38.     }
    40.     fmt.Println("Phone:", result.Phone)
    41. }

    我们可以看出来mgo的操作方式和beedb的操作方式几乎类似，都是基于struct的操作方式，这个就是Go Style。

    • 目录
    • 上一节: 使用Beego orm库进行ORM开发
    • 下一节: 小结