Redis基础篇

1. 认识Redis#

Redis 是一种开源的高性能键值数据库，全称为 Remote Dictionary Server（远程字典服务器）。它通常用作缓存、消息队列、分布式锁等场景中的核心组件，同时也支持丰富的数据结构和多种高级特性。

Redis特点：

1. 内存存储： Redis 将数据存储在内存中，读写速度极快，适合对性能要求较高的场景。
2. 丰富的数据结构： Redis 提供了多种数据结构，满足不同的使用需求：
3. 持久化支持：
   • RDB (Redis Database)： 定期生成快照保存到磁盘。
   • AOF (Append Only File)： 将每次写操作追加到日志中，提供更高的数据安全性。
4. 主从复制与高可用： Redis 支持主从复制，可通过 Sentinel 或 Cluster 模式实现高可用和水平扩展。
5. 轻量级与高并发： Redis 是单线程的，但由于采用了高效的 I/O 多路复用机制，性能非常优越。

1.1 安装Redis#

1.1.1 常规安装#

Ubuntu：

1. 更新系统软件包

   1
   sudo apt update

2. 安装 Redis

   1
   sudo apt install redis-server -y

3. 配置文件，默认位于/etc/redis/redis.conf（具体配置信息可参考后文docker安装部分）

4. 启动 Redis

   1
   sudo systemctl start redis-server

5. 设置开机自启

   1
   sudo systemctl enable redis-server

6. 验证 Redis 运行状态

   1
   # 查看状态
   2
   sudo systemctl status redis-server
   3
   
   4
   # 进入 Redis
   5
   redis-cli
   6
   
   7
   # 尝试ping
   8
   127.0.0.1:6379> ping
   9
   PONG

Centos：

1. 更新系统软件包

   1
   sudo yum update -y

2. 安装 Redis

   1
   # 首先，安装 EPEL 仓库
   2
   sudo yum install epel-release -y
   3
   
   4
   # 安装 Redis
   5
   sudo yum install redis -y

3. 配置文件，默认位于/etc/redis/redis.conf（具体配置信息可参考后文docker安装部分）

4. 启动 Redis

   1
   sudo systemctl start redis-server

5. 设置开机自启

   1
   sudo systemctl enable redis-server

6. 验证 Redis 运行状态

   1
   # 查看状态
   2
   sudo systemctl status redis-server
   3
   
   4
   # 进入 Redis
   5
   redis-cli
   6
   
   7
   # 尝试ping
   8
   127.0.0.1:6379> ping
   9
   PONG

1.1.2 Docker创建Redis容器#

1. 拉取docker镜像

   1
   docker pull redis

2. 在本地某个位置创建以下内容

   1
   # 以/docker/redis为例
   2
   mkdir -p /docker/redis
   3
   mkdir -p /docker/redis/data
   4
   touch /docker/redis/redis.conf

3. 编辑redis.conf配置文件

   1
   # Redis配置文件
   2
   
   3
   # Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程
   4
   daemonize no
   5
   
   6
   # 指定Redis监听端口，默认端口为6379
   7
   port 6379
   8
   
   9
   # 绑定的主机地址，不要绑定容器的本地127.0.0.1地址，因为这样就无法在容器外部访问
   10
   bind 0.0.0.0
   11
   
   12
   #需要密码则打开
   13
   requirepass 123456
   14
   
   15
   # 持久化
   16
   appendonly yes
   17
   
   18
   slave-read-only no

4. 启动容器

   1
   docker run -d \
   2
     --name redis \
   3
     -p 6379:6379 \
   4
     -v /docker/redis/redis.conf:/etc/redis/redis.conf \
   5
     -v /docker/redis/data:/data \
   6
     redis \
   7
     redis-server /etc/redis/redis.conf

5. 进入 Redis 容器

   1
   docker exec -it redis redis-cli

6. 若已配置密码，则需使用以下命令进行验证才能使用

   1
   AUTH password

1.2 Redis客户端#

1.2.1 命令行客户端#

使用如下命令即可进入Redis命令行客户端

1
redis-cli -h 127.0.0.1 -p 6379 -a 123456

• -h：地址
• -p：端口
• -a：密码

或不输入密码，在进入客户端后用如下命令进行身份验证

1
AUTH [password]

1.2.2 图形化界面#

可以使用这个开源图形化页面客户端

效果图如下所示：

2. Redis命令#

Redis中的常见数据结构：

TIP

Redis官方文档中包含对所有命令的详细介绍，在后续的内容中可以结合官方文档深入学习

2.1 Redis通用命令#

