一 REDIS基本介绍

Redis时NoSQL数据库,不是传统的关系型数据库。

Redis 是一个开源(BSD许可)的,内存中的数据结构存储系统,它可以用作数据库、缓存和消息中间件。它支持多种类型的数据结构,如字符串(strings),散列(hashes),列表(lists),集合(sets),有序集合(sorted sets)与范围查询,bitmaps,hyperloglogs和 地理空间(geospatial)索引半径查询。

Redis 内置了复制(replication),LUA脚本(Lua scripting),LRU驱动事件(LRU eviction),事务(transactions)和不同级别的 磁盘持久化(persistence),并通过Redis哨兵(Sentinel)和自动分区(Cluster)提供高可用性(high availability)。

Redis 优点:

  1. 性能非常高,单机能够达到15w qps,通常适合做缓存,也可以持久化
  2. 是完全开源免费的,高性能的(key-val)分布式内存数据库,基于内存运行并持久化的NoSQL数据库,是最热门的NoSQL数据库之一,也成为数据结构服务器

Redis 操作原理图:

在这里插入图片描述

**Redis 操作指令:**http://redisdoc.com/

二 REDIS快速入门

说明: Redis 安装好后,默认有 16 个数据库,初始默认使用 0 号库, 编号是 0…15

基本操作:

set key valkeys *get keyselect indexdbsizeflushdbflushall

部分操作演示:

127.0.0.1:6379> set key1 hello
OK
127.0.0.1:6379> get key1
"hello"
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> get key1
(nil)
127.0.0.1:6379[1]> select 0
OK
127.0.0.1:6379> get key1
"hello"
127.0.0.1:6379> dbsize
(integer) 1
127.0.0.1:6379> set key2 Psych
OK
127.0.0.1:6379> dbsize
(integer) 2
127.0.0.1:6379>
三 REDIS的CRUD操作
StringHashListSetzset

3.1 String操作

string 是 redis 最基本的类型,一个 key 对应一个 value。string 类型是二进制安全的。除普通的字符串外,也可以存放图片等数据。

redis 中字符串 value 最大是 512M

基本演示:

127.0.0.1:6379> set address sichuan
OK
127.0.0.1:6379> get address
"sichuan"

3.1.1 CRUD操作

set key valueget keydel key

实例演示:

127.0.0.1:6379> set address sichuan
OK
127.0.0.1:6379> get address
"sichuan"
127.0.0.1:6379> del address
(integer) 1
127.0.0.1:6379> get address
(nil)

3.1.2 其他常用操作

setex key time valuemset key1 value1 key2 value2 ...mget key1 key2 ...

实例演示:

127.0.0.1:6379> setex name 5 Psych
OK
127.0.0.1:6379> get name                    // 5s后获取
(nil)
127.0.0.1:6379> mset name1 Psych name2 tom
OK
127.0.0.1:6379> get name2
"tom"
127.0.0.1:6379> mget name1 name2
1) "Psych"
2) "tom"

3.2 Hash操作

Redis hash 是一个键值对集合

Redis hash 是一个 string 类型的 field 和 value 的映射表,hash 特别适合用于存储对
象。

3.2.1 CRUD操作

hset key field valuekeyfieldvalueHSETfieldvaluehget key fieldnilhgetall keykeyhdel key fieldkey

实例演示:

127.0.0.1:6379> hset user1 name Psych
(integer) 1
127.0.0.1:6379> hset user1 age 18
(integer) 1
127.0.0.1:6379> hset user1 job playboy
(integer) 1
127.0.0.1:6379> hget user1 name
"Psych"
127.0.0.1:6379> hget user1 age
"18"
127.0.0.1:6379> hget user1 job
"playboy"
127.0.0.1:6379> hgetall user1
1) "name"
2) "Psych"
3) "age"
4) "18"
5) "job"
6) "playboy"
127.0.0.1:6379> hdel user1 job
(integer) 1
127.0.0.1:6379> hgetall user1
1) "name"
2) "Psych"
3) "age"
4) "18"

3.2.2 其他常用操作

hmset key field1 value1 field2 value2 ...field-valuekeykeyhmget key field1 field2 ...keynilkeykeynilhlen keykeyhexists key fieldfieldkey10

