【go】golang redis | github.com/redis/go-redis/v9 正确打开golang的redis | go-zero redis 与simple-admin redis

让我们一起支持群主维护simple-admin 社群吧！！！
不能加入星球的朋友记得来点个Star！！
https://github.com/suyuan32/simple-admin-core

一、redis框架推荐

1、go-zero redis

go-zero 本身整合了个redis框架
优势：在svc中注册后，全局直接调用，且整合了redis分布式锁

https://github.com/zeromicro/go-zero/core/stores/redis

2、redis官方版本

推荐使用 v9版本
优势：使用更加灵活，可以控制返回值

https://github.com/redis/go-redis

二、2个框架与redis

官方文档：

https://redis.uptrace.dev/guide/go-redis.html#connecting-to-redis-server

1、go-zero整合v9 且兼容go-zero redis

这里面简单介绍一下2个框架如何整合redis的

1.1 config

这里simple-admin 框架整合了redis官方v9版本
且github地址：https://github.com/suyuan32/simple-admin-common

go-zero的使用的是自己整合的redis
github.com/zeromicro/go-zero/core/stores/cache

package config

import (
	"github.com/suyuan32/simple-admin-common/config"
	"github.com/zeromicro/go-zero/rest"
	"github.com/zeromicro/go-zero/core/stores/cache"
)

type Config struct {
	rest.RestConf
	// simple-admin
	RedisConf config.RedisConf
	// go-zero
	Cache     cache.CacheConf
}

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

1.2 svc

svc/service_context.go （根据生成习惯也能是：servicecontext.go）

package svc

import (
	"github.com/zeromicro/go-zero/core/stores/redis"
	"redis1 "github.com/redis/go-redis/v9"
)

type ServiceContext struct {
	Redis           redis1.UniversalClient
	Config 					config.Config
	RedisCache               *redis.Redis
}

func NewServiceContext(c config.Config) *ServiceContext {
	// 初始化 cache，其中 WithLimit 可以指定最大缓存的数量
	cCache, err := collection.NewCache(time.Minute, collection.WithLimit(10000))
	if err != nil {
		panic(err)
	}
	rds := c.RedisConf.MustNewUniversalRedis()
	redisCache := c.Cache[0].NewRedis()
	return &ServiceContext{
		Config:                   c,
		CCache:                   cCache,
		RedisCache:               redisCache,
		Redis:  rds
	}
}

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

• 上面的 redisCache 是整合go-zero的redis
• 上面的 redis 是整合官方v9版本的redis

2、redis-v9 一些用法

1.1 、TTL

总结：

• TTL 键不存在： time.Duration(-2)：
• TTL 键不存在 、 键没有设置过期时间：time.Duration(-1)

package main

import (
	"context"
	"fmt"
	"github.com/redis/go-redis/v9"
	"time"
)

func main() {
	// 连接到 Redis 服务器
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // Redis 服务器地址
		Password: "",                // 密码
		DB:       0,                 // 使用默认数据库
	})

	// 使用完毕后关闭连接
	defer client.Close()

	// 设置上下文和键名
	ctx := context.Background()
	key := "example_key"
	client.Set(ctx, key, "123", time.Second*1)

	// 获取键的 TTL
	ttl, _ := client.TTL(ctx, key).Result()

	fmt.Println(ttl)
	// 处理返回值
	if ttl == time.Duration(-2) {
		fmt.Println("键不存在")
	} else if ttl == time.Duration(-1) {
		fmt.Println("键没有设置过期时间")
	} else {
		fmt.Printf("键的 TTL 为: %v\n", ttl)
	}
}

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

1.2 、 Exists

总结：

• 键存在： 1
• 键不存在：0

下面代码实现了一个场景：设置键的过期时间为当天的 24 点整

package main

import (
	"context"
	"fmt"
	"time"
	"github.com/redis/go-redis/v9"
)

func main() {
	// 连接到 Redis 服务器
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // Redis 服务器地址
		Password: "",                // 密码
		DB:       0,                 // 使用默认数据库
	})

	// 使用完毕后关闭连接
	defer client.Close()

	// 设置上下文和键名
	ctx := context.Background()
	key := "example_key"

	// 检查键是否存在
	exists := client.Exists(ctx, key).Val()
	if exists == 1 {
		fmt.Println("键存在")
	} else {
		fmt.Println("键不存在")
	}

	// 设置键的过期时间为当天的 24 点整
	now := time.Now()
	expireTime := time.Date(now.Year(), now.Month(), now.Day(), 23, 59, 59, 0, now.Location())
	duration := expireTime.Sub(now)
	err := client.Expire(ctx, key, duration).Err()
	if err != nil {
		fmt.Printf("设置过期时间失败: %v\n", err)
	} else {
		fmt.Println("设置过期时间成功")
	}
}

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

1.3、Expire

如果键不存在，则 Expire 方法不会产生任何效果
因为无法设置不存在的键的过期时间。在这种情况下，你可以选择先确保键存在，然后再设置过期时间，或者直接忽略不存在的键。

package main

import (
	"context"
	"fmt"
	"time"

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

func main() {
	// 创建 Redis 客户端连接
	client := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // Redis 服务器地址
		Password: "",                // 密码
		DB:       0,                 // 使用默认数据库
	})

	// 使用完毕后关闭连接
	defer client.Close()

	// 设置键值对
	err := client.Set(context.Background(), "mykey", "myvalue", 0).Err()
	if err != nil {
		panic(err)
	}

	// 设置过期时间为10秒
	expireDuration := 10 * time.Second

	// 设置过期时间
	err = client.Expire(context.Background(), "mykey", expireDuration).Err()
	if err != nil {
		panic(err)
	}

	fmt.Println("成功设置键的过期时间为 10 秒")
}

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

1.4、EXPIRE 和 TTL 区别

EXPIRE 和 TTL 是 Redis 中两个不同的命令，它们用于处理键的过期时间，但在用法和行为上有一些区别。

EXPIRE:

EXPIRE 命令用于将键的过期时间设置为指定的秒数。它接受两个参数：键和秒数。键在指定的秒数后会过期。如果键已经设置了过期时间，那么这个过期时间会被覆盖。
示例使用：EXPIRE key seconds

TTL:

TTL 命令用于获取键的剩余过期时间（Time To Live）。它返回键的剩余生存时间，以秒为单位。如果键没有设置过期时间，或者键不存在，TTL 命令会返回 -1；如果键存在但没有剩余过期时间，TTL 命令会返回 -2。
示例使用：TTL key

区别总结：

• EXPIRE 用于设置键的过期时间，而 TTL 用于获取键的剩余过期时间。
• EXPIRE 需要提供键和过期时间，而 TTL 只需要提供键。
• EXPIRE 设置的过期时间是绝对的，而 TTL 返回的是相对于当前时间的剩余时间。

在实际使用中，如果你需要设置键的过期时间，你会使用 EXPIRE 命令；如果你需要获取键的剩余过期时间，你会使用 TTL 命令。

3、未完待续。。。