RedisTemplate常用方法总结（参考官方文档2.6.2）

╰半橙微兮° 2023-10-01 20:21 31阅读 0赞

--------------------

title: RedisTemplate常用方法总结（参考官方文档2.6.2）  
date: 2022-02-27 03:40:27  
tags:

*  Redis  
    categories:
 *  Redis  
    cover: https://cover.png  
    feature: false

--------------------

#### 文章目录 ####

*  1. 简介
 *   *  1.1 类继承关系
     *  1.2 方法
     *  1.3 功能介绍
 *  2. RedisTemplate 顶层方法
 *  3. RedisTemplate.opsForValue() 方法
 *  4. RedisTemplate.opsForHash() 方法
 *  5. RedisTemplate.opsForList() 方法
 *  6. RedisTemplate.opsForSet() 方法
 *  7. RedisTemplate.opsForZSet() 方法

## 1. 简介 ##

RedisTemplate 是 Spring Data Redis 提供给用户的最高级的抽象客户端，用户可直接通过 RedisTemplate进行多种操作

### 1.1 类继承关系 ###

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
        
    }

*  RedisAccessor：Base class for RedisTemplate defining common properties. Not intended to be used directly.  
    RedisTemplate 定义通用属性的基类。不打算直接使用
 *  RedisOperations：Interface that specified a basic set of Redis operations, implemented by RedisTemplate. Not often used but a useful option for extensibility and testability (as it can be easily mocked or stubbed).  
    指定一组基本 Redis 操作的接口，由 RedisTemplate 实现。不经常使用，但对于可扩展性和可测试性来说是一个有用的选项（因为它可以很容易地被模拟或存根）
 *  BeanClassLoaderAware：Callback that allows a bean to be aware of the bean class loader; that is, the class loader used by the present bean factory to load bean classes. This is mainly intended to be implemented by framework classes which have to pick up application classes by name despite themselves potentially being loaded from a shared class loader.  
    允许 bean 知道 bean 类加载器的回调；也就是当前bean工厂用来加载bean类的类加载器。这主要是由框架类实现的，这些框架类必须按名称选择应用程序类，尽管它们可能是从共享类加载器加载的

### 1.2 方法 ###

// 配置默认序列化与反序列化工具类
    1.afterPropertiesSet
    // 根据参数执行相关operation操作，例如，事务
    2.execute
    // 执行pipelining流水线相关操作
    3.executePipelined
    // 执行指定connection连接的相关操作
    4.executeWithStickyConnection
    // 执行session内的execute方法
    5.executeSession
    // 创建RedisConnection代理类
    6.createRedisConnectionProxy
    // connection连接的预处理
    7.preProcessConnection
    // 结果的后处理，默认什么都不做
    8.postProcessResult
    // 是否向RedisCallback暴露本地连接
    9.isExposeConnection
    // 设置是否向RedisCallback暴露本地连接
    10.setExposeConnection
    // 12到26都是设置和获取相关序列化工具类
    11.isEnableDefaultSerializer
    12.setEnableDefaultSerializer
    13.getDefaultSerializer
    14.setDefaultSerializer
    15.setKeySerializer
    16.getKeySerializer
    17.setValueSerializer
    18.getValueSerializer
    19.getHashKeySerializer
    20.setHashKeySerializer
    21.getHashValueSerializer
    22.setHashValueSerializer
    23.getStringSerializer
    24.setStringSerializer
    25.setScriptExecutor
    // 27到34为私有方法，不对外提供使用
    26.rawKey
    27.rawString
    28.rawValue
    29.rawKeys
    30.deserializeKey
    31.deserializeMixedResults
    32.deserializeSet
    33.convertTupleValues
    // 执行事务
    34.exec
    35.execRaw
    // 删除操作
    36.delete
    // 接触链接
    37.unlink
    // 查看是否含有指定key
    38.hasKey
    39.countExistingKeys
    // 设置过期时间
    40.expire
    41.expireAt
    // 转换成字节流并向channel发送message
    42.convertAndSend
    // 获取过期时间
    43.getExpire
    // 根据传入的正则表达式返回所有的key
    44.keys
    // 取消指定key的过期时间
    45.persist
    // 移动指定的key和index到数据库中
    46.move
    // 从键空间随机获取一个key
    47.randomKey
    // 将指定key改成目标key
    48.rename
    // key不存在时，将指定key改成目标key
    49.renameIfAbsent
    // 设置存储在指定key的类型
    50.type
    // 检索存储在key的值的序列化版本
    51.dump
    // 执行Redis的restore的命令
    52.restore
    // 标记事务阻塞的开始
    53.multi
    // 丢弃所有在multi之后发出的命令
    54.discard
    // 观察指定key在事务处理开始即multi之后的修改情况
    55.watch
    // 刷新先前观察的所有key
    56.unwatch
    // 为key元素排序
    57.sort
    // 关闭客户端连接
    58.killClient
    // 请求连接客户端的相关信息和统计数据
    59.getClientList
    // 更改复制配置到新的master
    60.slaveOf
    // 将本机更改为master
    61.slaveOfNoOne
    // 64到79都是获取相对应的操作
    62.opsForCluster
    63.opsForGeo
    64.boundGeoOps
    65.boundHashOps
    66.opsForHash
    67.opsForHyperLogLog
    68.opsForList
    69.boundListOps
    70.boundSetOps
    71.opsForSet
    72.opsForStream
    73.boundStreamOps
    74.boundValueOps
    75.opsForValue
    76.boundZSetOps
    77.opsForZSet
    // 设置是否支持事务
    78.setEnableTransactionSupport
    // 设置bean的类加载器
    79.setBeanClassLoader