实例演示:

127.0.0.1:6379> hmset user2 name tom age 20 job teacher
OK
127.0.0.1:6379> hmget user2 name age job
1) "tom"
2) "20"
3) "teacher"
127.0.0.1:6379> hlen user2
(integer) 3
127.0.0.1:6379> hexists user2 name
(integer) 1
127.0.0.1:6379> hexists user2 male
(integer) 0

3.3 List操作

列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)。

List 本质是个链表, List 的元素 是有序的,元素的值可以重复.

3.3.1 CRUD操作

lpush key value1 value2 ...valuekeyvaluevaluemylistLPUSH mylist a b cc b aLPUSH mylist aLPUSH mylist bLPUSH mylist ckeykeyrpush key value1 value2 ...valuekeyvaluevaluemylistRPUSH mylist a b ca b cRPUSH mylist aRPUSH mylist bRPUSH mylist ckeykeylrange key start stopkeystartstopstartstop001-1-2lpop keykeykeynilrpop keykeykeynildel key

实例演示:

127.0.0.1:6379> lpush city sichuan beijing shanghai
(integer) 3
127.0.0.1:6379> lrange city 0 -1
1) "shanghai"
2) "beijing"
3) "sichuan"
127.0.0.1:6379> rpush city chongqing guangzhou
(integer) 5
127.0.0.1:6379> lrange city 0 -1
1) "shanghai"
2) "beijing"
3) "sichuan"
4) "chongqing"
5) "guangzhou"
127.0.0.1:6379> lpop city
"shanghai"
127.0.0.1:6379> lrange city 0 -1
1) "beijing"
2) "sichuan"
3) "chongqing"
4) "guangzhou"
127.0.0.1:6379> rpop city
"guangzhou"
127.0.0.1:6379> lrange city 0 -1
1) "beijing"
2) "sichuan"
3) "chongqing"
127.0.0.1:6379> del city
(integer) 1
127.0.0.1:6379> lrange city 0 -1
(empty list or set)

3.3.2 其他常用操作

llen keykeykeykey0key

实例演示:

127.0.0.1:6379> lpush name Psych tom jerry
(integer) 3
127.0.0.1:6379> llen name
(integer) 3

3.3.3 注意事项

  1. index索引是按照索引下标获得元素(从左至右,编号从0开始)
  2. List数据可以从左或从右插入添加
  3. 如果List的值全移除,对应的键也就消失了,则其变为空

3.4 Set操作

Redis 的 Set 是 string 类型无序集合。

底层是 HashTable 数据结构, Set 也是存放很多字符串元素,字符串元素是无序
的,而且元素的值不能重复

CRUD操作

sadd key member1 member2 ...memberkeymemberkeymemberkeymembersmembers keykeykeysismember key membermemberkeymember1memberkey0keymembermemberkeymember

实例演示:

127.0.0.1:6379> sadd emails Psych@163.com tom@qq.com jerry@sohu.com
(integer) 3
127.0.0.1:6379> smembers emails
1) "Psych@163.com"
2) "jerry@sohu.com"
3) "tom@qq.com"
127.0.0.1:6379> sismember emails Psych@163.com
(integer) 1
127.0.0.1:6379> sismember emails Psych@qq.com
(integer) 0
127.0.0.1:6379> srem emails tom@qq.com jerry@sohu.com
(integer) 2
127.0.0.1:6379> smembers emails
1) "Psych@163.com"
四 Golang简单操作REDIS

Redis client for Go官方go-redis使用文档:https://pkg.go.dev/github.com/go-redis/redis/v9@v9.0.0-beta.1#section-readme

4.1 go-Redis连接

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/go-redis/redis/v9"
)

func main() {
	// 连接到redis
	var ctx = context.Background()
	// 对服务器的传入请求应创建context,对服务器的传出调用应接受context。
	// Background()返回非零的空context,它不会被取消,没有值,也没有过期时间。
	// 它通常由主函数、初始化和测试使用,并作为传入请求的顶级context。

	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // url
		Password: "",
		DB:       0, // 0号数据库
	})
	s, err := client.Ping(ctx).Result()
	if err != nil {
		fmt.Println("ping err :", err)
		return
	}
	fmt.Println("连接成功...", s)
}    
ctx

