Redis技术学习指南：从入门到实践

小码快撩

已于 2024-04-26 16:42:57 修改

阅读量9.4k

点赞数 29

文章标签： redis 数据库缓存

于 2024-03-10 10:15:00 首次发布

本文链接：https://blog.csdn.net/2301_78813969/article/details/136560654

版权

引言

Redis，全称为Remote Dictionary Server（远程字典服务器），是一种开源的、基于内存的数据结构存储系统，支持数据持久化，并提供多种数据结构如字符串、哈希表、列表、集合、有序集合等多种数据模型。由于其高性能和丰富的数据类型，Redis被广泛应用于缓存、会话管理、实时排行榜、消息队列、分布式锁等多个场景。

一、键值存储与数据结构

1. Redis字符串（String）

import redis.clients.jedis.Jedis;

public class RedisStringExample {
    public static void main(String[] args) {
        // 创建Jedis连接对象
        Jedis jedis = new Jedis("localhost", 6379);

        // 设置一个键值对，key为"user:1", value为"John"
        jedis.set("user:1", "John");

        // 获取键对应的值
        String value = jedis.get("user:1");
        System.out.println(value);  // 输出: "John"

        // 更新键的值
        jedis.set("user:1", "Jane");

        // 对字符串进行自增操作（仅适用于可转化为整数的字符串）
        jedis.incr("counter");  // 如果不存在，则创建并设置为1；如果存在，则加1

        // 删除键
        jedis.del("user:1");
    }
}

2. Redis哈希表（Hash）

public class RedisHashExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);

        // 设置哈希表
        jedis.hset("user:profile", "name", "Alice");
        jedis.hset("user:profile", "age", "30");
        jedis.hset("user:profile", "city", "New York");

        // 获取哈希表中的所有字段和值
        Map<String, String> profile = jedis.hgetAll("user:profile");
        System.out.println(profile);  // 输出：{name=Alice, age=30, city=New York}

        // 获取哈希表中特定字段的值
        String name = jedis.hget("user:profile", "name");
        System.out.println(name);  // 输出: "Alice"

        // 更新哈希表中的字段值
        jedis.hset("user:profile", "city", "San Francisco");

        // 删除哈希表中的单个字段
        jedis.hdel("user:profile", "age");
    }
}

3. Redis列表（List）

public class RedisListExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);

        // 在列表左侧插入元素
        jedis.lpush("shopping_list", "apples");

        // 在列表右侧插入元素
        jedis.rpush("shopping_list", "bananas");

        // 获取列表内容
        List<String> items = jedis.lrange("shopping_list", 0, -1);
        System.out.println(items);  // 输出：[apples, bananas]

        // 从列表左侧弹出一个元素
        String poppedItem = jedis.lpop("shopping_list");
        System.out.println(poppedItem);  // 输出：apples
    }
}

4. Redis集合（Set）

public class RedisSetExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);

        // 向集合中添加元素（无序不重复）
        jedis.sadd("unique_tags", "redis", "database", "nosql");

        // 获取集合中的所有元素
        Set<String> tags = jedis.smembers("unique_tags");
        System.out.println(tags);  // 输出：[redis, database, nosql]

        // 判断某个元素是否存在于集合中
        boolean isPresent = jedis.sismember("unique_tags", "redis");
        System.out.println(isPresent);  // 输出：true

        // 从集合中移除元素
        jedis.srem("unique_tags", "nosql");
    }
}

5. Redis有序集合（Sorted Set）

public class RedisSortedSetExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);

        // 向有序集合中添加元素，并带有分数以排序
        jedis.zadd("scores", 85, "Alice");
        jedis.zadd("scores", 90, "Bob");
        jedis.zadd("scores", 88, "Charlie");

        // 按照分数排序获取集合中的所有成员及其分数
        Set<Tuple> sortedMembers = jedis.zrangeWithScores("scores", 0, -1);
        for (Tuple member : sortedMembers) {
            System.out.println(member.getElement() + ": " + member.getScore());  // 输出：Alice: 85, Charlie: 88, Bob: 90
        }

        // 根据分数范围查询成员
        Set<String> membersInRange = jedis.zrangeByScore("scores", 85, 90);
        System.out.println(membersInRange);  // 输出：[Alice, Charlie, Bob]
    }
}

