redis常用知识汇总（包括 jedis 和 springboot 整合 redis）

王國慶  金牌会员 | 2024-9-9 14:30:54 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 923|帖子 923|积分 2773

先容

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


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

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


  • 默认情况下，redis.conf 文件位于 Redis 安装目录中。您可以在启动 Redis 时指定该文件的位置，例如：
    1. redis-server /path/to/redis.conf
    复制代码
关键配置选项

1. 端口号


  • port：指定 Redis 服务器监听的端口号。默认端口是 6379。
    1. port 6379
    复制代码
2. 绑定地址


  • bind：指定 Redis 只在特定的网络接口上监听。如果您希望 Redis 只担当来自本地的连接，可以将其设置为 127.0.0.1。
    1. bind 127.0.0.1
    复制代码
3. 守护进程模式


  • daemonize：指定 Redis 是否以守护进程的方式运行。如果设置为 yes，Redis 将在后台运行。默认值是 no。
    1. daemonize yes
    复制代码
4. 暗码保护


  • requirepass：为 Redis 设置访问暗码，只有提供精确暗码的客户端才能连接到 Redis 服务器。
    1. requirepass yourpassword
    复制代码
5. RDB 快照文件


  • dbfilename：指定 RDB 快照文件的名称。默认文件名为 dump.rdb。
    1. dbfilename dump.rdb
    复制代码
  • dir：指定 RDB 快照文件的存放目录。
    1. dir /var/lib/redis/
    复制代码
启动和使用 Redis 配置


  • 修改完 redis.conf 后，您可以通过以下下令启动 Redis：
    1. redis-server /path/to/redis.conf
    复制代码
  • 可以通过以下下令检查 Redis 是否精确加载了配置文件：
    1. redis-cli CONFIG GET *
    复制代码
    这会显示当前 Redis 实例的全部配置选项及其值。
    通过这些根本配置，我们可以根据必要自定义 Redis 的行为，以适应不同的应用场景。
  • 使用 AUTH 下令举行身份验证
    1. AUTH your_password
    复制代码
2、Redis 的通用下令

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

  • 键管理：

    • DEL key：删除键。
    • EXISTS key：检查键是否存在。
    • EXPIRE key seconds：为键设置过期时间。
    • KEYS pattern：查找全部符合给定模式的键。
    • TTL key：查看键的剩余生存时间。
    1. DEL mykey
    2. EXISTS mykey
    3. EXPIRE mykey 60
    4. KEYS *pattern*
    5. TTL mykey
    复制代码
3、Redis 的数据结构

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

String 是 Redis 中最根本的数据类型，每个键对应一个字符串类型的值（value）。
常见下令


  • SET：添加或修改一个键值对。例如 SET key value。
  • GET：根据键获取对应的值。例如 GET key。
  • MSET：批量添加多个键值对。例如 MSET key1 value1 key2 value2。
  • MGET：根据多个键获取多个值。例如 MGET key1 key2。
  • INCR：让一个整型的键自增1。例如 INCR counter。
  • INCRBY：让一个整型的键自增指定步长。例如 INCRBY counter 5。
  • INCRBYFLOAT：让一个浮点数的键自增指定步长。例如 INCRBYFLOAT balance 0.5。
  • SETNX：添加一个键值对，前提是这个键不存在，否则不执行。例如 SETNX key value。
  • SETEX：添加一个带有过期时间的键值对。例如 SETEX key 60 value（60秒后过期）。
哈希（Hash ）

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


  • HSET：向 Hash 中添加一个字段和值。例如 HSET key field value。
  • HGET：获取 Hash 中某个字段的值。例如 HGET key field。
  • HMSET：批量添加多个字段和值。例如 HMSET key field1 value1 field2 value2。
  • HMGET：批量获取多个字段的值。例如 HMGET key field1 field2。
  • HGETALL：获取 Hash 中全部的字段和值。例如 HGETALL key。
  • HKEYS：获取 Hash 中的全部字段名。例如 HKEYS key。
  • HVALS：获取 Hash 中的全部值。例如 HVALS key。
  • HINCRBY：让 Hash 中某个字段的值自增指定步长。例如 HINCRBY key field 2。
  • HSETNX：向 Hash 中添加一个字段和值，前提是这个字段不存在。例如 HSETNX key field value。
