介绍

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 -> "[email protected]"（用户 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", "[email protected]");
  

• 获取哈希字段的值

  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，可以是 Object、Integer、自定义对象等。
• 序列化方式灵活: 通过设置不同的序列化器，可以对键和值进行序列化和反序列化。

2. StringRedisTemplate

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

主要特点：

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

3. 区别总结

示例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输出的结果

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"));

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