randomKey

public K randomKey()

从redis的key集合中随机返回一个key，如果key集合为空，则返回null

expireAt

public Boolean expireAt(K key, Date date)

为指定key的键值对设置过期时间（在什么时间过期），如果key不存在返回false，设置成功返回true

expire

default Boolean expire(K key, Duration timeout)

参数说明

  1. key： 键

  2. Duration：多少时间后过期，可以传入不同的Duration对象来表示时间

    如下所示，就不演示了

    image-20221013143521616

Boolean expire(K var1, long var2, TimeUnit var4)

参数说明

  1. var1：key
  2. var2： 多少个单位时间
  3. var4： 单位时间，TimeUnit是一个枚举类，有以下几个枚举值
    1. NANOSECONDS：纳秒
    2. MICROSECONDS微秒
    3. MILLISECONDS：毫秒
    4. SECONDS：秒
    5. MINUTES：分
    6. HOURS：时
    7. DAYS：天

举例说明

1
2
3
4
5
6
7
redisTemplate.expire("k2", 1000, TimeUnit.NANOSECONDS); // 1000纳秒后过期
redisTemplate.expire("k2", 1000, TimeUnit.MICROSECONDS);// 1000微秒后过期
redisTemplate.expire("k2", 1000, TimeUnit.MILLISECONDS);// 1000毫秒后过期
redisTemplate.expire("k2", 1000, TimeUnit.SECONDS);     // 1000秒后过期
redisTemplate.expire("k2", 1000, TimeUnit.MINUTES);     // 1000分钟后过期
redisTemplate.expire("k2", 1000, TimeUnit.HOURS);       // 1000小时后过期
redisTemplate.expire("k2", 1000, TimeUnit.DAYS);        // 1000天后过期

delete

Boolean delete(K var1)

删除key为var1的键值对，删除成功返回true，删除失败返回false，如key本身就不存在

Long delete(Collection<K> var1)

传入key集合，删除key集合中对应的键值对，返回成功删除的个数

Boolean unlink(K var1)

仅将var1s从keyspace元数据中删除，真正的删除会在后续异步操作

Long unlink(Collection<K> var1)

同时unlink多个key

Type

public DataType type(K key)

返回key的类型，返回值为DataType

有以下几个枚举值

1
2
3
4
5
6
7
NONE("none"),
STRING("string"),
LIST("list"),
SET("set"),
ZSET("zset"),
HASH("hash"),
STREAM("stream");

rename

public void rename(K oldKey, K newKey)

将oldKey重命名为newKey

setEnableTransactionSupport

开启redis事务支持，默认不开启事务，需要手动开启

public void setEnableTransactionSupport(boolean enableTransactionSupport)

mutli

public void multi()

开启redis事务

exec

public List<Object> exec()

需要配合mutli使用

提交事务，返回事务期间执行过操作的返回值的List集合（无返回值的不输出），使用默认的RedisSerializer来反序列化

官方解释

]Execute a transaction, using the default RedisSerializers to deserialize any results that are byte[]s or Collections or Maps of byte[]s or Tuples. Other result types (Long, Boolean, etc) are left as-is in the converted results. If conversion of tx results has been disabled in the RedisConnectionFactory the results of exec will be returned without deserialization. This check is mostly for backwards compatibility with 1.0.

public List<Object> exec(RedisSerializer<?> valueSerializer)

提交事务，指定RedisSerializer来反序列化

官方解释

Execute a transaction, using the provided RedisSerializerto deserialize any results that are byte[]s or Collections of byte[]s. If a result is a Map, the provided RedisSerializer will be used for both the keys and values. Other result types (Long, Boolean, etc) are left as-is in the converted results. Tuple results are automatically converted to TypedTuples.

1
2
3
4
5
6
7
8
9
10
redisTemplate.setEnableTransactionSupport(true); //开启事务支持
redisTemplate.multi(); // 开启事务
redisTemplate.opsForValue().set("k1", "v1"); // true
redisTemplate.randomKey(); // k1
redisTemplate.expireAt("k1", new Date(System.currentTimeMillis() + 1000 * 60)); // true
redisTemplate.type("k1"); // STRING
redisTemplate.rename("k1", "k2");
System.out.println(redisTemplate.exec()); // 提交事务
// 输出结果
// [true, k1, true, STRING]

discard

public void discard()

回滚事务，需要配合mutli使用

watch

void watch(K key)

在事务期间，监听key的变化