### 1.3 功能介绍 ###

spring-data-redis 提供了如下功能：

1.  连接池自动管理，提供了一个高度封装的“RedisTemplate”类
2.  进行了归类封装,将同一类型操作封装为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，是“newString(bytes,charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略
     *  JacksonJsonRedisSerializer：jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂
     *  OxmSerializer：提供了将javabean与xml之间的转换能力，目前可用的三方支持包括jaxb，apache-xmlbeans；redis存储的数据将是xml工具。不过使用此策略，编程将会有些难度，而且效率最低；不建议使用。【需要spring-oxm模块的支持】
    
    如果你的数据需要被第三方工具解析，那么数据应该使用 StringRedisSerializer 而不是 JdkSerializationRedisSerializer

## 2. RedisTemplate 顶层方法 ##

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

## 3. RedisTemplate.opsForValue() 方法 ##

1.  设置 key 跟 value 的值
    
        redisTemplate.opsForValue().set(K key, V value)
2.  获取 key 的值
    
        redisTemplate.opsForValue().get(Object key)
3.  设置key跟value的值，同时设置过期时间
    
        redisTemplate.opsForValue().set(K key, V value, Duration timeout)
4.  在 start 和 end 之间获取键值的子字符串
    
        redisTemplate.opsForValue().get(K key, long start, long end)
5.  设置 key 的值并返回其旧值
    
        redisTemplate.opsForValue().getAndSet(K key, V value)
6.  获取多个 key
    
        redisTemplate.opsForValue().multiGet(Collection<K> keys)
7.  获取原来的key的值后在后面新增上新的字符串
    
        redisTemplate.opsForValue().append(K key, String value)
8.  增量方式增加double值
    
        redisTemplate.opsForValue().increment(K key, double increment)
9.  通过increment(K key, long delta)方法以增量方式存储long值（正值则自增，负值则自减）
    
        redisTemplate.opsForValue().increment(K key, long increment)
10. 仅当提供的 key 不存在时，才使用集合中提供的键值对将多个 key 设置为多个值。
    
        redisTemplate.opsForValue().multiSetIfAbsent(Map<? extends K,? extends V> map)
11. 使用集合中提供的键值对将多个 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)
12. 获取指定key的字符串的长度
    
        redisTemplate.opsForValue().size(K key)
13. 用给定值覆盖从指定偏移量开始的 key 的部分。
    
        redisTemplate.opsForValue().set(K key, V value, long offset)
14. 如果 key 不存在，则设置 key 以保存字符串值，存在返回false，否则返回true
    
        redisTemplate.opsForValue().setIfAbsent(key, value)
15. 重新设置key的值并加入过期时间
    
        redisTemplate.opsForValue().set(key, value, timeout, unit)
16. 将二进制第offset位值变为value
    
        redisTemplate.opsForValue().setBit(K key, long offset, boolean value)
17. 对key所储存的字符串值，获取指定偏移量上的位(bit)
    
        redisTemplate.opsForValue().getBit(K key, long offset)

## 4. RedisTemplate.opsForHash() 方法 ##

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

## 5. RedisTemplate.opsForList() 方法 ##

1.  从 key 的 list 中获取索引处的元素
    
        redisTemplate.opsForList().index(K key, long index)
2.  从 key 的 list 中获取 start 和 end 之间的元素
    
        redisTemplate.opsForList().range(K key, long start, long end)
3.  为 key 添加值
    
        redisTemplate.opsForList().leftPush(K key, V value)
4.  将值添加到 key 中
    
        redisTemplate.opsForList().leftPushAll(K key, Collection<V> values)
5.  仅当 list 存在时，才将值添加到 key 中
    
        redisTemplate.opsForList().leftPushIfPresent(K key, V value)
6.  在 pivot 之前将值添加到 key 中
    
        redisTemplate.opsForList().leftPush(K key, V pivot, V value)
7.  将值附加到 key
    
        redisTemplate.opsForList().rightPush(K key, V value)
        redisTemplate.opsForList().rightPushAll(K key, Collection<V> values)
