场景

当我们需要存入一个String类型的键值对到Redis中，如下：
（缓存接口）

1. public interface CacheService {
   
2. 
   
3.     /**
   
4.      * 添加一个字符串键值对
   
5.      * @param key 键
   
6.      * @param value 值
   
7.      */
   
8.     void setString(String key, String value);
   
9. }

复制代码

（Redis实现）

1. import com.hezy.service.CacheService;
   
2. import org.springframework.beans.factory.annotation.Autowired;
   
3. import org.springframework.data.redis.core.RedisTemplate;
   
4. import org.springframework.stereotype.Service;
   
5. 
   
6. @Service
   
7. public class RedisServiceImpl implements CacheService {
   
8. 
   
9.     @Autowired
   
10.     private RedisTemplate<String, String> redisTemplate;
    
11. 
    
12. 
    
13.     @Override
    
14.     public void setString(String key, String value) {
    
15.         redisTemplate.opsForValue().set(key, value);
    
16.     }
    
17. }

复制代码

（使用）

1. import com.hezy.service.impl.RedisServiceImpl;
   
2. import org.junit.jupiter.api.Test;
   
3. import org.springframework.beans.factory.annotation.Autowired;
   
4. import org.springframework.boot.test.context.SpringBootTest;
   
5. 
   
6. @SpringBootTest
   
7. public class RedisServiceImplTest {
   
8. 
   
9.     @Autowired
   
10.     private RedisServiceImpl redisService;
    
11. 
    
12.     @Test
    
13.     public void test1() {
    
14.         String key = "content";
    
15.         String value = "这是一段分非常大非常大的字符串…………………………非常大";
    
16.         redisService.setString(key, value);
    
17.     }
    
18. }

复制代码

（查看Redis）

有时候，我们存入的字符串可能过长，过大，有可能来自于一个大对象的序列化。这时候存入的key-value，会造成value过大，会触发一些预警。
可以采用我下面这种分段存储的方法。

优化

思路：将字符串分段，每一段生成一个key，然后将这些分段key再用Redis的List类型存储；获取时就先获取这些分段key，再循环去get对应的字符串，拼接起来就是完整的字符串。
如下：分段存，增加一个参数，设置每段字符串的长度
（缓存接口）

1.     /**
   
2.      * 分段存储
   
3.      * @param key 键
   
4.      * @param value 值
   
5.      * @param chunkSize 每个分段大小
   
6.      */
   
7.     void setStrSub(String key, String value, int chunkSize);

复制代码

（Redis实现）

1.     @Override
   
2.     public void setStrSub(String key, String value, int chunkSize) {
   
3.         // 将value，按照length，分成多个部分
   
4.         int totalChunks = (int) Math.ceil((double) value.length() / chunkSize);
   
5.         // 定义一个分段数据key集合
   
6.         List<String> subKeys = new ArrayList<>(totalChunks);
   
7.         // 将字符串分成多段
   
8.         for (int i = 0; i < totalChunks; i++) {
   
9.             // 计算分段起止位置
   
10.             int startIndex = i * chunkSize;
    
11.             int endIndex = Math.min(startIndex + chunkSize, value.length());
    
12.             // 获取对应分段数据
    
13.             String chunkValue = value.substring(startIndex, endIndex);
    
14.             // 拼接分段key
    
15.             String subKey = key + "_" + i;
    
16.             // 存储分段数据
    
17.             setString(subKey, chunkValue);
    
18.             // 将分段key添加到集合
    
19.             subKeys.add(subKey);
    
20.         }
    
21.         // 分段key添加到集合
    
22.         setList(key, subKeys);
    
23.     }

复制代码

（添加一个集合到Redis）

1.     @Override
   
2.     public void setList(String key, List value) {
   
3.         redisTemplate.opsForList().rightPushAll(key, value);
   
4.     }

复制代码

启动，测试

1.     @Test
   
2.     public void test2() {
   
3.         String key = "content";
   
4.         String value = "这是一段分非常大非常大的字符串…………………………非常大";
   
5.         redisService.setStrSub(key, value, 5);
   
6.     }

复制代码

查看Redis

然后，要取数据，也很简单；
（缓存接口）

1.     /**
   
2.      * 获取字符串（分段）
   
3.      * @param key
   
4.      * @return
   
5.      */
   
6.     String getStrSub(String key);

复制代码

（Redis实现）

1.     @Override
   
2.     public String getStrSub(String key) {
   
3.         // 先把分段key获取出来
   
4.         List<String> list = getList(key);
   
5.         // 字符串拼接，用StringBuilder，线程安全
   
6.         StringBuilder stringBuilder = new StringBuilder();
   
7.         for (String subKey : list) {
   
8.             String subValue = getString(subKey);
   
9.             // 这里要跳过null，不然最后输出会把null转为字符串
   
10.             if (subValue == null) {
    
11.                 continue;
    
12.             }
    
13.             stringBuilder.append(subValue);
    
14.         }
    
15.         // 如果没有数据，返回null
    
16.         return "".contentEquals(stringBuilder) ? null : stringBuilder.toString();
    
17.     }

复制代码

（Redis获取一个List）

1.     @Override
   
2.     public List getList(String key) {
   
3.         return redisTemplate.opsForList().range(key, 0, -1);
   
4.     }

复制代码

（使用）

1.     @Test
   
2.     public void test3() {
   
3.         String content = redisService.getStrSub("content");
   
4.         System.out.println(content);
   
5.     }

复制代码

（打印）

总结

本文介绍了Redis分段存储一个大键值对（String）的一种方式，看下来，实现并不复杂。使用上也可以很方便，可以考虑把分段的存取和普通的存取都兼容起来，这样对于使用者，只需要加一个参数（分段大小）。
到此这篇关于分段存储Redis键值对的方法详解的文章就介绍到这了,更多相关Redis键值对分段存储内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：https://www.jb51.net/database/334834goy.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！