1. 安装 | 干干的笔记

# 1. 安装

 go get github.com/garyburd/redigo/redis

# 2. 连接

package main

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

func main() {
    c, err := redis.Dial("tcp", "localhost:6379")
    if err != nil {
        fmt.Println("conn redis failed,", err)
        return
    }
    if _, err := c.Do("AUTH", "123456"); err != nil {
        fmt.Println("conn redis failed,", err)
        return
    }
    if _, err := c.Do("SELECT", 2); err != nil {
        fmt.Println("conn redis failed,", err)
        return
    }
    fmt.Println("redis conn success")
    defer c.Close()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 3. 连接池

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

var pool *redis.Pool  //创建redis连接池

func init(){
    pool = &redis.Pool{     //实例化一个连接池
        MaxIdle:16,    //最初的连接数量
        // MaxActive:1000000,    //最大连接数量
        MaxActive:0,    //连接池最大连接数量,不确定可以用0（0表示自动定义），按需分配
        IdleTimeout:300,    //连接关闭时间 300秒 （300秒不使用自动关闭）    
        Dial: func() (redis.Conn ,error){     //要连接的redis数据库
            c, err := redis.Dial("tcp", "127.0.0.1:6379")
            if err != nil {
              return nil, err
            }
            if _, err := c.Do("AUTH", "123456"); err != nil {
              c.Close()
              return nil, err
            }
            if _, err := c.Do("SELECT", 2); err != nil {
              c.Close()
              return nil, err
            }
            return c, nil
        },
    }
}

func main(){
    c := pool.Get() //从连接池，取一个链接
    defer c.Close() //函数运行结束 ，把连接放回连接池

    _,err := c.Do("Set","abc",200)
    if err != nil {
      fmt.Println(err)
      return
    }
    pool.Close() //关闭连接池
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

# 4. String

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

var pool *redis.Pool  //创建redis连接池

func init(){
    pool = &redis.Pool{     //实例化一个连接池
        MaxIdle:16,    //最初的连接数量
        // MaxActive:1000000,    //最大连接数量
        MaxActive:0,    //连接池最大连接数量,不确定可以用0（0表示自动定义），按需分配
        IdleTimeout:300,    //连接关闭时间 300秒 （300秒不使用自动关闭）    
        Dial: func() (redis.Conn ,error){     //要连接的redis数据库
            c, err := redis.Dial("tcp", "127.0.0.1:6379")
            if err != nil {
              return nil, err
            }
            if _, err := c.Do("AUTH", "123456"); err != nil {
              c.Close()
              return nil, err
            }
            if _, err := c.Do("SELECT", 2); err != nil {
              c.Close()
              return nil, err
            }
            return c, nil
        },
    }
}

func main(){
    c := pool.Get() //从连接池，取一个链接
    defer c.Close() //函数运行结束 ，把连接放回连接池

    _, err := c.Do("MSet", "abc", 100, "efg", 200)
    if err != nil {
      fmt.Println(err)
      return
    }

    r, err := redis.Ints(c.Do("MGet", "abc", "efg"))
    if err != nil {
      fmt.Println("get abc failed,", err)
      return
    }

    for _, v := range r {
      fmt.Println(v)
    }

    //设置过期时间
    _, err := c.Do("expire", "abc", 10)
    if err != nil {
      fmt.Println(err)
      return
    }
    pool.Close() //关闭连接池
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

# 5. List

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

var pool *redis.Pool  //创建redis连接池

func init(){
    pool = &redis.Pool{     //实例化一个连接池
        MaxIdle:16,    //最初的连接数量
        // MaxActive:1000000,    //最大连接数量
        MaxActive:0,    //连接池最大连接数量,不确定可以用0（0表示自动定义），按需分配
        IdleTimeout:300,    //连接关闭时间 300秒 （300秒不使用自动关闭）    
        Dial: func() (redis.Conn ,error){     //要连接的redis数据库
            c, err := redis.Dial("tcp", "127.0.0.1:6379")
            if err != nil {
              return nil, err
            }
            if _, err := c.Do("AUTH", "123456"); err != nil {
              c.Close()
              return nil, err
            }
            if _, err := c.Do("SELECT", 2); err != nil {
              c.Close()
              return nil, err
            }
            return c, nil
        },
    }
}

func main(){
    go func() {
      c := pool.Get()
      for {
        t := time.Now().UnixNano()
        _, err := c.Do("lpush", "book_list", t)
        if err != nil {
          fmt.Println(err)
          return
        }
        time.Sleep(time.Millisecond * 500)
      }
      defer c.Close()
    }()

    go func() {
      c := pool.Get()
      for {
        r, err := redis.String(c.Do("rpop", "book_list"))
        if err != nil {
          fmt.Println(err)
          continue
        }
        fmt.Println("----->", r)
        time.Sleep(time.Second)
      }
      defer c.Close()
    }()

    time.Sleep(time.Second * 10)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# 6. Hash

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

var pool *redis.Pool  //创建redis连接池

func init(){
    pool = &redis.Pool{     //实例化一个连接池
        MaxIdle:16,    //最初的连接数量
        // MaxActive:1000000,    //最大连接数量
        MaxActive:0,    //连接池最大连接数量,不确定可以用0（0表示自动定义），按需分配
        IdleTimeout:300,    //连接关闭时间 300秒 （300秒不使用自动关闭）    
        Dial: func() (redis.Conn ,error){     //要连接的redis数据库
            c, err := redis.Dial("tcp", "127.0.0.1:6379")
            if err != nil {
              return nil, err
            }
            if _, err := c.Do("AUTH", "123456"); err != nil {
              c.Close()
              return nil, err
            }
            if _, err := c.Do("SELECT", 2); err != nil {
              c.Close()
              return nil, err
            }
            return c, nil
        },
    }
}

func main(){
	  c := pool.Get()
	  defer c.Close()
 		_, err = c.Do("HSet", "books", "abc", 100)
    if err != nil {
      fmt.Println(err)
      return
    }

    r, err := redis.Int(c.Do("HGet", "books", "abc"))
    if err != nil {
      fmt.Println("get abc failed,", err)
      return
    }
    fmt.Println(r)   
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

← Gin快速入门 Redis Zset多维度排行榜 →