void watch(Collection<K> keys)

在事务期间，监听keys的变化

unwatch

public void unwatch()

取消对所有key的监听

move

public Boolean move(K key, int dbIndex)

移动键为key的键值对到索引为dbIndex的库去

移动成功返回true，移动失败返回false（如键值对本来就不存在）

dump

public byte[] dump(K key)

dump指定key

slaveOf

public void slaveOf(String host, int port)

用于在 Redis 运行时动态地修改复制(replication)功能的行为

slaveOfNoOne

public void slaveOfNoOne()

将服务器改为主服务器

afterPropertiesSet

public void afterPropertiesSet()

初始化RedisTemplate的一些参数设置

非spring注入使用RedisTemplate,需先调用afterPropertiesSet()方法

killClient

public void killClient(String host, int port)

关闭host:port的客户端连接

opsForValue

针对字符串的操作集合

set

void set(K var1, V var2)

设置键值对[var1, var2]

void set(K var1, V var2, long var3, TimeUnit var5)

设置键值对[var1, var2]，并且通过TimeUnit设置过期时间

default void set(K key, V value, Duration timeout)

设置键值对[var1, var2]，并且通过Duration设置过期时间

void set(K var1, V var2, long var3)

设置键值对[var1, var2]，并且设置过期时间为var3毫秒

setIfAbsent

Boolean setIfAbsent(K var1, V var2)

在键var1不存在时设置键值对[var1, var2]，

Boolean setIfAbsent(K var1, V var2, long var3, TimeUnit var5)

在键var1不存在时设置键值对[var1, var2]，并且通过TimeUnit设置过期时间

default Boolean setIfAbsent(K key, V value, Duration timeout)

在键var1不存在时设置键值对[var1, var2]，并且通过Duration设置过期时间

setIfAbsent

Boolean setIfPresent(K var1, V var2)

在键key存在时设置值为value

Boolean setIfPresent(K var1, V var2, long var3, TimeUnit var5)

在键key存在时设置值为value，并且通过TimeUnit设置过期时间

default Boolean setIfPresent(K key, V value, Duration timeout)

在键key存在时设置值为value，并且通过Duration设置过期时间

mutliSet

void multiSet(Map<? extends K, ? extends V> var1)

同时设置多个键值对

mutliGet

List<V> multiGet(Collection<K> var1)

根据给定的Key集合同时取出多个值

multiSetIfAbsent

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

同时设置多个键值对当且仅当对应的键不存在时设置

get

V get(Object var1)

取出键为var1的键值对对应的值

String get(K var1, long var2, long var4)

获得键为var1的键值对对应在区间[var2, var4)之间的子字符串

increment

Long increment(K var1)

将键为var1键值对的值增加1

Long increment(K var1, long var2)

将键为var1键值对的值增加var2

Double increment(K var1, double var2)

将键为var1键值对的值增加var2（浮点数）

decrement

Long decrement(K var1)

将键为var1键值对的值减少1

Long decrement(K var1, long var2)

将键为var1键值对的值减少var2

size

Long size(K var1)

获得键为var1的键值对对应的值的长度

append

Integer append(K var1, String var2)

将字符串var2追加都键为var1的键值对对应的值的后面

getAndSet

V getAndSet(K var1, V var2)

设置新值，返回旧值

opsForHash

针对哈希表的操作集合

put

void put(H var1, HK var2, HV var3)

将记录[var2, var3]加入键为var1的哈希表中

putAll

void putAll(H var1, Map<? extends HK, ? extends HV> var2)

将集合var2中的所有记录加入键为var1的哈希表中

putIfAbsent

Boolean putIfAbsent(H var1, HK var2, HV var3)

将记录[var2, var3]加入键为var1的哈希表中如果[var2, var3]不存在

size

Long size(H var1)

获得键为var1中的记录总数

delete

Long delete(H var1, Object... var2)

删除键在可变数组中var2中的键值对记录

hasKey

Boolean hasKey(H var1, Object var2)

判断哈希表var1中是否存在对应的哈希键var2

Keys

Set<HK> keys(H var1)

返回哈希表var1的所有哈希key集合

values

List<HV> values(H var1)

返回哈希表var1的所有哈希value集合

entries

Map<HK, HV> entries(H var1)

返回哈希表var1中所有哈希键值对的entries集合

lengthOfValue

Long lengthOfValue(H var1, HK var2)

返回哈希表var1中哈希键为var2的键值对对应的值的长度

