RedisTemplate使用文档

一.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类型的数据操作

3. 提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations：

• • BoundValueOperations
  • BoundSetOperations
  • BoundListOperations
  • BoundSetOperations
  • BoundHashOperations

4. 将事务操作封装，有容器控制。
5. 针对数据的“序列化/反序列化”，提供了多种可选择策略(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的直接方法

// 确定给定 key 是否存在，有的话就返回 true，没有就返回 false
redisTemplate.hasKey(K key)

// 删除给定的 key
redisTemplate.delete(K key)

// 删除给定 key 的集合
redisTemplate.delete(Collection<K> keys)

// 执行 Redis 转储命令并返回结果，把key值序列化成byte[]类型
redisTemplate.dump(K key)

// 对传入的key值设置过期时间、将给定 key 的过期时间设置为日期时间戳
redisTemplate.expire(K key, long timeout, TimeUnit unit)
redisTemplate.expireAt(K key, Date date)

// 查找与给定模式匹配的所有 key ，返回的是一个没有重复的Set类型
redisTemplate.keys(K pattern)

// 将 oldKey 重命名为 newKey
redisTemplate.rename(K oldKey, K newKey)

// 获取key值的类型
redisTemplate.type(K key)

// 仅当 newKey 不存在时，才将密钥 oldKey 重命名为 newKey。
redisTemplate.renameIfAbsent(K oldKey, K newKey)

// 随机从redis中获取一个key
redisTemplate.randomKey()

// 获取当前key的剩下的过期时间
redisTemplate.getExpire(K key)

// 获取剩余的过期时间，同时设置时间单位
redisTemplate.getExpire(K key, TimeUnit timeUnit)

// 删除 key 的过期时间
redisTemplate.persist(K key)

// 将给定的 key 移动到带有索引的数据库
redisTemplate.move(K key, int dbIndex)

 

2.RedisTemplate.opsForValue() 方法

// 设置 key 跟 value 的值
redisTemplate.opsForValue().set(K key, V value)

// 获取 key 的值
redisTemplate.opsForValue().get(Object key)

// 设置key跟value的值，同时设置过期时间
redisTemplate.opsForValue().set(K key, V value, Duration timeout)

// 在 start 和 end 之间获取键值的子字符串
redisTemplate.opsForValue().get(K key, long start, long end)

// 设置 key 的值并返回其旧值
redisTemplate.opsForValue().getAndSet(K key, V value)

// 获取多个 key
redisTemplate.opsForValue().multiGet(Collection<K> keys)

// 获取原来的key的值后在后面新增上新的字符串
redisTemplate.opsForValue().append(K key, String value)

// 增量方式增加double值
redisTemplate.opsForValue().increment(K key, double increment)

// 通过increment(K key, long delta)方法以增量方式存储long值（正值则自增，负值则自减）
redisTemplate.opsForValue().increment(K key, long increment)

// 仅当提供的 key 不存在时，才使用集合中提供的键值对将多个 key 设置为多个值。
redisTemplate.opsForValue().multiSetIfAbsent(Map<? extends K,? extends V> map)

// 使用集合中提供的键值对将多个 key 设置为多个值。
Map map = new HashMap(); map.put("1","1"); map.put("2","2"); 
map.put("3","3"); 
redisTemplate.opsForValue().multiSet(Map<? extends K,? extends V> map)

// 获取指定key的字符串的长度
redisTemplate.opsForValue().size(K key)

// 用给定值覆盖从指定偏移量开始的 key 的部分。
redisTemplate.opsForValue().set(K key, V value, long offset)

// 如果 key 不存在，则设置 key 以保存字符串值，存在返回false，否则返回true
redisTemplate.opsForValue().setIfAbsent(key, value)

// 重新设置key的值并加入过期时间
redisTemplate.opsForValue().set(key, value, timeout, unit)

// 将二进制第offset位值变为value
redisTemplate.opsForValue().setBit(K key, long offset, boolean value)

// 对key所储存的字符串值，获取指定偏移量上的位(bit)
redisTemplate.opsForValue().getBit(K key, long offset)

 

3.RedisTemplate.opsForHash() 方法

// 从 key 处的 hash 中获取给定 hashKey 的值，即 key field（hashKey） value
redisTemplate.opsForHash().get(H key, Object hashKey)

// 获取存储在 key 的整个 hash，即获取所有值
redisTemplate.opsForHash().entries(H key)

// 设置hash hashKey 的值
redisTemplate.opsForHash().put(H key, HK hashKey, HV value)

// 使用 m 中提供的数据将多个 hash 字段设置为多个值，即使用 map 进行赋值
redisTemplate.opsForHash().putAll(H key, Map<? extends HK,? extends HV> m)

// 仅当 hashKey 不存在时才设置 hash hashKey 的值。
redisTemplate.opsForHash().putIfAbsent(H key, HK hashKey, HV value)

// 删除给定的hash hashKeys
redisTemplate.opsForHash().delete(H key, Object... hashKeys)

// 确定给定的hash hashKey 是否存在
redisTemplate.opsForHash().hasKey(H key, Object hashKey)

// 通过给定的增量增加hash hashKey 的值
redisTemplate.opsForHash().increment(H key, HK hashKey, double increment)
redisTemplate.opsForHash().increment(H key, HK hashKey, long increment)

// 在 key 处获取 hash 的 hashKey 集（字段）
redisTemplate.opsForHash().keys(H key)

// 获取 key 的 hash 大小。
redisTemplate.opsForHash().size(H key)

// 在 key 处获取 hash 的值
redisTemplate.opsForHash().values(H key)

// 查看匹配的键值对
redisTemplate.opsForHash().scan(H key, ScanOptions options)

 

4.RedisTemplate.opsForList() 方法

// 从 key 的 list 中获取索引处的元素
redisTemplate.opsForList().index(K key, long index)

// 从 key 的 list 中获取 start 和 end 之间的元素
redisTemplate.opsForList().range(K key, long start, long end)

// 为 key 添加值
redisTemplate.opsForList().leftPush(K key, V value)

// 将值添加到 key 中
redisTemplate.opsForList().leftPushAll(K key, Collection<V> values)

// 仅当 list 存在时，才将值添加到 key 中
redisTemplate.opsForList().leftPushIfPresent(K key, V value)

// 在 pivot 之前将值添加到 key 中
redisTemplate.opsForList().leftPush(K key, V pivot, V value)

// 将值附加到 key
redisTemplate.opsForList().rightPush(K key, V value)
redisTemplate.opsForList().rightPushAll(K key, Collection<V> values)

// 在 pivot 之后将值添加到 key 中
redisTemplate.opsForList().rightPush(K key, V pivot, V value)

// 在列表元素的索引处设置值
redisTemplate.opsForList().set(K key, long index, V value)

// 删除并返回存储在 key 的列表中的第一个元素、
redisTemplate.opsForList().leftPop(K key)
redisTemplate.opsForList().leftPop(K key, Duration timeout)
redisTemplate.opsForList().leftPop(K key, long count)
redisTemplate.opsForList().leftPop(K key, long timeout, TimeUnit unit)

// 删除并返回存储在 key 的列表中的最后一个元素
redisTemplate.opsForList().rightPop(K key)
redisTemplate.opsForList().rightPop(K key, Duration timeout)
redisTemplate.opsForList().rightPop(K key, long count)
redisTemplate.opsForList().rightPop(K key, long timeout, TimeUnit unit)

// 从 sourceKey 的列表中删除最后一个元素，将其附加到 destinationKey 并返回其值
redisTemplate.opsForList().rightPopAndLeftPush(K sourceKey, K destinationKey)
redisTemplate.opsForList().rightPopAndLeftPush(K sourceKey, K destinationKey, Duration timeout)

// 从存储在 key 的列表中删除第一个 count 出现的 value
redisTemplate.opsForList().remove(K key, long count, Object value)

// 在 start 和 end 之间的元素的 key 处修剪列表
redisTemplate.opsForList().trim(K key, long start, long end)

// 获取存储在 key 的列表的大小
redisTemplate.opsForList().size(K key)

 

5.RedisTemplate.opsForSet() 方法

// 在 key 的 set 中添加给定值
redisTemplate.opsForSet().add(K key, V... values)

// 在 key 的 set 中删除给定值并返回已删除元素的数量
redisTemplate.opsForSet().remove(K key, Object... values)

// 从 key 的 set 中移除并返回一个随机成员
redisTemplate.opsForSet().    pop(K key)

// 在 key 处获取集合的大小
redisTemplate.opsForSet().size(K key)

// 检查在 key 的 set 中是否包含值
redisTemplate.opsForSet().isMember(K key, Object o)

// 返回在 key 和 otherKeys 处与所有给定 sets 相交的成员
redisTemplate.opsForSet().intersect(K key, Collection<K> otherKeys)

// 在 key 和 otherKeys 处与所有给定 sets 相交，并将结果存储在 destKey 中
redisTemplate.opsForSet().intersectAndStore(K key, Collection<K> otherKeys, K destKey)

// 在 key 和 otherKey 处相交所有给定的 sets，并将结果存储在 destKey 中
redisTemplate.opsForSet().intersectAndStore(K key, K otherKey, K destKey)

// 合并给定 key 和 otherKey 的所有 sets
redisTemplate.opsForSet().union(K key, K otherKey)

// 将给定 key 和 otherKey 处的所有 set 合并，并将结果存储在 destKey 中
redisTemplate.opsForSet().unionAndStore(K key, K otherKey, K destKey)

// 获取差集
redisTemplate.opsForSet().difference(key, otherKeys)

// 获取差集并存储到destKey
redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)