4.2 String操作

set:

func (c Client) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd

get:

func (c Client) Get(ctx context.Context, key string) *StringCmd

实例演示:

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/go-redis/redis/v9"
)

func main() {
	// 连接到redis
	var ctx = context.Background()
	// 对服务器的传入请求应创建context,对服务器的传出调用应接受context。
	// Background返回非零的空context。它不会被取消,没有值,也没有过期时间。
	// 它通常由主函数、初始化和测试使用,并作为传入请求的顶级context。

	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // url
		Password: "",
		DB:       0, // 0号数据库
	})
	s, err := client.Ping(ctx).Result()
	if err != nil {
		fmt.Println("ping err :", err)
		return
	}
	fmt.Println("连接成功...", s)

	// // set操作:第三个参数是过期时间,如果是0表示不会过期。
	err = client.Set(ctx, "name", "Psych", 0).Err()
	if err != nil {
		panic(err)
	}

	// get操作
	val, err := client.Get(ctx, "name").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("name", val)

	// 这里设置过期时间.
	err = client.Set(ctx, "age", "20", 1*time.Second).Err()
	if err != nil {
		panic(err)
	}

	client.Incr(ctx, "age") // 自增
	client.Incr(ctx, "age") // 自增
	client.Decr(ctx, "age") // 自减

	val, err = client.Get(ctx, "age").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("age", val) // age 的值为21

	// 因为 key "age" 的过期时间是一秒钟, 因此当一秒后, 此 key 会自动被删除了.
	time.Sleep(1 * time.Second)
	val, err = client.Get(ctx, "age").Result()
	if err != nil {
		// 因为 key "age" 已经过期了, 因此会有一个 redis: nil 的错误.
		fmt.Printf("error: %v\n", err)
	}
	fmt.Println("age", val)

}

运行结果:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\test.go"
连接成功... PONG
name Psych
age 21
error: redis: nil
age 

[Done] exited with code=0 in 2.397 seconds

在redis-cli.exe中测试:

127.0.0.1:6379> get name
"Psych"

4.3 Hash操作

HSet:

func (c Client) HSet(ctx context.Context, key string, values ...interface{}) *IntCmd

HGet:

func (c Client) HGet(ctx context.Context, key, field string) *StringCmd

HMSet:

func (c Client) HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd

HMGet:

func (c Client) HMGet(ctx context.Context, key string, fields ...string) *SliceCmd

HLen:

func (c Client) HLen(ctx context.Context, key string) *IntCmd

HDel:

func (c Client) HDel(ctx context.Context, key string, fields ...string) *IntCmd

实例演示:

package main

import (
	"context"
	"fmt"

	"github.com/go-redis/redis/v9"
)

func main() {
	// 连接到redis
	var ctx = context.Background()
	// 对服务器的传入请求应创建context,对服务器的传出调用应接受context。
	// Background返回非零的空context。它不会被取消,没有值,也没有过期时间。
	// 它通常由主函数、初始化和测试使用,并作为传入请求的顶级context。

	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // url
		Password: "",
		DB:       0, // 0号数据库
	})
	s, err := client.Ping(ctx).Result()
	if err != nil {
		fmt.Println("ping err :", err)
		return
	}
	fmt.Println("连接成功...", s)

	// 向名称为 user_xys 的 hash 中添加元素 name
	client.HSet(ctx, "user1", "name", "Psych")

	// 向名称为 user_xys 的 hash 中添加元素 age
	client.HSet(ctx, "user1", "age", "18")

	// 批量地向名称为 user_test 的 hash 中添加元素 name 和 age
	client.HMSet(ctx, "user_test", map[string]string{"name": "test", "age": "20"})

	// 批量获取名为 user_test 的 hash 中的指定字段的值.
	fields, err := client.HMGet(ctx, "user_test", "name", "age").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("fields in user_test: ", fields)

	// 获取名为 user1 的 hash 中的字段个数
	length, err := client.HLen(ctx, "user1").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("field count in user1: ", length) // 字段个数为2

	// 删除名为 user_test 的 age 字段
	client.HDel(ctx, "user_test", "age")
	age, err := client.HGet(ctx, "user_test", "age").Result()
	if err != nil {
		fmt.Printf("Get user_test age error: %v\n", err)
	} else {
		fmt.Println("user_test age is: ", age) // 字段个数为2
	}

}

