00、RedisTemplate使用

于 2024-08-25 18:09:48 发布
阅读量445 收藏 15
点赞数 9
分类专栏： Redis 文章标签： java 前端 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012011912/article/details/141532341
版权

一、opsForValue()

1、set(K var1, V var2)

新增一个字符串类型的值

  • var1是key
  • var2是值
  • key存在就覆盖，不存在新增
redisTemplate.opsForValue().set("BBB","你好");
2、set(K key, V value, Duration timeout)

新增一个字符串类型的值，同时设置过期时间

  • var1是key
  • var2是值
  • key存在就覆盖，不存在新增
redisTemplate.opsForValue().set("BBB","你好", Duration.ofMinutes(1));
3、set(K var1, V var2, long var3, TimeUnit var5)

新增一个字符串类型的值，同时设置过期时间

  • var1是key
  • var2是值
  • key存在就覆盖，不存在新增
redisTemplate.opsForValue().set("BBB","你好", 1, TimeUnit.MINUTES);
4、append(K var1, String var2)

给对应的key追加value，key不存在直接新增

redisTemplate.opsForValue().append("AAA", "哈哈哈");
5、set(K key1, V v1, long v2)

将key的值从下标1往后替换为新的value,key不存在相当于新增

redisTemplate.opsForValue().set("BBB","您的",1);
6、setBit(K var1, long var2, boolean var4)

key键对应的值value对应的ascii码,在offset的位置(从左向右数)变为value

redisTemplate.opsForValue().setBit("BBB", 0, true);
7、getBit(K var1, long var2)

判断指定的位置ASCII码的bit位是否为1

redisTemplate.opsForValue().getBit("BBB", 1);
8、setIfAbsent(K var1, V var2);

如果key不存在则新增，key存在不做任何操作

redisTemplate.opsForValue().setIfAbsent("BBB", "好的");
9、setIfAbsent(K var1, V var2, long var3, TimeUnit var5)

如果key不存在则新增，同时设置过期时间，key存在不做任何操作。

redisTemplate.opsForValue().setIfAbsent("AAA", "好的", 1, TimeUnit.MINUTES);
10、setIfAbsent(K key, V value, Duration timeout)

如果key不存在则新增，同时设置过期时间，key存在不做任何操作。

redisTemplate.opsForValue().setIfAbsent("BBB", "好的", Duration.ofMinutes(1));
11、setIfPresent(K var1, V var2)

如果key存在则修改，key不存在不做任何操作

redisTemplate.opsForValue().setIfPresent("BBB", "好的");
12、setIfPresent(K var1, V var2, long var3, TimeUnit var5)

如果key存在则修改，同时设置过期时间，key不存在不做任何操作。

redisTemplate.opsForValue().setIfPresent("BBB", "好的",1, TimeUnit.MINUTES);
13、setIfPresent(K key, V value, Duration timeout)

如果key存在则修改，同时设置过期时间，key不存在不做任何操作

redisTemplate.opsForValue().setIfPresent("BBB", "好的",Duration.ofMinutes(1));
14、getAndSet(K var1, V var2)

获取key对应的值，如果key存在则修改,不存在则新增

redisTemplate.opsForValue().getAndSet("BBB", "心情");
15、increment(K var1)

以增量的方式（默认增量为1）将long值存储在变量中(value为其他类型时报错)，返回最新值

redisTemplate.opsForValue().increment("AAA");
16、increment(K var1, long var2)

以指定增量的方式将Long值存储在变量中，返回最新值

redisTemplate.opsForValue().increment("AAA",2);
17、increment(K var1, double var2)

以指定增量的方式将Double值存储在变量中，返回最新值

redisTemplate.opsForValue().increment("AAA", 3.2);
18、decrement(K var1)

以递减的方式（默认为1）将long值存储在变量中(value为其他类型时报错，Double也不行，只能为Long)，返回最新值

redisTemplate.opsForValue().decrement("AAA");
19、decrement(K var1, long var2)

以指定递减量递减的方式将long值存储在变量中(value为其他类型时报错，Double也不行，只能为Long)，返回最新值

redisTemplate.opsForValue().decrement("AAA",2);
20、size(K var1)

获取指定key对应值的长度

redisTemplate.opsForValue().size("BBB");
21、get(Object var1)

获取指定的key对应的值

String BBB = (String) redisTemplate.opsForValue().get("BBB");
System.out.println("BBB = " + BBB);
22、get(K var1, long var2, long var4)

