Redis 基础入门

HSXISAWD2026/3/20大约 15 分钟

Redis 基础入门

一、Redis 简介

1.1 什么是 Redis

Redis（Remote Dictionary Server）是一个开源的、基于内存的数据结构存储系统。它可以用作数据库、缓存和消息中间件。Redis 由意大利开发者 Salvatore Sanfilippo（网名 antirez）于 2009 年开发，现在由 Redis Labs 维护。

与传统的关系型数据库不同，Redis 将数据存储在内存中，这使得它的读写速度极快。根据官方测试数据，Redis 在普通硬件上可以达到每秒 10 万次以上的读写操作。

1.2 Redis 的核心特性

特性	描述
极高性能	基于内存操作，单机 QPS 可达 10W+，读写延迟在微秒级别
丰富的数据类型	支持 String、List、Hash、Set、Sorted Set 等多种数据结构
原子性操作	所有操作都是原子性的，支持事务和 Lua 脚本
持久化	支持 RDB 快照和 AOF 日志两种持久化方式
主从复制	支持 master-slave 模式的数据备份
高可用	通过 Sentinel 和 Cluster 实现高可用和分布式
发布订阅	内置 Pub/Sub 消息通信模式
Lua 脚本	支持服务端 Lua 脚本执行，保证原子性

1.3 Redis 的典型应用场景

1.4 Redis 版本演进

Redis 的版本迭代历史反映了其功能的不断增强：

版本	发布时间	重要特性
2.0	2010	虚拟内存、Hash 数据结构
2.6	2012	Lua 脚本、毫秒级过期精度
2.8	2013	部分同步（PSYNC）、Sentinel 稳定版
3.0	2015	Redis Cluster 官方集群方案
3.2	2016	GEO 地理位置、Lua 脚本调试
4.0	2017	模块系统、PSYNC 2.0、混合持久化
5.0	2018	Stream 数据类型、集群管理器
6.0	2020	多线程 I/O、ACL 权限控制、客户端缓存
6.2	2021	GETEX、COPY 命令、性能优化

本文档基于 Redis 6.x 版本编写，这是目前生产环境中使用最广泛、最稳定的版本。

1.5 Redis vs 其他存储方案

对比项	Redis	Memcached	MySQL
数据类型	丰富（5 种+）	只有 String	关系型
持久化	支持	不支持	支持
集群	Cluster	客户端分片	主从/分库分表
线程模型	单线程(6.0 前)	多线程	多线程
事务	弱事务	不支持	ACID
内存管理	多种淘汰策略	LRU	缓冲池
适用场景	缓存、队列、实时计算	简单缓存	持久化存储

二、Redis 安装与配置

2.1 Linux 环境安装

源码编译安装（推荐）

# 1. 安装依赖
yum install -y gcc gcc-c++ make

# 2. 下载 Redis 6.2 稳定版
cd /usr/local/src
wget https://download.redis.io/releases/redis-6.2.14.tar.gz

# 3. 解压并编译
tar -zxvf redis-6.2.14.tar.gz
cd redis-6.2.14
make
make install PREFIX=/usr/local/redis

# 4. 复制配置文件
mkdir -p /usr/local/redis/conf
cp redis.conf /usr/local/redis/conf/

# 5. 创建数据目录和日志目录
mkdir -p /data/redis
mkdir -p /var/log/redis

包管理器安装

# CentOS/RHEL
yum install epel-release -y
yum install redis -y

# Ubuntu/Debian
apt update
apt install redis-server -y

2.2 Docker 安装（开发环境推荐）

# 拉取 Redis 6.2 镜像
docker pull redis:6.2

# 创建配置文件目录和数据目录
mkdir -p /data/redis/conf
mkdir -p /data/redis/data

# 下载默认配置文件（可选）
wget https://raw.githubusercontent.com/redis/redis/6.2/redis.conf -O /data/redis/conf/redis.conf