get

HV get(H var1, Object var2)

取得哈希表var1哈希键为var2的值

increment

Long increment(H var1, HK var2, long var3)

将返回哈希表var1中哈希键为var2的键值对对应的值增加var3

double increment(H var1, HK var2, double var3)

将返回哈希表var1中哈希键为var2的键值对对应的值增加var3（double）

mutliGet

List<HV> multiGet(H var1, Collection<HK> var2)

同时取得多个哈希值

opsForList

针对列表的操作集合

set

void set(K var1, long var2, V var4)

设置列表var1的索引下标var2位置的值为var4

remove

Long remove(K var1, long var2, Object var4)

从列表var1的左边开始删除var2个值为var4的元素

size

Long size(K var1)

返回列表var1中的元素个数

range

List<V> range(K var1, long var2, long var4)

从列表var1中取出区间[var2, var4]的子列表

trim

void trim(K var1, long var2, long var4)

移除列表var1中在区间[var2, var4]的元素

leftPush/rightPush

Long leftPush(K var1, V var2)

在列表var1的左边/右边插入值为var2的元素

Long leftPush(K var1, V var2, V var3)

在列表var1的var2索引前/后插入var3

leftPushAll/rightPushAll

Long leftPushAll(K var1, V... var2)

在列表var1的左边/右边依次插入var2变长数组中的元素

Long leftPushAll(K var1, Collection<V> var2)

在列表var1的左边/右边依次插入var2集合中的元素

leftPushIfPresent/rightPushIfPresent

Long leftPushIfPresent(K var1, V var2)

在列表var1的左边/右边插入值为var2的元素当且仅当值var2不存在

leftPop/rightPop

V leftPop(K var1)

移除并返回从列表var1左边/右边开始第一个值为var1的元素

V leftPop(K var1, long var2, TimeUnit var4)

移除并返回从列表var1左边/右边开始第var4个值为var1的元素

default V leftPop(K key, Duration timeout)

在timeout时间后移除并返回从列表var1左边/右边开始第一个值为var1的元素

rightPopAndLeftPush

V rightPopAndLeftPush(K var1, K var2)

从var1的列表中移除最后一个元素，将其附加到var2的列表第一个元素前并返回其值

V rightPopAndLeftPush(K var1, K var2, long var3, TimeUnit var5)

在var3 TimeUnit时间后从var1的列表中移除最后一个元素，将其附加到var2的列表第一个元素前并返回其值

default V rightPopAndLeftPush(K sourceKey, K destinationKey, Duration timeout)

在timeout时间后从sourceKey的列表中移除最后一个元素，将其附加到destinationKey的列表第一个元素并返回其值

opsForSet

针对集合的操作

add

Long add(K var1, V... var2)

在集合var1中添加可变数组var2中的元素

remove

Long remove(K var1, Object... var2)

在集合var1中移除可变数组var2中的元素

isMemeber

Boolean isMember(K var1, Object var2)

判断var2是否是var1中

members

Set<V> members(K var1)

返回集合var1中所有的元素集合

randomMember

V randomMember(K var1)

随机从var1集合中返回一个元素

randomMembers

List<V> randomMembers(K var1, long var2)

随机从var1集合中返回var1个元素组成的list集合

distinctRandomMembers

Set<V> distinctRandomMembers(K var1, long var2)

随机从var1集合中返回var1个不同元素组成的list集合

pop

V pop(K var1)

从set集合var1中随机弹出一个元素

List<V> pop(K var1, long var2)

从set集合var1中随机弹出var2个元素组成的list集合

move

Boolean move(K var1, V var2, K var3)

将元素var2从var1集合移动到var2集合

size

Long size(K var1)

返回set集合var1中的元素个数

union/intersect/difference

Set<V> union(K var1, K var2)

返回set集合var1和set集合var2的并集/交集/补集

Set<V> union(K var1, Collection<K> var2)

返回set集合var1和Collection集合var2的并集/交集/补集

Set<V> union(Collection<K> var1)

返回集合key在var1中的元素集合的并集/交集/补集

unionAndStore/intersectAndStore/differenceAndStore

Long unionAndStore(K var1, K var2, K var3)

将set集合var1和set集合var2的并集/交集/补集存到集合var3中

Long unionAndStore(K var1, Collection<K> var2, K var3)

将set集合var1和Collection集合var2的并集/交集/补集存到集合var3中

