30天学会Go--第7天 GO语言 Redis 学习与实践（改）

文章目录

[30天学会Go--第7天 GO语言 Redis 学习与实践（改）](#30天学会Go--第7天 GO语言 Redis 学习与实践（改）)
- 前言
- [一、Redis 基础知识](#一、Redis 基础知识)
- - [1.1 Redis 的核心特性](#1.1 Redis 的核心特性)
  - [1.2 Redis 常见使用场景](#1.2 Redis 常见使用场景)
- [二、安装 Redis](#二、安装 Redis)
- - [2.1 在 Linux 上安装](#2.1 在 Linux 上安装)
  - [2.2 在 Windows 上安装](#2.2 在 Windows 上安装)
  - [2.3 使用 Docker 安装 Redis](#2.3 使用 Docker 安装 Redis)
- [三、Redis 常用命令](#三、Redis 常用命令)
- - [3.1 基本操作](#3.1 基本操作)
  - [3.2 数据结构操作](#3.2 数据结构操作)
  - - 字符串（String）
    - - 扩展命令：
    - 哈希（Hash）
    - - 扩展命令：
    - 列表（List）
    - - 扩展命令：
    - 集合（Set）
    - - 扩展命令：
    - [有序集合（Sorted Set）](#有序集合（Sorted Set）)
    - - 扩展命令：
- [四、在 Go 中使用 Redis](#四、在 Go 中使用 Redis)
- - [4.1 安装 go-redis](#4.1 安装 go-redis)
  - [4.2 使用示例](#4.2 使用示例)
  - - 代码示例
    - 代码解读
- [五、Redis 高级功能](#五、Redis 高级功能)
- - [5.1 发布/订阅（Pub/Sub）](#5.1 发布/订阅（Pub/Sub）)
  - [5.2 使用 Redis 实现分布式锁](#5.2 使用 Redis 实现分布式锁)
  - - 加锁
    - 解锁
    - 运行逻辑
    - 注意事项
    - - [1. 锁的过期时间](#1. 锁的过期时间)
      - [2. 解锁的原子性](#2. 解锁的原子性)
    - 扩展功能：自动续约
    - 分布式锁的完整实现示例
    - 分布式锁的应用场景
- 六、总结

前言

Redis 是一个高性能的开源内存数据库，常用于缓存、消息队列、会话存储等场景。它支持多种数据结构（如字符串、哈希、列表、集合、有序集合等）和丰富的操作命令，具有极高的性能和灵活性。

以下是 Redis 的基础知识、安装、常用命令，以及在 Go 中使用 Redis 的方法。

redis中文官方文档指南：redis中文文档

redis的中文官方文档学习笔记很全，推荐去官网学习

30天学会Go--第6天 GO语言 RESTful API 学习与实践：30天学会Go--第6天 GO语言 RESTful API 学习与实践-CSDN博客

一、Redis 基础知识

1.1 Redis 的核心特性

内存存储：所有数据存储在内存中，读写速度极快。
多种数据结构：支持字符串（String）、哈希（Hash）、列表（List）、集合（Set）、有序集合（Sorted Set）等。
持久化：支持将内存数据持久化到磁盘（RDB 和 AOF 两种方式）。
高可用：支持主从复制、哨兵模式和集群模式，提供高可用性和扩展性。
丰富的功能：如发布/订阅（Pub/Sub）、事务、Lua 脚本等。

1.2 Redis 常见使用场景

缓存：将经常访问的数据存储到 Redis 中，提高读取性能。
会话存储：存储用户登录状态等会话信息。
排行榜：利用有序集合（Sorted Set）实现排行榜功能。
消息队列：使用列表（List）或发布/订阅功能实现消息队列。
分布式锁：利用 Redis 的原子操作实现分布式锁。

二、安装 Redis

2.1 在 Linux 上安装

下载 Redis：

bash 复制代码

wget http://download.redis.io/redis-stable.tar.gz

解压并编译：

bash 复制代码

tar xzf redis-stable.tar.gz
cd redis-stable
make

启动 Redis：
bash 复制代码
```
src/redis-server
```

2.2 在 Windows 上安装

下载 Redis for Windows：
- Redis 官方不支持 Windows，但可以下载社区版：https://github.com/microsoftarchive/redis/releases
解压后运行 redis-server.exe 启动服务。
将 Redis 的安装目录添加到系统的环境变量 PATH 中：
- 打开 系统属性 > 高级系统设置 > 环境变量。
- 在系统变量中找到 Path，点击编辑。
- 添加 Redis 的安装目录路径（如 C:\Program Files\Redis）

2.3 使用 Docker 安装 Redis

拉取 Redis 镜像：
bash 复制代码
```
docker pull redis
```

启动 Redis 容器：

bash 复制代码

docker run -d --name redis -p 6379:6379 redis

三、Redis 常用命令

3.1 基本操作

连接 Redis：
bash 复制代码
```
redis-cli
```
设置键值对：
bash 复制代码
```
SET key value
```
获取键值：
bash 复制代码
```
GET key
```
删除键：
bash 复制代码
```
DEL key
```
检查键是否存在：
bash 复制代码
```
EXISTS key
```
设置过期时间（秒）：
bash 复制代码
```
EXPIRE key seconds
```
查看剩余过期时间：
bash 复制代码
```
TTL key
```

3.2 数据结构操作

字符串（String）

字符串是 Redis 中最基本的数据结构，可以存储文本或二进制数据，支持数值操作。

增加值（适用于数值类型）：
- INCR key：将键的值加 1。
  bash 复制代码
```
SET counter 10
INCR counter
# 输出: (integer) 11
```
- INCRBY key increment：将键的值增加指定的 increment。
  bash 复制代码
```
INCRBY counter 5
# 输出: (integer) 16
```
- DECR key：将键的值减 1。
  bash 复制代码
```
DECR counter
# 输出: (integer) 15
```
- DECRBY key decrement：将键的值减少指定的 decrement。
  bash 复制代码
```
DECRBY counter 3
# 输出: (integer) 12
```

扩展命令：

SET key value：设置键的值。
bash 复制代码
```
SET greeting "Hello"
```
GET key：获取键的值。
bash 复制代码
```
GET greeting
# 输出: "Hello"
```
APPEND key value：将 value 追加到键的现有值之后。
bash 复制代码
```
APPEND greeting " World"
# 输出: (integer) 11
```
STRLEN key：获取键值的长度。
bash 复制代码
```
STRLEN greeting
# 输出: (integer) 11
```

哈希（Hash）

哈希是一个键值对集合，适用于存储对象（如用户信息）。

设置哈希字段：
- HSET key field value：设置哈希表中的字段 field 为指定值 value。
  bash 复制代码
```
HSET user:1 name "Alice"
HSET user:1 age 30
# 输出: (integer) 1
```
获取哈希字段值：
- HGET key field：获取哈希表中字段 field 的值。
  bash 复制代码
```
HGET user:1 name
# 输出: "Alice"
```
获取所有字段和值：
- HGETALL key：获取哈希表中所有字段和值。
  bash 复制代码
```
HGETALL user:1
# 输出: 
# 1) "name"
# 2) "Alice"
# 3) "age"
# 4) "30"
```

扩展命令：

HMSET key field1 value1 field2 value2：同时设置多个字段及其值。
bash 复制代码
```
HMSET user:2 name "Bob" age 25 city "New York"
```
HMGET key field1 field2：获取多个字段的值。
bash 复制代码
```
HMGET user:2 name city
# 输出: 
# 1) "Bob"
# 2) "New York"
```
HDEL key field：删除哈希表中的一个或多个字段。
bash 复制代码
```
HDEL user:1 age
# 输出: (integer) 1
```
HLEN key：获取哈希表中字段的数量。
bash 复制代码
```
HLEN user:2
# 输出: (integer) 3
```
HEXISTS key field：检查字段是否存在。
bash 复制代码
```
HEXISTS user:2 city
# 输出: (integer) 1
```

列表（List）

列表是一个链表，支持从两端插入和弹出元素。

从左插入元素：
- LPUSH key value1 value2：将一个或多个值插入到列表的头部。
  bash 复制代码
```
LPUSH tasks "Task1" "Task2"
# 输出: (integer) 2
```
从右插入元素：
- RPUSH key value1 value2：将一个或多个值插入到列表的尾部。
  bash 复制代码
```
RPUSH tasks "Task3"
# 输出: (integer) 3
```
获取列表范围内的元素：
- LRANGE key start stop：获取指定范围的元素（支持负索引）。
  bash 复制代码
```
LRANGE tasks 0 -1
# 输出: 
# 1) "Task2"
# 2) "Task1"
# 3) "Task3"
```
弹出最左边的元素：
- LPOP key：移除并返回列表的第一个元素。
  bash 复制代码
```
LPOP tasks
# 输出: "Task2"
```

扩展命令：

RPOP key：移除并返回列表的最后一个元素。
bash 复制代码
```
RPOP tasks
# 输出: "Task3"
```
LLEN key：获取列表的长度。
bash 复制代码
```
LLEN tasks
# 输出: (integer) 1
```
LINDEX key index：获取列表中指定索引的元素。
bash 复制代码
```
LINDEX tasks 0
# 输出: "Task1"
```

集合（Set）

集合是一个无序的、唯一的元素集合。

添加元素到集合：
- SADD key member1 member2：将一个或多个元素添加到集合。
  bash 复制代码
```
SADD fruits "apple" "banana" "cherry"
# 输出: (integer) 3 
```
获取集合中的所有元素：
- SMEMBERS key：获取集合中的所有元素。
  bash 复制代码
```
SMEMBERS fruits
# 输出: 
# 1) "apple"
# 2) "banana"
# 3) "cherry"
```
检查元素是否存在：
- SISMEMBER key member：检查指定元素是否在集合中。
  bash 复制代码
```
SISMEMBER fruits "banana"
# 输出: (integer) 1
```

扩展命令：

SREM key member：移除集合中的一个或多个元素。
bash 复制代码
```
SREM fruits "apple"
# 输出: (integer) 1
```
SCARD key：获取集合中元素的数量。
bash 复制代码
```
SCARD fruits
# 输出: (integer) 2
```

有序集合（Sorted Set）

有序集合是一个带有分数的集合，分数用于排序。

添加元素并设置分数：
- ZADD key score1 member1 score2 member2：添加一个或多个元素及其分数。
  bash 复制代码
```
ZADD leaderboard 100 "Alice" 200 "Bob" 150 "Charlie"
# 输出: (integer) 3
```
获取有序集合中的元素：
- ZRANGE key start stop [WITHSCORES]：按分数从低到高返回指定范围的元素。
  bash 复制代码
```
ZRANGE leaderboard 0 -1 WITHSCORES
# 输出: 
# 1) "Alice"
# 2) "100"
# 3) "Charlie"
# 4) "150"
# 5) "Bob"
# 6) "200"
```

扩展命令：

ZINCRBY key increment member：为指定元素的分数增加 increment。
bash 复制代码
```
ZINCRBY leaderboard 50 "Alice"
# 输出: "150"
```

四、在 Go 中使用 Redis

在 Go 中使用 Redis，通常使用第三方库 go-redis。

4.1 安装 go-redis

运行以下命令安装：

bash 复制代码

go get github.com/redis/go-redis/v9

4.2 使用示例

以下是一个简单的示例，展示如何在 Go 中使用 Redis。

代码示例

go 复制代码

package main

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

var ctx = context.Background() // 一个通用的、无状态的上下文，用于程序的起点或测试场景

func main() {
	// 1. 连接到 Redis
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // Redis 地址
		Password: "",               // 如果没有设置密码，留空
		DB:       0,                // 使用默认数据库
	})

	// 2. 写入数据
	err := rdb.Set(ctx, "key", "value", 0).Err()
	if err != nil {
		panic(err)
	}

	// 3. 读取数据
	val, err := rdb.Get(ctx, "key").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("key:", val)

	// 4. 检查键是否存在
	exists, err := rdb.Exists(ctx, "key").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("key exists:", exists)

	// 5. 删除键
	err = rdb.Del(ctx, "key").Err()
	if err != nil {
		panic(err)
	}
	fmt.Println("key deleted")
}

代码解读

连接 Redis：
- 使用 redis.NewClient 创建 Redis 客户端。
- 配置地址、密码和数据库编号。
写入数据：
- 使用 Set 方法写入键值对。
- 第三个参数为过期时间，0 表示不过期。
读取数据：
- 使用 Get 方法读取键的值。
检查键是否存在：
- 使用 Exists 方法检查键是否存在。
删除键：
- 使用 Del 方法删除键。

五、Redis 高级功能

5.1 发布/订阅（Pub/Sub）

Redis 的发布/订阅（Pub/Sub）功能允许消息的发布者和订阅者通过频道（Channel）进行通信，适用于实时消息推送场景。

发布消息

go 复制代码

err := rdb.Publish(ctx, "channel1", "Hello, Redis!").Err()
if err != nil {
    panic(err)
}

Publish ：将消息发布到指定的频道 channel1。
如果频道没有订阅者，消息会被丢弃，不会存储在 Redis 中。

订阅消息

go 复制代码

sub := rdb.Subscribe(ctx, "channel1")
ch := sub.Channel()

for msg := range ch {
    fmt.Println("Received message:", msg.Payload)
}

Subscribe ：订阅指定的频道 channel1。
sub.Channel()：返回一个通道（Channel），用于接收消息。
msg.Payload：获取消息内容。

运行逻辑

订阅者通过 Subscribe 监听指定频道。
发布者通过 Publish 向频道发送消息。
订阅者会实时接收到频道中的消息。

注意事项

实时性：消息是实时传递的，Redis 不会存储历史消息。
性能：在高并发场景下，Pub/Sub 的性能可能会成为瓶颈，不适合复杂的消息队列需求。
替代方案：对于更复杂的消息系统，可以考虑使用 Redis 的 Stream 数据结构或专用的消息队列（如 RabbitMQ、Kafka）。

5.2 使用 Redis 实现分布式锁

分布式锁是一种用于在分布式系统中控制资源访问的机制。Redis 的原子操作（如 SETNX 和 DEL）可以用来实现分布式锁。

加锁

go 复制代码

ok, err := rdb.SetNX(ctx, "lock_key", "lock_value", 10*time.Second).Result()
if err != nil || !ok {
    fmt.Println("Failed to acquire lock")
    return
}
fmt.Println("Lock acquired, executing task...")

SetNX ：尝试设置键 lock_key，如果键不存在，则设置成功并返回 true；如果键已存在，则返回 false。
10\*time.Second：锁的过期时间，防止因异常情况导致锁无法释放。
ok：表示加锁是否成功。

解锁

go 复制代码

rdb.Del(ctx, "lock_key")

Del ：删除键 lock_key，释放锁。

运行逻辑

使用 SetNX 确保锁的唯一性和原子性。
设置锁的过期时间，避免因程序崩溃导致锁无法释放。
任务完成后，删除锁。

注意事项

1. 锁的过期时间

必须设置锁的过期时间，防止因程序崩溃或超时导致锁无法释放。
如果锁的持有时间超过预期，可以使用 Lua 脚本延长锁的过期时间。

2. 解锁的原子性

简单的 Del 存在潜在问题：如果一个客户端意外删除了其他客户端的锁，可能会导致资源竞争。

可以使用 Lua 脚本确保解锁的原子性：

go 复制代码

unlockScript := redis.NewScript(`
    if redis.call("GET", KEYS[1]) == ARGV[1] then
        return redis.call("DEL", KEYS[1])
    else
        return 0
    end
`)

_, err := unlockScript.Run(ctx, rdb, []string{"lock_key"}, "lock_value").Result()
if err != nil {
    panic(err)
}

扩展功能：自动续约

在某些任务耗时较长的情况下，可以通过定时任务自动续约锁的过期时间：

go 复制代码

go func() {
    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop()

    for range ticker.C {
        _, err := rdb.Expire(ctx, "lock_key", 10*time.Second).Result()
        if err != nil {
            fmt.Println("Failed to renew lock")
            return
        }
        fmt.Println("Lock renewed")
    }
}()

分布式锁的完整实现示例

以下是一个完整的分布式锁实现，包括加锁、续约和解锁：

go 复制代码

package main

import (
	"context"
	"fmt"
	"time"

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

var ctx = context.Background()

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})

	// 加锁
	lockKey := "lock_key"
	lockValue := "unique_value"
	ok, err := rdb.SetNX(ctx, lockKey, lockValue, 10*time.Second).Result()
	if err != nil || !ok {
		fmt.Println("Failed to acquire lock")
		return
	}
	fmt.Println("Lock acquired")

	// 自动续约
	go func() {
		ticker := time.NewTicker(5 * time.Second)
		defer ticker.Stop()

		for range ticker.C {
			_, err := rdb.Expire(ctx, lockKey, 10*time.Second).Result()
			if err != nil {
				fmt.Println("Failed to renew lock")
				return
			}
			fmt.Println("Lock renewed")
		}
	}()

	// 模拟执行业务逻辑
	time.Sleep(15 * time.Second)

	// 解锁
	unlockScript := redis.NewScript(`
		if redis.call("GET", KEYS[1]) == ARGV[1] then
			return redis.call("DEL", KEYS[1])
		else
			return 0
		end
	`)
	_, err = unlockScript.Run(ctx, rdb, []string{lockKey}, lockValue).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println("Lock released")
}

分布式锁的应用场景

任务调度：确保同一时间只有一个实例执行任务。
库存扣减：防止多客户端同时更新库存数据。
限流控制：限制某些资源的并发访问量。

六、总结

Redis 是一个功能强大且灵活的内存数据库，在 Go 中使用 Redis 非常简单。通过学习 Redis 的基本命令和在 Go 中的集成，你可以轻松实现缓存、消息队列、分布式锁等功能。