获取key指定下标之间对应的值

String BBB = redisTemplate.opsForValue().get("BBB",0,1);
System.out.println("BBB = " + BBB);
23、multiSet(Map<? extends K, ? extends V> var1)

将map中的key分别作为不同的key存到Redis中（见截图）

  • 若某个key已经存在则替换为新值，其他不存在的则新增
  • map中5个key，3个存在Redis中，2个没有，结果就是3个值被修改，2个新增
Map valueMap = new HashMap();
valueMap.put("valueMap1","aa");
valueMap.put("valueMap2","bb");
valueMap.put("valueMap3","cc");
valueMap.put("valueMap4","ee");
redisTemplate.opsForValue().multiSet(valueMap);

image-20211027155553135

24、multiSetIfAbsent(Map<? extends K, ? extends V> var1)

将map中的key分别作为不同的key存到Redis中（见截图）

  • 若某个key已经存在不做修改，不存在的则新增（map中的key在Redis中都不存在时才新增）
  • map中5个key，3个存在Redis中，2个没有，结果就是不会新增不会修改，若map中5个key，5个都不存在Redis中，则新增
Map valueMap = new HashMap();
valueMap.put("valueMap1","aa");
valueMap.put("valueMap2","bb");
valueMap.put("valueMap3","cc");
valueMap.put("valueMap4","ee");
valueMap.put("valueMap5","ff");
redisTemplate.opsForValue().multiSetIfAbsent(valueMap);
25、multiGet(Collection var1)

根据集合中的key取出对应的value值

List paraList = new ArrayList();
paraList.add("valueMap1");
paraList.add("valueMap2");
paraList.add("valueMap3");
List list = redisTemplate.opsForValue().multiGet(paraList);
26、拓展

存入JSON字符串（对象集合）

对象和对象集合一定要转成JSON存放，容易解析

List<MPEntity> list = mpService.list();
redisTemplate.opsForValue().set("BBB", JSON.toJSONString(list));

image-20211028150903825

  • 获取解析JSON字符串

    String bbb = (String) redisTemplate.opsForValue().get("BBB");
List<MPEntity> mpEntities = JSON.parseArray(bbb, MPEntity.class);
System.out.println("mpEntities = " + mpEntities);

    image-20211028151028443

二、opsForValue()

1、leftPush(K key, V value)

从集合左边插入值

  • 值重复无影响
  • 先进先出
redisTemplate.opsForList().leftPush("list","a");
redisTemplate.opsForList().leftPush("list","a");
redisTemplate.opsForList().leftPush("list","b");

image-20211028161003964

2、leftPush(K key, V v, V v1)

从集合左边开始在v值后边插入新值v1

  • 在集合中查找v值
  • 有多个v值时，从左边开始查到第一个v值即可（也就是最后插入的v值，靠左的v值），然后在v值左边插入新值v1
  • 不存在v时，不插入新值v1
redisTemplate.opsForList().leftPush("list", "a", "e");

image-20211028162709885

3、leftPushAll(K key, Collection values)

从左边批量插入新值

List<String> strings = Arrays.asList("j", "q", "k");
redisTemplate.opsForList().leftPushAll("list", strings);

image-20211028163912176

4、leftPushAll(K key, V… values)

从左边批量插入新值(同上)

redisTemplate.opsForList().leftPushAll("list", "j", "q", "k");
5、leftPushIfPresent(K key, V value)

如果key存在，从左边插入新值

  • key不存在，不新增
redisTemplate.opsForList().leftPushIfPresent("list", "j");

image-20211028165050000

6、leftPop(K key)

默认移除key中最左的一个值

redisTemplate.opsForList().leftPop("list");

image-20211028165424396

7、leftPop(K key, long timeout, TimeUnit unit)

指定过期时间后删除key中最左的一个值

redisTemplate.opsForList().leftPop("list",1,TimeUnit.MINUTES);

image-20211028170726469

8、rightPopAndLeftPush(K k1, K k2)

移除k1中最右的值，并将移除的值插入k2中最左侧

  • k1和k2不是同一个key时，k1右侧移除，k2左侧插入，k2不存在时则新增一个然后在插入
  • k1和k2是同一个key时，相当于把最右侧的值移到了最左侧
redisTemplate.opsForList().rightPopAndLeftPush("list", "list2");

image-20211028173144174

9、rightPopAndLeftPush(K k1, K k2, long timeout, TimeUnit unit)