1. KEYS 命令#

作用： KEYS 命令用于查找与指定模式匹配的所有键。

语法：KEYS pattern

参数说明：

• pattern是匹配模式，可以包含通配符：
  • *：匹配任意多个字符。
  • ?：匹配单个字符。
  • [abc]：匹配任意一个指定字符。

示例：

1
SET key1 value1
2
SET key2 value2
3
SET hello value3
4
KEYS k*    # 返回 ["key1", "key2"]
5
KEYS h?llo # 返回 ["hello"]

注意：

• KEYS 命令扫描所有键，性能较差，不建议在生产环境中频繁使用。

2. DEL 命令#

作用： DEL 命令用于删除一个或多个键。如果键不存在，则忽略。

语法： DEL key [key ...]

示例：

1
SET key1 value1
2
SET key2 value2
3
DEL key1 key2   # 返回 2，表示删除了两个键
4
DEL key3        # 返回 0，表示 key3 不存在

3. EXISTS 命令#

作用： EXISTS 用于检查一个或多个键是否存在。

语法：EXISTS key [key ...]

返回值：

• 如果提供一个键，则返回 1（存在）或 0（不存在）。
• 如果提供多个键，则返回存在的键数。

示例：

1
SET key1 value1
2
EXISTS key1     # 返回 1
3
EXISTS key2     # 返回 0
4
EXISTS key1 key2 # 返回 1，表示 key1 存在

4. EXPIRE 命令#

作用： EXPIRE 命令用于为键设置过期时间（以秒为单位）。当时间到了后，键会被自动删除。

语法：EXPIRE key seconds

返回值：

• 返回 1：设置成功。
• 返回 0：键不存在或无法设置过期时间（例如永久键）。

示例：

1
SET key1 value1
2
EXPIRE key1 10  # 设置 key1 的过期时间为 10 秒

相关命令：

• PEXPIRE key milliseconds：设置以毫秒为单位的过期时间。

5. TTL 命令#

作用： TTL 命令返回键的剩余生存时间（以秒为单位）。

语法：TTL key

返回值：

• 正整数：剩余的过期时间（秒）。
• -1：键存在，但没有设置过期时间。
• -2：键不存在。

示例：

1
SET key1 value1
2
EXPIRE key1 10
3
TTL key1       # 返回 10（时间会随着查询减少）
4
TTL key2       # 返回 -2，表示 key2 不存在

相关命令：

• PTTL key：返回以毫秒为单位的剩余时间。

2.2 Key的层级结构#

1. Key 的基本结构#

• 数据类型： Redis 的键是二进制安全的字符串。这意味着键可以包含任何字节，甚至是二进制数据。
• 长度限制： 单个键的最大长度为 512 MB，但实践中通常不会使用如此长的键，因为长键会影响性能。
• 字符限制： 键可以包含任何字符，包括空格、特殊字符等。

2. Key 的命名规则#

Redis 对键的命名没有严格的规则，但为了方便管理和性能优化，通常遵循一些约定和最佳实践：

• 命名规范：
  • 使用清晰、描述性的命名。
  • 避免使用过长的键。
  • 避免键的命名冲突。
• 分层命名（推荐）：
  • 通常使用冒号 : 作为分隔符，形成分层结构。
  • 示例：user:1001:profile、order:2024:details。
  • 这种命名方式便于通过命令（如 SCAN 或 KEYS）按前缀过滤相关键。

3. Key 的最佳实践#

1. 短而有意义的命名：
   • 键名应该尽量短小，但足够有意义，避免浪费内存。
   • 示例：用 user:1001 代替冗长的 application:user:id:1001。
2. 避免通配符查询：
   • 避免在生产环境中使用 KEYS 命令，因为它是 $O(N)$ 的操作，可能导致性能问题。
   • 推荐使用 SCAN 命令逐步遍历。
3. 统一命名规则：
   • 采用固定的前缀和分隔符，以便于组织和查找。
   • 示例：appname:module:identifier。
4. 设置过期时间（TTL）：
   • 对临时性数据设置过期时间，减少内存占用。
   • 示例：SET key value EX 60 设置 60 秒过期。
5. 避免大规模键值冲突：
   • 避免使用通用名称，如 key1、temp。

4. Key 的使用场景#

根据业务需求，键的命名可以体现其用途。例如：

• 用户信息：user:1001:info，user:1001:orders
• 缓存数据：cache:product:1234
• 会话信息：session:abc123

5. Redis Key 的注意事项#