8.  在 pivot 之后将值添加到 key 中
    
        redisTemplate.opsForList().rightPush(K key, V pivot, V value)
9.  在列表元素的索引处设置值
    
        redisTemplate.opsForList().set(K key, long index, V value)
10. 删除并返回存储在 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)
11. 删除并返回存储在 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)
12. 从 sourceKey 的列表中删除最后一个元素，将其附加到 destinationKey 并返回其值
    
        redisTemplate.opsForList().rightPopAndLeftPush(K sourceKey, K destinationKey)
        redisTemplate.opsForList().rightPopAndLeftPush(K sourceKey, K destinationKey, Duration timeout)
13. 从存储在 key 的列表中删除第一个 count 出现的 value
    
        redisTemplate.opsForList().remove(K key, long count, Object value)
14. 在 start 和 end 之间的元素的 key 处修剪列表
    
        redisTemplate.opsForList().trim(K key, long start, long end)
15. 获取存储在 key 的列表的大小
    
        redisTemplate.opsForList().size(K key)

## 6. RedisTemplate.opsForSet() 方法 ##

1.  在 key 的 set 中添加给定值
    
        redisTemplate.opsForSet().add(K key, V... values)
2.  在 key 的 set 中删除给定值并返回已删除元素的数量
    
        redisTemplate.opsForSet().remove(K key, Object... values)
3.  从 key 的 set 中移除并返回一个随机成员
    
        redisTemplate.opsForSet().	pop(K key)
4.  在 key 处获取集合的大小
    
        redisTemplate.opsForSet().size(K key)
5.  检查在 key 的 set 中是否包含值
    
        redisTemplate.opsForSet().isMember(K key, Object o)
6.  返回在 key 和 otherKeys 处与所有给定 sets 相交的成员
    
        redisTemplate.opsForSet().intersect(K key, Collection<K> otherKeys)
7.  在 key 和 otherKeys 处与所有给定 sets 相交，并将结果存储在 destKey 中
    
        redisTemplate.opsForSet().intersectAndStore(K key, Collection<K> otherKeys, K destKey)
8.  在 key 和 otherKey 处相交所有给定的 sets，并将结果存储在 destKey 中
    
        redisTemplate.opsForSet().intersectAndStore(K key, K otherKey, K destKey)
9.  合并给定 key 和 otherKey 的所有 sets
    
        redisTemplate.opsForSet().union(K key, K otherKey)
10. 将给定 key 和 otherKey 处的所有 set 合并，并将结果存储在 destKey 中
    
        redisTemplate.opsForSet().unionAndStore(K key, K otherKey, K destKey)
11. 获取差集
    
        redisTemplate.opsForSet().difference(key, otherKeys)
12. 获取差集并存储到destKey
    
        redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)
13. 随机获取集合中的一个元素
    
        redisTemplate.opsForSet().randomMember(key)
14. 获取集合中的所有元素
    
        redisTemplate.opsForSet().members(key)
15. 随机获取集合中count个值
    
        redisTemplate.opsForSet().randomMembers(key, count)
16. 随机获取集合中count个值，但是去重
    
        redisTemplate.opsForSet().distinctRandomMembers(key, count)
17. 遍历set
    
        redisTemplate.opsForSet().scan(key, options)

## 7. RedisTemplate.opsForZSet() 方法 ##

1.  添加元素，从小到大排序
    
        redisTemplate.opsForZSet().add(key, value, score)
2.  删除多个values的值
    
        redisTemplate.opsForZSet().remove(key, values)
3.  增加元素的score值同时返回增加后的值
    
        redisTemplate.opsForZSet().incrementScore(key, value, delta)
4.  返回元素在集合的从小到大排名
    
        redisTemplate.opsForZSet().rank(key, value)
5.  返回元素在集合的由大到小排名
    
        redisTemplate.opsForZSet().reverseRank(key, value)
6.  获取集合中指定区间的元素
    
        redisTemplate.opsForZSet().reverseRangeWithScores(key, start,end)
7.  查询集合中的元素并从小到大排序
    
        redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)
        redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max)
8.  从高到低的排序，然后获取最小与最大值之间的值
    
        redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)
9.  根据score值获取元素数量
    
        redisTemplate.opsForZSet().incrementScore(key, value, delta)
10. 获取集合的大小
    
        redisTemplate.opsForZSet().size(key)redisTemplate.opsForZSet().zCard(key)
11. 获取集合中key、value元素的score值
    
        redisTemplate.opsForZSet().score(key, value)
12. 移除指定索引元素
    
        redisTemplate.opsForZSet().removeRange(key, start, end)
13. 移除指定score范围的集合成员
    
        redisTemplate.opsForZSet().removeRangeByScore(key, min, max)
14. 获取key和otherKey的并集并存储在 destKey 中
    
        redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)
15. 获取key和otherKey的交集并存储在 destKey 中
    
        redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)