以上代码片段展示了如何使用Jedis客户端库来操作Redis的各种数据结构。在实际应用中，请根据业务需求选择合适的数据类型。

二、内存数据库与高性能

内存存储：数据全部存放在内存中，访问速度极快。
单线程模型：虽然Redis是单线程模型，但通过IO多路复用技术（如epoll、kqueue等），可以在一个线程内处理大量并发连接请求，避免了线程切换带来的开销。
丰富的数据结构：提供了字符串、哈希表、列表、集合、有序集合等多种数据结构，这些数据结构的操作通常在O(1)时间复杂度内完成。

下面是一些体现Redis内存操作和高性能特性的代码示例：

import redis.clients.jedis.Jedis;

public class RedisPerformanceExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);

        // 内存存储演示：设置并获取键值对，由于数据在内存中，所以读写速度快
        jedis.set("key", "value");
        String value = jedis.get("key");
        System.out.println(value);  // 输出：value

        // 高性能演示：使用链表进行快速添加和获取元素
        jedis.rpush("list-key", "item1", "item2", "item3");
        List<String> items = jedis.lrange("list-key", 0, -1);
        System.out.println(items);  // 输出：[item1, item2, item3]

        // 使用有序集合进行快速插入和按分数排序查询
        jedis.zadd("sorted-set-key", 1, "one");
        jedis.zadd("sorted-set-key", 2, "two");
        jedis.zadd("sorted-set-key", 3, "three");

        // 查询分数范围内的成员
        Set<String> sortedMembers = jedis.zrangeByScore("sorted-set-key", 1, 3);
        System.out.println(sortedMembers);  // 输出：[one, two, three]
        
        // 关闭Jedis连接
        jedis.close();
    }
}

在这个示例中，我们利用Jedis库操作Redis服务器。无论是设置和获取简单的键值对，还是对链表或有序集合进行操作，都能体现出Redis基于内存的数据操作以及单线程高并发处理的能力。同时，因为Redis支持多种高效的数据结构，使得它能更好地满足不同场景下的性能需求。

在实际应用中，为了进一步提高Redis的性能，还可以结合以下策略：

合理选择数据结构以匹配业务场景。
利用缓存淘汰策略（如LRU）管理内存资源。
设置合适的持久化策略，平衡性能与数据安全性。
根据需要配置集群模式以实现水平扩展。

三、数据持久化

Redis提供了两种主要的数据持久化方式：RDB（Redis DataBase）和AOF（Append Only File）。下面通过Java代码示例来讲解如何配置和触发这两种持久化策略。

1. Redis RDB持久化（快照）

在Redis服务器端，RDB是默认开启的。在Java应用中，我们通常不需要直接编写代码去触发RDB持久化，因为RDB是由Redis服务根据预设的规则自动执行的。例如，可以通过修改Redis配置文件设置触发条件，如满足特定的写命令次数、时间间隔等。
但若需要在程序中手动触发RDB保存，可以使用SAVE或BGSAVE命令（实际生产环境中推荐使用BGSAVE以避免阻塞主线程），以下是一个模拟调用BGSAVE命令的例子：

import redis.clients.jedis.Jedis;

public class RedisPersistenceExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);

        // 执行业务操作...

        // 模拟触发RDB持久化（实际上不建议在客户端代码中这样做）
        jedis.configSet("save", "");  // 清除已有的保存策略以确保接下来的操作生效
        jedis.save();  // 这将阻塞直到RDB文件创建完成，因此一般不用

        // 或者更推荐的做法是异步保存，但这仍然需要Redis服务器支持并正确配置
        jedis.bgsave();  // 异步保存，不会阻塞当前连接，但在服务器端仍会占用一个工作线程

        // 关闭Jedis连接
        jedis.close();
    }
}

注意：在实际应用中，由于安全性和性能考虑，通常不会在客户端代码中触发RDB持久化。而是在Redis服务器配置文件中设置合理的RDB保存策略，让Redis服务自行管理数据持久化。

