526互联

RedisTemplate使用文档

发布时间 2023-09-03 11:51:58作者: 夏嘻嘻嘻嘻嘻

一.Redis五种基本数据类型

1.String字符串

String的数据结构是简单的Key-Value模型，Value可以是字符串，也可以是数字。

应用场景

  • 计数器—点赞,视频播放量,每播放一次就+1
  • 统计多单位的数量
  • 粉丝数
  • 对象缓存存储

2.Hash散列表

Redis 的哈希是键值对的集合。
Redis 的哈希值是字符串字段和字符串值之间的映射，因此它们被用来表示对象，还有用户信息之类的，经常变动的信息。
Hash更适合用于对象的存储，String更适合字符串存储。

使用场景

  • 主要用于存储部分变更数据，比如存储用户信息等等

3.List链表

Redis 的链表是简单的字符串列表，排序插入顺序。您可以添加元素到 Redis 的列表的头部或尾部
Lpush：表示的是向链表的左添加，也就是向链表的头添加；
Rpush：表示的是向链表的右添加，也就是向链表的尾添加；

应用场景

  • 消息队列：利用List的PUSH操作，将任务存在List中，然后工作线程再用POP操作将任务取出进行执行。Redis还提供了操作List中某一段的api，你可以直接查询，删除List中某一段的元素。
  • 消息排队，消息队列（Lpush、Rpop）、栈（Lpush、Lpop）
  • 使用list可以构建队列系统，使用sorted set甚至可以构建有优先级的队列系统。

4.Set( 集合)

Redis 的集合是字符串的无序集合。
在Set集合当中，是不允许有重复的。
set是通过hash table实现的，可以进行添加、删除和查找。对集合我们可以取并集，交集，差集.

应用场景

  • 微博、用户将所有关注的人都放入到一个set集合当中，将它的粉丝也放在一个集合中。
  • 共同关注、共同爱好、二度好友、QQ的好友推荐（六度分割理论）

5.SortedSet( 有序集合) zset

Redis 的有序集合类似于 Redis 的集合，字符串不重复的集合。

应用场景

  • 存储班级成绩表、工资表排序

二.Spring Data Redis

Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis, JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现。 spring-data-redis针对jedis提供了如下功能：

  1. 连接池自动管理，提供了一个高度封装的“RedisTemplate”类
  2. 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
    • ValueOperations：简单K-V操作
    • SetOperations：set类型数据操作
    • ZSetOperations：zset类型数据操作
    • HashOperations：针对map类型的数据操作
    • ListOperations：针对list类型的数据操作
  1. 提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations：
    • BoundValueOperations
    • BoundSetOperations
    • BoundListOperations
    • BoundSetOperations
    • BoundHashOperations
  1. 将事务操作封装，有容器控制。
  2. 针对数据的“序列化/反序列化”，提供了多种可选择策略(RedisSerializer)

JdkSerializationRedisSerializer：POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列。是目前最常用的序列化策略。

StringRedisSerializer：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。

JacksonJsonRedisSerializer：jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。【需要jackson-mapper-asl工具支持】

三.RedisTemplate的使用

1. RedisTemplate的直接方法
 1 // 确定给定 key 是否存在，有的话就返回 true，没有就返回 false
 2 redisTemplate.hasKey(K key)
 3 
 4 // 删除给定的 key
 5 redisTemplate.delete(K key)
 6 
 7 // 删除给定 key 的集合
 8 redisTemplate.delete(Collection<K> keys)
 9 