列表（List）

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


  • LPUSH：在列表头部插入一个元素。例如 LPUSH mylist "world"。
  • RPUSH：在列表尾部插入一个元素。例如 RPUSH mylist "hello"。
  • LPOP：移除并返回列表的第一个元素。例如 LPOP mylist。
  • RPOP：移除并返回列表的最后一个元素。例如 RPOP mylist。
  • LRANGE：获取列表的一个子集。例如 LRANGE mylist 0 -1。
聚集（Set）

聚集是无序的字符串聚集，不答应重复元素。适合用于存储必要唯一性的聚集，如标签、用户脚色等。
常见下令


  • SADD：向聚集添加一个元素。例如 SADD myset "apple"。
  • SREM：移除聚集中的一个元素。例如 SREM myset "apple"。
  • SCARD：返回聚集中元素的个数。例如 SCARD myset。
  • SMEMBERS：获取聚集中的全部元素。例如 SMEMBERS myset。
  • SISMEMBER：判断元素是否在聚集中。例如 SISMEMBER myset "apple"。
有序聚集（Sorted Set）

有序聚集类似于聚集，但每个元素都会关联一个分数，元素按分数举行排序。适合用于排名、评分系统等场景。
常见下令


  • ZADD：向有序聚集添加一个元素，并设置分数。例如 ZADD leaderboard 100 "player1"。
  • ZRANGE：按索引范围获取有序聚集中的元素，可以选择同时返回分数。例如 ZRANGE leaderboard 0 -1 WITHSCORES。
  • ZSCORE：获取有序聚集中指定元素的分数。例如 ZSCORE leaderboard "player1"。
  • 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 的根本用法


  • 引入依赖
    在 Maven 官网获取 Jedis 依赖，并添加到 pom.xml 中：

  • 连接 Redis
    使用 Jedis 连接 Redis 非常简单。以下是一个根本的连接示例：
    1. import redis.clients.jedis.Jedis;
    3. public class RedisExample {
    4.     public static void main(String[] args) {
    5.         // 创建一个 Jedis 对象，并指定 Redis 服务器的地址和端口
    6.         Jedis jedis = new Jedis("localhost", 6379);
    7.         // 输入密码，如果没有修改配置文件修改密码的话，不用写这个
    8.         jedis.auth(“123456”)；
    9.         // 设置 Redis 字符串数据
    10.         jedis.set("mykey", "Hello, Redis!");
    11.         // 获取并打印 Redis 字符串数据
    12.         System.out.println("Redis 存储的字符串: " + jedis.get("mykey"));
    13.         // 关闭 Jedis 连接
    14.         jedis.close();
    15.     }
    16. }
    复制代码
  • 常见操纵
    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)

  • 连接池
  1. import redis.clients.jedis.Jedis;
  2. import redis.clients.jedis.JedisPool;
  3. import redis.clients.jedis.JedisPoolConfig;
  5. public class JedisConnectionFactory {
  6.     private static final JedisPool jedisPool;
  8.     static {
  9.         // 配置连接池
  10.         JedisPoolConfig poolConfig = new JedisPoolConfig();
  11.         poolConfig.setMaxTotal(8);         // 最大连接数
  12.         poolConfig.setMaxIdle(8);          // 最大空闲连接数
  13.         poolConfig.setMinIdle(0);          // 最小空闲连接数
  14.         poolConfig.setMaxWaitMillis(1000); // 最大等待时间
  16.         // 创建连接池对象
  17.         jedisPool = new JedisPool(poolConfig,
  18.                                   "127.0.0.1", // Redis 主机地址
  19.                                   6379,              // Redis 端口号
  20.                                   1000,              // 超时时间
  21.                                   "yourPassword");         // Redis 密码
  22.     }
  24.     public static Jedis getJedis() {        // 通过这个方法在pool中获取jedis
  25.         return jedisPool.getResource();
  26.     }
  27. }