# 启动 Redis 容器
docker run -d \
  --name redis \
  -p 6379:6379 \
  -v /data/redis/data:/data \
  -v /data/redis/conf/redis.conf:/etc/redis/redis.conf \
  redis:6.2 redis-server /etc/redis/redis.conf

# 连接到 Redis
docker exec -it redis redis-cli

2.3 Windows 安装

Redis 官方不直接支持 Windows，但可以使用以下方式：

WSL2（推荐）：在 Windows Subsystem for Linux 中按 Linux 方式安装
Docker Desktop：使用 Docker 运行 Redis 容器
第三方移植版：使用 Microsoft 维护的 Windows 版本（仅供开发测试）

2.4 配置文件详解

Redis 的配置文件 redis.conf 包含大量可配置项，下面介绍最重要的配置：

# =========================
# 网络配置
# =========================

# 绑定 IP，默认只监听本地
# 生产环境建议绑定内网 IP
bind 127.0.0.1 192.168.1.100

# 端口号
port 6379

# 保护模式，开启后只允许本地访问
# 如果设置了密码或 bind，可以关闭
protected-mode yes

# TCP 连接队列长度
tcp-backlog 511

# 客户端空闲超时时间（0 表示不超时）
timeout 0

# TCP keepalive，检测死连接
tcp-keepalive 300

# =========================
# 通用配置
# =========================

# 是否以守护进程方式运行
daemonize yes

# PID 文件路径
pidfile /var/run/redis_6379.pid

# 日志级别：debug/verbose/notice/warning
loglevel notice

# 日志文件路径
logfile /var/log/redis/redis.log

# 数据库数量，默认 16 个（0-15）
databases 16

# =========================
# 安全配置
# =========================

# 访问密码（强烈建议设置）
requirepass your_password_here

# 重命名危险命令（生产环境建议配置）
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG "CONFIG_b840fc02"
rename-command KEYS "KEYS_d7g8h9j2"

# =========================
# 内存配置
# =========================

# 最大内存限制（生产环境必须设置）
maxmemory 2gb

# 内存淘汰策略
# volatile-lru: 从设置过期时间的 key 中使用 LRU 算法淘汰
# allkeys-lru: 从所有 key 中使用 LRU 算法淘汰
# volatile-lfu: 从设置过期时间的 key 中使用 LFU 算法淘汰
# allkeys-lfu: 从所有 key 中使用 LFU 算法淘汰
# volatile-random: 从设置过期时间的 key 中随机淘汰
# allkeys-random: 从所有 key 中随机淘汰
# volatile-ttl: 淘汰即将过期的 key
# noeviction: 不淘汰，内存满时返回错误
maxmemory-policy allkeys-lru

# LRU/LFU 算法采样数量
maxmemory-samples 5

# =========================
# 持久化配置 - RDB
# =========================

# RDB 触发条件：N 秒内至少 M 次修改
save 900 1      # 900秒内至少1次修改
save 300 10     # 300秒内至少10次修改
save 60 10000   # 60秒内至少10000次修改

# 如果要禁用 RDB，取消所有 save 配置，或使用：
# save ""

# RDB 文件名
dbfilename dump.rdb

# 数据目录
dir /data/redis

# RDB 保存失败时是否停止写入
stop-writes-on-bgsave-error yes

# RDB 文件是否压缩
rdbcompression yes

# RDB 文件是否校验
rdbchecksum yes

# =========================
# 持久化配置 - AOF
# =========================

# 是否开启 AOF
appendonly yes

# AOF 文件名
appendfilename "appendonly.aof"

# AOF 同步策略
# always: 每次写入都同步，最安全但最慢
# everysec: 每秒同步一次，推荐配置
# no: 由操作系统决定何时同步
appendfsync everysec

# AOF 重写期间是否禁止 fsync
no-appendfsync-on-rewrite no

# AOF 重写触发条件
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# =========================
# 慢查询日志
# =========================

# 慢查询阈值（微秒），10000 = 10ms
slowlog-log-slower-than 10000

# 慢查询日志最大长度
slowlog-max-len 128

# =========================
# 客户端配置
# =========================

# 最大客户端连接数
maxclients 10000