10 // 执行 Redis 转储命令并返回结果，把key值序列化成byte[]类型
11 redisTemplate.dump(K key)
12 
13 // 对传入的key值设置过期时间、将给定 key 的过期时间设置为日期时间戳
14 redisTemplate.expire(K key, long timeout, TimeUnit unit)
15 redisTemplate.expireAt(K key, Date date)
16 
17 // 查找与给定模式匹配的所有 key ，返回的是一个没有重复的Set类型
18 redisTemplate.keys(K pattern)
19 
20 // 将 oldKey 重命名为 newKey
21 redisTemplate.rename(K oldKey, K newKey)
22 
23 // 获取key值的类型
24 redisTemplate.type(K key)
25 
26 // 仅当 newKey 不存在时，才将密钥 oldKey 重命名为 newKey。
27 redisTemplate.renameIfAbsent(K oldKey, K newKey)
28 
29 // 随机从redis中获取一个key
30 redisTemplate.randomKey()
31 
32 // 获取当前key的剩下的过期时间
33 redisTemplate.getExpire(K key)
34 
35 // 获取剩余的过期时间，同时设置时间单位
36 redisTemplate.getExpire(K key, TimeUnit timeUnit)
37 
38 // 删除 key 的过期时间
39 redisTemplate.persist(K key)
40 
41 // 将给定的 key 移动到带有索引的数据库
42 redisTemplate.move(K key, int dbIndex)

 

2.RedisTemplate.opsForValue() 方法

 1 // 设置 key 跟 value 的值
 2 redisTemplate.opsForValue().set(K key, V value)
 3 
 4 // 获取 key 的值
 5 redisTemplate.opsForValue().get(Object key)
 6 
 7 // 设置key跟value的值，同时设置过期时间
 8 redisTemplate.opsForValue().set(K key, V value, Duration timeout)
 9 
10 // 在 start 和 end 之间获取键值的子字符串
11 redisTemplate.opsForValue().get(K key, long start, long end)
12 
13 // 设置 key 的值并返回其旧值
14 redisTemplate.opsForValue().getAndSet(K key, V value)
15 
16 // 获取多个 key
17 redisTemplate.opsForValue().multiGet(Collection<K> keys)
18 
19 // 获取原来的key的值后在后面新增上新的字符串
20 redisTemplate.opsForValue().append(K key, String value)
21 
22 // 增量方式增加double值
23 redisTemplate.opsForValue().increment(K key, double increment)
24 
25 // 通过increment(K key, long delta)方法以增量方式存储long值（正值则自增，负值则自减）
26 redisTemplate.opsForValue().increment(K key, long increment)
27 
28 // 仅当提供的 key 不存在时，才使用集合中提供的键值对将多个 key 设置为多个值。
29 redisTemplate.opsForValue().multiSetIfAbsent(Map<? extends K,? extends V> map)
30 
31 // 使用集合中提供的键值对将多个 key 设置为多个值。
32 Map map = new HashMap(); map.put("1","1"); map.put("2","2"); 
33 map.put("3","3"); 
34 redisTemplate.opsForValue().multiSet(Map<? extends K,? extends V> map)
35 
36 // 获取指定key的字符串的长度
37 redisTemplate.opsForValue().size(K key)
38 
39 // 用给定值覆盖从指定偏移量开始的 key 的部分。
40 redisTemplate.opsForValue().set(K key, V value, long offset)
41 
42 // 如果 key 不存在，则设置 key 以保存字符串值，存在返回false，否则返回true
43 redisTemplate.opsForValue().setIfAbsent(key, value)
44 
45 // 重新设置key的值并加入过期时间
46 redisTemplate.opsForValue().set(key, value, timeout, unit)
47 
48 // 将二进制第offset位值变为value
49 redisTemplate.opsForValue().setBit(K key, long offset, boolean value)
50 
51 // 对key所储存的字符串值，获取指定偏移量上的位(bit)
52 redisTemplate.opsForValue().getBit(K key, long offset)

 

3.RedisTemplate.opsForHash() 方法

 1 // 从 key 处的 hash 中获取给定 hashKey 的值，即 key field（hashKey） value
 2 redisTemplate.opsForHash().get(H key, Object hashKey)
 3 
 4 // 获取存储在 key 的整个 hash，即获取所有值
 5 redisTemplate.opsForHash().entries(H key)
 6 
 7 // 设置hash hashKey 的值
 8 redisTemplate.opsForHash().put(H key, HK hashKey, HV value)
 9 