复制代码
参数说明：


  • 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
  1. spring:
  2.   data:
  3.     redis:
  4.       # Redis 服务器的主机地址
  5.       host: localhost
  7.       # Redis 服务器的端口
  8.       port: 6379
  10.       # 配置 Redis 连接池（Lettuce 使用的连接池）
  11.       lettuce:
  12.         pool:
  13.           # 连接池中最大活动连接数
  14.           max-active: 8
  16.           # 连接池中最大空闲连接数
  17.           max-idle: 8
  19.           # 连接池中最小空闲连接数
  20.           min-idle: 0
  22.           # 连接池中最大等待时间
  23.           max-wait: 100ms
  25.       # Redis 数据库索引（默认为 0，Redis 默认提供 16 个数据库）
  26.       database: 0
  28.       # Redis 服务器的密码，用于身份验证
  29.       password: yourpassword
复制代码

  • 配置序列化器
    在 Spring Data Redis 中，序列化和反序列化是处理 Redis 数据的关键部分。序列化是将 Java 对象转换为字节省的过程，以便存储到 Redis 中；反序列化则是将存储在 Redis 中的字节省转换回 Java 对象的过程。Spring Data Redis 提供了多种序列化和反序列化策略，可以根据详细需求举行配置。
配置结果


  • 键: 被序列化成字符串（例如，"myKey"）。
  • 值: 被序列化成 JSON 字符串（例如，{"name":"John","age":30}）。
  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.data.redis.connection.RedisConnectionFactory;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  6. import org.springframework.data.redis.serializer.StringRedisSerializer;
  8. @Configuration
  9. public class RedisConfig {
  11.     @Bean
  12.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
  13.         // 创建RedisTemplate对象
  14.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  16.         // 设置连接工厂
  17.         template.setConnectionFactory(connectionFactory);
  19.         // 使用 StringRedisSerializer 代替 GenericJackson2JsonRedisSerializer
  20.         //  GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
  21.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  22.         GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
  24.         // 设置key的序列化
  25.         template.setKeySerializer(stringRedisSerializer);
  26.         template.setHashKeySerializer(stringRedisSerializer);
  28.         template.setValueSerializer(genericJackson2JsonRedisSerializer);
  29.         template.setHashValueSerializer(genericJackson2JsonRedisSerializer);
  30.         return template;
  31.     }
  32. }
复制代码
2、对数据的操纵

Spring Data Redis 提供了一组 API 用于操控 Redis 数据库。以下是一些常用的 API 及其详细说明：
1. 字符串操纵 (String)


  • 设置值
    1. redisTemplate.opsForValue().set("key", "value");
    复制代码
  • 获取值
    1. String value = (String) redisTemplate.opsForValue().get("key");
    复制代码
  • 设置值（带过期时间）
    1. redisTemplate.opsForValue().set("key", "value", Duration.ofMinutes(10));
    复制代码
  • 删除键
    1. redisTemplate.delete("key");
    复制代码
2. 哈希操纵 (Hash)


  • 设置哈希字段的值
    1. redisTemplate.opsForHash().put("user:1000", "name", "Alice");
    2. redisTemplate.opsForHash().put("user:1000", "email", "alice@example.com");
    复制代码
  • 获取哈希字段的值
    1. String name = (String) redisTemplate.opsForHash().get("user:1000", "name");
    复制代码
  • 获取哈希的全部字段和值
    1. Map<Object, Object> userMap = redisTemplate.opsForHash().entries("user:1000");
    复制代码
3. 列表操纵 (List)


  • 右侧推入列表
    1. redisTemplate.opsForList().rightPush("list", "value1");
    2. redisTemplate.opsForList().rightPush("list", "value2");
    复制代码
  • 左侧推入列表
    1. redisTemplate.opsForList().leftPush("list", "value0");
    复制代码
  • 获取列表的全部元素
    1. List<Object> list = redisTemplate.opsForList().range("list", 0, -1);
    复制代码
  • 弹出列表的右侧元素
    1. Object value = redisTemplate.opsForList().rightPop("list");
    复制代码