2. Redis AOF持久化（日志追加）

AOF持久化是基于命令日志的方式实现的，当有写入操作时，Redis会将命令记录到AOF文件中。AOF持久化的开启和配置也是在Redis服务器端进行的。
同样，在Java客户端中，我们不会直接控制AOF的日志追加行为，而是配置Redis服务器使得它自动根据AOF策略执行相应的持久化动作。然而，我们可以查看和调整AOF相关的配置：

import redis.clients.jedis.Jedis;

public class RedisPersistenceExample {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);

        // 查看当前AOF状态（例如是否开启）
        String appendOnly = jedis.configGet("appendonly").get(1);
        System.out.println("AOF状态: " + appendOnly); 

        // 调整AOF配置（实际操作中应谨慎，并且在配置文件中修改更为合适）
        jedis.configSet("appendonly", "yes");  // 开启AOF持久化
        jedis.configSet("appendfsync", "everysec");  // 设置每秒同步一次磁盘

        // 执行业务操作...

        // 关闭Jedis连接
        jedis.close();
    }
}

再次强调，在实际场景下，对于持久化策略的调整应在Redis服务器端进行，而不是通过客户端代码动态更改。上述代码仅为演示目的，真实环境下应该按照需求配置Redis服务器的配置文件，并确保符合应用程序对数据一致性和性能的要求。

四、主从复制（Replication）

1. 工作原理与角色划分

主节点（Master）：负责处理客户端的写操作，并将这些写命令记录在自己的日志中，然后同步给从节点。
从节点（Slave）：连接到主节点并接收主节点发送的所有写命令，执行相同的命令以保持数据的一致性。从节点可以接受客户端的读请求，从而实现读写分离，减轻主节点的压力。

2. 同步过程

全量同步（Full Resynchronization）：

当一个新的从节点首次连接主节点或主从节点之间发生网络断开时间过长导致断连后重新连接时，会触发全量同步。主节点会生成一个RDB（Redis Database）快照文件并将文件传输给从节点，从节点加载该文件获取当前数据库状态；之后，主节点还会将断开期间积累的写命令发送给从节点执行。

增量同步（Partial Resynchronization）：

在正常情况下，主节点会持续地将写命令通过其输出缓冲区传送给从节点，这种机制称为基于偏移量的复制。每个主从节点都有一个复制偏移量，当从节点连接到主节点时，它会将自己的复制偏移量告知主节点，主节点只需要把从节点未接收到的部分命令发送过去即可。

PSYNC协议：

Redis 2.8版本引入了PSYNC命令来优化主从同步流程，能够支持全量和增量两种模式的平滑切换。

3. 主从配置

要建立主从关系，需要在从节点上配置slaveof命令，指定主节点的IP地址和端口号。
可以设置从节点只读(slave-read-only yes)，这样客户端只能对从节点进行读操作，而不能写入数据。
Redis Sentinel（哨兵）系统可以提供自动化的主从切换功能，确保高可用性。

4. 复制优点

数据备份和容灾：即使主节点出现问题，从节点也能提供服务。
扩展读性能：通过增加从节点，可以分散读取请求，提高系统的整体读性能。
横向扩展：结合Redis Cluster或者代理层可以实现更复杂的分布式部署方案。

5. 注意事项

由于主从复制是异步的，所以在网络延迟或主节点崩溃的情况下，可能存在数据丢失的风险。
如果多个从节点升级为主节点，可能会出现数据不一致的情况，需要使用Redis Sentinel或Raft等一致性算法来管理集群中的主从切换和数据一致性问题。

五、哨兵（Sentinel）系统

Redis Sentinel（哨兵）是Redis官方提供的高可用性解决方案，它是一个分布式系统，用于监控和管理Redis主从集群，并能够自动处理主节点故障转移以及其他相关的任务。以下是Redis Sentinel系统的详细讲解：

1. Sentinel的基本功能