10 // 使用 m 中提供的数据将多个 hash 字段设置为多个值，即使用 map 进行赋值
11 redisTemplate.opsForHash().putAll(H key, Map<? extends HK,? extends HV> m)
12 
13 // 仅当 hashKey 不存在时才设置 hash hashKey 的值。
14 redisTemplate.opsForHash().putIfAbsent(H key, HK hashKey, HV value)
15 
16 // 删除给定的hash hashKeys
17 redisTemplate.opsForHash().delete(H key, Object... hashKeys)
18 
19 // 确定给定的hash hashKey 是否存在
20 redisTemplate.opsForHash().hasKey(H key, Object hashKey)
21 
22 // 通过给定的增量增加hash hashKey 的值
23 redisTemplate.opsForHash().increment(H key, HK hashKey, double increment)
24 redisTemplate.opsForHash().increment(H key, HK hashKey, long increment)
25 
26 // 在 key 处获取 hash 的 hashKey 集（字段）
27 redisTemplate.opsForHash().keys(H key)
28 
29 // 获取 key 的 hash 大小。
30 redisTemplate.opsForHash().size(H key)
31 
32 // 在 key 处获取 hash 的值
33 redisTemplate.opsForHash().values(H key)
34 
35 // 查看匹配的键值对
36 redisTemplate.opsForHash().scan(H key, ScanOptions options)

 

4.RedisTemplate.opsForList() 方法

 1 // 从 key 的 list 中获取索引处的元素
 2 redisTemplate.opsForList().index(K key, long index)
 3 
 4 // 从 key 的 list 中获取 start 和 end 之间的元素
 5 redisTemplate.opsForList().range(K key, long start, long end)
 6 
 7 // 为 key 添加值
 8 redisTemplate.opsForList().leftPush(K key, V value)
 9 
10 // 将值添加到 key 中
11 redisTemplate.opsForList().leftPushAll(K key, Collection<V> values)
12 
13 // 仅当 list 存在时，才将值添加到 key 中
14 redisTemplate.opsForList().leftPushIfPresent(K key, V value)
15 
16 // 在 pivot 之前将值添加到 key 中
17 redisTemplate.opsForList().leftPush(K key, V pivot, V value)
18 
19 // 将值附加到 key
20 redisTemplate.opsForList().rightPush(K key, V value)
21 redisTemplate.opsForList().rightPushAll(K key, Collection<V> values)
22 
23 // 在 pivot 之后将值添加到 key 中
24 redisTemplate.opsForList().rightPush(K key, V pivot, V value)
25 
26 // 在列表元素的索引处设置值
27 redisTemplate.opsForList().set(K key, long index, V value)
28 
29 // 删除并返回存储在 key 的列表中的第一个元素、
30 redisTemplate.opsForList().leftPop(K key)
31 redisTemplate.opsForList().leftPop(K key, Duration timeout)
32 redisTemplate.opsForList().leftPop(K key, long count)
33 redisTemplate.opsForList().leftPop(K key, long timeout, TimeUnit unit)
34 
35 // 删除并返回存储在 key 的列表中的最后一个元素
36 redisTemplate.opsForList().rightPop(K key)
37 redisTemplate.opsForList().rightPop(K key, Duration timeout)
38 redisTemplate.opsForList().rightPop(K key, long count)
39 redisTemplate.opsForList().rightPop(K key, long timeout, TimeUnit unit)
40 
41 // 从 sourceKey 的列表中删除最后一个元素，将其附加到 destinationKey 并返回其值
42 redisTemplate.opsForList().rightPopAndLeftPush(K sourceKey, K destinationKey)
43 redisTemplate.opsForList().rightPopAndLeftPush(K sourceKey, K destinationKey, Duration timeout)
44 
45 // 从存储在 key 的列表中删除第一个 count 出现的 value
46 redisTemplate.opsForList().remove(K key, long count, Object value)
47 
48 // 在 start 和 end 之间的元素的 key 处修剪列表
49 redisTemplate.opsForList().trim(K key, long start, long end)
50 
51 // 获取存储在 key 的列表的大小
52 redisTemplate.opsForList().size(K key)

 