2.5 启动与连接

启动 Redis 服务

# 方式一：使用默认配置启动
redis-server

# 方式二：指定配置文件启动
redis-server /usr/local/redis/conf/redis.conf

# 方式三：命令行参数启动（覆盖配置文件）
redis-server /usr/local/redis/conf/redis.conf --port 6380 --daemonize yes

Systemd 服务管理

创建服务文件 /etc/systemd/system/redis.service：

[Unit]
Description=Redis In-Memory Data Store
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/redis/bin/redis-server /usr/local/redis/conf/redis.conf
ExecStop=/usr/local/redis/bin/redis-cli shutdown
Restart=always
User=redis
Group=redis

[Install]
WantedBy=multi-user.target

# 加载配置
systemctl daemon-reload

# 启动服务
systemctl start redis

# 设置开机自启
systemctl enable redis

# 查看状态
systemctl status redis

连接 Redis

# 本地连接
redis-cli

# 指定主机和端口
redis-cli -h 192.168.1.100 -p 6379

# 带密码连接
redis-cli -h 192.168.1.100 -p 6379 -a your_password

# 连接后验证密码
redis-cli
> AUTH your_password

# 连接并选择数据库
redis-cli -n 1

# 执行单条命令
redis-cli PING
redis-cli SET foo bar
redis-cli GET foo

三、基本命令操作

3.1 通用命令

# 测试连接
PING
# 返回 PONG

# 查看服务器信息
INFO
INFO memory    # 只看内存信息
INFO server    # 只看服务器信息

# 查看所有配置
CONFIG GET *

# 获取/设置配置
CONFIG GET maxmemory
CONFIG SET maxmemory 4gb

# 选择数据库（0-15）
SELECT 1

# 查看当前数据库 key 数量
DBSIZE

# 清空当前数据库
FLUSHDB

# 清空所有数据库
FLUSHALL

# 查看所有 key（生产环境慎用）
KEYS *
KEYS user:*    # 匹配模式

# 使用 SCAN 迭代（推荐）
SCAN 0 MATCH user:* COUNT 100

# 判断 key 是否存在
EXISTS key1 key2

# 查看 key 的类型
TYPE mykey

# 删除 key
DEL key1 key2 key3

# 异步删除（适用于大 key）
UNLINK key1 key2

# 重命名 key
RENAME oldkey newkey
RENAMENX oldkey newkey  # 仅当 newkey 不存在时

# 随机返回一个 key
RANDOMKEY

3.2 过期时间操作

# 设置过期时间（秒）
EXPIRE key 3600

# 设置过期时间（毫秒）
PEXPIRE key 3600000

# 设置在指定时间点过期（Unix 时间戳，秒）
EXPIREAT key 1704067200

# 设置在指定时间点过期（Unix 时间戳，毫秒）
PEXPIREAT key 1704067200000

# 查看剩余过期时间（秒）
TTL key
# 返回值：
# -1: 没有设置过期时间
# -2: key 不存在
# >0: 剩余秒数

# 查看剩余过期时间（毫秒）
PTTL key

# 移除过期时间
PERSIST key

3.3 String 类型基本操作

String 是 Redis 最基础的数据类型，可以存储字符串、整数或浮点数。

# 设置值
SET key value
SET name "hello world"

# 设置值并指定过期时间
SET key value EX 3600      # 秒
SET key value PX 3600000   # 毫秒
SETEX key 3600 value       # 等同于 SET + EXPIRE

# 只在 key 不存在时设置（常用于分布式锁）
SET key value NX
SETNX key value

# 只在 key 存在时设置
SET key value XX

# 获取值
GET key

# 获取旧值并设置新值
GETSET key newvalue

# 批量设置
MSET key1 value1 key2 value2 key3 value3

# 批量获取
MGET key1 key2 key3

# 追加字符串
APPEND key " suffix"

# 获取字符串长度
STRLEN key

# 获取子字符串
GETRANGE key 0 4    # 获取前5个字符
GETRANGE key -5 -1  # 获取后5个字符