1. 避免过多的唯一键：如果键太多且唯一性过强（如时间戳），会导致内存占用增加和管理复杂性提升。
2. 警惕键空间膨胀：避免生成大量无用键，例如动态生成的临时键。

2.3 String类型常见命令#

String 是最基本的数据类型，用于存储简单的键值对（key-value）。它是 Redis 中最常用的数据类型，可以存储字符串、整数、浮点数等各种数据。

2.4 Hash类型常见命令#

Hash 是一种键值对集合，用于存储多个字段（field）及其对应的值（value）。

Hash的结构示意图：

常用命令如下所示：

2.5 List类型常见命令#

List 是一种有序的数据结构，类似于传统编程语言中的链表或数组。它由多个元素组成，支持元素的插入、删除、访问和查询操作。Redis 中的 List 是双向链表，因此它能够高效地在列表的两端进行操作。

2.6 Set类型常见命令#

Set 是一种无序的数据结构，它用于存储多个不重复的元素。Set 是一种集合类型，具有高效的插入、删除和查找操作，特别适用于那些不关心元素顺序、但需要保证唯一性的数据集合。

2.7 ZSet（Sorted Set）类型常见命令#

Sorted Set（有序集合）是一种非常强大的数据结构，结合了 Set 和 List 的特点。与普通的 Set 不同，Sorted Set 中的元素是有序的，每个元素除了一个值（member）外，还关联一个分数（score）。元素的排序是根据分数来进行的，分数可以是浮点数。

3. Redis的Java客户端#

以下是一些常用的客户端总结：

3.1 Jedis#

项目地址：

使用方法：#

1. 引入maven坐标

   1
   <dependency>
   2
       <groupId>redis.clients</groupId>
   3
       <artifactId>jedis</artifactId>
   4
       <version>5.2.0</version>
   5
   </dependency>

2. 建立连接

   1
   Jedis jedis = new Jedis("localhost", 6379);
   2
   jedis.auth("password");
   3
   jedis.select(0);

3. 使用

   1
   jedis.set("name", "zhangsan");
   2
   System.out.println(jedis.get("name"));

4. 释放资源

   1
   if (jedis != null) {
   2
       jedis.close();
   3
   }

Jedis连接池#

由于Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此推荐使用Jedis连接池代替Jedis的直连方式。

以下是一个基于Jedis连接池的实践：

1
public class JedisFactory {
2
    // 创建 JedisPool 实例
3
    private static JedisPool jedisPool;
4

5
    // 静态代码块初始化连接池
6
    static {
7
        // 配置连接池参数
8
        JedisPoolConfig poolConfig = new JedisPoolConfig();
9
        poolConfig.setMaxTotal(128);  // 最大连接数
10
        poolConfig.setMaxIdle(64);    // 最大空闲连接数
11
        poolConfig.setMinIdle(16);    // 最小空闲连接数
12
        poolConfig.setTestOnBorrow(true);  // 获取连接时进行有效性检查
13
        poolConfig.setTestOnReturn(true);  // 归还连接时进行有效性检查
14
        poolConfig.setMaxWaitMillis(3000);  // 最大等待时间，单位毫秒
15

16
        // 初始化 Jedis 连接池
17
        jedisPool = new JedisPool(config, "localhost", 6379, 1000, "password");
18
    }
19

20
    // 提供 Jedis 连接
21
    public static Jedis getJedis() {
22
        return jedisPool.getResource();
23
    }
24

25
    // 关闭连接池
26
    public static void closePool() {
27
        if (jedisPool != null) {
28
            jedisPool.close();
29
        }
30
    }
31
}

3.2 Spring Data Redis#

Spring Data Redis 是 Spring Framework 的一个子项目，旨在简化 Redis 数据库的访问。它提供了对 Redis 的高层次抽象和方便的操作方式，使开发者能够更高效地使用 Redis 的功能。

核心功能#

1. RedisTemplate 提供操作接口
   • Spring Data Redis 提供了 RedisTemplate 和 StringRedisTemplate，以便对 Redis 数据库进行操作。
   • 它封装了对 Redis 的低级命令，支持各种数据结构（如字符串、哈希、列表、集合、有序集合等）的操作。
2. 支持多种 Redis 数据结构
   • String ：简单的键值对存储。
   • **Hash **：适合存储对象或关联数据。
   • List ：适合处理任务队列。
   • Set 和 Sorted Set ：用于无序和有序集合存储。
   • Pub/Sub：支持发布/订阅消息模式。
3. 连接池管理
   • Spring Data Redis 默认支持多种 Redis 连接池实现（如 Jedis、Lettuce）。