监控：Sentinel系统持续地对Redis主从集群中的各个节点进行健康检查，包括判断节点是否可达、是否在执行主从复制等。
通知：当检测到某个节点出现故障时，Sentinel会通过发布与订阅机制向其他Sentinel节点及客户端发送通知。
自动故障转移：当主节点不可达或下线时，Sentinel会根据预定义的故障转移策略选举出一个从节点升级为主节点，并将其他从节点指向新的主节点，整个过程无需人工干预。
配置提供者：客户端可以连接到Sentinel获取当前集群的状态信息和服务端地址列表，实现自动发现和切换主节点。

2. Sentinel工作原理

多个Sentinel实例组成一个Sentinel系统，共同监视同一组Redis主从集群。
每个Sentinel都会定期对集群中的所有节点进行心跳检测（默认每秒一次），若连续数次未收到响应，则认为该节点主观下线（Sdown）；如果大多数Sentinel也认为该节点不可达，则判定为客观下线（Odown）并触发故障转移流程。
故障转移时，Sentinel会选择一个合适的从节点晋升为主节点，同时更新其余从节点的复制目标以指向新主节点，并在原主节点恢复后将其配置为从节点，重新加入集群。
Sentinel使用Raft一致性算法来保证自身内部对于主节点状态的判断以及故障转移决策的一致性。

3. 配置与部署

在每个Sentinel配置文件中，需要设置要监视的主节点以及其他Sentinel实例的信息。
至少需要三个Sentinel实例才能确保故障转移决策的一致性和容错能力。
客户端可以通过Sentinel服务发现API动态获取主节点的最新地址，实现高可用连接。

4. 注意事项

Redis Sentinel要求所有节点版本一致，且网络环境稳定可靠。
在实际生产环境中，需合理设置各种超时参数以适应不同场景的需求，例如主节点判断下线的时间阈值、故障转移后的等待同步时间等。
对于重要业务场景，建议结合运维手段如监控告警系统、备份策略等进一步提高数据安全性。

六、Redis Cluster（集群）

Redis Cluster是Redis从3.0版本开始提供的原生分布式解决方案，它采用数据分片（Sharding）的方式将数据分散在多个节点上，并通过内部的Gossip协议进行节点间通信和状态管理。以下是Redis Cluster系统的详细讲解：

1. Redis Cluster的主要特点

数据分片：集群中的每个节点都只存储部分数据，通过哈希槽（Slot）的概念将键空间划分为16384个槽位，每个键根据其CRC16散列值对应到一个槽位，然后槽位分配给不同的节点。
高可用性：每个主节点都有至少一个从节点（副本节点），当主节点发生故障时，集群能够自动进行故障转移，由从节点升级为主节点并继续提供服务。
客户端直连：客户端可以直接连接任意节点进行读写操作，节点会处理针对本节点的数据请求，而对于其他节点上的数据请求，节点会代理转发至正确的节点。
节点发现与通信：集群内部使用Gossip协议进行节点之间的状态传播和配置更新，包括新节点加入、节点下线、故障转移等信息。
横向扩展能力：随着数据量的增长或并发访问需求的增加，可以方便地添加新的Redis节点以扩展整个集群的能力。

2. Redis Cluster的工作原理

数据分布：客户端在执行命令前，会对键进行CRC16散列计算得到槽位编号，然后直接向负责该槽位的节点发送命令。若客户端不知道哪个节点负责某个槽位，也可以先连接任意节点询问。
故障检测与恢复：节点之间定期进行心跳检测，当某节点长时间未响应心跳消息，则认为该节点可能已下线，触发选举过程。选举成功后，集群内的其他节点会调整自身配置并将原主节点的从节点提升为主节点。
在线迁移：为了平衡各个节点的压力或者动态调整集群结构，Redis Cluster还支持在线迁移槽位的功能，即在不影响服务的情况下重新分配槽位到其他节点。

3. 配置与部署

创建Redis Cluster需要至少包含三个主节点，每个主节点可有相应的从节点。
使用redis-cli工具或自定义脚本初始化集群，指定各个节点的IP地址和端口号，并分配槽位。

4. 注意事项

