RedisTemplate/StringRedisTemplate常用API

kimi-001

已于 2024-04-16 11:12:23 修改

阅读量1.7k

点赞数

分类专栏： Redis 文章标签： java redis 数据库

于 2023-01-28 10:08:23 首次发布

本文链接：https://blog.csdn.net/weixin_43476020/article/details/128775293

版权

Redis 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

文章目录

一、注入
二、API

一、注入

由于StringRedisTemplate继承自RedisTemplate，所以他们的方法基本一样

//无需泛型，key、value都是String
@Autowired
private StringRedisTemplate stringRedisTemplate;

//使用@Autowired，不能加泛型，否则会注入失败；不加泛型更灵活，这样方法中可以使用任意Operations泛型：...Operations<K,V> operations=redisTemplate.opsFor...()，虽然会警告，但都可以正常使用
@Autowired
private RedisTemplate redisTemplate;

二、API

1、redisTemplate

1、局部序列化

//获取key、value序列化器
RedisSerializer keySerializer=redisTemplate.getKeySerializer();
RedisSerializer valueSerializer=redisTemplate.getValueSerializer();

//获取hashKey、hashValue序列化器
RedisSerializer<?> redisTemplate.getHashKeySerializer();
RedisSerializer<?> redisTemplate.getHashValueSerializer();

//设置key、value序列化器
void redisTemplate.setKeySerializer(RedisSerializer<?> serializer);
void redisTemplate.setValueSerializer(RedisSerializer<?> serializer);

//设置hashKey、hashValue序列化器
void setHashKeySerializer(RedisSerializer<?> hashKeySerializer);
void setHashValueSerializer(RedisSerializer<?> hashValueSerializer);

2、检查key是否存在

Boolean redisTemplate.hasKey("rafa");

3、计算存在key数量

Long countExistingKeys(Collection<K> keys);

4、根据key删除缓存

//单个，返回是否删除成功
Boolean redisTemplate.delete("test");

//批量，返回删除的个数
Long redisTemplate.delete(Collection c);

5、设置过期时间

Boolean expireAt(K key, Date date);

/**
 * TimeUnit时间分量
 *      TimeUnit.MILLISECONDS 毫秒
 *      TimeUnit.SECONDS
 *      TimeUnit.MINUTES
 *      TimeUnit.HOURS
 *      TimeUnit.DAYS
 */
Boolean expire(K key, long timeout, TimeUnit unit);

6、根据key获取过期时间

//key永不过期返回-1；key不存在返回-2

//默认按秒
Long getExpire(K key);

//自定义时间分量
Long getExpire(String key,TimeUnit.MINUTES);

7、key重命名

//oldKey不存在时-异常
//newKey存在时：oldKey会删除，会将存在的newKey的值覆盖
void redisTemplate.rename(oldKey, newKey)

//oldKey不存在时 - 异常；newKey存在时 - false
Boolean redisTemplate.renameIfAbsent(oldKey, newKey)

8、查找匹配的key值

Set<String> redisTemplate.keys("ss:*");
//使用keys *进行模糊匹配引发Redis锁（因为redis单线程，keys会阻塞），造成Redis锁住，CPU飙升，引起了所有调用链路的超时并且卡住，其他的redis请求都会被堵塞；业务量大的时候会出问题，可使用scan代替

2、ValueOperations 字符串

1、获取

ValueOperations<K, V>  redisTemplate.opsForValue();

2、 set

void set(K key, V value);

//设置过期时间，Duration.ofDays(1L)
void set(K key, V value, Duration timeout);

//设置过期时间
void set(K key, V value, final long timeout, final TimeUnit unit);

//替换从指定位置开始的字串
void set(K key, V value, long offset);

//set value，返回set之前的值
V getAndSet(K key, V newValue);

//批量set
void multiSet(Map<K,V> map);

//key不存在才会set进去，返回true；key存在不会set，返回false
Boolean setIfAbsent(K key, V value)
Boolean setIfAbsent(K key, V value, Duration timeout)
Boolean setIfAbsent(K key, V value, long timeout, TimeUnit unit)

