redis常用知识汇总(包括 jedis 和 springboot 整合 redis)

介绍

Redis 是一个开源的内存数据库,它支持多种数据结构,并且常用于高速缓存、会话管理、消息队列等场景。Redis 的全称是 Remote Dictionary Server,是一种 key-value(键值对)存储系统,能够以极高的性能处理大量数据的读写操作。

Redis 的主要特点:

  1. 基于内存:数据存储在内存中,具有极高的读写速度,适用于实时数据处理和快速响应需求的应用。
  2. 支持持久化:虽然是内存数据库,但 Redis 提供了将数据保存到磁盘的持久化功能,防止数据丢失。
  3. 丰富的数据结构
  4. 数据过期与自动删除:Redis 支持为每个键设置过期时间,到期后自动删除,常用于缓存系统。
  5. 发布/订阅机制:Redis 提供了消息队列功能,可以让客户端订阅和发布消息。
  6. 事务支持:Redis 支持简单的事务机制,允许多个命令作为一个原子操作执行。
  7. 高可用性与分布式:通过 Redis Cluster、Sentinel 机制支持高可用和自动故障转移,能够在分布式环境中使用。

1、Redis 基本配置

Redis 的配置文件通常命名为 redis.conf,存放在 Redis 安装目录中。通过修改该文件,可以自定义 Redis 的各种行为。

配置文件位置

  • 默认情况下,redis.conf 文件位于 Redis 安装目录中。您可以在启动 Redis 时指定该文件的位置,例如:

    redis-server /path/to/redis.conf
    

关键配置选项

1. 端口号

  • port:指定 Redis 服务器监听的端口号。默认端口是 6379

    port 6379
    

2. 绑定地址

  • bind:指定 Redis 只在特定的网络接口上监听。如果您希望 Redis 只接受来自本地的连接,可以将其设置为 127.0.0.1

    bind 127.0.0.1
    

3. 守护进程模式

  • daemonize:指定 Redis 是否以守护进程的方式运行。如果设置为 yes,Redis 将在后台运行。默认值是 no

    daemonize yes
    

4. 密码保护

  • requirepass:为 Redis 设置访问密码,只有提供正确密码的客户端才能连接到 Redis 服务器。

    requirepass yourpassword
    

5. RDB 快照文件

  • dbfilename:指定 RDB 快照文件的名称。默认文件名为 dump.rdb

    dbfilename dump.rdb
    
  • dir:指定 RDB 快照文件的存放目录。

    dir /var/lib/redis/
    

启动和使用 Redis 配置

  • 修改完 redis.conf 后,您可以通过以下命令启动 Redis:

    redis-server /path/to/redis.conf
    
  • 可以通过以下命令检查 Redis 是否正确加载了配置文件:

    redis-cli CONFIG GET *
    

    这会显示当前 Redis 实例的所有配置选项及其值。
    通过这些基本配置,我们可以根据需要自定义 Redis 的行为,以适应不同的应用场景。

  • 使用 AUTH 命令进行身份验证

    AUTH your_password
    

2、Redis 的通用命令

除了与数据结构相关的命令外,Redis 还提供了一些通用命令,用于管理 Redis 实例、数据操作和服务器配置。

  • 键管理

    • DEL key:删除键。
    • EXISTS key:检查键是否存在。
    • EXPIRE key seconds:为键设置过期时间。
    • KEYS pattern:查找所有符合给定模式的键。
    • TTL key:查看键的剩余生存时间。
    DEL mykey
    EXISTS mykey
    EXPIRE mykey 60
    KEYS *pattern*
    TTL mykey
    

3、Redis 的数据结构

Redis 是一个高性能的键值存储系统,支持多种复杂的数据结构。这些数据结构使得 Redis 不仅可以作为简单的缓存,还能满足更多样化的数据存储需求。以下是 Redis 支持的主要数据结构:

字符串(String )

String 是 Redis 中最基本的数据类型,每个键对应一个字符串类型的值(value)。