Redis Cluster不支持跨槽位的事务和多键操作，如MGET、DEL等，如果这些命令涉及的键不在同一个槽位，将会返回错误。
客户端需兼容Redis Cluster协议才能正确与集群交互，许多主流的Redis客户端库已经实现了对Cluster的支持。
对于大规模集群，运维工作较为复杂，需要关注节点健康状况、合理分配槽位以及避免热点数据问题等。

总之，Redis Cluster为大型应用提供了水平扩展能力和高可用保障，但同时要求开发者在设计数据模型和客户端实现时充分考虑集群特性和限制。

七、Lua脚本支持

Redis支持Lua脚本以增强其功能和性能，Lua脚本在Redis中提供了以下核心特性：

1. 原子操作

Redis通过EVAL、EVALSHA等命令执行Lua脚本，确保脚本中的所有操作作为一个整体执行，中间不会被其他客户端的命令插入。这种原子性有助于实现复杂的业务逻辑，并避免竞态条件。

2. 减少网络开销

使用Lua脚本可以将一系列Redis命令组合成一个脚本，一次性发送到Redis服务器执行，从而减少客户端与服务器之间的网络通信次数，提高性能。

3. 数据一致性

Lua脚本能够处理多个键的操作，同时保证这些键的相关操作按预期顺序执行，增强了数据的一致性。

4. 缓存脚本

Redis会缓存编译后的Lua脚本，使用SHA1哈希值作为唯一标识。后续请求时如果发现缓存中有对应的脚本，则直接使用已编译的版本，进一步提升执行效率。

5. 锁和CAS（Check-and-Set）操作

Lua脚本可以用来模拟锁机制以及更复杂的并发控制策略，比如实现乐观锁或悲观锁。
脚本内部可以读取和修改多个键，然后根据某些条件决定是否执行特定操作，类似于数据库中的CAS操作。

6. 示例与用法

在Redis中执行Lua脚本的基本语法是：

    EVAL script numkeys key [key ...] arg [arg ...]

其中，script是要执行的Lua代码；numkeys表示接下来要传入的键的数量；key [key ...]是指定的键列表；arg [arg ...]则是传递给Lua脚本的参数列表。

示例：假设有一个简单的Lua脚本，用于原子地增加某个键的值并检查结果是否达到阈值：

    local current_value = redis.call('GET', KEYS[1])
    local new_value = tonumber(current_value) + ARGV[1]
    if new_value > tonumber(ARGV[2]) then
        return false
    else
        redis.call('SET', KEYS[1], new_value)
        return true
    end

客户端可以通过如下命令调用这个脚本：

    EVAL "..." 1 myKey 10 100

这个脚本会在原子环境下尝试将myKey的值加10，并判断是否超过100。

7. 注意事项

Lua脚本执行期间，Redis会阻塞其他对同一键的并发操作，因此编写高效且避免长时间运行的脚本非常重要。
脚本中访问的键必须全部由KEYS数组指定，不能动态生成键名。
需要注意Lua语言本身的限制，如内存限制、执行时间限制等，并针对这些限制进行适当的优化和错误处理。

八、发布/订阅（Pub/Sub）机制

Redis的发布/订阅（Publish/Subscribe，简称Pub/Sub）机制是一种消息通信模式，它允许客户端向频道（channel）发送消息以及从频道接收消息。以下是Redis Pub/Sub机制的详细讲解

1. 概念与角色

发布者（Publisher）：通过PUBLISH命令将消息发送到指定的频道。
订阅者（Subscriber）：使用SUBSCRIBE或PSUBSCRIBE命令订阅一个或多个频道，当有消息发布到所订阅的频道时，订阅者会接收到这些消息。

2. 频道和模式订阅

频道：在Redis中，频道是字符串标识符，所有订阅了相同频道的客户端都会收到该频道发布的所有消息。
模式订阅：除了常规的频道订阅外，还可以通过PSUBSCRIBE命令进行模式订阅。模式可以包含通配符，如news.*，这样订阅者将会接收到所有以news.开头的频道的消息。

3. 命令说明