指定过期时间后，移除k1中最右的值，并将移除的值插入k2中最左侧（同上）

  • k1和k2不是同一个key时，k1右侧移除，k2左侧插入，k2不存在时则新增一个然后在插入
  • k1和k2是同一个key时，相当于把最右侧的值移到了最左侧
redisTemplate.opsForList().rightPopAndLeftPush("list", "list2",1,TimeUnit.MINUTES);

image-20211028173915959

image-20211028174004748

10、rightPush(K key, V value)

从右侧插入新值

redisTemplate.opsForList().rightPush("rightList",'a');
redisTemplate.opsForList().rightPush("rightList",'b');
redisTemplate.opsForList().rightPush("rightList",'c');

image-20211028180346272

11、rightPush(K key, V v1, V v2)

从右查找v1，并在v1右侧插入新值v2

  • v1有多个，只找到最靠右的一个即可
  • v1没有，不插入
redisTemplate.opsForList().rightPush("rightList", "b", "e");

image-20211028180909547

12、rightPushAll(K key, V… values)

从右侧批量插入

redisTemplate.opsForList().rightPushAll("rightList", "e", "f","g");

image-20211028181234661

13、rightPushAll(K key, Collection values)

从右侧批量插入

List<String> strings = Arrays.asList("j", "q", "k");
redisTemplate.opsForList().rightPushAll("rightList", strings);

image-20211028181522430

14、rightPushIfPresent(K key, V value)

如果key存在，在右侧新插入value，否则不插入

redisTemplate.opsForList().rightPushIfPresent("rightList", "a");

image-20211028182241565

15、rightPop(K key)

默认从最右侧移除一个值

redisTemplate.opsForList().rightPop("rightList");

image-20211028182605961

16、rightPop(K key, long timeout, TimeUnit unit)

指定过期时间后，从最右侧移除一个值

redisTemplate.opsForList().rightPop("rightList",1,TimeUnit.MINUTES);
17、index(K key, final long index)

获取指定位置的值（index从左往右，从0开始）

  • 超过下标，不报错，返回null
String string1 = (String) redisTemplate.opsForList().index("rightList", 2);
System.out.println("string1 = " + string1);

image-20211028183337630

18、size(K key)

获取对应key的集合长度

Long size = redisTemplate.opsForList().size("rightList");
System.out.println("size = " + size);

image-20211028183702987

19、set(K key, final long index, V value)

在指定坐标位置插入(替换)新值

  • index不存在，报错（ERR index out of range）
  • key不存在，报错（ERR no such key）
  • 从左侧插入
redisTemplate.opsForList().set("rightList",2,"e");

image-20211029155952080