Long unionAndStore(Collection<K> var1, K var2)

将集合key在var1中的元素集合的并集/交集/补集存到集合var2中

opsForZSet

针对有序集合ZSet的操作集合

add

Boolean add(K key, V value, double score)

将元素及其权重score放到有序集合key中

Long add(K key, Set<TypedTuple<V>> tuples)

将tuples集合中的元素及其权重放到有序集合key中

remove

Long remove(K key, Object... values)

将可变数组中的元素从有序结合key中移除

removeRange

Long removeRange(K key, long start, long end)

将有序集合key中在区间[start, end]中的元素移除

removeRangeByScore

Long removeRangeByScore(K key, double min, double max)

移除有序集合key权重在[min, max]之间的所有元素

size

Long size(K key)

返回有序集合Key中元素的个数

score

double score(K key, Object o)

给有序集合key中的元素o设置score

range

Set<V> range(K key, long start, long end)

升序

返回有序结合Key中排名在[start, end]中的元素集合

zCard

Long zCard(K key)

获得有序结合key中的元素个数

rangeWithScores|reverseRange

返回有序结合Key中排名在[start, end]中的元素集合（带权重）

升序：Set<TypedTuple<V>> rangeWithScores(K key, long start, long end)

降序： Set<V> reverseRange(K key, long start, long end)

rangeByScore|reverseRangeByScore

升序：Set<V> rangeByScore(K key, double min, double max)

降序： Set<V> reverseRangeByScore(K key, double min, double max)

返回有序集合Key中score在区间[min, max]中的有序集合

升序：Set<V> rangeByScore(K key, double min, double max, long offset, long count)

降序：Set<V> reverseRangeByScore(K key, double min, double max, long offset, long count)

返回有序集合Key中score在区间[min, max]中的有序集合在区间[offset, offset + count - 1] 返回的有序集合

rangeByScoreWithScores|rangeByScoreWithScores

升序：Set<TypedTuple<V>> rangeByScoreWithScores(K key, double min, double max)

降序：Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key, double min, double max)

返回有序集合Key中score在区间[min, max]中的有序集合（带权重）

升序：Set<TypedTuple<V>> rangeByScoreWithScores(K key, double min, double max, long offset, long count)

降序：Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key, double min, double max, long offset, long count)

返回有序集合Key中score在区间[min, max]中的有序集合在区间[offset, offset + count - 1] 返回的有序集合（带权重）

rangeByLex

Set<V> rangeByLex(K key, Range range)

返回有序集合key中在[range.getMin, range.getMax]中的有序集合

Set<V> rangeByLex(K key, Range range, Limit limit)

返回有序集合key中在[range.getMin, range.getMax]中的前limit个元素组成的有序集合

rank

Long rank(K key, Object o)

返回集合升序排列时元素o的排名

reverseRank

Long reverseRank(K key, Object o)

返回集合降序排列时元素o的排名

count

Long count(K key, double min, double max)

返回有序集合key中score中[min, max]中的元素个数

incrementScore

Double (K key, V value, double delta)

将有序集合key中value的score增加delta（浮点数）

intersectAndStore | unionAndStore

Long intersectAndStore|unionAndStore(K key, K otherKey, K destKey)

将有序集合key和有序集合otherKey中的交集存到有序集合destKey中，并返回交集个数

Long intersectAndStore|unionAndStore(K key, Collection<K> otherKeys, K destKey)

将有序集合key和有序集合（多个集合）otherKeys中的交集存到有序集合destKey中，并返回交集个数

default Long intersectAndStore|unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate)

将有序集合key和有序集合（多个集合）otherKeys中的交集存到有序集合destKey中，并返回交集个数，按照聚合规则Aggregate

Aggregate枚举类

MAX:最大值

MIN:最小值

SUM:总和

Sort aggregation operations

排序聚合操作

Long intersectAndStore|unionAndStore(K key, Collection<K> otherKeys, K destKey, Aggregate aggregate, Weights weights)

将有序集合key和有序集合（多个集合）otherKeys中的交集存到有序集合destKey中，并返回交集个数，按照聚合规则Aggregate和乘法因子Weight

Weight说明

Value object encapsulating a multiplication factor for each input sorted set. This means that the score of every element in every input sorted set is multiplied by this factor before being passed to the aggregation function

对象封装每个输入排序集的乘法因子。这意味着在传递给聚合函数之前，每个输入排序集中每个元素的得分都要乘以这个因子