go-Redis

go-Redis

基本介绍

1. Redis是NoSQL数据库，不是传统的关系数据库
2. Redis：REmote DIctionary Server 远程字典服务器，Redis性能非常高，单机能够达到15w qps，通常适合做缓存，也可以做持久化
3. 完全开源免费的，高性能的（key/value）分布式内存数据库，基于内存运行并支持持久化的NoSQL数据库，是最热门NoSQL数据库之一，也称为数据结构服务器

终端使用

1. Redis的五大数据类型：String、Hash、List、Set、zset（有序的Set）

字符串String

1. string是redis最基本的类型，一个key对应 一个value
2. string类型是二进制安全的。除普通的字符串外，也可以存放图片等数据
3. redis中字符串value最大是512M

4. CRUD：

   1. set 若存在就修改，不存在就添加

      setex address1 10 beijing 设置销毁时间

      mset同时设置一个或多个key-value对

      msetnx同时设置多对不存在的key-value对，若有存在的都不会添加成功

   2. get 获取

      mget获取一个或多个key-value对

   3. del 删除

   4. incr decr key对应的value数组-1 +1

   5. getset 设置当前的key的value，同时返回原来的value

Hash哈希表

1. Redis hash是一个键值对集合。var user1 map[string]string

2. Redis hash是一个string类型的field和value的映射表，hash适用于存储对象

   User1 name smith age 30

3. CRUD

   1. hset key1 field1 value1修改或添加

      hmset key1 field1 value1 field2 value2 ...设置多个key

      hsetnx为哈希表中不存在的字段赋值。如果字段已经存在于哈希表中，操作无效。如果 key 不存在，一个新哈希表被创建

   2. hget key1 field1获取

      hgetall key获取所有

      hmget key1 field1 field2... 获取多个key

   3. hdel key删除

   4. hlen key获取key对应的字段个数

   5. hexists key field 判断是否存在字段

   6. hkeys key 返回此key的所有字段名

   7. hvals key返回此key的所有values

List列表

1. 该类型是一个插入顺序排序的字符串元素集合, 基于双链表实现。可以在头部插入也可在尾部插入
2. List本质是一个链表，List的元素是有序的，元素的值可以重复
3. CRUD
   1. LPUSH key element [element ...]redis LPUSH用于将一个或多个值插入到列表key 的头部。返回执行push操作后列表的长度。
   2. RPUSH key element [element ...]向存存储在 key 中的列表的尾部插入所有指定的值。返回执行 push 操作后的列表长度
   3. LPOP key用于删除并返回存储在 key中的列表的第一个元素。key不存在的时候返回 nil。
   4. RPOP key用于移除并返回列表 key 的最后一个元素。
   5. LSET key index element用于设置列表 key 中 index 位置的元素值element。
   6. LLEN key用于返回存储在 key 中的列表长度。
   7. LINDEX key index返回列表 key 里索引 index 位置存储的元素
   8. LRANGE KEY_NAME START END用于返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。

Set集合

1. Set类型是一种无顺序集合, 它和List类型最大的区别是：集合中的元素没有顺序, 且元素是唯一的。
2. Set类型主要应用于：在某些场景，如社交场景中，通过交集、并集和差集运算，通过Set类型可以非常方便地查找共同好友、共同关注和共同偏好等社交关系。
3. CRUD
   1. SADD key member [member ...]将一个或多个成员元素加入到集合中，已经存在于集合的成员元素将被忽略。返回新成功添加到集合里元素的数量，不包括已经存在于集合中的元素。
   2. SPOP key [count]用于从集合 key中删除并返回一个或多个随机元素。
   3. SMEMBERS key返回存储在 key 中的集合的所有的成员。 不存在的集合被视为空集合。
   4. SCARD key返回集合中元素的数量。
   5. SREM key member [member ...]用于在集合中删除指定的元素。如果指定的元素不是集合成员则被忽略。
   6. SINTER key [key ...]返回所有给定集合的成员交集。
   7. SDIFF key [key ...]返回第一个集合与其他集合之间的差异，也可以认为说第一个集合中独有的元素。
   8. SDIFFSTORE destination key [key ...]``SDIFFSTORE 命令的作用和SDIFF类似，不同的是它将结果保存到 destination 集合，而把结果集返回给客户端。
   9. SUNION key [key ...]用于返回所有给定集合的并集。

