• Go语言学习笔记—golang操作Redis

    文章目录

    一 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

    基本操作：

    1. set key val ：添加 key-val
    2. keys * ：查看当前 redis 的 所有 key
    3. get key ”获取 key 对应的值
    4. select index ：切换 redis 数据库
    5. dbsize ：查看当前数据库的 key-val 数量
    6. flushdb ：清空当前数据库的 key-val
    7. flushall ：清空所有数据库的 key-val

    部分操作演示：

    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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    三 REDIS的CRUD操作

    Redis 支持的五大数据类型是: String(字符串) 、Hash (哈希)、List(列表)、Set(集合)和 zset(sorted set有序集合)

    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"

    • 1
    • 2
    • 3
    • 4

    3.1.1 CRUD操作

    • set key value：添加String数据，如果存在就相当于修改，不存在则是添加
    • get key：获取key对应的value数据
    • del key：删除key对应的value数据

    实例演示：

    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)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.1.2 其他常用操作

    • setex key time value：(set with expire)键秒值，设置限时的 key-value
    • mset key1 value1 key2 value2 ... ：同时设置一个或多个 key-value
    • mget key1 key2 ... ：同时获取多个 key-value

    实例演示：

    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"

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    3.2 Hash操作

    Redis hash 是一个键值对集合。

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

    3.2.1 CRUD操作

    • hset key field value ：将哈希表 key 中域 field 的值设置为 value 。如果给定的哈希表并不存在， 那么一个新的哈希表将被创建并执行 HSET 操作。如果域 field 已经存在于哈希表中， 那么它的旧值将被新值 value 覆盖。
    • hget key field ：返回给定域的值。如果给定域不存在于哈希表中， 又或者给定的哈希表并不存在， 那么命令返回 nil 。
    • hgetall key ：返回哈希表 key 中，所有的域和值。
    • hdel key field ：删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。

    实例演示：

    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"

    • 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

    3.2.2 其他常用操作

    • hmset key field1 value1 field2 value2 ... ：同时将多个 field-value (域-值)对设置到哈希表 key 中。此命令会覆盖哈希表中已存在的域。如果 key 不存在，一个空哈希表被创建并执行 HMSET操作。
    • hmget key field1 field2 ... ：返回哈希表 key 中，一个或多个给定域的值。如果给定的域不存在于哈希表，那么返回一个 nil 值。因为不存在的 key 被当作一个空哈希表来处理，所以对一个不存在的 key 进行 HMGET 操作将返回一个只带有 nil 值的表。
    • hlen key ：返回哈希表 key 中域的数量。
    • hexists key field ：检查给定域 field 是否存在于哈希表 key 当中。给定域存在时返回 1 ， 在给定域不存在时返回 0 。

    实例演示：

    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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    3.3 List操作

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

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

    3.3.1 CRUD操作

    • lpush key value1 value2 ... ：将一个或多个值 value 插入到列表 key 的表头。如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头： 比如说，对空列表 mylist 执行命令 LPUSH mylist a b c ，列表的值将是 c b a ，这等同于原子性地执行 LPUSH mylist a 、 LPUSH mylist b 和 LPUSH mylist c 三个命令。如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。
    • rpush key value1 value2 ... ：将一个或多个值 value 插入到列表 key 的表尾(最右边)。如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表尾：比如对一个空列表 mylist 执行 RPUSH mylist a b c ，得出的结果列表为 a b c ，等同于执行命令 RPUSH mylist a 、 RPUSH mylist b 、 RPUSH mylist c 。如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。当 key 存在但不是列表类型时，返回一个错误。
    • lrange key start stop ：返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
    • lpop key ：移除并返回列表 key 的头元素。当 key 不存在时，返回 nil 。
    • rpop key ：移除并返回列表 key 的尾元素。当 key 不存在时，返回 nil 。
    • del key ：移除对应List内数据，使其为空。

    实例演示：

    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)

    • 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

    3.3.2 其他常用操作

    • llen key ：返回列表 key 的长度。如果 key 不存在，则 key 被解释为一个空列表，返回 0 .如果 key 不是列表类型，返回一个错误。

    实例演示：

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

    • 1
    • 2
    • 3
    • 4

    3.3.3 注意事项

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

    3.4 Set操作

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

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

    CRUD操作：

    • sadd key member1 member2 ... ：将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。假如 key 不存在，则创建一个只包含 member 元素作成员的集合。当 key 不是集合类型时，返回一个错误。（在Redis2.4版本以前， SADD 只接受单个 member 值。）
    • smembers key :返回集合 key 中的所有成员（无序的）。不存在的 key 被视为空集合。
    • sismember key member : 判断 member 元素是否集合 key 的成员。如果 member 元素是集合的成员，返回 1 。 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。
    • srem key member1 member2 … ：移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。当 key 不是集合类型，返回一个错误。（在 Redis 2.4 版本以前， SREM 只接受单个 member 值。）

    实例演示：

    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"

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    四 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)
}    

    • 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

    其中声明的的第一个值为ctx，Context包定义了context类型，它跨API边界和进程之间传递截止日期、取消信号和其他请求范围的值。

    对服务器的传入请求应创建context，对服务器的传出调用应接受context。它们之间的函数调用链必须传入context。

    使用context的程序应遵循以下规则，以保持跨包的接口一致，并启用静态分析工具来检查context传播：

    1. 不要在结构类型内存储context；
    2. 相反，需将context显式传递给每个需要它的函数；
    3. context应该是第一个参数（如下文中操作方法Set或Get等中传入的ctx）。

    4.2 String操作

    set：

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

    • 1

    get：

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

    • 1

    实例演示：

    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)

}

    • 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
    • 65
    • 66
    • 67
    • 68

    运行结果：

    [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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在redis-cli.exe中测试：

    127.0.0.1:6379> get name
"Psych"

    • 1
    • 2

    4.3 Hash操作

    HSet：

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

    • 1

    HGet：

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

    • 1

    HMSet：

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

    • 1

    HMGet：

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

    • 1

    HLen：

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

    • 1

    HDel：

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

    • 1

    实例演示：

    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
	}

}

    • 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

    运行结果：

    [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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在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"

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    4.4 List操作

    LPush：

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

    • 1

    RPush

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

    • 1

    LLen

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

    • 1

    LPop

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

    • 1

    RPop

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

    • 1

    实例演示：

    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)

}

    • 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

    运行结果：

    [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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4.5 Set操作

    SAdd：

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

    • 1

    SIsMember：

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

    • 1

    SInter：

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

    • 1

    SMembers：

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

    • 1

    实例演示：

    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)

}

    • 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

    运行结果：

    [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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在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"

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    五 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.
	})

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    通过 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()

}

    • 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

    上面的例子启动了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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

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

  • 相关阅读:
    Windows命令行窗口修改字体方法
    二维码智慧门牌管理系统：让城市管理更高效、更便捷
    数据库高级 V
    setup中使用watch
    【ASP.NET Core】自定义Session的存储方式
    使用VuePress快速搭建博客
    Lintcode 1115 · Average of Levels in Binary Tree (BFS/DFS 经典题)
    量化分析革新金融服务软件的三种方式
    大语言模型LLM分布式训练：TensorFlow下的大语言模型训练实践（LLM系列05）
    java游戏制作-拼图游戏
  • 原文地址：https://blog.csdn.net/qq_39280718/article/details/126025603