//key存在才会set进去，返回true；key不存在不会set，返回false
Boolean setIfPresent(K key, V value);
Boolean setIfPresent(K key, V value, Duration timeout);
Boolean setIfPresent(K key, V value, long timeout, TimeUnit unit);

3、 get

//当其他工程需要该实体类进行反序列化时要满足：1.serialVersionUID要一致；2.反序列的对象和反序列化的对象所属的包名一致

V get(Object key)

//获取指定位置的子串
String get(K key, long start, long end);

//根据key集合获取
List<V> multiGet(Collection<K> keys);

4、字符串长度

Long size(K key);

5、末尾追加

//返回追加后字符串长度
Integer append(K key, String value);

6、递增

将key储存的值加上增量，如果key不存在，那 key的值会先被初始化为 0 ，然后再执行相加，如果值包含错误的类型的值不能表示为数字，返回一个错误
若key设置了过期时间，会保持时间正常走，并不会因为增/减而将过期时间重置

/**
 * 异常：JedisDataException: ERR value is not an integer or out of range，该异常就是使用该api时，序列化策略有问题
 * 
 * GenericJackson2JsonRedisSerializer、Jackson2JsonRedisSerializer：是先将对象转为json，然后再保存到redis，value在redis中是字符串，无法进行加、减
 * JdkSerializationRedisSerializer使用的jdk对象序列化，序列化后的值有类信息、版本号等，是一个包含很多字母的字符串，无法加、减
 * GenericToStringSerializer、StringRedisSerializer将字符串的值直接转为字节数组，保存到redis中是数字，可以进行加、减
 *
 * 解决：
 *     1.使用StringRedisTemplate
 *     2.redis全局设置的value序列化无法修改, 先局部设置value的序列化，再set、加减存入的value一定要是String类型，不要Long、Double、Integer：valueOperations.set(key,String.valueOf(batch));
 */

//加，返回加之后的值
//+1
Long increment(String key);

Long increment(String key, long delta);
Double increment(String key, double delta);

//减，返回减之后的值
//-1
Long decrement(K key);

Long decrement(K key, long delta);

3、hash 散列

1、获取

HashOperations<K,HK,HV>	redisTemplate.opsForHash();

2、新增

void put(key, hashKey, value);

//不存在才会set进去；返回：不存在-true，存在-false
Boolean putIfAbsent(key, hashKey, value);

//新增一个Map
void putAll(key, Map map);

3、获取

//获取一条键值对
Object get(key, hashKey);

//获取该key的所有的键值对
Map<Object,Object> entries("map")

//获取该key的所有value
List<Object> values("map");

4、获取该key的所有hashKey

Set<Object> keys("map");

5、获取该key的键值对记录数

Long size("map");

8、指定key的指定hashkey是否存在

Boolean hasKey(key, hashKey);

9、删除

Long delete(key, Object... hashKeys);

10、递增

Long increment(String key,String hashKey, long delta);
Double increment(String key,String hashKey, double delta);

4、List 列表

1、获取

ListOperations<String,T> opsForList=redisTemplate.opsForList();

2、长度

Long size(key)

3、获取指定下标的元素

V index(key, index)

4、添加元素

//左侧
//返回添加后集合的长度
Long leftPush(key, value)
Long leftPushAll(K key, V... values)
Long leftPushAll(K key, Collection<V> values)

//如果key存在则添加，否则返回0
Long leftPushIfPresent(K key, V value)

//右侧~左侧

//指定下标处添加
void set(K key, final long index, V value)

5、获取指定区间的元素

//start、end：首尾下标；0 - -1获取集合的所有元素
List<T> range(key,long start, long end)

6、删除并返回元素

//左侧
V leftPop(key)
V leftPop(K key, long timeout, TimeUnit unit)
//如果在设置的超时时间内集合中仍为空，则退出

//右侧~左侧

//右侧移出一个元素，添加到另一个集合左侧
//返回移出元素
V rightPopAndLeftPush(K sourceKey, K destinationKey)
V rightPopAndLeftPush(K sourceKey, K destinationKey, long timeout,TimeUnit unit)