常见命令
  1. SET:添加或修改一个键值对。例如 SET key value
  2. GET:根据键获取对应的值。例如 GET key
  3. MSET:批量添加多个键值对。例如 MSET key1 value1 key2 value2
  4. MGET:根据多个键获取多个值。例如 MGET key1 key2
  5. INCR:让一个整型的键自增1。例如 INCR counter
  6. INCRBY:让一个整型的键自增指定步长。例如 INCRBY counter 5
  7. INCRBYFLOAT:让一个浮点数的键自增指定步长。例如 INCRBYFLOAT balance 0.5
  8. SETNX:添加一个键值对,前提是这个键不存在,否则不执行。例如 SETNX key value
  9. SETEX:添加一个带有过期时间的键值对。例如 SETEX key 60 value(60秒后过期)。

哈希(Hash )

Hash 是 Redis 中的一种用于存储键值对的集合。它类似于编程语言中的哈希表或字典。一个 Hash 里可以存储多个字段和值,因此非常适合存储对象。

常见命令
  1. HSET:向 Hash 中添加一个字段和值。例如 HSET key field value
  2. HGET:获取 Hash 中某个字段的值。例如 HGET key field
  3. HMSET:批量添加多个字段和值。例如 HMSET key field1 value1 field2 value2
  4. HMGET:批量获取多个字段的值。例如 HMGET key field1 field2
  5. HGETALL:获取 Hash 中所有的字段和值。例如 HGETALL key
  6. HKEYS:获取 Hash 中的所有字段名。例如 HKEYS key
  7. HVALS:获取 Hash 中的所有值。例如 HVALS key
  8. HINCRBY:让 Hash 中某个字段的值自增指定步长。例如 HINCRBY key field 2
  9. HSETNX:向 Hash 中添加一个字段和值,前提是这个字段不存在。例如 HSETNX key field value

列表(List)

列表是一个有序的字符串集合,可以在集合的头部或尾部插入、删除元素。适合用于实现消息队列等功能。

常见命令
  1. LPUSH:在列表头部插入一个元素。例如 LPUSH mylist "world"
  2. RPUSH:在列表尾部插入一个元素。例如 RPUSH mylist "hello"
  3. LPOP:移除并返回列表的第一个元素。例如 LPOP mylist
  4. RPOP:移除并返回列表的最后一个元素。例如 RPOP mylist
  5. LRANGE:获取列表的一个子集。例如 LRANGE mylist 0 -1

集合(Set)

集合是无序的字符串集合,不允许重复元素。适合用于存储需要唯一性的集合,如标签、用户角色等。

常见命令
  1. SADD:向集合添加一个元素。例如 SADD myset "apple"
  2. SREM:移除集合中的一个元素。例如 SREM myset "apple"
  3. SCARD:返回集合中元素的个数。例如 SCARD myset
  4. SMEMBERS:获取集合中的所有元素。例如 SMEMBERS myset
  5. SISMEMBER:判断元素是否在集合中。例如 SISMEMBER myset "apple"

有序集合(Sorted Set)

有序集合类似于集合,但每个元素都会关联一个分数,元素按分数进行排序。适合用于排名、评分系统等场景。

常见命令
  1. ZADD:向有序集合添加一个元素,并设置分数。例如 ZADD leaderboard 100 "player1"
  2. ZRANGE:按索引范围获取有序集合中的元素,可以选择同时返回分数。例如 ZRANGE leaderboard 0 -1 WITHSCORES
  3. ZSCORE:获取有序集合中指定元素的分数。例如 ZSCORE leaderboard "player1"
  4. ZREM:移除有序集合中的一个元素。例如 ZREM leaderboard "player1"

Jedis 是一个用于与 Redis 数据库交互的 Java 客户端库。通过 Jedis,你可以在 Java 应用程序中执行各种 Redis 操作,如增删改查等。Jedis 提供了一组简单易用的 API,使开发者可以轻松地将 Redis 集成到他们的 Java 应用程序中。

" : "的作用