5.RedisTemplate.opsForSet() 方法

 1 // 在 key 的 set 中添加给定值
 2 redisTemplate.opsForSet().add(K key, V... values)
 3 
 4 // 在 key 的 set 中删除给定值并返回已删除元素的数量
 5 redisTemplate.opsForSet().remove(K key, Object... values)
 6 
 7 // 从 key 的 set 中移除并返回一个随机成员
 8 redisTemplate.opsForSet().    pop(K key)
 9 
10 // 在 key 处获取集合的大小
11 redisTemplate.opsForSet().size(K key)
12 
13 // 检查在 key 的 set 中是否包含值
14 redisTemplate.opsForSet().isMember(K key, Object o)
15 
16 // 返回在 key 和 otherKeys 处与所有给定 sets 相交的成员
17 redisTemplate.opsForSet().intersect(K key, Collection<K> otherKeys)
18 
19 // 在 key 和 otherKeys 处与所有给定 sets 相交，并将结果存储在 destKey 中
20 redisTemplate.opsForSet().intersectAndStore(K key, Collection<K> otherKeys, K destKey)
21 
22 // 在 key 和 otherKey 处相交所有给定的 sets，并将结果存储在 destKey 中
23 redisTemplate.opsForSet().intersectAndStore(K key, K otherKey, K destKey)
24 
25 // 合并给定 key 和 otherKey 的所有 sets
26 redisTemplate.opsForSet().union(K key, K otherKey)
27 
28 // 将给定 key 和 otherKey 处的所有 set 合并，并将结果存储在 destKey 中
29 redisTemplate.opsForSet().unionAndStore(K key, K otherKey, K destKey)
30 
31 // 获取差集
32 redisTemplate.opsForSet().difference(key, otherKeys)
33 
34 // 获取差集并存储到destKey
35 redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)
36 
37 // 随机获取集合中的一个元素
38 redisTemplate.opsForSet().randomMember(key)
39 
40 // 获取集合中的所有元素
41 redisTemplate.opsForSet().members(key)
42 
43 // 随机获取集合中count个值
44 redisTemplate.opsForSet().randomMembers(key, count)
45 
46 // 随机获取集合中count个值，但是去重
47 redisTemplate.opsForSet().distinctRandomMembers(key, count)
48 
49 // 遍历set
50 redisTemplate.opsForSet().scan(key, options)

 

6.RedisTemplate.opsForZSet() 方法

 1 // 添加元素，从小到大排序
 2 redisTemplate.opsForZSet().add(key, value, score)
 3 
 4 // 删除多个values的值
 5 redisTemplate.opsForZSet().remove(key, values)
 6 
 7 // 增加元素的score值同时返回增加后的值
 8 redisTemplate.opsForZSet().incrementScore(key, value, delta)
 9 
10 // 返回元素在集合的从小到大排名
11 redisTemplate.opsForZSet().rank(key, value)
12 
13 // 返回元素在集合的由大到小排名
14 redisTemplate.opsForZSet().reverseRank(key, value)
15 
16 // 获取集合中指定区间的元素
17 redisTemplate.opsForZSet().reverseRangeWithScores(key, start,end)
18 
19 // 查询集合中的元素并从小到大排序
20 redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)
21 redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max)
22 
23 // 从高到低的排序，然后获取最小与最大值之间的值
24 redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)
25 
26 // 根据score值获取元素数量
27 redisTemplate.opsForZSet().incrementScore(key, value, delta)
28 
29 // 获取集合的大小
30 redisTemplate.opsForZSet().size(key)redisTemplate.opsForZSet().zCard(key)
31 
32 // 获取集合中key、value元素的score值
33 redisTemplate.opsForZSet().score(key, value)
34 
35 // 移除指定索引元素
36 redisTemplate.opsForZSet().removeRange(key, start, end)
37 
38 // 移除指定score范围的集合成员
39 redisTemplate.opsForZSet().removeRangeByScore(key, min, max)
40 
41 // 获取key和otherKey的并集并存储在 destKey 中
42 redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)
43 
44 // 获取key和otherKey的交集并存储在 destKey 中
45 redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)