4. 事务支持
   • 支持 Redis 的事务操作，确保一组命令的原子性执行。
5. 缓存集成
   • Spring Data Redis 集成了 Spring 的缓存抽象（@Cacheable、@CacheEvict 等注解），可以将 Redis 用作高效的缓存存储。
6. 支持 Redis 哨兵和集群
   • 对 Redis Sentinel 和 Redis Cluster 提供了良好的支持，以实现高可用性和分布式部署。

RedisTemplate 的常用接口#

使用方法#

1. 在Spring项目中引入Maven依赖

   1
   <!-- Spring Boot Redis starter -->
   2
   <dependency>
   3
       <groupId>org.springframework.boot</groupId>
   4
       <artifactId>spring-boot-starter-data-redis</artifactId>
   5
   </dependency>
   6
   <!-- 连接池 -->
   7
   <dependency>
   8
       <groupId>org.apache.commons</groupId>
   9
       <artifactId>commons-pool2</artifactId>
   10
   </dependency>
   11
   <!-- 序列化器 -->
   12
   <dependency>
   13
       <groupId>com.fasterxml.jackson.core</groupId>
   14
       <artifactId>jackson-databind</artifactId>
   15
   </dependency>

2. 在application.yml中配置Redis的信息

   1
   spring:
   2
     data:
   3
       redis:
   4
         host: localhost
   5
         port: ${redis.port}
   6
         password: ${redis.password}
   7
         database: ${redis.database}
   8
         lettuce:
   9
           pool:
   10
             max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
   11
             max-idle: 8   # 连接池中的最大空闲连接
   12
             min-idle: 0   # 连接池中的最小空闲连接
   13
             max-wait: 100 # 连接池最大阻塞等待时间（使用负值表示没有限制）

3. 自定义 RedisTemplate 配置（默认的序列化器可读性差且内存占用大）

   1
   @Configuration
   2
   public class RedisConfig {
   3
   
   4
       @Bean
   5
       public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
   6
           RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
   7
           redisTemplate.setConnectionFactory(connectionFactory);
   8
   
   9
           // 设置 Key 和 HashKey 的序列化方式
   10
           redisTemplate.setKeySerializer(new StringRedisSerializer());
   11
           redisTemplate.setHashKeySerializer(new StringRedisSerializer());
   12
   
   13
           // 设置 Value 和 HashValue 的序列化方式
   14
           redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
   15
           redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
   16
   
   17
           redisTemplate.afterPropertiesSet();
   18
           return redisTemplate;
   19
       }
   20
   }

4. 使用，以操作String类型为例

   1
   @Service
   2
   public class RedisStringService {
   3
   
   4
       @Autowired
   5
       private RedisTemplate<String, Object> redisTemplate;
   6
   
   7
       // 保存字符串
   8
       public void saveString(String key, String value) {
   9
           redisTemplate.opsForValue().set(key, value);
   10
       }
   11
   
   12
       // 获取字符串
   13
       public String getString(String key) {
   14
           return (String) redisTemplate.opsForValue().get(key);
   15
       }
   16
   
   17
       // 设置过期时间
   18
       public void setExpire(String key, long timeout) {
   19
           redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
   20
       }
   21
   }

优化使用#

通过上面这种使用方式，程序会自动完成序列化和反序列化操作，这样很便于我们使用。但是这种方法仍然有一定的弊端，如下图所示，这是一个自定义类，为了实现自动序列化和反序列化，它会将类的基本信息也一并存入。当数据量较大时，就会产生过多的占用，浪费系统资源。因此，最好手动序列化和反序列化。

要实现手动序列化有很多可选方案，例如fastjson，ObjectMapper等。下面以ObjectMapper为例，介绍如何使用

1
@Autowired
2
private StringRedisTemplate stringRedisTemplate;
3

4
private final ObjectMapper objectMapper = new ObjectMapper();
5

6
    @Test
7
    void testStringRedisTemplate() {
8
        Person person = new Person("张三", 25);
9
        try {
10
            stringRedisTemplate.opsForValue().set("exercise:person:3", objectMapper.writeValueAsString(person));
11
            String personJson = stringRedisTemplate.opsForValue().get("exercise:person:3");
12
            Person person1 = objectMapper.readValue(personJson, Person.class);
13
            System.out.println(person1.getName());
14
            System.out.println(person1.getAge());
15
        } catch (Exception e) {
16
            System.out.println("Error");
17
        }
18
    }

从下图中可以看到，通过这种方式存取的对象就不会包含类的信息。在后续可以进行进一步的封装以更好的使用。