在 Redis 中,冒号 (:) 用于创建键名的层级结构,以帮助组织和管理数据。例如,user:1000:name 表示用户 ID 为 1000 的名字,order:5000:status 表示订单 ID 为 5000 的状态。使用冒号可以让数据看起来像路径一样分层,便于分类和查询。

假设你在存储用户信息和订单信息:

  • user:1000:name -> "Alice"(用户 ID 为 1000 的名字)
  • user:1000:email -> "alice@example.com"(用户 ID 为 1000 的电子邮件)
  • order:2000:status -> "shipped"(订单 ID 为 2000 的状态)

这里,user:order: 是前缀,用于区分不同类型的数据,而冒号 : 用于分隔不同的层级。

4、jedis

Jedis 是一个用于与 Redis 数据库交互的 Java 客户端库。通过 Jedis,你可以在 Java 应用程序中执行各种 Redis 操作,如增删改查等。Jedis 提供了一组简单易用的 API,使开发者可以轻松地将 Redis 集成到他们的 Java 应用程序中。

Jedis 的基本用法

  1. 引入依赖
    Maven 官网获取 Jedis 依赖,并添加到 pom.xml 中:

  2. 连接 Redis
    使用 Jedis 连接 Redis 非常简单。以下是一个基本的连接示例:

    import redis.clients.jedis.Jedis;
    
    public class RedisExample {
        public static void main(String[] args) {
            // 创建一个 Jedis 对象,并指定 Redis 服务器的地址和端口
            Jedis jedis = new Jedis("localhost", 6379);
            // 输入密码,如果没有修改配置文件修改密码的话,不用写这个
            jedis.auth(“123456”);
            // 设置 Redis 字符串数据
            jedis.set("mykey", "Hello, Redis!");
            // 获取并打印 Redis 字符串数据
            System.out.println("Redis 存储的字符串: " + jedis.get("mykey"));
            // 关闭 Jedis 连接
            jedis.close();
        }
    }
    
  3. 常见操作
    Jedis 支持 Redis 的所有基本数据结构和操作。(上面 3、Redis 的数据结构 中的命令 jedis 都有对应的方法)

    • 字符串(String)jedis.set(key, value)jedis.get(key)
    • 哈希(Hash)jedis.hset(key, field, value)jedis.hget(key, field)
    • 列表(List)jedis.lpush(key, value)jedis.lrange(key, start, end)
    • 集合(Set)jedis.sadd(key, member)jedis.smembers(key)
    • 有序集合(Sorted Set)jedis.zadd(key, score, member)jedis.zrange(key, start, end)
  4. 连接池

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

public class JedisConnectionFactory {
    private static final JedisPool jedisPool;

    static {
        // 配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(8);         // 最大连接数
        poolConfig.setMaxIdle(8);          // 最大空闲连接数
        poolConfig.setMinIdle(0);          // 最小空闲连接数
        poolConfig.setMaxWaitMillis(1000); // 最大等待时间

        // 创建连接池对象
        jedisPool = new JedisPool(poolConfig, 
                                  "127.0.0.1", // Redis 主机地址
                                  6379,              // Redis 端口号
                                  1000,              // 超时时间
                                  "yourPassword");         // Redis 密码
    }

    public static Jedis getJedis() {	// 通过这个方法在pool中获取jedis
        return jedisPool.getResource();
    }
}

参数说明:

  • config: JedisPoolConfig 配置对象,用于配置连接池参数。
  • redisHost: Redis 服务器的主机地址。
  • redisPort: Redis 服务器的端口号。
  • 2000: 连接超时时间,单位为毫秒。
  • redisPassword: Redis 服务器的密码。

5、SpringDataRedis

Spring Data Redis 是 Spring Data 生态系统中的一个模块,提供与 Redis 的简便集成。Redis 是一个高性能的内存键值存储,Spring Data Redis 通过提供简单、一致和声明式的方式,简化了与 Redis 的交互,将低级别的 Redis 操作抽象为高级 API 和模板。

1、准备工作

