redis使用

使用第三方开源的redis库: <font style="color:rgb(51, 51, 51);">github.com/garyburd/redigo/redis</font> 命令行输入 ： 
  1. go get github.com/garyburd/redigo/redis

连接redis

:::color2 redigo - 图1

redigo - 图2

想要添加什么属性，在后面添加。

:::

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6.     "github.com/gomodule/redigo/redis"
  7. )
  9. func main() {
  10.     c, err := redis.Dial("tcp", "172.23.188.124:6379", 
  11.         redis.DialConnectTimeout(time.Duration(1) * time.Second),
  12.         // redis.DialPassword("111"),
  13.         redis.DialDatabase(1))
  14.     if err != nil {
  15.         fmt.Println("conn redis failed,", err)
  16.         return
  17.     }
  19.     defer c.Close()
  20. }

String类型Set、Get操作

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/garyburd/redigo/redis"
  6. )
  8. func main() {
  9.     c, err := redis.Dial("tcp", "localhost:6379")
  10.     if err != nil {
  11.         fmt.Println("conn redis failed,", err)
  12.         return
  13.     }
  15.     defer c.Close()
  16.     _, err = c.Do("Set", "abc", 100)
  17.     if err != nil {
  18.         fmt.Println(err)
  19.         return
  20.     }
  22.     r, err := redis.Int(c.Do("Get", "abc"))
  23.     if err != nil {
  24.         fmt.Println("get abc failed,", err)
  25.         return
  26.     }
  28.     fmt.Println(r)            // 100
  29. }

:::color2 **<font style="color:#DF2A3F;">c.Do("MSet", "abc", 100, "efg", 300)</font>**：Do执行语句

**<font style="color:#DF2A3F;">redis.Int</font>**：转成int类型，返回int类型

**<font style="color:#DF2A3F;">redis.Ints</font>**：转成[]int类型，返回[]int类型

:::

String批量操作

  1. package main
  4. import (
  5.     "fmt"
  6.     "github.com/garyburd/redigo/redis"
  7. )
  10. func main() {
  11.     c, err := redis.Dial("tcp", "localhost:6379")
  12.     if err != nil {
  13.         fmt.Println("conn redis failed,", err)
  14.         return
  15.     }
  18.     defer c.Close()
  19.     _, err = c.Do("MSet", "abc", 100, "efg", 300)
  20.     if err != nil {
  21.         fmt.Println(err)
  22.         return
  23.     }
  26.     r, err := redis.Ints(c.Do("MGet", "abc", "efg"))
  27.     if err != nil {
  28.         fmt.Println("get abc failed,", err)
  29.         return
  30.     }
  33.     for _, v := range r {
  34.         fmt.Println(v)
  35.     }
  36. }

设置过期时间

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/garyburd/redigo/redis"
  6. )
  8. func main() {
  9.     c, err := redis.Dial("tcp", "localhost:6379")
  10.     if err != nil {
  11.         fmt.Println("conn redis failed,", err)
  12.         return
  13.     }
  15.     defer c.Close()
  16.     _, err = c.Do("expire", "abc", 10)
  17.     if err != nil {
  18.         fmt.Println(err)
  19.         return
  20.     }
  21. }

List队列操作

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/garyburd/redigo/redis"
  6. )
  8. func main() {
  9.     c, err := redis.Dial("tcp", "localhost:6379")
  10.     if err != nil {
  11.         fmt.Println("conn redis failed,", err)
  12.         return
  13.     }
  15.     defer c.Close()
  16.     _, err = c.Do("lpush", "book_list", "abc", "ceg", 300)
  17.     if err != nil {
  18.         fmt.Println(err)
  19.         return
  20.     }
  22.     r, err := redis.String(c.Do("lpop", "book_list"))
  23.     if err != nil {
  24.         fmt.Println("get abc failed,", err)
  25.         return
  26.     }
  28.     fmt.Println(r)            // 300
  29. }

Hash表

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/garyburd/redigo/redis"
  6. )
  8. func main() {
  9.     c, err := redis.Dial("tcp", "localhost:6379")
  10.     if err != nil {
  11.         fmt.Println("conn redis failed,", err)
  12.         return
  13.     }
  15.     defer c.Close()
  16.     _, err = c.Do("HSet", "books", "abc", 100)
  17.     if err != nil {
  18.         fmt.Println(err)
  19.         return
  20.     }
  22.     r, err := redis.Int(c.Do("HGet", "books", "abc"))
  23.     if err != nil {
  24.         fmt.Println("get abc failed,", err)
  25.         return
  26.     }
  28.     fmt.Println(r)   // 100
  29. }

redis连接池

:::color2 MaxIdle：最大的空闲连接数，表示即使没有redis连接时依然可以保持N个空闲的连接，而不被清除，随时处于待命状态。

MaxActive：最大的连接数，表示同时最多有N个连接。0表示不限制。

IdleTimeout：最大的空闲连接等待时间，超过此时间后，空闲连接将被关闭。如果设置成0，空闲连接将不会被关闭。应该设置一个比redis服务端超时时间更短的时间。

DialConnectTimeout：连接Redis超时时间。

DialReadTimeout：从Redis读取数据超时时间。

DialWriteTimeout：向Redis写入数据超时时间。

连接流程大概是这样的:

1.尝试从空闲列表MaxIdle中，获得一个可用连接;如果成功直接返回，失败则尝试步骤2

2.如果当前的MaxIdle < 连接数 < MaxActive，则尝试创建一个新连接，失败则尝试步骤3

  1. 如果连接数 > MaxActive就等待,直到满足步骤2的条件，重复步骤2

:::

  1. package main
  2. import(
  3.     "fmt"
  4.     "github.com/garyburd/redigo/redis"
  5. )
  7. var pool *redis.Pool  //创建redis连接池
  9. func init(){
  10.     pool = &redis.Pool{     //实例化一个连接池
  11.         MaxIdle:16,    //最初的连接数量
  12.         // MaxActive:1000000,    //最大连接数量
  13.         MaxActive:0,    //连接池最大连接数量,不确定可以用0（0表示自动定义），按需分配
  14.         IdleTimeout:300,    //连接关闭时间 300秒 （300秒不使用自动关闭）    
  15.         Dial: func() (redis.Conn ,error){     //要连接的redis数据库
  16.             return redis.Dial("tcp","localhost:6379")
  17.         },
  18.     }
  19. }
  21. func main(){
  22.     c := pool.Get() //从连接池，取一个链接
  23.     defer c.Close() //函数运行结束 ，把连接放回连接池
  25.     _,err := c.Do("Set","abc",200)
  26.     if err != nil {
  27.             fmt.Println(err)
  28.             return
  29.         }
  31.     r,err := redis.Int(c.Do("Get","abc"))
  32.     if err != nil {
  33.             fmt.Println("get abc faild :",err)
  34.             return
  35.         }
  36.     fmt.Println(r)
  37.     pool.Close() //关闭连接池
  38. }