7、删除元素

//根据值、数量，返回删除的元素数量
Long remove(K key, long count, Object value)
//count=0：删除元素值=value的所有元素
//count>0：删除从左侧开始的count个元素
//count<0：删除从右侧开始的count个元素

//保留指定区间元素，其余删除
void trim(K key, final long start, final long end)

5、Set 无序集合

1、获取

SetOperations<K,V>  redisTemplate.opsForSet();

2、集合大小

//key不存在时=0
Long size(key)

3、元素是否存在

//存入时的key、value的序列化器和判断时的序列化器一定要相同，否则即使两个元素一样，也会输出不存在
Boolean isMember(key, value)

4、添加元素

//返回添加后的集合长度
//添加的元素是集合中存在的元素时，不会添加
Long add(K key, V... values)

5、移除元素

//返回移除后的集合长度
Long remove(K key, Object... values)

6、获取所有元素

//key不存在或没有一个元素时，set的=empty，!=null
Set<T> members(key)

7、随机获取集合中元素

//1个
V randomMember(String key)

//多个
List<V> randomMembers(String key, long count)

//多个并去重，如果指定2个，去重后可能返回的是一个元素
Set<V> distinctRandomMembers(K key, long count)

8、将一个集合中的元素移动至另一个集合

Boolean move(String key, V value, String destKey)

9、移除并返回几个随机的元素

//1个
V pop(K key)

//多个
List<V> pop(K key, long count)

10、交集

//返回key与otherKey的交集
Set<V> intersect(String key, String otherKey)

//返回key与otherKey多个集合的交集
Set<V> intersect(K key, Collection<K> otherKeys)

//key与otherKey集合交集存入destKey集合中，返回交集元素个数
Long intersectAndStore(String key, String otherKey, String destKey)

//key与otherKey多个集合交集存入destKey集合中，返回交集元素个数
Long intersectAndStore(K key, Collection<K> otherKeys, K destKey)

11、并集

//返回key与otherKey的并集
Set<V> union(String key, String otherKey)

//返回key与otherKey多个集合的并集
Set<V> union(K key, Collection<K> otherKeys)

//key与otherKey集合并集存入destKey集合中，返回并集元素个数
Long unionAndStore(String key, String otherKey, String destKey)

//key与otherKey多个集合并集存入destKey集合中，返回并集元素个数
Long unionAndStore(K key, Collection<K> otherKeys, K destKey)

12、差集

//返回key与otherKey的差集
Set<V> difference(String key, String otherKey)

//返回key与otherKey多个集合的差集
Set<V> difference(K key, Collection<K> otherKeys)

//key与otherKey集合差集存入destKey集合中，返回差集元素个数
Long differenceAndStore(String key, String otherKey, String destKey)

//key与otherKey多个集合差集存入destKey集合中，返回差集元素个数
Long differenceAndStore(K key, Collection<K> otherKeys, K destKey)

13、遍历集合

//ScanOptions.NONE为显示所有
Cursor<V> scan(K key,ScanOptions options)

Cursor<String> cursor=setOperations.scan(cacheKey,ScanOptions.NONE);
while(cursor.hasNext()){
    Object object = cursor.next();
}

6、Zset 有序集合

1、获取

ZSetOperations<K, V> redisTemplate.opsForZSet();

2、集合大小

Long zCard(K key)

//内部其实是调用zCard
Long size(K key)

3、添加元素

//1个
Boolean add(K key, V value, double score)

//多个，TypedTuple包含value、score属性
Long add(K key, Set<TypedTuple<V>> tuples)

4、移除元素

//返回移除后的集合长度

//根据元素值
Long remove(K key, Object... values)

//根据下标
Long removeRange(K key, long start, long end)

//根据score
Long removeRangeByScore(K key, double min, double max)

5、增加元素的score值

//返回增加后的score值
Double incrementScore(String key, V value, double delta)

6、查询一个元素的score

Double score(K key, Object o)

7、查询一个元素在集合中的排名

//从小到大，从0开始
Long rank(String key, Object o)

