GoLang之使用garyburd/redigo/redis依赖操作Redis

使用garyburd/redigo/redis依赖操作Redis

注：本文使用github.com/garyburd/redigo/redis v1.6.3进行讲解

1.Redis介绍

*Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库
*Redis 与其他 key - value 缓存产品有以下三个特点：
(1)Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用
(2)Redis不仅仅支持简单的key-value类型的数据，同时还提供string、list（链表）、set（集合）、hash表等数据结构的存储
(3)Redis支持数据的备份，即master-slave模式的数据备份

2.Redis优势

*性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s ，单机能够达到15w qps，通常适合做缓存
*丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作
原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来
丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性
*Redis与其他key-value存储有什么不同:
(1)Redis有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象
(2)Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问

3.Redis依赖安装

go get github.com/garyburd/redigo/redis

4.Redis.Conn接口

type Conn interface {
	// Close closes the connection.
	Close() error

	// Err returns a non-nil value when the connection is not usable.
	Err() error

	// Do sends a command to the server and returns the received reply.
	Do(commandName string, args ...interface{}) (reply interface{}, err error)

	// Send writes the command to the client's output buffer.
	Send(commandName string, args ...interface{}) error

	// Flush flushes the output buffer to the Redis server.
	Flush() error

	// Receive receives a single reply from the Redis server
	Receive() (reply interface{}, err error)
}

5.Redis.Int(s)函数

func Ints(reply interface{}, err error) ([]int, error) {}

6.Redis.Ints函数

func Ints(reply interface{}, err error) ([]int, error) {}

7.Redis.String函数

func String(reply interface{}, err error) (string, error) {}

8.Redis.Dial函数

func Dial(network, address string, options ...DialOption) (Conn, error) {}

9.Redis.Pool结构体

type Pool struct {
	Dial func() (Conn, error)
	TestOnBorrow func(c Conn, t time.Time) error
	MaxIdle int
	MaxActive int
	IdleTimeout time.Duration
	Wait bool
	MaxConnLifetime time.Duration
	chInitialized uint32 
	mu     sync.Mutex    
	closed bool         
	active int           
	ch     chan struct{} 
	idle   idleList      
}

10.连接Redis

//首先先打开redis客户端，然后运行代码
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
	}

	fmt.Println("redis conn success") //输出：redis conn success

	defer c.Close()
}

11.String类型Set、Get单操作

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
	}

	defer c.Close()
	_, err = c.Do("Set", "abc", 100)
	if err != nil {
		fmt.Println(err)
		return
	}
	//func Int(reply interface{}, err error) (int, error) {}
	r, err := redis.Int(c.Do("Get", "abc"))
	if err != nil {
		fmt.Println("get abc failed,", err)
		return
	}

	fmt.Println(r) //输出: 100
}

12.String类型Set、Get批量操作

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
   }

   defer c.Close()
   _, err = c.Do("MSet", "abc", 100, "efg", 300)
   if err != nil {
      fmt.Println(err)
      return
   }
   //func Ints(reply interface{}, err error) ([]int, error) {
   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)  /*输出：100
                             200
   
   */
   }
}

13.List队列lpush、lpop批量操作

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
	}

	defer c.Close()
	_, err = c.Do("lpush", "book_list", "abc", "ceg", 300)
	if err != nil {
		fmt.Println(err)
		return
	}
	r, err := redis.String(c.Do("lpop", "book_list"))
	if err != nil {
		fmt.Println("get abc failed,", err)
		return
	}

	fmt.Println(r) //输出：300
}

14.expire命令设置过期时间

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
    }

    defer c.Close()
    _, err = c.Do("expire", "abc", 10)//10秒后过期
    if err != nil {
        fmt.Println(err)
        return
    }
}

15.Hash表Hset、Hget单操作

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
	}

	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)//输出：100
}

16.Redis连接池

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数据库
            return redis.Dial("tcp","localhost:6379")
        },
    }
}

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

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

        r,err := redis.Int(c.Do("Get","abc"))
        if err != nil {
            fmt.Println("get abc faild :",err)
            return
        }
        fmt.Println(r)//输出：200
        pool.Close() //关闭连接池
}