# 覆盖子字符串
SETRANGE key 0 "new"

3.4 数值操作

# 设置数值
SET counter 100

# 自增 1
INCR counter    # 返回 101

# 自减 1
DECR counter    # 返回 100

# 增加指定值
INCRBY counter 10    # 返回 110

# 减少指定值
DECRBY counter 5     # 返回 105

# 增加浮点数
INCRBYFLOAT price 0.5

# 注意：如果 key 不存在，会先初始化为 0
INCR newkey    # 返回 1

3.5 位操作

# 设置位
SETBIT key 7 1

# 获取位
GETBIT key 7

# 统计值为 1 的位数
BITCOUNT key
BITCOUNT key 0 0    # 只统计第一个字节

# 位运算
BITOP AND destkey key1 key2
BITOP OR destkey key1 key2
BITOP XOR destkey key1 key2
BITOP NOT destkey key

# 查找第一个设置为指定值的位
BITPOS key 1        # 第一个值为 1 的位
BITPOS key 0        # 第一个值为 0 的位

四、客户端连接

4.1 常用客户端库

语言	客户端	特点
Java	Jedis	轻量级，同步阻塞
Java	Lettuce	基于 Netty，支持异步
Java	Redisson	功能丰富，分布式对象
Python	redis-py	官方推荐
Node.js	ioredis	功能完整，支持集群
Go	go-redis	类型安全，支持集群
PHP	phpredis	C 扩展，性能好
C#	StackExchange.Redis	高性能，生产就绪

4.2 Java 客户端示例

Jedis 使用

<!-- Maven 依赖 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.4.0</version>
</dependency>

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisExample {

    // 创建连接池（推荐方式）
    private static JedisPool createPool() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(100);          // 最大连接数
        config.setMaxIdle(20);            // 最大空闲连接
        config.setMinIdle(5);             // 最小空闲连接
        config.setMaxWaitMillis(3000);    // 最大等待时间
        config.setTestOnBorrow(true);     // 借出时检测

        return new JedisPool(config, "localhost", 6379, 2000, "password");
    }

    public static void main(String[] args) {
        JedisPool pool = createPool();

        // 使用 try-with-resources 自动归还连接
        try (Jedis jedis = pool.getResource()) {
            // 字符串操作
            jedis.set("name", "redis");
            String name = jedis.get("name");
            System.out.println("name: " + name);

            // 带过期时间
            jedis.setex("session:123", 3600, "user_data");

            // 自增
            jedis.incr("counter");

            // Hash 操作
            jedis.hset("user:1001", "name", "张三");
            jedis.hset("user:1001", "age", "25");
            Map<String, String> user = jedis.hgetAll("user:1001");

            // List 操作
            jedis.lpush("queue", "task1", "task2", "task3");
            String task = jedis.rpop("queue");

            // Set 操作
            jedis.sadd("tags", "java", "redis", "mysql");
            Set<String> tags = jedis.smembers("tags");

            // Sorted Set 操作
            jedis.zadd("ranking", 100, "player1");
            jedis.zadd("ranking", 200, "player2");
            Set<String> top = jedis.zrevrange("ranking", 0, 9);

        } finally {
            pool.close();
        }
    }
}

Lettuce 使用

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.2.6.RELEASE</version>
</dependency>

import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;

public class LettuceExample {
    public static void main(String[] args) {
        // 创建客户端
        RedisClient client = RedisClient.create("redis://password@localhost:6379/0");

        // 获取连接
        StatefulRedisConnection<String, String> connection = client.connect();
        RedisCommands<String, String> commands = connection.sync();

        // 执行命令
        commands.set("key", "value");
        String value = commands.get("key");

        // 关闭连接
        connection.close();
        client.shutdown();
    }
}

4.3 Spring Boot 集成

