GO学习之 数据库(Redis)

GO系列

1、GO学习之Hello World

2、GO学习之入门语法

3、GO学习之切片操作

4、GO学习之 Map 操作

5、GO学习之 结构体 操作

6、GO学习之 通道(Channel)

7、GO学习之 多线程(goroutine)

8、GO学习之 函数(Function)

9、GO学习之 接口(Interface)

10、GO学习之 网络通信(Net/Http)

11、GO学习之 微框架(Gin)

12、GO学习之 数据库(mysql)

13、GO学习之 数据库(Redis)

文章目录

• GO系列
• 前言
• [一、Redis 简介](#一、Redis 简介)
• [二、Redis 基本操作](#二、Redis 基本操作)
• • [2.1 get - set 操作](#2.1 get - set 操作)
  • [2.2 lpush - lpop 操作](#2.2 lpush - lpop 操作)
  • [2.3 hset - hget 操作](#2.3 hset - hget 操作)
  • [2.4 sadd - smembers 操作](#2.4 sadd - smembers 操作)
• 三、第三方库
• 四、总结

前言

按照公司目前的任务，go 学习是必经之路了，虽然行业卷，不过技多不压身，依旧努力！！！

一个项目想要提高访问速度和性能，缓存是很重要的一步，甚至可以说是必不可少，那目前最最流行的还是 Redis 缓存，那 Go 中怎么对Redis进行操作呢？有哪些第三方的函数库可以方便我们使用呢？

一、Redis 简介

尽管说起 Redis 大家都很熟悉，不过个人觉得再熟悉的东西也难免有疏忽的点。

Redis（Remote Dictionary Server）是一个开源的高性能的基于key-value内存数据存储系统，遵循 BSD 协议，通常被用作缓存 、数据库 和消息队列 。Redis 支持多种数据结构，比如：string、list、set、zset、hash 等。

Redis优点如下（不限于）：

1. 高性能：Redis基于内存进行数据读写，速度非常快。
2. 数据结构多样性：Redis 支持多样数据结构，适用于不同的数据存储需求。
3. 支持持久化 ：Redis可以持久化数据到磁盘，防止数据丢失，有 RDB 、AOF和混合持久化方式。
4. 支持分布式：Redis提供了分布式存储的支持，以集群的方式提供服务，有 主从（master - slave）、哨兵（Sentinel）、集群（Cluster）集群方式。
5. 功能更加丰富：Redis提供了更加丰富的功能，比如：发布订阅、Lua脚本执行等。

Redis 缺点如下（不限于）：

1. 内存限制：Redis数据存储在内存中，受限于内存大小，不适用与存储大量数据。
2. 数据持久化效率：数据持久化可能会影响Redis性能。

二、Redis 基本操作

首先下载 Redis 的第三方库：

针对简单的 Redis 操作，操作比较容易上手。

go get github.com/go-redis/redis

2.1 get - set 操作

package main

import (
	"fmt"
	"log"

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

func main() {
	// 创建一个Redis客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "192.168.1.199:6379",
		Password: "",
		DB:       0,
	})

	// 设置一个 key - value
	key := "key-2"
	value := "Hello Redis"
	// err := client.Set(key, value, 0).Err()
	err := client.Set(key, value, 0).Err()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("set key 成功！")

	// 获取一个key
	val, gErr := client.Get(key).Result()
	if gErr != nil {
		log.Fatal(gErr)
	}
	fmt.Println("获取到：", key, val)
}

运行结果：

PS D:\workspaceGo\src\redis> go run .\getset.go
set key 成功！
获取到： key-2 Hello Redis

2.2 lpush - lpop 操作

package main

import (
	"fmt"
	"log"

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

func main() {
	// 创建一个Redis客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "192.168.1.199:6379",
		Password: "",
		DB:       0,
	})

	key := "myList"
	value := "element-"
	// 向列表中添加元素
	for i := 0; i < 3; i++ {
		err := client.LPush(key, fmt.Sprint(value, i)).Err()
		if err != nil {
			log.Fatal(err)
		}
	}
	fmt.Println("Lpush 成功！")

	// 向列表中获取元素
	elements, lErr := client.LPop(key).Result()
	if lErr != nil {
		log.Fatal(lErr)
	}
	fmt.Printf("获取到列表 %s：%v", key, elements)
}

运行结果：

PS D:\workspaceGo\src\redis> go run .\listTest.go
Lpush 成功！
获取到列表 myList：element-2

2.3 hset - hget 操作

package main

import (
	"fmt"
	"log"

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

func main() {
	// 创建一个Redis客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "192.168.1.199:6379",
		Password: "",
		DB:       0,
	})

	key := "myHash"
	field := "field-"
	// 向 hash 中设置字段和值
	for i := 0; i < 3; i++ {
		err := client.HSet(key, fmt.Sprint(field, i), i).Err()
		if err != nil {
			log.Fatal(err)
		}
	}
	fmt.Println("向 myHash 中添加值成功")

	// 从 hash 中获取字段和值
	value, hErr := client.HGet(key, fmt.Sprint(field, 0)).Result()
	if hErr != nil {
		log.Fatal(hErr)
	}
	fmt.Printf("hash中的第一个字段：%s 值：%v \n", "field-0", value)

	// 获取所有的 字段 和 值
	allValue, haErr := client.HGetAll(key).Result()
	if haErr != nil {
		log.Fatal(hErr)
	}
	fmt.Println("hash中的所有字段和值", allValue)
}

运行结果：

PS D:\workspaceGo\src\redis> go run .\hashTest.go
向 myHash 中添加值成功
hash中的第一个字段：field-0 值：0
hash中的所有字段和值 map[field-0:0 field-1:1 field-2:2]

2.4 sadd - smembers 操作

package main

import (
	"fmt"
	"log"

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

func main() {
	// 创建一个Redis客户端
	client := redis.NewClient(&redis.Options{
		Addr:     "192.168.1.199:6379",
		Password: "",
		DB:       0,
	})

	key := "mySet"
	value := "element-"
	// 向集合中添加元素
	for i := 0; i < 3; i++ {
		err := client.SAdd(key, fmt.Sprint(value, i)).Err()
		if err != nil {
			log.Fatal(err)
		}
	}
	fmt.Println("向集合 mySet 中添加元素完成！")

	// 从 mySet 集合中获取元素
	values, smErr := client.SMembers(key).Result()
	if smErr != nil {
		log.Fatal(smErr)
	}
	fmt.Println("从 mySet 集合中获取的元素：", values)
}

运行结果：

PS D:\workspaceGo\src\redis> go run .\setTest.go
向集合 mySet 中添加元素完成！
从 mySet 集合中获取的元素： [element-1 element-0 element-2]

三、第三方库

Redis 还有其他第三方库，比如：github.com/go-redis/redis/v8 和 golang.org/x/net/context 上下文配合，可以在操作 Redis 过程中进行错误信息和元信息的追踪，以便实现更复杂的业务逻辑。

go get github.com/go-redis/redis/v8
go get golang.org/x/net/context

还有其他的，比如：

• github.com/gomodule/redigo：提供了更底层的接口，允许更精细地控制 Redis 操作。
• github.com/bsm/redislock：提供了分布式锁的实现，用于分布式系统中保证数据一致性。
• github.com/alicebob/miniredis：这是一个内从中模拟 Redis 服务器的库，用于单元集成测试。

四、总结

此篇仅仅用了 github.com/go-redis/redis 库对 Redis 的基本操作针对不同的数据结构进行了简单的操作，其实如若对 Redis 的命令熟悉，那用 Go 来操作 Redis 就不复杂了。

总之，Redis 是一个功能丰富、高性能的内存数据存储系统，适用于缓存、数据库和消息队列等多种应用场景。在使用 Redis 缓存时，需要考虑数据存储需求、缓存失效策略等因素，以实现更高效的数据访问和管理。