Redis整合SpringBoot的RedisTemplate实现类(实例详解)
Redis整合SpringBoot》》RedisService接口
packagecom.tuan.common.base.redis;
importjava.util.List;
importjava.util.Map;
importjava.util.Set;
importjava.util.concurrent.TimeUnit;
publicinterfaceRedisService{
//Redis字符串(String)
/**
*模糊值再删除
*@paramkey
*@return
*/
booleandelslike(Stringkey);
/**
*通过键来获取值
*@paramkey
*@returnString
*/
Stringget(Stringkey);
/**
*获取值装成Int类型
*@paramkey
*@return
*/
IntegergetInt(Stringkey);
/**
*删除一个键
*@paramkey
*@return
*/
booleandel(Stringkey);
/**
*key设置value没有失效时间
*@paramkey
*@paramvalue
*/
voidset(Stringkey,Stringvalue);
/**
*key设置value有失效时间
*@paramkey
*@paramvalue
*@paramexpire
*/
voidset(Stringkey,Stringvalue,Integerexpire);
/**
*向key递增1
*@paramkey
*@return
*/
Longincr(Stringkey);
/**
*向key递增1,设置expire失效时间
*@paramkey
*@paramexpire
*@return
*/
Longincr(Stringkey,Integerexpire);
/**
*向key递增delta数值并设置expire失效时间
*@paramkey
*@paramdelta
*@paramexpire
*@return
*/
Longincr(Stringkey,intdelta,Integerexpire);
/**
*向key递减1
*@paramkey
*@return
*/
Longdecr(Stringkey);
/**
*向key递减1,设置expire失效时间
*@paramkey
*@paramexpire
*@return
*/
Longdecr(Stringkey,Integerexpire);
/**
*向key设置expire失效时间
*@paramkey
*@paramexpire
*/
voidexpire(Stringkey,Integerexpire);
/**
*判断key是不存在，设值为1和设置失效时间成功返回true
*判断key是存在，直接返回false
*@paramkey
*@paramexpire
*@return
*/
booleansetnx(Stringkey,Integerexpire);
/**
*判断key是不存在，设值为value和设置失效时间成功返回true
*判断key是存在，直接返回false
*@paramkey
*@paramexpire
*@return
*/
booleansetnxv(Stringkey,Stringvalue,Integerexpire);
/**
*判断键是否存在
*@paramkey
*@return
*/
BooleanhasKey(Stringkey);
//Redis集合(Set)
/**
Redis的Set是String类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
Redis中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
集合中最大的成员数为232-1(4294967295,每个集合可存储40多亿个成员)。
*/
/**
*RedisSadd命令将一个或多个成员元素加入到集合中，已经存在于集合的成员元素将被忽略。
*假如集合key不存在，则创建一个只包含添加的元素作成员的集合。
*当集合key不是集合类型时，返回一个错误。
*注意：在Redis2.4版本以前，SADD只接受单个成员值。
*/
/**
*设置set不重复的值，
*向key插入value值，
*expire为键的失效时间
*@paramkey
*@paramvalue
*@paramexpirenull无时间
*/
voidsadd(Stringkey,Stringvalue,Integerexpire);
/**
*向key键的set删除一个元素memeber
*@paramkey
*@parammemeber
*/
voidsrem(Stringkey,Stringmemeber);
/**
*set中命令判断成员元素是否是集合的成员。
*@paramkey
*@paramvalue
*@return
*/
booleansismember(Stringkey,Stringvalue);
/**
*set取出key所有的数据
*@paramkey
*@return
*/
Setsmembers(Stringkey);
/**
*set中这个key值的数量
*@paramkey
*@return
*/
Longssize(Stringkey);
//Redis列表(List)
/**
Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
一个列表最多可以包含232-1个元素(4294967295,每个列表超过40亿个元素)。
*/
/**
*取得key分页的数据
*@paramkeylist的键
*@paramstart开始下标
*@paramend结束下标
*@return
*/
Listlrange(Stringkey,intstart,intend);
/**
*list取key的下值的数量
*@paramkey
*@return
*/
intllen(Stringkey);
/**
*开始---结尾
*向右添加数据左---→右添加数据
*@paramkeylist键
*@paramvalue添加到list的值
*@paramexpirelist失效时间
*/
voidrpush(Stringkey,Stringvalue,Integerexpire);
/**
*结尾---开始
*向左添加数据右---→左添加数据
*@paramkeylist键
*@paramvalue添加到list的值
*@paramexpirelist失效时间
*/
voidlpush(Stringkey,Stringvalue,Integerexpire);
/**
*list中这个key键下删除count个value值
*@paramkeylist键
*@paramcount删除多少个值
*@paramvaluelist中的值
*/
voidrmpush(Stringkey,Integercount,Stringvalue);
/**
*移出并获取列表的第一个元素(下标为0的元素)
*@paramkeylist键
*@return
*/
Stringlpop(Stringkey);
//Redis有序集合(sortedset)
/**
Redis有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
有序集合的成员是唯一的,但分数(score)却可以重复。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。集合中最大的成员数为232-1(4294967295,每个集合可存储40多亿个成员)。
*/
/**
*RedisZadd命令用于将一个或多个成员元素及其分数值加入到有序集当中。
*如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上。
*分数值可以是整数值或双精度浮点数。
*如果有序集合key不存在，则创建一个空的有序集并执行ZADD操作。
*当key存在但不是有序集类型时，返回一个错误。
*注意：在Redis2.4版本以前，ZADD每次只能添加一个元素。
*/
/**
*@paramkey有序集合key
*@parammember成员元素
*@paramscore成员的分数值
*@return成功与否
*/
booleanzadd(Stringkey,Stringmember,doublescore,Integerexpire);
/**
*RedisZinterstore命令计算给定的一个或多个有序集的交集，其中给定key的数量必须以numkeys参数指定，并将该交集(结果集)储存到destination。
*默认情况下，结果集中某个成员的分数值是所有给定集下该成员分数值之和
*/
longzinterstore(Stringkey,ListotherKeys,StringdestKey,Integerexpire);
/**
*获取有序集合的第一个元素，通过索引区间来实现，而不是通过分数
*@paramkey
*@return
*/
Stringzfirst(Stringkey);
/**
*删除zset中指定的member值
*@paramkey
*@parammember
*@return
*/
booleanzrem(Stringkey,Stringmember);
/**
*zset取出key中所有的数据
*@paramkey
*@return
*/
Mapzscan(Stringkey);
/**
*对key的zset中member进行递增或者递减incrScore值
*@paramkeyzset键
*@parammember目标
*@paramincrScore要改变的数值
*@paramexpire失效时间
*@return
*/
Doublezincrby(Stringkey,Stringmember,doubleincrScore,Integerexpire);
/**
*找到对key的zset中member值（也就是这个member分数）
*@paramkey
*@parammember
*@return
*/
Doublezscore(Stringkey,Stringmember);
//Redis哈希(Hash)
/**
Redishash是一个string类型的field和value的映射表，hash特别适合用于存储对象。
Redis中每个hash可以存储232-1键值对（40多亿）。
*/
/**
*添加hash对象
*hash一般存储对象key标记那个用户
*hashKey用户下的什么信息
*value具体数据
*@paramkeyhash的键
*@paramhashKey目标键
*@paramvalue存储的值
*@paramexpire失效时间
*/
voidhput(Stringkey,StringhashKey,Objectvalue,Integerexpire);
/**
*删除hash对象key键中的hashKey
*@paramkey
*@paramhashKey
*/
voidhdel(Stringkey,StringhashKey);
/**
*获取hash对象key键中的hashKey具体的数据
*@paramkey
*@paramhashKey
*/
Objecthget(Stringkey,StringhashKey);
/**
*获取hash对象key键下有多少个对象数量
*@paramkey
*@return
*/
Longhsize(Stringkey);
/**
*获取hash对象key键下有所有的对象
*@paramkey
*@return
*/
List
Redis整合SpringBoot》》RedisServiceImpl实现
packagecom.tuan.common.base.redis.impl;
importcom.tuan.common.base.redis.RedisService;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.beans.factory.annotation.Value;
importorg.springframework.dao.DataAccessException;
importorg.springframework.data.redis.connection.RedisConnection;
importorg.springframework.data.redis.connection.StringRedisConnection;
importorg.springframework.data.redis.core.*;
importorg.springframework.stereotype.Service;
importorg.springframework.util.CollectionUtils;
importorg.springframework.util.StringUtils;
importjava.util.*;
importjava.util.concurrent.TimeUnit;
importjava.util.stream.Collectors;
@Service
publicclassRedisServiceImplimplementsRedisService{
privatefinalStringKVS_KEY_SPLIT="-";
@Value("${spring.application.name}")
privateStringapplicationName;
@Value("${spring.profiles.active}")
privateStringprofileActive;
@Value("${customize.copyright.name.en}")
privateStringcopyrightEn;
@Autowired
privateStringRedisTemplatestringRedisTemplate;
/**
*stringRedisTemplate.opsForValue();//操作字符串
*stringRedisTemplate.opsForHash();//操作hash
*stringRedisTemplate.opsForList();//操作list
*stringRedisTemplate.opsForSet();//操作set
*stringRedisTemplate.opsForZSet();//操作有序set
*/
/**
*assembleCacheKey所有键的拼接
*@paramkey
*@return
*/
privateStringassembleCacheKey(Stringkey){
if(StringUtils.isEmpty(key)){
returnnull;
}
returncopyrightEn+KVS_KEY_SPLIT+applicationName+KVS_KEY_SPLIT+profileActive+KVS_KEY_SPLIT+key;
}
@Override
publicListgetmultiet(Listkeys){
if(CollectionUtils.isEmpty(keys)){
returnnull;
}
keys=keys.stream().map(key->assembleCacheKey(key)).collect(Collectors.toList());
returnstringRedisTemplate.opsForValue().multiGet(keys);
}
@Override
publicStringget(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
returnstringRedisTemplate.opsForValue().get(key);
}
@Override
publicListlrange(Stringkey,intstart,intend){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
returnstringRedisTemplate.opsForList().range(key,start,end);
}
@Override
publicintllen(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
return0;
}
Longsize=stringRedisTemplate.opsForList().size(key);
returnnull==size?0:size.intValue();
}
@Override
publicIntegergetInt(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
Stringvalue=stringRedisTemplate.opsForValue().get(key);
if(StringUtils.isEmpty(value)){
returnnull;
}
try{
returnInteger.valueOf(value);
}catch(NumberFormatExceptione){
e.printStackTrace();
returnnull;
}
}
@Override
publicbooleandel(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnfalse;
}
try{
Booleandelete=stringRedisTemplate.delete(key);
returnnull!=delete&&delete;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}
@Override
publicbooleandelslike(Stringkey){
key=assembleCacheKey(key);
Setkeys=stringRedisTemplate.keys(key);
if(StringUtils.isEmpty(key)){
returnfalse;
}
try{
Longdelete=stringRedisTemplate.delete(keys);
returndelete>0?true:false;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}
@Override
publicvoidset(Stringkey,Stringvalue){
set(key,value,null);
}
@Override
publicvoidset(Stringkey,Stringvalue,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)||StringUtils.isEmpty(value)){
return;
}
if(null!=expire){
stringRedisTemplate.opsForValue().set(key,value,expire,TimeUnit.SECONDS);
}else{
stringRedisTemplate.opsForValue().set(key,value);
}
}
@Override
publicLongincr(Stringkey){
returnincr(key,1,null);
}
@Override
publicLongincr(Stringkey,Integerexpire){
returnincr(key,1,expire);
}
@Override
publicLongincr(Stringkey,intdelta,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
Longret=stringRedisTemplate.opsForValue().increment(key,delta);
if(null!=expire){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
returnret;
}
@Override
publicLongdecr(Stringkey){
returnincr(key,-1,null);
}
@Override
publicLongdecr(Stringkey,Integerexpire){
returnincr(key,-1,expire);
}
@Override
publicvoidrpush(Stringkey,Stringvalue,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)||StringUtils.isEmpty(value)){
return;
}
stringRedisTemplate.opsForList().rightPush(key,value);
if(null!=expire){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
}
@Override
publicvoidlpush(Stringkey,Stringvalue,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)||StringUtils.isEmpty(value)){
return;
}
stringRedisTemplate.opsForList().leftPush(key,value);
if(null!=expire){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
}
@Override
publicvoidrmpush(Stringkey,Integercount,Stringvalue){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)||StringUtils.isEmpty(value)){
return;
}
stringRedisTemplate.opsForList().remove(key,count,value);
}
@Override
publicStringlpop(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
returnstringRedisTemplate.opsForList().leftPop(key);
}
@Override
publicvoidexpire(Stringkey,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
return;
}
if(null!=expire){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
}
@Override
publicbooleansetnx(Stringkey,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnfalse;
}
Booleanret=stringRedisTemplate.opsForValue().setIfAbsent(key,"1");
if(null==ret||!ret){
returnfalse;
}
if(null!=expire){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
returntrue;
}
@Override
publicbooleansetnxv(Stringkey,Stringvalue,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnfalse;
}
Booleanret=stringRedisTemplate.opsForValue().setIfAbsent(key,value);
if(null==ret||!ret){
returnfalse;
}
if(null!=expire){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
returntrue;
}
@Override
publicBooleanhasKey(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnfalse;
}
Booleanresult=stringRedisTemplate.hasKey(key);
returnnull==result?false:result;
}
@Override
publicvoidsadd(Stringkey,Stringvalue,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)||StringUtils.isEmpty(value)){
return;
}
Longresult=stringRedisTemplate.opsForSet().add(key,value);
if(null!=expire&&null!=result&&result>0){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
}
@Override
publicvoidsrem(Stringkey,Stringmemeber){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)||StringUtils.isEmpty(memeber)){
return;
}
stringRedisTemplate.opsForSet().remove(key,memeber);
}
@Override
publicbooleansismember(Stringkey,Stringvalue){
if(StringUtils.isEmpty(value)){
returnfalse;
}
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnfalse;
}
Booleanresult=stringRedisTemplate.opsForSet().isMember(key,value);
returnnull==result?false:result;
}
@Override
publicSetsmembers(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
returnstringRedisTemplate.opsForSet().members(key);
}
@Override
publicLongssize(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
returnstringRedisTemplate.opsForSet().size(key);
}
@Override
publicbooleanzadd(Stringkey,Stringmember,doublescore,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnfalse;
}
Booleanresult=stringRedisTemplate.opsForZSet().add(key,member,score);
if(null==result||!result){
returnfalse;
}
if(null!=expire){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
returntrue;
}
@Override
publiclongzinterstore(Stringkey,ListotherKeys,StringdestKey,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
return0;
}
destKey=assembleCacheKey(destKey);
if(StringUtils.isEmpty(destKey)){
return0;
}
if(CollectionUtils.isEmpty(otherKeys)){
return0;
}
ListfinalOtherKeys=newArrayList<>();
for(StringeachOtherKey:otherKeys){
finalOtherKeys.add(assembleCacheKey(eachOtherKey));
}
Longresult=stringRedisTemplate.opsForZSet().intersectAndStore(key,finalOtherKeys,destKey);
if(null==result||result<=0){
return0;
}
if(null!=expire){
stringRedisTemplate.expire(destKey,expire,TimeUnit.SECONDS);
}
returnresult;
}
@Override
publicStringzfirst(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
SetstringSet=stringRedisTemplate.opsForZSet().range(key,0,0);
returnCollectionUtils.isEmpty(stringSet)?null:stringSet.toArray()[0].toString();
}
@Override
publicbooleanzrem(Stringkey,Stringmember){
if(StringUtils.isEmpty(member)){
returnfalse;
}
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnfalse;
}
Longresult=stringRedisTemplate.opsForZSet().remove(key,member);
returnnull!=result&&result>0;
}
@Override
publicMapzscan(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
try{
Cursor>tupleCursor=stringRedisTemplate.opsForZSet().scan(key,ScanOptions.scanOptions().build());
Mapresult=newHashMap<>();
while(tupleCursor.hasNext()){
ZSetOperations.TypedTupletuple=tupleCursor.next();
result.put(tuple.getValue(),tuple.getScore());
}
returnresult;
}catch(Exceptione){
e.printStackTrace();
returnnull;
}
}
@Override
publicDoublezincrby(Stringkey,Stringmember,doubleincrScore,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
Doublescore=stringRedisTemplate.opsForZSet().incrementScore(key,member,incrScore);
if(null!=expire&&expire>0){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
returnscore;
}
@Override
publicDoublezscore(Stringkey,Stringmember){
if(StringUtils.isEmpty(member)){
returnnull;
}
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
returnstringRedisTemplate.opsForZSet().score(key,member);
}
@Override
publicvoidhput(Stringkey,StringhashKey,Objectvalue,Integerexpire){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
return;
}
stringRedisTemplate.opsForHash().put(key,hashKey,value);
if(null!=expire&&expire>0){
stringRedisTemplate.expire(key,expire,TimeUnit.SECONDS);
}
}
@Override
publicvoidhdel(Stringkey,StringhashKey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
return;
}
stringRedisTemplate.opsForHash().delete(key,hashKey);
}
@Override
publicObjecthget(Stringkey,StringhashKey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
returnstringRedisTemplate.opsForHash().get(key,hashKey);
}
@Override
publicLonghsize(Stringkey){
key=assembleCacheKey(key);
if(StringUtils.isEmpty(key)){
returnnull;
}
returnstringRedisTemplate.opsForHash().size(key);
}
@Override
publicList
到此这篇关于Redis整合SpringBoot的RedisTemplate实现类的文章就介绍到这了,更多相关Redis整合SpringBoot实现类内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！