PUBLISH channel message：发布一条消息到指定频道，返回值是订阅该频道并接收此消息的客户端数量。
SUBSCRIBE channel [channel ...]：订阅一个或多个频道，订阅成功后，客户端将进入订阅状态，不再响应其他非订阅相关命令，只接收频道消息。
UNSUBSCRIBE [channel [channel ...]]：取消订阅一个或多个频道，若不指定频道，则取消所有已订阅的频道。
PSUBSCRIBE pattern [pattern ...]：订阅一个或多个符合给定模式的频道，同样进入订阅状态。
PUNSUBSCRIBE [pattern [pattern ...]]：取消模式订阅，如果不指定模式，则取消所有已订阅的模式。

4. 工作流程

客户端执行SUBSCRIBE或PSUBSCRIBE命令开始订阅频道或模式。
发布者通过PUBLISH命令向特定频道发送消息。
Redis服务器检查当前哪些订阅者订阅了这个频道，然后将消息广播给这些订阅者。
订阅者接收到消息，并且可以选择如何处理这些消息。

5. 特性与限制

异步单向通信：发布者不会知道哪些订阅者收到了消息，也不关心订阅者的响应。
持久化：Pub/Sub的消息不会被持久化存储，一旦发布并被接收或者由于没有订阅者而丢失，消息将无法找回。
消息即时性：只有在线并且活跃的订阅者能够接收到消息，离线期间的消息将不会得到补发。

总之，Redis的Pub/Sub机制非常适合构建实时消息系统、事件通知系统等场景，为应用提供了一个简单易用且高性能的消息传递服务。

九、过期策略与淘汰算法

Redis提供了两种主要的过期策略和多种内存淘汰算法，以管理存储在内存中的键值对的有效性和当内存达到最大限制时的数据清理机制。

1. 过期策略

惰性删除（Lazy Deletion）

当客户端尝试访问一个带有过期时间（TTL）的键时，Redis会首先检查这个键是否已经过期。
如果发现键已过期，Redis不会立即删除它，而是执行一次惰性删除操作，即在返回键不存在给客户端的同时将该键从数据库中移除。

定期删除（Scheduled Deletion）

Redis使用一个名为“定时器”的机制，每隔一段时间随机检查一部分设置了过期时间的键，并删除其中已过期的键。
这种定期删除是周期性的，且不是严格意义上的定时任务，目的是为了避免集中处理大量过期键导致服务器负载过大。

2. 内存淘汰算法（Eviction Policies）

当Redis实例使用的内存量达到用户设置的最大内存限制（maxmemory配置项指定）时，Redis需要根据选择的淘汰策略来决定哪些数据应该被删除以腾出空间。
以下是Redis支持的几种内存淘汰算法：

Volatile-LRU (LRU - Least Recently Used)

根据最近最少使用原则淘汰数据。优先删除最近最久未被访问并且设置了过期时间的键。

Allkeys-LRU

同样基于LRU算法，但不区分键是否设置了过期时间，所有键都会参与LRU淘汰。

Volatile-TTL (Least Time To Live)

删除即将过期的键，优先选择剩余生存时间（TTL）最短的键。

Allkeys-random (Random Eviction)

随机选择并删除任意键，不论其是否有过期时间。

Noeviction

不删除任何数据，对于可能导致内存溢出的操作，Redis会返回错误，不允许新写入操作继续进行。

默认情况下，如果没有明确指定淘汰策略，Redis会选择noeviction，这意味着一旦内存满载，将不再接收会导致内存增长的命令请求。开发人员可以根据实际需求通过配置文件或运行时设置来调整淘汰策略

十、安全特性

Redis作为一款高性能的内存数据库，其安全特性主要包括以下几个方面：

1. 认证与授权

密码认证：Redis支持设置访问密码（通过requirepass配置项），客户端在连接时需要提供正确的密码才能执行命令。自Redis 6.0版本起，默认启用了明文传输密码保护功能。
用户管理与ACL（Access Control List）：从Redis 6.0开始，Redis引入了用户管理和ACL系统，可以为不同用户分配不同的权限，如读写权限、键空间限制等，提高了安全性。

2. 网络层面的安全性