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 优点：
- 性能非常高，单机能够达到15w qps，通常适合做缓存，也可以持久化
- 是完全开源免费的，高性能的(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>
StringHashListSetzset3.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 注意事项
- index索引是按照索引下标获得元素（从左至右，编号从0开始）
- List数据可以从左或从右插入添加
- 如果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"
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)
}
ctx4.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"
通过 Golang 对 Redis 操作， 还可以通过 Redis 链接池
- 事先初始化一定数量的链接，放入到链接池
- 当 Go 需要操作 Redis 时，直接从 Redis 链接池取出链接即可
- 这样可以节省临时获取 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会增加.