添加依赖

  • spring data redis
  • commons pool

常见配置

  • application.yaml
spring:
  data:
    redis:
      # Redis 服务器的主机地址
      host: localhost

      # Redis 服务器的端口
      port: 6379

      # 配置 Redis 连接池(Lettuce 使用的连接池)
      lettuce:
        pool:
          # 连接池中最大活动连接数
          max-active: 8

          # 连接池中最大空闲连接数
          max-idle: 8

          # 连接池中最小空闲连接数
          min-idle: 0

          # 连接池中最大等待时间
          max-wait: 100ms

      # Redis 数据库索引(默认为 0,Redis 默认提供 16 个数据库)
      database: 0

      # Redis 服务器的密码,用于身份验证
      password: yourpassword
  • 配置序列化器
    Spring Data Redis 中,序列化和反序列化是处理 Redis 数据的关键部分。序列化是将 Java 对象转换为字节流的过程,以便存储到 Redis 中;反序列化则是将存储在 Redis 中的字节流转换回 Java 对象的过程。Spring Data Redis 提供了多种序列化和反序列化策略,可以根据具体需求进行配置。

配置效果

  • : 被序列化成字符串(例如,"myKey")。
  • : 被序列化成 JSON 字符串(例如,{"name":"John","age":30})。
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        // 创建RedisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        // 设置连接工厂
        template.setConnectionFactory(connectionFactory);

        // 使用 StringRedisSerializer 代替 GenericJackson2JsonRedisSerializer
        //  GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();

        // 设置key的序列化
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);

        template.setValueSerializer(genericJackson2JsonRedisSerializer);
        template.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        return template;
    }
}

2、对数据的操作

Spring Data Redis 提供了一组 API 用于操控 Redis 数据库。以下是一些常用的 API 及其详细说明:

1. 字符串操作 (String)

  • 设置值

    redisTemplate.opsForValue().set("key", "value");
    
  • 获取值

    String value = (String) redisTemplate.opsForValue().get("key");
    
  • 设置值(带过期时间)

    redisTemplate.opsForValue().set("key", "value", Duration.ofMinutes(10));
    
  • 删除键

    redisTemplate.delete("key");
    

2. 哈希操作 (Hash)

  • 设置哈希字段的值

    redisTemplate.opsForHash().put("user:1000", "name", "Alice");
    redisTemplate.opsForHash().put("user:1000", "email", "alice@example.com");
    
  • 获取哈希字段的值

    String name = (String) redisTemplate.opsForHash().get("user:1000", "name");
    
  • 获取哈希的所有字段和值

    Map<Object, Object> userMap = redisTemplate.opsForHash().entries("user:1000");
    

3. 列表操作 (List)

  • 右侧推入列表

    redisTemplate.opsForList().rightPush("list", "value1");
    redisTemplate.opsForList().rightPush("list", "value2");
    
  • 左侧推入列表

    redisTemplate.opsForList().leftPush("list", "value0");
    
  • 获取列表的所有元素

    List<Object> list = redisTemplate.opsForList().range("list", 0, -1);
    
  • 弹出列表的右侧元素

    Object value = redisTemplate.opsForList().rightPop("list");
    

4. 集合操作 (Set)

  • 添加元素到集合

    redisTemplate.opsForSet().add("set", "value1", "value2");
    
  • 获取集合的所有元素

    Set<Object> set = redisTemplate.opsForSet().members("set");
    
  • 移除集合的元素

    redisTemplate.opsForSet().remove("set", "value1");
    

5. 有序集合操作 (Sorted Set)

  • 添加元素到有序集合

    redisTemplate.opsForZSet().add("zset", "value1", 1);
    redisTemplate.opsForZSet().add("zset", "value2", 2);
    
  • 获取有序集合的所有元素

    Set<Object> zset = redisTemplate.opsForZSet().range("zset", 0, -1);
    
  • 获取有序集合的元素及其分数

    Set<ZSetOperations.TypedTuple<Object>> zsetWithScores = redisTemplate.opsForZSet().rangeWithScores("zset", 0, -1);
    