4. 聚集操纵 (Set)


  • 添加元素到聚集
    1. redisTemplate.opsForSet().add("set", "value1", "value2");
    复制代码
  • 获取聚集的全部元素
    1. Set<Object> set = redisTemplate.opsForSet().members("set");
    复制代码
  • 移除聚集的元素
    1. redisTemplate.opsForSet().remove("set", "value1");
    复制代码
5. 有序聚集操纵 (Sorted Set)


  • 添加元素到有序聚集
    1. redisTemplate.opsForZSet().add("zset", "value1", 1);
    2. redisTemplate.opsForZSet().add("zset", "value2", 2);
    复制代码
  • 获取有序聚集的全部元素
    1. Set<Object> zset = redisTemplate.opsForZSet().range("zset", 0, -1);
    复制代码
  • 获取有序聚集的元素及其分数
    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. 区别总结

特性RedisTemplateStringRedisTemplate支持的键和值类型支持任何类型（如 String, Object, Integer 等）只支持 String 类型的键和值序列化方式必要手动配置序列化器（可以选择 JSON、JDK 序列化等）默认使用 StringRedisSerializer，无需额外配置适用场景适用于复杂的数据类型，如 Object、JSON 等。适用于简单的 String 类型数据操纵。示例1：

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


示例2：

观察下图有 @Test 注解的代码
  1. // Uesr类
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  6. @Data
  7. @AllArgsConstructor
  8. @NoArgsConstructor
  9. public class User {
  10.     String name;
  11.     Integer age;
  12. }
  14. // 测试
  15. @Autowired
  16.     private RedisTemplate<String, Object> redisTemplate;
  18.     @Autowired
  19.     private StringRedisTemplate stringRedisTemplate;
  20.    
  21. @Test
  22.     void insertUser() {
  23.         User user = new User("world", 1);
  25.         redisTemplate.opsForValue().set("user:1", user);    // 自动将JAVA对象序列换成JSON格式的字符串
  26.         User myuser = (User) redisTemplate.opsForValue().get("user:1"); // 自动反序列化，将JSON格式的字符串转换成JAVA对象
  27.         System.out.println("myuser = " + myuser);
  28.     }
  30. @Test
  31.     void insertUser2() {
  32.         User user = new User("world", 2);
  33.         String jsonUser = JSON.toJSONString(user);  // 手动序列化成JSON格式的字符串
  35.         stringRedisTemplate.opsForValue().set("user:1", jsonUser);
  36.         String str = stringRedisTemplate.opsForValue().get("user:1");
  37.         System.out.println("str = " + str);
  39.         User myuser = JSON.parseObject(str, User.class);    // 手动从JSON格式的字符串转换成JAVA对象
  40.         System.out.println("myuser = " + myuser);
  41.     }
复制代码
下面两张图分别是第一个Test和第二个Test输出的结果


通过上面图可以清晰的看到 RedisTemplate 会自动系列化JSON格式字符串和反序列化成JAVA对象，但是 StringRedisTemplate 都必要手动处理
6、增补

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

fastjson 常见用法
  1. // 将 Java 对象序列化为 JSON 字符串
  2. String jsonString = JSON.toJSONString(user);
  3.         
  4. // 将 JSON 字符串反序列化为 Java 对象
  5. User deserializedUser = JSON.parseObject(jsonString, User.class);
  7. // 创建一个 JSONObject
  8. JSONObject jsonObject = new JSONObject();
  9. jsonObject.put("name", "John");
  10. // 转换成JSON字符串
  11. jsonObject.toString()
  13. // 解析 JSON 字符串
  14. String jsonString = "{"name":"ld","age":18,"city":"ShangHai"}";
  15. JSONObject parsedObject = JSONObject.parseObject(jsonString);
  16. // 获取value, 输出 ld
  17. System.out.println("Name: " + parsedObject.getString("name"));
复制代码
临时更到这里 ... 后面再补

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

王國慶

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表