# application.yml
spring:
  redis:
    host: localhost
    port: 6379
    password: your_password
    database: 0
    timeout: 3000ms
    lettuce:
      pool:
        max-active: 100
        max-idle: 20
        min-idle: 5
        max-wait: 3000ms

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 字符串操作
    public void setString(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    public void setStringWithExpire(String key, String value, long seconds) {
        stringRedisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
    }

    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    // Hash 操作
    public void setHash(String key, String field, Object value) {
        redisTemplate.opsForHash().put(key, field, value);
    }

    public Object getHash(String key, String field) {
        return redisTemplate.opsForHash().get(key, field);
    }

    // List 操作
    public void pushList(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    public Object popList(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    // Set 操作
    public void addSet(String key, Object... values) {
        redisTemplate.opsForSet().add(key, values);
    }

    public Set<Object> getSet(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    // Sorted Set 操作
    public void addZSet(String key, Object value, double score) {
        redisTemplate.opsForZSet().add(key, value, score);
    }

    public Set<Object> getZSetRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }
}

4.4 Python 客户端示例

import redis
from redis import ConnectionPool

# 创建连接池
pool = ConnectionPool(
    host='localhost',
    port=6379,
    password='your_password',
    db=0,
    max_connections=100,
    decode_responses=True  # 自动将字节解码为字符串
)

# 创建客户端
r = redis.Redis(connection_pool=pool)

# 字符串操作
r.set('name', 'redis')
r.setex('session:123', 3600, 'user_data')  # 带过期时间
name = r.get('name')
print(f"name: {name}")

# 自增
r.incr('counter')
counter = r.get('counter')

# Hash 操作
r.hset('user:1001', mapping={'name': '张三', 'age': '25'})
user = r.hgetall('user:1001')

# List 操作
r.lpush('queue', 'task1', 'task2', 'task3')
task = r.rpop('queue')

# Set 操作
r.sadd('tags', 'python', 'redis', 'mysql')
tags = r.smembers('tags')

# Sorted Set 操作
r.zadd('ranking', {'player1': 100, 'player2': 200})
top = r.zrevrange('ranking', 0, 9, withscores=True)

# 管道（批量操作，减少网络往返）
pipe = r.pipeline()
pipe.set('key1', 'value1')
pipe.set('key2', 'value2')
pipe.get('key1')
pipe.get('key2')
results = pipe.execute()

4.5 Go 客户端示例

package main

import (
    "context"
    "fmt"
    "time"

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

var ctx = context.Background()

func main() {
    // 创建客户端
    rdb := redis.NewClient(&redis.Options{
        Addr:         "localhost:6379",
        Password:     "your_password",
        DB:           0,
        PoolSize:     100,
        MinIdleConns: 10,
        DialTimeout:  5 * time.Second,
        ReadTimeout:  3 * time.Second,
        WriteTimeout: 3 * time.Second,
    })
    defer rdb.Close()

    // 测试连接
    _, err := rdb.Ping(ctx).Result()
    if err != nil {
        panic(err)
    }

    // 字符串操作
    err = rdb.Set(ctx, "name", "redis", 0).Err()
    err = rdb.SetEX(ctx, "session:123", "user_data", time.Hour).Err()
    name, err := rdb.Get(ctx, "name").Result()
    fmt.Printf("name: %s\n", name)

    // 自增
    counter, err := rdb.Incr(ctx, "counter").Result()

    // Hash 操作
    err = rdb.HSet(ctx, "user:1001", "name", "张三", "age", "25").Err()
    user, err := rdb.HGetAll(ctx, "user:1001").Result()

    // List 操作
    err = rdb.LPush(ctx, "queue", "task1", "task2", "task3").Err()
    task, err := rdb.RPop(ctx, "queue").Result()

    // Set 操作
    err = rdb.SAdd(ctx, "tags", "go", "redis", "mysql").Err()
    tags, err := rdb.SMembers(ctx, "tags").Result()

    // Sorted Set 操作
    err = rdb.ZAdd(ctx, "ranking",
        &redis.Z{Score: 100, Member: "player1"},
        &redis.Z{Score: 200, Member: "player2"},
    ).Err()
    top, err := rdb.ZRevRange(ctx, "ranking", 0, 9).Result()

    // 管道
    pipe := rdb.Pipeline()
    pipe.Set(ctx, "key1", "value1", 0)
    pipe.Set(ctx, "key2", "value2", 0)
    pipe.Get(ctx, "key1")
    pipe.Get(ctx, "key2")
    cmds, err := pipe.Exec(ctx)
}

五、可视化管理工具

5.1 常用管理工具

工具	类型	特点
Redis Desktop Manager	桌面应用	功能全面，支持 SSH 隧道
Another Redis Desktop Manager	桌面应用	免费开源，轻量级
RedisInsight	官方工具	免费，功能强大，支持集群
Medis	Mac 应用	界面美观，专为 Mac 设计
phpRedisAdmin	Web 应用	PHP 开发，可部署在服务器
redis-commander	Web 应用	Node.js 开发，易于部署

5.2 命令行监控

# 实时监控命令
redis-cli MONITOR

# 查看统计信息
redis-cli INFO

# 查看内存使用情况
redis-cli INFO memory

# 查看客户端连接
redis-cli CLIENT LIST

# 查看慢查询日志
redis-cli SLOWLOG GET 10

# 实时统计
redis-cli --stat
redis-cli --bigkeys    # 扫描大 key
redis-cli --memkeys    # 扫描内存占用
redis-cli --hotkeys    # 热点 key（需开启 LFU）

六、最佳实践

6.1 Key 命名规范

# 推荐格式：业务名:对象类型:对象ID:属性
# 使用冒号分隔，小写字母

# 用户信息
user:1001:info
user:1001:session

# 订单数据
order:202401150001:detail
order:user:1001:list

# 缓存数据
cache:product:1001
cache:category:list

# 计数器
counter:page:home:pv
counter:article:1001:view

# 锁
lock:order:create:1001

# 不推荐
# 过长的 key
very_very_very_very_very_long_key_name
# 包含特殊字符
user:info:{id}
# 大小写混用
User:INFO:1001

6.2 连接池配置建议

// Jedis 连接池配置示例
JedisPoolConfig config = new JedisPoolConfig();

// 最大连接数 = (执行命令平均耗时 * 业务QPS) / 1000
// 假设命令耗时 2ms，QPS 5000，则最大连接数 = 2 * 5000 / 1000 = 10
// 考虑到波动，可以设置为 2-3 倍，即 20-30
config.setMaxTotal(30);

// 最大空闲连接数，建议等于最大连接数
config.setMaxIdle(30);

// 最小空闲连接数，保证基本的连接可用
config.setMinIdle(10);

// 获取连接最大等待时间，超时抛出异常
config.setMaxWaitMillis(2000);

// 借出连接时检测有效性
config.setTestOnBorrow(true);

// 归还连接时检测有效性
config.setTestOnReturn(false);

// 空闲时检测有效性
config.setTestWhileIdle(true);

// 空闲连接检测间隔
config.setTimeBetweenEvictionRunsMillis(30000);

// 最小空闲时间，超过后可能被回收
config.setMinEvictableIdleTimeMillis(60000);

6.3 常见问题与解决

问题	可能原因	解决方案
连接超时	网络问题/连接数不足	检查网络，增加连接池大小
内存不足	数据量大/未设置过期时间	设置 maxmemory 和淘汰策略
响应慢	大 key/慢命令/持久化	使用 SCAN 替代 KEYS，优化命令
数据丢失	持久化配置不当	开启 AOF，合理配置 RDB
连接被拒绝	达到 maxclients	增加 maxclients，排查连接泄漏

七、总结

本章介绍了 Redis 的基础知识：

Redis 概述：特性、应用场景、版本演进
安装配置：多种安装方式、重要配置项详解
基本命令：通用命令、String 类型操作、过期时间
客户端连接：Java/Python/Go 客户端使用示例
最佳实践：命名规范、连接池配置、常见问题

掌握这些基础知识后，你已经可以在项目中使用 Redis 进行基本的缓存操作了。后续章节将深入讲解 Redis 的各种数据类型、持久化机制、高可用架构等高级内容。