//从大到小
Long reverseRank(Stirng key, Object o)

8、统计分数区间数量

//score>=min&&<=max
Long count(K key, double min, double max)

9、获取指定区间的元素

//0 - -1获取该集合的所有元素

//根据下标
//先将集合元素按照score从小到大排列，获取下标 start-end的集合元素值
//返回的集合元素值按照score从小到大排列
Set<V> range(K key, long start, long end)

//先将集合元素按照score从大到小排列，获取下标 start-end的集合元素值
//返回的集合元素值按照score从大到小排列
Set<V> reverseRange(K key, long start, long end)

//先将集合元素按照score从小到大排列，获取下标 start-end的集合元素
//返回的集合元素按照score从小到大排列
Set<TypedTuple<V>> rangeWithScores(K key, long start, long end)

//先将集合元素按照score从大到小排列，获取下标 start-end的集合元素
//返回的集合元素按照score从大到小排列
Set<TypedTuple<V>> reverseRangeWithScores(K key, long start, long end)


//根据分数
//获取score>=min&&<=max的元素值
//返回的集合元素值按照score从小到大排列
Set<V> reverseRangeByScore(K key, double min, double max)
//获取分数>=min&&<=max的元素值
//返回的集合元素值按照score从大到小排列
Set<V> rangeByScore(K key, double min, double max)

//先将集合元素按照score从小到大排列
//获取分数>=min&&<=max的元素值，并且从下标offset开始，获取count个
//返回的集合元素值按照score从小到大排列
Set<V> rangeByScore(K key, double min, double max, long offset, long count)

//先将集合元素按照score从大到小排列
//获取分数>=min&&<=max的元素值，并且从下标offset开始，获取count个
//返回的集合元素值按照score从大到小排列
Set<V> reverseRangeByScore(K key,double min,double max,long offset,
long count)

//获取分数>=min&&<=max的元素
//返回的集合元素按照score从小到大排列
Set<TypedTuple<V>> rangeByScoreWithScores(K key, double min, double max)

//获取分数>=min&&<=max的元素
//返回的集合元素按照score从大到小排列
Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key,double min,
double max)

//先将集合元素按照score从小到大排列
//获取分数>=min&&<=max的元素，并且从下标offset开始，获取count个
//返回的集合元素按照score从小到大排列
Set<TypedTuple<V>> rangeByScoreWithScores(K key, double min, double max, 
long offset, long count)

//先将集合元素按照score从大到小排列
//获取分数>=min&&<=max的元素，并且从下标offset开始，获取count个
//返回的集合元素按照score从大到小排列
Set<TypedTuple<V>> reverseRangeByScoreWithScores(K key, double min, 
double max, long offset, long count)

//根据条件
Set<V> rangeByLex(K key, Range range)
Set<V> rangeByLex(K key, Range range, Limit limit)
//Range  RedisZSetCommands.Range.range().gt(1.2)
//Limit   RedisZSetCommands.Limit.limit().offset(0).count(2)

10、交集

//将key和otherKey的交集存入destKey集合中，返回交集元素个数
Long intersectAndStore(K key, K otherKey, K destKey)

//将key和otherKey集合的交集存入destKey集合中，返回交集元素个数
Long intersectAndStore(K key, Collection<K> otherKeys, K destKey)

11、并集

//key与otherKey集合并集存入destKey集合中，返回并集元素个数
Long unionAndStore(String key, String otherKey, String destKey)

//key与otherKey多个集合并集存入destKey集合中，返回并集元素个数
Long unionAndStore(K key, Collection<K> otherKeys, K destKey)

12、差集

//key与otherKey集合差集存入destKey集合中，返回差集元素个数
Long differenceAndStore(String key, String otherKey, String destKey)

//key与otherKey多个集合差集存入destKey集合中，返回差集元素个数
Long differenceAndStore(K key, Collection<K> otherKeys, K destKey)

13、遍历集合

//ScanOptions.NONE-显示所有
Cursor<String> cursor=setOperations.scan(cacheKey,ScanOptions.NONE);
while(cursor.hasNext()){
    Object object = cursor.next();
}