ZSet顺序集合

1. ZSet是一种有序集合类型，每个元素都会关联一个double类型的分数权值，通过这个权值来为集合中的成员进行从小到大的排序。与Set类型一样，其底层也是通过哈希表实现的。
2. CRUD:
3. ZADD key [NX|XX] [GT|LT] [CH] [INCR] score member [score member ...]用于将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
4. ZPOPMAX key [count]删除并返回最多count个有序集合key中的最高得分的成员。如未指定，count的默认值为1。
5. ZPOPMIN key [count]删除并返回最多count个有序集合key中最低得分的成员。如未指定，count的默认值为1。
6. ZREM key member [member ...]用于从有序集合key中删除指定的成员member。
7. ZCARD key用于返回有序集的成员个数。
8. ZCOUNT key min max返回有序集 key 中， score 值在 min 和 max 之间(默认包括 score 值等于 min 或 max )的成员的数量。
9. ZSCORE key member用于返回有序集 key.中成员 member 的分数。
10. ZREVRANGE key start stop [WITHSCORES]返回有序集key中，指定区间内的成员。其中成员的位置按score值递减(从高到低)来排列。

Golang操作Redis

1. 下载使用第三方开源的redis库

string

import (
	"fmt"

	"github.com/garyburd/redigo/redis"
)

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Printf("dial err: %v\n", err)
		return
	}
	defer conn.Close()

	reply, err2 := conn.Do("set", "name", "tom")
	if err2 != nil {
		fmt.Printf("set cmd err2: %v\n", err2)
	}
	fmt.Printf("reply: %v\n", reply) // reply: OK
	fmt.Printf("reply: %T\n", reply) // reply: string

	replyGet, err3 := conn.Do("get", "name")
	if err3 != nil {
		fmt.Printf("get cmd err: %v\n", err3)
	}
	fmt.Printf("replyGet: %T\n", replyGet)                   // replyGet: []uint8
	fmt.Printf("replyGet: %v\n", string(replyGet.([]uint8))) // replyGet: tom

	conn.Do("mset", "name1", "jack", "name2", "smith")

	reply2, _ := redis.Strings(conn.Do("mget", "name", "name1", "name2"))
	fmt.Printf("reply2: %v\n", reply2) // reply2: [tom jack smith]
	fmt.Printf("reply2: %T\n", reply2) // reply2: []string
}

Hash

import (
	"fmt"
	"strconv"

	"github.com/garyburd/redigo/redis"
)

type User struct {
	Name    string
	Age     int
	Address string
}

func main() {
	conn, err := redis.Dial("tcp", "localhost:6379")
	if err != nil {
		fmt.Printf("Dial err: %v\n", err)
	}
	defer conn.Close()

	conn.Do("hset", "user4", "name", "marry", "age", 40, "address", "ustl")

	reply, _ := redis.StringMap(conn.Do("hgetall", "user4"))

	fmt.Printf("reply: %v\n", reply) // reply: map[address:ustl age:40 name:marry]

	var user User = User{}
	for key, val := range reply {
		switch key {
		case "name":
			user.Name = val
		case "age":
			user.Age, _ = strconv.Atoi(val)
		case "address":
			user.Address = val
		}
	}
	fmt.Printf("user: %v\n", user) // user: {marry 40 ustl}
}

其他操作都类似

链接池

1. 事先初始化一定数量的链接，放入到链接池
2. 当go需要操作redis时，直接从redis链接池取出链接即可
3. 这样可以节省临时获取redis链接的时间，从而提高效率

import (
	"fmt"

	"github.com/garyburd/redigo/redis"
)

var pool *redis.Pool

func init() {
	pool = &redis.Pool{
		MaxIdle:     8,
		MaxActive:   0,
		IdleTimeout: 100,
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "localhost:6379")
		},
	}
}

func main() {
	// 1. 从链接池中取出链接
	conn := pool.Get()
	// 2. 关闭资源
	defer conn.Close()

	// 3. 操作redis
	reply, err := redis.StringMap(conn.Do("hgetall", "user1"))
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}
	fmt.Printf("reply: %s\n", reply) // reply: map[address:dlmu age:30 name:tom]

}