// 随机获取集合中的一个元素
redisTemplate.opsForSet().randomMember(key)

// 获取集合中的所有元素
redisTemplate.opsForSet().members(key)

// 随机获取集合中count个值
redisTemplate.opsForSet().randomMembers(key, count)

// 随机获取集合中count个值，但是去重
redisTemplate.opsForSet().distinctRandomMembers(key, count)

// 遍历set
redisTemplate.opsForSet().scan(key, options)

 

6.RedisTemplate.opsForZSet() 方法

// 添加元素，从小到大排序
redisTemplate.opsForZSet().add(key, value, score)

// 删除多个values的值
redisTemplate.opsForZSet().remove(key, values)

// 增加元素的score值同时返回增加后的值
redisTemplate.opsForZSet().incrementScore(key, value, delta)

// 返回元素在集合的从小到大排名
redisTemplate.opsForZSet().rank(key, value)

// 返回元素在集合的由大到小排名
redisTemplate.opsForZSet().reverseRank(key, value)

// 获取集合中指定区间的元素
redisTemplate.opsForZSet().reverseRangeWithScores(key, start,end)

// 查询集合中的元素并从小到大排序
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)
redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max)

// 从高到低的排序，然后获取最小与最大值之间的值
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)

// 根据score值获取元素数量
redisTemplate.opsForZSet().incrementScore(key, value, delta)

// 获取集合的大小
redisTemplate.opsForZSet().size(key)redisTemplate.opsForZSet().zCard(key)

// 获取集合中key、value元素的score值
redisTemplate.opsForZSet().score(key, value)

// 移除指定索引元素
redisTemplate.opsForZSet().removeRange(key, start, end)

// 移除指定score范围的集合成员
redisTemplate.opsForZSet().removeRangeByScore(key, min, max)

// 获取key和otherKey的并集并存储在 destKey 中
redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)

// 获取key和otherKey的交集并存储在 destKey 中
redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)