运行结果:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\hash\hash.go"
连接成功... PONG
fields in user_test:  [test 20]
field count in user1:  2
Get user_test age error: redis: nil

[Done] exited with code=0 in 1.416 seconds

在redis-cli.exe中测试:

127.0.0.1:6379> hget user1 name
"Psych"
127.0.0.1:6379> hgetall user1
1) "name"
2) "Psych"
3) "age"
4) "18"
127.0.0.1:6379> hgetall user_test
1) "name"
2) "test"

4.4 List操作

LPush:

func (c Client) LPush(ctx context.Context, key string, values ...interface{}) *IntCmd

RPush

func (c Client) RPush(ctx context.Context, key string, values ...interface{}) *IntCmd

LLen

func (c Client) LLen(ctx context.Context, key string) *IntCmd

LPop

func (c Client) LPop(ctx context.Context, key string) *StringCmd

RPop

func (c Client) RPop(ctx context.Context, key string) *StringCmd

实例演示:

package main

import (
	"context"
	"fmt"

	"github.com/go-redis/redis/v9"
)

func main() {
	// 连接到redis
	var ctx = context.Background()
	// 对服务器的传入请求应创建context,对服务器的传出调用应接受context。
	// Background返回非零的空context。它不会被取消,没有值,也没有过期时间。
	// 它通常由主函数、初始化和测试使用,并作为传入请求的顶级context。

	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // url
		Password: "",
		DB:       0, // 0号数据库
	})
	s, err := client.Ping(ctx).Result()
	if err != nil {
		fmt.Println("ping err :", err)
		return
	}
	fmt.Println("连接成功...", s)

	//在名称为 fruit 的list尾添加一个值为value的元素
	client.RPush(ctx, "fruit", "apple")

	//在名称为 fruit 的list头添加一个值为value的 元素
	client.LPush(ctx, "fruit", "banana")

	//返回名称为 fruit 的list的长度
	length, err := client.LLen(ctx, "fruit").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("length: ", length) // 长度为2

	// 返回并删除名称为 fruit 的list中的首元素
	value, err := client.LPop(ctx, "fruit").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("fruit: ", value)

	// 返回并删除名称为 fruit 的list中的尾元素
	value, err = client.RPop(ctx, "fruit").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("fruit: ", value)

}

运行结果:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\List\List.go"
连接成功... PONG
length:  2
fruit:  banana
fruit:  apple

[Done] exited with code=0 in 1.653 seconds

4.5 Set操作

SAdd:

func (c Client) SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd

SIsMember:

func (c Client) SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd

SInter:

func (c Client) SInter(ctx context.Context, keys ...string) *StringSliceCmd

SMembers:

func (c Client) SMembers(ctx context.Context, key string) *StringSliceCmd

实例演示:

package main

import (
	"context"
	"fmt"

	"github.com/go-redis/redis/v9"
)

func main() {
	// 连接到redis
	var ctx = context.Background()
	// 对服务器的传入请求应创建context,对服务器的传出调用应接受context。
	// Background返回非零的空context。它不会被取消,没有值,也没有过期时间。
	// 它通常由主函数、初始化和测试使用,并作为传入请求的顶级context。

	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // url
		Password: "",
		DB:       0, // 0号数据库
	})
	s, err := client.Ping(ctx).Result()
	if err != nil {
		fmt.Println("ping err :", err)
		return
	}
	fmt.Println("连接成功...", s)

	client.SAdd(ctx, "blacklist", "Obama")     // 向 blacklist 中添加元素
	client.SAdd(ctx, "blacklist", "Hillary")   // 再次添加
	client.SAdd(ctx, "blacklist", "the Elder") // 添加新元素

	client.SAdd(ctx, "whitelist", "the Elder") // 向 whitelist 添加元素

	// 判断元素是否在集合中
	isMember, err := client.SIsMember(ctx, "blacklist", "Bush").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("Is Bush in blacklist: ", isMember)

	// 求交集, 即既在黑名单中, 又在白名单中的元素
	names, err := client.SInter(ctx, "blacklist", "whitelist").Result()
	if err != nil {
		panic(err)
	}
	// 获取到的元素是 "the Elder"
	fmt.Println("Inter result: ", names)

	// 获取指定集合的所有元素
	all, err := client.SMembers(ctx, "blacklist").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("All member: ", all)

}