20、trim(K key, long long1, long long2）

截取下标long1和long2之间的值，包括long1和long2对应的值，并将其保留为key对应的新值

  • 左侧坐标从0开始，右侧从-1开始

  • 当long1超过坐标时（此时与long2无关），都会截取为空，key会被删除

  • 当long1为负时（此时与long2无关），都会截取为空，key会被删除

  • 当long1为正且在下标存在其中，long2为负数时，只要两个没有重叠，相当于去左去右，保留了中间的部分

  • 当long1为正且在下标存在其中，long2为负数时，只要两个交叉重叠，截取为空，如下图

redisTemplate.opsForList().trim("rightList",1,3);

image-20211029160654225

image-20211029170206215

21、List range(K key, long start, long end)

获取指定下标间的值

redisTemplate.opsForList().range("rightList", 0, -1);//获取所有值
22、remove(K key, long count, Object value)

从存储在键中的列表中删除等于值的元素的第一个计数事件。

  • count> 0：删除等于从左到右移动的值的第一个元素；
  • count< 0：删除等于从右到左移动的值的第一个元素；
  • count = 0：删除等于value的所有元素。
redisTemplate.opsForList().remove("rightList", 0, "c");
23、拓展

当存储对象、对象集合时，最好转为JSON字符串，方便存储解析

三、opsForHash()

1、put(H var1, HK var2, HV var3)

新增hashMap值

  • var1 为Redis的key
  • var2 为key对应的map值的key
  • var3 为key对应的map值的值
  • var2相同替换var3
redisTemplate.opsForHash().put("hashValue","map1","value1");
redisTemplate.opsForHash().put("hashValue","map2","value2");

image-20211031131414748

2、get(H var1, Object var2)

获取key对应的map中，key为var2的map的对应的值

Object o = redisTemplate.opsForHash().get("hashValue", "map1");
System.out.println("o = " + o);

image-20211031131949212

3、entries(H key)

获取key对应的所有map键值对

Map hashValue = redisTemplate.opsForHash().entries("hashValue");
System.out.println("hashValue = " + hashValue);

image-20211031132440702

4、keys(H key)

获取key对应的map中所有的键

Set hashValue = redisTemplate.opsForHash().keys("hashValue");
System.out.println("hashValue = " + hashValue);

image-20211031132730932

5、values(H key)

获取key对应的map中所有的值

List hashValue = redisTemplate.opsForHash().values("hashValue");
System.out.println("hashValue = " + hashValue);

image-20211031132939498

6、hasKey(H key, Object var2)

判断key对应的map中是否有指定的键

Boolean aBoolean = redisTemplate.opsForHash().hasKey("hashValue", "map1");
System.out.println("aBoolean = " + aBoolean);

image-20211031133137190

7、size(H key)

获取key对应的map的长度

Long hashValue = redisTemplate.opsForHash().size("hashValue");
System.out.println("hashValue = " + hashValue);

image-20211031133545972

8、putIfAbsent(H key, HK var2, HV var3)

如何key对应的map不存在，则新增到map中，存在则不新增也不覆盖

redisTemplate.opsForHash().putIfAbsent("hashValue", "map3", "value3");
9、putAll(H key, Map<? extends HK, ? extends HV> map)

直接以map集合的方式添加key对应的值

  • map中key已经存在，覆盖替换
  • map中key不存在，新增
Map newMap = new HashMap();
newMap.put("map4","map4");
newMap.put("map5","map5");
redisTemplate.opsForHash().putAll("hashValue",newMap);

image-20211031134338995

10、multiGet(H key, Collection var2)

以集合的方式获取这些键对应的map

List list = new ArrayList<>();
list.add("map1");
list.add("map2");
List hashValue = redisTemplate.opsForHash().multiGet("hashValue", list);
System.out.println("hashValue = " + hashValue);

image-20211031134908614

11、lengthOfValue(H key, HK var2)

获取指定key对应的map集合中，指定键对应的值的长度

Long aLong = redisTemplate.opsForHash().lengthOfValue("hashValue", "map1");
System.out.println("aLong = " + aLong);

image-20211031135149212

12、increment(H key, HK var2, long long1)

使key对应的map中，键var2对应的值以long1自增

Long increment = redisTemplate.opsForHash().increment("hashValue", "map7", 1);
System.out.println("increment = " + increment);

image-20211031135548988

13、increment(H key, HK var2, double d1)

使key对应的map中，键var2对应的值以double类型d1自增

Double increment = redisTemplate.opsForHash().increment("hashValue", "map8", 1.2);
System.out.println("increment = " + increment);

image-20211031135808867

14、scan(H var1, ScanOptions var2)

匹配获取键值对

  • ScanOptions.NONE为获取全部键对
  • ScanOptions.scanOptions().match(“map1”).build()，匹配获取键位map1的键值对,不能模糊匹配
Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("hashValue",ScanOptions.scanOptions().match("map1").build());
//Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("hashValue",ScanOptions.NONE);
    while (cursor.hasNext()) {
        Map.Entry<Object, Object> entry = cursor.next();
        System.out.println("entry.getKey() = " + entry.getKey());
        System.out.println("entry.getValue() = " + entry.getValue());
    }

image-20211031140717393

15、delete(H key, Object… var2)

删除key对应的map中的键值对

Long delete = redisTemplate.opsForHash().delete("hashValue", "map1", "map2");
System.out.println("delete = " + delete);

image-20211031140940098

16、拓展

map中存储对象、对象集合时最好转为JSON字符串，容易解析

map中键值对都可以存为对象、对象集合JSON字符串，具体看实际应用存储

List<MPEntity> list = mpService.list();
redisTemplate.opsForHash().put("hashValue",JSON.toJSONString(list),JSON.toJSONString(list));

image-20211031141646718

四、opsForSet()

1、add(K key, V… var2)

向key中批量添加值

redisTemplate.opsForSet().add("set", "aa", "bb", "cc");
redisTemplate.opsForSet().add("set", "ee");

image-20211031142538670

2、members(K key)

获取key中的值

Set set = redisTemplate.opsForSet().members("set");
System.out.println("set = " + set);

image-20211031142750831

3、size(K key)

获取key对应集合的长度

Long set = redisTemplate.opsForSet().size("set");
System.out.println("set = " + set);

image-20211031142943575

4、randomMember(K key)

随机获取key对应的集合中的元素

Object set = redisTemplate.opsForSet().randomMember("set");
System.out.println("set = " + set);

image-20211031143140404

5、randomMembers(K key, long long1)

随机获取key对应集合中指定个数的元素

  • set本身是不会有重复的值
  • 随机获取可能获取到一样的，所以返回的list集合中可能会有重复的值
List set = redisTemplate.opsForSet().randomMembers("set", 2);
System.out.println("set = " + set);

image-20211031143342948

6、isMember(K key, Object o1)

判断key对应的集合中是否包含元素o1

Boolean member = redisTemplate.opsForSet().isMember("set", "aa");
System.out.println("member = " + member);

image-20211031143543716

7、distinctRandomMembers(K key, long long1)

随机获取key对应集合中指定个数的元素，并且去重

Set set = redisTemplate.opsForSet().distinctRandomMembers("set", 3);
System.out.println("set = " + set);

image-20211031144436310

8、move(K key1, V v1, K key2)

将key1对应集合中的值v1，转移到key2集合中

  • key2不存在直接新增
  • v1不存在，转移失败返回false
Boolean move = redisTemplate.opsForSet().move("set", "aa", "set2");
System.out.println("move = " + move);

image-20211031145000223

image-20211031145037399

9、pop(K key)

随机弹出key对应集合中的一个元素

Object set = redisTemplate.opsForSet().pop("set");
System.out.println("set = " + set);

image-20211031145351575

10、pop(K key, long count)

随机移除key对应集合中的count个元素

List set = redisTemplate.opsForSet().pop("set", 2);
System.out.println("set = " + set);
11、remove(K key, Object… values)

批量移除key对应集合中指定的元素

redisTemplate.opsForSet().remove("set", "cc","aa");
12、scan(K key, ScanOptions options)

匹配获取键值对

  • ScanOptions.NONE为获取全部键值对
  • ScanOptions.scanOptions().match(“C”).build()匹配获取键位map1的键值对,不能模糊匹配。
Cursor<Object> cursor = redisTemplate.opsForSet().scan("set", ScanOptions.scanOptions().match("ee").build());
while (cursor.hasNext()){
    Object object = cursor.next();
    System.out.println("object = " + object);
}
13、difference(K key, Collection otherKeys)

获取key与其他集合之间的差值

  • key中有，otherKeys中没有的
List list = new ArrayList();
list.add("set2");
Set set = redisTemplate.opsForSet().difference("set", list);
System.out.println("set = " + set);
14、difference(K key, K otherKey)

获取key与另一个otherKey集合之间的差值

  • key中有，otherKeys中没有的
Set difference = redisTemplate.opsForSet().difference("set", "set2");
System.out.println("difference = " + difference);
15、differenceAndStore(K key, K otherKey, K destKey)

获取key与另一个otherKey所对应的集合之间的差值，并将结果存入指定的destKey中

  • destKey存在，它原本集合中的所有值会被清空并且替换为获取的差值
  • destKey不存在，直接新增
  • key与otherKey没有获取到差值，destKey如果存在，会被删除
Long aLong = redisTemplate.opsForSet().differenceAndStore("set", "set2", "set3");
System.out.println("aLong = " + aLong);

image-20211031151339675

16、differenceAndStore(K key, Collection otherKeys, K destKey)

获取key与另外一些otherKeys集合之间的差值，并将结果存入指定的destKey中

  • destKey存在，它原本集合中的所有值会被清空并且替换为获取的差值
  • destKey不存在，直接新增
  • key与otherKeys没有获取到差值，destKey如果存在，会被删除
List list = new ArrayList();
list.add("set2");
Long aLong = redisTemplate.opsForSet().differenceAndStore("set", list, "set3");
System.out.println("aLong = " + aLong);
17、intersect(K key, K otherKey)

获取两个集合中的交集元素

Set intersect = redisTemplate.opsForSet().intersect("set", "set2");
System.out.println("intersect = " + intersect);

image-20211031152454758

18、intersect(K key, Collection otherKeys)

获取多个key对应集合之间的交集

List list = new ArrayList();
list.add("set2");
list.add("set3");
Set set = redisTemplate.opsForSet().intersect("set", list);
System.out.println("set = " + set);
19、intersectAndStore(K key, K otherKey, K destKey)

获取key集合与另一个otherKey集合之间的交集元素，并将其放入指定的destKey集合中

  • 没有获取到交集元素时，注意：若指定集合destKey存在，它将会被删除
Long aLong = redisTemplate.opsForSet().intersectAndStore("set", "set2", "set4");
System.out.println("aLong = " + aLong);

image-20211031153009261

20、intersectAndStore(K key, Collection otherKeys, K destKey)

获取key集合与其他otherKeys集合之间的交集元素，并将其放入指定的destKey集合中

  • 没有获取到交集元素时，注意：若指定集合destKey存在，它将会被删除
List list = new ArrayList();
list.add("set2");
Long aLong = redisTemplate.opsForSet().intersectAndStore("set", list, "set5");
System.out.println("aLong = " + aLong);
21、union(K key, K otherKey)

获取两个集合的合集，并且去重

Set union = redisTemplate.opsForSet().union("set", "set2");
System.out.println("union = " + union);

image-20211031153638106

22、union(K key, Collection otherKeys)

获取多个集合的合集，去重

List list = new ArrayList();
list.add("set2");
Set union = redisTemplate.opsForSet().union("set", list);
System.out.println("union = " + union);
23、unionAndStore(K key, K otherKey, K destKey)

获取两个集合之间的合集，并放入指定key对应的新集合中

  • 若指定key对应的集合存在，会被覆盖掉
Long aLong = redisTemplate.opsForSet().unionAndStore("se3", "set2", "set4");
System.out.println("aLong = " + aLong);

image-20211031154515616

24、unionAndStore(K key, Collection otherKeys, K destKey)

获取多个集合之间的合集，并放入指定key对应的新集合中

  • 若指定key对应的集合存在，会被覆盖掉
List list = new ArrayList();
list.add("set2");
list.add("set3");
redisTemplate.opsForSet().unionAndStore("set", list, "set4");
25、拓展

存储对象、对象集合为转换为JSON字符串，方便解析获取

List<MPEntity> list = mpService.list();
redisTemplate.opsForSet().add("set7", JSON.toJSONString(list), "bb", "cc");

image-20211031155012212

五、opsForZSet()

1、add(K key, V value, double score)

向指定key中添加元素，按照score值由小到大进行排列

  • 集合中对应元素已存在，会被覆盖，包括score
redisTemplate.opsForZSet().add("zSet", "aaa", 1);
redisTemplate.opsForZSet().add("zSet", "bbb", 2);
redisTemplate.opsForZSet().add("zSet", "ccc", 3);

image-20211031160548828

2、add(K key, Set tuples)

向指定key中添加元素，按照score值由小到大进行排列

  • 集合中对应元素已存在，会被覆盖，包括score
ZSetOperations.TypedTuple<String> objectTypedTuple1 = new DefaultTypedTuple<>("eee",9.6);
ZSetOperations.TypedTuple<String> objectTypedTuple2 = new DefaultTypedTuple<>("fff",1.5);
ZSetOperations.TypedTuple<String> objectTypedTuple3 = new DefaultTypedTuple<>("ggg",7.4);
Set<ZSetOperations.TypedTuple<String>> typles = new HashSet<>();
typles.add(objectTypedTuple1);
typles.add(objectTypedTuple2);
typles.add(objectTypedTuple3);
redisTemplate.opsForZSet().add("zSet", typles);

image-20211031162053359

3、incrementScore(K key, V v1, double delta)

增加key对应的集合中元素v1的score值，并返回增加后的值

  • v1不存在，直接新增一个元素

image-20211031162407772

4、score(K key, Object o)

获取key对应集合中o元素的score值

Double score = redisTemplate.opsForZSet().score("zSet", "aaa");
System.out.println("score = " + score);

image-20211031162946753

5、size(K key)

获取集合的大小，地层调用的还是 zCard(K key)

Long zSet = redisTemplate.opsForZSet().size("zSet");
System.out.println("zSet = " + zSet);

image-20211031163158251

6、zCard(K key)

获取集合大小

Long zSet = redisTemplate.opsForZSet().zCard("zSet");
System.out.println("zSet = " + zSet);

image-20211031163404845

7、count(K key, double min, double max)

获取指定score区间里的元素个数

  • 包括min、max
8、range(K key, long start, long end)

获取指定下标之间的值

  • (0,-1)就是获取全部
Set zSet = redisTemplate.opsForZSet().range("zSet", 0, 2);
System.out.println("zSet = " + zSet);
9、rangeByScore(K key, double min, double max)

获取指定score区间的值

Set zSet = redisTemplate.opsForZSet().rangeByScore("zSet", 1, 5);
System.out.println("zSet = " + zSet);
10、rangeByScore(K key, double min, double max, long offset, long count)

获取指定score区间的值，然后从给定下标和给定长度获取最终值

Set zSet = redisTemplate.opsForZSet().rangeByScore("zSet", 1, 5, 1, 2);
System.out.println("zSet = " + zSet);

image-20211031170511811
image-20211031170532272

11、rank(K key, Object o)

获取指定元素在集合中的索引，索引从0开始

Long rank = redisTemplate.opsForZSet().rank("zSet", "aaa");
System.out.println("rank = " + rank);
12、reverseRank(K key, Object o)

获取倒序排列的索引值，索引从0开始

Long rank = redisTemplate.opsForZSet().reverseRank("zSet", "eee");
System.out.println("rank = " + rank);

image-20211031180413240

image-20211031180438496

13、reverseRange(K key, long start, long end)

逆序获取对应下标的元素

Set zSet = redisTemplate.opsForZSet().reverseRange("zSet", 0, 3);
System.out.println("zSet = " + zSet);

image-20211031180702500

image-20211031180731346

14、remove(K key, Object… values)

移除集合中指定的值

Long remove = redisTemplate.opsForZSet().remove("zSet", "aaa", "bbb");
System.out.println("remove = " + remove);
15、removeRange(K key, long start, long end)

移除指定下标的值

redisTemplate.opsForZSet().removeRange("zSet", 0, 1);
16、removeRangeByScore(K key, double min, double max)

移除指定score区间内的值

海绵宝宝丶哈
关注
  • 9
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RedisTemplate常用集合使用说明-opsForList(三)
XinhuaShuDiao的博客
08-09 1万+
         基础配置介绍已经在前面的《RedisTemplate常用集合使用说明(一)》中已经介绍了，现在我们直接介绍opsForList()方法的使用：      1、leftPush(K key, V value)     在变量左边添加元素值。   redisTemplate.opsForList().leftPush("list","a"); redisTemplat...
RedisTemplate集合使用说明-opsForList(二）
小驴程序源
12-14 1481
1、leftPush(K key, V value) 在变量左边添加元素值。 redisTemplate.opsForList().leftPush("list","a"); redisTemplate.opsForList().leftPush("list","b"); redisTemplate.opsForList().leftPush("list","c"); 2、index(K key, long index) 获取集合指定位置的值。 String listValue = redis
RedisTemplate使用最详解（二）--- opsForList()
热门推荐
weixin_43658899的博客
10-29 6万+
1、leftPush(K key, V value) 从集合左边插入值 值重复无影响 先进先出 redisTemplate.opsForList().leftPush("list","a"); redisTemplate.opsForList().leftPush("list","a"); redisTemplate.opsForList().leftPush("list","b"); 2、leftPush(K key, V v, V v1) 从集合左边开始在v值后边插入新值v1 在集合中查
RedisTemplate.opsForList()用法简介并举例
一起coding，一起嗨。
08-08 5854
是RedisTemplate类提供的用于操作List类型的方法。它可以用于对Redis中的List数据结构进行各种操作，如添加元素、获取元素、删除元素等。请注意，示例中的"mylist"是列表的键名，“value1”、"value2"等是要插入或获取的元素值。方法的常见用法，你可以根据具体的业务需求选择适合的方法进行操作。
Redis之RedisTemplate使用（RedisTemplate工具类）
03-15
Redis之RedisTemplate使用（RedisTemplate工具类） String类型相关操作 List类型相关操作 Set类型相关操作 Map类型相关操作 ZSet类型相关操作
在Java中使用redisTemplate操作缓存的方法示例
08-26
"Java中使用redisTemplate操作缓存的方法示例" 在Java中使用redisTemplate操作缓存的方法示例，主要介绍了在Java中使用redisTemplate操作缓存的方法示例，在Redis中可以存储String、List、Set、Hash、Zset。感兴趣...
Spring学习笔记之RedisTemplate的配置与使用教程
08-27
【Spring中的RedisTemplate配置与使用】 在Spring框架中，RedisTemplate是用于操作Redis数据库的一个强大工具，它提供了丰富的API来简化Redis的操作。本教程将详细讲解如何配置和使用RedisTemplate。 **I. 基本...
spring使用RedisTemplate的操作类访问Redis
08-30
Spring 使用 RedisTemplate 操作类访问 Redis 本篇文章主要介绍了 Spring 使用 RedisTemplate 的操作类访问 Redis，具有一定的参考价值。下面将详细说明标题和描述中的知识点。 首先，RedisTemplate 是 Spring ...
RedisTemplate-JDBCTemplate.zip
07-18
使用`RedisTemplate`的主要步骤如下： 1. 配置Redis连接工厂，如`JedisConnectionFactory`，并设置相应的连接参数。 2. 在Spring配置中声明`RedisTemplate`，并指定键值序列化器（如StringRedisSerializer）和其他...
RedisTemplate中opsForValue和opsForList方法的使用详解
weixin_42258334的博客
06-29 8902
REDIS
Redis opsForList 简介
qq_44499717的博客
04-26 2648
Redis opsForList 简介 1、leftPush(K key, V value) 在变量左边添加元素值。 Java代码 收藏代码 redisTemplate.opsForList().leftPush(“list”,“a”); redisTemplate.opsForList().leftPush(“list”,“b”); redisTemplate.opsForList().leftPush(“list”,“c”); 2、index(K key, long index) 获取集合指定位置
【Redis】Redis使用和RedisTemplate的方法介绍
别倒在黎明之前的博客
09-05 2465
leftPush ：从集合左边插入值 | | 从集合左边开始在v值后边插入新值v1leftPushAll ：从左边批量插入新值 | | 从左边批量插入新值(同上)leftPushIfPresent ：如果key存在，从左边插入新值leftPop ：默认移除key中最左的一个值| |指定过期时间后删除key最左的一个值rightPopAndLeftPush ：移除k1中最右的值，并将移除的值插入k2中最左侧| |指定过期时间后，移除k1中最右的值，并将移除的值插入k2中最左侧（同上）
SpringBoot RedisTemplate opsForList
风信子
03-29 6090
SpringBoot RedisTemplate opsForList1 SpringBoot RedisTemplate spring-data-redis-2.6.2.jar @Autowired private RedisTemplate redisTemplate; /* * (non-Javadoc) * @see org.springframework.data.redis.core.RedisOperations#opsForList() */ @Override public Li
Redis常用操作
最新发布
yzs2022的博客
12-19 613
Redis操作
RedisTemplate使用说明_02_opsForList
皮球
04-24 2596
从存储在键中的列表中删除等于值的元素的第一个计数事件。在集合的指定位置插入元素,如果指定位置已有元素，则覆盖，没有则新增，超过集合下标+n则会报错。移除集合中右边的元素在等待的时间里，同时在左边添加元素，如果超过等待的时间仍没有元素则退出。移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。向集合中第一次出现第二个参数变量元素的右边添加第三个参数变量的元素值。移除集合中右边的元素，同时在左边加入一个元素。
RedisTemplate类-opsForList 列表操作api
小哇
12-25 7648
1、leftPush(K key, V value) 在变量左边添加元素值。 redisTemplate.opsForList().leftPush("list","a"); redisTemplate.opsForList().leftPush("list","b"); redisTemplate.opsForList().leftPush("list","c"); 2、i...
使用 RedisTemplate 保存数据时 key 多出来 \xac\xed\x00\x05t\x00\x011 之类的编码
09-12
这种情况通常是因为 RedisTemplate 默认使用了 JdkSerializationRedisSerializer 进行序列化，而在进行序列化时，会将字符串转换为字节数组，导致了这种看起来不可读的编码。你可以尝试使用其他的序列化器来解决这个问题。 一种常见的解决方案是使用 StringRedisSerializer，它会将字符串直接序列化为字节数组，而不会进行额外的转换。你可以通过配置 RedisTemplate 的 valueSerializer 来指定使用 StringRedisSerializer： ```java RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setKeySerializer(new StringRedisSerializer()); ``` 另外，如果你需要存储的是自定义的对象，你也可以考虑使用其他的序列化器，比如 Jackson2JsonRedisSerializer，它可以将对象序列化为 JSON 字符串，方便阅读和调试： ```java RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(YourObject.class)); ``` 通过选择合适的序列化器，你应该能够解决 RedisTemplate 保存数据时 key 多出来不可读编码的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值