3、RedisTemplate 和 StringRedisTemplate

1. RedisTemplate

RedisTemplate 是一个泛型类,能够处理不同类型的键和值。你可以指定键和值的序列化方式,以及 Redis 数据的类型(如 String, Object, Hash, List, Set, ZSet 等)。

主要特点:

  • 泛型支持: 它支持任意类型的键和值,不限于 String,可以是 ObjectInteger、自定义对象等。
  • 序列化方式灵活: 通过设置不同的序列化器,可以对键和值进行序列化和反序列化。

2. StringRedisTemplate

StringRedisTemplateRedisTemplate 的一种特化版本,它专门用于操作 String 类型的键和值。它默认使用 StringRedisSerializer 来对键和值进行序列化和反序列化,因此只处理 String 数据类型。

主要特点:

  • 简化操作: 专注于 String 类型的数据操作,不需要额外配置序列化器,适用于键和值都为 String 类型的场景。
  • 默认序列化方式: 内置 StringRedisSerializer,默认将键和值都序列化为 String

3. 区别总结

特性 RedisTemplate StringRedisTemplate
支持的键和值类型 支持任何类型(如 String, Object, Integer 等) 只支持 String 类型的键和值
序列化方式 需要手动配置序列化器(可以选择 JSON、JDK 序列化等) 默认使用 StringRedisSerializer,无需额外配置
适用场景 适用于复杂的数据类型,如 ObjectJSON 等。 适用于简单的 String 类型数据操作。

示例1:

图一是通过 RedisTemplate 存到 redis 中的 JSON 字符串,图二是通过 StringRedisTemplate 存到redis 中的 JSON 字符串,由于 RedisTemplate 能够实现 自动的反序列化,所以需要存储多余的 @class 信息,会造成内存的浪费。


示例2:

观察下图有 @Test 注解的代码

// Uesr类
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    String name;
    Integer age;
}

// 测试
@Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
@Test
    void insertUser() {
        User user = new User("world", 1);

        redisTemplate.opsForValue().set("user:1", user);    // 自动将JAVA对象序列换成JSON格式的字符串
        User myuser = (User) redisTemplate.opsForValue().get("user:1"); // 自动反序列化,将JSON格式的字符串转换成JAVA对象
        System.out.println("myuser = " + myuser);
    }

@Test
    void insertUser2() {
        User user = new User("world", 2);
        String jsonUser = JSON.toJSONString(user);  // 手动序列化成JSON格式的字符串

        stringRedisTemplate.opsForValue().set("user:1", jsonUser);
        String str = stringRedisTemplate.opsForValue().get("user:1");
        System.out.println("str = " + str);

        User myuser = JSON.parseObject(str, User.class);    // 手动从JSON格式的字符串转换成JAVA对象
        System.out.println("myuser = " + myuser);
    }

下面两张图分别是第一个Test和第二个Test输出的结果


通过上面图可以清楚的看到 RedisTemplate 会自动系列化JSON格式字符串和反序列化成JAVA对象,但是 StringRedisTemplate 都需要手动处理

6、补充

上面用到的JSON处理库是 fastjson2, 可在 maven 官网 下载依赖

fastjson 常见用法

// 将 Java 对象序列化为 JSON 字符串
String jsonString = JSON.toJSONString(user);
        
// 将 JSON 字符串反序列化为 Java 对象
User deserializedUser = JSON.parseObject(jsonString, User.class);

// 创建一个 JSONObject
JSONObject jsonObject = new JSONObject();
jsonObject.put("name", "John");
// 转换成JSON字符串
jsonObject.toString()

// 解析 JSON 字符串
String jsonString = "{\"name\":\"ld\",\"age\":18,\"city\":\"ShangHai\"}";
JSONObject parsedObject = JSONObject.parseObject(jsonString);
// 获取value, 输出 ld
System.out.println("Name: " + parsedObject.getString("name"));

暂且更到这里 ... 后面再补