运行结果:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\Set\Set.go"
连接成功... PONG
Is Bush in blacklist:  false
Inter result:  [the Elder]
All member:  [the Elder Hillary Obama]

[Done] exited with code=0 in 1.495 seconds

在redis-cli.exe中测试:

127.0.0.1:6379> smembers blacklist
1) "the Elder"
2) "Hillary"
3) "Obama"
127.0.0.1:6379> smembers whitelist
1) "the Elder"
五 Redis连接池

通过 Golang 对 Redis 操作, 还可以通过 Redis 链接池

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

默认情况下, redis.v9 的 redis 连接池大小是10, 不过我们可以在初始化 redis 客户端时自行设置连接池的大小, 例如:

client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // url
		Password: "",
		DB:       0, // 0号数据库
		PoolSize: 5, //设置了 redis 连接池的大小为5.
	})

通过 redis.Options 的 PoolSize 属性, 我们设置了 redis 连接池的大小为5.

那么接下来我们来看一下这个设置有什么效果吧:

package main

import (
	"context"
	"fmt"
	"sync"

	"github.com/go-redis/redis/v9"
)

func main() {
	// 连接到redis
	var ctx = context.Background()
	// 对服务器的传入请求应创建context,对服务器的传出调用应接受context。
	// Background返回非零的空context。它不会被取消,没有值,也没有过期时间。
	// 它通常由主函数、初始化和测试使用,并作为传入请求的顶级context。

	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // url
		Password: "",
		DB:       0, // 0号数据库
		PoolSize: 5, //设置了 redis 连接池的大小为5.
	})
	s, err := client.Ping(ctx).Result()
	if err != nil {
		fmt.Println("ping err :", err)
		return
	}
	fmt.Println("连接成功...", s)

	wg := sync.WaitGroup{}
	wg.Add(10)

	for i := 0; i < 10; i++ {
		go func() {
			defer wg.Done()

			for j := 0; j < 100; j++ {
				client.Set(ctx, fmt.Sprintf("name%d", j), fmt.Sprintf("xys%d", j), 0).Err()
				client.Get(ctx, fmt.Sprintf("name%d", j)).Result()
			}

			fmt.Printf("PoolStats, TotalConns: %d, IdleConns: %d\n", client.PoolStats().TotalConns, client.PoolStats().IdleConns)
		}()
	}

	wg.Wait()

}

上面的例子启动了10个 routine 来不断向 redis 读写数据, 然后我们通过 client.PoolStats() 获取连接池的信息. 运行输出如下:

[Running] go run "c:\Users\Mechrevo\Desktop\go_pro\pool\pool.go"
连接成功... PONG
PoolStats, TotalConns: 5, IdleConns: 1
PoolStats, TotalConns: 5, IdleConns: 1
PoolStats, TotalConns: 5, IdleConns: 1
PoolStats, TotalConns: 5, IdleConns: 0
PoolStats, TotalConns: 5, IdleConns: 0
PoolStats, TotalConns: 5, IdleConns: 1
PoolStats, TotalConns: 5, IdleConns: 2
PoolStats, TotalConns: 5, IdleConns: 3
PoolStats, TotalConns: 5, IdleConns: 4
PoolStats, TotalConns: 5, IdleConns: 5

[Done] exited with code=0 in 1.315 seconds

通过输出可以看到, 此时最大的连接池数量确实是 5 了, 并且一开始时, 因为 coroutine 的数量大于5, 会造成 redis 连接不足的情况(反映在 IdleConns(池中的空闲连接数)上,就是前几次的输出 IdleConns一直是1), 当某个 coroutine 结束后, 会释放此 redis 连接, 因此 IdleConns会增加.